mimo-lang 1.1.1 → 2.0.6

package/compiler/lexer/processToken.js

@@ -1,40 +0,0 @@
-// processToken.js
-
-import { OPERATORS } from "./tokenTypes.js";
-
-export const isOperator = (char) => OPERATORS.includes(char);
-
-export const processToken = (currentToken, currentType, tokens) => {
-    if (currentToken) {
-        tokens.push({ type: currentType, value: currentToken });
-        return { currentToken: "", currentType: null };
-    }
-    return { currentToken, currentType };
-};
-
-export const processStringToken = (inString, currentToken, tokens) => {
-    inString = !inString;
-    if (!inString) {
-        tokens.push({ type: "string", value: currentToken });
-        currentToken = "";
-    }
-    return { inString, currentToken };
-};
-
-export const processOperatorToken = (char, index, input, currentType, currentToken, tokens) => {
-    if (currentToken) {
-        ({ currentToken, currentType } = processToken(currentToken, currentType, tokens));
-    }
-
-    
-    currentType = "operator";
-    currentToken += char;
-
-
-    if (index < input.length - 1 && isOperator(input[index + 1])) {
-        currentToken += input[index + 1];
-        index++; // Skip the next operator character
-    }
-    tokens.push({ type: currentType, value: currentToken });
-    return { currentToken: "", currentType: null, i:index };
-};

package/compiler/lexer/tokenTypes.js

@@ -1,4 +0,0 @@
-// tokenTypes.js
-export const OPERATORS = ["+", "-", "*", "/", ">", "<", "=", "!"];
-export const KEYWORDS = ["let", "const", "if", "else", "for", "while", "function", "return"];
-export const PUNCTUATION = ["(", ")", ",", "[", "]"];

package/compiler/lexer/tokenizer.js

@@ -1,74 +0,0 @@
-import { processToken, processStringToken, processOperatorToken, isOperator } from './processToken.js';
-import { PUNCTUATION } from './tokenTypes.js';
-
-/**
- * @typedef {Object} Token
- * @property {string} type - The type of the token (e.g., 'number', 'identifier', 'operator', etc.).
- * @property {string} value - The value of the token (e.g., '42', 'x', '+', etc.).
- */
-
-/**
- * Generate tokens from the given input.
- * @param {string} input - The input to be tokenized.
- * @returns {Token[]} An array of tokens.
- */
-function generateTokens(input) {
-    const tokens = [];
-    let currentToken = "";
-    let currentType = null;
-    let inComment = false;
-    let inString = false;
-
-    for (let i = 0; i < input.length; i++) {
-        const char = input[i];
-        
-        if (inComment) {
-            if (char === "\n") {
-                inComment = false;
-            }
-            continue;
-        }
-
-        if (char === "/" && input[i + 1] === "/") {
-            inComment = true;
-            i++; // Skip the second '/'
-            continue;
-        }
-
-        if (char === '"') {
-            ({ inString, currentToken } = processStringToken(inString, currentToken, tokens));
-            continue;
-        }
-
-        if (inString) {
-            currentToken += char;
-            continue;
-        }
-
-        if (/\s/.test(char)) {
-            ({ currentToken, currentType } = processToken(currentToken, currentType, tokens));
-            continue;
-        }
-
-        if (isOperator(char)) {
-            ({ currentToken, currentType, i } = processOperatorToken(char, i, input, currentType, currentToken, tokens));
-        }else  if (PUNCTUATION.includes(char)) {
-            ({ currentToken, currentType } = processToken(currentToken, currentType, tokens));
-            tokens.push({ type: "punctuation", value: char });
-        } else {
-            currentToken += char;
-            if (!currentType) {
-                currentType = /[a-zA-Z]/.test(char)
-                    ? "identifier"
-                    : /[0-9]/.test(char)
-                    ? "number"
-                    : null;
-            }
-        }
-    }
-
-    ({ currentToken, currentType } = processToken(currentToken, currentType, tokens));
-    return tokens;
-}
-
-export { generateTokens };

package/compiler/parser/expression/comparison.js

@@ -1,18 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-
-export function comparisonExpression(tokens, index) {
-    const operator = tokens[index++].value;
-        let left = parseExpression(tokens, index);
-        index = left.index; // Update the index
-        let right = parseExpression(tokens, index);
-        index = right.index; // Update the index
-        return {
-          expression: {
-            type: "comparison",
-            operator,
-            left: left.expression,
-            right: right.expression,
-          },
-          index,
-        };
-}

package/compiler/parser/expression/identifier.js

@@ -1,29 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-
-export function identifierExpression(tokens, index) {
-  if (
-    tokens[index + 1]?.value === "[" &&
-    tokens[index + 3]?.value === "]"
-  ) {
-    const name = tokens[index].value;
-    index += 2; // Skip identifier and '['
-    const indexExpression = parseExpression(tokens, index);
-    index = indexExpression.index; // Update the index
-    if (tokens[index]?.value === "]") {
-      index++; // Skip ']'
-    }
-    return {
-      expression: {
-        type: "indexAccess",
-        name,
-        index: indexExpression.expression,
-      },
-      index,
-    };
-  } else {
-    return {
-      expression: { type: "variable", name: tokens[index++].value },
-      index,
-    };
-  }
-}

package/compiler/parser/expression/number.js

@@ -1,10 +0,0 @@
-
-export function numberExpression(tokens, index){
-    return {
-        expression: {
-        type: "literal",
-        value: parseFloat(tokens[index++].value),
-        },
-        index,
-    };
-}

package/compiler/parser/expression/operator.js

@@ -1,21 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-
-export function operatorExpression(tokens, index) {
-  let operator = tokens[index++].value;
-  let left = parseExpression(tokens, index);
-  index = left.index; // Update the index
-  if (tokens[index]?.type === "operator") {
-    operator += tokens[index++].value; // Handle two-character operators like '=='
-  }
-  let right = parseExpression(tokens, index);
-  index = right.index; // Update the index
-  return {
-    expression: {
-      type: "binary",
-      operator,
-      left: left.expression,
-      right: right.expression,
-    },
-    index,
-  };
-}

package/compiler/parser/expression/punctuation.js

@@ -1,31 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-
-export function punctuationExpression(tokens, index) {
-    if (tokens[index].value === "[") {
-        index++; // Skip '['
-        const elements = [];
-        while (
-          tokens[index]?.type !== "punctuation" &&
-          tokens[index]?.value !== "]"
-        ) {
-          let result = parseExpression(tokens, index);
-          elements.push(result.expression);
-          index = result.index; // Update the index
-          if (
-            tokens[index]?.type === "punctuation" &&
-            tokens[index]?.value === ","
-          ) {
-            index++; // Skip ',' between elements
-          }
-        }
-        if (tokens[index]?.value === "]") {
-          index++; // Skip ']'
-        }
-        return { expression: { type: "list", elements }, index };
-      }
-
-    return {
-        expression: { type: "punctuation", value: tokens[index++].value },
-        index,
-    };
-}

package/compiler/parser/expression/string.js

@@ -1,6 +0,0 @@
-export function stringExpression(tokens, index){
-    return {
-        expression: { type: "literal", value: tokens[index++].value },
-        index,
-    };
-}

package/compiler/parser/parseExpression.js

@@ -1,27 +0,0 @@
-import { comparisonExpression } from "./expression/comparison.js";
-import { identifierExpression } from "./expression/identifier.js";
-import { numberExpression } from "./expression/number.js";
-import { operatorExpression } from "./expression/operator.js";
-import { punctuationExpression } from "./expression/punctuation.js";
-import { stringExpression } from "./expression/string.js";
-
-export const parseExpression = (tokens, index) => {
-//   console.log("expression..", tokens[index].type, tokens[index].value);
-
-  switch (tokens[index].type) {
-    case "number":
-     return numberExpression(tokens, index);
-    case "string":
-      return stringExpression(tokens, index);
-    case "identifier":
-      return identifierExpression(tokens, index);
-    case "operator":
-     return operatorExpression(tokens, index);
-    case "punctuation":
-      return punctuationExpression(tokens, index);
-    default:
-      if (["<", ">", ">=", "<=", "==", "!="].includes(tokens[index].value)) {
-        return comparisonExpression(tokens, index);
-      }
-  }
-};

package/compiler/parser/parseStatement.js

@@ -1,34 +0,0 @@
-import { ifStatement } from "./statement/if.js";
-import { setStatement } from "./statement/set.js";
-import { tryCatchStatement } from "./statement/try-catch.js";
-import { whileStatement } from "./statement/while.js";
-import { functionStatement } from "./statement/function.js";
-import { callStatement } from "./statement/call.js";
-import { returnStatement } from "./statement/return.js";
-import { showStatement } from "./statement/show.js";
-
-export const parseStatement = (tokens, index) => {
-  let statement = { type: "statement" };
-
-  if (tokens[index].value === "set") {
-    ({ statement, index } = setStatement(tokens, index));
-  } else if (tokens[index].value === "if") {
-    ({ statement, index } = ifStatement(tokens, index));
-  } else if (tokens[index].value === "while") {
-    ({ statement, index } = whileStatement(tokens, index));
-  } else if (tokens[index].value === "try") {
-    ({ statement, index } = tryCatchStatement(tokens, index));
-  } else if (tokens[index].value === "function") {
-    ({ statement, index } = functionStatement(tokens, index));
-  } else if (tokens[index].value === "call") {
-    ({ statement, index } = callStatement(tokens, index));
-  } else if (tokens[index].value === "return") {
-    ({ statement, index } = returnStatement(tokens, index));
-  } else if (tokens[index].value === "show") {
-    ({ statement, index } = showStatement(tokens, index));
-  } else {
-    index++;
-  }
-
-  return { statement, index };
-};

package/compiler/parser/parser.js

@@ -1,45 +0,0 @@
-import { parseStatement } from "./parseStatement.js";
-
-
-/**
- * @typedef {import('../lexer/tokenizer.js').Token} Token
- */
-
-/**
- * @typedef {Object} Node
- * @property {string} type - The type of the node (e.g., 'binary', 'assignment', 'literal', etc.).
- *  optionals
- * @property {string} [operator] - The operator (e.g., '+', '-', '*', '/', etc.).
- * @property {Node} [left] - The left node.
- * @property {Node} [right] - The right node.
- * @property {Node} [condition] - The expression node.
- * @property {Node} [consequent] - The consequent node.
- * @property {Node} [expression] - The expression node.
- * @property {Node} [alternate] - The alternate node.
- * @property {string} [target] - The target of the assignment.
- * @property {number} [value] - The value to be assigned.
- * @property {string} [name] - The name of functions and variables.
- * @property {string[]} [params] - The parameters of a function.
- * @property {Node[]} [body] - The body of a block statement.
-*/
-
-/**
- * Parse the list of tokens into an abstract syntax tree (AST).
- * @param {Token[]} tokens - The list of tokens to be parsed.
- * @returns {Node[]} An array of AST nodes.
- */
-
-export function parseTokens(tokens) {
-    let index = 0;
-
-    const program = [];
-    while (index < tokens.length) {
-        let statement;
-        let result = parseStatement(tokens, index);
-        statement = result.statement;
-        index = result.index; // Update the index
-        program.push(statement);
-    }
-
-    return program;
-}

package/compiler/parser/statement/call.js

@@ -1,26 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-
-export const callStatement = (tokens, index) => {
-  let statement = { type: "call" };
-  statement.name = tokens[index + 1]?.value;
-  index += 2; // Skip 'call' and function name
-  statement.args = [];
-  statement.target = null;
-  if (tokens[index].value === "(") {
-    index++; // Skip '('
-    while (tokens[index].value !== ")") {
-      if (tokens[index].value !== ",") {
-        let result = parseExpression(tokens, index);
-        statement.args.push(result.expression);
-        index = result.index; // Update the index
-      } else {
-        index++; // Skip ','
-      }
-    }
-    index++; // Skip ')'
-  }
-  if ((tokens[index++].value = "->")) {
-    statement.target = tokens[index++].value;
-  }
-  return { statement, index };
-};

package/compiler/parser/statement/function.js

@@ -1,29 +0,0 @@
-import { parseStatement } from "../parseStatement.js";
-
-// #file:statement/function.js
-export const functionStatement = (tokens, index) => {
-  index++; // Skip 'function'
-  let statement = { type: "function" };
-  statement.name = tokens[index++]?.value;
-  index++; // Skip 'function' and function name
-  statement.params = [];
-  while (tokens[index] && tokens[index]?.value !== ")") {
-    statement.params.push(tokens[index]?.value);
-    index++; // Skip parameter
-    if (tokens[index]?.value === ",") {
-      index++; // Skip ','
-    }
-  }
-  index++; // Skip ')'
-  const body = [];
-  while (tokens[index] && tokens[index].value !== "endfunction") {
-    let result = parseStatement(tokens, index);
-    body.push(result.statement);
-    index = result.index; // Update the index
-  }
-  if (tokens[index] && tokens[index].value === "endfunction") {
-    index++;
-  }
-  statement.body = body;
-  return { statement, index };
-};

package/compiler/parser/statement/if.js

@@ -1,34 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-import { parseStatement } from "../parseStatement.js";
-
-export function ifStatement(tokens, index) {
-  let statement = { type: "if" };
-  index++;
-  let result = parseExpression(tokens, index);
-  statement.condition = result.expression;
-  index = result.index; // Update the index
-  statement.consequent = [];
-
-  while (
-      tokens[index] &&
-      tokens[index].value !== "endif" &&
-      tokens[index].value !== "else"
-  ) {
-      let result = parseStatement(tokens, index);
-      statement.consequent.push(result.statement);
-      index = result.index; // Update the index
-  }
-  if (tokens[index].value === "else") {
-      index++;
-      statement.alternate = [];
-      while (tokens[index] && tokens[index].value !== "endif") {
-          let result = parseStatement(tokens, index);
-          statement.alternate.push(result.statement);
-          index = result.index; // Update the index
-      }
-  }
-  if (tokens[index].value === "endif") {
-      index++;
-  }
-  return { statement, index };
-}

package/compiler/parser/statement/return.js

@@ -1,10 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-
-// #file:statement/return.js
-export const returnStatement = (tokens, index) => {
-    let statement = { type: "return" };
-    let result = parseExpression(tokens, index + 1);
-    statement.expression = result.expression;
-    index = result.index; // Update the index
-    return { statement, index };
-};

package/compiler/parser/statement/set.js

@@ -1,11 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-
-export function setStatement(tokens, index) {
-  let statement = { type: "assignment" };
-  index++;
-  statement.target = tokens[index++].value;
-  let result = parseExpression(tokens, index);
-  statement.value = result.expression;
-  index = result.index; // Update the index
-  return { statement, index };
-}

package/compiler/parser/statement/show.js

@@ -1,10 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-
-export const showStatement = (tokens, index) => {
-    let statement = { type: "print" };
-    index++; // Skip 'show'
-    let result = parseExpression(tokens, index);
-    statement.value = result.expression;
-    index = result.index; // Update the index
-    return { statement, index };
-};

package/compiler/parser/statement/try-catch.js

@@ -1,25 +0,0 @@
-import { parseStatement } from "../parseStatement.js";
-
-export const tryCatchStatement = (tokens, index) => {
-  let statement = { type: "try-catch" };
-  statement.tryBlock = [];
-  index++;
-  while (tokens[index] && tokens[index].value !== "catch") {
-    let result = parseStatement(tokens, index);
-    statement.tryBlock.push(result.statement);
-    index = result.index; // Update the index
-  }
-  if (tokens[index].value === "catch") {
-    index++;
-    statement.catchBlock = [];
-    while (tokens[index] && tokens[index].value !== "endtry") {
-      let result = parseStatement(tokens, index);
-      statement.catchBlock.push(result.statement);
-      index = result.index; // Update the index
-    }
-  }
-  if (tokens[index].value === "endtry") {
-    index++;
-  }
-  return { statement, index };
-};

package/compiler/parser/statement/while.js

@@ -1,22 +0,0 @@
-import { parseExpression } from "../parseExpression.js";
-import { parseStatement } from "../parseStatement.js";
-
-
-export const whileStatement = (tokens, index) => {
-  index++; // Skip 'while'
-  let statement = { type: "while" };
-  let result = parseExpression(tokens, index);
-  statement.condition = result.expression;
-  index = result.index; // Update the index
-  const body = [];
-  while (tokens[index] && tokens[index].value !== "endwhile") {
-    let result = parseStatement(tokens, index);
-    body.push(result.statement);
-    index = result.index; // Update the index
-  }
-  if (tokens[index].value === "endwhile") {
-    index++;
-  }
-  statement.body = body;
-  return { statement, index };
-};

package/converter/go/convert.js

@@ -1,110 +0,0 @@
-let declaredVariables = new Set();
-
-function generateGoCodeFromAst(node) {
-  switch (node.type) {
-    case "function":
-      return generateFunction(node);
-    case "assignment":
-      return generateAssignment(node);
-    case "while":
-      return generateWhile(node);
-    case "if":
-      return generateIf(node);
-    case "return":
-      return generateReturn(node);
-    case "call":
-      return generateCall(node);
-    case "print":
-      return generatePrint(node);
-    case "literal":
-      return node.value;
-    case "variable":
-      return node.name;
-    case "binary":
-      return generateBinary(node);
-    default:
-      throw new Error(`Unknown node type: ${node.type}`);
-  }
-}
-
-export function generateGoCodeFromAstArray(ast) {
-  declaredVariables = new Set();
-  const functionCode = ast
-    .filter((node) => node.type === "function")
-    .map(generateGoCodeFromAst)
-    .join("\n\n");
-  const otherCode = ast
-    .filter((node) => node.type !== "function")
-    .map(generateGoCodeFromAst)
-    .join("\n");
-  return formatGoCode(`
-    package main
-
-    import "fmt"
-
-    ${functionCode}
-
-    func main() {
-      ${otherCode}
-    }
-  `);
-}
-
-function generateFunction(node) {
-  const params = node.params.map((p) => `${p} any`).join(", ");
-  const body = node.body.map(generateGoCodeFromAst).join("\n");
-  return `func ${node.name}(${params}) any {\n${body}\n}`;
-}
-
-function generateAssignment(node) {
-  let prefix = "";
-  if (!declaredVariables.has(node.target)) {
-    prefix = "var ";
-    declaredVariables.add(node.target);
-  }
-  return `${prefix}${node.target} = ${generateGoCodeFromAst(node.value)}`;
-}
-
-function generateWhile(node) {
-  const condition = generateGoCodeFromAst(node.condition);
-  const body = node.body.map(generateGoCodeFromAst).join("\n");
-  return `for ${condition} {\n${body}\n}`;
-}
-
-function generateIf(node) {
-  const condition = generateGoCodeFromAst(node.condition);
-  const consequent = node.consequent.map(generateGoCodeFromAst).join("\n");
-  return `if ${condition} {\n${consequent}\n}`;
-}
-
-function generateReturn(node) {
-  return `return ${generateGoCodeFromAst(node.expression)}`;
-}
-
-function generateCall(node) {
-  const args = node.args.map(generateGoCodeFromAst).join(", ");
-  let callCode = `${node.name}(${args})`;
-  if (node.target) {
-    let prefix = "";
-    if (!declaredVariables.has(node.target)) {
-      prefix = "var ";
-      declaredVariables.add(node.target);
-    }
-    callCode = `${prefix}${node.target} = ${callCode}`;
-  }
-  return callCode;
-}
-
-function generatePrint(node) {
-  return `fmt.Println(${generateGoCodeFromAst(node.value)})`;
-}
-
-function generateBinary(node) {
-  const left = generateGoCodeFromAst(node.left);
-  const right = generateGoCodeFromAst(node.right);
-  return `${left} ${node.operator} ${right}`;
-}
-
-function formatGoCode(code) {
-  return code;
-}