tstream.c

Go to the documentation of this file.

// Copyright (C) 2023 Ethan Uppal. All rights reserved.
 
#include "tstream_short.h"
#include "error/error.h"  // ps_error et al.
#include "util/arena.h"   // ast_sprintf
#include "util/io.h"      // ps_file_ctx
 
inline void ps_tstream_init(struct ps_tstream* ts,
    const struct ps_token_arr* tokens, const struct ps_file_ctx* file_ctx) {
    ts->index = 0;
    ts->tokens = tokens;
    ts->file_ctx = file_ctx;
}
 
inline bool ps_tstream_is_eof(struct ps_tstream* ts) {
    return ts->index >= ts->tokens->length;
}
 
inline struct ps_token* ps_tstream_current(struct ps_tstream* ts) {
    return eof() ? NULL : (struct ps_token*)&ts->tokens->contents[ts->index];
}
 
inline void ps_tstream_advance_n(struct ps_tstream* ts, isize n) {
    ts->index += n;
}
 
struct ps_token* ps_tstream_peek(struct ps_tstream* ts, usize n,
    enum ps_token_type type) {
    if (ts->index + n < ts->tokens->length) {
        const struct ps_token* token = &ts->tokens->contents[ts->index + n];
        return token->type == type ? (struct ps_token*)token : NULL;
    }
    return NULL;
}
 
struct ps_token* ps_tstream_match(struct ps_tstream* ts,
    enum ps_token_type type, STR ctx) {
    struct ps_token* current = tcur();
 
    // handle end of file
    if (!current) {
        ps_tstream_eof_error(ts, -1, ctx,
            ast_sprintf("Expected '%s' here", ps_token_type_to_string(type)));
        return NULL;
    }
 
    // consume the token
    ps_tstream_advance(ts);
 
    // handle mismatch
    if (current->type != type) {
        ps_error(PS_SCOPE_ERROR, PS_ECODE_UNEXPECTED_TKN, ts->file_ctx->buffer,
            current->loc, current->length,
            ast_sprintf("Unexpected token %s", ctx),
            ast_sprintf("Expected '%s' here, received '%s' instead",
                ps_token_type_to_string(type),
                ps_token_type_to_string(current->type)),
            NULL);
        return NULL;
    }
 
    return current;
}
 
#define _PS_MATCH_N_ERROR_FIX_MSG                                              \
    ast_sprintf("Expected one of %zu options here, received '%s' instead",     \
        count, ps_token_type_to_string(current->type))
 
struct ps_token* ps_tstream_match_any(struct ps_tstream* ts,
    enum ps_token_type types[], usize count, STR ctx) {
    struct ps_token* current = tcur();
 
    // handle end of file
    if (!current) {
        ps_tstream_eof_error(ts, -1, ctx,
            ast_sprintf("Expected one of %zu options here", count));
        return NULL;
    }
 
    // consume the token
    ps_tstream_advance(ts);
 
    // check for match
    for (usize i = 0; i < count; i++) {
        if (current->type == types[i]) {
            return current;
        }
    }
 
    // handle mismatch
    ps_error(PS_SCOPE_ERROR, PS_ECODE_UNEXPECTED_TKN, ts->file_ctx->buffer,
        current->loc, current->length, ast_sprintf("Unexpected token %s", ctx),
        _PS_MATCH_N_ERROR_FIX_MSG, NULL);
    return NULL;
}
 
#undef _PS_MATCH_N_ERROR_FIX_MSG
 
void ps_tstream_eof_error(struct ps_tstream* ts, int code, STR ctx, STR fix) {
    ps_assert(ts->tokens->length > 0, "precondition");
 
    // use last token
    const struct ps_token* token =
        &ts->tokens->contents[ts->tokens->length - 1];
 
    ps_error(PS_SCOPE_ERROR, code == -1 ? PS_ECODE_UNEXPECTED_TKN : code,
        ts->file_ctx->buffer, token->loc, token->length,
        ast_sprintf("Unexpected end of file %s", ctx), fix, NULL);
}