exblex.h

Go to the documentation of this file.

 
#ifndef EXBLEX_H
#define EXBLEX_H
 
#include "../../src/common.h"
 
#include <ctype.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
 
 
struct exblex {
        const char *buf;
 
        const char *tokens;
 
        size_t token_count;
 
        /* --- Fields from now on should be zero-initialized. --- */
 
        size_t cur /* (current) Index lexing continues on. */;
 
        char pushback_char /* A character that was part of the input stream but
                            * not consumed by the previous token (e.g., the `+`
                            * in `abc+def`). */;
 
        char *current_seminfo /* Holds semantic information pointer of the last
                               * token and returns it in
                               * `exblex_current_seminfo`. */;
};
 
static inline uint16_t _exblex_priv_tokenid(const struct exblex *l, char tk)
{
        for (uint16_t i = 1; i <= l->token_count; i++)
                if (l->tokens[i] == tk)
                        return i;
 
        return 0;
}
static inline void exblex_init(struct exblex *l,
                               const char *buf,
                               const char *tokens)
{
        rdesc_assert(tokens[0] == '\0', "first element of tokens (tokens[0]) "
                     "should be '\\0'");
 
        *l = (struct exblex) {
                .buf = buf,
                .tokens = tokens,
                .token_count = strlen(tokens + 1),
                .cur = 0, .current_seminfo = NULL,
                .pushback_char = '\0',
        };
}
 
static inline char *exblex_current_seminfo(struct exblex *l)
{
        return l->current_seminfo;
}
 
static inline uint16_t exblex_next(struct exblex *l)
{
        while (l->buf[l->cur] && isspace(l->buf[l->cur]))
                l->cur++;
 
        char c = l->buf[l->cur++];
        char *seminfo = NULL;
        size_t seminfo_len = 0;
 
        bool is_num = true;
        while (isalnum(c) || c == '_') {
                if (seminfo == NULL) {
                        rdesc_assert(seminfo = malloc(sizeof(char) * 2),
                                     "malloc failed");
                        seminfo_len++;
                } else {
                        rdesc_assert(seminfo = realloc(seminfo, sizeof(char) * (++seminfo_len + 1)),
                                     "realloc failed");
                }
 
                if (!isdigit(c))
                        is_num = false;
 
                seminfo[seminfo_len - 1] = c;
 
                c = l->buf[l->cur++];
        }
 
        if (seminfo) {
                seminfo[seminfo_len] = '\0';
 
                l->cur--;
                int id = 0;
 
                if (is_num)
                        id = _exblex_priv_tokenid(l, 'd');
                else if (!isdigit(seminfo[0]))
                        id = _exblex_priv_tokenid(l, 'w');
 
                if (id) {
                        l->current_seminfo = seminfo;
 
                        return id;
                } else {
                        if (seminfo_len > 1)
                                c = '\0';
                        else
                                c = seminfo[0];
 
                        free(seminfo);
                }
        }
 
        return _exblex_priv_tokenid(l, c);
}
 
 
#endif