Source code

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