public Reference Parse(ParserContext context) { // Ensure current token is of type symbol dollar. context.Stream.EnsureCurrent(TokenType.SymbolDollar); // Skip symbol dollar token. context.Stream.Skip(); // Invoke the identifier parser. string identifier = new IdentifierParser().Parse(context); // Create the reference construct. Reference reference = new Reference(identifier); // Return the resulting id construct. return(reference); }
public Kind Parse(ParserContext context) { // Ensure current type is symbol parentheses start. context.Stream.EnsureCurrent(TokenType.SymbolColon); // Skip parentheses start. context.Stream.Skip(); // Invoke identifier parser. string name = new IdentifierParser().Parse(context); // TODO: Pointer support. // Create the kind construct. Kind kind = new Kind(name); // Return the construct. return(kind); }
public Section Parse(ParserContext context) { // Invoke identifier parser to capture section name. string name = new IdentifierParser().Parse(context); // Ensure current token is of type symbol colon. context.Stream.EnsureCurrent(TokenType.SymbolColon); // Skip symbol colon. context.Stream.Skip(); // // Create the instruction buffer list. List <Instruction> instructions = new List <Instruction>(); // Create the token buffer. Token buffer = context.Stream.Current; // Begin instruction parsing. while (buffer.Type != TokenType.SymbolTilde) { // Invoke instruction parser. Instruction instruction = new InstructionParser().Parse(context); // Append the instruction to the list. instructions.Add(instruction); // Update the token buffer. buffer = context.Stream.Current; } // Ensure current token is of type symbol tilde. context.Stream.EnsureCurrent(TokenType.SymbolTilde); // Skip symbol tilde. context.Stream.Skip(); // Create the section construct. Section section = new Section(name, instructions.ToArray()); // Return the construct. return(section); }
public Metadata Parse(ParserContext context) { // Ensure current token type to be of symbol exclamation. context.Stream.EnsureCurrent(TokenType.SymbolExclamation); // Skip symbol exclamation token. context.Stream.Skip(); // TODO: Key and value are delimitered-string literals, not identifiers. // Parse key. string key = new IdentifierParser().Parse(context); // Parse the value. string value = new IdentifierParser().Parse(context); // Create the construct. Metadata metadata = new Metadata(key, value); // Return the construct. return(metadata); }
public Instruction Parse(ParserContext context) { string?resultIdentifier = null; if (context.Stream.Current.Type == TokenType.SymbolPercent) { context.Stream.Skip(); resultIdentifier = new IdentifierParser().Parse(context); context.Stream.EnsureCurrent(TokenType.SymbolEqual); context.Stream.Skip(); } string name = new IdentifierParser().Parse(context); // Create a buffer for the current token. Token token = context.Stream.Get(); // Create the inputs buffer list. List <IConstruct> inputs = new List <IConstruct>(); // Instruction contains arguments. while (token.Type != TokenType.SymbolSemiColon) { // Invoke the input parser. IConstruct input = new InputParser().Parse(context); // Append the input to the list. inputs.Add(input); // Update the buffer token. token = context.Stream.Get(); } // Ensure current token is of type semi-colon. context.Stream.EnsureCurrent(TokenType.SymbolSemiColon); // Skip semi-colon token. context.Stream.Skip(); Instruction inst; switch (name) { case InstructionName.End: { if (inputs.Count > 1) { throw new Exception("Unexpected amount of inputs"); } else if (!(inputs[0] is Value)) { throw new Exception("Expected input to be a value"); } inst = new EndInst(inputs[0] as Value); break; } default: { throw new Exception($"Unrecognized instruction name: {name}"); } } return(inst); }
public Routine Parse(ParserContext context) { // Ensure current token is of type symbol at. context.Stream.EnsureCurrent(TokenType.SymbolAt); // Skip symbol at token. context.Stream.Skip(); // Invoke the identifier parser. string identifier = new IdentifierParser().Parse(context); // Ensure current token is of type parentheses start. context.Stream.EnsureCurrent(TokenType.SymbolParenthesesL); // Skip parentheses start token. context.Stream.Skip(); // Capture the current token as the buffer. Token buffer = context.Stream.Current; // Create the argument buffer list. List <(Kind, Reference)> args = new List <(Kind, Reference)>(); // Begin argument parsing. while (buffer.Type != TokenType.SymbolParenthesesR) { // Invoke kind parser. Kind kind = new KindParser().Parse(context); // Invoke reference parser. Reference reference = new ReferenceParser().Parse(context); // Abstract current token. Token token = context.Stream.Current; // Current token must be symbol comma or parentheses end. if (token.Type != TokenType.SymbolParenthesesR && token.Type != TokenType.SymbolComma) { throw new Exception($"Unexpected token in argument list: {token.Type}"); } // Skip symbol comma token. else if (token.Type == TokenType.SymbolComma) { context.Stream.Skip(); } // Append the argument. args.Add((kind, reference)); // Update the buffer. buffer = context.Stream.Current; } // Ensure current token is symbol parentheses end. context.Stream.EnsureCurrent(TokenType.SymbolParenthesesR); // Skip parentheses end. context.Stream.Skip(); // Invoke kind parser to parse return kind. Kind returnKind = new KindParser().Parse(context); // Update the token buffer. buffer = context.Stream.Current; // Parse the body. Section body = new SectionParser().Parse(context); // Ensure current token is of type symbol tilde. context.Stream.EnsureCurrent(TokenType.SymbolTilde); // Skip symbol tilde. context.Stream.Skip(); // Create the prototype. Prototype prototype = new Prototype(identifier, args.ToArray(), returnKind, false); // Create the routine construct. Routine routine = new Routine(prototype, body); // Return the resulting routine. return(routine); }