/home/renji/Data/projects/zenlang/sources/zbl/Token.hpp

Go to the documentation of this file.

#pragma once

#ifdef INTERNAL_TOKEN_REF

#include "zbl/Ast.hpp"
#endif

namespace zbl {

    const int MaxTokenSize = 32;


    struct TokenData {
        int id;

        char svalue[MaxTokenSize];

        char* lvalue;

        bool hidden;

        int line;

        int col;

#ifdef INTERNAL_TOKEN_REF

        Ast::TypeSpec* typeSpec;

        const Ast::VariableDef* vdef;

        Ast::Storage::T storage;
#endif
    };


    struct Token : public TokenData {
        inline void initString(char* str, const int& len) {
            for(int i = 0; i < len; ++i) {
                str[i] = 0;
            }
        }

        inline void init() {
            id = 0;
            initString(svalue, zbl::MaxTokenSize);
            lvalue= 0;
            hidden = false;
            line = 0;
            col = 0;
#ifdef INTERNAL_TOKEN_REF
            typeSpec = 0;
            vdef = 0;
            storage = Ast::Storage::Init;
#endif
        }

        inline void createValue(const z::string& v) {
            text = v;
            v.toUtf8(svalue, zbl::MaxTokenSize);
            if(v.length() >= zbl::MaxTokenSize) {
                lvalue = new char[v.length() + 1];
                initString(lvalue, v.length() + 1);
                v.toUtf8(lvalue, v.length() + 1);
            }
        }

        static inline void deleteValue(zbl::TokenData& td) {
            if(td.lvalue != 0) {
                delete[] td.lvalue;
                td.lvalue = 0;
            }
        }

        static inline z::string getValue(const zbl::TokenData& td) {
            if(td.lvalue != 0) {
                return z::string(td.lvalue);
            }
            return z::string(td.svalue);
        }

        inline Token() {
            init();
        }

        inline Token(const int& i, const z::string& v, const bool& h) : text(v) {
            init();
            createValue(v);
            id = i;
            hidden = h;
        }

        inline Token(const z::string& v) : text(v) {
            init();
            createValue(v);
        }

        inline Token(const int& i, const z::string& v, const bool& h, const int& l, const int& c) : text(v) {
            init();
            createValue(v);
            id = i;
            hidden = h;
            line = l;
            col = c;
        }

        inline void copyFrom(const zbl::Token& src) {
            init();
            createValue(src.text);
            id = src.id;
            line = src.line;
            col = src.col;
            hidden = src.hidden;
    #ifdef INTERNAL_TOKEN_REF
            typeSpec = src.typeSpec;
            vdef = src.vdef;
            storage = src.storage;
    #endif
        }

        inline Token(const zbl::Token& src) {
            copyFrom(src);
        }

        inline Token& operator=(const zbl::Token& src) {
            copyFrom(src);
            return ref(this);
        }

    private:
        z::string text;
    };
}