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);
}
