src/config/lxrgmr-code/lxr/config.lexproc.c

   1
   2 #include <stdio.h>
   3
   4 #include "../token_id.h"
   5
   6 void STATE_SET (int state)
   7 {
   8         BEGIN(state);
   9 }
  10
  11 int on_help_proc (register const char *str, register unsigned int len)
  12 {
  13 //      printf("HELP:\n");
  14         BEGIN(HELP_TXT);
  15         return 0;
  16 }
  17
  18
  19 #include "zconf.c"
  20
  21 /*********************************************************************
  22  * lxr proc code.
  23  *********************************************************************/
  24
  25 int on_token_proc (int ret)
  26 {
  27 //      extern char str_buff[8192];
  28 //      extern int str_idx;
  29         extern SRC_FILE_DESC *gpcurr_src_file;
  30         char *pstr;
  31
  32         TOKEN_PROC_STATE *pstTokenState = gpcurr_src_file->pstCurrTokenState;
  33         const char *str = NULL;
  34
  35         /*
  36          * display token id, token name, and it's content.
  37          */
  38         str = name_look_up_token(ret);
  39         if (str)
  40         {
  41                 printf("<%d> %s: ", ret, str);
  42                 if (!strcmp(str, "T_EOL"))
  43                 {
  44                         printf("\n");
  45                         return 0;
  46                 }
  47                 else if (!strcmp(str, "T_HELPTEXT"))
  48                         printf("\n");
  49                 else if (!strcmp(str, "T_WORD_QUOTE"))
  50                         printf("\n");
  51                 else if (!strcmp(str, "T_C89_CMNT"))
  52                         printf("\n");
  53
  54                 //if (str_idx != 0)
  55                 if (is_empty_string(&strbuff))
  56                         pstr = pstTokenState->token_str;
  57                 else
  58                         pstr = strbuff.text;
  59
  60 //              printf("str_idx = %d\n", str_idx);
  61 //              printf("pstr = %d\n", pstr);
  62                 printf("%s\n", pstr);
  63
  64                 /*
  65                 if (yylval.id)
  66                 {
  67                         if (yylval.id->token == ret)
  68                                 printf("%s\n", yylval.id->name);
  69                         else
  70                                 printf("%s\n", yylval.string);
  71                 }
  72                 */
  73         }
  74
  75         // TBD: append gmr parser func here.
  76
  77         return 0;
  78 }
  79
  80 /*
  81  * set content flag automatically.
  82  * referenced from script.l(script.lex.c).
  83  */
  84 #define RETURN(token)                   g_content_before_cmnt=1; return token;
  85
  86 int const_string (CACHING_STR *pstr_cache, int token)
  87 {
  88         if (is_unallocated_string(&strbuff))
  89         {
  90                 alloc_string(&strbuff, yytext, yyleng);
  91                 yylval.string = strbuff.text;
  92
  93                 last_token = token;
  94                 return token;
  95         }
  96         else
  97                 append_string(&strbuff, yytext, yyleng);
  98
  99         RETURN( T_WORD );
 100 }
 101
 102 #if 1
 103
 104 int yywrap (void)
 105 {
 106     return 1;
 107 }
 108
 109 int lex_c_preproc_hdr (void)
 110 {
 111         /* only works with newline started. */
 112         if (g_content_before_cmnt == 0)
 113         {
 114                 /*
 115                  * XXX: lookup macro rsv-word name table, if not matching, it's a comment string.
 116                  * XXX: invoke OnCPreProc().
 117                  */
 118                 printf("C-PREPROC:\n%s", yytext);
 119                 g_cpreproc_flag=1;
 120                 BEGIN(C_PREPROC);
 121         }
 122         else
 123         {
 124                 g_cpreproc_flag=0;
 125                 printf("SH-CMNT:\n%s", yytext);
 126                 BEGIN(SH_CMNT_STATE);
 127 //              return T_EOL;
 128         }
 129
 130         return 0;
 131 }
 132
 133 int lex_sh_cmnt (void)
 134 {
 135 //              printf("%s\n", yytext);
 136                 BEGIN(INITIAL);
 137
 138                 if (!is_unallocated_string(&strbuff))
 139                 {
 140                         last_token = 0;
 141                         yylval.string = strbuff.text;
 142                         RETURN( T_WORD );
 143                 }
 144
 145                 return T_EOL;
 146 }
 147
 148 int lex_c_preproc_param (void)
 149 {
 150                 printf("%s\n", yytext);
 151
 152                 if (g_cpreproc_flag == 1)
 153                 {
 154                         // XXX: replace cpreproc code here.
 155                         BEGIN(INITIAL);
 156                 }
 157                 else
 158                 {
 159                         BEGIN(INITIAL);
 160                 }
 161                 g_cpreproc_flag = 0;
 162
 163                 BEGIN(INITIAL);
 164                 if (!is_unallocated_string(&strbuff))
 165                 {
 166                         last_token = 0;
 167                         yylval.string = strbuff.text;
 168                         RETURN( T_WORD );
 169                 }
 170
 171                 return 0;
 172 }
 173
 174 void lex_c89_cmnt_nl (void)
 175 {
 176         /*
 177          * if there are content before comment, matching '\n' same as '* /' for ending expr.
 178          * if there are no content before comment, just matching '* /' for ending expr.
 179          * this kind of implementation is in order to avoid conflect with shell cmd '/ *'.
 180          *
 181          * TBD:
 182          * @ there should be a piece of code to caching token and string if in this condition.
 183          *   if '\n' detected as a ending expr for comment, get token from caching buffer.
 184          */
 185         if (g_cmnt_state == EN_CMNT_BEGIN)
 186                 g_cmnt_state=EN_CMNT;
 187
 188         if (g_content_before_cmnt != 0 && g_cmnt_state != EN_CMNT_EXTEND)
 189         {
 190                 /*
 191                  * treat '/*' as a normal string.
 192                  * put back other string to buffer.
 193                  * TBD: append to T_WORD or other token.
 194                  */
 195                 /* do not unput() idx=0, or it will be treated as a comment again. */
 196                 for (int i=cmnt_idx; i>0; i--)
 197                         unput(cmnt_buff[i]);
 198
 199                 BEGIN(INITIAL);
 200 //              return T_CMNT_STR;
 201         }
 202         else
 203         {
 204                 cmnt_buff[cmnt_idx]='\n';
 205                 cmnt_idx++;
 206                 cmnt_buff[cmnt_idx]=0;
 207         }
 208 }
 209
 210 void lex_c89_cmnt_tail (void)
 211 {
 212                 if (g_cmnt_state != EN_CMNT_EXTEND)
 213                 {
 214                         g_cmnt_state=EN_CMNT_NONE;
 215                         printf("C89-CMNT: \n%s%s\n", cmnt_buff, yytext);
 216                         BEGIN(INITIAL);
 217         //              g_content_before_cmnt=0;
 218         //              return T_CMNT_STR;
 219                 }
 220                 else
 221                 {
 222                         if (yyleng == 2)
 223                         {
 224                                 /*
 225                                  * ignore / * * / comment in / ** ** /
 226                                  */
 227                                 cmnt_buff[cmnt_idx]='*';
 228                                 cmnt_idx++;
 229                                 cmnt_buff[cmnt_idx]='/';
 230                                 cmnt_idx++;
 231                                 cmnt_buff[cmnt_idx]=0;
 232                         }
 233                         else
 234                         {
 235                                 // '\*\*\/' ext comment
 236                                 g_cmnt_state=EN_CMNT_NONE;
 237                                 printf("C89-EXT-CMNT: \n%s%s\n", cmnt_buff, yytext);
 238                                 BEGIN(INITIAL);
 239                                 g_content_before_cmnt=0;
 240                 //              return T_CMNT_STR;
 241                         }
 242                 }
 243 }
 244
 245 /*
 246 enum ENM_PUNCT_TYPE {
 247         EN_PUNCT_NORMAL = 1,
 248         EN_PUNCT_CMNT,
 249         EN_PUNCT_DQUOTE,
 250         EN_PUNCT_SUBSCRIPT,
 251         EN_PUNCT_HELPTEXT,
 252 };
 253 */
 254
 255 int lex_punct (int state)
 256 {
 257         const struct token_id *id = punct_look_up_token(yytext[0]);
 258
 259         if (id == NULL)
 260         {
 261                 /*
 262                  * no opr-char and pfx-char matched,
 263                  * punct will be seen as a normal char in string word.
 264                  */
 265                 //unput(yytext[0]);
 266                 append_string(&strbuff, yytext, yyleng);
 267                 return 0;
 268         }
 269         else if (TOKEN_FLAG(id->flags) == TF_OPCHAR)
 270         {
 271                 /* return token if it is a signature */
 272                 yylval.id = id;
 273                 return id->token;
 274         }
 275         else if (TOKEN_FLAG(id->flags) == T_PFX_CHAR)
 276         {
 277                 /*
 278                  * if it is a T_PFX_CHAR char, entering state
 279                  * TBD:
 280                  */
 281 //              const struct token_id *id = punct_look_up_token(yytext, yyleng);
 282 //              push_state(curr_state);
 283 //              BEGIN(state);
 284                 return 0;
 285         }
 286         else
 287                 printf("err: (%s)should not be running here.\n", yytext);
 288
 289         return 0;
 290 }
 291
 292 int lex_token_word (void)
 293 {
 294         /*
 295          * if there are chars before a symbol string,
 296          * symbol is seen as a word.
 297          */
 298         if (!is_unallocated_string(&strbuff))
 299         {
 300 //              printf("T_WORD:%s\n", yytext);
 301                 append_string(&strbuff, yytext, yyleng);
 302                 yylval.string = strbuff.text;
 303                 RETURN( T_WORD );
 304         }
 305
 306         const struct token_id *id = token_id_lookup(yytext, yyleng);
 307
 308 //      if (id)
 309 //      {
 310 //              printf("SYM(0x%02x): %s\n", yylval.id, yytext);
 311 //      }
 312 //      else
 313 //              printf("WORD: %s\n", yytext);
 314
 315         // TBD:
 316         current_pos.file = current_file;
 317         current_pos.lineno = yylineno;
 318         // TBD: non-command token does not effective.
 319         if (id && id->flags & TF_COMMAND)
 320         /*
 321         if (id &&
 322                 (id->flags & TF_COMMAND ||
 323                 id->flags & TF_PARAM ||
 324                 id->flags & TF_OPTION))
 325         */
 326         {
 327                 yylval.id = id;
 328                 RETURN( id->token );
 329         }
 330         alloc_string(&strbuff, yytext, yyleng);
 331         yylval.string = strbuff.text;
 332
 333         RETURN( T_WORD );
 334 }
 335
 336 #endif
 337