src/config/lxrgmr-code/token/getoken.c

   1
   2 #include <stdio.h>
   3 #include <memory.h>
   4 #include <string.h>
   5
   6 #include "strtoken.h"
   7 #include "../lib/AQStack.h"
   8 #include "../lib/util.h"
   9
  10 #include "../gmr/parser.tab.h"
  11
  12 //extern YYSTYPE yylval;
  13
  14 extern int config_yylex();
  15 extern int yylex(void);
  16 extern void strtoken_init(void);
  17
  18 /*
  19  * last token stores returned token value.
  20  * it was setted with 0 if [[:blank:]] detected.
  21  * it's used for:
  22  * @ string join. stick string and word out of yylex() by judging var of last_token.
  23  * @ c89 style comment '\/\*' processing.
  24  * @ '\' mask char.
  25  */
  26 int ret = 0;
  27 int dual_token_flag = 0;
  28
  29 int prev_token = 0;
  30
  31 /*
  32                 if (ret == T_EOL && last_token == -1)
  33                 {
  34                         printf("ignore T_EOL at the beginning of file.\n");
  35                         continue;
  36                 }
  37                 else if (ret == T_EOL && (last_token == T_WORD || last_token == T_WORD_QUOTE))
  38                 {
  39 //                      printf("T_EOL.\n");
  40                         prev_token = ret;
  41                         dual_token_flag = 1;
  42                         ret = T_EOL;
  43                 }
  44                 else if (ret == T_EOL && prev_token == T_EOL)
  45                 {
  46 //                      printf("T_EOL again.\n");
  47                         continue;
  48                 }
  49                 else if (ret == T_EOL && prev_token != T_EOL)
  50                 {
  51 //                      printf("T_EOL\n");
  52                         prev_token = ret;
  53                         continue;
  54                 }
  55                 else if (ret != T_EOL && prev_token == T_EOL)
  56                 {
  57 //                      printf("end of T_EOL\n");
  58                         prev_token = ret;
  59 //                      dual_token_flag = 1;
  60 //                      ret = T_EOL;
  61                 }
  62 */
  63
  64 enum __tag_STATE_TYPE {
  65         EM_EXPR,
  66         EM_ENVAR,
  67         EM_CMNT,
  68         EM_MACRO,
  69         EM_ASSIGN,
  70         EM_WORD,
  71         EM_STRING,
  72         EM_NL,
  73         EM_BLANK,
  74 };
  75
  76 /*
  77  * wait token
  78  * token proc
  79  */
  80 int tbl[][3] = {
  81         // TBD:
  82 #if 0
  83         {T_ASSIGN,              T_SEMI,                 EM_EXPR},
  84         {T_ENVASSIGN,   T_SEMI,                 EM_EXPR},
  85         {T_LBRACKET1,   T_RBRACKET1,    EM_EXPR},
  86         {T_DLBRACKET1,  T_DRBRACKET1,   EM_EXPR},
  87
  88         {T_DOLLAR,              T_RBRACKET3,    EM_ENVAR},
  89
  90         {T_CMNT_BEGIN,  T_CMNT,                 EM_CMNT},
  91
  92         {T_MDEFINE,             T_NL,                   EM_MACRO},
  93         {T_MIF,                 T_NL,                   EM_MACRO},
  94         {T_MIFDEF,              T_NL,                   EM_MACRO},
  95         {T_MIFNDEF,             T_NL,                   EM_MACRO},
  96         {T_MELSE,               T_NL,                   EM_MACRO},
  97         {T_MENDIF,              T_NL,                   EM_MACRO},
  98         {T_MINCLUDE,    T_NL,                   EM_MACRO},
  99         {T_MPRAGMA,             T_NL,                   EM_MACRO},
 100
 101         {T_WORD,                T_ASSIGN,               EM_ASSIGN},
 102         {T_WORD,                T_ADDASSIGN,    EM_ASSIGN},
 103         {T_WORD,                T_LBRACKET2,    EM_ASSIGN},
 104
 105         {T_WORD,                0,                              EM_WORD},
 106
 107         {T_WORD_QUOTE,  0,                              EM_STRING},
 108
 109         {T_EOL,                 0,                              EM_NL},
 110
 111         {T_BLANK,               0,                              EM_BLANK},
 112 #endif
 113 };
 114
 115 /*
 116  * expr: T_ASSIGN/T_ENVASSIGN and T_SEMI,
 117  *               T_LBRACKET2 and T_RBRACKET2,
 118  *               T_LBRACKET1 AND T_RBRACKET1.
 119  *               T_DLBRACKET1 AND T_DRBRACKET1.
 120  * envar: T_DOLLAR and T_RBRACKET3.
 121  * word: T_WORD and T_WORD and T_CONST.
 122  * string: T_WORD_QUOTE and T_WORD_QUOTE.
 123  * init-nl: T_EOL, filter.
 124  * multi-nl: T_EOL and T_EOL, filter.
 125  * blank: T_BLANK and T_BLANK, filter.
 126  * comment: T_CMNT_BEGIN and T_CMNT.
 127  */
 128 uint32 TokenProc (int token)
 129 {
 130         int state = 0;
 131
 132         if (state == EM_EXPR)
 133                 ;
 134         else if (state == EM_ENVAR)
 135                 ;
 136         else if (state == EM_CMNT)
 137                 ;
 138         else if (state == EM_WORD)
 139                 ;
 140         else if (state == EM_STRING)
 141                 ;
 142         else if (state == EM_NL)
 143                 ;
 144         else if (state == EM_BLANK)
 145                 ;
 146         else
 147                 ;
 148 }
 149
 150 int on_token_proc (int ret)
 151 {
 152 //      extern char str_buff[8192];
 153 //      extern int str_idx;
 154         extern PARSER_DESC *gparser;
 155         char *pstr;
 156
 157         TOKEN_PROC_STATE *pstTokenState = gparser->pstCurrTokenState;
 158         const char *str = NULL;
 159
 160         /*
 161          * display token id, token name, and it's content.
 162          */
 163         str = name_look_up_token(ret);
 164         if (str)
 165         {
 166                 printf("<%d> %s: ", ret, str);
 167                 if (!strcmp(str, "T_EOL"))
 168                 {
 169                         printf("\n");
 170                         return 0;
 171                 }
 172                 else if (!strcmp(str, "T_HELPTEXT"))
 173                         printf("\n");
 174                 else if (!strcmp(str, "T_WORD_QUOTE"))
 175                         printf("\n");
 176                 else if (!strcmp(str, "T_C89_CMNT"))
 177                         printf("\n");
 178
 179                 //if (str_idx != 0)
 180                 if (is_empty_string(&strbuff))
 181                         pstr = pstTokenState->token_str;
 182                 else
 183                         pstr = strbuff.text;
 184
 185 //              printf("str_idx = %d\n", str_idx);
 186 //              printf("pstr = %d\n", pstr);
 187                 printf("%s\n", pstr);
 188
 189                 /*
 190                 if (yylval.id)
 191                 {
 192                         if (yylval.id->token == ret)
 193                                 printf("%s\n", yylval.id->name);
 194                         else
 195                                 printf("%s\n", yylval.string);
 196                 }
 197                 */
 198         }
 199
 200         // TBD: append gmr parser func here.
 201
 202         return 0;
 203 }
 204
 205 /*
 206  * @
 207  * @ string/word combine
 208  * @ nl combine
 209  * @ first nl in file ignore.
 210  *
 211  */
 212
 213 int yylex_token_proc (PARSER_DESC *file)
 214 {
 215         int token;
 216         void *pdata;
 217         char *pStkBuff;
 218
 219 //      fprintf(stderr, "yylex_proc()\n");
 220         //return 0;
 221
 222         do {
 223                 // buffered token.
 224                 if (!QStackIF_IsEmpty(&file->stTokenQ))
 225                 {
 226                         token = (int)QStackIF_DeQueue(&file->stTokenQ);
 227                         pdata = (void *)QStackIF_DeQueue(&file->stTokenQ);
 228
 229 //                      printf("token(%d, %d, %d)\n", ret, prev_token, last_token);
 230
 231 //                      if (last_token == T_EOL && (prev_token == 0 || prev_token == T_EOL))
 232 //                      {
 233 //                              prev_token = last_token;
 234 //                              continue;
 235 //                      }
 236
 237                         on_token_proc(token);
 238
 239                         /*
 240                          * do buffer release work here, and does not need to invoke free(yylval.string);
 241                          * in grammer proc func.
 242                          */
 243                         if (!is_unallocated_string(&strbuff) || yylval.string)
 244                         {
 245 //                              printf("free_string()\n");
 246                                 free_string(&strbuff);
 247                         }
 248
 249                         return token;
 250                 }
 251
 252                 /* new token parsing */
 253                 yylval.string = NULL;
 254                 do {
 255                         //if (!(ret = token_read(gparser)))
 256                         if (!(ret = yylex()))
 257                         {
 258 //                              fprintf(stderr, "b break(%d)\n", ret);
 259                                 break;
 260                         }
 261 //                      printf("yylex(%d, %d, %d)\n", ret, prev_token, last_token);
 262
 263                         ret = TokenProc(ret);
 264                 } while (1);
 265
 266                 last_token = ret;
 267                 dual_token_flag = 1;
 268 //              continue;
 269 //              return ret;
 270         }
 271         while (1);
 272
 273 //      fprintf(stderr, "e return (%d)\n", 0);
 274         return 0;
 275 }
 276
 277 int yylex_proc (void)
 278 {
 279         extern PARSER_DESC *gparser;
 280
 281         yylex_token_proc(gparser);
 282 }
 283
 284 void lxrgmr_init (void)
 285 {
 286         strtoken_init();
 287
 288         token_id_init();
 289         init_strbuff(&strbuff);
 290
 291         yylval.string = NULL;
 292         yylval.id = NULL;
 293         last_token = -1;
 294         dual_token_flag = 0;
 295 }
 296
 297
 298
 299
 300
 301