mimo-lang 1.0.0 → 1.0.8

package/cli.js

@@ -1,8 +1,17 @@
 #!/usr/bin/env node
 
 import fs from "fs";
+import path from "path";
 import Mimo from "./index.js";
-import { version } from "./package.json";
+
+// Get the directory of the current script
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+
+// Read the package.json file
+const packageJson = JSON.parse(
+  fs.readFileSync(path.join(__dirname, "package.json"), "utf-8")
+);
+const { version } = packageJson;
 
 // Check if the user asked for the version
 if (process.argv.includes("-v") || process.argv.includes("--version")) {
@@ -10,14 +19,32 @@ if (process.argv.includes("-v") || process.argv.includes("--version")) {
   process.exit(0);
 }
 
+// Check if the user asked for help
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  console.log("Usage: mimo [FILENAME] [-o|--output] [-t|--time] [-h|--help] [-q|--quiet] [-d|--debug] [-v|--version]");
+  console.log("FILENAME: The file to process.");
+  console.log("-o, --output: Generate output file.");
+  console.log("-t, --time: Measure execution time.");
+  console.log("-h, --help: Show this help message.");
+  console.log("-q, --quiet: Suppress all non-essential output.");
+  console.log("-d, --debug: Display additional debug information.");
+  console.log("-v, --version: Display the version number.");
+  process.exit(0);
+}
+
 // Check if a filename was provided
 if (process.argv.length < 3) {
-  console.error("Error: No file name provided.");
-  console.log("Usage: mimo [FILENAME]");
+  console.error("Error: No file name provided.\n");
+  console.log("Usage: mimo [FILENAME] [-o|--output] [-t|--time] [-h|--help] [-q|--quiet] [-d|--debug] [-v|--version]");
+  console.log("Use the --help flag for more information.\n\n");
   process.exit(1);
 }
 
 const filename = process.argv[2];
+const shouldGenerateOutput = process.argv.includes("-o") || process.argv.includes("--output");
+const shouldMeasureTime = process.argv.includes("-t") || process.argv.includes("--time");
+const shouldSuppressOutput = process.argv.includes("-q") || process.argv.includes("--quiet");
+const shouldDisplayDebugInfo = process.argv.includes("-d") || process.argv.includes("--debug");
 
 // Check if the file exists
 if (!fs.existsSync(filename)) {
@@ -37,8 +64,21 @@ try {
 // Run the code
 const mimo = new Mimo();
 try {
-  mimo.run(code);
+  if (shouldMeasureTime) console.time("Execution time");
+  
+  let { program } = await mimo.run(code);
+
+  if (shouldMeasureTime) console.timeEnd("Execution time");
+
+  if (shouldGenerateOutput) {
+    const outputFilename = path.join(
+      path.dirname(filename),
+      path.basename(filename, path.extname(filename)) + ".js"
+    );
+    fs.writeFileSync(outputFilename, mimo.toJS(program), "utf-8");
+    if (!shouldSuppressOutput) console.log(`Output written to: ${outputFilename}`);
+  }
 } catch (err) {
-  console.error("Error running code:", err.message);
+  if (shouldDisplayDebugInfo) console.error("Error running code:", err);
   process.exit(1);
-}
+}

package/compiler/execute/interpreter.js

@@ -1,10 +1,10 @@
-import { interpretBinary } from "./interpreters/binary";
-import { interpretCall } from "./interpreters/call";
-import { interpretIf } from "./interpreters/if";
-import { interpretTryCatch } from "./interpreters/try-catch";
-import { interpretWhile } from "./interpreters/while";
-import { createFunction } from "./utils/createfunction";
-import { evaluate } from "./utils/evaluate";
+import { interpretBinary } from "./interpreters/binary.js";
+import { interpretCall } from "./interpreters/call.js";
+import { interpretIf } from "./interpreters/if.js";
+import { interpretTryCatch } from "./interpreters/try-catch.js";
+import { interpretWhile } from "./interpreters/while.js";
+import { createFunction } from "./utils/createfunction.js";
+import { evaluate } from "./utils/evaluate.js";
 
 export async function interpretStatement(statement, env) {
   if (Array.isArray(statement)) {

package/compiler/execute/interpreters/binary.js

@@ -1,4 +1,4 @@
-import { evaluate } from "../utils/evaluate";
+import { evaluate } from "../utils/evaluate.js";
 
 export async function interpretBinary(statement, env) {
     if (env[statement.target] === undefined) {

package/compiler/execute/interpreters/call.js

@@ -1,4 +1,4 @@
-import { evaluate } from "../utils/evaluate";
+import { evaluate } from "../utils/evaluate.js";
 
 export async function interpretCall(statement, env) {
     const func = env[statement.name];

package/compiler/execute/interpreters/if.js

@@ -1,5 +1,5 @@
-import { interpretStatement } from "../interpreter";
-import { evaluate } from "../utils/evaluate";
+import { interpretStatement } from "../interpreter.js";
+import { evaluate } from "../utils/evaluate.js";
 
 export async function interpretIf(statement, env) {
     if (evaluate(statement.condition, env)) {

package/compiler/execute/interpreters/try-catch.js

@@ -1,3 +1,4 @@
+import { interpretStatement } from "../interpreter.js";
 
 export async function interpretTryCatch(statement, env) {
     try {

package/compiler/execute/interpreters/while.js

@@ -1,5 +1,5 @@
-import { interpretStatement } from "../interpreter";
-import { evaluate } from "../utils/evaluate";
+import { interpretStatement } from "../interpreter.js";
+import { evaluate } from "../utils/evaluate.js";
 
 export async function interpretWhile(statement, env) {
     while (evaluate(statement.condition, env)) {

package/compiler/execute/utils/createfunction.js

@@ -1,4 +1,4 @@
-import { interpret } from "../interpreter";
+import { interpret } from "../interpreter.js";
 
 export function createFunction(params, body, env) {
   return async function (...args) {

package/compiler/execute/utils/evaluate.js

@@ -1,4 +1,4 @@
-import { operate } from "./operate";
+import { operate } from "./operate.js";
 
 export const evaluate = (expression, env) =>
   expression.type === "literal"

package/compiler/lexer/processToken.js

@@ -1,6 +1,6 @@
 // processToken.js
 
-import { OPERATORS } from "./tokenTypes";
+import { OPERATORS } from "./tokenTypes.js";
 
 export const isOperator = (char) => OPERATORS.includes(char);
 

package/compiler/parser/expression/comparison.js

@@ -1,4 +1,4 @@
-import { parseExpression } from "../parseExpression";
+import { parseExpression } from "../parseExpression.js";
 
 export function comparisonExpression(tokens, index) {
     const operator = tokens[index++].value;

package/compiler/parser/expression/identifier.js

@@ -1,4 +1,4 @@
-import { parseExpression } from "../parseExpression";
+import { parseExpression } from "../parseExpression.js";
 
 export function identifierExpression(tokens, index) {
   if (

package/compiler/parser/expression/operator.js

@@ -1,4 +1,4 @@
-import { parseExpression } from "../parseExpression";
+import { parseExpression } from "../parseExpression.js";
 
 export function operatorExpression(tokens, index) {
   let operator = tokens[index++].value;

package/compiler/parser/expression/punctuation.js

@@ -1,4 +1,4 @@
-import { parseExpression } from "../parseExpression";
+import { parseExpression } from "../parseExpression.js";
 
 export function punctuationExpression(tokens, index) {
     if (tokens[index].value === "[") {

package/compiler/parser/parseExpression.js

@@ -1,9 +1,9 @@
-import { comparisonExpression } from "./expression/comparison";
-import { identifierExpression } from "./expression/identifier";
-import { numberExpression } from "./expression/number";
-import { operatorExpression } from "./expression/operator";
-import { punctuationExpression } from "./expression/punctuation";
-import { stringExpression } from "./expression/string";
+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);

package/compiler/parser/parseStatement.js

@@ -1,12 +1,11 @@
-import { parseExpression } from "./parseExpression";
-import { ifStatement } from "./statement/if";
-import { setStatement } from "./statement/set";
-import { tryCatchStatement } from "./statement/try-catch";
-import { whileStatement } from "./statement/while";
-import { functionStatement } from "./statement/function";
-import { callStatement } from "./statement/call";
-import { returnStatement } from "./statement/return";
-import { showStatement } from "./statement/show";
+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" };

package/compiler/parser/parser.js

@@ -1,4 +1,4 @@
-import { parseStatement } from "./parseStatement";
+import { parseStatement } from "./parseStatement.js";
 
 export function parseTokens(tokens) {
     let index = 0;

package/compiler/parser/statement/call.js

@@ -1,4 +1,4 @@
-import { parseExpression } from "../parseExpression";
+import { parseExpression } from "../parseExpression.js";
 
 export const callStatement = (tokens, index) => {
   let statement = { type: "call" };

package/compiler/parser/statement/function.js

@@ -1,4 +1,4 @@
-import { parseStatement } from "../parseStatement";
+import { parseStatement } from "../parseStatement.js";
 
 // #file:statement/function.js
 export const functionStatement = (tokens, index) => {

package/compiler/parser/statement/if.js

@@ -1,5 +1,5 @@
-import { parseExpression } from "../parseExpression";
-import { parseStatement } from "../parseStatement";
+import { parseExpression } from "../parseExpression.js";
+import { parseStatement } from "../parseStatement.js";
 
 export function ifStatement(tokens, index) {
   let statement = { type: "if" };

package/compiler/parser/statement/return.js

@@ -1,4 +1,4 @@
-import { parseExpression } from "../parseExpression";
+import { parseExpression } from "../parseExpression.js";
 
 // #file:statement/return.js
 export const returnStatement = (tokens, index) => {

package/compiler/parser/statement/set.js

@@ -1,4 +1,4 @@
-import { parseExpression } from "../parseExpression";
+import { parseExpression } from "../parseExpression.js";
 
 export function setStatement(tokens, index) {
   let statement = { type: "assignment" };

package/compiler/parser/statement/show.js

@@ -1,4 +1,4 @@
-import { parseExpression } from "../parseExpression";
+import { parseExpression } from "../parseExpression.js";
 
 export const showStatement = (tokens, index) => {
     let statement = { type: "print" };

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

@@ -1,4 +1,4 @@
-import { parseStatement } from "../parseStatement";
+import { parseStatement } from "../parseStatement.js";
 
 export const tryCatchStatement = (tokens, index) => {
   let statement = { type: "try-catch" };

package/compiler/parser/statement/while.js

@@ -1,5 +1,5 @@
-import { parseExpression } from "../parseExpression";
-import { parseStatement } from "../parseStatement";
+import { parseExpression } from "../parseExpression.js";
+import { parseStatement } from "../parseStatement.js";
 
 
 export const whileStatement = (tokens, index) => {

package/converter/go/convert.js

@@ -29,20 +29,31 @@ function generateGoCodeFromAst(node) {
 
 export function generateGoCodeFromAstArray(ast) {
   declaredVariables = new Set();
-  const generatedCode = ast.map(generateGoCodeFromAst).join("\n\n");
+  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"
 
-    ${generatedCode}
+    ${functionCode}
+
+    func main() {
+      ${otherCode}
+    }
   `);
 }
 
 function generateFunction(node) {
-  const params = node.params.join(", ");
+  const params = node.params.map((p) => `${p} any`).join(", ");
   const body = node.body.map(generateGoCodeFromAst).join("\n");
-  return `func ${node.name}(${params}) int {\n${body}\n}`;
+  return `func ${node.name}(${params}) any {\n${body}\n}`;
 }
 
 function generateAssignment(node) {
@@ -51,7 +62,7 @@ function generateAssignment(node) {
     prefix = "var ";
     declaredVariables.add(node.target);
   }
-  return `${prefix}${node.target} := ${generateGoCodeFromAst(node.value)}`;
+  return `${prefix}${node.target} = ${generateGoCodeFromAst(node.value)}`;
 }
 
 function generateWhile(node) {
@@ -79,12 +90,11 @@ function generateCall(node) {
       prefix = "var ";
       declaredVariables.add(node.target);
     }
-    callCode = `${prefix}${node.target} := ${callCode}`;
+    callCode = `${prefix}${node.target} = ${callCode}`;
   }
   return callCode;
 }
 
-
 function generatePrint(node) {
   return `fmt.Println(${generateGoCodeFromAst(node.value)})`;
 }

package/index.js

@@ -1,9 +1,7 @@
-import { generateTokens } from "./compiler/lexer/tokenizer";
-import { parseTokens } from "./compiler/parser/parser";
-import { interpret } from "./compiler/execute/interpreter";
-import { generateGoCodeFromAstArray } from "./converter/go/convert";
-import { generateCodeJsFromAstArray } from "./converter/js/convert";
-import fs from "fs";
+import { generateTokens } from "./compiler/lexer/tokenizer.js";
+import { parseTokens } from "./compiler/parser/parser.js";
+import { interpret } from "./compiler/execute/interpreter.js";
+import { generateCodeJsFromAstArray } from "./converter/js/convert.js";
 
 // The main class for the Mimo language
 export default class Mimo {
@@ -31,18 +29,13 @@ export default class Mimo {
   async run(code) {
     const tokens = await this.tokenize(code);
     const program = await this.parse(tokens);
-    return await this.interpret(program);
+    const env = await this.interpret(program);
+    return { program, env };
   }
 
   // Convert the AST to JavaScript code
   toJS(ast) {
     return generateCodeJsFromAstArray(ast);
   }
-
-  // Convert the AST to Go code
-  toGO(ast) {
-    return generateGoCodeFromAstArray(ast);
-  }
 }
 
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mimo-lang",
-  "version": "1.0.0",
+  "version": "1.0.8",
   "description": "A programming language made in javascript mostly for learning purposes.",
   "keywords": [
     "programing language"
@@ -14,7 +14,9 @@
     "mimo": "./cli.js"
   },
   "scripts": {
-    "dev": "bun index.js"
+    "mimo": "bun cli.js",
+    "dev": "bun index.js",
+    "test": "bun test/index.js"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/webpack.config.js

@@ -0,0 +1,9 @@
+const path = require('path');
+
+module.exports = {
+  entry: './index.js', // Entry point of your application
+  output: {
+    filename: 'bundle.js', // Name of the bundled output file
+    path: path.resolve(__dirname, 'dist'), // Output directory
+  },
+};