akbasic/src/structtype.c

/**
 * @file structtype.c
 * @brief Implements the `TYPE` table and the prescan that fills it.
 *
 * The prescan is textual and runs before the program does, exactly as the label
 * and `DATA` prescans do and for the same reason: a declaration has to be in
 * effect wherever control goes, including when a branch skips the lines that
 * made it.
 *
 * **It is three passes, and each one exists for a case that cannot be done in
 * the pass before it.** Pass 1 registers names and line ranges, so a field can
 * name a type declared further down the program. Pass 2 parses field lists, now
 * able to resolve every type reference. Pass 3 computes sizes and offsets by
 * repeated resolution, because a type nested by value must know its own size
 * before its container can -- and a group of types that never resolve is
 * precisely a cycle of by-value containment, which is what makes "a TYPE cannot
 * contain itself by value" a diagnosis rather than an assumption.
 */

#include <ctype.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>

#include <akerror.h>
#include <akstdlib.h>

#include <akbasic/error.h>
#include <akbasic/runtime.h>
#include <akbasic/structtype.h>

#include "verbs.h"

/** @brief Step over spaces and tabs. */
static const char *skip_space(const char *cursor)
{
    while ( *cursor != '\0' && isspace((unsigned char)*cursor) ) {
	cursor += 1;
    }
    return cursor;
}

/**
 * @brief Step over a stored line's own line number, if it still carries one.
 *
 * Every path inside the library files what the scanner already stripped, but
 * akbasic_runtime_store_line() is public and a host may hand it a raw line, so
 * both spellings are real and both are handled here -- the same allowance
 * scan_line_labels() makes.
 */
static const char *skip_lineno(const char *cursor)
{
    cursor = skip_space(cursor);
    if ( isdigit((unsigned char)*cursor) ) {
	while ( isdigit((unsigned char)*cursor) ) {
	    cursor += 1;
	}
    }
    return skip_space(cursor);
}

/*
 * Room to read a word that is *too long* and still see that it was.
 *
 * Reading into a buffer the size of the limit truncates before anything can
 * check, so an over-long name would arrive already trimmed to fit and be
 * accepted -- which is how the length check below was unreachable when it was
 * first written. Twice the limit is enough to tell the two cases apart, and a
 * word longer than this is still longer than the limit, so it is refused either
 * way.
 */
#define STRUCT_WORD_SCRATCH	(AKBASIC_MAX_STRUCT_NAME * 2)

/** @brief Copy the next whitespace-delimited word, uppercased. Empty when the line ends. */
static const char *next_word(const char *cursor, char *dest, size_t len)
{
    size_t used = 0;

    dest[0] = '\0';
    cursor = skip_space(cursor);
    while ( *cursor != '\0' && !isspace((unsigned char)*cursor) ) {
	if ( used + 1 < len ) {
	    dest[used] = (char)toupper((unsigned char)*cursor);
	    used += 1;
	}
	cursor += 1;
    }
    dest[used] = '\0';
    return cursor;
}

/**
 * @brief Compare a word against a keyword. Verbs are case-insensitive here as everywhere.
 *
 * The answer leaves through @p dest rather than the return value because the
 * comparison itself can fail, and a `bool` has nowhere to put that. See
 * libakstdlib #38.
 */
static akerr_ErrorContext *word_is(const char *word, const char *keyword, bool *dest)
{
    PREPARE_ERROR(errctx);
    int cmp = 0;

    FAIL_ZERO_RETURN(errctx, (dest != NULL), AKERR_NULLPOINTER, "NULL dest in word_is");
    PASS(errctx, aksl_strcmp(word, keyword, &cmp));
    *dest = (cmp == 0);
    SUCCEED_RETURN(errctx);
}

/**
 * @brief The type a field name's suffix declares.
 *
 * The same rule every other name in the language follows, which is the reason a
 * field list needs no type column: `W#` is an integer because it says so.
 */
static akerr_ErrorContext *type_from_suffix(const char *name, akbasic_Type *dest)
{
    PREPARE_ERROR(errctx);
    size_t len = 0;

    PASS(errctx, aksl_strlen(name, &len));
    FAIL_ZERO_RETURN(errctx, (len >= 2), AKBASIC_ERR_SYNTAX,
		     "Field name \"%s\" carries no type suffix", name);
    switch ( name[len - 1] ) {
    case '#': *dest = AKBASIC_TYPE_INTEGER; break;
    case '%': *dest = AKBASIC_TYPE_FLOAT;   break;
    case '$': *dest = AKBASIC_TYPE_STRING;  break;
    case '@': *dest = AKBASIC_TYPE_STRUCT;  break;
    default:
	FAIL_RETURN(errctx, AKBASIC_ERR_SYNTAX,
		    "Field name \"%s\" carries no type suffix (# integer, %% float, $ string, @ structure)",
		    name);
    }
    SUCCEED_RETURN(errctx);
}

akerr_ErrorContext *akbasic_structtype_table_init(akbasic_StructTypeTable *obj)
{
    PREPARE_ERROR(errctx);

    FAIL_ZERO_RETURN(errctx, (obj != NULL), AKERR_NULLPOINTER, "NULL table in structtype init");
    PASS(errctx, aksl_memset(obj, 0, sizeof(*obj)));
    obj->count = 0;