Zen
A cross-platform functional programming language

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

Go to the documentation of this file.
00001 
00007 #pragma once
00008 
00010 #ifdef INTERNAL_TOKEN_REF
00011 
00017 #include "zbl/Ast.hpp"
00018 #endif
00019 
00022 namespace zbl {
00024 
00026     const int MaxTokenSize = 32;
00027 
00029 
00033     struct TokenData {
00035         int id;
00036 
00038         char svalue[MaxTokenSize];
00039 
00041         char* lvalue;
00042 
00044         bool hidden;
00045 
00047         int line;
00048 
00050         int col;
00051 
00052 #ifdef INTERNAL_TOKEN_REF
00053 
00054         Ast::TypeSpec* typeSpec;
00055 
00057         const Ast::VariableDef* vdef;
00058 
00060         Ast::Storage::T storage;
00061 #endif
00062     };
00063 
00065 
00067     struct Token : public TokenData {
00072         inline void initString(char* str, const int& len) {
00073             for(int i = 0; i < len; ++i) {
00074                 str[i] = 0;
00075             }
00076         }
00077 
00080         inline void init() {
00081             id = 0;
00082             initString(svalue, zbl::MaxTokenSize);
00083             lvalue= 0;
00084             hidden = false;
00085             line = 0;
00086             col = 0;
00087 #ifdef INTERNAL_TOKEN_REF
00088             typeSpec = 0;
00089             vdef = 0;
00090             storage = Ast::Storage::Init;
00091 #endif
00092         }
00093 
00097         inline void createValue(const z::string& v) {
00098             text = v;
00099             v.toUtf8(svalue, zbl::MaxTokenSize);
00100             if(v.length() >= zbl::MaxTokenSize) {
00101                 lvalue = new char[v.length() + 1];
00102                 initString(lvalue, v.length() + 1);
00103                 v.toUtf8(lvalue, v.length() + 1);
00104             }
00105         }
00106 
00110         static inline void deleteValue(zbl::TokenData& td) {
00111             if(td.lvalue != 0) {
00112                 delete[] td.lvalue;
00113                 td.lvalue = 0;
00114             }
00115         }
00116 
00123         static inline z::string getValue(const zbl::TokenData& td) {
00124             if(td.lvalue != 0) {
00125                 return z::string(td.lvalue);
00126             }
00127             return z::string(td.svalue);
00128         }
00129 
00132         inline Token() {
00133             init();
00134         }
00135 
00143         inline Token(const int& i, const z::string& v, const bool& h) : text(v) {
00144             init();
00145             createValue(v);
00146             id = i;
00147             hidden = h;
00148         }
00149 
00155         inline Token(const z::string& v) : text(v) {
00156             init();
00157             createValue(v);
00158         }
00159 
00167         inline Token(const int& i, const z::string& v, const bool& h, const int& l, const int& c) : text(v) {
00168             init();
00169             createValue(v);
00170             id = i;
00171             hidden = h;
00172             line = l;
00173             col = c;
00174         }
00175 
00179         inline void copyFrom(const zbl::Token& src) {
00180             init();
00181             createValue(src.text);
00182             id = src.id;
00183             line = src.line;
00184             col = src.col;
00185             hidden = src.hidden;
00186     #ifdef INTERNAL_TOKEN_REF
00187             typeSpec = src.typeSpec;
00188             vdef = src.vdef;
00189             storage = src.storage;
00190     #endif
00191         }
00192 
00196         inline Token(const zbl::Token& src) {
00197             copyFrom(src);
00198         }
00199 
00204         inline Token& operator=(const zbl::Token& src) {
00205             copyFrom(src);
00206             return ref(this);
00207         }
00208 
00209     private:
00211         z::string text;
00212     };
00213 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines