@openxiot/xiot-core-spec-ts 0.0.2

package/dist/xiot/core/spec/typedef/rule/parser/token/Token.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = exports.TokenType = void 0;
+const AnyValue_1 = require("../../../operation/value/AnyValue");
+const ReverseValue_1 = require("../../../operation/value/ReverseValue");
+const AutoscalingValue_1 = require("../../../operation/value/AutoscalingValue");
+var TokenType;
+(function (TokenType) {
+    TokenType["KEY_IF"] = "KEY_IF";
+    TokenType["KEY_THEN"] = "KEY_THEN";
+    TokenType["KEY_ENDIF"] = "KEY_ENDIF";
+    TokenType["KEY_AND"] = "KEY_AND";
+    TokenType["KEY_SLEEP"] = "KEY_SLEEP";
+    TokenType["KEY_REMIND"] = "KEY_REMIND";
+    TokenType["KEY_ANY"] = "KEY_ANY";
+    TokenType["KEY_REVERSE"] = "KEY_REVERSE";
+    TokenType["KEY_AUTOSCALING"] = "KEY_AUTOSCALING";
+    TokenType["XID3"] = "XID3";
+    TokenType["EXID"] = "EXID";
+    TokenType["OPERATE"] = "OPERATE";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["STRING"] = "STRING";
+    TokenType["TRUE"] = "TRUE";
+    TokenType["FALSE"] = "FALSE";
+    TokenType["LEFT_PARENTHESES"] = "LEFT_PARENTHESES";
+    TokenType["RIGHT_PARENTHESES"] = "RIGHT_PARENTHESES";
+    // logical operator
+    TokenType["OP_AND"] = "OP_AND";
+    TokenType["OP_OR"] = "OP_OR";
+    // comparison operator
+    TokenType["OP_EQUAL"] = "OP_EQUAL";
+    TokenType["OP_NOT_EQUAL"] = "OP_NOT_EQUAL";
+    TokenType["OP_GREATER"] = "OP_GREATER";
+    TokenType["OP_GREATER_OR_EQUAL"] = "OP_GREATER_OR_EQUAL";
+    TokenType["OP_LESS"] = "OP_LESS";
+    TokenType["OP_LESS_OR_EQUAL"] = "OP_LESS_OR_EQUAL";
+    // for event
+    TokenType["LEFT_BRACE"] = "LEFT_BRACE";
+    TokenType["RIGHT_BRACE"] = "RIGHT_BRACE";
+    TokenType["HASH"] = "HASH";
+    TokenType["ASSIGNMENT"] = "ASSIGNMENT";
+    TokenType["SEMICOLON"] = "SEMICOLON";
+    TokenType["COMMA"] = "COMMA";
+    // for Parser0
+    TokenType["EVENT_VALUE"] = "EVENT_VALUE";
+})(TokenType || (exports.TokenType = TokenType = {}));
+class Token {
+    constructor(type, offset, length, bytes) {
+        // for Parser0
+        this.arguments = new Map();
+        this._type = type;
+        this._offset = offset;
+        this._length = length;
+        if (bytes !== undefined && bytes !== null) {
+            this._bytes = new Array(...bytes.slice(offset, offset + length));
+        }
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+    }
+    get bytes() {
+        return this._bytes;
+    }
+    set bytes(value) {
+        this._bytes = value;
+    }
+    get offset() {
+        return this._offset;
+    }
+    set offset(value) {
+        this._offset = value;
+    }
+    get length() {
+        return this._length;
+    }
+    set length(value) {
+        this._length = value;
+    }
+    toString() {
+        if (this.type == TokenType.EVENT_VALUE) {
+            let b = '{';
+            let i = 1;
+            const size = this.arguments.size;
+            for (const argument of this.arguments.values()) {
+                b += argument.toString();
+                if (i < size) {
+                    b += ', ';
+                }
+                i++;
+            }
+            b += '}';
+            return b.toString();
+        }
+        if (this.bytes !== null && this.bytes !== undefined) {
+            return this.bytes.join('');
+        }
+        return 'null';
+    }
+    /**
+     * 操作数: 数值
+     * @return boolean
+     */
+    isValue() {
+        switch (this.type) {
+            case TokenType.NUMBER:
+            case TokenType.STRING:
+            case TokenType.TRUE:
+            case TokenType.FALSE:
+            case TokenType.KEY_ANY:
+            case TokenType.KEY_REVERSE:
+            case TokenType.KEY_AUTOSCALING:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * 运算符优先级
+     * @return int
+     */
+    priority() {
+        switch (this.type) {
+            case TokenType.LEFT_PARENTHESES:
+            case TokenType.RIGHT_PARENTHESES:
+                return 4;
+            case TokenType.OP_EQUAL:
+            case TokenType.OP_NOT_EQUAL:
+            case TokenType.OP_GREATER:
+            case TokenType.OP_GREATER_OR_EQUAL:
+            case TokenType.OP_LESS:
+            case TokenType.OP_LESS_OR_EQUAL:
+                return 2;
+            case TokenType.OP_AND:
+            case TokenType.OP_OR:
+                return 1;
+            default:
+                return 0;
+        }
+    }
+    /**
+     * 运算符
+     * @return boolean
+     */
+    isOperator() {
+        switch (this.type) {
+            case TokenType.OP_AND:
+            case TokenType.OP_OR:
+            case TokenType.OP_EQUAL:
+            case TokenType.OP_NOT_EQUAL:
+            case TokenType.OP_GREATER:
+            case TokenType.OP_GREATER_OR_EQUAL:
+            case TokenType.OP_LESS:
+            case TokenType.OP_LESS_OR_EQUAL:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * 操作数
+     * @return boolean
+     */
+    isOperand() {
+        switch (this.type) {
+            case TokenType.NUMBER:
+            case TokenType.STRING:
+            case TokenType.TRUE:
+            case TokenType.FALSE:
+            case TokenType.XID3:
+            case TokenType.EXID:
+            case TokenType.EVENT_VALUE:
+            case TokenType.KEY_ANY:
+            case TokenType.KEY_REVERSE:
+            case TokenType.KEY_AUTOSCALING:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * 运算符：逻辑运算符
+     * @return boolean
+     */
+    isLogicalOperator() {
+        switch (this.type) {
+            case TokenType.OP_AND:
+            case TokenType.OP_OR:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * 运算符：比较运算符
+     * @return boolean
+     */
+    isComparisonOperator() {
+        switch (this.type) {
+            case TokenType.OP_EQUAL:
+            case TokenType.OP_GREATER:
+            case TokenType.OP_GREATER_OR_EQUAL:
+            case TokenType.OP_LESS:
+            case TokenType.OP_LESS_OR_EQUAL:
+            case TokenType.OP_NOT_EQUAL:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * 括号
+     * @return boolean
+     */
+    isParentheses() {
+        switch (this.type) {
+            case TokenType.LEFT_PARENTHESES:
+            case TokenType.RIGHT_PARENTHESES:
+                return true;
+            default:
+                return false;
+        }
+    }
+    getInteger() {
+        const value = String(this.bytes.join(''));
+        if (this.type !== TokenType.NUMBER) {
+            throw new Error('表达式错误，token不是数值: ' + value);
+        }
+        if (value.indexOf('.') !== -1) {
+            throw new Error('表达式错误，token不是整数: ' + value);
+        }
+        return parseInt(value, 10);
+    }
+    getString() {
+        return String(this.bytes.join(''));
+    }
+    getValue() {
+        const value = String(this.bytes.join(''));
+        switch (this.type) {
+            case TokenType.NUMBER:
+                if (value.indexOf('.') !== -1) {
+                    return parseFloat(value);
+                }
+                else {
+                    return parseInt(value, 10);
+                }
+            // BUG，居然和上面的判断是相反的
+            // return value.indexOf(".") != -1 ? parseFloat(value) : parseInt(value);
+            case TokenType.STRING:
+                return value;
+            case TokenType.TRUE:
+                return true;
+            case TokenType.FALSE:
+                return false;
+            case TokenType.KEY_ANY:
+                return new AnyValue_1.AnyValue();
+            case TokenType.KEY_REVERSE:
+                return new ReverseValue_1.ReverseValue();
+            case TokenType.KEY_AUTOSCALING:
+                return new AutoscalingValue_1.AutoscalingValue();
+            default:
+                throw new Error('表达式错误，token不是合法的属性值: ' + value);
+        }
+        return [];
+    }
+}
+exports.Token = Token;

package/dist/xiot/core/spec/typedef/rule/parser/token/Tokenizer.d.ts

@@ -0,0 +1,29 @@
+import { Token } from './Token';
+export declare class Tokenizer {
+    private tokens;
+    private bytes;
+    private current;
+    parse(expression: string): Array<Token>;
+    private parseToken;
+    private parseTokenMonocase;
+    private parseTokenTrue;
+    private parseTokenFalse;
+    private parseTokenIF;
+    private parseTokenTHEN;
+    private parseTokenENDIF;
+    private parseTokenSLEEP;
+    private parseTokenREMIND_or_REVERSE;
+    private parseTokenAND_or_ANY_AUTOSCALING;
+    private parseTokenString;
+    private parseTokenNumber;
+    private parseTokeAnd;
+    private parseTokenOR;
+    private parseTokenNOT_or_NOT_EQUAL;
+    private parseTokenEQUAL_or_ASSIGNMENT_or_OPERATE;
+    private parseTokenGreater_or_GE;
+    private parseTokenLess_or_LE;
+    private parseTokenExternalID;
+    private parseTokenID3;
+    private is_hex;
+    private is_print;
+}