public static SyntaxNode Parse(CobaltParser parser)
{
if (parser.Match(TokenClass.IDENTIFIER, "if", TokenClass.OPEN_PARAN, "("))
{
Statement ret = new Statement();
parser.Match(TokenClass.IDENTIFIER, TokenClass.OPEN_PARAN, typeof(Expression),
TokenClass.CLOSE_PARAN, typeof(Statement));
return ret;
}
else if (parser.Match(TokenClass.IDENTIFIER, "while", TokenClass.OPEN_PARAN, "("))
{
Statement ret = new Statement();
parser.Match(TokenClass.IDENTIFIER, TokenClass.OPEN_PARAN, typeof(Expression),
TokenClass.CLOSE_PARAN, typeof(Statement));
return ret;
}
else if (parser.Match(TokenClass.IDENTIFIER, TokenClass.ASSIGN))
{
Statement stn = new Statement();
parser.Term(stn, typeof(Identifier), TokenClass.ASSIGN, typeof(Expression), TokenClass.SEMI_COLON);
return stn;
}
else if (parser.Match(TokenClass.OPEN_BRACKET))
{
CodeBlock block = new CodeBlock();
parser.ReadToken();
while (parser.PeekToken() != null && parser.PeekToken().Class != TokenClass.CLOSE_BRACKET)
block.AddLeave(Statement.Parse(parser));
parser.ReadToken();
return block;
}
return null;
}
public ParseFromFileTests()
{
ILoggerFactory loggerFactory = new NullLoggerFactory();
Lexer = new CobaltLexer(loggerFactory);
Parser = new CobaltParser(loggerFactory);
}
public static Identifier Parse(CobaltParser parser)
{
Token tok = parser.ReadToken();
if (tok.Class != TokenClass.IDENTIFIER)
return null;
else
return new Identifier(tok.Value.ToString());
}
/// <summary>
/// Sets up the compiler instance with all needed components.
/// </summary>
/// <param name="loggerFactory">A logger factory to use to instantiate loggers.</param>
public CobaltCompiler(ILoggerFactory loggerFactory, ITargetCodeGenerator compilerBackend)
{
Logger = loggerFactory.CreateLogger <CobaltCompiler>();
Lexer = new CobaltLexer(loggerFactory);
Parser = new CobaltParser(loggerFactory);
Optimizer = new CobaltOptimizer(loggerFactory);
Analyzer = new CobaltSemanticAnalyzer(loggerFactory);
TargetCodeGenerator = compilerBackend;
}
static void Main(string[] args)
{
long l = 4 + 2 * 4 + (1 + 2 * 2);
Console.WriteLine(l);
CobaltLexer lexer = new CobaltLexer("{i = 5 + 5;x = 2; y = 3;}");
lexer.Scan();
CobaltParser parser = new CobaltParser(lexer.TokenList);
Console.ReadLine();
}
public static SyntaxNode Parse(CobaltParser parser)
{
ArgList list = new ArgList();
while (parser.PeekToken().Class != Lexer.TokenClass.CLOSE_PARAN)
{
list.AddLeave(Expression.Parse(parser));
if (parser.PeekToken().Class != Lexer.TokenClass.CLOSE_PARAN && parser.PeekToken().Class
!= Lexer.TokenClass.COMMA)
throw new Exception("Oh now");
}
parser.ReadToken();
return list;
}
private static SyntaxNode ParseLevel1BinOperation(CobaltParser parser)
{
SyntaxNode left = ParseLevel2BinOperation(parser);
if (parser.PeekToken() != null && parser.PeekToken().Class == TokenClass.BIN_OP
&& getPrecedence(parser.PeekToken().Value.ToString()) == 1)
{
string oper = parser.ReadToken().Value.ToString();
BinOp ret = new BinOp(BinaryOperation.BOOL_AND);
ret.AddLeave(left);
ret.AddLeave(ParseLevel1BinOperation(parser));
return ret;
}
return left;
}
private static void ParseBlock(CobaltParser parser)
{
}
private static void parse(CobaltParser parser, Statement parent)
{
parent.AddLeave(Parse(parser));
}
public static SyntaxNode Parse(CobaltParser parser)
{
return new Expression(ParseLevel0BinOperation(parser));
}
private static SyntaxNode ParseValue(CobaltParser parser)
{
if (parser.PeekToken().Class == TokenClass.IDENTIFIER)
return new Identifier(parser.ReadToken().Value.ToString());
else if (parser.PeekToken().Class == TokenClass.CONSTANT)
return new Constant((long)parser.ReadToken().Value);
else if (parser.PeekToken().Class == TokenClass.OPEN_PARAN)
{
parser.ReadToken();
SyntaxNode ret = ParseLevel0BinOperation(parser);
if (parser.ReadToken().Class != TokenClass.CLOSE_PARAN)
throw new Exception("Expected )");
return ret;
}
else
{
Console.WriteLine(parser.PeekToken().Class);
return null;
}
}
private static SyntaxNode ParseLevel6BinOperation(CobaltParser parser)
{
SyntaxNode left = ParseValue(parser);
if (parser.PeekToken() != null && parser.PeekToken().Class == TokenClass.BIN_OP
&& getPrecedence(parser.PeekToken().Value.ToString()) == 6)
{
string oper = parser.ReadToken().Value.ToString();
Console.WriteLine(oper);
BinOp ret = new BinOp(oper == "*" ? BinaryOperation.MUL : BinaryOperation.DIV);
ret.AddLeave(left);
ret.AddLeave(ParseLevel6BinOperation(parser));
return ret;
}
return left;
}
/// <summary>
/// Sets up the test class with a parser instance to run the tests with.
/// </summary>
public ParserTests()
{
Parser = new CobaltParser(new LoggerFactory());
}
