added elif (#3 and #21)

Author: ppaska

index.html

@@ -29,7 +29,12 @@
   <div class="container">
     <h4>JSPython development console</h4>
     <div id="editor">
-"1,2,3".split(',')[0]
+a = 33
+b = 33
+if b > a:
+  print("b is greater than a")
+elif a == b:
+  print("a and b are equal")
     </div>
 
     <button onclick="tokenize()">Tokenize</button>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "jspython-interpreter",
-  "version": "2.1.11",
+  "version": "2.1.12",
   "description": "JSPython is a javascript implementation of Python language that runs within web browser or NodeJS environment",
   "keywords": [
     "python",

src/common/ast-types.ts

@@ -16,6 +16,7 @@ export type AstNodeType =
   | 'createObject'
   | 'createArray'
   | 'if'
+  | 'elif'
   | 'for'
   | 'while'
   | 'tryExcept'
@@ -142,12 +143,24 @@ export class ArrowFuncDefNode extends AstNode implements FuncDefNode {
   }
 }
 
+export class ElifNode extends AstNode {
+  constructor(
+    public conditionNode: AstNode,
+    public elifBody: AstNode[],
+    public loc: Uint16Array
+  ) {
+    super('elif');
+    this.loc = loc;
+  }
+}
+
 export class IfNode extends AstNode {
   constructor(
     public conditionNode: AstNode,
     public ifBody: AstNode[],
+    public elifs: ElifNode[] | undefined = undefined,
     public elseBody: AstNode[] | undefined = undefined,
-    public loc: Uint16Array
+    public loc: Uint16Array,
   ) {
     super('if');
     this.loc = loc;
@@ -243,7 +256,6 @@ export class ChainingObjectAccessNode extends AstNode {
   }
 }
 
-
 export interface LogicalNodeItem {
   node: AstNode;
   op: LogicalOperators | undefined;

src/evaluator/evaluator.ts

@@ -4,7 +4,7 @@ import {
   AstBlock,
   AstNode,
   BinOpNode,
-    ChainingCallsNode,
+  ChainingCallsNode,
   ChainingObjectAccessNode,
   ConstNode,
   CreateArrayNode,
@@ -139,12 +139,29 @@ export class Evaluator {
 
     if (node.type === 'if') {
       const ifNode = node as IfNode;
+      let doElse = true;
       if (this.evalNode(ifNode.conditionNode, blockContext)) {
         this.evalBlock(
           { name: blockContext.moduleName, type: 'if', body: ifNode.ifBody } as AstBlock,
           blockContext
         );
-      } else if (ifNode.elseBody) {
+        doElse = false;
+      } else if (ifNode.elifs?.length) {
+        for (let i = 0; i < ifNode.elifs.length; i++) {
+          const elIfNode = ifNode.elifs[i];
+
+          if (this.evalNode(elIfNode.conditionNode, blockContext)) {
+            this.evalBlock(
+              { name: blockContext.moduleName, type: 'if', body: elIfNode.elifBody } as AstBlock,
+              blockContext
+            );
+            doElse = false;
+            break;
+          }
+        }
+      }
+      
+      if (doElse && ifNode.elseBody) {
         this.evalBlock(
           { name: blockContext.moduleName, type: 'if', body: ifNode.elseBody } as AstBlock,
           blockContext
@@ -369,10 +386,7 @@ export class Evaluator {
 
       if (assignNode.target.type === 'getSingleVar') {
         const node = assignNode.target as SetSingleVarNode;
-        blockContext.blockScope.set(
-          node.name,
-          this.evalNode(assignNode.source, blockContext)
-        );
+        blockContext.blockScope.set(node.name, this.evalNode(assignNode.source, blockContext));
       } else if (assignNode.target.type === 'chainingCalls') {
         const targetNode = assignNode.target as ChainingCallsNode;
 
@@ -382,7 +396,7 @@ export class Evaluator {
           targetNode.innerNodes.slice(0, targetNode.innerNodes.length - 1),
           targetNode.loc
         );
-        const targetObject = (this.evalNode(targetObjectNode, blockContext)) as Record<
+        const targetObject = this.evalNode(targetObjectNode, blockContext) as Record<
           string,
           unknown
         >;
@@ -393,10 +407,10 @@ export class Evaluator {
         if (lastInnerNode.type === 'getSingleVar') {
           lastPropertyName = (lastInnerNode as GetSingleVarNode).name;
         } else if (lastInnerNode.type === 'chainingObjectAccess') {
-          lastPropertyName = (this.evalNode(
+          lastPropertyName = this.evalNode(
             (lastInnerNode as ChainingObjectAccessNode).indexerBody,
             blockContext
-          )) as string;
+          ) as string;
         } else {
           throw Error('Not implemented Assign operation with chaining calls');
         }
@@ -411,7 +425,6 @@ export class Evaluator {
       return this.resolveChainingCallsNode(node as ChainingCallsNode, blockContext);
     }
 
-
     if (node.type === 'createObject') {
       const createObjectNode = node as CreateObjectNode;
       const obj = {} as Record<string, unknown>;
@@ -435,12 +448,9 @@ export class Evaluator {
     }
   }
 
-  private resolveChainingCallsNode(
-    chNode: ChainingCallsNode,
-    blockContext: BlockContext
-  ): unknown {
+  private resolveChainingCallsNode(chNode: ChainingCallsNode, blockContext: BlockContext): unknown {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let startObject = (this.evalNode(chNode.innerNodes[0], blockContext)) as any;
+    let startObject = this.evalNode(chNode.innerNodes[0], blockContext) as any;
 
     for (let i = 1; i < chNode.innerNodes.length; i++) {
       const nestedProp = chNode.innerNodes[i];
@@ -455,7 +465,7 @@ export class Evaluator {
         const node = nestedProp as ChainingObjectAccessNode;
         // startObject = startObject[node.] as unknown;
         startObject = startObject[
-          (this.evalNode(node.indexerBody, blockContext)) as string
+          this.evalNode(node.indexerBody, blockContext) as string
         ] as unknown;
       } else if (nestedProp.type === 'funcCall') {
         const funcCallNode = nestedProp as FunctionCallNode;
@@ -489,5 +499,4 @@ export class Evaluator {
 
     return startObject === undefined ? null : startObject;
   }
-
 }

src/evaluator/evaluatorAsync.ts

@@ -238,12 +238,30 @@ export class EvaluatorAsync {
 
     if (node.type === 'if') {
       const ifNode = node as IfNode;
+      let doElse = true;
+
       if (await this.evalNodeAsync(ifNode.conditionNode, blockContext)) {
         await this.evalBlockAsync(
           { name: blockContext.moduleName, type: 'if', body: ifNode.ifBody } as AstBlock,
           blockContext
         );
-      } else if (ifNode.elseBody) {
+        doElse = false;
+      } else if (ifNode.elifs?.length) {
+        for (let i = 0; i < ifNode.elifs.length; i++) {
+          const elIfNode = ifNode.elifs[i];
+
+          if (await this.evalNodeAsync(elIfNode.conditionNode, blockContext)) {
+            await this.evalBlockAsync(
+              { name: blockContext.moduleName, type: 'if', body: elIfNode.elifBody } as AstBlock,
+              blockContext
+            );
+            doElse = false;
+            break;
+          }
+        }
+      }
+
+      if (doElse && ifNode.elseBody) {
         await this.evalBlockAsync(
           { name: blockContext.moduleName, type: 'if', body: ifNode.elseBody } as AstBlock,
           blockContext

src/interpreter.spec.ts

@@ -909,5 +909,77 @@ describe('Interpreter', () => {
     expect(interpreter.eval('"\\"12\\"34\\""')).toBe('"12"34"');
   });
 
+  it('- elif 1', async () => {
+    const interpreter = Interpreter.create();
+
+    const script = `
+    x = 5
+    if x == 6:
+      x = 20
+    elif x == 5:
+      x = 10
+    else:
+      x = 30
+
+    return x
+    `;
+    expect(await interpreter.evalAsync(script)).toBe(10);
+    expect(interpreter.eval(script)).toBe(10);
+  });
+
+  it('- elif 2', async () => {
+    const interpreter = Interpreter.create();
+
+    const script = `
+    x = 6
+    if x == 6:
+      x = 20
+    elif x == 5:
+      x = 10
+    else:
+      x = 30
+
+    return x
+    `;
+    expect(await interpreter.evalAsync(script)).toBe(20);
+    expect(interpreter.eval(script)).toBe(20);
+  });
+
+  it('- elif 3', async () => {
+    const interpreter = Interpreter.create();
+
+    const script = `
+    x = 11
+    if x == 6:
+      x = 20
+    elif x == 5:
+      x = 10
+    else:
+      x = 30
+    return x
+    `;
+    expect(await interpreter.evalAsync(script)).toBe(30);
+    expect(interpreter.eval(script)).toBe(30);
+  });
+
+  it('- elif 4', async () => {
+    const interpreter = Interpreter.create();
+
+    const script = `
+    x = 11
+    if x == 6:
+      x = 20
+    elif x == 11:
+      x = 11
+    elif x == 5:
+      x = 10
+    else:
+      x = 30
+    return x
+    `;
+    expect(await interpreter.evalAsync(script)).toBe(11);
+    expect(interpreter.eval(script)).toBe(11);
+  });  
+
   //
 });

src/parser/parser.ts

@@ -46,7 +46,8 @@ import {
   findChainingCallTokensIndexes,
   splitTokensByIndexes,
   ChainingCallsNode,
-  ChainingObjectAccessNode
+  ChainingObjectAccessNode,
+  ElifNode
 } from '../common';
 import { JspyParserError } from '../common/utils';
 
@@ -197,6 +198,31 @@ export class Parser {
           ? this.groupLogicalOperations(logicOpIndexes, conditionTokens)
           : this.createExpressionNode(conditionTokens);
 
+        // elifs
+        const elifNodes: ElifNode[] = [];
+        while (
+          instructions.length > i + 1 &&
+          getTokenValue(instructions[i + 1].tokens[0]) === 'elif'
+        ) {
+
+          const elifInstruction = instructions[++i];
+
+          const endOfElif = findTokenValueIndex(elifInstruction.tokens, v => v === ':');
+
+          const conditionTokens = elifInstruction.tokens.slice(1, endDefOfDef);
+
+          const elifConditionNode = findIndexes(conditionTokens, OperationTypes.Logical, logicOpIndexes)
+            ? this.groupLogicalOperations(logicOpIndexes, conditionTokens)
+            : this.createExpressionNode(conditionTokens);
+  
+          const elifBody = getBody(elifInstruction.tokens, endOfElif+1);
+          elifNodes.push(
+            new ElifNode(elifConditionNode, elifBody, getTokenLoc(elifInstruction.tokens[0]))
+          );
+          
+        }
+
+        // else
         let elseBody: AstNode[] | undefined = undefined;
         if (
           instructions.length > i + 1 &&
@@ -207,7 +233,9 @@ export class Parser {
           i++;
         }
 
-        ast.body.push(new IfNode(conditionNode, ifBody, elseBody, getTokenLoc(firstToken)));
+        ast.body.push(
+          new IfNode(conditionNode, ifBody, elifNodes, elseBody, getTokenLoc(firstToken))
+        );
       } else if (getTokenValue(firstToken) === 'try') {
         if (getTokenValue(instruction.tokens[1]) !== ':') {
           throw `'try' statement should be followed by ':'`;