@jorgsowa/php-parser 3.2.5-1

package/src/index.js

@@ -0,0 +1,239 @@
+/**
+ * Copyright (C) 2020 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+const lexer = require("./lexer");
+const parser = require("./parser");
+const tokens = require("./tokens");
+const AST = require("./ast");
+
+/**
+ * @private
+ */
+function combine(src, to) {
+  const keys = Object.keys(src);
+  let i = keys.length;
+  while (i--) {
+    const k = keys[i];
+    const val = src[k];
+    if (val === null) {
+      delete to[k];
+    } else if (typeof val === "function") {
+      to[k] = val.bind(to);
+    } else if (Array.isArray(val)) {
+      to[k] = Array.isArray(to[k]) ? to[k].concat(val) : val;
+    } else if (typeof val === "object") {
+      to[k] = typeof to[k] === "object" ? combine(val, to[k]) : val;
+    } else {
+      to[k] = val;
+    }
+  }
+  return to;
+}
+
+/**
+ * Initialise a new parser instance with the specified options
+ *
+ * @class
+ * @memberOf module:php-parser
+ * @tutorial Engine
+ * @example
+ * var parser = require('php-parser');
+ * var instance = new parser({
+ *   parser: {
+ *     extractDoc: true,
+ *     suppressErrors: true,
+ *     version: 704 // or '7.4'
+ *   },
+ *   ast: {
+ *     withPositions: true
+ *   },
+ *   lexer: {
+ *     short_tags: true,
+ *     asp_tags: true
+ *   }
+ * });
+ *
+ * var evalAST = instance.parseEval('some php code');
+ * var codeAST = instance.parseCode('<?php some php code', 'foo.php');
+ * var tokens = instance.tokenGetAll('<?php some php code');
+ *
+ * @param {Object} options - List of options
+ * @property {Lexer} lexer
+ * @property {Parser} parser
+ * @property {AST} ast
+ * @property {Object} tokens
+ */
+const Engine = function (options) {
+  if (typeof this === "function") {
+    return new this(options);
+  }
+  this.tokens = tokens;
+  this.lexer = new lexer(this);
+  this.ast = new AST();
+  this.parser = new parser(this.lexer, this.ast);
+  if (options && typeof options === "object") {
+    // disable php7 from lexer if already disabled from parser
+    if (options.parser) {
+      if (!options.lexer) {
+        options.lexer = {};
+      }
+      if (options.parser.version) {
+        if (typeof options.parser.version === "string") {
+          let version = options.parser.version.split(".");
+          version = parseInt(version[0]) * 100 + parseInt(version[1]);
+          if (isNaN(version)) {
+            throw new Error("Bad version number : " + options.parser.version);
+          } else {
+            options.parser.version = version;
+          }
+        } else if (typeof options.parser.version !== "number") {
+          throw new Error("Expecting a number for version");
+        }
+        if (options.parser.version < 500 || options.parser.version > 900) {
+          throw new Error("Can only handle versions between 5.x to 8.x");
+        }
+      }
+    }
+    combine(options, this);
+
+    // same version flags based on parser options
+    this.lexer.version = this.parser.version;
+  }
+};
+
+/**
+ * Check if the inpyt is a buffer or a string
+ * @private
+ * @param  {Buffer|String} buffer Input value that can be either a buffer or a string
+ * @return {String}   Returns the string from input
+ */
+const getStringBuffer = function (buffer) {
+  return typeof buffer.write === "function" ? buffer.toString() : buffer;
+};
+
+/**
+ * Creates a new instance (Helper)
+ * @param {Object} options
+ * @return {Engine}
+ * @private
+ */
+Engine.create = function (options) {
+  return new Engine(options);
+};
+
+/**
+ * Evaluate the buffer
+ * @private
+ */
+Engine.parseEval = function (buffer, options) {
+  const self = new Engine(options);
+  return self.parseEval(buffer);
+};
+
+/**
+ * Parse an evaluating mode string (no need to open php tags)
+ * @param {String} buffer
+ * @return {Program}
+ */
+Engine.prototype.parseEval = function (buffer) {
+  this.lexer.mode_eval = true;
+  this.lexer.all_tokens = false;
+  buffer = getStringBuffer(buffer);
+  return this.parser.parse(buffer, "eval");
+};
+
+/**
+ * Static function that parse a php code with open/close tags
+ * @private
+ */
+Engine.parseCode = function (buffer, filename, options) {
+  if (typeof filename === "object" && !options) {
+    // retro-compatibility
+    options = filename;
+    filename = "unknown";
+  }
+  const self = new Engine(options);
+  return self.parseCode(buffer, filename);
+};
+
+/**
+ * Function that parse a php code with open/close tags
+ *
+ * Sample code :
+ * ```php
+ * <?php $x = 1;
+ * ```
+ *
+ * Usage :
+ * ```js
+ * var parser = require('php-parser');
+ * var phpParser = new parser({
+ *   // some options
+ * });
+ * var ast = phpParser.parseCode('...php code...', 'foo.php');
+ * ```
+ * @param {String} buffer - The code to be parsed
+ * @param {String} filename - Filename
+ * @return {Program}
+ */
+Engine.prototype.parseCode = function (buffer, filename) {
+  this.lexer.mode_eval = false;
+  this.lexer.all_tokens = false;
+  buffer = getStringBuffer(buffer);
+  return this.parser.parse(buffer, filename);
+};
+
+/**
+ * Split the buffer into tokens
+ * @private
+ */
+Engine.tokenGetAll = function (buffer, options) {
+  const self = new Engine(options);
+  return self.tokenGetAll(buffer);
+};
+
+/**
+ * Extract tokens from the specified buffer.
+ * > Note that the output tokens are *STRICLY* similar to PHP function `token_get_all`
+ * @param {string} buffer
+ * @return {Array<string|string[]>} - Each item can be a string or an array with following informations [token_name, text, line_number]
+ */
+Engine.prototype.tokenGetAll = function (buffer) {
+  this.lexer.mode_eval = false;
+  this.lexer.all_tokens = true;
+  buffer = getStringBuffer(buffer);
+  const EOF = this.lexer.EOF;
+  const names = this.tokens.values;
+  this.lexer.setInput(buffer);
+  let token = this.lexer.lex() || EOF;
+  const result = [];
+  while (token != EOF) {
+    let entry = this.lexer.yytext;
+    if (Object.prototype.hasOwnProperty.call(names, token)) {
+      entry = [names[token], entry, this.lexer.yylloc.first_line];
+    }
+    result.push(entry);
+    token = this.lexer.lex() || EOF;
+  }
+  return result;
+};
+
+/** @module php-parser */
+
+// exports the function
+module.exports = Engine;
+
+// makes libraries public
+module.exports.tokens = tokens;
+module.exports.lexer = lexer;
+module.exports.AST = AST;
+module.exports.parser = parser;
+module.exports.combine = combine;
+module.exports.Engine = Engine;
+
+// allow the default export in index.d.ts
+module.exports.default = Engine;

package/src/lexer/attribute.js

@@ -0,0 +1,85 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+module.exports = {
+  attributeIndex: 0,
+  attributeListDepth: {},
+  matchST_ATTRIBUTE() {
+    let ch = this.input();
+    if (this.is_WHITESPACE()) {
+      do {
+        ch = this.input();
+      } while (this.is_WHITESPACE());
+      this.unput(1);
+      return null;
+    }
+    switch (ch) {
+      case "]":
+        if (this.attributeListDepth[this.attributeIndex] === 0) {
+          delete this.attributeListDepth[this.attributeIndex];
+          this.attributeIndex--;
+          this.popState();
+        } else {
+          /* istanbul ignore next */
+          this.attributeListDepth[this.attributeIndex]--;
+        }
+        return "]";
+      case "(":
+      case ")":
+      case ":":
+      case "=":
+      case "|":
+      case "&":
+      case "^":
+      case "-":
+      case "+":
+      case "*":
+      case "%":
+      case "~":
+      case "<":
+      case ">":
+      case "!":
+      case ".":
+        return this.consume_TOKEN();
+      case "[":
+        this.attributeListDepth[this.attributeIndex]++;
+        return "[";
+      case ",":
+        return ",";
+      case '"':
+        return this.ST_DOUBLE_QUOTES();
+      case "'":
+        return this.T_CONSTANT_ENCAPSED_STRING();
+      case "/":
+        if (this._input[this.offset] === "/") {
+          return this.T_COMMENT();
+        } else if (this._input[this.offset] === "*") {
+          this.input();
+          return this.T_DOC_COMMENT();
+        } else {
+          return this.consume_TOKEN();
+        }
+    }
+    if (this.is_LABEL_START() || ch === "\\") {
+      while (this.offset < this.size) {
+        const ch = this.input();
+        if (!(this.is_LABEL() || ch === "\\")) {
+          if (ch) this.unput(1);
+          break;
+        }
+      }
+      return this.T_STRING();
+    } else if (this.is_NUM()) {
+      return this.consume_NUM();
+    }
+
+    /* istanbul ignore next */
+    throw new Error(
+      `Bad terminal sequence "${ch}" at line ${this.yylineno} (offset ${this.offset})`,
+    );
+  },
+};

package/src/lexer/comments.js

@@ -0,0 +1,63 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+module.exports = {
+  /*
+   * Reads a single line comment
+   */
+  T_COMMENT() {
+    while (this.offset < this.size) {
+      const ch = this.input();
+      if (ch === "\n" || ch === "\r") {
+        return this.tok.T_COMMENT;
+      } else if (
+        ch === "?" &&
+        !this.aspTagMode &&
+        this._input[this.offset] === ">"
+      ) {
+        this.unput(1);
+        return this.tok.T_COMMENT;
+      } else if (
+        ch === "%" &&
+        this.aspTagMode &&
+        this._input[this.offset] === ">"
+      ) {
+        this.unput(1);
+        return this.tok.T_COMMENT;
+      }
+    }
+    return this.tok.T_COMMENT;
+  },
+  /*
+   * Behaviour : https://github.com/php/php-src/blob/master/Zend/zend_language_scanner.l#L1927
+   */
+  T_DOC_COMMENT() {
+    let ch = this.input();
+    let token = this.tok.T_COMMENT;
+    if (ch === "*") {
+      // started with '/*' , check is next is '*'
+      ch = this.input();
+      if (this.is_WHITESPACE()) {
+        // check if next is WHITESPACE
+        token = this.tok.T_DOC_COMMENT;
+      }
+      if (ch === "/") {
+        return token;
+      } else {
+        this.unput(1); // reset
+      }
+    }
+    while (this.offset < this.size) {
+      ch = this.input();
+      if (ch === "*" && this._input[this.offset] === "/") {
+        this.input();
+        break;
+      }
+    }
+    return token;
+  },
+};

package/src/lexer/initial.js

@@ -0,0 +1,64 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+module.exports = {
+  nextINITIAL() {
+    if (
+      this.conditionStack.length > 1 &&
+      this.conditionStack[this.conditionStack.length - 1] === "INITIAL"
+    ) {
+      // Return to HEREDOC/ST_DOUBLE_QUOTES mode
+      this.popState();
+    } else {
+      this.begin("ST_IN_SCRIPTING");
+    }
+    return this;
+  },
+  matchINITIAL() {
+    while (this.offset < this.size) {
+      let ch = this.input();
+      if (ch == "<") {
+        ch = this.ahead(1);
+        if (ch == "?") {
+          if (this.tryMatch("?=")) {
+            this.unput(1)
+              .appendToken(this.tok.T_OPEN_TAG_WITH_ECHO, 3)
+              .nextINITIAL();
+            break;
+          } else if (this.tryMatchCaseless("?php")) {
+            ch = this._input[this.offset + 4];
+            if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
+              this.unput(1).appendToken(this.tok.T_OPEN_TAG, 6).nextINITIAL();
+              break;
+            }
+          }
+          if (this.short_tags) {
+            this.unput(1).appendToken(this.tok.T_OPEN_TAG, 2).nextINITIAL();
+            break;
+          }
+        } else if (this.asp_tags && ch == "%") {
+          if (this.tryMatch("%=")) {
+            this.aspTagMode = true;
+            this.unput(1)
+              .appendToken(this.tok.T_OPEN_TAG_WITH_ECHO, 3)
+              .nextINITIAL();
+            break;
+          } else {
+            this.aspTagMode = true;
+            this.unput(1).appendToken(this.tok.T_OPEN_TAG, 2).nextINITIAL();
+            break;
+          }
+        }
+      }
+    }
+    if (this.yytext.length > 0) {
+      return this.tok.T_INLINE_HTML;
+    } else {
+      return false;
+    }
+  },
+};

package/src/lexer/numbers.js

@@ -0,0 +1,171 @@
+/**
+ * Copyright (C) 2018 Glayzzle (BSD3 License)
+ * @authors https://github.com/glayzzle/php-parser/graphs/contributors
+ * @url http://glayzzle.com
+ */
+"use strict";
+
+/* istanbul ignore else  */
+let MAX_LENGTH_OF_LONG = 10;
+let long_min_digits = "2147483648";
+if (process.arch == "x64") {
+  MAX_LENGTH_OF_LONG = 19;
+  long_min_digits = "9223372036854775808";
+}
+
+module.exports = {
+  consume_NUM() {
+    let ch = this.yytext[0];
+    let hasPoint = ch === ".";
+    if (ch === "0") {
+      ch = this.input();
+      // check if hexa
+      if (ch === "x" || ch === "X") {
+        ch = this.input();
+        if (ch !== "_" && this.is_HEX()) {
+          return this.consume_HNUM();
+        } else {
+          this.unput(ch ? 2 : 1);
+        }
+        // check binary notation
+      } else if (ch === "b" || ch === "B") {
+        ch = this.input();
+        if ((ch !== "_" && ch === "0") || ch === "1") {
+          return this.consume_BNUM();
+        } else {
+          this.unput(ch ? 2 : 1);
+        }
+      } else if (ch === "o" || ch === "O") {
+        ch = this.input();
+        if (ch !== "_" && this.is_OCTAL()) {
+          return this.consume_ONUM();
+        } else {
+          this.unput(ch ? 2 : 1);
+        }
+      } else if (!this.is_NUM()) {
+        if (ch) this.unput(1);
+      }
+    }
+
+    while (this.offset < this.size) {
+      const prev = ch;
+      ch = this.input();
+
+      if (ch === "_") {
+        if (prev === "_") {
+          // restriction : next to underscore / 1__1;
+          this.unput(2); // keep 1
+          break;
+        }
+        if (prev === ".") {
+          // next to decimal point  "1._0"
+          this.unput(1); // keep 1.
+          break;
+        }
+        if (prev === "e" || prev === "E") {
+          // next to e "1e_10"
+          this.unput(2); // keep 1
+          break;
+        }
+      } else if (ch === ".") {
+        if (hasPoint) {
+          // no multiple points "1.0.5"
+          this.unput(1); // keep 1.0
+          break;
+        }
+        if (prev === "_") {
+          // next to decimal point  "1_.0"
+          this.unput(2); // keep 1
+          break;
+        }
+        hasPoint = true;
+        continue;
+      } else if (ch === "e" || ch === "E") {
+        if (prev === "_") {
+          // next to e "1_e10"
+          this.unput(1);
+          break;
+        }
+        let undo = 2;
+        ch = this.input();
+        if (ch === "+" || ch === "-") {
+          // 1e-5
+          undo = 3;
+          ch = this.input();
+        }
+        if (this.is_NUM_START()) {
+          this.consume_LNUM();
+          return this.tok.T_DNUMBER;
+        }
+        this.unput(ch ? undo : undo - 1); // keep only 1
+        break;
+      }
+
+      if (!this.is_NUM()) {
+        // example : 10.0a
+        if (ch) this.unput(1); // keep 10.0
+        break;
+      }
+    }
+
+    if (hasPoint) {
+      return this.tok.T_DNUMBER;
+    } else if (this.yytext.length < MAX_LENGTH_OF_LONG - 1) {
+      return this.tok.T_LNUMBER;
+    } else {
+      if (
+        this.yytext.length < MAX_LENGTH_OF_LONG ||
+        (this.yytext.length == MAX_LENGTH_OF_LONG &&
+          this.yytext < long_min_digits)
+      ) {
+        return this.tok.T_LNUMBER;
+      }
+      return this.tok.T_DNUMBER;
+    }
+  },
+  // read hexa
+  consume_HNUM() {
+    while (this.offset < this.size) {
+      const ch = this.input();
+      if (!this.is_HEX()) {
+        if (ch) this.unput(1);
+        break;
+      }
+    }
+    return this.tok.T_LNUMBER;
+  },
+  // read a generic number
+  consume_LNUM() {
+    while (this.offset < this.size) {
+      const ch = this.input();
+      if (!this.is_NUM()) {
+        if (ch) this.unput(1);
+        break;
+      }
+    }
+    return this.tok.T_LNUMBER;
+  },
+  // read binary
+  consume_BNUM() {
+    let ch;
+    while (this.offset < this.size) {
+      ch = this.input();
+      if (ch !== "0" && ch !== "1" && ch !== "_") {
+        if (ch) this.unput(1);
+        break;
+      }
+    }
+    return this.tok.T_LNUMBER;
+  },
+  // read an octal number
+  consume_ONUM() {
+    while (this.offset < this.size) {
+      const ch = this.input();
+      if (!this.is_OCTAL()) {
+        if (ch) this.unput(1);
+        break;
+      }
+    }
+    return this.tok.T_LNUMBER;
+  },
+};