index.js

const { readFileSync } = require("fs");
const TOKEN_TYPES = {
  START_PROGRAM: /^GRRRRRRR!/,
  END_PROGRAM: /^HSSSSSSS!/,
  DECLARE: /^RAAAWR!/,
  ASSIGN: /^RAAAWR\./,
  RAAWR_KEYWORD: /^RAAWR\b/,
  FUNCTION_DEFINE: /^DEFINE_TERRITORY/,
  FUNCTION_END: /^END_TERRITORY/,
  FUNCTION_RETURN: /^RETURN_PREY/,
  FUNCTION_CALL: /^CALL_TERRITORY/,
  IF: /^IF_ROAR/,
  THEN: /^THEN_CHOMP/,
  ELSE: /^ELSE_STOMP/,
  END_IF: /^END_HUNT/,
  WHILE: /^WHILE_ROAR/,
  LOOP: /^KEEP_MIGRATING/,
  END_LOOP: /^END_MIGRATION/,
  OUTPUT: /^ROAR/,
  INPUT: /^SNIFF/,
  PLUS: /^RAAWR\+/,
  MINUS: /^RAAWR\-/,
  MUL: /^RAAWR\*/,
  DIV: /^RAAWR\//,
  MOD: /^RAAWR%/,
  EQ: /^RAAWR==/,
  GT: /^RAAWR>/,
  LT: /^RAAWR</,
  CONCAT: /^ROOOOAAR/,
  LPAREN: /^\(/,
  RPAREN: /^\)/,
  COMMA: /^,/,
  STRING: /^"([^"]*)"/,
  BOOLEAN_TRUE: /^GRRR/,
  BOOLEAN_FALSE: /^HISS/,
  NUMBER: /^\d+(\.\d+)?/,
  IDENTIFIER: /^[A-Za-z_][A-Za-z0-9_]*/,
  COMMENT: /^\/\/.*/,
  NEWLINE: /^\n+/,
  WHITESPACE: /^[ \t\r]+/,
};
const orderedTokenTypes = [
  "START_PROGRAM",
  "END_PROGRAM",
  "DECLARE",
  "ASSIGN",
  "FUNCTION_DEFINE",
  "FUNCTION_END",
  "FUNCTION_RETURN",
  "FUNCTION_CALL",
  "IF",
  "THEN",
  "ELSE",
  "END_IF",
  "WHILE",
  "LOOP",
  "END_LOOP",
  "OUTPUT",
  "INPUT",
  "PLUS",
  "MINUS",
  "MUL",
  "DIV",
  "MOD",
  "EQ",
  "GT",
  "LT",
  "CONCAT",
  "RAAWR_KEYWORD",
  "LPAREN",
  "RPAREN",
  "COMMA",
  "STRING",
  "BOOLEAN_TRUE",
  "BOOLEAN_FALSE",
  "NUMBER",
  "IDENTIFIER",
  "COMMENT",
  "NEWLINE",
  "WHITESPACE",
];
function tokenize(code) {
  let tokens = [],
    line = 1;
  while (code.length > 0) {
    let matched = false;
    for (const type of orderedTokenTypes) {
      const regex = TOKEN_TYPES[type];
      const match = regex.exec(code);
      if (match) {
        matched = true;
        const value = match[0];
        if (type === "NEWLINE") line += (value.match(/\n/g) || []).length;
        if (!["WHITESPACE", "COMMENT", "NEWLINE"].includes(type)) {
          tokens.push({
            type,
            value: type === "STRING" ? match[1] : value,
            line,
          });
        }
        code = code.slice(value.length);
        break;
      }
    }
    if (!matched)
      throw new Error(`ROOOAAARRR! Unrecognized '${code[0]}' at line ${line}.`);
  }
  return tokens;
}
function parse(tokens) {
  let i = 0;
  function peek() {
    return tokens[i];
  }
  function consume(expected) {
    const tok = tokens[i++];
    if (!tok)
      throw new Error(
        `CRUNCH! (Syntax Error: Unexpected end of code, expected ${
          expected || "token"
        }.)`
      );
    if (expected && tok.type !== expected)
      throw new Error(
        `ROOOAAARRR! (Syntax Error: Expected '${expected}', but found '${tok.type}' ('${tok.value}') at line ${tok.line}.)`
      );
    return tok;
  }
  function match(type) {
    return tokens[i] && tokens[i].type === type;
  }
  function parseProgram() {
    const node = { type: "Program", body: [], line: peek().line };
    consume("START_PROGRAM");
    while (!match("END_PROGRAM")) node.body.push(parseStatement());
    consume("END_PROGRAM");
    return node;
  }
  function parseStatement() {
    if (match("DECLARE")) return parseVariableDeclaration();
    if (match("ASSIGN")) return parseAssignment();
    if (match("OUTPUT")) return parseOutput();
    if (match("INPUT")) return parseInput();
    if (match("IF")) return parseIf();
    if (match("WHILE")) return parseWhile();
    if (match("FUNCTION_DEFINE")) return parseFunctionDef();
    if (match("FUNCTION_CALL")) return parseFunctionCall();
    if (match("FUNCTION_RETURN")) return parseReturn();
    throw new Error(
      `ROOOAAARRR! (Syntax Error: Unexpected statement '${
        peek().value
      }' at line ${peek().line}.)`
    );
  }
  function parseVariableDeclaration() {
    const line = peek().line;
    consume("DECLARE");
    const name = consume("IDENTIFIER").value;
    consume("RAAWR_KEYWORD");
    const value = parseExpression();
    return { type: "VariableDeclaration", name, value, line };
  }
  function parseAssignment() {
    const line = peek().line;
    consume("ASSIGN");
    const name = consume("IDENTIFIER").value;
    consume("RAAWR_KEYWORD");
    const value = parseExpression();
    return { type: "Assignment", name, value, line };
  }
  function parseOutput() {
    const line = peek().line;
    consume("OUTPUT");
    const value = parseExpression();
    return { type: "Output", value, line };
  }
  function parseInput() {
    const line = peek().line;
    consume("INPUT");
    const name = consume("IDENTIFIER").value;
    return { type: "Input", name, line };
  }
  function parseIf() {
    const line = peek().line;
    consume("IF");
    const cond = parseExpression();
    consume("THEN");
    const thenBranch = [];
    while (!match("ELSE") && !match("END_IF"))
      thenBranch.push(parseStatement());
    let elseBranch = [];
    if (match("ELSE")) {
      consume("ELSE");
      while (!match("END_IF")) elseBranch.push(parseStatement());
    }
    consume("END_IF");
    return { type: "If", condition: cond, thenBranch, elseBranch, line };
  }
  function parseWhile() {
    const line = peek().line;
    consume("WHILE");
    const cond = parseExpression();
    consume("LOOP");
    const body = [];
    while (!match("END_LOOP")) body.push(parseStatement());
    consume("END_LOOP");
    return { type: "While", condition: cond, body, line };
  }
  function parseFunctionDef() {
    const line = peek().line;
    consume("FUNCTION_DEFINE");
    const name = consume("IDENTIFIER").value;
    consume("LPAREN");
    const params = [];
    if (!match("RPAREN")) {
      params.push(consume("IDENTIFIER").value);
      while (match("RAAWR_KEYWORD")) {
        consume("RAAWR_KEYWORD");
        params.push(consume("IDENTIFIER").value);
      }
    }
    consume("RPAREN");
    const body = [];
    let returnValue = null;
    while (!match("FUNCTION_END")) {
      if (match("FUNCTION_RETURN")) returnValue = parseReturn().value;
      else body.push(parseStatement());
    }
    consume("FUNCTION_END");
    return {
      type: "FunctionDeclaration",
      name,
      params,
      body,
      returnValue,
      line,
    };
  }
  function parseReturn() {
    const line = peek().line;
    consume("FUNCTION_RETURN");
    const value = parseExpression();
    return { type: "Return", value, line };
  }
  function parseFunctionCall() {
    const line = peek().line;
    consume("FUNCTION_CALL");
    const name = consume("IDENTIFIER").value;
    consume("LPAREN");
    const args = [];
    if (!match("RPAREN")) {
      args.push(parseExpression());
      while (match("RAAWR_KEYWORD")) {
        consume("RAAWR_KEYWORD");
        args.push(parseExpression());
      }
    }
    consume("RPAREN");
    return { type: "FunctionCall", name, args, line };
  }
  function parseExpression() {
    let left = parsePrimaryExpression();
    while (
      [
        "PLUS",
        "MINUS",
        "MUL",
        "DIV",
        "MOD",
        "EQ",
        "GT",
        "LT",
        "CONCAT",
      ].includes(peek()?.type)
    ) {
      const op = consume().type;
      const right = parsePrimaryExpression();
      left = {
        type: "BinaryExpression",
        operator: op,
        left,
        right,
        line: left.line,
      };
    }
    return left;
  }
  function parsePrimaryExpression() {
    const tok = peek();
    if (!tok)
      throw new Error(`CRUNCH! (Syntax Error: Unexpected end in expression.)`);
    if (tok.type === "NUMBER") {
      consume("NUMBER");
      return { type: "Literal", value: parseFloat(tok.value), line: tok.line };
    }
    if (tok.type === "STRING") {
      consume("STRING");
      return { type: "Literal", value: tok.value, line: tok.line };
    }
    if (tok.type === "BOOLEAN_TRUE") {
      consume("BOOLEAN_TRUE");
      return { type: "Literal", value: true, line: tok.line };
    }
    if (tok.type === "BOOLEAN_FALSE") {
      consume("BOOLEAN_FALSE");
      return { type: "Literal", value: false, line: tok.line };
    }
    if (tok.type === "FUNCTION_CALL") {
      return parseFunctionCall();
    }
    if (tok.type === "IDENTIFIER") {
      consume("IDENTIFIER");
      return { type: "Identifier", name: tok.value, line: tok.line };
    }
    if (tok.type === "LPAREN") {
      consume("LPAREN");
      const expr = parseExpression();
      consume("RPAREN");
      return expr;
    }
    throw new Error(
      `ROOOAAARRR! (Syntax Error: Unexpected token '${tok.value}' at line ${tok.line}.)`
    );
  }
  return parseProgram();
}
class Environment {
  constructor(parent = null) {
    this.vars = new Map();
    this.functions = new Map();
    this.parent = parent;
  }
  declareVar(name, value) {
    if (this.vars.has(name))
      throw new Error(
        `CRUNCH! (Runtime Error: Variable '${name}' already declared.)`
      );
    this.vars.set(name, value);
  }
  setVar(name, value) {
    if (this.vars.has(name)) return this.vars.set(name, value);
    if (this.parent) return this.parent.setVar(name, value);
    throw new Error(
      `CRUNCH! (Runtime Error: Variable '${name}' not declared.)`
    );
  }
  getVar(name) {
    if (this.vars.has(name)) return this.vars.get(name);
    if (this.parent) return this.parent.getVar(name);
    throw new Error(
      `CRUNCH! (Runtime Error: Variable '${name}' not declared.)`
    );
  }
  declareFunction(name, def) {
    this.functions.set(name, def);
  }
  getFunction(name, line) {
    if (this.functions.has(name)) return this.functions.get(name);
    if (this.parent) return this.parent.getFunction(name, line);
    throw new Error(
      `CRUNCH! (Runtime Error: Function '${name}' not found at line ${line}.)`
    );
  }
}
async function interpret(ast, getInput) {
  const globalEnv = new Environment();
  async function evaluate(node, env) {
    if (node.type === "Literal") return node.value;
    if (node.type === "Identifier") return env.getVar(node.name);
    if (node.type === "BinaryExpression") {
      const l = await evaluate(node.left, env);
      const r = await evaluate(node.right, env);
      if (["PLUS", "MINUS", "MUL", "DIV", "MOD"].includes(node.operator)) {
        if (typeof l !== "number" || typeof r !== "number") {
          throw new Error(
            `CRUNCH! (Runtime Error: ${
              node.operator
            } expects numbers, got ${typeof l} and ${typeof r} at line ${
              node.line
            }.)`
          );
        }
      }
      if (["EQ", "GT", "LT"].includes(node.operator)) {
      }
      if (node.operator === "CONCAT") {
      }
      switch (node.operator) {
        case "PLUS":
          return l + r;
        case "MINUS":
          return l - r;
        case "MUL":
          return l * r;
        case "DIV":
          if (r === 0)
            throw new Error(
              `CRUNCH! (Runtime Error: Division by zero at line ${node.line}. The Raptor just ate your data.)`
            );
          return l / r;
        case "MOD":
          if (r === 0)
            throw new Error(
              `CRUNCH! (Runtime Error: Modulo by zero at line ${node.line}. Even dinosaurs can't divide by zero!)`
            );
          return l % r;
        case "EQ":
          return l === r;
        case "GT":
          return l > r;
        case "LT":
          return l < r;
        case "CONCAT":
          return String(l) + String(r);
        default:
          throw new Error(
            `CRUNCH! (Runtime Error: Unknown operator '${node.operator}' at line ${node.line}.)`
          );
      }
    }
    if (node.type === "FunctionCall") {
      const def = env.getFunction(node.name, node.line);
      if (def.params.length !== node.args.length)
        throw new Error(
          `CRUNCH! (Runtime Error: Function '${node.name}' expects ${def.params.length} arguments, but got ${node.args.length} at line ${node.line}.)`
        );
      const fnEnv = new Environment(env);
      for (let i = 0; i < def.params.length; i++)
        fnEnv.declareVar(def.params[i], await evaluate(node.args[i], env));
      for (const stmt of def.body) {
        const res = await execute(stmt, fnEnv);
        if (res && res.type === "Return")
          return await evaluate(res.value, fnEnv);
      }
      if (def.returnValue) return await evaluate(def.returnValue, fnEnv);
      return;
    }
    throw new Error(
      `CRUNCH! (Runtime Error: Unknown expression type '${node.type}' at line ${node.line}.)`
    );
  }
  async function execute(node, env) {
    switch (node.type) {
      case "VariableDeclaration":
        env.declareVar(node.name, await evaluate(node.value, env));
        break;
      case "Assignment":
        env.setVar(node.name, await evaluate(node.value, env));
        break;
      case "Output":
        console.log(await evaluate(node.value, env));
        break;
      case "Input":
        env.setVar(node.name, await getInput());
        break;
      case "If": {
        const cond = await evaluate(node.condition, env);
        if (typeof cond !== "boolean")
          throw new Error(
            `CRUNCH! (Runtime Error: IF_ROAR condition must be boolean, got ${typeof cond} at line ${
              node.line
            }.)`
          );
        const branch = cond ? node.thenBranch : node.elseBranch;
        for (const stmt of branch) await execute(stmt, env);
        break;
      }
      case "While":
        const conditionValue = await evaluate(node.condition, env);
        if (typeof conditionValue !== "boolean")
          throw new Error(
            `CRUNCH! (Runtime Error: WHILE_ROAR condition must be boolean, got ${typeof conditionValue} at line ${
              node.line
            }.)`
          );
        while (await evaluate(node.condition, env)) {
          for (const stmt of node.body) await execute(stmt, env);
        }
        break;
      case "FunctionDeclaration":
        env.declareFunction(node.name, node);
        break;
      case "Return":
        return node;
      case "FunctionCall":
        await evaluate(node, env);
        break;
      default:
        throw new Error(
          `CRUNCH! (Runtime Error: Unknown node type '${node.type}' in execute.)`
        );
    }
  }
  for (const stmt of ast.body) await execute(stmt, globalEnv);
}
async function runRaaawr(code) {
  try {
    const tokens = tokenize(code);
    const ast = parse(tokens);
    const readline = require("readline");
    const rl = readline.createInterface({
      input: process.stdin,
      output: process.stdout,
    });
    const getInput = () =>
      new Promise((res) => rl.question("", (ans) => res(ans)));
    console.log("--- Raaawr Execution Started ---");
    await interpret(ast, getInput);
    console.log("--- Raaawr Execution Finished ---");
    rl.close();
  } catch (e) {
    console.error("FATAL ERROR:", e.message);
  }
}
const raaawrCode = `
GRRRRRRR!
RAAAWR! DINO_NAME RAAWR "" 
ROAR "Welcome to the Jurassic Jungle!"
ROAR "What's your name, brave dinosaur?"
SNIFF DINO_NAME
ROAR "RAAAWR! " ROOOOAAR DINO_NAME ROOOOAAR " has entered the jungle."
RAAAWR! IS_HUNGRY RAAWR GRRR
RAAAWR! PREY_COUNT RAAWR 0
RAAAWR! ENERGY RAAWR 50
RAAAWR! MAX_ENERGY RAAWR 100
DEFINE_TERRITORY HUNT_PREY ()
    ROAR "Looking for prey..."
    RAAAWR. PREY_COUNT RAAWR (PREY_COUNT RAAWR+ 1)
    RAAAWR. ENERGY RAAWR (ENERGY RAAWR- 10)
    ROAR "Caught one prey! Total prey: " ROOOOAAR PREY_COUNT
END_TERRITORY
DEFINE_TERRITORY EAT_PREY ()
    IF_ROAR (PREY_COUNT RAAWR> 0) THEN_CHOMP
        RAAAWR. PREY_COUNT RAAWR (PREY_COUNT RAAWR- 1)
        RAAAWR. ENERGY RAAWR (ENERGY RAAWR+ 20)
        ROAR "Yum! Ate a prey! Energy: " ROOOOAAR ENERGY
    ELSE_STOMP
        ROAR "No prey to eat!"
    END_HUNT
END_TERRITORY
DEFINE_TERRITORY NEED_REST ()
    IF_ROAR (ENERGY RAAWR< 30) THEN_CHOMP
        RETURN_PREY GRRR
    ELSE_STOMP
        RETURN_PREY HISS
    END_HUNT
END_TERRITORY
RAAAWR! ACTION RAAWR "" 
RAAAWR! NEEDS_REST RAAWR HISS 
WHILE_ROAR (ENERGY RAAWR< MAX_ENERGY) KEEP_MIGRATING
    ROAR "Energy level: " ROOOOAAR ENERGY
    ROAR "Do you want to hunt or eat? (hunt/eat)"
    SNIFF ACTION
    IF_ROAR (ACTION RAAWR== "hunt") THEN_CHOMP
        CALL_TERRITORY HUNT_PREY ()
    ELSE_STOMP
        CALL_TERRITORY EAT_PREY ()
    END_HUNT
    RAAAWR. NEEDS_REST RAAWR CALL_TERRITORY NEED_REST ()
    IF_ROAR (NEEDS_REST RAAWR== GRRR) THEN_CHOMP
        ROAR "You feel tired and need to rest."
        RAAAWR. ENERGY RAAWR (ENERGY RAAWR+ 15)
        ROAR "You rested and regained some energy."
    END_HUNT
END_MIGRATION
ROAR "Well done, " ROOOOAAR DINO_NAME ROOOOAAR "! You survived the jungle!"
ROAR "Total prey caught: " ROOOOAAR PREY_COUNT
ROAR "Final energy: " ROOOOAAR ENERGY
ROAR "RAAAWR-some adventure ends here!"
DEFINE_TERRITORY Calculate_Energy_Cost (distance RAAWR terrain_difficulty)
    RAAAWR! base_cost RAAWR (distance RAAWR* 2)
    RAAAWR! terrain_modifier RAAWR (terrain_difficulty RAAWR% 3)
    RAAAWR! total_cost RAAWR (base_cost RAAWR+ terrain_modifier)
    RETURN_PREY total_cost
END_TERRITORY
RAAAWR! travel_distance RAAWR 15 
RAAAWR! current_terrain RAAWR 7 
RAAAWR! hunt_cost RAAWR CALL_TERRITORY Calculate_Energy_Cost(travel_distance RAAWR current_terrain) 
ROAR "Calculated hunt energy cost: " ROOOOAAR hunt_cost
HSSSSSSS!
`;
runRaaawr(raaawrCode);