public VarDeclareExpr Parse(ParserContext context) { // Parse the type. Type type = new TypeParser().Parse(context); // Create the variable declaration & link the type. VarDeclareExpr declaration = new VarDeclareExpr(type, null); // Invoke identifier parser. string identifier = new IdentifierParser().Parse(context); // Assign the name. declaration.SetName(identifier); // Capture current token. Token token = context.Stream.Current; // A value is being assigned. if (token.Type == SyntaxAnalysis.TokenType.OperatorAssignment) { // Skip the assignment operator. context.Stream.Skip(); // Parse value. Expr value = new ExprParser().Parse(context); // Assign value. declaration.Value = value; } // Return the resulting declaration construct. return(declaration); }
public PathResult Parse(ParserContext context) { // Create the resulting path's nodes. List <string> nodes = new List <string>(); // Invoke identifier parser to capture the node. string node = new IdentifierParser().Parse(context); // Append node to path. nodes.Add(node); // Use recursion if symbol dot is present. if (context.Stream.Current.Type == TokenType.SymbolDot) { // Skip symbol dot token. context.Stream.Skip(); // Create the parser instance. PathParser childParser = new PathParser(); // Invoke the parser. PathResult childParserPath = childParser.Parse(context); // Append resulting child parser's path(s) to the resulting path. nodes.AddRange(childParserPath.nodes); } // Create the resulting path. PathResult result = new PathResult(nodes); // Return the resulting path. return(result); }
public Alias Parse(ParserContext context) { // Ensure current token is alias keyword. context.Stream.EnsureCurrent(TokenType.KeywordAlias); // Skip alias keyword, capture target identifier. string targetName = context.Stream.Next(TokenType.Identifier).Value; // Skip target identifier onto as keyword. context.Stream.Skip(TokenType.KeywordAs); // Skip as keyword. context.Stream.Skip(); // Invoke identifier parser to capture alias name. string aliasName = new IdentifierParser().Parse(context); // Ensure current token is symbol semi-colon. context.Stream.EnsureCurrent(TokenType.SymbolSemiColon); // Skip semi-colon. context.Stream.Skip(); // Create the alias construct. Alias alias = new Alias(targetName, aliasName); // Return the resulting construct. return(alias); }
public StructDef Parse(ParserContext context) { // Ensure current token is struct keyword. context.Stream.EnsureCurrent(TokenType.KeywordStruct); // Skip struct keyword token. context.Stream.Skip(); // Invoke identifier parser. string identifier = new IdentifierParser().Parse(context); // Ensure current token is block start. context.Stream.EnsureCurrent(TokenType.SymbolBlockL); // Skip block start token. context.Stream.Skip(); // Create the properties buffer list. List <StructDefProperty> properties = new List <StructDefProperty>(); // Start iteration with callback. context.Stream.NextUntil(TokenType.SymbolBlockR, (Token token) => { // Invoke type parser. Type type = new TypeParser().Parse(context); // Invoke identifier parser. string name = new IdentifierParser().Parse(context); // Ensure current token is symbol semi-colon. context.Stream.EnsureCurrent(SyntaxAnalysis.TokenType.SymbolSemiColon); // Create property. StructDefProperty property = new StructDefProperty(type, name); // Attach property to the prototype. properties.Add(property); // Continue normal iteration. return(false); }); // Create the body construct. StructDefBody body = new StructDefBody(properties); // Ensure current token type is block end. context.Stream.EnsureCurrent(TokenType.SymbolBlockR); // Skip block end token. context.Stream.Skip(); // Create the struct construct. StructDef @struct = new StructDef(identifier, body); // Return the resulting struct construct. return(@struct); }
public Attribute Parse(ParserContext context) { // Ensure current token is bracket start. context.Stream.EnsureCurrent(TokenType.SymbolBracketL); // Skip bracket start. context.Stream.Skip(); // Create the native attribute flag. bool native = false; // Attribute is native. if (context.Stream.Current.Type == TokenType.OperatorLessThan) { // Raise the native attribute flag. native = true; // Skip over operator less than. context.Stream.Skip(); } // Invoke identifier parser. string identifier = new IdentifierParser().Parse(context); // If the attribute was flagged as native, skip the remaining delimiter. if (native) { // Ensure current token is operator greater than. context.Stream.EnsureCurrent(TokenType.OperatorGreaterThan); // Skip over operator greater then. context.Stream.Skip(); } // Ensure current token is bracket end. context.Stream.EnsureCurrent(TokenType.SymbolBracketR); // Skip bracket end. context.Stream.Skip(); // Create the attribute entity. Attribute attribute = new Attribute(identifier, native); // Return the attribute entity. return(attribute); }
public Prototype Parse(ParserContext context) { // Parse the return type. Type returnType = new TypeParser().Parse(context); // Invoke identifier parser. string identifier = new IdentifierParser().Parse(context); // Invoke the formal argument parser. FormalArgs args = new FormalArgsParser().Parse(context); // Create the resulting prototype entity. Prototype prototype = new Prototype(identifier, args, returnType); // Return prototype. return(prototype); }
public GlobalVar Parse(ParserContext context) { // Invoke type parser. Type type = new TypeParser().Parse(context); // Expect current token to be symbol at. context.Stream.EnsureCurrent(TokenType.SymbolAt); // Skip symbol at token. context.Stream.Skip(); // Invoke identifier parser. string identifier = new IdentifierParser().Parse(context); // Create the global variable. GlobalVar globalVar = new GlobalVar(identifier, type); // Return the global variable. return(globalVar); }
public StructExpr Parse(ParserContext context) { // Ensure current token is keyword new. context.Stream.EnsureCurrent(TokenType.KeywordNew); // Skip new keyword token. context.Stream.Skip(); // Invoke identifier parser. string identifier = new IdentifierParser().Parse(context); // Invoke struct body parser. List <StructProperty> body = new StructBodyParser().Parse(context); // Create the resulting struct. StructExpr @struct = new StructExpr(identifier, body); // Return the resulting struct. return(@struct); }
public StructProperty Parse(ParserContext context) { // Invoke identifier parser. string identifier = new IdentifierParser().Parse(context); // Ensure current token is symbol colon. context.Stream.EnsureCurrent(TokenType.SymbolColon); // Skip colon symbol token. context.Stream.Skip(); // Invoke expression parser to capture the value. Expr value = new ExprParser().Parse(context); // Create the resulting property construct. StructProperty property = new StructProperty(identifier, value, this.index); // Return the resulting property construct. return(property); }