e2f1dce23fd1db48ad3f089322a99ea01722d7db
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpeclipse / phpeditor / PHPParser.java
1 package net.sourceforge.phpeclipse.phpeditor;
2
3 import java.util.HashMap;
4
5 import net.sourceforge.phpeclipse.phpeditor.php.PHPKeywords;
6
7 /**********************************************************************
8 Copyright (c) 2000, 2002 IBM Corp. and others.
9 All rights reserved. This program and the accompanying materials
10 are made available under the terms of the Common Public License v1.0
11 which accompanies this distribution, and is available at
12 http://www.eclipse.org/legal/cpl-v10.html
13
14 Contributors:
15     IBM Corporation - Initial implementation
16     Klaus Hartlage - www.eclipseproject.de
17 **********************************************************************/
18
19 public class PHPParser extends PHPKeywords {
20
21   private static HashMap keywordMap = null;
22   private String str;
23
24   // current character
25   char ch;
26   // current token
27   int token;
28
29   // row counter for syntax errors:
30   int rowCount;
31   // column counter for syntax errors:
32   int columnCount;
33
34   int chIndx;
35
36   // current identifier
37   String identifier;
38
39   Long longNumber;
40   Double doubleNumber;
41
42   final static int TT_EOF = 0;
43   final static int TT_UNDEFINED = 1;
44
45   final static int TT_NOT = 31;
46   final static int TT_DOT = 32;
47   final static int TT_POW = 33;
48   final static int TT_DIVIDE = 34;
49   final static int TT_MULTIPLY = 35;
50   final static int TT_SUBTRACT = 36;
51   final static int TT_ADD = 37;
52   final static int TT_EQUAL = 38;
53   final static int TT_UNEQUAL = 39;
54   final static int TT_GREATER = 40;
55   final static int TT_GREATEREQUAL = 41;
56   final static int TT_LESS = 42;
57   final static int TT_LESSEQUAL = 43;
58   final static int TT_AND = 44;
59   final static int TT_OR = 45;
60   final static int TT_HASH = 46;
61   final static int TT_DDOT = 47;
62   final static int TT_DOTASSIGN = 48;
63
64   final static int TT_SET = 49;
65
66   final static int TT_FOREACH = 51;
67   final static int TT_ARGOPEN = 128;
68   final static int TT_ARGCLOSE = 129;
69   final static int TT_LISTOPEN = 130;
70   final static int TT_LISTCLOSE = 131;
71   final static int TT_PARTOPEN = 132;
72   final static int TT_PARTCLOSE = 133;
73   final static int TT_COMMA = 134;
74   final static int TT_PERCENT = 135;
75   final static int TT_STRING = 136;
76   final static int TT_IDENTIFIER = 138;
77   final static int TT_DIGIT = 139;
78   final static int TT_SEMICOLON = 140;
79   final static int TT_SLOT = 141;
80   final static int TT_SLOTSEQUENCE = 142;
81   final static int TT_DECREMENT = 144;
82   final static int TT_INCREMENT = 145;
83   final static int TT_ADDTO = 146;
84   final static int TT_DIVIDEBY = 147;
85   final static int TT_SUBTRACTFROM = 148;
86   final static int TT_TIMESBY = 149;
87   final static int TT_VARIABLE = 150;
88   final static int TT_INT_NUMBER = 151;
89   final static int TT_DOUBLE_NUMBER = 152;
90   final static int TT_INTERPOLATED_STRING = 153;
91   final static int TT_STRING_CONSTANT = 154;
92   //  final static int TT_AT = 153; // @
93   /**
94    *  Class Constructor.
95    *
96    *@param  s
97    *@param  sess  Description of Parameter
98    *@see
99    */
100   public PHPParser(String s, int rowCount) {
101     if (keywordMap == null) {
102       keywordMap = new HashMap();
103       for (int i = 0; i < PHP_KEYWORS.length; i++) {
104         keywordMap.put(PHP_KEYWORS[i], new Integer(PHP_KEYWORD_TOKEN[i]));
105       }
106     }
107     this.str = s;
108     this.token = TT_EOF;
109     this.chIndx = 0;
110     this.rowCount = rowCount;
111     this.columnCount = 0;
112
113     getNextToken();
114   }
115
116   private void throwSyntaxError(String error) {
117
118     if (str.length() < chIndx) {
119       chIndx--;
120     }
121     // read until end-of-line
122     int eol = chIndx;
123     while (str.length() > eol) {
124       ch = str.charAt(eol++);
125       if (ch == '\n') {
126         eol--;
127         break;
128       }
129     }
130     throw new SyntaxError(rowCount, chIndx - columnCount, str.substring(columnCount + 1, eol), error);
131   }
132
133   /**
134    *  Method Declaration.
135    *
136    *@see
137    */
138   void getChar() {
139     if (str.length() > chIndx) {
140       ch = str.charAt(chIndx++);
141
142       return;
143     }
144
145     chIndx = str.length() + 1;
146     ch = ' ';
147     token = TT_EOF;
148   }
149
150   /**
151    * gets the next token from input
152    */
153   void getNextToken() {
154     while (str.length() > chIndx) {
155       ch = str.charAt(chIndx++);
156       token = TT_UNDEFINED;
157       if (ch == '\n') {
158         rowCount++;
159         columnCount = chIndx;
160         continue; // while loop
161       }
162
163       if (!Character.isWhitespace(ch)) {
164         if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch == '_') || (ch == '$') || (ch == '@')) {
165           getIdentifier();
166           return;
167         }
168         if (ch >= '0' && ch <= '9') {
169           getNumber();
170           return;
171         }
172         if (ch == '/') {
173           if (str.length() > chIndx) {
174             if (str.charAt(chIndx) == '/') {
175               chIndx++;
176               // read comment until end of line:
177               while ((str.length() > chIndx) && (str.charAt(chIndx) != '\n')) {
178                 chIndx++;
179               }
180               continue;
181             } else if (str.charAt(chIndx) == '*') {
182               chIndx++;
183               // multi line comment:
184               while (str.length() > chIndx) {
185                 if  (str.charAt(chIndx) == '*' &&
186                       (str.length() > (chIndx+1) ) && 
187                       str.charAt(chIndx+1) == '/') {
188                   chIndx += 2;
189                   break;
190                 }
191                 chIndx++;
192               }
193               continue;
194             }
195           }
196         } else if (ch == '#') {
197           // read comment until end of line:
198           while ((str.length() > chIndx) && (str.charAt(chIndx) != '\n')) {
199             chIndx++;
200           }
201           continue;
202         } else if (ch == '"') {
203           // read string until end
204           while ((str.length() > chIndx) && (str.charAt(chIndx++) != '"')) {
205             if (str.charAt(chIndx) == '\\') {
206               if (str.length() > chIndx) {
207                 chIndx++;
208               }
209               if (str.length() > chIndx) {
210                 chIndx++;
211               }
212             } else {
213               if (str.charAt(chIndx) == '\n') {
214                 rowCount++;
215                 columnCount = chIndx;
216               }
217             }
218           }
219           if (str.length() > chIndx) {
220             chIndx++;
221           }
222           token = TT_INTERPOLATED_STRING;
223           return;
224         } else if (ch == '\'') {
225           // read string until end
226           while ((str.length() > chIndx) && (str.charAt(chIndx++) != '\'')) {
227             if (str.charAt(chIndx) == '\\') {
228               if (str.length() > chIndx) {
229                 chIndx++;
230               }
231               if (str.length() > chIndx) {
232                 chIndx++;
233               }
234             }
235           }
236           if (str.length() > chIndx) {
237             chIndx++;
238           }
239           token = TT_STRING_CONSTANT;
240           return;
241         }
242
243         switch (ch) {
244
245           case '(' :
246             token = TT_ARGOPEN;
247
248             break;
249           case ')' :
250             token = TT_ARGCLOSE;
251
252             break;
253           case '{' :
254             token = TT_LISTOPEN;
255
256             break;
257           case '}' :
258             token = TT_LISTCLOSE;
259
260             break;
261           case '[' :
262             token = TT_PARTOPEN;
263
264             break;
265           case ']' :
266             token = TT_PARTCLOSE;
267
268             break;
269           case ',' :
270             token = TT_COMMA;
271
272             break;
273
274           case '.' :
275             token = TT_DOT;
276             if (str.length() > chIndx) {
277               if (str.charAt(chIndx) == '=') {
278                 chIndx++;
279                 token = TT_DOTASSIGN;
280
281                 break;
282               }
283             }
284
285             break;
286           case '"' :
287             token = TT_STRING;
288
289             break;
290           case '%' :
291             token = TT_PERCENT;
292
293             break;
294           case ';' :
295             token = TT_SEMICOLON;
296
297             break;
298           case '^' :
299             token = TT_POW;
300
301             break;
302           case '/' :
303             token = TT_DIVIDE;
304
305             if (str.length() > chIndx) {
306               if (str.charAt(chIndx) == '=') {
307                 chIndx++;
308                 token = TT_DIVIDEBY;
309
310                 break;
311               }
312             }
313
314             break;
315           case '*' :
316             token = TT_MULTIPLY;
317             if (str.length() > chIndx) {
318               if (str.charAt(chIndx) == '*') {
319                 chIndx++;
320                 token = TT_POW;
321
322                 break;
323               }
324               if (str.charAt(chIndx) == '=') {
325                 chIndx++;
326                 token = TT_TIMESBY;
327
328                 break;
329               }
330             }
331
332             break;
333           case '+' :
334             token = TT_ADD;
335             if (str.length() > chIndx) {
336               if (str.charAt(chIndx) == '+') {
337                 chIndx++;
338                 token = TT_INCREMENT;
339
340                 break;
341               }
342               if (str.charAt(chIndx) == '=') {
343                 chIndx++;
344                 token = TT_ADDTO;
345
346                 break;
347               }
348             }
349             break;
350           case '-' :
351             token = TT_SUBTRACT;
352             if (str.length() > chIndx) {
353               if (str.charAt(chIndx) == '-') {
354                 chIndx++;
355                 token = TT_DECREMENT;
356
357                 break;
358               }
359               if (str.charAt(chIndx) == '=') {
360                 chIndx++;
361                 token = TT_SUBTRACTFROM;
362
363                 break;
364               }
365             }
366
367             break;
368           case '=' :
369             token = TT_SET;
370
371             if (str.length() > chIndx) {
372               ch = str.charAt(chIndx);
373
374               if (ch == '=') {
375                 chIndx++;
376                 token = TT_EQUAL;
377
378                 break;
379               }
380               if (ch == '>') {
381                 chIndx++;
382                 token = TT_FOREACH;
383
384                 break;
385               }
386             }
387
388             break;
389           case '!' :
390             token = TT_NOT;
391
392             if (str.length() > chIndx) {
393               if (str.charAt(chIndx) == '=') {
394                 chIndx++;
395                 token = TT_UNEQUAL;
396
397                 break;
398               }
399             }
400
401             break;
402           case '>' :
403             token = TT_GREATER;
404
405             if (str.length() > chIndx) {
406               if (str.charAt(chIndx) == '=') {
407                 chIndx++;
408                 token = TT_GREATEREQUAL;
409
410                 break;
411               }
412             }
413
414             break;
415           case '<' :
416             token = TT_LESS;
417
418             if (str.length() > chIndx) {
419               if (str.charAt(chIndx) == '=') {
420                 chIndx++;
421                 token = TT_LESSEQUAL;
422
423                 break;
424               }
425             }
426
427             break;
428
429           case '|' :
430             if (str.length() > chIndx) {
431               if (str.charAt(chIndx++) == '|') {
432                 token = TT_OR;
433
434                 break;
435               }
436             }
437
438             break;
439           case '&' :
440             if (str.length() > chIndx) {
441               if (str.charAt(chIndx++) == '&') {
442                 token = TT_AND;
443
444                 break;
445               }
446             }
447
448             break;
449           case ':' :
450             token = TT_DDOT;
451
452             break;
453           case '#' :
454             token = TT_HASH;
455
456             break;
457             //          case '@' :
458             //            token = TT_AT;
459             //
460             //            break;
461           default :
462             throwSyntaxError("unexpected character: '" + ch + "'");
463         }
464
465         if (token == TT_UNDEFINED) {
466           throwSyntaxError("token not found");
467         }
468
469         return;
470       }
471     }
472
473     chIndx = str.length() + 1;
474     ch = ' ';
475     token = TT_EOF;
476   }
477
478   void getIdentifier() {
479     StringBuffer ident = new StringBuffer();
480     ident.append(ch);
481
482     ident.append(ch);
483     if (ch == '$') {
484       token = TT_VARIABLE;
485     } else {
486       token = TT_IDENTIFIER;
487     }
488     getChar();
489     while ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || (ch >= '_')) {
490       ident.append(ch);
491       getChar();
492     }
493     identifier = ident.toString();
494
495     Integer i = (Integer) keywordMap.get(identifier);
496     if (i != null) {
497       token = i.intValue();
498     }
499   }
500
501   void getNumber() {
502     StringBuffer inum = new StringBuffer();
503     char dFlag = ' ';
504     int numFormat = 10;
505
506     // save first digit
507     char firstCh = ch;
508     inum.append(ch);
509
510     getChar();
511     // determine number conversions:
512     if (firstCh == '0') {
513       switch (ch) {
514         case 'b' :
515           numFormat = 2;
516           getChar();
517           break;
518         case 'B' :
519           numFormat = 2;
520           getChar();
521           break;
522         case 'o' :
523           numFormat = 8;
524           getChar();
525           break;
526         case 'O' :
527           numFormat = 8;
528           getChar();
529           break;
530         case 'x' :
531           numFormat = 16;
532           getChar();
533           break;
534         case 'X' :
535           numFormat = 16;
536           getChar();
537           break;
538       }
539     }
540
541     if (numFormat == 16) {
542       while ((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) {
543         inum.append(ch);
544         getChar();
545       }
546     } else {
547       while ((ch >= '0' && ch <= '9') || (ch == '.') || (ch == 'E') || (ch == 'e')) {
548         if ((ch == '.') || (ch == 'E') || (ch == 'e')) {
549           if (ch == '.' && dFlag != ' ') {
550             break;
551           }
552           if ((dFlag == 'E') || (dFlag == 'e')) {
553             break;
554           }
555           dFlag = ch;
556           inum.append(ch);
557           getChar();
558           if ((ch == '-') || (ch == '+')) {
559             inum.append(ch);
560             getChar();
561           }
562         } else {
563           inum.append(ch);
564           getChar();
565         }
566       }
567     }
568
569     // token = TT_INT_NUMBER;
570
571     try {
572       if (dFlag != ' ') {
573         doubleNumber = new Double(inum.toString());
574         token = TT_DOUBLE_NUMBER;
575         return;
576       } else {
577         longNumber = Long.valueOf(inum.toString(), numFormat);
578         token = TT_INT_NUMBER;
579         return;
580       }
581
582     } catch (Throwable e) {
583       throwSyntaxError("Number format error: " + inum.toString());
584     }
585   }
586
587   public void start() throws SyntaxError {
588     statementList();
589     if (token != TT_EOF) {
590       if (token == TT_ARGCLOSE) {
591         throwSyntaxError("too many closing ')'; end-of-file not reached");
592       }
593       if (token == TT_LISTCLOSE) {
594         throwSyntaxError("too many closing '}'; end-of-file not reached");
595       }
596       if (token == TT_PARTCLOSE) {
597         throwSyntaxError("too many closing ']'; end-of-file not reached");
598       }
599
600       throwSyntaxError("end-of-file not reached");
601     }
602
603   }
604
605   public void statementList() {
606     statement();
607   }
608
609   public void statement() {
610     while (token != TT_UNDEFINED) {
611       if (token > TT_KEYWORD) {
612         if (token == TT_case) {
613           getNextToken();
614           constant();
615           if (token == TT_DDOT) {
616             getNextToken();
617             statement();
618           } else {
619             throwSyntaxError("':' character after 'case' constant expected.");
620           }
621           return;
622         } else if (token == TT_default) {
623           getNextToken();
624           if (token == TT_DDOT) {
625             getNextToken();
626             statement();
627           } else {
628             throwSyntaxError("':' character after 'default' expected.");
629           }
630           return;
631         } else if (token == TT_include || token == TT_include_once) {
632           getNextToken();
633           expression();
634           if (token == TT_SEMICOLON) {
635             getNextToken();
636           } else {
637             throwSyntaxError("';' character after 'include' or 'include_once' expected.");
638           }
639           return;
640         } else if (token == TT_require || token == TT_require_once) {
641           getNextToken();
642           constant();
643           if (token == TT_SEMICOLON) {
644             getNextToken();
645           } else {
646             throwSyntaxError("';' character after 'require' or 'require_once' expected.");
647           }
648           return;
649         } else if (token == TT_if) {
650           getNextToken();
651           if (token == TT_ARGOPEN) {
652             getNextToken();
653           } else {
654             throwSyntaxError("'(' expected after 'if' keyword.");
655           }
656           expression();
657           if (token == TT_ARGCLOSE) {
658             getNextToken();
659           } else {
660             throwSyntaxError("')' expected after 'if' condition.");
661           }
662           ifStatement();
663           return;
664
665         } else if (token == TT_switch) {
666           getNextToken();
667           if (token == TT_ARGOPEN) {
668             getNextToken();
669           } else {
670             throwSyntaxError("'(' expected after 'switch' keyword.");
671           }
672           expression();
673           if (token == TT_ARGCLOSE) {
674             getNextToken();
675           } else {
676             throwSyntaxError("')' expected after 'switch' condition.");
677           }
678           switchStatement();
679           return;
680         } else if (token == TT_for) {
681           getNextToken();
682           if (token == TT_ARGOPEN) {
683             getNextToken();
684           } else {
685             throwSyntaxError("'(' expected after 'for' keyword.");
686           }
687           if (token == TT_SEMICOLON) {
688             getNextToken();
689           } else {
690             expression();
691             if (token == TT_SEMICOLON) {
692               getNextToken();
693             } else {
694               throwSyntaxError("';' character after 'for' expected.");
695             }
696           }
697           if (token == TT_SEMICOLON) {
698             getNextToken();
699           } else {
700             expression();
701             if (token == TT_SEMICOLON) {
702               getNextToken();
703             } else {
704               throwSyntaxError("';' character after 'for' expected.");
705             }
706           }
707           if (token == TT_ARGCLOSE) {
708             getNextToken();
709           } else {
710             expression();
711             if (token == TT_ARGCLOSE) {
712               getNextToken();
713             } else {
714               throwSyntaxError("')' expected after 'for' condition.");
715             }
716           }
717           forStatement();
718           return;
719         } else if (token == TT_while) {
720           getNextToken();
721           if (token == TT_ARGOPEN) {
722             getNextToken();
723           } else {
724             throwSyntaxError("'(' expected after 'while' keyword.");
725           }
726           expression();
727           if (token == TT_ARGCLOSE) {
728             getNextToken();
729           } else {
730             throwSyntaxError("')' expected after 'while' condition.");
731           }
732           whileStatement();
733           return;
734         } else if (token == TT_foreach) {
735           getNextToken();
736           if (token == TT_ARGOPEN) {
737             getNextToken();
738           } else {
739             throwSyntaxError("'(' expected after 'foreach' keyword.");
740           }
741           expression();
742           if (token == TT_as) {
743             getNextToken();
744           } else {
745             throwSyntaxError("'as' expected after 'foreach' exxpression.");
746           }
747           variable();
748           if (token == TT_FOREACH) {
749             getNextToken();
750             variable();
751           }
752           if (token == TT_ARGCLOSE) {
753             getNextToken();
754           } else {
755             throwSyntaxError("')' expected after 'foreach' expression.");
756           }
757           foreachStatement();
758           return;
759
760         } else if (token == TT_continue || token == TT_break || token == TT_return) {
761           getNextToken();
762           if (token != TT_SEMICOLON) {
763             expression();
764           }
765           if (token == TT_SEMICOLON) {
766             getNextToken();
767           } else {
768             throwSyntaxError("';' expected after 'continue', 'break' or 'return'.");
769           }
770           return;
771
772         } else if (token == TT_echo) {
773           getNextToken();
774           expressionList();
775           if (token == TT_SEMICOLON) {
776             getNextToken();
777           } else {
778             throwSyntaxError("';' expected after 'echo' statement.");
779           }
780           return;
781
782         } else if (token == TT_print) {
783           getNextToken();
784           expression();
785           if (token == TT_SEMICOLON) {
786             getNextToken();
787           } else {
788             throwSyntaxError("';' expected after 'print' statement.");
789           }
790           return;
791
792         } else if (token == TT_global || token == TT_static) {
793           getNextToken();
794           variableList();
795           if (token == TT_SEMICOLON) {
796             getNextToken();
797           } else {
798             throwSyntaxError("';' expected after 'global' or 'static' statement.");
799           }
800           return;
801
802         } else if (token == TT_unset) {
803           getNextToken();
804           if (token == TT_ARGOPEN) {
805             getNextToken();
806           } else {
807             throwSyntaxError("'(' expected after 'unset' keyword.");
808           }
809           variableList();
810           if (token == TT_ARGCLOSE) {
811             getNextToken();
812           } else {
813             throwSyntaxError("')' expected after 'unset' statement.");
814           }
815           if (token == TT_SEMICOLON) {
816             getNextToken();
817           } else {
818             throwSyntaxError("';' expected after 'unset' statement.");
819           }
820           return;
821
822         } else if (token == TT_exit || token == TT_die) {
823           getNextToken();
824           if (token != TT_SEMICOLON) {
825             exitStatus();
826           }
827           if (token == TT_SEMICOLON) {
828             getNextToken();
829           } else {
830             throwSyntaxError("';' expected after 'exit' or 'die' statement.");
831           }
832           return;
833
834         } else if (token == TT_define) {
835           getNextToken();
836           if (token == TT_ARGOPEN) {
837             getNextToken();
838           } else {
839             throwSyntaxError("'(' expected after 'define' keyword.");
840           }
841           constant();
842           if (token == TT_COMMA) {
843             getNextToken();
844           } else {
845             throwSyntaxError("',' expected after first 'define' constant.");
846           }
847           constant();
848           if (token == TT_ARGCLOSE) {
849             getNextToken();
850           } else {
851             throwSyntaxError("')' expected after 'define' statement.");
852           }
853           if (token == TT_SEMICOLON) {
854             getNextToken();
855           } else {
856             throwSyntaxError("';' expected after 'define' statement.");
857           }
858           return;
859
860         }
861
862       } else {
863         if (token == TT_LISTOPEN) {
864           getNextToken();
865           statementList();
866           if (token == TT_LISTCLOSE) {
867             getNextToken();
868           } else {
869             throwSyntaxError("'}' expected.");
870           }
871         }
872       }
873       expression();
874       if (token == TT_SEMICOLON) {
875         getNextToken();
876       } else {
877         throwSyntaxError("';' expected after expression.");
878       }
879     }
880   }
881
882   public void labeledStatement() {
883   }
884
885   public void expressionStatement() {
886   }
887
888   public void inclusionStatement() {
889   }
890
891   public void compoundStatement() {
892   }
893
894   public void selectionStatement() {
895   }
896
897   public void iterationStatement() {
898   }
899
900   public void jumpStatement() {
901   }
902
903   public void outputStatement() {
904   }
905
906   public void scopeStatement() {
907   }
908
909   public void flowStatement() {
910   }
911
912   public void definitionStatement() {
913   }
914
915   public void ifStatement() {
916   }
917
918   public void switchStatement() {
919   }
920
921   public void forStatement() {
922   }
923
924   public void whileStatement() {
925   }
926
927   public void foreachStatement() {
928   }
929
930   public void exitStatus() {
931     if (token == TT_ARGOPEN) {
932       getNextToken();
933     } else {
934       throwSyntaxError("'(' expected in 'exit-status'.");
935     }
936     if (token != TT_ARGCLOSE) {
937       expression();
938     }
939     if (token == TT_ARGCLOSE) {
940       getNextToken();
941     } else {
942       throwSyntaxError("')' expected after 'exit-status'.");
943     }
944   }
945
946   public void expressionList() {
947     do {
948       expression();
949       if (token == TT_COMMA) {
950         getNextToken();
951       } else {
952         break;
953       }
954     } while (true);
955   }
956
957   public void expression() {
958     if (token == TT_STRING_CONSTANT || token == TT_INTERPOLATED_STRING) {
959       getNextToken();
960     } else {
961       postfixExpression();
962       //      while (token != TT_SEMICOLON) {
963       //        getNextToken();
964       //      }
965     }
966   }
967
968   public void postfixExpression() {
969
970   }
971
972   public void variableList() {
973     do {
974       variable();
975       if (token == TT_COMMA) {
976         getNextToken();
977       } else {
978         break;
979       }
980     } while (true);
981   }
982
983   public void variable() {
984     if (token == TT_VARIABLE) {
985       getNextToken();
986     } else {
987       throwSyntaxError("$-variable expected in variable-list.");
988     }
989   }
990
991   public void constant() {
992
993   }
994 }