@freelog/freelog-cg-collection 1.0.0

package/CollectionPolicyCustomVisitor.js

@@ -0,0 +1,544 @@
+const {CollectionPolicyVisitor} = require("./gen/CollectionPolicyVisitor");
+
+class CollectionPolicyCustomVisitor extends CollectionPolicyVisitor {
+    constructor() {
+        super();
+        this.audienceSection = {};
+        this.varDeclarationList = [];
+        this.stateMachine = [];
+
+        this.currentState = null;
+        this.currentStateObj = null;
+        this.currentEventElem = null;
+    }
+
+    visitAudience_clause(ctx) {
+        this.audienceSection["audiences"] = ctx.audience().map(elem => elem.getText());
+
+        return super.visitAudience_clause(ctx);
+    }
+
+    visitAudience_condition(ctx) {
+        if (ctx.expression_param_list() != null) {
+            this.audienceSection["conditions"] = this.visitExpression_param_list(ctx.expression_param_list());
+        } else {
+            this.audienceSection["conditions"] = [];
+        }
+
+        return super.visitAudience_condition(ctx);
+    }
+
+    visitGlobal_variable_definition(ctx) {
+        let varElem = {
+            type: "varGlobal",
+            content: ctx.getText(),
+            varName: ctx.global_variable_name().getText(),
+            varValue: ctx.assignment_clause().getText(),
+            varValueObj: this.visitAssignment_clause(ctx.assignment_clause())
+        };
+
+        this.varDeclarationList.push(varElem);
+
+        return varElem;
+    }
+
+    visitMacro_variable_definition(ctx) {
+        let varElem = {
+            type: "varMacro",
+            content: ctx.getText(),
+            varName: ctx.macro_variable_name().getText(),
+            varValue: ctx.assignment_clause().getText(),
+            varValueObj: this.visitAssignment_clause(ctx.assignment_clause())
+        };
+
+        this.varDeclarationList.push(varElem);
+
+        return varElem;
+    }
+
+    visitExpression_definition(ctx) {
+        let builtInFunctionResult = this.visitBuilt_in_function(ctx.expression_def_declaration().built_in_function());
+
+        let varElem = {
+            type: "expCustom",
+            content: ctx.getText(),
+            varName: builtInFunctionResult["funcName"],
+            varValue: ctx.condition_expression().getText(),
+            varValueObj: this.visitCondition_expression(ctx.condition_expression())
+        };
+        let paramList = [];
+        for (let i = 0; i < builtInFunctionResult["paramList"].length; i++) {
+            let paramElem = builtInFunctionResult["paramList"][i];
+            paramList.push(paramElem["paramValue"]);
+        }
+        varElem["paramList"] = paramList;
+
+        this.varDeclarationList.push(varElem);
+
+        return varElem;
+    }
+
+    visitState_definition(ctx) {
+        this.currentState = ctx.state_name().getText();
+        this.currentStateObj = {stateName: this.currentState, assignments: [], events: []};
+        this.stateMachine.push(this.currentStateObj);
+
+        return super.visitState_definition(ctx);
+    }
+
+    visitFsmVarAssignment(ctx) {
+        let assignmentElem = {
+            type: "varAssigment",
+            content: ctx.getText(),
+            varName: ctx.variable_assignment().variable_chain().getText(),
+            varValue: ctx.variable_assignment().assignment_clause().getText(),
+            varValueObj: super.visitAssignment_clause(ctx.variable_assignment().assignment_clause())
+        };
+
+        this.currentStateObj["assignments"].push(assignmentElem);
+
+        return assignmentElem;
+    }
+
+    visitFsmVarInitial(ctx) {
+        let assignmentElem = {
+            type: "varInitial",
+            content: ctx.getText(),
+            varName: ctx.local_variable_name().getText(),
+            varValue: ctx.assignment_clause().getText(),
+            varValueObj: super.visitAssignment_clause(ctx.assignment_clause())
+        };
+
+        this.currentStateObj["assignments"].push(assignmentElem);
+
+        return assignmentElem;
+    }
+
+    visitEventNormal(ctx) {
+        let builtInFunctionResult = this.visitBuilt_in_function(ctx.event().built_in_function());
+
+        this.currentEventElem = {
+            type: "normal",
+            content: ctx.getText(),
+            eventName: builtInFunctionResult["funcName"],
+            eventParamList: builtInFunctionResult["paramList"],
+            toState: ctx.state_name().getText(),
+            actions: []
+        };
+        if (ctx.event().event_path() != null) {
+            this.currentEventElem["eventPath"] = ctx.event().event_path().getText();
+        }
+        if (ctx.action_section() != null) {
+            this.visitAction_section(ctx.action_section());
+        }
+
+        this.currentStateObj["events"].push(this.currentEventElem);
+
+        return this.currentEventElem;
+    }
+
+    visitEventTerminate(ctx) {
+        this.currentEventElem = {
+            type: "terminate",
+            content: ctx.getText(),
+            eventName: ctx.TERMINATE().getText()
+        };
+
+        this.currentStateObj["events"].push(this.currentEventElem);
+
+        return this.currentEventElem;
+    }
+
+    visitAction_section(ctx) {
+        this.currentEventElem["actions"] = [];
+
+        return super.visitAction_section(ctx);
+    }
+
+    visitFsmActionFunctionCall(ctx) {
+        let actionElem = {
+            type: "functionCall",
+            content: ctx.getText(),
+            actionObj: this.visitFunction_call(ctx.function_call())
+        };
+
+        this.currentEventElem["actions"].push(actionElem);
+
+        return actionElem;
+    }
+
+    visitFsmActionVarAssignment(ctx) {
+        let actionElem = {
+            type: "varAssignment",
+            content: "ctx.getText()",
+            actionObj: {
+                varName: ctx.variable_assignment().variable_chain().getText(),
+                varValue: ctx.variable_assignment().assignment_clause().getText(),
+                varValueObj: this.visitAssignment_clause(ctx.variable_assignment().assignment_clause())
+            }
+        };
+
+        this.currentEventElem["actions"].push(actionElem);
+
+        return actionElem;
+    }
+
+    visitAssignment_clause(ctx) {
+        if (ctx.expression() != null) {
+            return this.visitExpression(ctx.expression());
+        } else if (ctx.boolean_expression() != null) {
+            return this.visitBoolean_expression(ctx.boolean_expression());
+        } else if (ctx.condition_expression() != null) {
+            return this.visitCondition_expression(ctx.condition_expression());
+        } else if (ctx.args_group_expression() != null) {
+            return this.visitArgs_group_expression(ctx.args_group_expression());
+        } else if (ctx.collection_expression() != null) {
+            return this.visitCollection_expression(ctx.collection_expression());
+        } else {
+            return super.visitAssignment_clause(ctx);
+        }
+    }
+
+    visitExpression(ctx) {
+        if (ctx.expression_op() != null) {
+            return {
+                expType: "expOp",
+                var1: this.visitExpression(ctx.expression(0)),
+                var2: this.visitExpression(ctx.expression(1)),
+                op: ctx.expression_op().getText()
+            };
+        } else {
+            return this.visitMultiplying_expression(ctx.multiplying_expression());
+        }
+    }
+
+    visitMultiplying_expression(ctx) {
+        if (ctx.multiplying_expression_op() != null) {
+            return {
+                expType: "expOp",
+                var1: this.visitMultiplying_expression(ctx.multiplying_expression(0)),
+                var2: this.visitMultiplying_expression(ctx.multiplying_expression(1)),
+                op: ctx.multiplying_expression_op().getText()
+            };
+        } else {
+            return this.visitPow_expression(ctx.pow_expression());
+        }
+    }
+
+    visitPow_expression(ctx) {
+        if (ctx.POW() != null) {
+            return {
+                expType: "expOp",
+                var1: this.visitPow_expression(ctx.pow_expression(0)),
+                var2: this.visitPow_expression(ctx.pow_expression(1)),
+                op: ctx.POW().getText()
+            };
+        } else {
+            return this.visitSigned_atom(ctx.signed_atom());
+        }
+    }
+
+    visitSigned_atom(ctx) {
+        if (ctx.function_call() != null) {
+            return this.visitFunction_call(ctx.function_call());
+        } else if (ctx.atom() != null) {
+            return this.visitAtom(ctx.atom());
+        } else if (ctx.signedSymbol != null) {
+            return {
+                expType: "expSigned",
+                var1: this.visitSigned_atom(ctx.signed_atom()),
+                symbol: ctx.signedSymbol.text
+            };
+        } else {
+            return super.visitSigned_atom(ctx);
+        }
+    }
+
+    visitAtom(ctx) {
+        if (ctx.constant() != null) {
+            return super.visitConstant(ctx.constant());
+        } else if (ctx.scientific() != null) {
+            return this.visitScientific(ctx.scientific());
+        } else if (ctx.LPAREN() != null) {
+            return {expType: "expParen", var1: this.visitExpression(ctx.expression())};
+        } else if (ctx.atom_string() != null) {
+            return this.visitAtom_string(ctx.atom_string());
+        } else if (ctx.entity_variable() != null) {
+            return this.visitEntity_variable(ctx.entity_variable());
+        } else if (ctx.variable_chain() != null) {
+            return this.visitVariable_chain(ctx.variable_chain());
+        } else {
+            return super.visitAtom(ctx);
+        }
+    }
+
+    visitBoolean_expression(ctx) {
+        if (ctx.boolean_expression_clause() != null) {
+            return this.visitBoolean_expression_clause(ctx.boolean_expression_clause());
+        }
+
+        if (ctx.LPAREN() != null) {
+            return {
+                expType: "expBooleanParen",
+                var1: this.visitBoolean_expression(ctx.boolean_expression(0))
+            };
+        }
+
+        if (ctx.NOT() != null) {
+            return {
+                expType: "expBooleanOpLogic",
+                var1: this.visitBoolean_expression(ctx.boolean_expression(0)),
+                op: ctx.NOT().getText()
+            };
+        } else if (ctx.AND() != null) {
+            return {
+                expType: "expBooleanOpLogic",
+                var1: this.visitBoolean_expression(ctx.boolean_expression(0)),
+                var2: this.visitBoolean_expression(ctx.boolean_expression(1)),
+                op: ctx.AND().getText()
+            };
+        } else if (ctx.OR() != null) {
+            return {
+                expType: "expBooleanOpLogic",
+                var1: this.visitBoolean_expression(ctx.boolean_expression(0)),
+                var2: this.visitBoolean_expression(ctx.boolean_expression(1)),
+                op: ctx.OR().getText()
+            };
+        }
+
+        return super.visitBoolean_expression(ctx);
+    }
+
+    visitBoolean_expression_clause(ctx) {
+        let result = null;
+        if (ctx.boolean_atom() != null) {
+            result = this.visitExpBooleanSingle(ctx);
+        } else if (ctx.boolean_op_collection() != null) {
+            result = this.visitExpBooleanOpCollection(ctx);
+        } else if (ctx.boolean_op_compare() != null) {
+            result = this.visitExpBooleanOpCompare(ctx);
+        } else {
+            result = super.visitBoolean_expression_clause(ctx);
+        }
+
+        return result;
+    }
+
+    visitExpBooleanSingle(ctx) {
+        return this.visitBoolean_atom(ctx.boolean_atom());
+    }
+
+    visitExpBooleanOpCollection(ctx) {
+        return {
+            expType: "expBooleanOpCollection",
+            var1: this.visitBoolean_atom_or_expression(ctx.boolean_atom_or_expression()),
+            var2: super.visitExpression_collection_clause(ctx.expression_collection_clause()),
+            op: ctx.boolean_op_collection().getText()
+        };
+    }
+
+    visitExpBooleanOpCompare(ctx) {
+        return {
+            expType: "expBooleanOpCompare",
+            var1: this.visitBoolean_atom_or_expression(ctx.boolean_atom_or_expression(0)),
+            var2: this.visitBoolean_atom_or_expression(ctx.boolean_atom_or_expression(1)),
+            op: ctx.boolean_op_compare().getText()
+        };
+    }
+
+    visitBoolean_atom(ctx) {
+        if (ctx.boolean_constant() != null) {
+            return this.visitBoolean_constant(ctx.boolean_constant());
+        }
+        if (ctx.function_call() != null) {
+            return this.visitFunction_call(ctx.function_call());
+        }
+        if (ctx.variable_chain() != null) {
+            return this.visitVariable_chain(ctx.variable_chain());
+        }
+        return super.visitBoolean_atom(ctx);
+    }
+
+    visitBoolean_constant(ctx) {
+        return {expType: "boolean", value: ctx.getText()};
+    }
+
+    visitCondition_expression(ctx) {
+        return {
+            expType: "expCondition",
+            paramList: this.visitCondition_expression_param_list(ctx.condition_expression_param_list())
+        };
+    }
+
+    visitBoolean_atom_or_expression(ctx) {
+        if (ctx.boolean_atom() != null) {
+            return this.visitBoolean_atom(ctx.boolean_atom());
+        }
+        if (ctx.expression() != null) {
+            return this.visitExpression(ctx.expression());
+        }
+    }
+
+    visitCondition_expression_param_list(ctx) {
+        let result = [];
+        if (ctx != null) {
+            ctx.condition_expression_param().forEach(param => {
+                result.push(this.visitCondition_expression_param(param));
+            });
+        }
+
+        return result;
+    }
+
+    visitCondition_expression_param(ctx) {
+        let result = {
+            paramValue: ctx.condition_expression_param_value().getText(),
+            paramValueObj: this.visitCondition_expression_param_value(ctx.condition_expression_param_value())
+        };
+        if (ctx.condition_expression_param_condition() != null) {
+            result["paramCondition"] = ctx.condition_expression_param_condition().getText();
+            result["paramConditionObj"] = this.visitCondition_expression_param_condition(ctx.condition_expression_param_condition());
+        }
+
+        return result;
+    }
+
+    visitCondition_expression_param_condition(ctx) {
+        return this.visitBoolean_expression(ctx.boolean_expression());
+    }
+
+    visitCondition_expression_param_value(ctx) {
+        if (ctx.expression() != null) {
+            return this.visitExpression(ctx.expression());
+        }
+        if (ctx.boolean_expression() != null) {
+            return this.visitBoolean_expression(ctx.boolean_expression());
+        }
+        if (ctx.args_group_expression() != null) {
+            return this.visitArgs_group_expression(ctx.args_group_expression());
+        }
+        if (ctx.collection_expression() != null) {
+            return this.visitCollection_expression(ctx.collection_expression());
+        }
+
+        return super.visitCondition_expression_param_value(ctx);
+    }
+
+    visitArgs_group_expression(ctx) {
+        return {
+            expType: "expArgsGroup",
+            paramList: this.visitArgs_group_param_list(ctx.args_group_param_list())
+        };
+    }
+
+    visitArgs_group_param_list(ctx) {
+        let paramList = [];
+        ctx.args_group_param().forEach(param => {
+            paramList.push({
+                paramName: param.args_group_param_name().getText().substring(1, param.args_group_param_name().getText().length - 1),
+                paramValue: param.args_group_param_value().getText(),
+                paramValueObj: this.visitArgs_group_param_value(param.args_group_param_value())
+            });
+        });
+
+        return paramList;
+    }
+
+    visitArgs_group_param_value(ctx) {
+        if (ctx.expression() != null) {
+            return this.visitExpression(ctx.expression());
+        }
+        if (ctx.boolean_expression() != null) {
+            return this.visitBoolean_expression(ctx.boolean_expression());
+        }
+        if (ctx.condition_expression() != null) {
+            return this.visitCondition_expression(ctx.condition_expression());
+        }
+        if (ctx.collection_expression() != null) {
+            return this.visitCollection_expression(ctx.collection_expression());
+        }
+        return super.visitArgs_group_param_value(ctx);
+    }
+
+    visitCollection_expression(ctx) {
+        let result = this.visitCollection_expression_content(ctx.collection_expression_content());
+        result["expType"] = "expCollection";
+
+        return result;
+    }
+
+    visitCollection_expression_content(ctx) {
+        return {
+            lSymbol: ctx.lSymbol.text,
+            rSymbol: ctx.rSymbol.text,
+            var1: this.visitExpression(ctx.expression(0)),
+            var2: this.visitExpression(ctx.expression(1))
+        };
+    }
+
+    visitExpression_param_list(ctx) {
+        let paramList = [];
+        ctx.expression_param().forEach(expParam => {
+            let paramElem = {
+                paramValue: expParam.assignment_clause().getText(),
+                paramValueObj: this.visitAssignment_clause(expParam.assignment_clause())
+            };
+            if (expParam.expression_param_name() != null) {
+                paramElem["paramName"] = expParam.expression_param_name().getText();
+            }
+            paramList.push(paramElem);
+        });
+
+        return paramList;
+    }
+
+    visitFunction_call(ctx) {
+        let result = this.visitBuilt_in_function(ctx.built_in_function());
+        result["expType"] = "functionCall";
+        if (ctx.variable_chain() != null) {
+            result["varChain"] = ctx.variable_chain().getText();
+        }
+
+        return result;
+    }
+
+    visitBuilt_in_function(ctx) {
+        let result = {funcName: ctx.funcname().getText()};
+
+        if (ctx.expression_param_list() != null) {
+            result["paramList"] = this.visitExpression_param_list(ctx.expression_param_list());
+        }
+
+        return result;
+    }
+
+    visitScientific(ctx) {
+        return {expType: "number", value: ctx.getText()};
+    }
+
+    visitAtom_string(ctx) {
+        return {expType: "string", value: ctx.getText().substring(1, ctx.getText().length - 1)};
+    }
+
+    visitEntity_variable(ctx) {
+        return {
+            expType: "entity",
+            entityType: ctx.ID().getText(),
+            entityName: ctx.ENTITY_NAME().getText().substring(1, ctx.ENTITY_NAME().getText().length - 1)
+        };
+    }
+
+    visitVariable_chain(ctx) {
+        let varType = "normal";
+        if (ctx.variable().environment_context() != null) {
+            varType = "context";
+        }
+        if (ctx.variable().environment_event() != null) {
+            varType = "event";
+        }
+
+        return {expType: "variableChain", varType: varType, content: ctx.getText()};
+    }
+}
+
+exports.CollectionPolicyCustomVisitor = CollectionPolicyCustomVisitor;

package/CollectionPolicyDecompiler.js

@@ -0,0 +1,131 @@
+class CollectionPolicyDecompiler {
+
+    decompile(result) {
+        let content = "";
+        content += `\n${this.decompileAudiences(result["audiences"])}`;
+        content += `\n${this.decompileServiceStates(result["serviceStates"])}`;
+        content += `\n${this.decompileStateMachine(result["stateMachine"])}`;
+        return content;
+    }
+
+    decompileAudiences(audiences) {
+        return `for ${audiences.map(audience => audience.name).join(", ")}`;
+    }
+
+    decompileServiceStates(serviceStates) {
+        let content = "";
+        serviceStates.forEach(serviceState => {
+            content += `\n${this.decompileServiceState(serviceState)}`;
+        });
+
+        return content;
+    }
+
+    decompileServiceState(serviceState) {
+        if (serviceState["caller"] == null) {
+            return serviceState["name"];
+        } else {
+            if (serviceState["functions"] == null || serviceState["functions"].length === 0) {
+                return `${serviceState["name"]} = ${serviceState["caller"]["name"]}`;
+            } else {
+                return `${serviceState["name"]} = ${serviceState["caller"]["name"]}.${this.decompileFunctions(serviceState["functions"])}`;
+            }
+        }
+    }
+
+    decompileStateMachine(stateMachine) {
+        let content = "";
+        for (let state in stateMachine) {
+            content += `\n${this.decompileMachineState(stateMachine[state], state)}`;
+        }
+
+        return content;
+    }
+
+    decompileMachineState(machineState, state) {
+        let serviceStates = machineState["serviceStates"];
+        let serviceStatesStr = "";
+        if (serviceStates != null && serviceStates.length !== 0) {
+            serviceStatesStr = `[${serviceStates.join(", ")}]`
+        }
+
+        return `${state}${serviceStatesStr}:${this.decompileTransitions(machineState["transitions"])}`;
+    }
+
+    decompileTransitions(transitions) {
+        if (transitions === null || transitions.length === 0) {
+            return "\n\tterminate";
+        }
+
+        let content = "";
+        transitions.forEach(transition => {
+            content += `\n${this.decompileTransition(transition)}`;
+        });
+
+        return content;
+    }
+
+    decompileTransition(transition) {
+        let condition = transition["condition"];
+        let conditionStr = "";
+        if (condition != null) {
+            switch (condition["type"]) {
+                case "case":
+                    conditionStr = `case in ${condition["serviceState"]}`;
+                    break;
+            }
+        }
+
+        let path = transition["path"];
+        let pathStr = path != null ? `${path}.` : "";
+        let args = transition["args"];
+        let argsStr = "";
+        if (args != null) {
+            let argArray = [];
+            for (let key in args) {
+                argArray.push(`"${args[key]}"`);
+            }
+            argsStr = argArray.join(", ");
+        }
+        let eventStr = `~${transition["service"]}.${pathStr}${transition["name"]}(${argsStr}) => ${transition["toState"]}`;
+
+        let actions = transition["actions"];
+        let actionsStr = "";
+        if (actions != null && actions.length !== 0) {
+            actions.forEach(action => {
+                let caller = action["caller"];
+                let callerStr = "";
+                if (caller != null) {
+                    callerStr = `${caller["name"]}.`;
+                }
+                actionsStr += `${callerStr}${this.decompileFunctions(action["functions"])}; `;
+            })
+            actionsStr = `do ${actionsStr}`;
+        }
+
+        return `\t${conditionStr} ${eventStr} ${actionsStr}`;
+    }
+
+    decompileFunctions(functions) {
+        if (functions == null || functions.length === 0) {
+            return "";
+        } else {
+            return functions.map(this.decompileFunction).join(".");
+        }
+    }
+
+    decompileFunction(func) {
+        if (func["functionArgs"] == null || func["functionArgs"].length === 0) {
+            return `${func["functionName"]}()`;
+        } else {
+            let functionArgs = func["functionArgs"];
+            let functionArgArray = [];
+            for (let name in functionArgs) {
+                functionArgArray.push(functionArgs[name]);
+            }
+            return `${func["functionName"]}(${functionArgArray.join(", ")})`;
+        }
+    }
+}
+
+exports.CollectionPolicyDecompiler = CollectionPolicyDecompiler;

package/CollectionPolicyErrorLexerListener.js

@@ -0,0 +1,23 @@
+const antlr4 = require("antlr4");
+
+class CollectionPolicyErrorLexerListener extends antlr4.error.ErrorListener {
+
+    constructor() {
+        super();
+        this.errors = [];
+        this.errorObjects = [];
+    }
+
+    syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
+        if (e instanceof antlr4.error.LexerNoViableAltException) {
+            this.errors.push(`line ${line}:${charPositionInLine} ${msg}`);
+            this.errorObjects.push({
+                line: line,
+                charPositionInLine: charPositionInLine,
+                msg: msg
+            });
+        }
+    }
+}
+
+exports.CollectionPolicyErrorLexerListener = CollectionPolicyErrorLexerListener;