Source Code Cross Referenced for Visitor.java in  » Scripting » oscript-2.10.4 » oscript » visitor » Java Source Code / Java DocumentationJava Source Code and Java Documentation

001:        //
002:        // Generated by JTB 1.2.1
003:        //
004:
005:        package oscript.visitor;
006:
007:        import oscript.syntaxtree.*;
008:        import java.util.*;
009:
010:        /**
011:         * All void visitors must implement this interface.
012:         */
013:        public interface Visitor {
014:            //
015:            // void Auto class visitors
016:            //
017:            public void visit(NodeList n);
018:
019:            public void visit(NodeListOptional n);
020:
021:            public void visit(NodeOptional n);
022:
023:            public void visit(NodeSequence n);
024:
025:            public void visit(NodeToken n);
026:
027:            //
028:            // User-generated visitor methods below
029:            //
030:
031:            /**
032:             * <PRE>
033:             * f0 -> ( &lt;UNIX_SELF_EXECUTABLE_COMMENT&gt; )?
034:             * f1 -> Program(false)
035:             * f2 -> &lt;EOF&gt;
036:             * </PRE>
037:             */
038:            public void visit(ProgramFile n);
039:
040:            /**
041:             * <PRE>
042:             * f0 -> ( EvaluationUnit() )*
043:             * </PRE>
044:             */
045:            public void visit(Program n);
046:
047:            /**
048:             * <PRE>
049:             * f0 -> ScopeBlock()
050:             *       | VariableDeclarationBlock()
051:             *       | FunctionDeclaration()
052:             *       | TryStatement()
053:             *       | ForLoopStatement()
054:             *       | CollectionForLoopStatement()
055:             *       | WhileLoopStatement()
056:             *       | ConditionalStatement()
057:             *       | SynchronizedStatement()
058:             *       | ReturnStatement()
059:             *       | BreakStatement()
060:             *       | ContinueStatement()
061:             *       | ExpressionBlock()
062:             *       | ThrowBlock()
063:             *       | ImportBlock()
064:             *       | MixinBlock()
065:             *       | EvalBlock()
066:             * </PRE>
067:             */
068:            public void visit(EvaluationUnit n);
069:
070:            /**
071:             * <PRE>
072:             * f0 -> "{"
073:             * f1 -> Program(false)
074:             * f2 -> "}"
075:             * </PRE>
076:             */
077:            public void visit(ScopeBlock n);
078:
079:            /**
080:             * <PRE>
081:             * f0 -> VariableDeclaration()
082:             * f1 -> ";"
083:             * </PRE>
084:             */
085:            public void visit(VariableDeclarationBlock n);
086:
087:            /**
088:             * <PRE>
089:             * f0 -> Expression()
090:             * f1 -> ";"
091:             * </PRE>
092:             */
093:            public void visit(ExpressionBlock n);
094:
095:            /**
096:             * <PRE>
097:             * f0 -> "throw"
098:             * f1 -> Expression()
099:             * f2 -> ";"
100:             * </PRE>
101:             */
102:            public void visit(ThrowBlock n);
103:
104:            /**
105:             * <PRE>
106:
107:             * f0 -> "import"
108:             * f1 -> Expression()
109:             * f2 -> ";"
110:             * </PRE>
111:             */
112:            public void visit(ImportBlock n);
113:
114:            /**
115:             * <PRE>
116:
117:             * f0 -> "mixin"
118:             * f1 -> Expression()
119:             * f2 -> ";"
120:             * </PRE>
121:             */
122:            public void visit(MixinBlock n);
123:
124:            /**
125:             * <PRE>
126:
127:             * f0 -> "eval"
128:             * f1 -> Expression()
129:             * f2 -> ";"
130:             * </PRE>
131:             */
132:            public void visit(EvalBlock n);
133:
134:            /**
135:             * <PRE>
136:
137:             * f0 -> Permissions(true)
138:             * f1 -> "var"
139:             * f2 -> &lt;IDENTIFIER&gt;
140:             * f3 -> ( "=" Expression() )?
141:             * </PRE>
142:             */
143:            public void visit(VariableDeclaration n);
144:
145:            /**
146:             * <PRE>
147:
148:             * f0 -> Permissions(true)
149:             * f1 -> "function"
150:             * f2 -> &lt;IDENTIFIER&gt;
151:             * f3 -> "("
152:             * f4 -> ( Arglist() )?
153:             * f5 -> ")"
154:             * f6 -> ( "extends" PrimaryExpressionWithTrailingFxnCallExpList() FunctionCallExpressionList() )?
155:             * f7 -> "{"
156:             * f8 -> Program(true)
157:             * f9 -> "}"
158:             * </PRE>
159:             */
160:            public void visit(FunctionDeclaration n);
161:
162:            /**
163:             * <PRE>
164:             * f0 -> Permissions(false)
165:             * f1 -> &lt;IDENTIFIER&gt;
166:             * f2 -> ( "," Permissions(false) &lt;IDENTIFIER&gt; )*
167:             * f3 -> ( "..." )?
168:             * </PRE>
169:             */
170:            public void visit(Arglist n);
171:
172:            /**
173:             * <PRE>
174:             * f0 -> "try"
175:             * f1 -> EvaluationUnit()
176:             * f2 -> ( "catch" "(" Expression() &lt;IDENTIFIER&gt; ")" EvaluationUnit() )*
177:             * f3 -> ( "catch" "(" &lt;IDENTIFIER&gt; ")" EvaluationUnit() )?
178:             * f4 -> ( "finally" EvaluationUnit() )?
179:             * </PRE>
180:             */
181:            public void visit(TryStatement n);
182:
183:            /**
184:             * <PRE>
185:
186:             * f0 -> "for"
187:             * f1 -> "("
188:             * f2 -> (  PreLoopStatement() )?
189:             * f3 -> ";"
190:             * f4 -> ( Expression() )?
191:             * f5 -> ";"
192:             * f6 -> ( Expression() )?
193:             * f7 -> ")"
194:             * f8 -> EvaluationUnit()
195:             * </PRE>
196:             */
197:            public void visit(ForLoopStatement n);
198:
199:            /**
200:             * <PRE>
201:
202:             * f0 -> "for"
203:             * f1 -> "("
204:             * f2 -> PreLoopStatement()
205:             * f3 -> ":"
206:             * f4 -> Expression()
207:             * f5 -> ")"
208:             * f6 -> EvaluationUnit()
209:             * </PRE>
210:             */
211:            public void visit(CollectionForLoopStatement n);
212:
213:            /**
214:             * <PRE>
215:             * f0 -> VariableDeclaration()
216:             *       | Expression()
217:             * </PRE>
218:             */
219:            public void visit(PreLoopStatement n);
220:
221:            /**
222:             * <PRE>
223:             * f0 -> "while"
224:             * f1 -> "("
225:             * f2 -> Expression()
226:             * f3 -> ")"
227:             * f4 -> EvaluationUnit()
228:             * </PRE>
229:             */
230:            public void visit(WhileLoopStatement n);
231:
232:            /**
233:             * <PRE>
234:             * f0 -> "if"
235:             * f1 -> "("
236:             * f2 -> Expression()
237:             * f3 -> ")"
238:             * f4 -> EvaluationUnit()
239:             * f5 -> ( "else" EvaluationUnit() )?
240:             * </PRE>
241:             */
242:            public void visit(ConditionalStatement n);
243:
244:            /**
245:             * <PRE>
246:             * f0 -> "synchronized"
247:             * f1 -> "("
248:             * f2 -> Expression()
249:             * f3 -> ")"
250:             * f4 -> EvaluationUnit()
251:             * </PRE>
252:             */
253:            public void visit(SynchronizedStatement n);
254:
255:            /**
256:             * <PRE>
257:             * f0 -> "return"
258:             * f1 -> ( Expression() )?
259:             * f2 -> ";"
260:             * </PRE>
261:             */
262:            public void visit(ReturnStatement n);
263:
264:            /**
265:             * <PRE>
266:             * f0 -> "break"
267:             * f1 -> ";"
268:             * </PRE>
269:             */
270:            public void visit(BreakStatement n);
271:
272:            /**
273:             * <PRE>
274:             * f0 -> "continue"
275:             * f1 -> ";"
276:             * </PRE>
277:             */
278:            public void visit(ContinueStatement n);
279:
280:            /**
281:             * <PRE>
282:             * f0 -> AssignmentExpression()
283:             * f1 -> ( "," AssignmentExpression() )*
284:             * </PRE>
285:             */
286:            public void visit(Expression n);
287:
288:            /**
289:             * <PRE>
290:             * f0 -> "("
291:             * f1 -> ( FunctionCallExpressionListBody() )?
292:             * f2 -> ")"
293:             * </PRE>
294:             */
295:            public void visit(FunctionCallExpressionList n);
296:
297:            /**
298:             * <PRE>
299:             * f0 -> AssignmentExpression()
300:             * f1 -> ( "," AssignmentExpression() )*
301:             * </PRE>
302:             */
303:            public void visit(FunctionCallExpressionListBody n);
304:
305:            /**
306:             * <PRE>
307:             * f0 -> ConditionalExpression()
308:             * f1 -> ( ( "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "&gt;&gt;=" | "&lt;&lt;=" | "&gt;&gt;&gt;=" | "&=" | "^=" | "|=" ) ConditionalExpression() )*
309:             * </PRE>
310:             */
311:            public void visit(AssignmentExpression n);
312:
313:            /**
314:             * <PRE>
315:             * f0 -> LogicalOrExpression()
316:             * f1 -> ( "?" LogicalOrExpression() ":" LogicalOrExpression() )?
317:             * </PRE>
318:             */
319:            public void visit(ConditionalExpression n);
320:
321:            /**
322:             * <PRE>
323:             * f0 -> LogicalAndExpression()
324:             * f1 -> ( "||" LogicalAndExpression() )*
325:             * </PRE>
326:             */
327:            public void visit(LogicalOrExpression n);
328:
329:            /**
330:             * <PRE>
331:             * f0 -> BitwiseOrExpression()
332:             * f1 -> ( "&&" BitwiseOrExpression() )*
333:             * </PRE>
334:             */
335:            public void visit(LogicalAndExpression n);
336:
337:            /**
338:             * <PRE>
339:             * f0 -> BitwiseXorExpression()
340:             * f1 -> ( "|" BitwiseXorExpression() )*
341:             * </PRE>
342:             */
343:            public void visit(BitwiseOrExpression n);
344:
345:            /**
346:             * <PRE>
347:             * f0 -> BitwiseAndExpression()
348:             * f1 -> ( "^" BitwiseAndExpression() )*
349:             * </PRE>
350:             */
351:            public void visit(BitwiseXorExpression n);
352:
353:            /**
354:             * <PRE>
355:             * f0 -> EqualityExpression()
356:             * f1 -> ( "&" EqualityExpression() )*
357:             * </PRE>
358:             */
359:            public void visit(BitwiseAndExpression n);
360:
361:            /**
362:             * <PRE>
363:             * f0 -> RelationalExpression()
364:             * f1 -> ( ( "==" | "!=" ) RelationalExpression() )*
365:             * </PRE>
366:             */
367:            public void visit(EqualityExpression n);
368:
369:            /**
370:             * <PRE>
371:             * f0 -> ShiftExpression()
372:             * f1 -> ( ( "&lt;" | "&gt;" | "&gt;=" | "&lt;=" | "instanceof" ) ShiftExpression() )*
373:             * </PRE>
374:             */
375:            public void visit(RelationalExpression n);
376:
377:            /**
378:             * <PRE>
379:             * f0 -> AdditiveExpression()
380:             * f1 -> ( ( "&lt;&lt;" | "&gt;&gt;" | "&gt;&gt;&gt;" ) AdditiveExpression() )*
381:             * </PRE>
382:             */
383:            public void visit(ShiftExpression n);
384:
385:            /**
386:             * <PRE>
387:             * f0 -> MultiplicativeExpression()
388:             * f1 -> ( ( "+" | "-" ) MultiplicativeExpression() )*
389:             * </PRE>
390:             */
391:            public void visit(AdditiveExpression n);
392:
393:            /**
394:             * <PRE>
395:             * f0 -> UnaryExpression()
396:             * f1 -> ( ( "*" | "/" | "%" ) UnaryExpression() )*
397:             * </PRE>
398:             */
399:            public void visit(MultiplicativeExpression n);
400:
401:            /**
402:             * <PRE>
403:             * f0 -> ( ( "++" | "--" | "+" | "-" | "~" | "!" ) )?
404:             * f1 -> PostfixExpression()
405:             * </PRE>
406:             */
407:            public void visit(UnaryExpression n);
408:
409:            /**
410:             * <PRE>
411:             * f0 -> TypeExpression()
412:             * f1 -> ( "++" | "--" )?
413:             * </PRE>
414:             */
415:            public void visit(PostfixExpression n);
416:
417:            /**
418:             * <PRE>
419:             * f0 -> AllocationExpression()
420:             *       | CastExpression()
421:             *       | PrimaryExpression()
422:             * </PRE>
423:             */
424:            public void visit(TypeExpression n);
425:
426:            /**
427:             * <PRE>
428:             * f0 -> "new"
429:             * f1 -> PrimaryExpressionWithTrailingFxnCallExpList()
430:             * f2 -> FunctionCallExpressionList()
431:             * </PRE>
432:             */
433:            public void visit(AllocationExpression n);
434:
435:            /**
436:             * <PRE>
437:             * f0 -> "("
438:             * f1 -> PrimaryExpressionNotFunction()
439:             * f2 -> ")"
440:             * f3 -> PrimaryExpression()
441:             * </PRE>
442:             */
443:            public void visit(CastExpression n);
444:
445:            /**
446:             * <PRE>
447:             * f0 -> PrimaryPrefix()
448:             * f1 -> ( PrimaryPostfix() )*
449:             * </PRE>
450:             */
451:            public void visit(PrimaryExpression n);
452:
453:            /**
454:             * <PRE>
455:             * f0 -> PrimaryPrefixNotFunction()
456:             * f1 -> ( PrimaryPostfix() )*
457:             * </PRE>
458:             */
459:            public void visit(PrimaryExpressionNotFunction n);
460:
461:            /**
462:             * <PRE>
463:             * f0 -> PrimaryPrefix()
464:             * f1 -> ( PrimaryPostfixWithTrailingFxnCallExpList() )*
465:             * </PRE>
466:             */
467:            public void visit(PrimaryExpressionWithTrailingFxnCallExpList n);
468:
469:            /**
470:             * <PRE>
471:             * f0 -> PrimaryPrefixNotFunction()
472:             *       | FunctionPrimaryPrefix()
473:             *       | ShorthandFunctionPrimaryPrefix()
474:             * </PRE>
475:             */
476:            public void visit(PrimaryPrefix n);
477:
478:            /**
479:             * <PRE>
480:             * f0 -> ThisPrimaryPrefix()
481:             *       | SuperPrimaryPrefix()
482:             *       | CalleePrimaryPrefix()
483:             *       | ArrayDeclarationPrimaryPrefix()
484:             *       | IdentifierPrimaryPrefix()
485:             *       | ParenPrimaryPrefix()
486:             *       | Literal()
487:             * </PRE>
488:             */
489:            public void visit(PrimaryPrefixNotFunction n);
490:
491:            /**
492:             * <PRE>
493:             * f0 -> "this"
494:             * </PRE>
495:             */
496:            public void visit(ThisPrimaryPrefix n);
497:
498:            /**
499:             * <PRE>
500:             * f0 -> "super"
501:             * </PRE>
502:             */
503:            public void visit(SuperPrimaryPrefix n);
504:
505:            /**
506:             * <PRE>
507:
508:             * f0 -> "callee"
509:             * </PRE>
510:             */
511:            public void visit(CalleePrimaryPrefix n);
512:
513:            /**
514:             * <PRE>
515:             * f0 -> &lt;IDENTIFIER&gt;
516:             * </PRE>
517:             */
518:            public void visit(IdentifierPrimaryPrefix n);
519:
520:            /**
521:             * <PRE>
522:             * f0 -> "("
523:             * f1 -> Expression()
524:             * f2 -> ")"
525:             * </PRE>
526:             */
527:            public void visit(ParenPrimaryPrefix n);
528:
529:            /**
530:             * <PRE>
531:
532:             * f0 -> "function"
533:             * f1 -> "("
534:             * f2 -> ( Arglist() )?
535:             * f3 -> ")"
536:             * f4 -> ( "extends" PrimaryExpressionWithTrailingFxnCallExpList() FunctionCallExpressionList() )?
537:             * f5 -> "{"
538:             * f6 -> Program(true)
539:             * f7 -> "}"
540:             * </PRE>
541:             */
542:            public void visit(FunctionPrimaryPrefix n);
543:
544:            /**
545:             * <PRE>
546:
547:             * f0 -> "'{"
548:             * f1 -> Program(true)
549:             * f2 -> "}"
550:             * </PRE>
551:             */
552:            public void visit(ShorthandFunctionPrimaryPrefix n);
553:
554:            /**
555:             * <PRE>
556:             * f0 -> "["
557:             * f1 -> ( FunctionCallExpressionListBody() )?
558:             * f2 -> "]"
559:             * </PRE>
560:             */
561:            public void visit(ArrayDeclarationPrimaryPrefix n);
562:
563:            /**
564:             * <PRE>
565:             * f0 -> FunctionCallPrimaryPostfix()
566:             *       | ArraySubscriptPrimaryPostfix()
567:             *       | ThisScopeQualifierPrimaryPostfix()
568:             *       | PropertyIdentifierPrimaryPostfix()
569:             * </PRE>
570:             */
571:            public void visit(PrimaryPostfix n);
572:
573:            /**
574:             * <PRE>
575:             * f0 -> ArraySubscriptPrimaryPostfix()
576:             *       | ThisScopeQualifierPrimaryPostfix()
577:             *       | PropertyIdentifierPrimaryPostfix()
578:             * </PRE>
579:             */
580:            public void visit(PrimaryPostfixWithTrailingFxnCallExpList n);
581:
582:            /**
583:             * <PRE>
584:             * f0 -> FunctionCallExpressionList()
585:             * </PRE>
586:             */
587:            public void visit(FunctionCallPrimaryPostfix n);
588:
589:            /**
590:             * <PRE>
591:             * f0 -> "["
592:             * f1 -> Expression()
593:             * f2 -> ( ".." Expression() )?
594:             * f3 -> "]"
595:             * </PRE>
596:             */
597:            public void visit(ArraySubscriptPrimaryPostfix n);
598:
599:            /**
600:             * <PRE>
601:             * f0 -> "."
602:             * f1 -> &lt;IDENTIFIER&gt;
603:             * </PRE>
604:             */
605:            public void visit(PropertyIdentifierPrimaryPostfix n);
606:
607:            /**
608:             * <PRE>
609:             * f0 -> "."
610:             * f1 -> "this"
611:             * </PRE>
612:             */
613:            public void visit(ThisScopeQualifierPrimaryPostfix n);
614:
615:            /**
616:             * <PRE>
617:             * f0 -> &lt;INTEGER_LITERAL&gt;
618:             *       | &lt;FLOATING_POINT_LITERAL&gt;
619:             *       | &lt;STRING_LITERAL&gt;
620:             *       | &lt;REGEXP_LITERAL&gt;
621:             *       | "true"
622:             *       | "false"
623:             *       | "null"
624:             *       | "undefined"
625:             * </PRE>
626:             */
627:            public void visit(Literal n);
628:
629:            /**
630:             * <PRE>
631:
632:             * f0 -> ( "static" | "const" | "private" | "protected" | "public" )*
633:             * </PRE>
634:             */
635:            public void visit(Permissions n);
636:
637:        }