public virtual CExpression Bin(CTokenType op, CExpression left, CExpression right)
{
return new CBinaryExpression
{
Operation = op,
Left = left,
Right = right
};
}
public CToken(CTokenType type) : this(type, null)
{
}
private CToken Tok(CTokenType type)
{
return new CToken(type);
}
private void Expect(CTokenType expected, object expectedValue)
{
var token = lexer.Read();
if (token.Type != expected)
throw new FormatException(string.Format("Expected '{0}' but got '{1}'.", expected, token.Type));
if (!expectedValue.Equals(token.Value))
throw new FormatException(string.Format("Expected '{0}' but got '{1}.", expectedValue, token.Value));
}
private object Expect(CTokenType expected)
{
var token = lexer.Read();
return Expect(expected, token);
}
public void ExpectCurrentType(CTokenType ExpectedType)
{
if (Current.Type != ExpectedType) throw(new Exception(String.Format("Expecting token type {0} but found {1}", ExpectedType, Current.Type)));
}
public CExpression Unary(CTokenType operation, CExpression expr)
{
return new CUnaryExpression { Operation = operation, Expression = expr };
}
private Exception Unexpected(CTokenType expected, CTokenType actual)
{
throw new FormatException(string.Format("Expected token '{0}' but saw '{1}' on line {2}.", expected, actual, lexer.LineNumber));
}
public CToken(CTokenType type, object value)
{
this.type = type;
this.value = value;
}
public CToken(CTokenType type) : this(type, null)
{
}
public CExpression Unary(CTokenType operation, CExpression expr)
{
return(new CUnaryExpression {
Operation = operation, Expression = expr
});
}
public TypeSpec SimpleType(CTokenType type)
{
return(new SimpleTypeSpec {
Type = type
});
}
public TypeQualifier TypeQualifier(CTokenType qualifier)
{
return(new TypeQualifier {
Qualifier = qualifier
});
}
public DeclSpec StorageClass(CTokenType token)
{
return(new StorageClassSpec {
Type = token
});
}
public CExpression PreIncrement(CTokenType token, CExpression uexpr)
{
throw new NotImplementedException();
}
private void Expect(CTokenType expectedType, object expectedValue)
{
var token = lexer.Read();
Assert.AreEqual(expectedType, token.Type);
Assert.AreEqual(expectedValue, token.Value);
}
public void AssertToken(CTokenType expType, object expectedValue)
{
var token = lex.Read();
Assert.AreEqual(expType, token.Type);
Assert.AreEqual(expectedValue, token.Value);
}
private CToken Tok(CTokenType type)
{
return(new CToken(type));
}
private void AssertToken(CTokenType exp)
{
var token = lex.Read();
Assert.AreEqual(exp, token.Type);
}
private CToken Tok(CTokenType type, object value)
{
return(new CToken(type, value));
}
public CExpression PostIncrement(CExpression e, CTokenType token)
{
return new IncrementExpression
{
Expression = e,
Incrementor = token,
Prefix = false
};
}
private void Expect(CTokenType expectedType)
{
var token = lexer.Read();
Assert.AreEqual(expectedType, token.Type);
}
private TypeSpec SType(CTokenType type)
{
return new SimpleTypeSpec { Type = type };
}
private void Peek(int n, CTokenType expectedType, string expectedValue)
{
var token = lexer.Peek(n);
Assert.AreEqual(expectedType, token.Type);
Assert.AreEqual(expectedValue, token.Value);
}
private object Expect(CTokenType expected, CToken actualToken)
{
if (actualToken.Type != expected)
throw new FormatException(string.Format("Expected '{0}' but got '{1}'.", expected, actualToken.Type));
return actualToken.Value;
}
public CExpression PreIncrement(CTokenType token, CExpression uexpr)
{
throw new NotImplementedException();
}
private static Token<CTokenType> GenerateToken(CTokenType type, string value = "", int line = 0)
{
var token = CToken.Create(new Token<TokenType>
{
LineNumber = line,
PositionInLine = 0,
Type = TokenType.INVALID,
Value = value
});
token.Type = type;
return token;
}
public DeclSpec StorageClass(CTokenType token)
{
return new StorageClassSpec { Type = token };
}
private CToken Tok(CTokenType type, object value)
{
return new CToken(type, value);
}
public TypeQualifier TypeQualifier(CTokenType qualifier)
{
return new TypeQualifier { Qualifier = qualifier };
}
public CToken(CTokenType type, object value)
{
this.type = type;
this.value = value;
}
public TypeSpec SimpleType(CTokenType type)
{
return new SimpleTypeSpec { Type = type };
}
private void AssertToken(CTokenType exp)
{
var token = lex.Read();
Assert.AreEqual(exp, token.Type);
}
public TypeSpec ComplexType(CTokenType token, int alignment, string tag, List<StructDecl> decls)
{
return new ComplexTypeSpec
{
Type = token,
Name = tag,
Alignment = alignment,
DeclList = decls,
};
}
private object ExpectToken(CTokenType token)
{
var t = lexer.Read();
if (t.Type != token)
throw Unexpected(token, t.Type);
return t.Value;
}
public Declarator CallConventionDeclarator(CTokenType conv, Declarator decl)
{
return new CallConventionDeclarator
{
Convention = conv,
Declarator = decl,
};
}
private bool PeekThenDiscard(CTokenType type)
{
if (lexer.Peek(0).Type != type)
return false;
lexer.Read();
return true;
}
private object Expect(CTokenType expected)
{
var token = lexer.Read();
return(Expect(expected, token));
}
