getpos(), line(), and col()

Author: J-Fields

src/cmd_line/commands/echo.ts

@@ -29,7 +29,7 @@ export class EchoCommand extends ExCommand {
   }
 
   public async execute(vimState: VimState): Promise<void> {
-    const ctx = new EvaluationContext();
+    const ctx = new EvaluationContext(vimState);
     const values = this.expressions.map((x) => ctx.evaluate(x));
     const message = values.map((v) => displayValue(v)).join(this.sep);
     StatusBar.setText(vimState, message, this.error);

src/cmd_line/commands/eval.ts

@@ -17,7 +17,7 @@ export class EvalCommand extends ExCommand {
   }
 
   public async execute(vimState: VimState): Promise<void> {
-    const ctx = new EvaluationContext();
+    const ctx = new EvaluationContext(vimState);
     ctx.evaluate(this.expression);
   }
 }
@@ -34,7 +34,7 @@ export class CallCommand extends ExCommand {
   }
 
   public async execute(vimState: VimState): Promise<void> {
-    const ctx = new EvaluationContext();
+    const ctx = new EvaluationContext(vimState);
     ctx.evaluate(this.expression);
   }
 }

src/cmd_line/commands/let.ts

@@ -154,7 +154,7 @@ export class LetCommand extends ExCommand {
   }
 
   async execute(vimState: VimState): Promise<void> {
-    const context = new EvaluationContext();
+    const context = new EvaluationContext(vimState);
     if (this.args.operation === 'print') {
       if (this.args.variables.length === 0) {
         // TODO
@@ -306,7 +306,7 @@ export class UnletCommand extends ExCommand {
   }
 
   async execute(vimState: VimState): Promise<void> {
-    const ctx = new EvaluationContext();
+    const ctx = new EvaluationContext(vimState);
     for (const variable of this.variables) {
       const store = ctx.getVariableStore(variable.namespace);
       const existed = store?.delete(variable.name);

src/cmd_line/commands/put.ts

@@ -67,7 +67,7 @@ export class PutExCommand extends ExCommand {
 
       this.arguments.register = '=';
 
-      const value = new EvaluationContext().evaluate(this.arguments.fromExpression);
+      const value = new EvaluationContext(vimState).evaluate(this.arguments.fromExpression);
       const stringified =
         value.type === 'list' ? value.items.map(toString).join('\n') : toString(value);
       Register.overwriteRegister(vimState, this.arguments.register, stringified, 0);

src/vimscript/expression/evaluate.ts

@@ -32,7 +32,9 @@ import {
 } from './types';
 import { Pattern, SearchDirection } from '../pattern';
 import { escapeRegExp, isInteger } from 'lodash';
-import { integerParser } from '../parserUtils';
+import { VimState } from '../../state/vimState';
+import { Position } from 'vscode';
+import { isVisualMode } from '../../mode/mode';
 
 // ID of next lambda; incremented each time one is created
 let lambdaNumber = 1;
@@ -146,9 +148,14 @@ export type VariableStore = Map<string, Variable>;
 export class EvaluationContext {
   private static globalVariables: VariableStore = new Map();
 
+  private vimState: VimState | undefined;
   private localScopes: VariableStore[] = [];
   private errors: string[] = [];
 
+  constructor(vimState: VimState | undefined) {
+    this.vimState = vimState;
+  }
+
   /**
    * Fully evaluates the given expression and returns the resulting value.
    * May throw a variety of VimErrors if the expression is semantically invalid.
@@ -677,6 +684,33 @@ export class EvaluationContext {
       this.errors.push(msg);
       return int(1);
     };
+
+    const getpos = (arg: string) => {
+      const pos: Position | undefined = (() => {
+        if (arg === '.') {
+          return this.vimState!.cursorStopPosition;
+        } else if (arg === '$') {
+          return new Position(this.vimState!.document.lineCount, 0);
+        } else if (arg.startsWith("'") && arg.length === 2) {
+          const mark = this.vimState!.historyTracker.getMark(arg[1]);
+          return mark?.position;
+        } else if (arg === 'w0') {
+          return new Position(this.vimState!.editor.visibleRanges[0].start.line, 0);
+        } else if (arg === 'w$') {
+          return new Position(this.vimState!.editor.visibleRanges[0].end.line, 0);
+        } else if (arg === 'v') {
+          return this.vimState!.cursorStartPosition;
+        }
+        return undefined;
+      })();
+      return {
+        bufnum: 0, // TODO
+        lnum: (pos?.line ?? -1) + 1,
+        col: (pos?.character ?? -1) + 1,
+        off: 0,
+      };
+    };
+
     const getArgs = (min: number, max?: number) => {
       if (max === undefined) {
         max = min;
@@ -830,6 +864,10 @@ export class EvaluationContext {
         const [x] = getArgs(1);
         return float(Math.ceil(toFloat(x!)));
       }
+      case 'col': {
+        const [s] = getArgs(1);
+        return int(getpos(toString(s!)).col);
+      }
       case 'copy': {
         const [x] = getArgs(1);
         switch (x?.type) {
@@ -891,6 +929,7 @@ export class EvaluationContext {
         }
         return int(count);
       }
+      // TODO: cursor()
       case 'deepcopy': {
         // TODO: real deep copy once references are implemented
         const [x] = getArgs(1);
@@ -1028,6 +1067,11 @@ export class EvaluationContext {
       }
       // TODO: getcurpos()
       // TODO: getline()
+      case 'getpos': {
+        const [s] = getArgs(1);
+        const { bufnum, lnum, col, off } = getpos(toString(s!));
+        return list([int(bufnum), int(lnum), int(col), int(off)]);
+      }
       // TODO: getreg()
       // TODO: getreginfo()
       // TODO: getregtype()
@@ -1199,6 +1243,10 @@ export class EvaluationContext {
             throw VimError.fromCode(ErrorCode.InvalidTypeForLen);
         }
       }
+      case 'line': {
+        const [s, winid] = getArgs(1, 2);
+        return int(getpos(toString(s!)).lnum);
+      }
       case 'localtime': {
         return int(Date.now() / 1000);
       }
@@ -1354,6 +1402,7 @@ export class EvaluationContext {
         // Halfway between integers, Math.round() rounds toward infinity while Vim's round() rounds away from 0.
         return float(_x < 0 ? -Math.round(-_x) : Math.round(_x));
       }
+      // TODO: setpos()
       // TODO: setreg()
       case 'sin': {
         const [x] = getArgs(1);
@@ -1476,6 +1525,7 @@ export class EvaluationContext {
         const [x] = getArgs(1);
         return float(Math.tanh(toFloat(x!)));
       }
+      // TODO: timer*()
       case 'tolower': {
         const [s] = getArgs(1);
         return str(toString(s!).toLowerCase());

test/vimscript/expression.test.ts

@@ -32,15 +32,15 @@ function exprTest(
         assert.deepStrictEqual(expression, asserts.expr);
       }
       if ('error' in asserts) {
-        const ctx = new EvaluationContext();
+        const ctx = new EvaluationContext(undefined);
         ctx.evaluate(expression);
       } else {
         if (asserts.value !== undefined) {
-          const ctx = new EvaluationContext();
+          const ctx = new EvaluationContext(undefined);
           assert.deepStrictEqual(ctx.evaluate(expression), asserts.value);
         }
         if (asserts.display !== undefined) {
-          const ctx = new EvaluationContext();
+          const ctx = new EvaluationContext(undefined);
           assert.deepStrictEqual(displayValue(ctx.evaluate(expression)), asserts.display);
         }
       }