public void TestTokenProperties()
{
IntegerToken lhs = new IntegerToken(2);
ReturnAndIncrementToken result = new ReturnAndIncrementToken(0, lhs);
Assert.AreEqual(lhs, result.Lhs);
}
public override string ToArmText()
{
return(this.Token switch
{
IntegerToken integerToken => integerToken.Value.ToString(),
_ => throw new NotImplementedException(),
});
protected void AddToken(int lineNo, Match matcher)
{
string id = matcher.Groups["id"].Value;
string comments = matcher.Groups["comments"].Value;
string integer = matcher.Groups["integer"].Value;
string str = matcher.Groups["string"].Value;
if (id != "")
{
if (comments == "")
{
Token token;
if (integer != "")
{
token = new IntegerToken(lineNo, int.Parse(integer));
}
else if (str != "")
{
token = new StrToken(lineNo, ToStringLiteral(str));
}
else
{
token = new IdToken(lineNo, id);
}
queue.Enqueue(token);
}
}
}
public bool TryScan(Pointer pointer, out Token token)
{
token = null;
if (pointer.Current != PLUS && pointer.Current != MINUS && !IsNumeric(pointer.Current))
{
return(false);
}
if ((pointer.Current == PLUS || pointer.Current == MINUS) && !IsNumeric(pointer.Next))
{
return(false);
}
string numericString = ScanNumericString(pointer, out bool isFloat);
if (isFloat)
{
token = new RealToken(float.Parse(numericString));
}
else
{
token = new IntegerToken(int.Parse(numericString));
}
return(true);
}
public void TestTokenProperties()
{
IntegerToken rhs = new IntegerToken(2);
ExistsToken result = new ExistsToken(0, rhs);
Assert.AreEqual(rhs, result.Rhs);
}
public void TestTokenProperties()
{
IntegerToken rhs = new IntegerToken(2);
IncrementAndReturnToken result = new IncrementAndReturnToken(0, rhs);
Assert.AreEqual(rhs, result.Rhs);
}
public void TestTokenProperties()
{
IntegerToken rhs = new IntegerToken(2);
ComplementToken result = new ComplementToken(0, rhs);
Assert.AreEqual(rhs, result.Rhs);
}
public void TestTokenProperties()
{
IntegerToken rhs = new IntegerToken(2);
IsNotEmptyToken result = new IsNotEmptyToken(0, rhs);
Assert.AreEqual(rhs, result.Rhs);
}
public void TestTokenProperties()
{
IntegerToken lhs = new IntegerToken(1);
IdentifierToken rhs = new IdentifierToken("blah");
PropertyAccessToken result = new PropertyAccessToken(0, lhs, rhs);
Assert.AreEqual(lhs, result.Host);
Assert.AreEqual(rhs, result.Property);
}
public void TestTokenProperties()
{
IntegerToken lhs = new IntegerToken(1);
IntegerToken rhs = new IntegerToken(2);
OrToken result = new OrToken(0, lhs, rhs);
Assert.AreEqual(lhs, result.Lhs);
Assert.AreEqual(rhs, result.Rhs);
}
public void TestTokenProperties()
{
BooleanToken test = new BooleanToken(true);
IntegerToken resultIfTrue = new IntegerToken(1);
IntegerToken resultIfFalse = new IntegerToken(2);
ConditionalOperatorToken result = new ConditionalOperatorToken(0, test, resultIfTrue, resultIfFalse);
Assert.AreEqual(test, result.Test);
Assert.AreEqual(resultIfTrue, result.ResultIfTrue);
Assert.AreEqual(resultIfFalse, result.ResultIfFalse);
}
public override bool Equals(object other, bool includeChildren)
{
if (!base.Equals(other, includeChildren))
{
return(false);
}
IntegerToken integerToken = (IntegerToken)other;
return(Radix == integerToken.Radix);
}
public MemoryImmediate(
OperatorToken leftBracket,
IntegerToken immediateAddress,
OperatorToken rightBracket)
: base(
OperandType.MemoryImmediate,
leftBracket,
immediateAddress,
rightBracket)
{
ImmediateAddress = immediateAddress;
}
public static ArmExpressionAst ParseArmExpressionAst(TokenStream stream)
{
var peek = stream.Peek();
return(peek switch
{
OpenParenToken _ => ArmExpressionParser.ParseArmSubexpressionAst(stream),
IdentifierToken _ => ArmExpressionParser.ParseDottedNotationExpressionAst(stream),
StringLiteralToken _ => ArmExpressionParser.ParseArmStringLiteralExpressionAst(stream),
IntegerToken _ => ArmExpressionParser.ParseArmNumericLiteralExpressionAst(stream),
_ => throw new InvalidOperationException(),
});
public bool Parse(ExpressionCompiler compiler)
{
int i = compiler.Pos;
int start = -1;
char ch;
while (i < compiler.Expression.Length)
{
ch = compiler.Expression[i++];
if (start == -1)
{
if (char.IsWhiteSpace(ch))
{
continue;
}
else if (char.IsDigit(ch))
{
start = i - 1;
}
else
{
return(false);
}
}
else if (!char.IsDigit(ch))
{
--i;
break;
}
}
if (start != -1)
{
string s = new string(compiler.Expression, start, i - start);
s = s.Trim();
try {
IntegerToken token = new IntegerToken(int.Parse(s), compiler.Pos);
compiler.Parent.AddChild(token);
compiler.Pos = i;
return(true);
} catch (System.FormatException e) {
throw new ParserException("integer", compiler.Pos, "Unable to parse as int: " + s, e);
}
}
return(false);
}
public BitnessDirectiveSymbol(
DirectiveToken directive,
IntegerToken bitness)
{
symbols.Add(directive);
symbols.Add(bitness);
Directive = directive.DirectiveType switch
{
DirectiveType.OperandSize => BitnessDirectiveType.Data,
DirectiveType.AddressSize => BitnessDirectiveType.Address,
_ => throw new InvalidOperationException($"Wrong directive type: {directive.DirectiveType}"),
};
Bitness = bitness.UnsignedValue switch
{
8 => DataWidth.Byte,
16 => DataWidth.Word,
32 => DataWidth.Dword,
64 => DataWidth.Qword,
_ => throw new InvalidOperationException($"Invalid bitness: {bitness.UnsignedValue}"),
};
}
public static bool TryParseNumberToken(this string value, out Token numberToken)
{
if (value.Contains("."))
{
var splitValue = value.Split('.', 'e', 'E');
if (splitValue.Length > 1 && splitValue[1].Length > 6)
{
if (!double.TryParse(value, out var d))
{
numberToken = null;
return(false);
}
numberToken = new DoubleToken(d);
return(true);
}
if (!float.TryParse(value, out var f))
{
numberToken = null;
return(false);
}
numberToken = new FloatToken(f);
return(true);
}
if (!long.TryParse(value, out var l))
{
numberToken = null;
return(false);
}
if (l >= int.MinValue && l <= int.MaxValue)
{
numberToken = new IntegerToken((int)l);
return(true);
}
numberToken = new LongToken(l);
return(true);
}
private Expression BuildInteger(IntegerToken iToken)
{
return(new Integer(iToken.Value));
}
public void TestSimpleInteger()
{
ValueToken result = new IntegerToken(123);
Assert.AreEqual(123, result.Value);
}
private Expression Factor()
{
Expression expr = null;
switch (look.Tag)
{
case '(':
Move();
expr = Bool();
Match(')');
return(expr);
case Tags.NUMBER:
IntegerToken token = (IntegerToken)look;
expr = new IntConstantExpression(token.Value);
Move();
return(expr);
case Tags.REAL:
RealToken realToken = (RealToken)look;
expr = new FloatConstantExpression(realToken.Value);
Move();
return(expr);
case Tags.TRUE:
Move();
return(BoolConstantExpression.True);;
case Tags.FALSE:
Move();
return(BoolConstantExpression.False);
case Tags.ID:
Move();
if (look.Tag == '(')
{
return(FuncCallExpression());
}
else
{
VariableUseExpression varUseExpr = VariableUseExpression();
if (look.Tag == Tags.INCR)
{
Expression incrExpr = UnaryArithmeticExpression.CreatePostIncrement(varUseExpr);
Move();
return(incrExpr);
}
if (look.Tag == Tags.DECR)
{
Expression decrExpr = UnaryArithmeticExpression.CreatePostDecrement(varUseExpr);
Move();
return(decrExpr);
}
if (look.Tag == '=')
{
Move();
return(new VariableAssignExpression(varUseExpr, Bool()));
}
return(varUseExpr);
}
}
Error("Syntax error");
return(null);
}
public Integer(IntegerToken t, SrcLoc location = null)
:
base(location)
{
Value = t;
}
private object IntegerValue(IntegerToken integerToken)
{
throw new NotImplementedException();
}
public IntegerConstExpression(IntegerToken value)
{
Value = value;
}
/// <summary>
/// </summary>
/// <param name="token"></param>
public ArmNumericLiteralExpressionAst(IntegerToken token)
{
this.Token = token ?? throw new ArgumentNullException(nameof(token));
}
public bool Parse(ExpressionCompiler compiler)
{
int i = compiler.Pos;
int start = -1;
char ch;
while (i < compiler.Expression.Length)
{
ch = compiler.Expression[i++];
if (start == -1)
{
if (char.IsWhiteSpace(ch))
{
continue;
}
else if (ch == '0')
{
if (i + 1 >= compiler.Expression.Length)
{
return(false);
}
char ch2 = compiler.Expression[i++];
char ch3 = compiler.Expression[i];
if (ch2 != 'b' || (ch3 != '0' && ch3 != '1'))
{
return(false);
}
start = i;
}
else
{
return(false);
}
}
else if (ch != '0' && ch != '1')
{
--i;
break;
}
}
if (start != -1)
{
string s = new string(compiler.Expression, start, i - start);
s = s.Trim();
try {
int value = Convert.ToInt32(s, 2);
IntegerToken token = new IntegerToken(value, compiler.Pos, 2);
compiler.Parent.AddChild(token);
compiler.Pos = i;
return(true);
} catch (System.FormatException e) {
throw new ParserException("binaryInteger", compiler.Pos, "Unable to parse as binary int: " + s, e);
}
}
return(false);
}
public ANodeIntegerLiteral(IntegerToken itok)
: base(itok.Location)
{
Integer = itok;
}
public void ReadNextToken()
{
SkipWhiteSpace();
switch (_char)
{
case '\0':
Token = EofToken.Instance;
break;
case '/':
ReadNextCharacter();
if (_char == '/')
{
ReadNextCharacter();
Token = DoubleSlashToken.Instance;
}
else
{
Token = SingleSlashToken.Instance;
}
break;
case '[':
ReadNextCharacter();
Token = LeftBracketToken.Instance;
break;
case ']':
ReadNextCharacter();
Token = RightBracketToken.Instance;
break;
case '=':
ReadNextCharacter();
Token = EqualToken.Instance;
break;
case ',':
ReadNextCharacter();
Token = CommaToken.Instance;
break;
case '\"':
ReadNextCharacter();
Token = new StringToken(ReadNextString());
break;
case 'M':
case 'm':
ReadNextKeyword("MESSAGE", () => MessageToken.Instance);
break;
case 'W':
case 'w':
ReadNextKeyword("WARNING", () => WarningToken.Instance);
break;
case 'E':
case 'e':
ReadNextKeyword("ERROR", () => ErrorToken.Instance);
break;
case 'P':
case 'p':
ReadNextCharacter();
if (char.ToUpper(_char) == 'R')
{
ReadNextKeyword("ROJECT", () => ProjectToken.Instance);
}
else if (char.ToUpper(_char) == 'A')
{
ReadNextKeyword("ATH", () => PathToken.Instance);
}
else
{
throw new ScanException(Expression);
}
break;
case 'T':
case 't':
ReadNextCharacter();
if (char.ToUpper(_char) != 'A')
{
throw new ScanException(Expression);
}
ReadNextCharacter();
if (char.ToUpper(_char) == 'R')
{
ReadNextKeyword("RGET", () => TargetToken.Instance);
}
else if (char.ToUpper(_char) == 'S')
{
ReadNextKeyword("SK", () => TaskToken.Instance);
}
else
{
throw new ScanException(Expression);
}
break;
case 'I':
case 'i':
ReadNextKeyword("ID", () => IdToken.Instance);
break;
case 'N':
case 'n':
ReadNextKeyword("NAME", () => NameToken.Instance);
break;
default:
if (char.IsDigit(_char))
{
Token = new IntegerToken(ReadNextInteger());
break;
}
throw new ScanException(Expression);
}
}
public IntegerConstantAstNode(IntegerToken value)
: base(value.Line, value.Column)
{
Value = value;
}
public IntegerNode(IntegerToken token)
{
Contract.Requires <ArgumentNullException>(token != null);
this.token = token;
}
public ImmediateOperand(IntegerToken integer)
: base(OperandType.Immediate, integer)
{
}
