Esempio n. 1
0
        public static LinkedListNode <Lexeme> TryParse(LinkedListNode <Lexeme> lexemes, out StructLit resultNode)
        {
            List <StructLitStmt> stmts = new List <StructLitStmt>();

            resultNode = null;
            if (lexemes.Value.Type != LT.OP_BRACE_O)
            {
                return(lexemes);
            }

            LinkedListNode <Lexeme> nextLexeme = lexemes.Next;

            nextLexeme = StructLitStmt.TryParse(nextLexeme, out var stmt);
            if (stmt == null)
            {
                return(lexemes);
            }

            stmts.Add(stmt);

            while (nextLexeme.Value.Type == LT.OP_COMMA)
            {
                nextLexeme = nextLexeme.Next;
                nextLexeme = StructLitStmt.TryParse(nextLexeme, out stmt);
                if (stmt == null)
                {
                    break;
                }
                stmts.Add(stmt);
            }

            resultNode = new StructLit {
                Statements = stmts, Token = nextLexeme.Value
            };

            if (nextLexeme.Value.Type == LT.OP_BRACE_C)
            {
                nextLexeme = nextLexeme.Next;
            }
            else
            {
                throw new ArgumentException($"Missing closing brace at {nextLexeme.Value.File}:{nextLexeme.Value.Line}");
            }

            return(nextLexeme);
        }
Esempio n. 2
0
        public static LinkedListNode <Lexeme> TryParse(LinkedListNode <Lexeme> lexemes, out Literal resultNode)
        {
            resultNode = null;
            switch (lexemes.Value.Type)
            {
            case LT.LIT_STR:
                resultNode = new StringLit {
                    Data = lexemes.Value.Value, Token = lexemes.Value
                };
                break;

            case LT.LIT_CHAR:
                resultNode = new CharLit {
                    Data = lexemes.Value.Value[0], Token = lexemes.Value
                };
                break;

            case LT.LIT_FLOAT:
                if (!double.TryParse(lexemes.Value.Value, out var ddata))
                {
                    throw new ArgumentException($"Unrecognized float value {lexemes.Value.Value} at {lexemes.Value.File}:{lexemes.Value.Line}");
                }

                resultNode = new FloatLit {
                    Data = ddata, Token = lexemes.Value
                };
                break;

            case LT.LIT_INT:
                if (!int.TryParse(lexemes.Value.Value, out var idata))
                {
                    throw new ArgumentException($"Unrecognized integer value {lexemes.Value.Value} at {lexemes.Value.File}:{lexemes.Value.Line}");
                }

                resultNode = new IntLit {
                    Data = idata, Token = lexemes.Value
                };
                break;

            case LT.KW_TRUE:
                resultNode = new BoolLit {
                    Data = true, Token = lexemes.Value
                };
                break;

            case LT.KW_FALSE:
                resultNode = new BoolLit {
                    Data = false, Token = lexemes.Value
                };
                break;

            case LT.OP_BRACE_O:
                var newLexemes = StructLit.TryParse(lexemes, out StructLit slit);
                if (slit != null)
                {
                    resultNode = slit;
                    return(newLexemes);
                }
                newLexemes = ArrayLit.TryParse(lexemes, out ArrayLit alit);
                if (alit != null)
                {
                    resultNode = alit;
                    return(newLexemes);
                }

                break;

            default:
                return(lexemes);
            }

            return(lexemes.Next);
        }