public override Expression VisitLiteral(LiteralContext context) { var literalParser = new LiteralParser(); var literal = literalParser.Visit(context); return(literal); }
public LiteralContext literal() { LiteralContext _localctx = new LiteralContext(Context, State); EnterRule(_localctx, 14, RULE_literal); int _la; try { EnterOuterAlt(_localctx, 1); { State = 71; _la = TokenStream.La(1); if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING_LITERAL) | (1L << NUMERIC_LITERAL) | (1L << BOOLEAN_LITERAL))) != 0))) { ErrorHandler.RecoverInline(this); } else { Consume(); } } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return(_localctx); }
private void logFloatTooBig(LiteralContext litContext) { log.error( new DiagnosticPosition(litContext.Start.Line, litContext.Start.Column), messages.floatLiteratTooBig, litContext.GetText() ); }
public LiteralContext literal() { LiteralContext _localctx = new LiteralContext(Context, State); EnterRule(_localctx, 24, RULE_literal); int _la; try { EnterOuterAlt(_localctx, 1); { State = 119; _la = TokenStream.LA(1); if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << NONE) | (1L << VALUETYPE) | (1L << STRING) | (1L << FLOAT) | (1L << INT) | (1L << ID))) != 0))) { ErrorHandler.RecoverInline(this); } else { ErrorHandler.ReportMatch(this); Consume(); } } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return(_localctx); }
public override void EnterLiteral([NotNull] LiteralContext context) { foreach (var rule in context.GetRuleContexts <ParserRuleContext>()) { rule.EnterRule(this); // integer litteral , bool litteral etc } }
public LiteralContext literal() { LiteralContext _localctx = new LiteralContext(Context, State); EnterRule(_localctx, 6, RULE_literal); int _la; try { EnterOuterAlt(_localctx, 1); { State = 72; _la = TokenStream.LA(1); if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NUMBER) | (1L << STRING) | (1L << DATE) | (1L << TRUE) | (1L << FALSE))) != 0))) { ErrorHandler.RecoverInline(this); } else { ErrorHandler.ReportMatch(this); Consume(); } } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return(_localctx); }
/// <summary> /// add a parametername from the current context to a context which has names /// </summary> /// <returns></returns> bool AddParameter(string name, uint pos, IDataType datatype, LiteralContext defaultvalue, RuleContext context) { RuleContext root = GetRootContext(context, typeof(SelectionRulezContext)); INode theDefaultValue = null; if (defaultvalue != null) { theDefaultValue = defaultvalue.XPTreeNode; } ParameterDefinition def = new ParameterDefinition(name: name, pos: pos, datatype: datatype, defaultvalue: (IExpression)theDefaultValue); if (root != null) { if (!((SelectionRulezContext)root).names.ContainsKey(name)) { ((SelectionRulezContext)root).names.Add(name, def); ((SelectionRule)((SelectionRulezContext)root).XPTreeNode).AddNewParameter(name, datatype); } else { this.NotifyErrorListeners(String.Format(Messages.RCM_3, name, "SelectionRule")); return(false); } return(true); } this.NotifyErrorListeners(String.Format(Messages.RCM_4, name, "SelectionRule")); return(false); }
public override ExprNode VisitLiteral([NotNull] LiteralContext context) { return(this.VisitFirstChild <ExprNode, Node>(new ParserRuleContext[] { context.number(), context.@bool(), context.stringLiteral(), context.charLiteral(), })); }
public StringLiteralManager(LiteralContext context) : base( () => { return(context.StringLiteral().Symbol.Text); }, (value) => { var stringLiteral = context.StringLiteral(); var newToken = new CommonToken(stringLiteral.Symbol.Type, value); context.Replace(stringLiteral, newToken); }) { this.context = context; }
public override Expression VisitLiteral(LiteralContext context) { if (context.string_literal() != null) { //TODO: interpolated strings var value = context.string_literal().GetText().TrimStart('@').Trim('"'); return(Expression.Constant(value, typeof(string))); } if (context.INTEGER_LITERAL() != null) { //TODO: literal suffixes, like L var literal = context.INTEGER_LITERAL(); if (Int32.TryParse(literal.Symbol.Text, out var intResult)) { return(Expression.Constant(intResult, typeof(Int32))); } if (Int64.TryParse(literal.Symbol.Text, out var longResult)) { return(Expression.Constant(longResult, typeof(Int64))); } } if (context.CHARACTER_LITERAL() != null) { var literal = context.CHARACTER_LITERAL(); var value = Char.Parse(literal.GetText().Trim('\'')); return(Expression.Constant(value, typeof(char))); } if (context.boolean_literal() != null) { var literal = context.boolean_literal(); var value = Boolean.Parse(literal.GetText()); return(Expression.Constant(value, typeof(bool))); } if (context.REAL_LITERAL() != null) { //TODO: literal suffixes, like m var literal = context.REAL_LITERAL(); var value = Double.Parse(literal.Symbol.Text); return(Expression.Constant(value, typeof(double))); } throw new InternalParseException("Unsupported literal", context); }
/// <summary> /// add a parametername from the current context to a context which has names /// </summary> /// <returns></returns> bool AddVariable(string name, IDataType datatype, LiteralContext literal, RuleContext context) { RuleContext root = GetRootContext(context, typeof(SelectStatementBlockContext)); VariableDefinition def = new VariableDefinition(name: name, datatype: datatype, defaultvalue: literal.XPTreeNode); if (root != null) { if (!((SelectStatementBlockContext)root).names.ContainsKey(name)) { ((SelectStatementBlockContext)root).names.Add(name, def); ((StatementBlock)((SelectStatementBlockContext)root).XPTreeNode).AddNewVariable(name, datatype); } else { this.NotifyErrorListeners(String.Format(Messages.RCM_1, name, "SelectStatementBlock")); return(false); } return(true); } this.NotifyErrorListeners(String.Format(Messages.RCM_2, name, "SelectStatementBlock")); return(false); }
public override Tree VisitPrimary(PrimaryContext primary) { var expressionContext = primary.parenthesized; if (expressionContext != null) { return((Expression)VisitExpression(expressionContext)); } LiteralContext literal = primary.literal(); if (literal != null) { return((Expression)VisitLiteral(literal)); } ITerminalNode identifier = primary.Identifier(); if (identifier != null) { return(makeIdentifier(identifier)); } return(new This(primary.start.Line, primary.start.Column, primary.stop.Line, primary.stop.Column)); }
internal static Literal Create(LiteralContext context) { if (context.literal() != null) { return(Create(context.literal())); } else { IToken token = (context.children[0] as ITerminalNode).Symbol; switch (token.Type) { case KScriptLexer.NAMED_TOKEN: return(new Literal(token.Text.Substring(1, token.Text.Length - 2).Trim(), LiteralType.Token)); case KScriptLexer.TRUE: return(new Literal(true, LiteralType.Value)); case KScriptLexer.FALSE: return(new Literal(false, LiteralType.Value)); case KScriptLexer.NUMBER: return(new Literal(decimal.Parse(token.Text), LiteralType.Value)); case KScriptLexer.STRING: return(new Literal(token.Text.Substring(1, token.Text.Length - 2), LiteralType.Value)); case KScriptLexer.NOW: return(new Literal(null, LiteralType.Date)); case KScriptLexer.NULL: return(new Literal(null, LiteralType.Value)); default: throw new InvalidOperationException(); } } }
public LiteralContext literal() { LiteralContext _localctx = new LiteralContext(Context, State); EnterRule(_localctx, 2, RULE_literal); try { State = 20; switch (TokenStream.La(1)) { case CURLY_BRACE_OPEN: EnterOuterAlt(_localctx, 1); { State = 18; _localctx.ObjectLiteral = objectLiteral(); } break; case SQUARE_BRACE_OPEN: EnterOuterAlt(_localctx, 2); { State = 19; _localctx.ArrayLiteral = arrayLiteral(); } break; default: throw new NoViableAltException(this); } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return(_localctx); }
public override SymbolBase VisitLiteral([NotNull] LiteralContext context) => // According to the grammar, a literal must contain one child. context.children.Select(child => Visit(child)).First();
public LiteralContext literal() { LiteralContext _localctx = new LiteralContext(Context, State); EnterRule(_localctx, 276, RULE_literal); int _la; try { EnterOuterAlt(_localctx, 1); { State = 2698; _la = TokenStream.La(1); if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (FALSE - 74)) | (1L << (NOTHING - 74)) | (1L << (NULL - 74)))) != 0) || ((((_la - 171)) & ~0x3f) == 0 && ((1L << (_la - 171)) & ((1L << (TRUE - 171)) | (1L << (STRINGLITERAL - 171)) | (1L << (DATELITERAL - 171)) | (1L << (COLORLITERAL - 171)) | (1L << (INTEGERLITERAL - 171)) | (1L << (DOUBLELITERAL - 171)))) != 0)) ) { ErrorHandler.RecoverInline(this); } else { Consume(); } } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return _localctx; }
public LiteralContext literal() { LiteralContext _localctx = new LiteralContext(_ctx, State); EnterRule(_localctx, 2, RULE_literal); try { State = 28; switch (_input.La(1)) { case NAMED_TOKEN: EnterOuterAlt(_localctx, 1); { State = 17; Match(NAMED_TOKEN); } break; case TRUE: EnterOuterAlt(_localctx, 2); { State = 18; Match(TRUE); } break; case FALSE: EnterOuterAlt(_localctx, 3); { State = 19; Match(FALSE); } break; case NUMBER: EnterOuterAlt(_localctx, 4); { State = 20; Match(NUMBER); } break; case STRING: EnterOuterAlt(_localctx, 5); { State = 21; Match(STRING); } break; case NOW: EnterOuterAlt(_localctx, 6); { State = 22; Match(NOW); } break; case NULL: EnterOuterAlt(_localctx, 7); { State = 23; Match(NULL); } break; case OPEN_PAREN: EnterOuterAlt(_localctx, 8); { State = 24; Match(OPEN_PAREN); State = 25; literal(); State = 26; Match(CLOSE_PAREN); } break; default: throw new NoViableAltException(this); } } catch (RecognitionException re) { _localctx.exception = re; _errHandler.ReportError(this, re); _errHandler.Recover(this, re); } finally { ExitRule(); } return(_localctx); }
/// <summary> /// add a parametername from the current context to a context which has names /// </summary> /// <returns></returns> bool AddParameter(string name, uint pos, IDataType datatype, LiteralContext defaultvalue, RuleContext context) { RuleContext root = GetRootContext(context, typeof(SelectionRulezContext)); INode theDefaultValue = null; if (defaultvalue != null) theDefaultValue = defaultvalue.XPTreeNode; ParameterDefinition def = new ParameterDefinition(name: name, pos: pos, datatype: datatype, defaultvalue: (IExpression) theDefaultValue); if (root != null) { if (!((SelectionRulezContext)root).names.ContainsKey(name)) { ((SelectionRulezContext)root).names.Add(name, def); ((SelectionRule)((SelectionRulezContext)root).XPTreeNode).AddNewParameter(name, datatype); } else { this.NotifyErrorListeners(String.Format(Messages.RCM_3, name, "SelectionRule")); return false; } return true; } this.NotifyErrorListeners(String.Format(Messages.RCM_4, name, "SelectionRule")); return false; }
/// <summary> /// add a parametername from the current context to a context which has names /// </summary> /// <returns></returns> bool AddVariable(string name, IDataType datatype, LiteralContext literal, RuleContext context) { RuleContext root = GetRootContext(context, typeof(SelectStatementBlockContext)); VariableDefinition def = new VariableDefinition(name: name, datatype: datatype, defaultvalue: literal.XPTreeNode); if (root != null) { if (!((SelectStatementBlockContext)root).names.ContainsKey(name)) { ((SelectStatementBlockContext)root).names.Add(name, def); ((StatementBlock)((SelectStatementBlockContext)root).XPTreeNode).AddNewVariable(name, datatype); } else { this.NotifyErrorListeners(String.Format(Messages.RCM_1, name, "SelectStatementBlock")); return false; } return true; } this.NotifyErrorListeners(String.Format(Messages.RCM_2, name, "SelectStatementBlock")); return false; }
public override Tree VisitLiteral(LiteralContext context) { IToken symbol; String text; Object value; TypeTag type; switch (context.literalType) { case INT: symbol = context.IntegerLiteral().Symbol; text = symbol.Text; if (Int32.TryParse(text, out var intLit)) { type = TypeTag.INT; value = intLit; } else if (Int64.TryParse(text, out var longLit)) { type = TypeTag.LONG; value = longLit; } else { log.error( new DiagnosticPosition(context.Start.Line, context.Start.Column), messages.intLiteratTooBig, context.GetText() ); type = TypeTag.ERROR; value = 0; } break; case FLOAT: symbol = context.FloatingPointLiteral().Symbol; text = symbol.Text; if (text.EndsWith("f") || text.EndsWith("F")) { text = text.Substring(0, text.Length - 1); type = TypeTag.FLOAT; if (Single.TryParse(text, out var floatLit)) { value = floatLit; } else { value = 0; logFloatTooBig(context); } } else if (text.EndsWith("d") || text.EndsWith("D")) { type = TypeTag.DOUBLE; if (Double.TryParse(text, out var doubleLit)) { value = doubleLit; } else { value = 0; logFloatTooBig(context); } } else if (Single.TryParse(text, out var floatLit)) { type = TypeTag.FLOAT; value = floatLit; } else if (Double.TryParse(text, out var doubleLit)) { type = TypeTag.DOUBLE; value = doubleLit; } else { type = TypeTag.ERROR; value = 0; logFloatTooBig(context); } break; case BOOLEAN: symbol = context.BooleanLiteral().Symbol; text = symbol.Text; type = TypeTag.BOOLEAN; value = Boolean.Parse(text); break; case CHAR: symbol = context.CharLiteral().Symbol; text = symbol.Text; type = TypeTag.CHAR; value = parseCharLiteral(text); break; case CSTRING: symbol = context.CStringLiteral().Symbol; text = symbol.Text; type = TypeTag.C_STRING; value = parseStringLiteral(text); break; case NULL: value = null; symbol = context.NULL().Symbol; type = TypeTag.NULL; text = "null"; break; default: throw new InvalidOperationException(); } int line = symbol.Line; int startColumn = symbol.Column; int endColumn = startColumn + text.Length; return(new LiteralExpression(line, startColumn, line, endColumn, type, value)); }
private ExpressionContext expression(int _p) { ParserRuleContext _parentctx = Context; int _parentState = State; ExpressionContext _localctx = new ExpressionContext(Context, _parentState); ExpressionContext _prevctx = _localctx; int _startState = 4; EnterRecursionRule(_localctx, 4, RULE_expression, _p); try { int _alt; EnterOuterAlt(_localctx, 1); { State = 31; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case LBRACKET: { _localctx = new ParenthesesContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 24; Match(LBRACKET); State = 25; expression(0); State = 26; Match(RBRACKET); } break; case LITERAL_NEGATION: { _localctx = new LiteralNegationContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 28; Match(LITERAL_NEGATION); } break; case LITERAL: { _localctx = new LiteralContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 29; Match(LITERAL); } break; case INVALID: { _localctx = new InvalidContext(_localctx); Context = _localctx; _prevctx = _localctx; State = 30; Match(INVALID); } break; default: throw new NoViableAltException(this); } Context.Stop = TokenStream.LT(-1); State = 44; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream, 3, Context); while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER) { if (_alt == 1) { if (ParseListeners != null) { TriggerExitRuleEvent(); } _prevctx = _localctx; { State = 42; ErrorHandler.Sync(this); switch (Interpreter.AdaptivePredict(TokenStream, 2, Context)) { case 1: { _localctx = new ConjunctionContext(new ExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_expression); State = 33; if (!(Precpred(Context, 6))) { throw new FailedPredicateException(this, "Precpred(Context, 6)"); } State = 34; Match(CONJUNCTION); State = 35; expression(7); } break; case 2: { _localctx = new DisjunctionContext(new ExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_expression); State = 36; if (!(Precpred(Context, 5))) { throw new FailedPredicateException(this, "Precpred(Context, 5)"); } State = 37; Match(DISJUNCTION); State = 38; expression(6); } break; case 3: { _localctx = new ImplicationContext(new ExpressionContext(_parentctx, _parentState)); PushNewRecursionContext(_localctx, _startState, RULE_expression); State = 39; if (!(Precpred(Context, 4))) { throw new FailedPredicateException(this, "Precpred(Context, 4)"); } State = 40; Match(IMPLICATION); State = 41; expression(5); } break; } } } State = 46; ErrorHandler.Sync(this); _alt = Interpreter.AdaptivePredict(TokenStream, 3, Context); } } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { UnrollRecursionContexts(_parentctx); } return(_localctx); }
public LiteralContext literal() { LiteralContext _localctx = new LiteralContext(Context, State); EnterRule(_localctx, 2, RULE_literal); try { State = 38; ErrorHandler.Sync(this); switch (TokenStream.LA(1)) { case Null: EnterOuterAlt(_localctx, 1); { State = 33; nullLiteral(); } break; case False: case True: EnterOuterAlt(_localctx, 2); { State = 34; booleanLiteral(); } break; case DecimalIntegerLiteral: case HexadecimalIntegerLiteral: case OctalIntegerLiteral: case BinaryIntegerLiteral: EnterOuterAlt(_localctx, 3); { State = 35; integerLiteral(); } break; case DecimalRealLiteral: EnterOuterAlt(_localctx, 4); { State = 36; realLiteral(); } break; case CharacterLiteral: EnterOuterAlt(_localctx, 5); { State = 37; characterLiteral(); } break; default: throw new NoViableAltException(this); } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return(_localctx); }