src/config/lxrgmr-code/token_id.h

   1 #ifndef __TOKEN_ID_H
   2 #define __TOKEN_ID_H
   3
   4 //#include "gmr/parser.tab.h"
   5 #include "token.h"
   6 #include "AQStack.h"
   7
   8 #define T_OPT_MODULES                   1
   9 #define T_OPT_DEFCONFIG_LIST    2
  10 #define T_OPT_ENV                               3
  11 #define T_OPT_ALLNOCONFIG_Y             4
  12
  13 enum TOKEN_FLAGS {
  14         TF_COMMAND      =       (1<<0),
  15         TF_PARAM        =       (1<<1),
  16         TF_OPTION       =       (1<<2),
  17         TF_PFX          =       (1<<3),
  18         TF_OPCHAR       =       (1<<4),
  19         TF_MACRO        =       (1<<5),
  20 };
  21
  22 #define T_PFX_CHAR              2000
  23
  24 /*
  25 #define TF_COMMAND      (1<<0)
  26 #define TF_PARAM        (1<<1)
  27 #define TF_OPTION       (1<<2)
  28 */
  29
  30 /*
  31  * token and opr-char can be defined in diffrent state.
  32  */
  33 enum ENM_TOKEN_SET_STATE {
  34         ENM_FLAG_PREPROC                = (1<<8),
  35         ENM_FLAG_CMDLINE                = (1<<9),
  36         ENM_FLAG_EXT                    = (1<<10),
  37         ENM_FLAG_SH_SCRIPT              = (1<<11),
  38         ENM_FLAG_SH_LANG                = (1<<12),
  39
  40         ENM_PREPROC                             = ( (1<<8) | (1<<9)  | (1<<10) | (1<<11) | (1<<12) ),
  41         ENM_CMDLINE                             = ( (1<<9) | (1<<11) | (1<<12) ),
  42         ENM_EXT                                 =   (1<<10),
  43         ENM_SH_SCRIPT                   = ( (1<<11) | (1<<12) ),
  44         ENM_SH_LANG                             = (1<<12),
  45 };
  46
  47 #define PTR_CHAR_CNT            (sizeof(char *))
  48 /* judge this char to get if it is a ptr value. */
  49 #define CHAR_FLAG_BYTE          (PTR_CHAR_CNT-1)
  50
  51 #define TOKEN_TBL_ITEM_CNT      (1<<5)
  52 #define MAX_TOKEN_IDX_CNT       5
  53
  54 /*
  55 struct kconf_id {
  56         const char *name;
  57         int token;
  58         unsigned int flags;
  59         enum symbol_type stype;
  60 };
  61 */
  62
  63 // for code compatible.
  64 #define kconf_id                                                token_id
  65
  66 typedef struct token_id                                 kconf_id;
  67
  68 #define TOKEN_FLAG(token)                               ((token)&(0xFFFF))
  69 #define TOKEN_TYPE(token)                               (((token)>>16)&(0xFFFF))
  70
  71 typedef struct __tag_SRC_FILE_DESC SRC_FILE_DESC;
  72
  73 typedef int (*TOKEN_ID_PROC) (int evt, int token, register const char *str, register unsigned int len, SRC_FILE_DESC *psrcfile);
  74
  75 struct token_id {
  76         union {
  77                 /*
  78                  * normally, ptr is larger then 0xFFFFFF.
  79                  * but if it is opr-char-string, store string
  80                  * in ptr buffer, this will decrease memory cost.
  81                  */
  82                 char *name;
  83
  84                 /* opr-char, it will decrease memory cost */
  85                 char chars[PTR_CHAR_CNT];
  86         };
  87         char *tokenstr;
  88         int state;
  89         int token;
  90         union {
  91                 /*
  92                 struct {
  93                         unsigned char flags;
  94                         unsigned char tokensetflags;
  95                 };
  96                 */
  97                 unsigned int flags;
  98                 struct {
  99                         unsigned short rsv;
 100                         /* TBD: put symbol_type to other */
 101                         unsigned short stype;
 102 //                      enum symbol_type stype;
 103                 };
 104         };
 105         TOKEN_ID_PROC proc;
 106 };
 107
 108 struct linear {
 109         struct linear *prev, *next;
 110         void * data;
 111 };
 112
 113 struct token_id_list {
 114         int id_cnt;
 115         int blk_item_cnt;
 116         struct linear *tbl_ptr;
 117         struct token_id *tbl_idx[MAX_TOKEN_IDX_CNT];
 118 };
 119
 120 #define ARRAY_SIZE(name)                                (sizeof(name)/sizeof(name[0]))
 121
 122 #define token_id_lookup(str, len)               (*pfn_token_id_lookup) (str, len)
 123 #define pfx_char_lookup(str, len)               (*pfn_pfx_char_lookup) (str, len)
 124 #define opr_char_lookup(str, len)               (*pfn_opr_char_lookup) (str, len)
 125
 126
 127 //extern struct token_id token_id_array[];
 128
 129 extern const struct token_id *(*pfn_token_id_lookup) (register const char *str, register unsigned int len);
 130 extern const struct token_id *(*pfn_pfx_char_lookup) (register const char punct);
 131 extern const struct token_id *(*pfn_opr_char_lookup) (register const char *str, register unsigned int len);
 132
 133 extern const char *name_look_up_token (int token);
 134 extern const struct token_id *punct_look_up_token (register const char punct);
 135 extern const struct token_id *opr_char_lookup_def (register const char *str, register unsigned int len);
 136 extern const struct token_id *pfx_char_lookup_def (register const char punct);
 137 extern const struct token_id *token_id_lookup_def (register const char *str, register unsigned int len);
 138 extern const struct token_id *token_id_lookup_w_idx (register const char *str, register unsigned int len);
 139
 140 extern int token_id_init (void);
 141 //extern const struct token_id *token_id_lookup(register const char *str, register unsigned int len);
 142
 143
 144 #define MAX_TOKEN_ID_TBL_SIZE           256
 145 #define MAX_RSVWD_LEN                           32
 146
 147 #define MAX_TOKEN_NUM                           128
 148 #define MAX_STATE_NUM                           128
 149
 150 typedef enum {
 151         TYPE_DUMMY = 0,
 152         TYPE_MASK = 1,
 153         TYPE_WORD = 2,          // include multi-byte
 154         TYPE_PUNCT = 3,         // pfx/pair/opr char
 155         TYPE_SPACE = 4,
 156         TYPE_NEWLINE = 5,
 157         TYPE_EOF = 6,
 158         TYPE_PFX = 7,
 159         TYPE_PAIR = 8,
 160         TYPE_BUFF_FULL = 9,     // buffer is full
 161         TYPE_MAX,
 162 } TOKEN_TYPE;
 163
 164 enum STATE_TOKEN_FLAGS {
 165         TF_CODE_BEGIN,
 166         TF_DOLLAR,
 167         TF_FUNCTION,
 168 };
 169
 170 #define SET_STATE_FLAG(state, flag)                             ((state)->u32Flag |= ~(flag))
 171 #define CLR_STATE_FLAG(state, flag)                             ((state)->u32Flag &= (flag))
 172 #define CHK_STATE_FLAG(state, flag)                             ((state)->u32Flag & (flag))
 173
 174 extern void QStackIF_PrintInfo (QSTACK *pstQStack);
 175 extern void QStackIF_PrintBuff (QSTACK *pstQStack);
 176
 177 #define STATE_SWITCH(pfile, state)                              do { \
 178                                         QStackIF_Push(&(pfile)->stStateStk, (uint32)(pfile)->pstCurrTokenState); \
 179                                         (pfile)->pstCurrTokenState = state_alloc_init((pfile), (state)); \
 180                                         (pfile)->pstCurrTokenState->paired_state = 0; \
 181                                 } while (false)
 182
 183 //                                      int paired_token_tmp = (pfile)->pstCurrTokenState->paired_token; \
 184 //                                      char *state_token_str_tmp = (pfile)->pstCurrTokenState->state_token_str; \
 185
 186 //                                      (pfile)->pstCurrTokenState->paired_token = paired_token_tmp; \
 187 //                                      (pfile)->pstCurrTokenState->state_token_str = state_token_str_tmp; \
 188
 189
 190 #define STATE_RECOVERY(pfile)                                   do { \
 191                                         free((void *)(pfile)->pstCurrTokenState); \
 192                                         (pfile)->pstCurrTokenState = (TOKEN_PROC_STATE *)QStackIF_Pop(&(pfile)->stStateStk); \
 193                                         (pfile)->pstStateInfo = (pfile)->pstCurrTokenState->pstStateInfo; \
 194                                 } while (false)
 195
 196 #define STATE_CHK(pfile, state)                                 ((pfile)->pstCurrTokenState->iStateId == (state))
 197
 198 #define STATE_VCHK(pvstate, state)                              ((pvstate)->iStateId == (state))
 199
 200
 201
 202 typedef struct __tag_TOKEN_PROC_STATE TOKEN_PROC_STATE;
 203 typedef int (*TOKEN_PROC) (char *str, TOKEN_TYPE type, TOKEN_PROC_STATE *pstTokenState);
 204
 205 /* static state info struct */
 206 typedef struct __tag_TOKEN_PROC_STATE_INFO {
 207         char                    *strStateName;
 208 //      int                             iStateId;
 209
 210         struct {
 211                 TOKEN_PROC                              pfnTokenStrProc;
 212                 const struct token_id   *pstTokenTbl;
 213                 int                                             iTblSize;
 214         } astTokenTypeTbl[TYPE_MAX];
 215         short                   *api16TokenNameLen[TYPE_MAX];
 216 } TOKEN_PROC_STATE_INFO, *PTOKEN_PROC_STATE_INFO;
 217
 218 /* run-time state struct */
 219 typedef struct __tag_TOKEN_PROC_STATE {
 220         int                                             iStateId;
 221         TOKEN_PROC_STATE_INFO   *pstStateInfo;
 222
 223         /* resolv info */
 224         char                                    *token_str;
 225         int                                             token_len;
 226         int                                             nl_cnt;
 227         int                                             recent_token;
 228         TOKEN_ID_PROC                   pfnTokenProc;
 229
 230         char                                    *state_token_str;
 231         TOKEN_ID_PROC                   pfnPairTokenProc;
 232         int                                             paired_token;
 233         int                                             paired_state;
 234
 235         /* statement token info */
 236         int                                             iTokenIdNum;
 237         uint32                                  u32Flag;
 238         uint32                                  u32CodeBlockLvl;
 239 } TOKEN_PROC_STATE, *PTOKEN_PROC_STATE;
 240
 241 typedef struct __tag_SRC_FILE_DESC {
 242         char                            *filename;
 243         FILE                            *file;
 244         int                                     lineno;
 245
 246         TOKEN_PROC_STATE                *pstCurrTokenState;
 247         TOKEN_PROC_STATE_INFO   *pstStateInfo;
 248         TOKEN_PROC_STATE_INFO   *pstStateInfoTbl;
 249         int                                             iStateInfoNum;
 250
 251         /* global token tbl for src file */
 252         TOKEN_PROC                              pfnMTokenStrProc;
 253         const struct token_id   *pstMTokenTbl;
 254         unsigned short                  *pu16MTokenNameLen;
 255
 256         /* for getchar() buffering */
 257         int                                     iBlkSize;
 258         int                                     iCurrIdx;
 259         char                            aBuff[2][512*8];
 260
 261         /* token string processing info */
 262         char                            bakchar;
 263         int                                     lasttype;
 264         int                                     type;
 265
 266         /* one type of token string processing */
 267         char                            aTokenStrBuff[512];
 268         int                                     iTokenStrLen;
 269         int                                     iPrevIdx;
 270
 271         /* parsing state stack */
 272         QSTACK                          stStateStk;
 273         char                            *pStkBuff;
 274         QSTACK                          stTokenQ;
 275 } SRC_FILE_DESC, *PSRC_FILE_DESC;
 276
 277 extern TOKEN_PROC_STATE *state_alloc_init (SRC_FILE_DESC *pfiledesc, int iState);
 278
 279 #endif /* __TOKEN_ID_H */
 280