public Expr Parse(ParserContext context) { // Create a lambda expression. LambdaExpr lambda = new LambdaExpr(); // Parse the formal arguments. FormalArgs args = new FormalArgsParser().Parse(context); // Assign the parsed arguments to the lambda. lambda.Args = args; // Create the type buffer, defaulting to void. ITypeEmitter type = PrimitiveTypeFactory.Void(); // Return type is explicitly specified, parse and use it instead of the default. if (context.Stream.Current.Type == TokenType.SymbolColon) { // Ensure current type is symbol colon. context.Stream.EnsureCurrent(TokenType.SymbolColon); // Skip symbol colon token. context.Stream.Skip(); // Parse the return type. type = new TypeParser().Parse(context); } // Assign the parsed type to the return type. lambda.ReturnType = type; // Ensure current token is symbol arrow. context.Stream.EnsureCurrent(TokenType.SymbolArrow); // Skip arrow symbol token. context.Stream.Skip(); // Parse the body block. Block body = new BlockParser().Parse(context); // Assign the block to the lambda. lambda.Body = body; // Return the resulting expression. return(lambda); }
public Function Parse(TokenStream stream) { // Parse the prototype from the stream, this captures the name, arguments and return type. Prototype prototype = new PrototypeParser().Parse(stream); // Create the function. var function = new Function(); // Assign the function prototype to the parsed prototype. function.Prototype = prototype; // Parse the body. Block body = new BlockParser().Parse(stream); // Set the name of the body block. body.SetNameEntry(); // Assign the body. function.Body = body; return(function); }
public Function Parse(ParserContext context) { // Create the attribute buffer list. List <Attribute> attributes = new List <Attribute>(); // Parse attribute if applicable. while (context.Stream.Current.Type == TokenType.SymbolBracketL) { // Invoke attribute parser. Attribute attribute = new AttributeParser().Parse(context); // Append the resulting attribute onto the buffer list. attributes.Add(attribute); } // Parse the prototype from the stream, this captures the name, arguments and return type. Prototype prototype = new PrototypeParser().Parse(context); // Create the function. Function function = new Function(); // Assign the function attributes. function.Attributes = attributes.ToArray(); // Assign the function prototype to the parsed prototype. function.Prototype = prototype; // Parse the body. Block body = new BlockParser().Parse(context); // Set the name of the body block. body.SetNameEntry(); // Assign the body. function.Body = body; // Return the function. return(function); }
public IfExpr Parse(ParserContext context) { // Ensure current token type is keyword if. context.Stream.EnsureCurrent(SyntaxAnalysis.TokenType.KeywordIf); // Skip if keyword token. context.Stream.Skip(); // Invoke parentheses expression parser to parse condition. Expr condition = new ParenthesesExprParser().Parse(context); // Invoke block parser to parse if block, which is its action. Block action = new BlockParser().Parse(context); // Create the alternative action buffer. Block otherwise = null; // Capture the current token. Token token = context.Stream.Current; // If expression contains an alternative action. if (token.Type == SyntaxAnalysis.TokenType.KeywordElse) { // Skip else keyword token. context.Stream.Skip(); // Invoke a new block parser to parse the alternative action. otherwise = new BlockParser().Parse(context); } // Create the if expression entity. IfExpr ifExpression = new IfExpr(condition, action, otherwise); // Return the resulting if expression entity. return(ifExpression); }