parser.c

Go to the documentation of this file.

// Copyright (C) 2023 Ethan Uppal. All rights reserved.
 
// TODO: this whole file
 
#include <stddef.h>  // NULL
#include <math.h>    // pow
#include "parser.h"
#include "tstream_short.h"
#include "error/error.h"
#include "util/arena.h"
#include "util/abort.h"
#include "frontend/analyzer/type.h"
#include "frontend/lexer/operator.h"
 
#define try_get_float(from, bind_to, do_)                                      \
    if (sscanf(from, "%lf", &bind_to) == 1) {                                  \
        do_                                                                    \
    }
 
#define PS_GROUP_MISMATCH_REFER(tkn)                                           \
    ps_error(PS_SCOPE_NOTE, PS_ECODE_MISMATCH, ts->file_ctx->buffer,           \
        (tkn)->loc, (tkn)->length, "to match opening parentheses",             \
        "Group opened here", NULL)
 
#define PS_END_STM(ctx)                                                        \
    do {                                                                       \
        if (!ps_tstream_peek(ts, 0, PS_TOKEN_RBRACE)) {                        \
            match(PS_TOKEN_NL, "at end of let statement") else {               \
                return NULL;                                                   \
            }                                                                  \
        }                                                                      \
    } while (0)
 
static enum ps_token_type literals_token_types[] = {
    PS_TOKEN_LIT_UNIT,
    PS_TOKEN_LIT_BIN,
    PS_TOKEN_LIT_OCT,
    PS_TOKEN_LIT_DEC,
    PS_TOKEN_LIT_HEX,
    PS_TOKEN_LIT_FLT,
    PS_TOKEN_LIT_CHR,
    PS_TOKEN_LIT_STR,
    PS_TOKEN_LIT_STR_INTERP,
    PS_TOKEN_LIT_FALSE,
    PS_TOKEN_LIT_TRUE,
};
 
static enum ps_token_type funcs_token_types[] = {
    PS_TOKEN_FUNC,
    PS_TOKEN_FUNC_INLINE,
    PS_TOKEN_FUNC_PRIVATE,
    PS_TOKEN_FUNC_PUBLIC,
    PS_TOKEN_FUNC_STATIC,
};
 
static void ps_parser_skip(struct ps_tstream* ts) {
    while (ps_tstream_peek(ts, 0, PS_TOKEN_NL)) {
        adv();
    }
}
 
struct ps_type_tuple* ps_parse_type_tuple(struct ps_tstream* ts) {
    // (
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_LPAR) != NULL, "precondition");
    struct ps_token* open = tcur();
    adv();
 
    // <type>, <type2>, ...
    struct ps_type_tuple* tuple = ps_type_tuple_new();
    while (!ps_tstream_peek(ts, 0, PS_TOKEN_RPAR)) {
        // get next type element
        struct ps_type* next = ps_parse_type_primary(ts);
        if (!next) {
            return NULL;
        }
        ps_push(&tuple, next);
 
        // if after a type we don't have a ), we should have a comma
        if (!ps_tstream_peek(ts, 0, PS_TOKEN_RPAR)) {
            match(PS_TOKEN_COMMA, "separating tuple type elements") else {
                return NULL;
            }
        }
    }
 
    // )
    match(PS_TOKEN_RPAR, "at end of tuple") else {
        PS_GROUP_MISMATCH_REFER(open);
        return NULL;
    }
 
    return tuple;
}
 
struct ps_type* ps_parse_type_primary(struct ps_tstream* ts) {
    struct ps_token* token = tcur();
    if (!token) {
        ps_tstream_eof_error(ts, PS_ECODE_INVALID_TYPE,
            "where type was expected", NULL);
        return NULL;
    }
    switch (token->type) {
        case PS_TOKEN_ID:
            adv();
            return ps_type_from_name(token);
        case PS_TOKEN_LIT_UNIT:
            adv();
            return ps_type_prim_new(PS_TYPE_UNIT);
        case PS_TOKEN_LPAR:
            return ps_type_from_tuple(ps_parse_type_tuple(ts));
        default:
            ps_error(PS_SCOPE_ERROR, PS_ECODE_INVALID_TYPE,
                ts->file_ctx->buffer, token->loc, token->length,
                "Invalid start of type", NULL, NULL);
            return NULL;
    }
}
 
struct ps_type* ps_parse_type(struct ps_tstream* ts) {
    struct ps_type* type = ps_parse_type_primary(ts);
    if (!type) {
        return NULL;
    }
    // while (ps_tstream_peek(ts, 0, PS_TOKEN_ARROW)) {
 
    // }
    return type;
}
 
struct ps_name* ps_parse_name(struct ps_tstream* ts, struct ps_token* first) {
    struct ps_name* name = ps_name_new();  // leak
 
    ps_push(&name, first);
 
    while (ps_tstream_peek(ts, 0, PS_TOKEN_SCOPE)) {
        adv();
        bindmatch(next, PS_TOKEN_ID, "after '::' in name") else {
            return NULL;
        }
        ps_push(&name, next);
    }
 
    return name;
}
 
struct ps_node_block* ps_parse_block(struct ps_tstream* ts) {
    // remember to use  ps_parser_skip so that extraneous newlines get ignored
 
    // {
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_LBRACE) != NULL, "precondition");
    struct ps_token* open = tcur();
    adv();
 
    ps_parser_skip(ts);
 
    struct ps_node_block* block = ps_node_block_new();
    // <statements>...
    while (!ps_tstream_peek(ts, 0, PS_TOKEN_RBRACE)) {
        struct ps_node* next = ps_parse_node(ts);
        if (!next) {
            return NULL;
        }
        ps_push(&block, next);
        ps_parser_skip(ts);
    }
 
    // }
    match(PS_TOKEN_RBRACE, "at end of block") else {
        PS_GROUP_MISMATCH_REFER(open);
        return NULL;
    }
 
    return block;
}
 
struct ps_node* ps_parse_let(struct ps_tstream* ts) {
    // let
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_LET) != NULL, "precondition");
    adv();
 
    // mut
    bool is_mutable = false;
    if (ps_tstream_peek(ts, 0, PS_TOKEN_MUT)) {
        is_mutable = true;
        adv();
    }
 
    // <name>
    bindmatch(name, PS_TOKEN_ID, "for variable name") else {
        return NULL;
    }
 
    // : <type>
    struct ps_type* type = NULL;
    if (ps_tstream_peek(ts, 0, PS_TOKEN_COLON)) {
        adv();
        type = ps_parse_type(ts);
        if (!type) {
            return NULL;
        }
    }
 
    // =
    match(PS_TOKEN_ASSIGN, "in let statement") else {
        return NULL;
    }
 
    // <value>
    struct ps_expr* value = ps_parse_expr(ts);
    if (!value) {
        return NULL;
    }
 
    // \n
    PS_END_STM("at end of let statement");
 
    return ps_node_let_new(name, is_mutable, type, value);
}
 
#define _PS_IS_FN_QUAL()                                                       \
    (ps_tstream_peek(ts, 0, PS_TOKEN_FUNC_INLINE)                              \
        || ps_tstream_peek(ts, 0, PS_TOKEN_FUNC_PRIVATE)                       \
        || ps_tstream_peek(ts, 0, PS_TOKEN_FUNC_PUBLIC)                        \
        || ps_tstream_peek(ts, 0, PS_TOKEN_FUNC_STATIC))
 
struct ps_node* ps_parse_fn(struct ps_tstream* ts) {
    /*
    static private inline fn name(arg1: Type1, arg2: Type2) -> ReturnType {
        <statement>*
    }
    */
 
    // fn
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_FUNC) || _PS_IS_FN_QUAL(),
        "precondition");
 
    enum ps_fn_qualifiers qualifiers = 0;
    while (_PS_IS_FN_QUAL()) {
        bindmatch_any(qualifier, funcs_token_types,
            "as function qualifier") else {
            return NULL;
        }
        switch (qualifier->type) {
            case PS_TOKEN_FUNC_INLINE:
                qualifiers |= PS_FN_INLINE;
                break;
            case PS_TOKEN_FUNC_PRIVATE:  // TODO: probably make these mutually
                                         // exclusive
                qualifiers |= PS_FN_PRIVATE;
                break;
            case PS_TOKEN_FUNC_PUBLIC:
                qualifiers |= PS_FN_PUBLIC;
                break;
            case PS_TOKEN_FUNC_STATIC:
                qualifiers |= PS_FN_STATIC;
                break;
            default:
                PS_NO_IMPL();
        }
    }
 
    match(PS_TOKEN_FUNC, "after function qualifiers") else {
        return NULL;
    }
 
    // <name>
    bindmatch(name, PS_TOKEN_ID, "for function name") else {
        return NULL;
    }
 
    struct ps_type_field_arr* params = ps_type_field_arr_new();
 
    if (ps_tstream_peek(ts, 0, PS_TOKEN_LIT_UNIT)) {
        // ()
        adv();
    } else {
        // (
        bindmatch(open, PS_TOKEN_LPAR, "after function name") else {
            return NULL;
        }
 
        // (<param>: <type>, <param2>: <type2>, ...)
        while (ps_tstream_peek(ts, 0, PS_TOKEN_ID)) {
            // <param>
            struct ps_token* param_name = tcur();
            adv();
 
            // :
            match(PS_TOKEN_COLON, "after argument name") else {
                return NULL;
            }
 
            // <type>
            struct ps_type* param_type = ps_parse_type(ts);
            if (!param_type) {
                return NULL;
            }
 
            /* clang-format off */
                struct ps_type_field field = {
                    .name = param_name->start, .type = param_type};
            /* clang-format on */
            ps_push(&params, field);
 
            // ,
            // after <param>: <type> we either want ) to end it or , for
            // another
            if (ps_tstream_peek(ts, 0, PS_TOKEN_COMMA)) {
                // if it is, skip past it
                adv();
            } else {
                // otherwise we need it to be a )
                match(PS_TOKEN_RPAR, "after arguments") else {
                    PS_GROUP_MISMATCH_REFER(open);
                    return NULL;
                }
                break;  // stop looking for new params
            }
        }
    }
 
    // -> <ret-type>
    struct ps_type* ret_type = NULL;
    if (ps_tstream_peek(ts, 0, PS_TOKEN_ARROW)) {
        adv();
        ret_type = ps_parse_type(ts);
        if (!ret_type) {
            return NULL;
        }
    }
 
    // { <body> }
    struct ps_node_block* body = ps_parse_block(ts);
    if (!body) {
        return NULL;
    }
 
    return ps_node_fn_new(name, ret_type, params, qualifiers, body);
}
 
struct ps_node* ps_parse_import(struct ps_tstream* ts) {
    // import
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_IMPORT) != NULL, "precondition");
    adv();
 
    bindmatch(first, PS_TOKEN_ID, "to start name") else {
        return NULL;
    }
    struct ps_name* name = ps_parse_name(ts, first);
    if (!name) {
        return NULL;
    }
 
    PS_END_STM("at end of import statement");
 
    return ps_node_import_new(name);
}
 
struct ps_node* ps_parse_extern(struct ps_tstream* ts) {
    // extern
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_EXTERN) != NULL, "precondition");
    adv();
 
    // <name>
    bindmatch(name, PS_TOKEN_ID, "for external function name") else {
        return NULL;
    }
 
    // (<sig>)
    struct ps_type_tuple* sig = ps_parse_type_tuple(ts);
    if (!sig) {
        return NULL;
    }
 
    PS_END_STM("at end of external declaration");
 
    return ps_node_extern_new(name, sig);
}
 
struct ps_node* ps_parse_struct(struct ps_tstream* ts) {
    // struct
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_STRUCT) != NULL, "precondition");
    adv();
    PS_NO_IMPL();
    return NULL;
}
 
struct ps_node* ps_parse_enum(struct ps_tstream* ts) {
    // enum
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_ENUM) != NULL, "precondition");
    adv();
    PS_NO_IMPL();
    return NULL;
}
 
struct ps_node* ps_parse_for(struct ps_tstream* ts) {
    // for
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_FOR) != NULL, "precondition");
    adv();
    PS_NO_IMPL();
    return NULL;
}
 
struct ps_node* ps_parse_while(struct ps_tstream* ts) {
    // while
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_WHILE) != NULL, "precondition");
    adv();
 
    // <guard>
    struct ps_expr* guard = ps_parse_expr(ts);
    if (!guard) {
        return NULL;
    }
 
    // { ... }
    struct ps_node_block* block = ps_parse_block(ts);
    if (!block) {
        return NULL;
    }
 
    return ps_node_while_new(guard, block);
}
 
struct ps_node* ps_parse_if(struct ps_tstream* ts) {
    // if
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_IF) != NULL, "precondition");
    adv();
 
    // <cond>
    struct ps_expr* cond = ps_parse_expr(ts);
    if (!cond) {
        return NULL;
    }
 
    // { ... }
    struct ps_node_block* then_block = ps_parse_block(ts);
    if (!then_block) {
        return NULL;
    }
 
    struct ps_node_block* else_block = NULL;
    if (ps_tstream_peek(ts, 0, PS_TOKEN_ELSE)) {
        // TODO: else if
        adv();
        else_block = ps_parse_block(ts);
        if (!else_block) {
            return NULL;
        }
    }
 
    return ps_node_if_new(cond, then_block, else_block);
}
 
struct ps_node* ps_parse_return(struct ps_tstream* ts) {
    // return
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_RET) != NULL, "precondition");
    adv();
 
    struct ps_expr* value = NULL;
    if (!(ps_tstream_peek(ts, 0, PS_TOKEN_NL)
            || ps_tstream_peek(ts, 0, PS_TOKEN_RBRACE))) {
        // <value>
        value = ps_parse_expr(ts);
        if (!value) {
            return NULL;
        }
        // \n
        PS_END_STM("at end of return statement");
    } else {
        // \n
        PS_END_STM("at end of return statement");
    }
 
    return ps_node_return_new(value);
}
 
struct ps_node* ps_parse_expr_stm(struct ps_tstream* ts) {
    struct ps_expr* expr = ps_parse_expr(ts);
    PS_END_STM("at end of expression statement");
    return ps_node_expr_stm_new(expr);
}
 
struct ps_expr* ps_parse_interp_str(struct ps_tstream* ts) {
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_LIT_STR_INTERP) != NULL,
        "precondition");
 
    struct ps_interp_str* string = ps_interp_str_new();
 
    // the format that the lexer produces is as follows:
    // (<str-interp-lit> <expr>)+ <str-lit>
 
    // continue to take interpolation literals followed by their expressions
    // e.g. <str-interp-lit> <expr>
    while (ps_tstream_peek(ts, 0, PS_TOKEN_LIT_STR_INTERP)) {
        ps_push(&string, ps_expr_lit_new_str(tcur()->start, tcur()));
        adv();
        struct ps_expr* following_expr = ps_parse_expr(ts);
        if (!following_expr) {
            return NULL;
        }
        ps_push(&string, following_expr);
    }
 
    // all interpolated strings end with a string literal token
    // e.g. <str-lit>
    bindmatch(end_str_literal, PS_TOKEN_LIT_STR,
        "at end of interpolated string") else {
        return NULL;
    }
    ps_push(&string,
        ps_expr_lit_new_str(end_str_literal->start, end_str_literal));
 
    return ps_expr_lit_new_interp_str(string);
}
 
struct ps_expr* ps_parse_expr_lit(struct ps_tstream* ts) {
    bindmatch_any(token, literals_token_types, "in expression literal") else {
        return NULL;
    }
 
    // TODO: check for integer out of bounds
    switch (token->type) {
        case PS_TOKEN_LIT_UNIT:
            return ps_expr_lit_new_unit(token);
        case PS_TOKEN_LIT_BIN:
            return ps_expr_lit_new_u64(strtoull(token->start + 2, NULL, 2),
                token);
        case PS_TOKEN_LIT_OCT:
            return ps_expr_lit_new_u64(strtoull(token->start + 2, NULL, 8),
                token);
        case PS_TOKEN_LIT_DEC:
            return ps_expr_lit_new_i64(strtoll(token->start, NULL, 10), token);
        case PS_TOKEN_LIT_HEX:
            return ps_expr_lit_new_u64(strtoull(token->start + 2, NULL, 16),
                token);
        case PS_TOKEN_LIT_FLT: {
            // parse float
            double float_val;
            try_get_float(token->start, float_val, {
                // handle scientific notation
                if (!eof() && tcur()->type == PS_TOKEN_E) {
                    adv();
                    bindmatch(exp_token, PS_TOKEN_LIT_DEC,
                        "for scientific notation exponent") else {
                        return NULL;
                    }
                    i64 exp_value = strtoll(exp_token->start, NULL, 10);
                    float_val *= pow(10.0, exp_value);
                }
 
                return ps_expr_lit_new_f64(float_val, token);
            }) else {
                ps_abort("lexer tokenized invalid floating point literal");
                return NULL;
            }
        }
        case PS_TOKEN_LIT_CHR:
            return ps_expr_lit_new_i64(token->start[0], token);
        case PS_TOKEN_LIT_STR:
            return ps_expr_lit_new_str(token->start, token);
        case PS_TOKEN_LIT_STR_INTERP: {
            unwind();  // see precondition for ps_parse_interp_str
            return ps_parse_interp_str(ts);
        }
        case PS_TOKEN_LIT_FALSE:
            return ps_expr_lit_new_bool(false, token);
        case PS_TOKEN_LIT_TRUE:
            return ps_expr_lit_new_bool(true, token);
        default:
            ps_abort("should not reach here");
            return NULL;
    }
}
 
struct ps_expr* ps_parse_expr_call(struct ps_tstream* ts,
    struct ps_token* callee) {
    // (
    ps_assert(ps_tstream_peek(ts, 0, PS_TOKEN_LPAR) != NULL, "precondition");
    adv();
 
    struct ps_expr_arr* args = ps_expr_arr_new();  // leak
    while (!ps_tstream_peek(ts, 0, PS_TOKEN_RPAR)) {
        // <arg>
        struct ps_expr* next = ps_parse_expr(ts);
        if (!next) {
            return NULL;
        }
        ps_push(&args, next);
 
        // ,
        if (!ps_tstream_peek(ts, 0, PS_TOKEN_RPAR)) {
            match(PS_TOKEN_COMMA, "between arguments") else {
                return NULL;
            }
        }
    }
 
    // )
    match(PS_TOKEN_RPAR, "at end of call") else {
        return NULL;
    }
 
    return ps_expr_call_new(callee, args);
}
 
struct ps_expr* ps_parse_expr_primary(struct ps_tstream* ts) {
    // handle end of file
    if (eof()) {
        ps_tstream_eof_error(ts, PS_ECODE_EXPECTED_EXPR,
            "where expression was expected", NULL);
        return NULL;
    }
 
    struct ps_token* cur = tcur();
 
    // unary operators
    if (ps_token_type_is_op(cur->type)) {
        const struct ps_operator* op = ps_token_type_get_op(cur->type);
        if (!op->is_unary) {
            ps_error(PS_SCOPE_ERROR, PS_ECODE_INVALID_OP, ts->file_ctx->buffer,
                cur->loc, cur->length,
                ast_sprintf("'%s' cannot be used here", cur->start),
                "Binary operator used as unary", NULL);
            return NULL;
        }
 
        // delegate to the helper but with `NULL` lhs
        return ps_parse_expr_helper(ts, NULL, op->unary_prec);
    }
 
    // parentheses: (<expr>)
    if (cur->type == PS_TOKEN_LPAR) {
        // (
        adv();
 
        // <expr>
        struct ps_expr* expr = ps_parse_expr(ts);
        if (!expr) {
            return NULL;
        }
 
        // )
        bindmatch(rpar, PS_TOKEN_RPAR, "in expression") else {
            PS_GROUP_MISMATCH_REFER(cur);
            return NULL;
        }
 
        return expr;
    }
 
    // variables
    if (cur->type == PS_TOKEN_ID) {
        adv();
        if (ps_tstream_peek(ts, 0, PS_TOKEN_LPAR)) {
            // calls
            return ps_parse_expr_call(ts, cur);
        } else if (ps_tstream_peek(ts, 0, PS_TOKEN_LIT_UNIT)) {
            // calls
            adv();
            return ps_expr_call_new(cur, ps_expr_arr_new());  // leak
        } else {
            return ps_expr_id_new(cur);
        }
    }
 
    // otherwise must be a literal
    return ps_parse_expr_lit(ts);
}
 
// https://en.wikipedia.org/wiki/Operator-precedence_parser#Pseudocode
struct ps_expr* ps_parse_expr_helper(struct ps_tstream* ts, struct ps_expr* lhs,
    ps_operator_precedence_t min_prec) {
    struct ps_token* lookahead = tcur();
    const struct ps_operator* op;
 
    while (lookahead && ps_token_type_is_op(lookahead->type)) {
        struct ps_token* old_lookahead = lookahead;
        op = ps_token_type_get_op(lookahead->type);
        if (!op->is_binary || !(op->binary_prec >= min_prec)) {
            break;
        }
        adv();  // past operator
 
        struct ps_expr* rhs = ps_parse_expr_primary(ts);
 
        lookahead = tcur();
        const struct ps_operator* op2;
 
        while (lookahead && ps_token_type_is_op(lookahead->type)) {
            op2 = ps_token_type_get_op(lookahead->type);
            if (!op2->is_binary) {
                break;
            }
            if (!(op2->is_left_associative
                    && op2->binary_prec > op->binary_prec)
                && !(!op2->is_left_associative
                     && op2->binary_prec >= op->binary_prec)) {
                break;
            }
            rhs = ps_parse_expr_helper(ts, rhs,
                op->binary_prec + (op2->binary_prec > op->binary_prec));
            lookahead = tcur();
        }
        if (lhs) {
            lhs = ps_expr_binary_new(lhs, old_lookahead, rhs);
        } else {
            lhs = ps_expr_unary_new(old_lookahead, rhs);
        }
    }
 
    return lhs;
}
 
struct ps_expr* ps_parse_expr(struct ps_tstream* ts) {
    return ps_parse_expr_helper(ts, ps_parse_expr_primary(ts), 0);
}
 
struct ps_node* ps_parse_node(struct ps_tstream* ts) {
    // TODO: impl
    switch (tcur()->type) {
        case PS_TOKEN_LET:
            return ps_parse_let(ts);
        case PS_TOKEN_FUNC_STATIC:
        case PS_TOKEN_FUNC_INLINE:
        case PS_TOKEN_FUNC_PRIVATE:
        case PS_TOKEN_FUNC_PUBLIC:
        case PS_TOKEN_FUNC:
            return ps_parse_fn(ts);
        case PS_TOKEN_IMPORT:
            return ps_parse_import(ts);
        case PS_TOKEN_EXTERN:
            return ps_parse_extern(ts);
        case PS_TOKEN_LBRACE: {
            struct ps_node_block* block = ps_parse_block(ts);
            return block ? ps_node_block_stm_new(block) : NULL;
        }
        case PS_TOKEN_STRUCT:
            return ps_parse_struct(ts);
        case PS_TOKEN_TRAIT:
            PS_NO_IMPL();
            return NULL;
        // return ps_parse_trait(ts);
        case PS_TOKEN_ENUM:
            return ps_parse_enum(ts);
        case PS_TOKEN_FOR:
            return ps_parse_for(ts);
        case PS_TOKEN_WHILE:
            return ps_parse_while(ts);
        case PS_TOKEN_IF:
            return ps_parse_if(ts);
        case PS_TOKEN_RET:
            return ps_parse_return(ts);
        default:
            return ps_parse_expr_stm(ts);
    }
}
 
struct ps_node_arr* ps_parse(struct ps_token_arr* tokens,
    const struct ps_file_ctx* file_ctx) {
    struct ps_tstream ts;
    ps_tstream_init(&ts, tokens, file_ctx);
    ps_parser_skip(&ts);
 
    struct ps_node_arr* nodes = ps_node_arr_new();
 
    // TODO: very similar to lexer lex code, see if can remove code duplication
    // Process tokens until 5 errors, then exit if any (up to 5) errors.
    int status = 0;
    while (!ps_tstream_is_eof(&ts)) {
        struct ps_node* next = ps_parse_node(&ts);
        ps_parser_skip(&ts);
        if (next) {
            ps_push(&nodes, next);
        } else {
            status = 1;
            if (ps_error_count() < PS_PARSER_MAX_ERRORS) {
                ps_parser_skip(&ts);
            } else {
                ps_error(PS_SCOPE_INFO, PS_ECODE_STOP, ts.file_ctx->buffer,
                    PS_LOC_NONE(), 1, "Stopping after max errors received.",
                    NULL, NULL);
                break;
            }
        }
    }
 
    if (status != 0) {
        ps_node_arr_free(nodes);
        return NULL;
    }
    return nodes;
}