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