compile.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-3.0-only
 
#pragma once
 
#include <ctu_interop_api.h>
 
#include "scan/scan.h"
 
#include "base/panic.h"
 
#include <limits.h>
 
typedef struct io_t io_t;
typedef struct scan_t scan_t;
 
CT_BEGIN_API
 
 
typedef struct scan_callbacks_t
{
    int (*init)(scan_t *extra, void *scanner);                   
    int (*parse)(void *scanner, scan_t *extra);                  
    void *(*scan)(const char *text, size_t size, void *scanner); 
    void (*destroy_buffer)(void *buffer, void *scanner);         
    void (*destroy)(void *scanner);                              
} scan_callbacks_t;
 
 
#define CT_CALLBACKS(id, prefix)                                                                \
    static int prefix##_##id##_##init(scan_t *extra, void *scanner)                             \
    {                                                                                           \
        return prefix##lex_init_extra(extra, (yyscan_t *)scanner);                              \
    }                                                                                           \
    static int prefix##_##id##_parse(void *scanner, scan_t *extra)                              \
    {                                                                                           \
        return prefix##parse(scanner, (scan_t *)extra);                                         \
    }                                                                                           \
    static void *prefix##_##id##_scan(const char *text, size_t size, void *scanner)             \
    {                                                                                           \
        CTASSERTF(size <= INT_MAX, #prefix "_scan (size = %zu > %d, name = %s)", size, INT_MAX, \
                  scan_path((scan_t *)scanner));                                                \
        return prefix##_scan_bytes(text, (int)size, scanner);                                   \
    }                                                                                           \
    static void prefix##_##id##_destroy_buffer(void *buffer, void *scanner)                     \
    {                                                                                           \
        prefix##_delete_buffer((YY_BUFFER_STATE)buffer, scanner);                               \
    }                                                                                           \
    static void prefix##_##id##_destroy(void *scanner)                                          \
    {                                                                                           \
        prefix##lex_destroy(scanner);                                                           \
    }                                                                                           \
    static const scan_callbacks_t id = {                                                        \
        .init = prefix##_##id##_##init,                                                         \
        .parse = prefix##_##id##_parse,                                                         \
        .scan = prefix##_##id##_scan,                                                           \
        .destroy_buffer = prefix##_##id##_destroy_buffer,                                       \
        .destroy = prefix##_##id##_destroy,                                                     \
    }
 
typedef enum parse_error_t
{
    eParseOk,
 
    eParseInitError,
 
    eParseScanError,
 
    eParseReject,
 
    eParseCount
} parse_error_t;
 
typedef struct parse_result_t
{
    parse_error_t result;
 
    union {
        void *tree;
        int error;
    };
} parse_result_t;
 
CT_INTEROP_API parse_result_t scan_buffer(
    IN_NOTNULL scan_t *scan,
    IN_NOTNULL const scan_callbacks_t *callbacks);
 
 
CT_END_API