@stordata/grammars 1.0.20230421155415

package/generated/src/grammars/CustomMetricParser.js

@@ -0,0 +1,579 @@
+// Generated from src/grammars/CustomMetric.g4 by ANTLR 4.12.0
+// jshint ignore: start
+import antlr4 from 'antlr4';
+import CustomMetricListener from './CustomMetricListener.js';
+const serializedATN = [4,1,21,34,2,0,7,0,2,1,7,1,1,0,1,0,1,0,1,1,1,1,1,1,
+1,1,1,1,1,1,1,1,3,1,15,8,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,5,1,29,8,1,10,1,12,1,32,9,1,1,1,0,1,2,2,0,2,0,0,37,0,4,1,0,0,0,2,14,1,
+0,0,0,4,5,3,2,1,0,5,6,5,0,0,1,6,1,1,0,0,0,7,8,6,1,-1,0,8,9,5,10,0,0,9,10,
+3,2,1,0,10,11,5,11,0,0,11,15,1,0,0,0,12,15,5,1,0,0,13,15,5,2,0,0,14,7,1,
+0,0,0,14,12,1,0,0,0,14,13,1,0,0,0,15,30,1,0,0,0,16,17,10,7,0,0,17,18,5,4,
+0,0,18,29,3,2,1,8,19,20,10,6,0,0,20,21,5,5,0,0,21,29,3,2,1,7,22,23,10,5,
+0,0,23,24,5,6,0,0,24,29,3,2,1,6,25,26,10,4,0,0,26,27,5,7,0,0,27,29,3,2,1,
+5,28,16,1,0,0,0,28,19,1,0,0,0,28,22,1,0,0,0,28,25,1,0,0,0,29,32,1,0,0,0,
+30,28,1,0,0,0,30,31,1,0,0,0,31,3,1,0,0,0,32,30,1,0,0,0,3,14,28,30];
+
+
+const atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);
+
+const decisionsToDFA = atn.decisionToState.map( (ds, index) => new antlr4.dfa.DFA(ds, index) );
+
+const sharedContextCache = new antlr4.atn.PredictionContextCache();
+
+export default class CustomMetricParser extends antlr4.Parser {
+
+    static grammarFileName = "CustomMetric.g4";
+    static literalNames = [ null, null, null, null, null, null, null, null, 
+                            null, "'.'", "'('", "')'", "'+'", "'-'", "'*'", 
+                            "'/'", "'\"'", "' '" ];
+    static symbolicNames = [ null, "NUMBER", "STRING", "WHITESPACE", "ADD", 
+                             "SUBTRACT", "MULTIPLY", "DIVIDE", "DIGIT", 
+                             "DOT", "L_PARANT", "R_PARANT", "PLUS", "MINUS", 
+                             "STAR", "SLASH", "DQUOTE", "SPACE", "TAB", 
+                             "CR", "LF", "ANY" ];
+    static ruleNames = [ "all", "expression" ];
+
+    constructor(input) {
+        super(input);
+        this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
+        this.ruleNames = CustomMetricParser.ruleNames;
+        this.literalNames = CustomMetricParser.literalNames;
+        this.symbolicNames = CustomMetricParser.symbolicNames;
+    }
+
+    sempred(localctx, ruleIndex, predIndex) {
+    	switch(ruleIndex) {
+    	case 1:
+    	    		return this.expression_sempred(localctx, predIndex);
+        default:
+            throw "No predicate with index:" + ruleIndex;
+       }
+    }
+
+    expression_sempred(localctx, predIndex) {
+    	switch(predIndex) {
+    		case 0:
+    			return this.precpred(this._ctx, 7);
+    		case 1:
+    			return this.precpred(this._ctx, 6);
+    		case 2:
+    			return this.precpred(this._ctx, 5);
+    		case 3:
+    			return this.precpred(this._ctx, 4);
+    		default:
+    			throw "No predicate with index:" + predIndex;
+    	}
+    };
+
+
+
+
+	all() {
+	    let localctx = new AllContext(this, this._ctx, this.state);
+	    this.enterRule(localctx, 0, CustomMetricParser.RULE_all);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 4;
+	        this.expression(0);
+	        this.state = 5;
+	        this.match(CustomMetricParser.EOF);
+	    } catch (re) {
+	    	if(re instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = re;
+		        this._errHandler.reportError(this, re);
+		        this._errHandler.recover(this, re);
+		    } else {
+		    	throw re;
+		    }
+	    } finally {
+	        this.exitRule();
+	    }
+	    return localctx;
+	}
+
+
+	expression(_p) {
+		if(_p===undefined) {
+		    _p = 0;
+		}
+	    const _parentctx = this._ctx;
+	    const _parentState = this.state;
+	    let localctx = new ExpressionContext(this, this._ctx, _parentState);
+	    let _prevctx = localctx;
+	    const _startState = 2;
+	    this.enterRecursionRule(localctx, 2, CustomMetricParser.RULE_expression, _p);
+	    try {
+	        this.enterOuterAlt(localctx, 1);
+	        this.state = 14;
+	        this._errHandler.sync(this);
+	        switch(this._input.LA(1)) {
+	        case 10:
+	            localctx = new WrappedExpressionContext(this, localctx);
+	            this._ctx = localctx;
+	            _prevctx = localctx;
+
+	            this.state = 8;
+	            this.match(CustomMetricParser.L_PARANT);
+	            this.state = 9;
+	            this.expression(0);
+	            this.state = 10;
+	            this.match(CustomMetricParser.R_PARANT);
+	            break;
+	        case 1:
+	            localctx = new NumberContext(this, localctx);
+	            this._ctx = localctx;
+	            _prevctx = localctx;
+	            this.state = 12;
+	            this.match(CustomMetricParser.NUMBER);
+	            break;
+	        case 2:
+	            localctx = new StringContext(this, localctx);
+	            this._ctx = localctx;
+	            _prevctx = localctx;
+	            this.state = 13;
+	            this.match(CustomMetricParser.STRING);
+	            break;
+	        default:
+	            throw new antlr4.error.NoViableAltException(this);
+	        }
+	        this._ctx.stop = this._input.LT(-1);
+	        this.state = 30;
+	        this._errHandler.sync(this);
+	        var _alt = this._interp.adaptivePredict(this._input,2,this._ctx)
+	        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
+	            if(_alt===1) {
+	                if(this._parseListeners!==null) {
+	                    this.triggerExitRuleEvent();
+	                }
+	                _prevctx = localctx;
+	                this.state = 28;
+	                this._errHandler.sync(this);
+	                var la_ = this._interp.adaptivePredict(this._input,1,this._ctx);
+	                switch(la_) {
+	                case 1:
+	                    localctx = new AdditionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    localctx.left = _prevctx;
+	                    this.pushNewRecursionContext(localctx, _startState, CustomMetricParser.RULE_expression);
+	                    this.state = 16;
+	                    if (!( this.precpred(this._ctx, 7))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 7)");
+	                    }
+	                    this.state = 17;
+	                    this.match(CustomMetricParser.ADD);
+	                    this.state = 18;
+	                    localctx.right = this.expression(8);
+	                    break;
+
+	                case 2:
+	                    localctx = new SubtractionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    localctx.left = _prevctx;
+	                    this.pushNewRecursionContext(localctx, _startState, CustomMetricParser.RULE_expression);
+	                    this.state = 19;
+	                    if (!( this.precpred(this._ctx, 6))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)");
+	                    }
+	                    this.state = 20;
+	                    this.match(CustomMetricParser.SUBTRACT);
+	                    this.state = 21;
+	                    localctx.right = this.expression(7);
+	                    break;
+
+	                case 3:
+	                    localctx = new MultiplicationContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    localctx.left = _prevctx;
+	                    this.pushNewRecursionContext(localctx, _startState, CustomMetricParser.RULE_expression);
+	                    this.state = 22;
+	                    if (!( this.precpred(this._ctx, 5))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)");
+	                    }
+	                    this.state = 23;
+	                    this.match(CustomMetricParser.MULTIPLY);
+	                    this.state = 24;
+	                    localctx.right = this.expression(6);
+	                    break;
+
+	                case 4:
+	                    localctx = new DivisionContext(this, new ExpressionContext(this, _parentctx, _parentState));
+	                    localctx.left = _prevctx;
+	                    this.pushNewRecursionContext(localctx, _startState, CustomMetricParser.RULE_expression);
+	                    this.state = 25;
+	                    if (!( this.precpred(this._ctx, 4))) {
+	                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 4)");
+	                    }
+	                    this.state = 26;
+	                    this.match(CustomMetricParser.DIVIDE);
+	                    this.state = 27;
+	                    localctx.right = this.expression(5);
+	                    break;
+
+	                } 
+	            }
+	            this.state = 32;
+	            this._errHandler.sync(this);
+	            _alt = this._interp.adaptivePredict(this._input,2,this._ctx);
+	        }
+
+	    } catch( error) {
+	        if(error instanceof antlr4.error.RecognitionException) {
+		        localctx.exception = error;
+		        this._errHandler.reportError(this, error);
+		        this._errHandler.recover(this, error);
+		    } else {
+		    	throw error;
+		    }
+	    } finally {
+	        this.unrollRecursionContexts(_parentctx)
+	    }
+	    return localctx;
+	}
+
+
+}
+
+CustomMetricParser.EOF = antlr4.Token.EOF;
+CustomMetricParser.NUMBER = 1;
+CustomMetricParser.STRING = 2;
+CustomMetricParser.WHITESPACE = 3;
+CustomMetricParser.ADD = 4;
+CustomMetricParser.SUBTRACT = 5;
+CustomMetricParser.MULTIPLY = 6;
+CustomMetricParser.DIVIDE = 7;
+CustomMetricParser.DIGIT = 8;
+CustomMetricParser.DOT = 9;
+CustomMetricParser.L_PARANT = 10;
+CustomMetricParser.R_PARANT = 11;
+CustomMetricParser.PLUS = 12;
+CustomMetricParser.MINUS = 13;
+CustomMetricParser.STAR = 14;
+CustomMetricParser.SLASH = 15;
+CustomMetricParser.DQUOTE = 16;
+CustomMetricParser.SPACE = 17;
+CustomMetricParser.TAB = 18;
+CustomMetricParser.CR = 19;
+CustomMetricParser.LF = 20;
+CustomMetricParser.ANY = 21;
+
+CustomMetricParser.RULE_all = 0;
+CustomMetricParser.RULE_expression = 1;
+
+class AllContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CustomMetricParser.RULE_all;
+    }
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	EOF() {
+	    return this.getToken(CustomMetricParser.EOF, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.enterAll(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.exitAll(this);
+		}
+	}
+
+
+}
+
+
+
+class ExpressionContext extends antlr4.ParserRuleContext {
+
+    constructor(parser, parent, invokingState) {
+        if(parent===undefined) {
+            parent = null;
+        }
+        if(invokingState===undefined || invokingState===null) {
+            invokingState = -1;
+        }
+        super(parent, invokingState);
+        this.parser = parser;
+        this.ruleIndex = CustomMetricParser.RULE_expression;
+    }
+
+
+	 
+		copyFrom(ctx) {
+			super.copyFrom(ctx);
+		}
+
+}
+
+
+class AdditionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        this.left = null;;
+        this.right = null;;
+        super.copyFrom(ctx);
+    }
+
+	ADD() {
+	    return this.getToken(CustomMetricParser.ADD, 0);
+	};
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.enterAddition(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.exitAddition(this);
+		}
+	}
+
+
+}
+
+CustomMetricParser.AdditionContext = AdditionContext;
+
+class MultiplicationContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        this.left = null;;
+        this.right = null;;
+        super.copyFrom(ctx);
+    }
+
+	MULTIPLY() {
+	    return this.getToken(CustomMetricParser.MULTIPLY, 0);
+	};
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.enterMultiplication(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.exitMultiplication(this);
+		}
+	}
+
+
+}
+
+CustomMetricParser.MultiplicationContext = MultiplicationContext;
+
+class SubtractionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        this.left = null;;
+        this.right = null;;
+        super.copyFrom(ctx);
+    }
+
+	SUBTRACT() {
+	    return this.getToken(CustomMetricParser.SUBTRACT, 0);
+	};
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.enterSubtraction(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.exitSubtraction(this);
+		}
+	}
+
+
+}
+
+CustomMetricParser.SubtractionContext = SubtractionContext;
+
+class NumberContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	NUMBER() {
+	    return this.getToken(CustomMetricParser.NUMBER, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.enterNumber(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.exitNumber(this);
+		}
+	}
+
+
+}
+
+CustomMetricParser.NumberContext = NumberContext;
+
+class WrappedExpressionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	L_PARANT() {
+	    return this.getToken(CustomMetricParser.L_PARANT, 0);
+	};
+
+	expression() {
+	    return this.getTypedRuleContext(ExpressionContext,0);
+	};
+
+	R_PARANT() {
+	    return this.getToken(CustomMetricParser.R_PARANT, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.enterWrappedExpression(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.exitWrappedExpression(this);
+		}
+	}
+
+
+}
+
+CustomMetricParser.WrappedExpressionContext = WrappedExpressionContext;
+
+class DivisionContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        this.left = null;;
+        this.right = null;;
+        super.copyFrom(ctx);
+    }
+
+	DIVIDE() {
+	    return this.getToken(CustomMetricParser.DIVIDE, 0);
+	};
+
+	expression = function(i) {
+	    if(i===undefined) {
+	        i = null;
+	    }
+	    if(i===null) {
+	        return this.getTypedRuleContexts(ExpressionContext);
+	    } else {
+	        return this.getTypedRuleContext(ExpressionContext,i);
+	    }
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.enterDivision(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.exitDivision(this);
+		}
+	}
+
+
+}
+
+CustomMetricParser.DivisionContext = DivisionContext;
+
+class StringContext extends ExpressionContext {
+
+    constructor(parser, ctx) {
+        super(parser);
+        super.copyFrom(ctx);
+    }
+
+	STRING() {
+	    return this.getToken(CustomMetricParser.STRING, 0);
+	};
+
+	enterRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.enterString(this);
+		}
+	}
+
+	exitRule(listener) {
+	    if(listener instanceof CustomMetricListener ) {
+	        listener.exitString(this);
+		}
+	}
+
+
+}
+
+CustomMetricParser.StringContext = StringContext;
+
+
+CustomMetricParser.AllContext = AllContext; 
+CustomMetricParser.ExpressionContext = ExpressionContext; 

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@stordata/grammars",
+  "version":"1.0.20230421155415",
+  "type": "module",
+  "main": "dist/main.cjs",
+  "repository": {
+    "type": "git",
+    "url": "ssh://git@gitlab.stordata.fr:2200/stordata/grammars.git"
+  },
+  "keywords": [
+    "antlr",
+    "stordata",
+    "grammars"
+  ],
+  "author": "La team d'en bas <teamdenbas@stordata.fr>",
+  "license": "UNLICENCED",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "webpack",
+    "test": "mocha src/**/*.spec.js",
+    "lint": "eslint webpack.config.js src/**/*.js",
+    "antlr": "antlr4 -Dlanguage=JavaScript -o generated src/grammars/CustomMetric.g4",
+    "clean": "rm dist/ -fR; rm generated/ -fR"
+  },
+  "engines": {
+    "node": ">= 18"
+  },
+  "dependencies": {
+    "antlr4": "4.12.0"
+  },
+  "devDependencies": {
+    "@stordata/eslint-config": "1.0.20230408020835",
+    "chai": "4.3.7",
+    "eslint": "8.38.0",
+    "mocha": "10.2.0",
+    "webpack": "5.80.0",
+    "webpack-cli": "5.0.1"
+  }
+}

package/src/GrammarSyntaxError.js

@@ -0,0 +1,10 @@
+export default class GrammarSyntaxError extends Error {
+
+  constructor(message, line, column) {
+    super(`${message} at ${line}:${column}`);
+
+    this.line = line;
+    this.column = column;
+  }
+
+}

package/src/ThrowingErrorListener.js

@@ -0,0 +1,11 @@
+import { ErrorListener } from 'antlr4';
+
+import GrammarSyntaxError from './GrammarSyntaxError.js';
+
+export default class ThrowingErrorListener extends ErrorListener {
+
+  syntaxError(recognizer, offendingSymbol, line, column, msg, e) {
+    throw new GrammarSyntaxError(msg, line, column, e);
+  }
+
+}

package/src/grammars/CustomMetric.g4

@@ -0,0 +1,38 @@
+grammar CustomMetric;
+
+all: expression EOF; // Will parse all input as an expression. Mind the EOF token
+
+expression: left=expression ADD right=expression                # Addition
+            | left=expression SUBTRACT right=expression         # Subtraction
+            | left=expression MULTIPLY right=expression         # Multiplication
+            | left=expression DIVIDE right=expression           # Division
+            | L_PARANT expression R_PARANT                      # WrappedExpression
+            | NUMBER                                            # Number
+            | STRING                                            # String
+            ;
+
+NUMBER: DIGIT+(DOT DIGIT+)?;
+STRING: DQUOTE ANY+? DQUOTE;
+WHITESPACE: (SPACE | TAB | CR | LF)+ -> skip;
+
+ADD: PLUS;
+SUBTRACT: MINUS;
+MULTIPLY: STAR;
+DIVIDE: SLASH;
+
+DIGIT: [0-9];
+DOT: '.';
+L_PARANT: '(';
+R_PARANT: ')';
+PLUS: '+';
+MINUS: '-';
+STAR: '*';
+SLASH: '/';
+DQUOTE: '"';
+
+SPACE: ' ';
+TAB: [\t];
+CR: [\r];
+LF: [\n];
+
+ANY: .;

package/src/grammars/parseCustomMetric.js

@@ -0,0 +1,7 @@
+import parse from '../parse.js';
+import CustomMetricLexer from '../../generated/src/grammars/CustomMetricLexer.js';
+import CustomMetricParser from '../../generated/src/grammars/CustomMetricParser.js';
+
+export default function parseCustomMetric(input) {
+  return parse(input, CustomMetricLexer, CustomMetricParser);
+}