@trebco/treb 31.9.1 → 32.3.1

package/treb-parser/src/parser.ts

@@ -411,6 +411,13 @@ export class Parser {
         }
         break;
 
+      case 'implicit-call':
+        if (func(unit)) {
+          unit.call = this.Walk2(unit.call, func);
+          unit.args = unit.args.map(source => this.Walk2(source, func));
+        }
+        break;
+
       case 'call':
         if (func(unit)) {
           unit.args = unit.args.map(source => this.Walk2(source, func));
@@ -477,6 +484,15 @@ export class Parser {
         }
         return;
 
+      case 'implicit-call':
+        if (func(unit)) {
+          this.Walk(unit.call, func);          
+          for (const arg of unit.args) {
+            this.Walk(arg, func);
+          }
+        }
+        return;
+
       case 'call':
         if (func(unit)) {
           for (const arg of unit.args) {
@@ -586,14 +602,15 @@ export class Parser {
         if (options.pass_through_addresses) { 
           return unit.label;
         }
-        return options.r1c1 ? this.R1C1Label(unit, options.r1c1_base) : this.AddressLabel(unit, offset);
+        return options.r1c1 ? this.R1C1Label(unit, options.r1c1_base, options.r1c1_force_relative) : this.AddressLabel(unit, offset);
 
       case 'range':
         if (options.pass_through_addresses) { 
           return unit.label;
         }
         return options.r1c1 ? 
-          this.R1C1Label(unit.start, options.r1c1_base) + ':' + this.R1C1Label(unit.end, options.r1c1_base) : 
+          this.R1C1Label(unit.start, options.r1c1_base, options.r1c1_force_relative) + ':' + 
+            this.R1C1Label(unit.end, options.r1c1_base, options.r1c1_force_relative) : 
           this.AddressLabel(unit.start, offset) + ':' + this.AddressLabel(unit.end, offset);
 
       case 'missing':
@@ -755,6 +772,10 @@ export class Parser {
             .map((x) => this.Render(x, options)).join(separator);
         }
 
+      case 'implicit-call':
+        return this.Render(unit.call, options) + 
+          '(' + unit.args.map(element => this.Render(element, options)).join(separator) + ')';
+
       case 'call':
         return (
           unit.name +
@@ -935,10 +956,14 @@ export class Parser {
 
   /**
    * generates absolute or relative R1C1 address
+   * 
+   * FIXME: not supporting relative (offset) addresses atm? I'd like to
+   * change this but I don't want to break anything...
    */
   protected R1C1Label(
     address: UnitAddress,
     base?: UnitAddress,
+    force_relative = false,
   ): string {
 
     let label = '';
@@ -948,8 +973,30 @@ export class Parser {
         '\'' + address.sheet + '\'' : address.sheet) + '!';
     }
 
+    let row = '';
+    let column = '';
+
+    if (force_relative && base) { 
+      const delta_row = address.row - base.row;
+      const delta_column = address.column - base.column;
+
+      if (delta_row) {
+        row = `[${delta_row}]`;
+      }
+      if (delta_column) {
+        column = `[${delta_column}]`;
+      }
+
+    }
+    else {
+      row = address.offset_row ? `[${address.row}]` : (address.row + 1).toString();
+      column = address.offset_column ? `[${address.column}]` : (address.column + 1).toString();
+    }
+
+    /*    
     const row = (address.absolute_row || !base) ? (address.row + 1).toString() : `[${address.row - base.row}]`;
     const column = (address.absolute_column || !base) ? (address.column + 1).toString() : `[${address.column - base.column}]`;
+    */
 
     label += `R${row}C${column}`;
 
@@ -1009,11 +1056,12 @@ export class Parser {
    *
    * @param exit exit on specific characters
    */
-  protected ParseGeneric(exit: number[] = [0]): ExpressionUnit | null {
+  protected ParseGeneric(exit: number[] = [0], explicit_group = false): ExpressionUnit | null {
     let stream: ExpressionUnit[] = [];
 
     for (; this.index < this.length;) {
       const unit = this.ParseNext(stream.length === 0);
+
       if (typeof unit === 'number') {
 
         if (exit.some((test) => unit === test)) {
@@ -1025,8 +1073,11 @@ export class Parser {
           // so we only have to worry about grouping. parse
           // up to the closing paren...
 
+          // actually now we have implicit calls, so we need
+          // to manage that here. 
+
           this.index++; // open paren
-          const group = this.ParseGeneric([CLOSE_PAREN]);
+          const group = this.ParseGeneric([CLOSE_PAREN], true);
           this.index++; // close paren
 
           // and wrap up in a group element to prevent reordering.
@@ -1034,14 +1085,18 @@ export class Parser {
 
           // skip nulls
 
-          if (group) {
+          // ...don't skip nulls? don't know what the rationale was
+          // but for implicit calls we will need to support empty arguments 
+
+          // if (group) {
             stream.push({
               type: 'group',
               id: this.id_counter++,
-              elements: [group],
+              elements: group? [group] : [],
               explicit: true,
             });
-          }
+          //}
+
         }
         else {
           // this can probably move to PNext? except for the test
@@ -1051,6 +1106,21 @@ export class Parser {
           if (operator) {
             stream.push(operator);
           }
+          else if (explicit_group && unit === this.argument_separator_char) {
+
+            // adding a new unit type here to explicitly show we're in
+            // a group; prevents later passes from treating arguments as 
+            // fractions or something else. we just need to remove these
+            // later
+
+            stream.push({
+              type: 'group-separator',
+              position: this.index,
+              id: this.id_counter++,
+            });
+
+            this.index++;
+          }
           else {
             this.error = `unexpected character [1]: ${String.fromCharCode(unit)}, 0x${unit.toString(16)}`;
             this.valid = false;
@@ -1231,13 +1301,6 @@ export class Parser {
     // fix ordering of binary operations based on precedence; also
     // convert and validate ranges
 
-    // return this.BinaryToRange(this.ArrangeUnits(stream));
-    // return this.ArrangeUnits(stream);
-
-    // const arranged = this.ArrangeUnits(stream);
-    // const result = this.BinaryToComplex(arranged);
-    // return result;
-
     return this.BinaryToComplex(this.ArrangeUnits(stream));
 
   }
@@ -1612,206 +1675,13 @@ export class Parser {
 
 
   /**
-   * converts binary operations with a colon operator to ranges. this also
-   * validates that there are no colon operations with non-address operands
-   * (which is why it's called after precendence reordering; colon has the
-   * highest preference). recursive only over binary ops AND unary ops.
-   * 
-   * NOTE: there are other legal arguments to a colon operator. specifically:
-   * 
-   * (1) two numbers, in either order
-   *
-   * 15:16
-   * 16:16
-   * 16:15
-   *
-   * (2) with one or both optionally having a $
-   *
-   * 15:$16
-   * $16:$16
-   *
-   * (3) two column identifiers, in either order
-   * 
-   * A:F
-   * B:A
-   *
-   * (4) and the same with $
-   *
-   * $A:F
-   * $A:$F
+   * reorders operations for precendence
    * 
-   * because none of these are legal in any other context, we leave the 
-   * default treatment of them UNLESS they are arguments to the colon 
-   * operator, in which case we will grab them. that does mean we parse
-   * them twice, but (...)
+   * this method was written with the assumption that groups were
+   * always an error. that's no longer true, with implicit calls.
+   * we should still error if it's not an _explicit_ group, i.e. there's
+   * just a bunch of naked tokens.
    * 
-   * FIXME: will need some updated to rendering these, we don't have any
-   * handler for rendering infinity
-   */
-  protected BinaryToRangeX(unit: ExpressionUnit): ExpressionUnit {
-    if (unit.type === 'binary') {
-      if (unit.operator === ':') {
-
-        let range: UnitRange|undefined;
-        let label = '';
-
-        if (unit.left.type === 'address' && unit.right.type === 'address') {
-          // construct a label using the full text. there's a possibility,
-          // I suppose, that there are spaces (this should probably not be
-          // legal). this is a canonical label, though (generated)
-
-          // it might be better to let this slip, or treat it as an error
-          // and force a correction... not sure (TODO/FIXME)
-
-          const start_index = unit.left.position + unit.left.label.length;
-          const end_index = unit.right.position;
-
-          range = {
-            type: 'range',
-            id: this.id_counter++,
-            position: unit.left.position,
-            start: unit.left,
-            end: unit.right,
-            label:
-              unit.left.label +
-              this.expression.substring(start_index, end_index) +
-              unit.right.label,
-          };
-
-          label = range.start.label + ':' + range.end.label;
-
-          this.address_refcount[range.start.label]--;
-          this.address_refcount[range.end.label]--;
-
-          // remove entries from the list for start, stop
-          const positions = [unit.left.position, unit.right.position];
-          this.full_reference_list = this.full_reference_list.filter((test) => {
-            return (
-              test.position !== positions[0] && test.position !== positions[1]
-            );
-          });
-
-        }
-        else if ((unit.left.type === 'literal' || unit.left.type === 'identifier')
-                && (unit.right.type === 'literal' || unit.right.type === 'identifier')) {
-
-          // see if we can plausibly interpret both of these as rows or columns
-
-          const left = this.UnitToAddress(unit.left);
-          const right = this.UnitToAddress(unit.right);
-
-          // and they need to match
-
-          if (left && right
-              && ((left.column === Infinity && right.column === Infinity)
-                  || (left.row === Infinity && right.row === Infinity))) {
-
-            label = left.label + ':' + right.label;
-
-            // we don't support out-of-order ranges, so we should correct.
-            // they just won't work otherwise. (TODO/FIXME)
-           
-            range = {
-              type: 'range',
-              id: this.id_counter++,
-              position: unit.left.position,
-              start: left,
-              end: right,
-              label,
-            };
-
-          }
-                    
-        }
-
-        /*
-        else if ( unit.left.type === 'literal' 
-                  && unit.right.type === 'literal' 
-                  && typeof unit.left.value === 'number' 
-                  && typeof unit.right.value === 'number') {
-
-          // technically we don't want to support any number that has
-          // a decimal place, but I'm not sure we have a useful way of
-          // measuring that... could look at the original text?
-
-          if (unit.left.value > 0 
-              && unit.right.value > 0
-              && !/\./.test(unit.left.text||'')
-              && !/\./.test(unit.right.text||'')
-              ) {
-
-            label = unit.left.value.toString() + ':' + unit.right.value.toString();
-
-            console.info('m2:', label);
-
-            const left: UnitAddress = {
-              type: 'address',
-              position: unit.left.position,
-              label: unit.left.value.toString(),
-              row: unit.left.value - 1,
-              id: this.id_counter++,
-              column: Infinity,
-            };
-
-            const right: UnitAddress = {
-              type: 'address',
-              position: unit.right.position,
-              label: unit.right.value.toString(),
-              row: unit.right.value - 1,
-              id: this.id_counter++,
-              column: Infinity,
-            };
-
-            range = {
-              type: 'range',
-              id: this.id_counter++,
-              position: unit.left.position,
-              start: left,
-              end: right,
-              label,
-            };
-
-          }
-          
-        }
-        */
-
-        if (range) {
-
-          this.dependencies.ranges[label] = range;
-
-          // and add the range
-          this.full_reference_list.push(range);
-
-          return range;
-
-        }
-        else {
-          this.error = `unexpected character: :`;
-          this.valid = false;
-          // console.info('xx', unit);
-        }
-
-      }
-
-      // recurse
-
-      unit.left = this.BinaryToRangeX(unit.left);
-      unit.right = this.BinaryToRangeX(unit.right);
-    }
-
-    // this should no longer be required, because we explicitly check
-    // when we construct the unary operations...
-
-    // else if (unit.type === 'unary') {
-    //   unit.operand = this.BinaryToRange(unit.operand);
-    // }
-
-    return unit;
-  }
-
-  /**
-   * reorders operations for precendence
    */
   protected ArrangeUnits(stream: ExpressionUnit[]): ExpressionUnit {
 
@@ -1838,6 +1708,10 @@ export class Parser {
     for (let index = 0; index < stream.length; index++) {
       let element = stream[index];
 
+      if (element.type === 'group-separator') {
+        continue; // drop 
+      }
+
       // given that we need to support unary operators, the logic needs
       // to be a little different. operators are OK at any position, provided
       // we can construct either a unary or binary operation.
@@ -1848,14 +1722,7 @@ export class Parser {
           // in this case we do it with recursion.
 
           if (unary_operators[element.operator]) {
-
-            // MARK X
-
-            // const right = this.BinaryToRange(
-            //  this.ArrangeUnits(stream.slice(index + 1)),
-            //);
-
-            // const right = this.ArrangeUnits(stream.slice(index + 1));
+            
             const right = this.BinaryToComplex(this.ArrangeUnits(stream.slice(index + 1)));
 
             // this ensures we return the highest-level group, even if we recurse
@@ -1932,7 +1799,35 @@ export class Parser {
         if (stack.length === 1) {
           const a = stack[0].type;
 
-          if (a !== 'operator') {
+          // support for lambdas
+
+          if (element.type === 'group' && element.explicit) {
+            if (a === 'address' || a === 'call' || a === 'identifier' || a === 'implicit-call') {
+
+              // our parser seems to create implicit groups from these
+              // values in parens. we should fix that, but we can unpack it.
+
+              let args = element.elements;
+              if (args.length === 1 && args[0].type === 'group' && !args[0].explicit) {
+                args = args[0].elements;
+              }
+              
+              // create an implicit call. replace on the stack.
+
+              stack[0] = {
+                type: 'implicit-call',
+                call: stack[0],
+                args,
+                id: this.id_counter++,
+                position: stack[0].position,
+              };
+
+              continue;
+
+            }
+          }
+          /*
+          else if (a !== 'operator') {
 
             // console.warn("unexpected element", stack[0], element);
 
@@ -1947,6 +1842,7 @@ export class Parser {
             };
 
           }
+          */
 
         }
         
@@ -1996,6 +1892,8 @@ export class Parser {
         stack.splice(-2, 2, operation);
       }
       else {
+
+        /*
         this.error = `multiple expressions`;
         this.error_position = (element as {position?: number}).position;
         this.valid = false;
@@ -2005,9 +1903,22 @@ export class Parser {
           elements: stream,
           explicit: false,
         };
+        */
+
+        stack.push(element);
+
       }
     }
 
+    if (stack.length > 1) {
+      return {
+        type: 'group',
+        id: this.id_counter++,
+        elements: stack,
+        explicit: false,
+      };
+    }
+
     return stack[0];
   }
 
@@ -2385,6 +2296,20 @@ export class Parser {
 
     this.ConsumeWhiteSpace();
 
+    // UPDATE: UNLESS the token is an address, because that's not
+    // a legal function name. so change that precedence rule, address
+    // comes first.
+
+    // erm -- that's not 100% correct. LOG10 is a valid cell address
+    // and a valid function name. there might be others as well.
+
+    if (this.flags.spreadsheet_semantics) {
+      const address = this.ConsumeAddress(str, position);
+      if (address) return address;
+    }
+
+    // [FIXME: what about braces? (...)]
+
     const next_char = this.data[this.index];
     if (next_char === OPEN_PAREN) {
       const args = this.ConsumeArguments();
@@ -2404,8 +2329,9 @@ export class Parser {
       // range operator, and a second address. that will be turned into a range
       // later.
 
-      const address = this.ConsumeAddress(str, position);
-      if (address) return address;
+      // moved up
+      // const address = this.ConsumeAddress(str, position);
+      // if (address) return address;
 
       // check for structured reference, if we had square brackets
 
@@ -2638,6 +2564,14 @@ export class Parser {
     if (!r) return null; 
     position = r.position;
 
+    // special hack for LOG10. ugh. can't find any other functions with
+    // this problem, in english at least. btw what's the translation for
+    // log10?
+
+    if (c.column === 8508 && r.row === 9) {
+      return null;
+    }
+
     const label = sheet ?
       sheet + token.substr(sheet.length, position - index).toUpperCase() :
       token.substr(0, position - index).toUpperCase();