iVProg/js/util/codeParser.js

// iVProg - www.usp.br/line/ivprog
// LInE - Free Education, Private Data

// This is used when is loaded "ivph" file under the button "upload"

import * as Models from '../visualUI/ivprog_elements';
import { LocalizedStrings } from './../services/localizedStringsService';
import * as VariableValueMenuManagement from '../visualUI/commands/variable_value_menu';
import * as CodeParser from '../visualUI/commands/generic_expression';

function parseBoolean (var_value, dimensions) {
  if (dimensions == 0)
    return var_value == LocalizedStrings.getUI("logic_value_true");
  if (dimensions == 1) {
    var final_array = [];
    var_value.forEach(function(el) {
      final_array.push(el == LocalizedStrings.getUI("logic_value_true"));
      });
    return final_array;
    }
  if (dimensions == 2) {
    var final_array = [];
    var_value.forEach(function(row) {
      var temp = [];
      row.forEach(function(el) {
        temp.push(el == LocalizedStrings.getUI("logic_value_true"));
        });
      final_array.push(temp);
      });
    return final_array;
    }
  }


function parseGlobal (global_obj) {
  var new_global = new Models.Variable(global_obj.type, global_obj.name, global_obj.value);

  new_global.is_constant = global_obj.is_const;
  new_global.columns = global_obj.columns;
  new_global.dimensions = global_obj.dimension;
  new_global.rows = global_obj.rows;

  if (global_obj.type == "boolean")
    new_global.value = parseBoolean(global_obj.value, global_obj.dimension);

  window.program_obj.addGlobal(new_global);
  }


function parseParameter (parameter_obj) {
  const new_parameter = new Models.Variable(
    parameter_obj.type,
    parameter_obj.name,
    null,
    parameter_obj.dimension,
    parameter_obj.is_const,
    parameter_obj.rows,
    parameter_obj.columns,
    parameter_obj.reference
    );

  new_parameter.value = parameter_obj.value;

  if (parameter_obj.type == "boolean" && parameter_obj.value)
    new_parameter.value = parseBoolean(parameter_obj.value, parameter_obj.dimension);

  return new_parameter;
  }


function parseFunction (function_obj) {
  const new_function = new Models.Function(function_obj.name, function_obj.return_type, function_obj.return_dimensions, [], false, false, []);

  if (!new_function.name) {
    new_function.name = LocalizedStrings.getUI("start");
    new_function.is_main = true;
    }

  if (function_obj.parameters_list) {
    function_obj.parameters_list.forEach(function(el) {
      new_function.parameters_list.push(parseParameter(el));
      });
    }

  if (function_obj.variables_list) {
    function_obj.variables_list.forEach(function(el) {
      new_function.variables_list.push(parseParameter(el));
      });
    }

  window.program_obj.addFunction(new_function);
  }

// Auxiliary to debug
function printCommandText (code) {
  if (code) {
    //if (code.commands) return "commands.length=" + code.commands.length; else return "Object.commands <empty>";
    var aux = "";
    if (code.globals) aux = "#globals=" + code.globals.length;
    else aux = "#globals=0";
    if (code.functions) aux += ", #functions=" + code.functions.length;
    else aux += ", #functions=0";
    return aux;
    }
  return "Object <empty>";
  }

// @calledby Recursive, "parserCodeVisual(.)": preparedFunction.commands = parseCommands(rawFunction.commands, preparedFunction);
// @calledby Generic parser, "parseCommands(.)": temp.push(parseCommands(command, function_obj));
// @calledby Each parser command as "function parseIfTrue(command,function_obj)": "ifTrueBlock=parseCommands(command.ifTrue,function_obj)" and "ifFalseBlock=parseCommands(command.ifFalse,function_obj)"
// Sequence calls: 
//   parserCodeVisual here
//   js/util/iassignHelpers.js!setPreviousAlgorithm(code):                                        var result = parserCodeVisual(code_obj);
//   js/iassign-integration-functions.js!prepareActivityToStudent(ilm_cont, ignore_logs = false): var result = ivprogCore.setPreviousAlgorithm(ilm_cont);
//   js/iassign-integration-functions.js!getiLMContent():                                         prepareActivityToStudent(data);
export function parserCodeVisual (code_obj = null) {
  console.log("js/util/codeParser.js!parserCodeVisual(.): code_obj has " + printCommandText(code_obj)); // JSON.stringify(code_obj));
  if (!code_obj || code_obj===null) {
    // Avoid severe error! parserCodeVisual@http://localhost/ivprog/ivprogh/js/main.ecdd914f315cb1bf2925.js:11054:5...
    console.log("js/util/codeParser.js!parserCodeVisual(.): code_obj is empty: " + code_obj); // JSON.stringify(code_obj));
    //D console.trace();
    return null;
    }
  // console.trace();
  window.conteudo = code_obj;

  // Globals:
  window.program_obj.globals = [];
  code_obj.globals.forEach(parseGlobal);

  // Functions:
  window.program_obj.functions = [];
  code_obj.functions.forEach(parseFunction);

  // Commands: 
  window.program_obj.functions.forEach(function (preparedFunction) {
    code_obj.functions.forEach(function (rawFunction) {
      if (preparedFunction.name == rawFunction.name || (!rawFunction.name && preparedFunction.name == LocalizedStrings.getUI("start"))) {

        //comments: starts
        if (rawFunction.variables_list && rawFunction.variables_list.length > 0) {
          const newVariablesList = [];
          rawFunction.variables_list.forEach(function(varItem) {
            if (varItem.type === "comment") {
              // This is a comment - create "Comment"
              const comment = parseComment(varItem, preparedFunction);
              if (comment) {
                newVariablesList.push(comment);
              }
            } else {
              // This is a comment - get existing variable
              const existingVar = preparedFunction.variables_list.find((v) => v.name === varItem.name);
              if (existingVar) {
                newVariablesList.push(existingVar);
              }
            }
          });
          preparedFunction.variables_list = newVariablesList;
        } //comments: end

        preparedFunction.commands = parseCommands(rawFunction.commands, preparedFunction);
        }
      });
    });
  console.log("codeParser.js!parserCodeVisual(.): finished!");
  return true; // set to js/util/iassignHelpers.js!setPreviousAlgorithm(code) success
  }


function parseCommands (commands_block, function_obj) {
  console.log("codeParser.js!parseCommands(.): commands_block=" + printCommandText(commands_block)); // "JSON.stringify(commands_block));" is infinity recursive...
  //D console.trace();
  if (Array.isArray(commands_block)) {
    var temp = [];
    commands_block.forEach(function (command) {
      //comments: starts
      var parsedCommand = parseCommands(command, function_obj);
      if (Array.isArray(parsedCommand)) {
        parsedCommand.forEach(function (decl) {
          temp.push(decl);
        });
      } else if (parsedCommand !== null) {
        if (command.inlineComment && parsedCommand.type !== "comment") {
          parsedCommand.inlineComment = command.inlineComment;
        }
        temp.push(parsedCommand);
      }
      //comments: end
      });
    return temp;
    }
  else { // if (Array.isArray(commands_block))
    var parsedCmd = null;

    switch (commands_block.type) {
      case Models.COMMAND_TYPES.reader:
        parsedCmd = parseReader(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.return:
        parsedCmd = parseReturn(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.writer:
        parsedCmd = parseWriter(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.break:
        parsedCmd = parseBreak(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.comment:
        parsedCmd = parseComment(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.attribution:
        parsedCmd = parseAttribution(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.functioncall:
        parsedCmd = parseFunctionCall(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.iftrue:
        parsedCmd = parseIfTrue(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.repeatNtimes:
        parsedCmd = parseRepeatNTimes(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.whiletrue:
        parsedCmd = parseWhileTrue(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.dowhiletrue:
        parsedCmd = parseDoWhileTrue(commands_block, function_obj);
        break;
      case Models.COMMAND_TYPES.switch:
        parsedCmd = parseSwitch(commands_block, function_obj);
        break;
      } // switch (commands_block.type)

    //comments: preserves "in-line" comments
    if (parsedCmd && commands_block.inlineComment) {
      parsedCmd.inlineComment = commands_block.inlineComment;
    }

    return parsedCmd;
    } // else if (Array.isArray(commands_block))
  } // function parseCommands(commands_block, function_obj)


function parseReader (command, function_obj) {
  var temp = CodeParser.expressionParserCodeVisual(command.variable, function_obj);
  if (Array.isArray(temp) && temp[0]) temp = temp[0];
  return new Models.Reader(temp);
  }


function parseReturn (command, function_obj) {
  var temp = CodeParser.expressionParserCodeVisual(command.expression, function_obj);
  return new Models.Return(temp);
  }


// Generate command "write(...)"
// @calls js/visualUI/commands/attribution.js: renderExpression
function parseWriter (command, function_obj) {
  //D var len_cmd = command.content.length; //leo
  //D var str = ""; // "#command.content=" + len_cmd + "\n"; //leo
  //D for (var i=0; i<len_cmd; i++) str += JSON.stringify(command.content[i]) + "; "; // "; " + command.content[i];
  //D console.log("./ivprog/js/util/codeParser.js: parseWriter(.): command=" + JSON.stringify(command)) // + "\nfunction_obj=||" + JSON.stringify(function_obj) + "||\n" + str); //leo
  console.log("./ivprog/js/util/codeParser.js: parseWriter(.): command=" + JSON.stringify(command));
  //#command=" + (command ? command.length : "<>") ); //leo + ";

  //leo
  //TODO It is missing to implement the visualUI construtor to "write_separator" in 'getVariable(.)'
  //TODO Incomplete solution: I change "Models.EXPRESSION_TYPES.write_sep" to "Models.ARITHMETIC_TYPES.plus" in ./ivprog/js/visualUI/commands/generic_expression.js
  //TODO See ./ivprog/js/visualUI/commands/generic_expression.js : expressionParserCodeVisual(.) : missing treat to 'write_sep' in 'getVariable(.)' final command
  // ATTENTION must pass all the vector to work with several variables in "write(.)"
  var temp = CodeParser.expressionParserCodeVisual(command.content, function_obj); // provide HTML elements

  //0 temp = CodeParser.expressionParserCodeVisual(command.content[0], function_obj);
  //D console.log("./ivprog/js/util/codeParser.js: parseWriter(.): #temp=" + temp.length + "; type=" + temp.type + ": temp=" + JSON.stringify(temp));
  return new Models.Writer(temp, command.newLine);
  }


function parseBreak (command, function_obj) {
  return new Models.Break();
  }


function parseAttribution (command, function_obj) {
  var variable = CodeParser.expressionParserCodeVisual(command.variable, function_obj);
  var expression = CodeParser.expressionParserCodeVisual(command.expression, function_obj);

  if (Array.isArray(variable)) variable = variable[0];

  return new Models.Attribution(variable, expression);
  }


// By Gleyce 2025/06/23; Edilson 2026/01/30
function parseComment (command, function_obj) {
  var text = command.comment || command.comment_text || command.value || command.text || "";

  if (!text) {
    console.warn("Comment without text!", command);
    return null;
    }

  var commentTextMenu = new Models.VariableValueMenu(VariableValueMenuManagement.VAR_OR_VALUE_TYPES.only_value, text, null, null, false);
  var commentObj = new Models.Comment(commentTextMenu);

  commentObj.comment = text;
  commentObj.value = text;
  commentObj._text = text;
  commentObj.comment_text = commentTextMenu;

  return commentObj;
  }


function parseFunctionCall (command, function_obj) {
  var parameters = [];
  if (command.parameters_list) {
    command.parameters_list.forEach(function(el) {
      var temp = CodeParser.expressionParserCodeVisual(el, function_obj);
      if (temp.content === 0) temp.content = "0";
      parameters.push(temp[0]);
      });
    }

  var function_called = CodeParser.searchFunction(command.name);

  var temp = new Models.VariableValueMenu(VariableValueMenuManagement.VAR_OR_VALUE_TYPES.only_function, null, null, null, false);
  temp.function_called = function_called;
  temp.parameters_list = parameters;

  return new Models.FunctionCall(temp, null);
  }


function parseIfTrue (command, function_obj) {
  var expression = CodeParser.expressionParserCodeVisual(command.expression, function_obj);
  var ifTrueBlock = parseCommands(command.ifTrue, function_obj);
  var ifFalseBlock = parseCommands(command.ifFalse, function_obj);
  return new Models.IfTrue(expression, ifTrueBlock, ifFalseBlock);
  }


function parseRepeatNTimes (command, function_obj) {
  //D console.log("codeParser.js!parseRepeatNTimes(.): command=" + JSON.stringify(command));
  console.log("codeParser.js!parseRepeatNTimes(.): command=" + command);
  var var_attribution = CodeParser.expressionParserCodeVisual(command.var_attribution, function_obj);
  var_attribution = var_attribution[0];

  var expression1 = CodeParser.expressionParserCodeVisual(command.var_initial, function_obj);
  expression1 = expression1[0];

  var expression2 = CodeParser.expressionParserCodeVisual(command.condition, function_obj);

  if (expression2[0].item == 'minus') {
    expression2 = expression2[1];
    expression2.content *= -1;
    }
  else expression2 = expression2[0];

  var var_step = CodeParser.expressionParserCodeVisual(command.step_expression, function_obj);

  var commands_block = parseCommands(command.commands, function_obj);

  var operator = command.step_expression[0].value == '+' ? Models.ARITHMETIC_TYPES.plus : Models.ARITHMETIC_TYPES.minus;

  var expression3 = new Models.ExpressionElement(Models.EXPRESSION_ELEMENTS.exp_op_exp, [null, operator, var_step[1]]);
  console.log("codeParser.js!parseRepeatNTimes(.): expression3=" + expression3);

  return new Models.RepeatNTimes(
    var_attribution,
    new Models.VariableValueMenu(VariableValueMenuManagement.VAR_OR_VALUE_TYPES.only_variable, null, null, null, false),
    expression1,
    expression2,
    expression3, 
    commands_block);
  } // function parseRepeatNTimes(command, function_obj)


function parseWhileTrue (command, function_obj) {
  var expression = CodeParser.expressionParserCodeVisual(command.expression, function_obj);
  var commands = parseCommands(command.commands, function_obj);

  return new Models.WhileTrue(expression, commands);
  }


function parseDoWhileTrue (command, function_obj) {  
  var expression = CodeParser.expressionParserCodeVisual(command.expression, function_obj);
  var commands = parseCommands(command.commands, function_obj);

  return new Models.DoWhileTrue(expression, commands);
  }


function parseSwitch (command, function_obj) {
  var expression = CodeParser.expressionParserCodeVisual(command.expression, function_obj);

  var sc = [];
  if (command.cases) {
    command.cases.forEach(function (case_el) {
      var temp_exp = CodeParser.expressionParserCodeVisual(case_el.expression, function_obj);
      var temp_commands = parseCommands(case_el.commands, function_obj);
      var temp_case = new Models.SwitchCase(temp_exp[0], temp_commands);
      sc.push(temp_case);
      })
    }

  return new Models.Switch(expression[0], sc);
  }