private static void ParseField(Lexer.Lexer lexer, out Exp k, out Exp v) { k = null; v = null; if (lexer.LookAhead() == ETokenType.SepLBracket) { lexer.NextToken(out _, out _, out _); k = ParseExp(lexer); lexer.NextTokenOfKind(ETokenType.SepRBracket, out _, out _); lexer.NextTokenOfKind(ETokenType.OpAssign, out _, out _); v = ParseExp(lexer); return; } var exp = ParseExp(lexer); if (exp is NameExp nameExp) { if (lexer.LookAhead() == ETokenType.OpAssign) { lexer.NextToken(out _, out _, out _); k = new StringExp { Line = nameExp.Line, Str = nameExp.Name }; v = ParseExp(lexer); return; } } v = exp; }
private static Stat ParseIfStat(Lexer.Lexer lexer) { var exps = new List <Exp>(); var blocks = new List <Block>(); lexer.NextTokenOfKind(ETokenType.KwIf, out _, out _); exps.Add(ParseExp(lexer)); lexer.NextTokenOfKind(ETokenType.KwThen, out _, out _); blocks.Add(ParseBlock(lexer)); while (lexer.LookAhead() == ETokenType.KwElseIf) { lexer.NextToken(out _, out _, out _); exps.Add(ParseExp(lexer)); lexer.NextTokenOfKind(ETokenType.KwThen, out _, out _); blocks.Add(ParseBlock(lexer)); } if (lexer.LookAhead() == ETokenType.KwElse) { lexer.NextToken(out _, out _, out _); exps.Add(new TrueExp { Line = lexer.Line }); blocks.Add(ParseBlock(lexer)); } lexer.NextTokenOfKind(ETokenType.KwEnd, out _, out _); return(new IfStat { Exps = exps, Blocks = blocks }); }
private static List<Exp> ParseRetExps(Lexer.Lexer lexer) { if (lexer.LookAhead() != ETokenType.KwReturn) return null; lexer.NextToken(out _, out _, out _); var ret = new List<Exp>(); switch (lexer.LookAhead()) { case ETokenType.Eof: case ETokenType.KwEnd: case ETokenType.KwElse: case ETokenType.KwElseIf: case ETokenType.KwUntil: return ret; case ETokenType.SepSemi: lexer.NextToken(out _, out _, out _); return ret; default: var exps = ParseExpList(lexer); if (lexer.LookAhead() == ETokenType.SepSemi) lexer.NextToken(out _, out _, out _); return exps; } }
private static Exp FinishPrefixExp(Lexer.Lexer lexer, Exp exp) { while (true) { switch (lexer.LookAhead()) { case ETokenType.SepLBracket: { lexer.NextToken(out _, out _, out _); var keyExp = ParseExp(lexer); lexer.NextTokenOfKind(ETokenType.SepRBracket, out _, out _); exp = new TableAccessExp { LastLine = lexer.Line, PrefixExp = exp, KeyExp = keyExp }; break; } case ETokenType.SepDot: { lexer.NextToken(out _, out _, out _); lexer.NextIdentifier(out var line, out var name); var keyExp = new StringExp { Line = line, Str = name }; exp = new TableAccessExp { LastLine = line, PrefixExp = exp, KeyExp = keyExp }; break; } case ETokenType.SepColon: case ETokenType.SepLParen: case ETokenType.SepLCurly: case ETokenType.String: { exp = FinishFuncCallExp(lexer, exp); break; } default: return(exp); } } }
private static Exp ParseExp5(Lexer.Lexer lexer) { var exp = ParseExp4(lexer); if (lexer.LookAhead() != ETokenType.OpConcat) { return(exp); } var line = 0; var exps = new List <Exp> { exp }; while (lexer.LookAhead() == ETokenType.OpConcat) { lexer.NextToken(out line, out _, out _); exps.Add(ParseExp4(lexer)); } return(new ConcatExp { Line = line, Exps = exps }); }
private static void ParseFieldList(Lexer.Lexer lexer, out List <Exp> ks, out List <Exp> vs) { ks = null; vs = null; if (lexer.LookAhead() != ETokenType.SepRCurly) { ParseField(lexer, out var k, out var v); ks = new List <Exp> { k }; vs = new List <Exp> { v }; while (IsFieldSep(lexer.LookAhead())) { lexer.NextToken(out _, out _, out _); if (lexer.LookAhead() != ETokenType.SepRCurly) { ParseField(lexer, out k, out v); ks.Add(k); vs.Add(v); } else { break; } } } }
public void Init() { var token = lexer.NextToken(); Console.WriteLine("First token"); Console.WriteLine(token.TokenType); Console.WriteLine(token.Value); }
private static void ParseFuncName(Lexer.Lexer lexer, out Exp exp, out bool hasColon) { hasColon = false; lexer.NextIdentifier(out var line, out var name); exp = new NameExp { Line = line, Name = name }; while (lexer.LookAhead() == ETokenType.SepDot) { lexer.NextToken(out _, out _, out _); lexer.NextIdentifier(out line, out name); var idx = new StringExp { Line = line, Str = name }; exp = new TableAccessExp { LastLine = line, KeyExp = idx, PrefixExp = exp, }; } if (lexer.LookAhead() == ETokenType.SepColon) { lexer.NextToken(out _, out _, out _); lexer.NextIdentifier(out line, out name); var idx = new StringExp { Line = line, Str = name }; exp = new TableAccessExp { LastLine = line, PrefixExp = exp, KeyExp = idx, }; hasColon = true; } }
private static List <Exp> ParseExpList(Lexer.Lexer lexer) { var exps = new List <Exp> { ParseExp(lexer) }; while (lexer.LookAhead() == ETokenType.SepComma) { lexer.NextToken(out _, out _, out _); exps.Add(ParseExp(lexer)); } return(exps); }
private static void ParseParList(Lexer.Lexer lexer, out List <string> parList, out bool isVararg) { parList = new List <string>(); isVararg = false; switch (lexer.LookAhead()) { case ETokenType.SepRParen: return; case ETokenType.Vararg: { lexer.NextToken(out _, out _, out _); isVararg = true; return; } } lexer.NextIdentifier(out _, out var name); parList.Add(name); while (lexer.LookAhead() == ETokenType.SepComma) { lexer.NextToken(out _, out _, out _); if (lexer.LookAhead() == ETokenType.Identifier) { lexer.NextIdentifier(out _, out name); parList.Add(name); } else { lexer.NextTokenOfKind(ETokenType.Vararg, out _, out _); isVararg = true; break; } } }
private static List <string> FinishNameList(Lexer.Lexer lexer, string name) { var names = new List <string> { name }; while (lexer.LookAhead() == ETokenType.SepComma) { lexer.NextToken(out _, out _, out _); lexer.NextIdentifier(out _, out var tokenName); names.Add(tokenName); } return(names); }
private static List <Exp> FinishVarList(Lexer.Lexer lexer, Exp prefixExp) { var vars = new List <Exp> { CheckVar(lexer, prefixExp) }; while (lexer.LookAhead() == ETokenType.SepComma) { lexer.NextToken(out _, out _, out _); var exp = ParsePrefixExp(lexer); vars.Add(CheckVar(lexer, exp)); } return(vars); }
private static StringExp ParseNameExp(Lexer.Lexer lexer) { if (lexer.LookAhead() == ETokenType.SepColon) { lexer.NextToken(out _, out _, out _); lexer.NextIdentifier(out var line, out var name); return(new StringExp { Line = line, Str = name, }); } return(null); }
private static List <Exp> ParseArgs(Lexer.Lexer lexer) { List <Exp> ret = null; switch (lexer.LookAhead()) { case ETokenType.SepLParen: { lexer.NextToken(out _, out _, out _); if (lexer.LookAhead() != ETokenType.SepRParen) { ret = ParseExpList(lexer); } lexer.NextTokenOfKind(ETokenType.SepRParen, out _, out _); break; } case ETokenType.SepLCurly: { ret = new List <Exp> { ParseTableConstructorExp(lexer) }; break; } default: { lexer.NextTokenOfKind(ETokenType.String, out var line, out var str); ret = new List <Exp> { new StringExp { Line = line, Str = str } }; break; } } return(ret); }
private static Stat FinishLocalVarDeclStat(Lexer.Lexer lexer) { lexer.NextIdentifier(out _, out var name0); var nameList = FinishNameList(lexer, name0); List <Exp> expList = null; if (lexer.LookAhead() == ETokenType.OpAssign) { lexer.NextToken(out _, out _, out _); expList = ParseExpList(lexer); } var lastLine = lexer.Line; return(new LocalVarDeclStat { ExpList = expList, LastLine = lastLine, NameList = nameList }); }
public static void Start() { while (true) { Console.Write(prompt); string input = Console.ReadLine(); if (input == string.Empty) { return; } var l = new Lexer.Lexer(input); Token token; do { token = l.NextToken(); Console.WriteLine(token); } while (token.Type.Equals(TokenType.EOF) == false); } }
private static Stat FinishForNumStat(Lexer.Lexer lexer, int lineOfToken, string name) { lexer.NextTokenOfKind(ETokenType.OpAssign, out _, out _); var initExp = ParseExp(lexer); lexer.NextTokenOfKind(ETokenType.SepComma, out _, out _); var limitExp = ParseExp(lexer); Exp stepExp; if (lexer.LookAhead() == ETokenType.SepComma) { lexer.NextToken(out _, out _, out _); stepExp = ParseExp(lexer); } else { stepExp = new IntegerExp { Line = lexer.Line, Val = 1 }; } lexer.NextTokenOfKind(ETokenType.KwDo, out var lineOfDo, out _); var block = ParseBlock(lexer); lexer.NextTokenOfKind(ETokenType.KwEnd, out _, out _); return(new ForNumStat { LineOfFor = lineOfToken, LineOfDo = lineOfDo, Block = block, InitExp = initExp, LimitExp = limitExp, StepExp = stepExp, VarName = name }); }
public void ConsumeNextToken() { lookahead[lookaheadIndex] = input.NextToken(); lookaheadIndex = (lookaheadIndex + 1) % lookaheadCount; }
private void NextToken() { _currentToken = _peekToken; _peekToken = _lexer.NextToken(); }
private static Exp ParseExp0(Lexer.Lexer lexer) { switch (lexer.LookAhead()) { case ETokenType.Vararg: { lexer.NextToken(out var line, out _, out _); return(new VarargExp { Line = line }); } case ETokenType.KwNil: { lexer.NextToken(out var line, out _, out _); return(new NilExp { Line = line }); } case ETokenType.KwTrue: { lexer.NextToken(out var line, out _, out _); return(new TrueExp { Line = line }); } case ETokenType.KwFalse: { lexer.NextToken(out var line, out _, out _); return(new FalseExp { Line = line }); } case ETokenType.String: { lexer.NextToken(out var line, out _, out var token); return(new StringExp { Line = line, Str = token }); } case ETokenType.Number: { return(ParseNumberExp(lexer)); } case ETokenType.SepLCurly: { return(ParseTableConstructorExp(lexer)); } case ETokenType.KwFunction: { lexer.NextToken(out _, out _, out _); return(ParseFuncDefExp(lexer)); } default: return(ParsePrefixExp(lexer)); } }