public override IQueryElement VisitLiteral([NotNull] QueryGrammarParser.LiteralContext context) { if (context.NUMBER() != null) { IntegerLiteral literal = new IntegerLiteral(); literal.Value = context.NUMBER().GetText(); return(literal); } else if (context.STRING_VALUE() != null) { StringLiteral literal = new StringLiteral(); literal.Value = context.STRING_VALUE().GetText().Replace("'", "\""); return(literal); } else if (context.BOOL_VALUE() != null) { BoolLiteral literal = new BoolLiteral(); literal.Value = context.BOOL_VALUE().GetText(); return(literal); } else if (context.NULL_VALUE() != null) { NullLiteral literal = new NullLiteral(); return(literal); } throw new SyntaxException("Unsupported literal."); }
public void Visit(IntegerLiteral literal) { _codeStack.Peek().CodeExpression = new CodePrimitiveExpression(literal.Value); _codeStack.Peek().Scope = new ScopeData <Type> { Type = typeof(int?), CodeDomReference = new CodeTypeReference(typeof(int?)) }; }
public override (IValue from, IValue to) Apply(IValue value, IValue operand) { switch (value) { case OrderedLiteralBase orderedLiteralValue: { switch (operand) { case OrderedLiteralBase orderedLiteralOperand: var literal = orderedLiteralValue % orderedLiteralOperand; return(literal, literal); default: throw new ArgumentOutOfRangeException(nameof(operand)); } } case { }: { switch (operand) { case IntegerLiteral integerLiteral: var literalFrom = IntegerLiteral.Zero; OrderedLiteralBase literalTo = new IntegerLiteral(integerLiteral); if (integerLiteral.AbsoluteValue > 0) { literalTo -= IntegerLiteral.One; } return(literalFrom, literalTo); default: throw new ArgumentOutOfRangeException(nameof(operand)); } }
public void TestIntegerLiteralEquals() { IntegerLiteral first = new IntegerLiteral() { Value = 3 }; IntegerLiteral firstClone = new IntegerLiteral() { Value = 3 }; IntegerLiteral second = new IntegerLiteral() { Value = 17 }; //Equals Assert.IsTrue(Equals(first, firstClone)); Assert.IsFalse(Equals(first, null)); Assert.IsFalse(Equals(first, "test")); Assert.IsFalse(Equals(first, second)); //Hash code Assert.AreEqual(first.GetHashCode(), firstClone.GetHashCode()); Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode()); }
public void IndexExpressionParsingTest() { var input = "someList[1 + 1]"; var lexer = new Lexer(input); var parser = new Parser(lexer); var program = parser.ParseCode(); StaticTests.CheckParserErrors(parser); Assert.AreEqual(nameof(ExpressionStatement), program.Statements.First().GetType().Name); var stmt = (ExpressionStatement)program.Statements.First(); Assert.AreEqual(nameof(IndexExpression), stmt.Expression.GetType().Name); var indexExp = (IndexExpression)stmt.Expression; StaticTests.TestIdentifier(indexExp.Left, "someList"); var int1 = new IntegerLiteral { Token = new Token { Type = Token.Int, Literal = "1" }, Value = 1 }; StaticTests.TestInfixExpression(indexExp.Index, int1, "+", int1); }
public void CreatingNewObject_ShouldHaveCorrectValueCorectDataGiven() { var expected = new IntegerValue(79); var actual = new IntegerLiteral("79"); Assert.Equal(expected, actual.Value); }
public static bool IntegerLiteralsAreEquivalent(IntegerLiteral literal1, IntegerLiteral literal2) { if (literal1 == null && literal2 == null) { return(true); } if (literal1 == null || literal2 == null) { return(false); } int value1 = 0; int value2 = 0; if (string.IsNullOrEmpty(literal1.LiteralValue) && string.IsNullOrEmpty(literal2.LiteralValue)) { return(true); } if (!(TryParseIntLiteralToInt32(literal1.LiteralValue, out value1) && TryParseIntLiteralToInt32(literal2.LiteralValue, out value2))) { return(false); } return(value1 == value2); }
public ConvertFunction(TypeName typeName, Expression valueExpression, IntegerLiteral style) { Debug.Assert(typeName != null); Debug.Assert(valueExpression != null); this.typeName = typeName; this.valueExpression = valueExpression; this.style = style; }
public static string GetDecimalLiteralOperand(IntegerLiteral expression, VHDLCompilerInterface compiler) { string value = expression.IntegerValue.ToString(CultureInfo.InvariantCulture); NewStatementTemplate template = new NewStatementTemplate("VHDLIntegerValue", value); return(template.TransformText()); }
public void ArrayLiteralParsingTest() { const string input = "[1, 2 * 2, 3 + 3]"; var lexer = new Lexer(input); var parser = new Parser(lexer); var program = parser.ParseCode(); StaticTests.CheckParserErrors(parser); Assert.AreEqual(nameof(ExpressionStatement), program.Statements.First().GetType().Name); var stmt = (ExpressionStatement)program.Statements.First(); Assert.AreEqual(nameof(ArrayLiteral), stmt.Expression.GetType().Name); var array = (ArrayLiteral)stmt.Expression; Assert.AreEqual(3, array.Elements.Count); StaticTests.TestIntegerLiteral(array.Elements.First(), 1); IntegerLiteral two = 2; IntegerLiteral three = 3; StaticTests.TestInfixExpression(array.Elements[1], two, "*", two); StaticTests.TestInfixExpression(array.Elements[2], three, "+", three); }
public void ProcessTopFilter(TopRowFilter TopFilter) { IntegerLiteral TopLiteral = null; if (FragmentTypeParser.GetFragmentType(TopFilter.Expression) != "ParenthesisExpression") { _smells.SendFeedBack(34, TopFilter); if (FragmentTypeParser.GetFragmentType(TopFilter.Expression) == "IntegerLiteral") { TopLiteral = (IntegerLiteral)TopFilter.Expression; } } else { var ParenthesisExpression = (ParenthesisExpression)TopFilter.Expression; if (FragmentTypeParser.GetFragmentType(ParenthesisExpression.Expression) == "IntegerLiteral") { TopLiteral = (IntegerLiteral)ParenthesisExpression.Expression; } } if (TopFilter.Percent && TopLiteral != null && TopLiteral.Value == "100") { _smells.SendFeedBack(35, TopLiteral); } }
public override void VisitIntegerLiteral(IntegerLiteral node, CloningAstVisitorContext context) { context.Result = new IntegerLiteral() { LiteralValue = node.LiteralValue }; }
public override object Visit(IntegerLiteral literal) { if (!literal.IsValid) { Report.AddError(literal.Position, InvalidLiteralMessage, literal.Value, StringEnum.GetStringValue(literal.GetType(null))); } return null; }
public void TestIntegerLiteralAccept() { Mock <KoraliumSqlVisitor> mock = new Mock <KoraliumSqlVisitor>(); IntegerLiteral integerLiteral = new IntegerLiteral(); integerLiteral.Accept(mock.Object); mock.Verify(x => x.VisitIntegerLiteral(integerLiteral)); }
public override object Visit(IntegerLiteral literal) { if (!literal.IsValid) { Report.AddError(literal.Position, InvalidLiteralMessage, literal.Value, StringEnum.GetStringValue(literal.GetType(null))); } return(null); }
public void IntegerLiteral_ShouldPrint() { var ast = new IntegerLiteral(0, "123"); Assert.That(PrettyPrinter.ToString(ast), Is.EqualTo( @"Integer(123) ")); }
public void Visit(IntegerLiteral node) { try { Convert.ToInt32(node.AnchorToken.Value); } catch (Exception e) { throw new SemanticError("Invalid integer literal", node.AnchorToken); } }
// Expressions // Returns the TypeDenoter denoting the type of the expression. Does // not use the given object. public TypeDenoter VisitArrayExpression(ArrayExpression ast, Void arg) { var elemType = ast.ArrayAggregate.Visit(this); var pos = ast.Position; var il = new IntegerLiteral(ast.ArrayAggregate.ElementCount, pos); return(ast.Type = new ArrayTypeDenoter(il, elemType, pos)); }
internal IntegerLiteralPostfixExpressionValue(IntegerLiteral value) : base(PostfixExpressionType.IntegerLiteral) { Debug.Assert(value != null); this.Value = value; this.ValueAsString = value.ToString(); }
public void Visit(IntegerLiteral t, IEnvironment env) { if (debug) { System.Console.WriteLine("IntegerLiteral: " + t.GetType().ToString()); } result = t.Value; return; }
public virtual bool VisitIntegerLiteral(IntegerLiteral stmt) { if (!VisitExpr(stmt)) { return(false); } return(true); }
public OpenxmlFunction(VariableName variableName, SqlScriptableToken stringValue, IntegerLiteral flags, Optional<OpenxmlSchema> schema) { Debug.Assert(variableName != null); Debug.Assert(stringValue != null); Debug.Assert(schema != null); this.variableName = variableName; this.stringValue = stringValue; this.flags = (flags == null) ? 0 : (int)flags.Value; this.schema = schema; }
public virtual void visit(IntegerLiteral literal) { var intType = baseInfer.ExpectedType as IntegerType; if (intType != null) { baseInfer.ResultType = intType; } }
public void TestIntegerLiteralGetValue() { IntegerLiteral integerLiteral = new IntegerLiteral() { Value = 3 }; Assert.AreEqual(3, integerLiteral.GetValue()); }
public override AstNode VisitIntegerLiteral(IntegerLiteral ast) { switch (ast.Value) { case -1: m_ilgen.Emit(OpCodes.Ldc_I4_M1); break; case 0: m_ilgen.Emit(OpCodes.Ldc_I4_0); break; case 1: m_ilgen.Emit(OpCodes.Ldc_I4_1); break; case 2: m_ilgen.Emit(OpCodes.Ldc_I4_2); break; case 3: m_ilgen.Emit(OpCodes.Ldc_I4_3); break; case 4: m_ilgen.Emit(OpCodes.Ldc_I4_4); break; case 5: m_ilgen.Emit(OpCodes.Ldc_I4_5); break; case 6: m_ilgen.Emit(OpCodes.Ldc_I4_6); break; case 7: m_ilgen.Emit(OpCodes.Ldc_I4_7); break; case 8: m_ilgen.Emit(OpCodes.Ldc_I4_8); break; default: if (ast.Value > 8 || ast.Value <= 127) { m_ilgen.Emit(OpCodes.Ldc_I4_S, (byte)ast.Value); } else { m_ilgen.Emit(OpCodes.Ldc_I4, ast.Value); } break; } return(ast); }
public void FalseLt() { var firstop = new IntegerLiteral("2", 0); var secondop = new IntegerLiteral("1", 0); var lt = new LogicalOp("<", firstop, secondop, 0); var assert = new ExpressionStatement("assert", lt, 0); program.Add(assert); Assert.Throws<MiniPLAssertionFailed>(() => interpreter.Run(new Program(program))); }
/// <summary> /// Constructor /// </summary> /// <param name="value">Field value</param> /// <param name="descriptor">CTF integer descriptor associated with the field</param> internal CtfIntegerValue(IntegerLiteral value, ICtfIntegerDescriptor descriptor) : base(CtfTypes.Integer) { this.Value = value; this.Descriptor = descriptor; this.MapValue = string.IsNullOrWhiteSpace(descriptor.Map) ? string.Empty : string.Intern(descriptor.Map); this.radix = descriptor.Base; }
private IntegerLiteral ParseIntegerLiteral() { var literal = new IntegerLiteral(currentToken); var value = long.Parse(currentToken.Literal); literal.LongValue = value; return(literal); }
protected FulltextTableFunction(ReservedKeyword keyword, Qualified<SchemaName, TableName> tableName, Expression query, Literal language, IntegerLiteral top) { Debug.Assert(keyword != null); Debug.Assert(tableName != null); Debug.Assert(query != null); this.keyword = keyword; this.tableName = tableName; this.query = query; this.language = language; this.top = top; }
internal CtfIntegerRange(ICtfIntegerDescriptor rangeBase, IntegerLiteral begin, IntegerLiteral end) { Debug.Assert(rangeBase != null); Debug.Assert(begin != null); Debug.Assert(end != null); this.Base = rangeBase; this.Begin = begin; this.End = end; }
public string Visit(IntegerLiteral node) { try { var num = Convert.ToInt32(node.AnchorToken.Value); return("\t\tldc.i4 " + num + "\n"); } catch (Exception e) { Console.WriteLine(e); throw new SemanticError("Invalid integer literal", node.AnchorToken); } }
public void TestVisitIntegerLiteral() { IntegerLiteral integerLiteral = new IntegerLiteral(); KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor(); koraliumSqlVisitor.Visit(integerLiteral); //Nothing to verify yet, only that no exceptions are thrown Assert.Pass(); }
public void ProcessAction(Stack <Ast> semanticStack, Symbol symbol, Token lastToken) { switch (symbol) { case Symbol.MakePlus: { var right = semanticStack.Pop(); var left = semanticStack.Pop(); var node = new PlusOperator(position: 0, left: (Expr)left, right: (Expr)right); semanticStack.Push(node); return; } case Symbol.MakeTimes: { var right = semanticStack.Pop(); var left = semanticStack.Pop(); var node = new TimesOperator(position: 0, left: (Expr)left, right: (Expr)right); semanticStack.Push(node); return; } case Symbol.MakeIdentifier: { var value = lastToken.Value; var node = new Identifier(position: 0, value: value); semanticStack.Push(node); return; } case Symbol.MakeIntegerLiteral: { var node = new IntegerLiteral(position: 0, value: lastToken.Value); semanticStack.Push(node); return; } case Symbol.MakeMakeBooleanTrueLiteral: { var node = new BooleanLiteral(position: 0, value: true); semanticStack.Push(node); return; } case Symbol.MakeMakeBooleanFalseLiteral: { var node = new BooleanLiteral(position: 0, value: false); semanticStack.Push(node); return; } default: throw new ArgumentOutOfRangeException(nameof(symbol), symbol, null); } }
public void TestCloneIntegerLiteral() { IntegerLiteral integerLiteral = new IntegerLiteral() { Value = 3 }; var clone = integerLiteral.Clone() as IntegerLiteral; Assert.AreEqual(integerLiteral, clone); Assert.IsFalse(ReferenceEquals(integerLiteral, clone)); }
private int create_sizes_from_initializer_list(CodeContext context, InitializerList il, int rank, List <Literal> sl) { if (sl.Count == (this.rank - rank)) { // only add size if this is the first initializer list of the current dimension var init = new IntegerLiteral(il.size.ToString(), il.source_reference); init.check(context); sl.Add(init); } int subsize = -1; foreach (Expression e in il.get_initializers()) { if (e is InitializerList) { if (rank == 1) { il.error = true; e.error = true; Report.error(e.source_reference, "Expected array element, got array initializer list"); return(-1); } int size = create_sizes_from_initializer_list(context, (InitializerList)e, rank - 1, sl); if (size == -1) { return(-1); } if (subsize >= 0 && subsize != size) { il.error = true; Report.error(il.source_reference, "Expected initializer list of size %d, got size %d".printf(subsize, size)); return(-1); } else { subsize = size; } } else { if (rank != 1) { il.error = true; e.error = true; Report.error(e.source_reference, "Expected array initializer list, got array element"); return(-1); } } } return(il.size); }
public static IntegerLiteral CreateIntegerLiteral(string value) { IntegerLiteral ast = null; if (value != null) { ast = new IntegerLiteral() { Value = value }; } return ast; }
public void NonIntegerLoopVariable(string type) { var variabledecl = new VariableDeclaration("foo", type, 0); statementlist.Add(variabledecl); var variable = new VariableReference("foo", 0); var integer = new IntegerLiteral("5", 0); var range = new Range(integer, integer, 0); var variabledecl2 = new VariableDeclaration("bar", "int", 0); var loopbody = new List<Statement>(); loopbody.Add(variabledecl2); var loop = new Loop(variable, range, loopbody, 0); statementlist.Add(loop); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public virtual void VisitIntegerLiteral(IntegerLiteral n) { }
public void UnaryNot() { var integer = new IntegerLiteral("42", 0); var and = new LogicalOp("=", integer, integer, 0); var not = new UnaryNot(and, 0); var assert = new ExpressionStatement("assert", and, 0); statementlist.Add(assert); var parsetree = new Program(statementlist); Assert.DoesNotThrow(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public TypeNameWithScale(SqlIdentifier identifier, IntegerLiteral precision, IntegerLiteral scale): base(identifier, precision) { Debug.Assert(scale != null); this.scale = scale.Value; }
public override void Visit(IntegerLiteral node) { this.action(node); }
public void SeveralVariableDeclarationsBeforeLoop(string type) { var intdeclaration = new VariableDeclaration("foo", "int", 0); var otherdeclaration = new VariableDeclaration("bar", type, 0); var variableref = new VariableReference("bar", 0); var integer = new IntegerLiteral("5", 0); var range = new Range(integer, integer, 0); var loop = new Loop(variableref, range, new List<Statement>(), 0); statementlist.Add(intdeclaration); statementlist.Add(otherdeclaration); statementlist.Add(loop); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public QueryMaxrecursionHint(IntegerLiteral maxRecursion) { this.maxRecursion = maxRecursion.Value; }
public override AstNode VisitIntegerLiteral(IntegerLiteral ast) { switch (ast.Value) { case -1: m_ilgen.Emit(OpCodes.Ldc_I4_M1); break; case 0: m_ilgen.Emit(OpCodes.Ldc_I4_0); break; case 1: m_ilgen.Emit(OpCodes.Ldc_I4_1); break; case 2: m_ilgen.Emit(OpCodes.Ldc_I4_2); break; case 3: m_ilgen.Emit(OpCodes.Ldc_I4_3); break; case 4: m_ilgen.Emit(OpCodes.Ldc_I4_4); break; case 5: m_ilgen.Emit(OpCodes.Ldc_I4_5); break; case 6: m_ilgen.Emit(OpCodes.Ldc_I4_6); break; case 7: m_ilgen.Emit(OpCodes.Ldc_I4_7); break; case 8: m_ilgen.Emit(OpCodes.Ldc_I4_8); break; default: if (ast.Value > 8 || ast.Value <= 127) { m_ilgen.Emit(OpCodes.Ldc_I4_S, (byte)ast.Value); } else { m_ilgen.Emit(OpCodes.Ldc_I4, ast.Value); } break; } return ast; }
public void IntAssignmentTest() { var variable = new VariableDeclaration("foo", "int", 0); var integer = new IntegerLiteral("4", 0); var assignment = new Assignment(variable, integer, 0); statementlist.Add(assignment); var parsetree = new Program(statementlist); var symbolTable = symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree); Assert.That(symbolTable.resolve("foo"), Is.InstanceOf<Symbol>()); Assert.That(symbolTable.resolve("foo").Type, Is.EqualTo("int")); }
public void LogicalOpLt() { var integer = new IntegerLiteral("1", 0); var lt = new LogicalOp("<", integer, integer, 0); var assert = new ExpressionStatement("assert", lt, 0); statementlist.Add(assert); var parsetree = new Program(statementlist); Assert.DoesNotThrow(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public void IntegerArgumentToNot() { var integer = new IntegerLiteral("5", 0); var not = new UnaryNot(integer, 0); var assert = new ExpressionStatement("assert", not, 0); statementlist.Add(assert); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public void UndefinedVariable() { var variable = new VariableReference("foo", 0); var integer = new IntegerLiteral("42", 0); var assignment = new Assignment(variable, integer, 0); statementlist.Add(assignment); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public void IntegerOverflow() { var integer = new IntegerLiteral("9999999999999999999999999999", 0); var print = new ExpressionStatement("print", integer, 0); statementlist.Add(print); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public TypeNameWithPrecision(SqlIdentifier identifier, IntegerLiteral precision): base(identifier) { Debug.Assert(precision != null); this.precision = precision.Value; }
public Expression TypeCheck(IntegerLiteral integerLiteral, Scope scope) { var position = integerLiteral.Position; var digits = integerLiteral.Digits; int value; if (Int32.TryParse(digits, out value)) return new IntegerLiteral(position, digits, NamedType.Integer); LogError(CompilerError.InvalidConstant(position, digits)); return integerLiteral; }
public void NonBooleanArgumentsToAnd() { var integer = new IntegerLiteral("5", 0); var equal = new LogicalOp("=", integer, integer, 0); var and = new LogicalOp("&", equal, integer, 0); var assert = new ExpressionStatement("assert", and, 0); statementlist.Add(assert); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
private static bool ParseIntegerLiteral( IList<TSqlParserToken> tokens, ref int nextToken, ref Literal result, ref int farestError) { var currentToken = nextToken; var value = ""; if (!ReadToken(tokens, TSqlTokenType.Integer, ref value, ref currentToken, ref farestError)) return false; result = new IntegerLiteral { FirstTokenIndex = currentToken - 1, LastTokenIndex = currentToken - 1, Value = value, }; nextToken = currentToken; return true; }
public override void ExplicitVisit(IntegerLiteral fragment) { _fragments.Add(fragment); }
public void LogicalOpEquals() { var integer = new IntegerLiteral("1", 0); var stringlit = new StringLiteral("\"foobar\"", 0); var equal = new LogicalOp("=", integer, stringlit, 0); var assert = new ExpressionStatement("assert", equal, 0); statementlist.Add(assert); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public IndexOptionGroupFillfactor(IntegerLiteral fillfactor) { this.fillfactor = fillfactor; }
public override AstNode VisitIntegerLiteral(IntegerLiteral ast) { ast.ExpressionType = PrimaryType.Int; //check literal int value; if (!Int32.TryParse(ast.Literal.Value, out value)) { m_errorManager.AddError(c_SE_InvalidIntLiteral, ast.Literal.Span, ast.Literal.Value); } else { ast.Value = value; } return base.VisitIntegerLiteral(ast); }
public void FaultyArithmetic() { var variable = new VariableDeclaration("foo", "int", 0); var integer = new IntegerLiteral("42", 0); var stringlit = new StringLiteral("\"foobar\"", 0); var plus = new ArithmeticOp("+", integer, integer, 0); var times = new ArithmeticOp("*", stringlit, plus, 0); var assignment = new Assignment(variable, times, 0); statementlist.Add(assignment); var parsetree = new Program(statementlist); Assert.Throws<SemanticError>(() => symbolTableBuilder.BuildSymbolTableAndTypeCheck(parsetree)); }
public IdentityFunction(TypeName typeName, IntegerLiteral seed, IntegerLiteral increment) { Debug.Assert(typeName != null); this.typeName = typeName; this.seed = seed; this.increment = increment; }
public IndexOptionNumeric(Identifier key, IntegerLiteral value): base(key) { Debug.Assert(value != null); this.value = value; }