final version

Author: ArekX

.gitignore

@@ -1 +1,2 @@
 .DS_Store
+full

grammar.js

@@ -0,0 +1,178 @@
+const { rule, either, exactly, optional, minOf, token } = require('./rule-helpers');
+
+// LineStatement -> IfExpressionStatement | AssignmentStatement | FunctionStatement
+const LineStatement = rule(
+    () => either(IfExpressionStatement, AssignmentStatement, FunctionStatement),
+    expression => expression
+);
+
+// IfExpressionStatement -> IfKeyword PStart Expression PEnd CodeBlock
+const IfExpressionStatement = rule(
+    () => exactly(IfKeyword, PStart, Expression, PEnd, CodeBlock),
+    ([,, check,, statements]) => ({ type: 'if', check, statements })
+)
+
+// CodeBlock -> BStart LineStatement* BEnd
+const CodeBlock = rule(
+    () => exactly(BStart, minOf(0, LineStatement), BEnd),
+    ([, statements]) => statements
+);
+
+// FunctionStatement -> FunctionExpression Eol
+const FunctionStatement = rule(
+    () => exactly(FunctionExpression, Eol),
+    ([expression]) => expression
+);
+
+// FunctionExpression -> Name PStart FunctionParameters? PEnd
+const FunctionExpression = rule(
+    () => exactly(Name, PStart, optional(FunctionParameters, []), PEnd),
+    ([name, _, parameters]) => ({
+        type: 'function',
+        name: name.value,
+        parameters
+    })
+);
+
+// FunctionParameters -> Expression (Comma Expression)*
+const FunctionParameters = rule(
+    () => exactly(Expression, minOf(0, exactly(Comma, Expression))),
+    ([first, rest]) => [first, ...rest.map(([_, parameter]) => parameter)]
+);
+
+// AssignmentStatement -> Name Equals Expression Eol
+const AssignmentStatement = rule(
+    () => exactly(Name, Equals, Expression, Eol),
+    ([name,, expression]) => ({ type: 'assignment', name: name.value, expression })
+);
+
+// We use this functions for all binary operations in the
+// Expression rule because all of them parse the same way
+// this will allow us to create nested operations.
+const processBinaryResult = ([left, right]) => {
+    let expression = left;
+
+    // We need to go through all operators on the right side
+    // because there can be 3 or more operators in an expression.
+    for (const [operator, rightSide] of right) {
+
+        // Each time we encounter an expression we put the
+        // previous one in the left side.
+        expression = {
+            type: 'operation',
+            operation: operator.value,
+            left: expression,
+            right: rightSide
+        };
+    }
+
+    // Finally we return the expression structure.
+    return expression;
+};
+
+// Expression -> EqualityTerm ((And | Or) EqualityTerm)*
+const Expression = rule(
+    () => exactly(EqualityTerm, minOf(0, exactly(either(And, Or), EqualityTerm))),
+    processBinaryResult
+);
+
+// EqualityTerm -> RelationTerm ((DoubleEquals | NotEquals) RelationTerm)*
+const EqualityTerm = rule(
+    () => exactly(RelationTerm, minOf(0, exactly(either(DoubleEquals, NotEquals), RelationTerm))),
+    processBinaryResult
+);
+
+// EqualityTerm -> AddSubTerm ((Less | Greater | LessEquals | GreaterEquals) AddSubTerm)*
+const RelationTerm = rule(
+    () => exactly(AddSubTerm, minOf(0, exactly(either(Less, Greater, LessEquals, GreaterEquals), AddSubTerm))),
+    processBinaryResult
+);
+
+// AddSubTerm -> MulDivTerm ((Add | Subtract) MulDivTerm)*
+const AddSubTerm = rule(
+    () => exactly(MulDivTerm, minOf(0, exactly(either(Add, Subtract), MulDivTerm))),
+    processBinaryResult
+);
+
+// MulDivTerm -> UnaryTerm ((Multiply | Divide) UnaryTerm)*
+const MulDivTerm = rule(
+    () => exactly(UnaryTerm, minOf(0, exactly(either(Multiply, Divide), UnaryTerm))),
+    processBinaryResult
+);
+
+// UnaryTerm -> Not? Factor
+const UnaryTerm = rule(
+    () => exactly(optional(Not), Factor),
+    ([addedNot, value]) => ({
+        type: 'unary',
+        withNot: addedNot.type !== 'optional',
+        value
+    })
+);
+
+// Factor -> GroupExpression | FunctionExpression | NumberExpression | VariableExpression | StringExpression
+const Factor = rule(
+    () => either(GroupExpression, FunctionExpression, NumberExpression, VariableExpression, StringExpression),
+    factor => factor
+);
+
+// GroupExpression -> PStart Expression PEnd
+const GroupExpression = rule(
+    () => exactly(PStart, Expression, PEnd),
+    ([, expression]) => expression
+);
+
+// VariableExpression -> Name
+const VariableExpression = rule(
+    () => Name,
+    name => ({
+        type: 'variable',
+        name: name.value
+    })
+);
+
+// NumberExpression -> Number
+const NumberExpression = rule(
+    () => Number,
+    number => ({
+        type: 'number',
+        value: number.value
+    })
+);
+
+// StringExpression -> String
+const StringExpression = rule(
+    () => String,
+    string => ({
+        type: 'string',
+        value: string.value
+    })
+);
+
+// Tokens
+const Number = token('number');
+const String = token('string');
+const Name = token('name');
+const Equals = token('operator', '=');
+const PStart = token('parenStart');
+const PEnd = token('parenEnd');
+const BStart = token('codeBlockStart');
+const BEnd = token('codeBlockEnd');
+const Comma = token('comma');
+const Eol = token('endOfLine');
+const IfKeyword = token('keyword', 'if');
+const And = token('operator', '&&');
+const Or = token('operator', '||');
+const DoubleEquals = token('operator', '==');
+const NotEquals = token('operator', '!=');
+const Less = token('operator', '<');
+const Greater = token('operator', '>');
+const LessEquals = token('operator', '<=');
+const GreaterEquals = token('operator', '>=');
+const Add = token('operator', '+');
+const Subtract = token('operator', '-');
+const Multiply = token('operator', '*');
+const Divide = token('operator', '/');
+const Not = token('operator', '!');
+
+module.exports = LineStatement;

index.js

@@ -1,30 +1,53 @@
-const run = require('./runner');
-
+// Code which we want to parse
 const code = `
 firstName = 'John';
 lastName = 'Smith';
 age = 50;
 
-print('Entered name: ' + firstName + ', ' + lastName, 2);
+print('Entered name: ' + firstName + ', ' + lastName);
 
-if (age > 40 && checkName(firstName, 'John')) {
+if (age > 40) {
     if (age > 45) {
         print('Age is above 45');
     }
     print('Welcome, ' + firstName + ' you are ' + age + ' old.');
 }
 `;
 
+// Import the lexer
+const analyseCode = require('./lexer-analyser');
+
+// Run the lexer
+const tokens = analyseCode(code);
+
+// Import the parser
+const parseTokens = require('./parser-analyser');
+
+// Run the parser
+const statements = parseTokens(tokens);
+
+
+// Import the interpreter
+const interpret = require('./interpreter');
+
+// We create a virtual state machine object
 const vm = {
     variables: {},
     functions: {
-        print(text) {
-            console.log('Printing:', text, ':)');
+        print(message) { // We add a print function so that we can call a function from our code.
+            console.log('MESSAGE:', message); 
         },
-        checkName(name, val) {
-            return name === val;
+        pow(x, y) { // We also add a function which returns something for an expression.
+            return Math.pow(x, y);
         }
     }
 };
+// Interpret the statements and return last result.
+const result = interpret(statements, vm);
 
-run(code, vm);
+// And finally we output the result
+console.log('Code we ran:');
+console.log(code);
+console.log('Result:')
+console.dir(result, {depth: null});
+console.log('Final VM State:', vm);