Source code

001// lexical analyzer  for GSQLParser component java version
002
003/****************************************************
004   Lexical analizer for GSQLParser Java component   
005   Copyright (c) 2004-2021 by Gudu software         
006****************************************************/
007
008package gudusoft.gsqlparser;
009
010import java.util.HashMap;
011import java.io.InputStreamReader;
012
013import java.util.Locale;
014import java.io.BufferedReader;
015import java.io.IOException;
016
017        
018public class TLexerathena extends TCustomLexer{
019    static int yynmarks = 0  ;
020    static int yynmatches ;
021    static int yyntrans   ;
022    static int yynstates  ;
023    static int[]  yyk,yym ; // 1 based
024    static int[]  yytint;  // 1 based
025    static TYytRec[] yyt ;  // 1 based
026    static int[]  yykl,yykh,yyml,yymh,yytl,yyth ; // 0 based
027    private  static  String[] keywordlist;
028    static String   table_file;
029    static HashMap<String, Integer> keywordValueList;
030    static HashMap<Integer, Integer> keywordTypeList;
031        static int[][] yystateTable;
032
033    static {
034              keywordValueList = new HashMap<String, Integer>();
035              keywordTypeList = new HashMap<Integer, Integer>();
036          table_file = "/gudusoft/gsqlparser/parser/athena/athena_lex_table.txt";
037                  if (TBaseType.enterprise_edition||TBaseType.athena_edition){
038                  inittable();
039              }
040    }
041    
042    public TLexerathena(){
043          super();
044          dbvendor = EDbVendor.dbvathena;
045    }
046   
047public boolean canBeColumnName(int tokencode){
048    //http://blog.csdn.net/superbeck/article/details/5387476
049    boolean ret = false;
050    int modifiers = keyword_type_identifier | keyword_type_column ;
051    Integer s = keywordTypeList.get(tokencode);
052     if (s != null){
053        int modifier = s;
054        ret = (modifiers & modifier) == modifier;
055    }
056
057    return ret;
058}
059   
060 public  int iskeyword(String str){
061        int ret = -1;
062        Integer s = keywordValueList.get(str.toUpperCase(Locale.ENGLISH));
063        if( s != null){
064            ret = s;
065        }
066        return ret;// -1 means not a keyword
067     }
068
069     public int getkeywordvalue(String keyword){
070        int ret = 0;
071        Integer s = keywordValueList.get(keyword.toUpperCase(Locale.ENGLISH));
072        if( s != null){
073            ret = s;
074         }
075        return ret;// 0 means not a keyword
076     }
077         
078    public static EKeywordType getKeywordType(String keyword){
079        return TCustomLexer.getKeywordType(keyword,keywordValueList,keywordTypeList);
080    }            
081
082    static void yystateLookupConfigure() {
083        int yystates = yytl.length;
084        yystateTable = new int[257][yystates];
085
086        // initialize to empty
087        for(int i = 0; i < yystates; i++) {
088            for (int j = 0; j < 257; j++)
089                yystateTable[j][i] = -1;
090        }
091
092        for(int i = 0; i < yystates; i++) {
093            int low = yytl[i];
094            int high = yyth[i];
095            for (int j = low; j <= high; j++) {
096                for (char c: yyt[j].cc) {
097                    yystateTable[c][i] = j;
098                }
099            }
100        }
101    }
102        
103    int yylex(){
104          int yyn;
105           while (true) { // top level while
106              yynew();
107              while (true){  //scan
108                 for(yyn = yykl[yystate]; yyn <= yykh[yystate]; yyn++){
109                     yymark(yyk[yyn]);
110                 }
111
112                 for(yyn=yymh[yystate]; yyn>= yyml[yystate]; yyn--){
113                    yymatch(yym[yyn]);
114                 }
115
116                 if(yytl[yystate] > yyth[yystate]){
117                     break;
118                 }
119
120                 yyscan();
121//                 yyn = yytl[yystate];
122                 totablechar();
123//                 while( (yyn <= yyth[yystate]) && (!(charinarray(yytablechar,yyt[yyn].cc))) ){
124//                   yyn++;
125//                 }
126//                 if (yyn > yyth[yystate]){
127//                     break;
128//                 }
129
130                 yyn = yystateTable[yytablechar][yystate];
131                 if (yyn == -1)
132                     break;
133                                         
134                 yystate = yyt[yyn].s;
135              } //scan
136
137              while (true){ //action
138                int yyrule;
139                if ( (yyrule = yyfind()) != -1 ){
140                   yyaction(yyrule);
141                   if (yyreject){
142                       continue;
143                   }
144                }else if( (!yydefault() ) && (yywrap()) ){
145                   yyclear();
146                   returni(0);
147                }
148                break;
149              }
150
151              if (!yydone) {
152                  continue;
153              }
154              break;
155            } // top level while
156
157           return yyretval;
158        }
159
160    static void inittable(){
161                
162                //if (yynmarks > 0) return; //init table already
163
164        String line;
165        boolean inyyk=false,inyym=false,inyykl=false,inyykh=false,inyyml=false,inyymh=false,inyytl=false,inyyth=false,inyytint=false,inyyt=false,inkeyword=false;
166        int yyk_count=0,yym_count=0,yykl_count=0,yykh_count=0,yyml_count=0,yymh_count=0,yytl_count=0,yyth_count=0,yytint_count=0,yyt_count=0;
167        int c=0;
168        keywordValueList.clear();
169        keywordTypeList.clear();
170        
171        BufferedReader br = new BufferedReader(new InputStreamReader(TLexerathena.class.getResourceAsStream(table_file)));
172
173            try{
174                while( (line = br.readLine()) != null){
175                          if (line.trim().startsWith("yynmarks=")){
176                             String[] ss = line.split("[=;]");
177                              yynmarks=Integer.parseInt(ss[1].trim());
178                              yyk = new int[yynmarks+1];
179                          }else if (line.trim().startsWith("yynmatches=")){
180                              String[] ss = line.split("[=;]");
181                               yynmatches=Integer.parseInt(ss[1].trim());
182                               yym = new int[yynmatches+1];
183                          }else if (line.trim().startsWith("yyntrans=")){
184                              String[] ss = line.split("[=;]");
185                               yyntrans=Integer.parseInt(ss[1].trim());
186                               yytint = new int[yyntrans+1];
187                               yyt = new TYytRec[yyntrans+1];
188                          }else if (line.trim().startsWith("yynstates=")){
189                              String[] ss = line.split("[=;]");
190                               yynstates=Integer.parseInt(ss[1].trim());
191                               yykl = new int[yynstates];
192                               yykh = new int[yynstates];
193                              yyml = new int[yynstates];
194                              yymh = new int[yynstates];
195                              yytl = new int[yynstates];
196                              yyth = new int[yynstates];
197                          }else if (line.trim().startsWith("<end>")){
198                              if (inyyk){
199                                  inyyk = false;
200                                 if (yynmarks+1 != yyk_count ){
201                                    System.out.println("required1:"+(yynmarks)+" actually:"+(yyk_count-1));
202                                 }
203                              }
204                              else if(inyym){
205                                     inyym = false;
206                                    if (yynmatches+1 != yym_count ){
207                                       System.out.println("required2:"+(yynmatches)+" actually:"+(yym_count-1));
208                                    }
209                              }
210                              else if(inyykl){
211                                     inyykl = false;
212                                    if (yynstates != yykl_count ){
213                                       System.out.println("required3:"+(yynstates)+" actually:"+(yykl_count));
214                                    }
215                              }
216                              else if(inyykh){
217                                     inyykh = false;
218                                    if (yynstates != yykh_count ){
219                                       System.out.println("required4:"+(yynstates)+" actually:"+(yykh_count));
220                                    }
221                              }
222                              else if(inyyml){
223                                     inyyml = false;
224                                    if (yynstates != yyml_count ){
225                                       System.out.println("required5:"+(yynstates)+" actually:"+(yyml_count));
226                                    }
227                              }
228                              else if(inyymh){
229                                     inyymh = false;
230                                    if (yynstates != yymh_count ){
231                                       System.out.println("required:"+(yynstates)+" actually:"+(yymh_count));
232                                    }
233                              }
234                              else if(inyytl){
235                                     inyytl = false;
236                                    if (yynstates != yytl_count ){
237                                       System.out.println("required6:"+(yynstates)+" actually:"+(yytl_count));
238                                    }
239                              }
240                              else if(inyyth){
241                                     inyyth = false;
242                                    if (yynstates != yyth_count ){
243                                       System.out.println("required7:"+(yynstates)+" actually:"+(yyth_count));
244                                    }
245                              }
246                              else if(inyytint){
247                                     inyytint = false;
248                                    if (yyntrans + 1 != yytint_count ){
249                                       System.out.println("required8:"+(yyntrans)+" actually:"+(yytint_count-1));
250                                    }
251                              }
252                              else if(inyyt){
253                                     inyyt = false;
254                                    if (yyntrans+1 != yyt_count ){
255                                       System.out.println("required9:"+(yyntrans)+" actually:"+(yyt_count-1));
256                                    }
257                              }
258                              else if(inkeyword){
259                                     inkeyword = false;
260                              }
261                          }else if(line.trim().startsWith("yyk =")){
262                             inyyk = true; 
263                          }else if(line.trim().startsWith("yym =")){
264                             inyym = true;
265                          }else if(line.trim().startsWith("yykl =")){
266                             inyykl = true;
267                          }else if(line.trim().startsWith("yykh =")){
268                             inyykh = true;
269                          }else if(line.trim().startsWith("yyml =")){
270                             inyyml = true;
271                          }else if(line.trim().startsWith("yymh =")){
272                             inyymh = true;
273                          }else if(line.trim().startsWith("yytl =")){
274                             inyytl = true;
275                          }else if(line.trim().startsWith("yyth =")){
276                             inyyth = true;
277                          }else if(line.trim().startsWith("yytint =")){
278                             inyytint = true;
279                          }else if(line.trim().startsWith("yyt =")){
280                             inyyt = true;
281                        }else if(line.trim().startsWith("keywordsvalue =")){
282                           inkeyword = true;
283                        }else if(inyyk){
284                             String[] ss = line.split("[,]");
285                               for(int j=0;j<ss.length;j++){
286                                   // System.out.println(ss[j].trim());
287                                 yyk[yyk_count++] = Integer.parseInt(ss[j].trim());
288                               }
289                          }else if(inyym){
290                               String[] ss = line.split("[,]");
291                                 for(int j=0;j<ss.length;j++){
292                                     // System.out.println(ss[j].trim());
293                                   yym[yym_count++] = Integer.parseInt(ss[j].trim());
294                                 }
295                          }else if(inyykl){
296                               String[] ss = line.split("[,]");
297                                 for(int j=0;j<ss.length;j++){
298                                    //  System.out.println(ss[j].trim());
299                                   yykl[yykl_count++] = Integer.parseInt(ss[j].trim());
300                                 }
301                          }else if(inyykh){
302                               String[] ss = line.split("[,]");
303                                 for(int j=0;j<ss.length;j++){
304                                     // System.out.println(ss[j].trim());
305                                   yykh[yykh_count++] = Integer.parseInt(ss[j].trim());
306                                 }
307                          }else if(inyyml){
308                               String[] ss = line.split("[,]");
309                                 for(int j=0;j<ss.length;j++){
310                                     // System.out.println(ss[j].trim());
311                                   yyml[yyml_count++] = Integer.parseInt(ss[j].trim());
312                                 }
313                          }else if(inyymh){
314                               String[] ss = line.split("[,]");
315                                 for(int j=0;j<ss.length;j++){
316                                     // System.out.println(ss[j].trim());
317                                   yymh[yymh_count++] = Integer.parseInt(ss[j].trim());
318                                 }
319                          }else if(inyytl){
320                               String[] ss = line.split("[,]");
321                                 for(int j=0;j<ss.length;j++){
322                                     // System.out.println(ss[j].trim());
323                                   yytl[yytl_count++] = Integer.parseInt(ss[j].trim());
324                                 }
325                          }else if(inyyth){
326                               String[] ss = line.split("[,]");
327                                 for(int j=0;j<ss.length;j++){
328                                     // System.out.println(ss[j].trim());
329                                   yyth[yyth_count++] = Integer.parseInt(ss[j].trim());
330                                 }
331                          }else if(inyytint){
332                               String[] ss = line.split("[,]");
333                                 for(int j=0;j<ss.length;j++){
334                                     // System.out.println(ss[j].trim());
335                                   yytint[yytint_count++] = Integer.parseInt(ss[j].trim());
336                                 }
337                          }else if(inyyt){
338                                //System.out.println(line.trim());
339
340                              c = 0;
341                              String[] st = line.trim().split(",,");
342                              char[] tmp = new char[st.length];
343                              for(int i=0;i<st.length;i++){
344
345                                  if(st[i].startsWith("\'")) {
346                                      if(st[i].length() == 3){  // 'a'
347                                          tmp[c++] = st[i].charAt(1);
348                                      }else if(st[i].length() == 4) { // '\\'
349                                          tmp[c++] = st[i].charAt(2);
350                                      }else{
351                                         System.out.println(" read yytstr error, error string is "+st[i]+ "line: "+ yyt_count);
352                                      }
353                                  }else{
354                                      try{
355                                           tmp[c++] = (char)Integer.parseInt(st[i]);   // char in number like 32 that represent space
356                                          } catch (NumberFormatException nfe) {
357                                             System.out.println("NumberFormatException: " + nfe.getMessage());
358                                          }
359                                  }
360                              } //while hasmoreTokens
361
362                          //yyt[lineno] = new YYTrec(tmp,yytint[lineno]);
363                              yyt[yyt_count] = new TYytRec(tmp,yytint[yyt_count]);
364                              yyt_count++;
365
366                          }else if(inkeyword){
367                              String[] ss =line.split("[=]");
368
369                              int val1 = -1;
370                              int val2 = -1;
371                              try {
372                                  val1 = Integer.parseInt(ss[1]);
373                                  val2 = Integer.parseInt(ss[2]);
374                              }
375                              catch (NumberFormatException nfe) {
376                                  System.out.println("NumberFormatException: " + nfe.getMessage());
377                              }
378                              keywordValueList.put(ss[0].toUpperCase(),val1);
379                              keywordTypeList.put(val1,val2);
380                             }
381                }
382                }catch(IOException e){
383                  System.out.println(e.toString());
384                }
385                                
386                                yystateLookupConfigure();
387
388    }
389
390
391    void yyaction(int yyruleno){
392                                
393
394      int ic;
395      char[] tmparray = {'=','+','-','*','/','>','<'};
396
397      yylvalstr = getyytext();
398  /* actions: */
399  switch(yyruleno){
400  case 1:
401                   
402                {
403                                        if (yylvalstr.equalsIgnoreCase(dolqstart))
404                                        {
405                                                //dolqstart = "";
406            start(init);
407            addlit(yylvalstr,yytextlen);
408            yylvalstr = litbufdup();
409                                                returni(sconst);
410                                        }
411                                        else
412                                        {
413            //nchars = yytextlen;
414            addlit(yylvalstr, yytextlen-1);
415            yyless(yytextlen-1);
416            return;
417                                        }
418                                        //System.out.println("<xdolq>{dolqdelim}: "+dolqstart);
419                                        break;
420                }
421                                
422  case 2:
423            
424          {
425              start(xdolq);
426              startlit();
427              dolqstart = yylvalstr;
428              addlit(yylvalstr,yytextlen);
429              //System.out.println("dolqdelim: "+dolqstart);
430              break;
431          }
432
433  case 3:
434                    
435        {
436                addlit(yylvalstr, yytextlen);
437          //System.out.println("<xdolq>{dolqinside}: "+yylvalstr);
438                break;
439        }
440                                
441  case 4:
442                    
443        {
444                        addlit(yylvalstr, yytextlen);
445                        break;
446        }
447                                
448  case 5:
449                        
450                {
451         addlitchar(yylvalstr.charAt(0));
452         break;
453                }
454          
455
456  case 6:
457           
458          {
459              if (getyysstate() == xq)
460              {
461                  nchars = yytextlen;
462                  addlit(yylvalstr, yytextlen-1);
463                  yyless(nchars-1);
464                  return;//exit;
465              }
466
467              start(xq);
468              startlit();
469              addlit(yylvalstr,yytextlen);
470              break;
471          }
472
473  case 7:
474                
475          {
476              if (getyysstate() == xq)
477              {
478                  nchars = yytextlen;
479                  addlit(yylvalstr, yytextlen-1);
480                  yyless(nchars-1);
481                  return;//exit;
482              }
483
484              start(xq);
485              startlit();
486              addlit(yylvalstr,yytextlen);
487              break;
488          }
489
490  case 8:
491                
492          {
493              if (getyysstate() == xq)
494              {
495                  nchars = yytextlen;
496                  addlit(yylvalstr, yytextlen-1);
497                  yyless(nchars-1);
498                  return;//exit;
499              }
500
501              start(xq);
502              startlit();
503              addlit(yylvalstr,yytextlen);
504              break;
505          }
506
507  case 9:
508                
509        {
510                    addlit(yylvalstr,yytextlen);
511                    if (xcdepth <= 0)
512                       {
513                        start(init);
514                        yylvalstr = litbufdup();
515                        returni(cmtslashstar);
516                       }
517                    else
518                       xcdepth--;
519
520                  break;
521        }
522
523
524  case 10:
525                
526                  {
527                      if (yylvalstr.equalsIgnoreCase("/*+")){
528                         xcdepth++;
529                          yyless(2);
530                          addlit(yylvalstr,yytextlen);
531                      }else{
532                          yyless(1);
533                          addlit(yylvalstr,1);
534                      }
535        
536                      break;
537
538                   }
539
540  case 11:
541                        
542                  {
543
544                      if (getyysstate() == xq)
545                      {
546                          nchars = yytextlen;
547                          addlit(yylvalstr, yytextlen-1);
548                          yyless(nchars-1);
549                          return;//exit;
550                      }
551
552                      xcdepth = 0;
553                      start(xc);
554                      startlit();
555                      yyless(2);
556                      addlit(yylvalstr,yytextlen);
557
558                  break;
559                  }
560
561  case 12:
562                
563                  {
564                    addlit(yylvalstr,yytextlen);
565        
566                    break;
567                  }
568
569  case 13:
570                
571                  {
572                      addlitchar(yylvalstr.charAt(0));
573        
574                      break;
575                  }
576
577  case 14:
578                
579                  {
580                      start(init);
581                      addlit(yylvalstr, yytextlen);
582                      yylvalstr = litbufdup();
583                      if( yylvalstr.startsWith("b")|| (yylvalstr.startsWith("B"))){
584                          returni(bconst);
585                      }else if( yylvalstr.startsWith("x")|| (yylvalstr.startsWith("X"))){
586                          returni(xconst);
587                      }else 
588                      {
589                      returni(sconst);
590                      }
591                      break;
592                  }
593
594  case 15:
595                
596                    {
597                    if (insqlpluscmd){
598                        yyless(0);
599                        yylvalstr = litbufdup();
600                        start(init);
601                        returni(sconst);
602                    }else{
603                      addlit(yylvalstr,yytextlen);
604                    }
605
606                    break;
607                }
608  case 16:
609            
610                  {
611                      if (getyysstate() == xq)
612                      {
613                          nchars = yytextlen;
614                          addlit(yylvalstr, yytextlen-1);
615                          yyless(nchars-1);
616                          return;//exit;
617                      }
618
619                      start(xq);
620                      startlit();
621                      addlit(yylvalstr,yytextlen);
622
623                      dummych1 = get_char();
624                      if (dummych1 == '\\') // recognize string like '\'
625                        {
626                          dummych2 = get_char();
627                          if (dummych2 == '\'')
628                          {
629                             // start(init);
630                              addlit("\\", 1);
631                              addlit("\'", 1);
632                              //yylvalstr = litbufdup();
633                              //returni(sconst);
634                          }
635                          else
636                           {
637                              unget_char(dummych2);
638                              unget_char(dummych1);
639                            }
640                        }
641                      else
642                      { unget_char(dummych1);}
643
644                      break;
645                  }
646                                  
647                                  
648  case 17:
649                       
650        {
651                start(init);
652                addlit(yylvalstr, yytextlen);
653                yylvalstr = litbufdup();
654                returni(ident);
655                break;
656        }
657
658  case 18:
659                        
660        {
661          if ((getyysstate() == xd)||(getyysstate() == xq))
662          {
663              addlit(yylvalstr, 1);
664              yyless(1);
665              return;//exit;
666          }     
667                //token_start := yylvalStr;
668                start(xbacktick);
669                startlit();
670                addlit(yylvalstr, yytextlen);
671                break;
672        }
673
674
675  case 19:
676                       
677        {
678                addlit(yylvalstr, yytextlen);
679                break;
680  }
681
682  case 20:
683                       
684        {
685    addlit(yylvalstr, yytextlen);
686                break;
687   }
688                                  
689
690  case 21:
691                        
692                  {
693                          start(xq);
694                          startlit();
695                          addlit(yylvalstr, yytextlen);
696                          dummych1 = get_char();
697                          if (dummych1 == '\\') // recognize string like '\'
698                            {
699                              dummych2 = get_char();
700                              if (dummych2 == '\'')
701                              {
702                                 // start(init);
703                                  addlit("\\", 1);
704                                  addlit("\'", 1);
705                                  //yylvalstr = litbufdup();
706                                  //returni(sconst);
707                              }
708                              else
709                               {
710                                  unget_char(dummych2);
711                                  unget_char(dummych1);
712                                }
713                            }
714                          else
715                          { unget_char(dummych1);}
716
717                      break;
718                  }
719
720  case 22:
721                
722                  {
723                      addlit(yylvalstr, yytextlen);
724                      break;
725                  }
726
727  case 23:
728                
729          {
730            dummych1 = get_char();
731            unget_char(dummych1);
732            if (dummych1 == (char)10)
733              {
734                if (insqlpluscmd){
735                  nchars = yytextlen;
736                  if(yylvalstr.charAt(nchars-1) == (char)13){
737                      yyless(nchars - 1);
738                      yylvalstr = yylvalstr.substring(0,nchars);
739                  }
740                    start(init);
741                    addlit(yylvalstr, nchars-1);
742                    yylvalstr = litbufdup();
743                    returni(sconst); //in sqlplus command, characters between ' and return is treated as a string
744
745                }else{
746                        dummych1 = get_char();
747                        addlit(yylvalstr+dummych1, yytextlen+1);
748                }
749              } else if (dummych1 == '\\')
750                  {
751                      dummych1 = get_char();
752                      dummych2 = get_char();
753                      addlit(yylvalstr+dummych1+dummych2, yytextlen+2);
754                      //addlit(yylvalstr, yytextlen);
755                  }
756                else
757                    { addlit(yylvalstr, yytextlen);}
758
759                        break;
760         }
761 
762  case 24:
763                 
764                  {
765                      addlit(yylvalstr, yytextlen);
766                      break;
767                  }
768
769
770
771  case 25:
772                
773                  {
774                      start(init);
775                      addlit(yylvalstr, yytextlen);
776                      if ((literallen == 0) && (!insqlpluscmd))
777                        {returni (error);}
778                      if (literallen >= namedatalen)
779                      {
780                         setlengthofliteralbuf(namedatalen);
781                         literallen = namedatalen;
782                      }
783                      yylvalstr = litbufdup();
784                      returni (ident);
785
786                      break;
787                  }
788
789
790  case 26:
791                
792                  {
793                      if (insqlpluscmd){
794                          yyless(0);
795                          yylvalstr = litbufdup();
796                          start(init);
797                          returni(sconst);
798                      }else{
799                          addlit(yylvalstr, yytextlen);
800                      }
801
802                      break;
803                  }
804
805  case 27:
806               
807                  {
808                      addlit(yylvalstr, yytextlen);
809                      break;
810                  }
811
812  case 28:
813                        
814                  {
815                      start(xd);
816                      startlit();
817                      addlit(yylvalstr, yytextlen);
818                      break;
819                  }
820
821  case 29:
822                
823                  {
824                    dummych1 = get_char();
825                    unget_char(dummych1);
826                    if (dummych1 == (char)10)
827                      {
828                          if (insqlpluscmd){
829                            nchars = yytextlen;
830                            if(yylvalstr.charAt(nchars-1) == (char)13){
831                                yyless(nchars - 1);
832                                yylvalstr = yylvalstr.substring(0,nchars);
833                            }
834                              start(init);
835                              addlit(yylvalstr, nchars-1);
836                              yylvalstr = litbufdup();
837                              returni(sconst); //in sqlplus command, characters between ' and return is treated as a string
838
839                          }else{
840                          dummych1 = get_char();
841                          addlit(yylvalstr+dummych1, yytextlen+1);
842                          }
843
844                      } else
845                        addlit(yylvalstr, yytextlen);
846
847                  break;
848                  }
849
850  case 30:
851                
852                  {
853                    returni(lexnewline);
854                    break;
855                  }
856
857  case 31:
858        
859                  {
860                      returni(lexspace);
861                      break;
862                  }
863
864  case 32:
865                
866                  {
867                  if ((getyysstate() == xq)
868                      || (getyysstate() == xd)
869                      || (getyysstate() == xc)
870                                          || (getyysstate() == xbacktick)
871                   )
872                  {
873                      addlit(yylvalstr, 1);
874                      yyless(1);
875                      return;//exit;
876                  }
877
878                  returni(cmtdoublehyphen);
879                  break;
880                  }
881
882  case 33:
883        
884                  {
885                       returnc(yylvalstr.charAt(0));
886                       break;
887                  }
888
889  case 34:
890                       
891                  {
892                    returni(cmpop);
893                    break;
894                  }
895
896  case 35:
897           
898                  {
899
900                  if (getyysstate() == xc)
901                     {
902                      slashstar = yylvalstr.indexOf("*/");
903                        if (slashstar >= 0)
904                          {
905                              start(init);
906                              addlit(yylvalstr,slashstar+2);
907                              yylvalstr = litbufdup();
908                              yyless(slashstar+2);
909                              returni(cmtslashstar);
910                          }
911                        else
912                          {
913                              addlit(yylvalstr,1);
914                              yyless(1);
915                          }
916                     }
917                  else if (getyysstate() == xq)
918                  {
919                              addlit(yylvalstr,1);
920                              yyless(1);
921                  }
922                  else
923                    {
924                      nchars = yytextlen;
925                      slashstar = yylvalstr.indexOf("/*");
926                      dashdash = yylvalstr.indexOf("--");
927                      if ((slashstar > 0) && (dashdash > 0))
928                        {
929                          //if both appear, take the first one
930                           if (slashstar > dashdash)
931                            {slashstar = dashdash;}
932                        }
933                      else
934                        {
935                          //   if slashstar=0 then slashstar := dashdash;
936                          // add (getyysstate <> xc) to avoid something like this */--,here */ should be handled instead of --
937                          if ((slashstar > 0) && (getyysstate() != xc)) {
938                            nchars = slashstar;
939                            }
940                        }
941
942                      while ((nchars > 1)
943                              && ( (yylvalstr.charAt(nchars-1) == '+' )
944                                  || (yylvalstr.charAt(nchars-1) =='-'))
945                              && (getyysstate() != xc))
946                        {
947                          for (ic = nchars - 1; ic>=1; ic--)
948                          {
949                            if (isopchar(yylvalstr.charAt(ic-1)))  break;
950                          }
951                          if (ic >= 1) break;
952                          nchars--;
953                        }
954
955                      if (nchars < yytextlen)
956                        {
957                          //Strip the unwanted chars from the token
958                          yyless(nchars);
959                          yylvalstr = yylvalstr.substring(0,nchars);
960                        }
961
962                          ///*
963                          // * If what we have left is only one char, and it's
964                          // * one of the characters matching "self", then
965                          // * return it as a character token the same way
966                          // * that the "self" rule would have.
967                          // * make sure @ return as self char, by james wang
968                          // */
969                          if ((nchars == 1) && (isselfchar(yylvalstr.charAt(0)) || (yylvalstr.charAt(0) == '@')))
970                            {
971                              returnc(yylvalstr.charAt(0));
972                            }
973                          else if (
974                                      (nchars >= 2)
975                                          &&(
976                                               charinarray(yylvalstr.charAt(nchars-1-1), tmparray)
977                                               && ((yylvalstr.charAt(nchars-1) == ':')
978                                                                ||(yylvalstr.charAt(nchars-1) == '.')
979                                                        )
980                                               )
981                                   )
982                              {
983                                yyless(nchars-1);
984                                 yylvalstr = yylvalstr.substring(0,nchars-1);
985                                if (nchars == 2)
986                                  returnc(yylvalstr.charAt(0));
987                                else
988                                  returni(op);
989                              }
990                            else if (
991                                        (nchars >= 2)
992                                            && (
993                                                  charinarray(yylvalstr.charAt(nchars-1-1),tmparray)
994                                                  && (yylvalstr.charAt(nchars-1) == '&')
995                                                 )
996                                       )
997                                {
998                                  yyless(nchars-1);
999                                   yylvalstr = yylvalstr.substring(0,nchars-1);
1000                                  if (nchars == 2)
1001                                    returnc(yylvalstr.charAt(0));
1002                                  else
1003                                    returni(op);
1004                                }
1005                            else if ( (nchars == 2) && (yylvalstr.charAt(0) == '.') && (yylvalstr.charAt(1) == '*'))
1006                              {
1007                                      yyless(1);
1008                                     returnc(yylvalstr.charAt(0));
1009                              }
1010                                      else if ((nchars == 2) && ((yylvalstr.charAt(0) == '=') && ( (yylvalstr.charAt(1) == '?')) ))
1011                                          {
1012                                            yyless(1);
1013                                            returnc(yylvalstr.charAt(0));
1014                                          }
1015                          else if ( (nchars >= 2) && ((yylvalstr.charAt(0) == '@')&&(yylvalstr.charAt(1) != '>')))
1016                            {
1017                                    yyless(1);
1018                                   returnc(yylvalstr.charAt(0));
1019                            }
1020                          else if ( (nchars >= 2) && ((yylvalstr.charAt(0) == '>')&&(yylvalstr.charAt(1) == '>')))
1021                            {
1022                                    yyless(1);
1023                                   returnc(yylvalstr.charAt(0));
1024                            }
1025                          else if ( (nchars >= 2) && (yylvalstr.charAt(0) == '?')&&(yylvalstr.charAt(1) != '&')&&(yylvalstr.charAt(1) != '|'))
1026                            {
1027                                    yyless(1);
1028                                   returnc(yylvalstr.charAt(0));
1029                            }
1030                              else if (((nchars > 2) && (yylvalstr.charAt(0) == '*'))
1031                                      && (yylvalstr.charAt(1) == '/')
1032                                      && (getyysstate() == xc)
1033                                      )
1034                                   { //in comment, and find */ , then it must the end of comment
1035                                     yyless(2);
1036                                        addlit(yylvalstr,yytextlen);
1037                                     if (xcdepth <= 0)
1038                                       {
1039                                         start(init);
1040                                         yylvalstr = litbufdup();
1041                                         returni(cmtslashstar);
1042                                       }
1043                                     else
1044                                       xcdepth--;
1045                                   }
1046                              else
1047                                returni(op);
1048                       }
1049
1050                  break;
1051                  }
1052
1053  case 36:
1054                        
1055                  {
1056                       returni(iconst);
1057                       break;
1058                  }
1059
1060  case 37:
1061                        
1062                  {
1063                    ///*  for i in 1..5 loop, we can't recognize 1. as a decimal,but 1 as decimal
1064                    nchars = yytextlen;
1065                    if (yylvalstr.charAt(nchars-1) == '.')
1066                      {
1067                        dummych1 = get_char();
1068                        unget_char(dummych1);
1069                        if (dummych1 == '.')
1070                          {
1071                              yyless(nchars-1);
1072                            yylvalstr = yylvalstr.substring(0,nchars - 1);
1073                            returni (iconst);
1074                            return;//exit;
1075                          }
1076                      }
1077                    returni (fconst);
1078                   break;
1079                  }
1080
1081  case 38:
1082                        
1083                  {
1084                   returni (fconst);
1085                   break;
1086                  }
1087
1088  case 39:
1089              
1090                  {
1091                     boolean dollarConstant = false;
1092                          if (getyysstate() == xdolq){
1093                           int p = yylvalstr.indexOf("$");
1094                       if (p > 0){
1095                           dollarConstant = true;
1096                           addlit(yylvalstr, p);
1097                          yyless(p);
1098                          return;
1099                       }
1100                      }
1101
1102                          if (!dollarConstant){
1103                            int rw;
1104                            if ( (rw = iskeyword(yylvalstr)) != -1)   { returni(rw);}
1105                            else
1106                                {returni(ident);}
1107                          }
1108                      break;
1109                  }
1110 
1111  case 40:
1112        
1113      {
1114        if (getyysstate() == xdolq){
1115                                        addlit(yylvalstr, yytextlen);
1116          return;
1117        }else{
1118                returni (param);
1119        }
1120        
1121       break;
1122      }
1123
1124
1125  case 41:
1126           
1127        {
1128     returni (typecast);
1129     break;
1130        }
1131        
1132  case 42:
1133           
1134        {
1135     returni (double_dot);
1136     break;
1137        }
1138
1139  case 43:
1140               
1141        {
1142     returni (assign_sign);
1143     break;
1144        }
1145
1146  case 44:
1147          
1148        {
1149                returni(ident);
1150                        break;
1151        }
1152        
1153                                  
1154  case 45:
1155                        
1156                  {
1157                   returni (error);
1158                   break;
1159                  }
1160
1161    default:{
1162     System.out.println("fatal error in yyaction");
1163    }
1164   }//switch
1165}/*yyaction*/;
1166
1167
1168
1169        }