Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory :  /var/www/html/libs/absol-full/dist/js/

Upload File : current_dir [ Writeable ] document_root [ Writeable ]

/*** module: node_modules/absol-form/js/sclang/SCGrammar.js ***/
"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _DPParseInstance = require("absol/src/Pharse/DPParseInstance");

/*********************************
 * EXPRESSION
 */
var operatorOrder = {
  'not': 4,
  '*': 5,
  '/': 5,
  'mod': 5,
  '+': 6,
  '-': 6,
  '<': 9,
  '>': 9,
  '<=': 9,
  '>=': 9,
  '==': 9,
  '!=': 9,
  'and': 14,
  'or': 15,
  'xor': 15
};
var elementRegexes = [['string', /("(?:[^"\\]|\\.)*?")|('(?:[^'\\]|\\.)*?')/], ['number', /(\d+([.]\d*)?([eE][+-]?\d+)?|[.]\d+([eE][+-]?\d+)?)/], ['word', /[_a-zA-Z][_a-zA-Z0-9]*/], ['dsymbol', /\+\+|--/], ['symbol', /[^\s_a-zA-Z0-9]/], ['skip', /[\s\r\n]+/]];
var rules = [];
rules.push({
  target: 'ident',
  elements: ['.word'],
  toAST: function (parsedNode) {
    return {
      type: 'Identifier',
      name: parsedNode.children[0].content
    };
  }
});
rules.push({
  target: 'args_list',
  elements: ['exp'],
  toAST: function (parsedNode) {
    return (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[0]);
  },
  toASTChain: function (parsedNode) {
    return [(0, _DPParseInstance.parsedNodeToAST)(parsedNode)];
  }
});
rules.push({
  target: 'args_list',
  elements: ['args_list', '_,', 'exp'],
  toASTChain: function (parsedNode) {
    return parsedNode.children[0].rule.toASTChain(parsedNode.children[0]).concat((0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[2]));
  }
});
rules.push({
  target: 'function_call',
  elements: ['ident', '_(', 'args_list', '_)'],
  toAST: function (parsedNode) {
    return {
      type: 'CallExpression',
      arguments: parsedNode.children[2].rule.toASTChain(parsedNode.children[2]),
      callee: (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[0])
    };
  }
});
rules.push({
  target: 'function_call',
  elements: ['ident', '_(', '_)'],
  toAST: function (parsedNode) {}
});
rules.push({
  target: 'exp',
  elements: ['ident'],
  toAST: function (parsedNode) {
    return (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[0]);
  }
});
rules.push({
  target: 'number',
  elements: ['.number'],
  toAST: function (parsedNode) {
    return {
      type: 'NumericLiteral',
      value: parseFloat(parsedNode.children[0].content)
    };
  }
});
rules.push({
  target: 'exp',
  elements: ['number'],
  toAST: function (parsedNode) {
    return (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[0]);
  }
});
['+', '-', '*', '/', 'Mod', 'And', 'Or', 'Xor', 'Not'].forEach(function (op) {
  rules.push({
    target: 'bin_op',
    elements: ['_' + op],
    toAST: function (parsedNode) {
      return {
        type: "BinaryOperator",
        content: op
      };
    }
  });
});
rules.push({
  target: 'exp',
  elements: ['exp', 'bin_op', 'exp'],
  toASTChain: function (parseNode) {
    var res = [];

    if (parseNode.children[0].rule === this) {
      res = res.concat(this.toASTChain(parseNode.children[0]));
    } else {
      res.push((0, _DPParseInstance.parsedNodeToAST)(parseNode.children[0]));
    }

    res.push(parseNode.children[1].children[0].content);

    if (parseNode.children[2].rule === this) {
      res = res.concat(this.toASTChain(parseNode.children[2]));
    } else {
      res.push((0, _DPParseInstance.parsedNodeToAST)(parseNode.children[2]));
    }

    return res;
  },
  toAST: function (parsedNode) {
    var chain = this.toASTChain(parsedNode);
    var stack = [];
    var item;
    var newNode;

    while (chain.length > 0) {
      item = chain.shift();

      if (typeof item === "string") {
        while (stack.length >= 3 && operatorOrder[stack[stack.length - 2]] <= operatorOrder[item]) {
          newNode = {
            type: 'BinaryExpression'
          };
          newNode.right = stack.pop();
          newNode.operator = stack.pop();
          newNode.left = stack.pop();
          stack.push(newNode);
        }
      }

      stack.push(item);
    }

    while (stack.length >= 3) {
      newNode = {
        type: 'BinaryExpression'
      };
      newNode.right = stack.pop();
      newNode.operator = stack.pop();
      newNode.left = stack.pop();
      stack.push(newNode);
    }

    return stack.pop();
  }
});
rules.push({
  target: 'exp',
  elements: ['function_call'],
  toAST: function (parsedNode) {
    return (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[0]);
  }
});
rules.push({
  target: 'bracket_group',
  elements: ['_(', 'exp', '_)'],
  toAST: function (parsedNode) {
    return (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[1]);
  }
});
rules.push({
  target: 'exp',
  elements: ['bracket_group'],
  toAST: function (parsedNode) {
    return (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[1]);
  }
});
rules.push({
  target: 'exp',
  elements: ['_(', 'exp', '_)'],
  toAST: function (parsedNode) {
    return (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[1]);
  }
});
['+', '-'].forEach(function (op) {
  ['number', 'bracket_group', 'ident', 'function_call'].forEach(function (arg) {
    rules.push({
      target: 'exp',
      elements: ['_' + op, arg],
      toAST: function (parsedNode) {
        return {
          type: 'UnaryExpression',
          argument: (0, _DPParseInstance.parsedNodeToAST)(parsedNode.children[1]),
          operator: op
        };
      }
    });
  });
});
/**************FOR QUICK PARSING***********************/

rules.push({
  target: 'exp',
  elements: ['.constance'],
  toAST: function (parsedNode) {
    return parsedNode.children[0];
  },
  toASTChain: function (parsedNode) {
    return [parsedNode.children[0]];
  }
});
var _default = {
  elementRegexes: elementRegexes,
  rules: rules
};
exports.default = _default;