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

0001:        /*=============================================================================
0002:         *     Copyright Texas Instruments 2002. All Rights Reserved.
0003:         */
0004:
0005:        package oscript.visitor;
0006:
0007:        import oscript.syntaxtree.*;
0008:
0009:        import java.util.*;
0010:        import oscript.data.Value;
0011:        import oscript.data.JavaBridge;
0012:
0013:        /**
0014:         * <CLASS_COMMENT>
0015:         */
0016:        public class ExtensibleVisitor extends ObjectDepthFirst {
0017:
0018:            /**
0019:             * table mapping node type to script visitor function
0020:             */
0021:            private Hashtable visitorTable = new Hashtable();
0022:
0023:            /**
0024:             * register node visitor
0025:             */
0026:            public Value register(Class nodeType, Value fxn) {
0027:                return (Value) (visitorTable.put(nodeType, fxn));
0028:            }
0029:
0030:            /**
0031:             * get node visitor
0032:             */
0033:            public Value get(Class nodeType) {
0034:                return (Value) (visitorTable.get(nodeType));
0035:            }
0036:
0037:            /**
0038:             * remove node visitor
0039:             */
0040:            public Value remove(Class nodeType) {
0041:                return (Value) (visitorTable.remove(nodeType));
0042:            }
0043:
0044:            /**
0045:             * handles node tokens
0046:             */
0047:            public Object visit(NodeToken n, Object argu) {
0048:                Value val = get(NodeToken.class);
0049:                if (val != null)
0050:                    return val.callAsFunction(new Value[] {
0051:                            JavaBridge.convertToScriptObject(n),
0052:                            JavaBridge.convertToScriptObject(argu) });
0053:                return super .visit(n, argu);
0054:            }
0055:
0056:            /**
0057:             *   <PRE>
0058:             * f0 -> ( &lt;UNIX_SELF_EXECUTABLE_COMMENT&gt; )?
0059:             * f1 -> Program(false)
0060:             * f2 -> &lt;EOF&gt;
0061:             * </PRE>
0062:             */
0063:            public Object visit(ProgramFile n, Object argu) {
0064:                Value val = get(ProgramFile.class);
0065:                if (val != null)
0066:                    return val.callAsFunction(new Value[] {
0067:                            JavaBridge.convertToScriptObject(n),
0068:                            JavaBridge.convertToScriptObject(argu) });
0069:                return super .visit(n, argu);
0070:            }
0071:
0072:            /**
0073:             *   <PRE>
0074:             * f0 -> ( EvaluationUnit() )*
0075:             * </PRE>
0076:             */
0077:            public Object visit(Program n, Object argu) {
0078:                Value val = get(Program.class);
0079:                if (val != null)
0080:                    return val.callAsFunction(new Value[] {
0081:                            JavaBridge.convertToScriptObject(n),
0082:                            JavaBridge.convertToScriptObject(argu) });
0083:                return super .visit(n, argu);
0084:            }
0085:
0086:            /**
0087:             *   <PRE>
0088:             * f0 -> ScopeBlock()
0089:             *       | VariableDeclarationBlock()
0090:             *       | FunctionDeclaration()
0091:             *       | TryStatement()
0092:             *       | ForLoopStatement()
0093:             *       | CollectionForLoopStatement()
0094:             *       | WhileLoopStatement()
0095:             *       | ConditionalStatement()
0096:             *       | SynchronizedStatement()
0097:             *       | ReturnStatement()
0098:             *       | BreakStatement()
0099:             *       | ContinueStatement()
0100:             *       | ExpressionBlock()
0101:             *       | ThrowBlock()
0102:             *       | ImportBlock()
0103:             *       | MixinBlock()
0104:             *       | EvalBlock()
0105:             * </PRE>
0106:             */
0107:            public Object visit(EvaluationUnit n, Object argu) {
0108:                Value val = get(EvaluationUnit.class);
0109:                if (val != null)
0110:                    return val.callAsFunction(new Value[] {
0111:                            JavaBridge.convertToScriptObject(n),
0112:                            JavaBridge.convertToScriptObject(argu) });
0113:                return super .visit(n, argu);
0114:            }
0115:
0116:            /**
0117:             *   <PRE>
0118:             * f0 -> "{"
0119:             * f1 -> Program(false)
0120:             * f2 -> "}"
0121:             * </PRE>
0122:             */
0123:            public Object visit(ScopeBlock n, Object argu) {
0124:                Value val = get(ScopeBlock.class);
0125:                if (val != null)
0126:                    return val.callAsFunction(new Value[] {
0127:                            JavaBridge.convertToScriptObject(n),
0128:                            JavaBridge.convertToScriptObject(argu) });
0129:                return super .visit(n, argu);
0130:            }
0131:
0132:            /**
0133:             *   <PRE>
0134:             * f0 -> VariableDeclaration()
0135:             * f1 -> ";"
0136:             * </PRE>
0137:             */
0138:            public Object visit(VariableDeclarationBlock n, Object argu) {
0139:                Value val = get(VariableDeclarationBlock.class);
0140:                if (val != null)
0141:                    return val.callAsFunction(new Value[] {
0142:                            JavaBridge.convertToScriptObject(n),
0143:                            JavaBridge.convertToScriptObject(argu) });
0144:                return super .visit(n, argu);
0145:            }
0146:
0147:            /**
0148:             *   <PRE>
0149:             * f0 -> Expression()
0150:             * f1 -> ";"
0151:             * </PRE>
0152:             */
0153:            public Object visit(ExpressionBlock n, Object argu) {
0154:                Value val = get(ExpressionBlock.class);
0155:                if (val != null)
0156:                    return val.callAsFunction(new Value[] {
0157:                            JavaBridge.convertToScriptObject(n),
0158:                            JavaBridge.convertToScriptObject(argu) });
0159:                return super .visit(n, argu);
0160:            }
0161:
0162:            /**
0163:             *   <PRE>
0164:             * f0 -> "throw"
0165:             * f1 -> Expression()
0166:             * f2 -> ";"
0167:             * </PRE>
0168:             */
0169:            public Object visit(ThrowBlock n, Object argu) {
0170:                Value val = get(ThrowBlock.class);
0171:                if (val != null)
0172:                    return val.callAsFunction(new Value[] {
0173:                            JavaBridge.convertToScriptObject(n),
0174:                            JavaBridge.convertToScriptObject(argu) });
0175:                return super .visit(n, argu);
0176:            }
0177:
0178:            /**
0179:             *   <PRE>
0180:
0181:             * f0 -> "import"
0182:             * f1 -> Expression()
0183:             * f2 -> ";"
0184:             * </PRE>
0185:             */
0186:            public Object visit(ImportBlock n, Object argu) {
0187:                Value val = get(ImportBlock.class);
0188:                if (val != null)
0189:                    return val.callAsFunction(new Value[] {
0190:                            JavaBridge.convertToScriptObject(n),
0191:                            JavaBridge.convertToScriptObject(argu) });
0192:                return super .visit(n, argu);
0193:            }
0194:
0195:            /**
0196:             *   <PRE>
0197:
0198:             * f0 -> "mixin"
0199:             * f1 -> Expression()
0200:             * f2 -> ";"
0201:             * </PRE>
0202:             */
0203:            public Object visit(MixinBlock n, Object argu) {
0204:                Value val = get(MixinBlock.class);
0205:                if (val != null)
0206:                    return val.callAsFunction(new Value[] {
0207:                            JavaBridge.convertToScriptObject(n),
0208:                            JavaBridge.convertToScriptObject(argu) });
0209:                return super .visit(n, argu);
0210:            }
0211:
0212:            /**
0213:             *   <PRE>
0214:
0215:             * f0 -> "eval"
0216:             * f1 -> Expression()
0217:             * f2 -> ";"
0218:             * </PRE>
0219:             */
0220:            public Object visit(EvalBlock n, Object argu) {
0221:                Value val = get(EvalBlock.class);
0222:                if (val != null)
0223:                    return val.callAsFunction(new Value[] {
0224:                            JavaBridge.convertToScriptObject(n),
0225:                            JavaBridge.convertToScriptObject(argu) });
0226:                return super .visit(n, argu);
0227:            }
0228:
0229:            /**
0230:             *   <PRE>
0231:
0232:             * f0 -> Permissions(true)
0233:             * f1 -> "var"
0234:             * f2 -> &lt;IDENTIFIER&gt;
0235:             * f3 -> ( "=" Expression() )?
0236:             * </PRE>
0237:             */
0238:            public Object visit(VariableDeclaration n, Object argu) {
0239:                Value val = get(VariableDeclaration.class);
0240:                if (val != null)
0241:                    return val.callAsFunction(new Value[] {
0242:                            JavaBridge.convertToScriptObject(n),
0243:                            JavaBridge.convertToScriptObject(argu) });
0244:                return super .visit(n, argu);
0245:            }
0246:
0247:            /**
0248:             *   <PRE>
0249:
0250:             * f0 -> Permissions(true)
0251:             * f1 -> "function"
0252:             * f2 -> &lt;IDENTIFIER&gt;
0253:             * f3 -> "("
0254:             * f4 -> ( Arglist() )?
0255:             * f5 -> ")"
0256:             * f6 -> ( "extends" PrimaryExpressionWithTrailingFxnCallExpList() FunctionCallExpressionList() )?
0257:             * f7 -> "{"
0258:             * f8 -> Program(true)
0259:             * f9 -> "}"
0260:             * </PRE>
0261:             */
0262:            public Object visit(FunctionDeclaration n, Object argu) {
0263:                Value val = get(FunctionDeclaration.class);
0264:                if (val != null)
0265:                    return val.callAsFunction(new Value[] {
0266:                            JavaBridge.convertToScriptObject(n),
0267:                            JavaBridge.convertToScriptObject(argu) });
0268:                return super .visit(n, argu);
0269:            }
0270:
0271:            /**
0272:             *   <PRE>
0273:             * f0 -> Permissions(false)
0274:             * f1 -> &lt;IDENTIFIER&gt;
0275:             * f2 -> ( "," Permissions(false) &lt;IDENTIFIER&gt; )*
0276:             * f3 -> ( "..." )?
0277:             * </PRE>
0278:             */
0279:            public Object visit(Arglist n, Object argu) {
0280:                Value val = get(Arglist.class);
0281:                if (val != null)
0282:                    return val.callAsFunction(new Value[] {
0283:                            JavaBridge.convertToScriptObject(n),
0284:                            JavaBridge.convertToScriptObject(argu) });
0285:                return super .visit(n, argu);
0286:            }
0287:
0288:            /**
0289:             *   <PRE>
0290:             * f0 -> "try"
0291:             * f1 -> EvaluationUnit()
0292:             * f2 -> ( "catch" "(" Expression() &lt;IDENTIFIER&gt; ")" EvaluationUnit() )*
0293:             * f3 -> ( "catch" "(" &lt;IDENTIFIER&gt; ")" EvaluationUnit() )?
0294:             * f4 -> ( "finally" EvaluationUnit() )?
0295:             * </PRE>
0296:             */
0297:            public Object visit(TryStatement n, Object argu) {
0298:                Value val = get(TryStatement.class);
0299:                if (val != null)
0300:                    return val.callAsFunction(new Value[] {
0301:                            JavaBridge.convertToScriptObject(n),
0302:                            JavaBridge.convertToScriptObject(argu) });
0303:                return super .visit(n, argu);
0304:            }
0305:
0306:            /**
0307:             *   <PRE>
0308:
0309:             * f0 -> "for"
0310:             * f1 -> "("
0311:             * f2 -> (  PreLoopStatement() )?
0312:             * f3 -> ";"
0313:             * f4 -> ( Expression() )?
0314:             * f5 -> ";"
0315:             * f6 -> ( Expression() )?
0316:             * f7 -> ")"
0317:             * f8 -> EvaluationUnit()
0318:             * </PRE>
0319:             */
0320:            public Object visit(ForLoopStatement n, Object argu) {
0321:                Value val = get(ForLoopStatement.class);
0322:                if (val != null)
0323:                    return val.callAsFunction(new Value[] {
0324:                            JavaBridge.convertToScriptObject(n),
0325:                            JavaBridge.convertToScriptObject(argu) });
0326:                return super .visit(n, argu);
0327:            }
0328:
0329:            /**
0330:             *   <PRE>
0331:
0332:             * f0 -> "for"
0333:             * f1 -> "("
0334:             * f2 -> PreLoopStatement()
0335:             * f3 -> ":"
0336:             * f4 -> Expression()
0337:             * f5 -> ")"
0338:             * f6 -> EvaluationUnit()
0339:             * </PRE>
0340:             */
0341:            public Object visit(CollectionForLoopStatement n, Object argu) {
0342:                Value val = get(CollectionForLoopStatement.class);
0343:                if (val != null)
0344:                    return val.callAsFunction(new Value[] {
0345:                            JavaBridge.convertToScriptObject(n),
0346:                            JavaBridge.convertToScriptObject(argu) });
0347:                return super .visit(n, argu);
0348:            }
0349:
0350:            /**
0351:             *   <PRE>
0352:             * f0 -> VariableDeclaration()
0353:             *       | Expression()
0354:             * </PRE>
0355:             */
0356:            public Object visit(PreLoopStatement n, Object argu) {
0357:                Value val = get(PreLoopStatement.class);
0358:                if (val != null)
0359:                    return val.callAsFunction(new Value[] {
0360:                            JavaBridge.convertToScriptObject(n),
0361:                            JavaBridge.convertToScriptObject(argu) });
0362:                return super .visit(n, argu);
0363:            }
0364:
0365:            /**
0366:             *   <PRE>
0367:             * f0 -> "while"
0368:             * f1 -> "("
0369:             * f2 -> Expression()
0370:             * f3 -> ")"
0371:             * f4 -> EvaluationUnit()
0372:             * </PRE>
0373:             */
0374:            public Object visit(WhileLoopStatement n, Object argu) {
0375:                Value val = get(WhileLoopStatement.class);
0376:                if (val != null)
0377:                    return val.callAsFunction(new Value[] {
0378:                            JavaBridge.convertToScriptObject(n),
0379:                            JavaBridge.convertToScriptObject(argu) });
0380:                return super .visit(n, argu);
0381:            }
0382:
0383:            /**
0384:             *   <PRE>
0385:             * f0 -> "if"
0386:             * f1 -> "("
0387:             * f2 -> Expression()
0388:             * f3 -> ")"
0389:             * f4 -> EvaluationUnit()
0390:             * f5 -> ( "else" EvaluationUnit() )?
0391:             * </PRE>
0392:             */
0393:            public Object visit(ConditionalStatement n, Object argu) {
0394:                Value val = get(ConditionalStatement.class);
0395:                if (val != null)
0396:                    return val.callAsFunction(new Value[] {
0397:                            JavaBridge.convertToScriptObject(n),
0398:                            JavaBridge.convertToScriptObject(argu) });
0399:                return super .visit(n, argu);
0400:            }
0401:
0402:            /**
0403:             *   <PRE>
0404:             * f0 -> "synchronized"
0405:             * f1 -> "("
0406:             * f2 -> Expression()
0407:             * f3 -> ")"
0408:             * f4 -> EvaluationUnit()
0409:             * </PRE>
0410:             */
0411:            public Object visit(SynchronizedStatement n, Object argu) {
0412:                Value val = get(SynchronizedStatement.class);
0413:                if (val != null)
0414:                    return val.callAsFunction(new Value[] {
0415:                            JavaBridge.convertToScriptObject(n),
0416:                            JavaBridge.convertToScriptObject(argu) });
0417:                return super .visit(n, argu);
0418:            }
0419:
0420:            /**
0421:             *   <PRE>
0422:             * f0 -> "return"
0423:             * f1 -> ( Expression() )?
0424:             * f2 -> ";"
0425:             * </PRE>
0426:             */
0427:            public Object visit(ReturnStatement n, Object argu) {
0428:                Value val = get(ReturnStatement.class);
0429:                if (val != null)
0430:                    return val.callAsFunction(new Value[] {
0431:                            JavaBridge.convertToScriptObject(n),
0432:                            JavaBridge.convertToScriptObject(argu) });
0433:                return super .visit(n, argu);
0434:            }
0435:
0436:            /**
0437:             *   <PRE>
0438:             * f0 -> "break"
0439:             * f1 -> ";"
0440:             * </PRE>
0441:             */
0442:            public Object visit(BreakStatement n, Object argu) {
0443:                Value val = get(BreakStatement.class);
0444:                if (val != null)
0445:                    return val.callAsFunction(new Value[] {
0446:                            JavaBridge.convertToScriptObject(n),
0447:                            JavaBridge.convertToScriptObject(argu) });
0448:                return super .visit(n, argu);
0449:            }
0450:
0451:            /**
0452:             *   <PRE>
0453:             * f0 -> "continue"
0454:             * f1 -> ";"
0455:             * </PRE>
0456:             */
0457:            public Object visit(ContinueStatement n, Object argu) {
0458:                Value val = get(ContinueStatement.class);
0459:                if (val != null)
0460:                    return val.callAsFunction(new Value[] {
0461:                            JavaBridge.convertToScriptObject(n),
0462:                            JavaBridge.convertToScriptObject(argu) });
0463:                return super .visit(n, argu);
0464:            }
0465:
0466:            /**
0467:             *   <PRE>
0468:             * f0 -> AssignmentExpression()
0469:             * f1 -> ( "," AssignmentExpression() )*
0470:             * </PRE>
0471:             */
0472:            public Object visit(Expression n, Object argu) {
0473:                Value val = get(Expression.class);
0474:                if (val != null)
0475:                    return val.callAsFunction(new Value[] {
0476:                            JavaBridge.convertToScriptObject(n),
0477:                            JavaBridge.convertToScriptObject(argu) });
0478:                return super .visit(n, argu);
0479:            }
0480:
0481:            /**
0482:             *   <PRE>
0483:             * f0 -> "("
0484:             * f1 -> ( FunctionCallExpressionListBody() )?
0485:             * f2 -> ")"
0486:             * </PRE>
0487:             */
0488:            public Object visit(FunctionCallExpressionList n, Object argu) {
0489:                Value val = get(FunctionCallExpressionList.class);
0490:                if (val != null)
0491:                    return val.callAsFunction(new Value[] {
0492:                            JavaBridge.convertToScriptObject(n),
0493:                            JavaBridge.convertToScriptObject(argu) });
0494:                return super .visit(n, argu);
0495:            }
0496:
0497:            /**
0498:             *   <PRE>
0499:             * f0 -> AssignmentExpression()
0500:             * f1 -> ( "," AssignmentExpression() )*
0501:             * </PRE>
0502:             */
0503:            public Object visit(FunctionCallExpressionListBody n, Object argu) {
0504:                Value val = get(FunctionCallExpressionListBody.class);
0505:                if (val != null)
0506:                    return val.callAsFunction(new Value[] {
0507:                            JavaBridge.convertToScriptObject(n),
0508:                            JavaBridge.convertToScriptObject(argu) });
0509:                return super .visit(n, argu);
0510:            }
0511:
0512:            /**
0513:             *   <PRE>
0514:             * f0 -> ConditionalExpression()
0515:             * f1 -> ( ( "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "&gt;&gt;=" | "&lt;&lt;=" | "&gt;&gt;&gt;=" | "&=" | "^=" | "|=" ) ConditionalExpression() )*
0516:             * </PRE>
0517:             */
0518:            public Object visit(AssignmentExpression n, Object argu) {
0519:                Value val = get(AssignmentExpression.class);
0520:                if (val != null)
0521:                    return val.callAsFunction(new Value[] {
0522:                            JavaBridge.convertToScriptObject(n),
0523:                            JavaBridge.convertToScriptObject(argu) });
0524:                return super .visit(n, argu);
0525:            }
0526:
0527:            /**
0528:             *   <PRE>
0529:             * f0 -> LogicalOrExpression()
0530:             * f1 -> ( "?" LogicalOrExpression() ":" LogicalOrExpression() )?
0531:             * </PRE>
0532:             */
0533:            public Object visit(ConditionalExpression n, Object argu) {
0534:                Value val = get(ConditionalExpression.class);
0535:                if (val != null)
0536:                    return val.callAsFunction(new Value[] {
0537:                            JavaBridge.convertToScriptObject(n),
0538:                            JavaBridge.convertToScriptObject(argu) });
0539:                return super .visit(n, argu);
0540:            }
0541:
0542:            /**
0543:             *   <PRE>
0544:             * f0 -> LogicalAndExpression()
0545:             * f1 -> ( "||" LogicalAndExpression() )*
0546:             * </PRE>
0547:             */
0548:            public Object visit(LogicalOrExpression n, Object argu) {
0549:                Value val = get(LogicalOrExpression.class);
0550:                if (val != null)
0551:                    return val.callAsFunction(new Value[] {
0552:                            JavaBridge.convertToScriptObject(n),
0553:                            JavaBridge.convertToScriptObject(argu) });
0554:                return super .visit(n, argu);
0555:            }
0556:
0557:            /**
0558:             *   <PRE>
0559:             * f0 -> BitwiseOrExpression()
0560:             * f1 -> ( "&&" BitwiseOrExpression() )*
0561:             * </PRE>
0562:             */
0563:            public Object visit(LogicalAndExpression n, Object argu) {
0564:                Value val = get(LogicalAndExpression.class);
0565:                if (val != null)
0566:                    return val.callAsFunction(new Value[] {
0567:                            JavaBridge.convertToScriptObject(n),
0568:                            JavaBridge.convertToScriptObject(argu) });
0569:                return super .visit(n, argu);
0570:            }
0571:
0572:            /**
0573:             *   <PRE>
0574:             * f0 -> BitwiseXorExpression()
0575:             * f1 -> ( "|" BitwiseXorExpression() )*
0576:             * </PRE>
0577:             */
0578:            public Object visit(BitwiseOrExpression n, Object argu) {
0579:                Value val = get(BitwiseOrExpression.class);
0580:                if (val != null)
0581:                    return val.callAsFunction(new Value[] {
0582:                            JavaBridge.convertToScriptObject(n),
0583:                            JavaBridge.convertToScriptObject(argu) });
0584:                return super .visit(n, argu);
0585:            }
0586:
0587:            /**
0588:             *   <PRE>
0589:             * f0 -> BitwiseAndExpression()
0590:             * f1 -> ( "^" BitwiseAndExpression() )*
0591:             * </PRE>
0592:             */
0593:            public Object visit(BitwiseXorExpression n, Object argu) {
0594:                Value val = get(BitwiseXorExpression.class);
0595:                if (val != null)
0596:                    return val.callAsFunction(new Value[] {
0597:                            JavaBridge.convertToScriptObject(n),
0598:                            JavaBridge.convertToScriptObject(argu) });
0599:                return super .visit(n, argu);
0600:            }
0601:
0602:            /**
0603:             *   <PRE>
0604:             * f0 -> EqualityExpression()
0605:             * f1 -> ( "&" EqualityExpression() )*
0606:             * </PRE>
0607:             */
0608:            public Object visit(BitwiseAndExpression n, Object argu) {
0609:                Value val = get(BitwiseAndExpression.class);
0610:                if (val != null)
0611:                    return val.callAsFunction(new Value[] {
0612:                            JavaBridge.convertToScriptObject(n),
0613:                            JavaBridge.convertToScriptObject(argu) });
0614:                return super .visit(n, argu);
0615:            }
0616:
0617:            /**
0618:             *   <PRE>
0619:             * f0 -> RelationalExpression()
0620:             * f1 -> ( ( "==" | "!=" ) RelationalExpression() )*
0621:             * </PRE>
0622:             */
0623:            public Object visit(EqualityExpression n, Object argu) {
0624:                Value val = get(EqualityExpression.class);
0625:                if (val != null)
0626:                    return val.callAsFunction(new Value[] {
0627:                            JavaBridge.convertToScriptObject(n),
0628:                            JavaBridge.convertToScriptObject(argu) });
0629:                return super .visit(n, argu);
0630:            }
0631:
0632:            /**
0633:             *   <PRE>
0634:             * f0 -> ShiftExpression()
0635:             * f1 -> ( ( "&lt;" | "&gt;" | "&gt;=" | "&lt;=" | "instanceof" ) ShiftExpression() )*
0636:             * </PRE>
0637:             */
0638:            public Object visit(RelationalExpression n, Object argu) {
0639:                Value val = get(RelationalExpression.class);
0640:                if (val != null)
0641:                    return val.callAsFunction(new Value[] {
0642:                            JavaBridge.convertToScriptObject(n),
0643:                            JavaBridge.convertToScriptObject(argu) });
0644:                return super .visit(n, argu);
0645:            }
0646:
0647:            /**
0648:             *   <PRE>
0649:             * f0 -> AdditiveExpression()
0650:             * f1 -> ( ( "&lt;&lt;" | "&gt;&gt;" | "&gt;&gt;&gt;" ) AdditiveExpression() )*
0651:             * </PRE>
0652:             */
0653:            public Object visit(ShiftExpression n, Object argu) {
0654:                Value val = get(ShiftExpression.class);
0655:                if (val != null)
0656:                    return val.callAsFunction(new Value[] {
0657:                            JavaBridge.convertToScriptObject(n),
0658:                            JavaBridge.convertToScriptObject(argu) });
0659:                return super .visit(n, argu);
0660:            }
0661:
0662:            /**
0663:             *   <PRE>
0664:             * f0 -> MultiplicativeExpression()
0665:             * f1 -> ( ( "+" | "-" ) MultiplicativeExpression() )*
0666:             * </PRE>
0667:             */
0668:            public Object visit(AdditiveExpression n, Object argu) {
0669:                Value val = get(AdditiveExpression.class);
0670:                if (val != null)
0671:                    return val.callAsFunction(new Value[] {
0672:                            JavaBridge.convertToScriptObject(n),
0673:                            JavaBridge.convertToScriptObject(argu) });
0674:                return super .visit(n, argu);
0675:            }
0676:
0677:            /**
0678:             *   <PRE>
0679:             * f0 -> UnaryExpression()
0680:             * f1 -> ( ( "*" | "/" | "%" ) UnaryExpression() )*
0681:             * </PRE>
0682:             */
0683:            public Object visit(MultiplicativeExpression n, Object argu) {
0684:                Value val = get(MultiplicativeExpression.class);
0685:                if (val != null)
0686:                    return val.callAsFunction(new Value[] {
0687:                            JavaBridge.convertToScriptObject(n),
0688:                            JavaBridge.convertToScriptObject(argu) });
0689:                return super .visit(n, argu);
0690:            }
0691:
0692:            /**
0693:             *   <PRE>
0694:             * f0 -> ( ( "++" | "--" | "+" | "-" | "~" | "!" ) )?
0695:             * f1 -> PostfixExpression()
0696:             * </PRE>
0697:             */
0698:            public Object visit(UnaryExpression n, Object argu) {
0699:                Value val = get(UnaryExpression.class);
0700:                if (val != null)
0701:                    return val.callAsFunction(new Value[] {
0702:                            JavaBridge.convertToScriptObject(n),
0703:                            JavaBridge.convertToScriptObject(argu) });
0704:                return super .visit(n, argu);
0705:            }
0706:
0707:            /**
0708:             *   <PRE>
0709:             * f0 -> TypeExpression()
0710:             * f1 -> ( "++" | "--" )?
0711:             * </PRE>
0712:             */
0713:            public Object visit(PostfixExpression n, Object argu) {
0714:                Value val = get(PostfixExpression.class);
0715:                if (val != null)
0716:                    return val.callAsFunction(new Value[] {
0717:                            JavaBridge.convertToScriptObject(n),
0718:                            JavaBridge.convertToScriptObject(argu) });
0719:                return super .visit(n, argu);
0720:            }
0721:
0722:            /**
0723:             *   <PRE>
0724:             * f0 -> AllocationExpression()
0725:             *       | CastExpression()
0726:             *       | PrimaryExpression()
0727:             * </PRE>
0728:             */
0729:            public Object visit(TypeExpression n, Object argu) {
0730:                Value val = get(TypeExpression.class);
0731:                if (val != null)
0732:                    return val.callAsFunction(new Value[] {
0733:                            JavaBridge.convertToScriptObject(n),
0734:                            JavaBridge.convertToScriptObject(argu) });
0735:                return super .visit(n, argu);
0736:            }
0737:
0738:            /**
0739:             *   <PRE>
0740:             * f0 -> "new"
0741:             * f1 -> PrimaryExpressionWithTrailingFxnCallExpList()
0742:             * f2 -> FunctionCallExpressionList()
0743:             * </PRE>
0744:             */
0745:            public Object visit(AllocationExpression n, Object argu) {
0746:                Value val = get(AllocationExpression.class);
0747:                if (val != null)
0748:                    return val.callAsFunction(new Value[] {
0749:                            JavaBridge.convertToScriptObject(n),
0750:                            JavaBridge.convertToScriptObject(argu) });
0751:                return super .visit(n, argu);
0752:            }
0753:
0754:            /**
0755:             *   <PRE>
0756:             * f0 -> "("
0757:             * f1 -> PrimaryExpressionNotFunction()
0758:             * f2 -> ")"
0759:             * f3 -> PrimaryExpression()
0760:             * </PRE>
0761:             */
0762:            public Object visit(CastExpression n, Object argu) {
0763:                Value val = get(CastExpression.class);
0764:                if (val != null)
0765:                    return val.callAsFunction(new Value[] {
0766:                            JavaBridge.convertToScriptObject(n),
0767:                            JavaBridge.convertToScriptObject(argu) });
0768:                return super .visit(n, argu);
0769:            }
0770:
0771:            /**
0772:             *   <PRE>
0773:             * f0 -> PrimaryPrefix()
0774:             * f1 -> ( PrimaryPostfix() )*
0775:             * </PRE>
0776:             */
0777:            public Object visit(PrimaryExpression n, Object argu) {
0778:                Value val = get(PrimaryExpression.class);
0779:                if (val != null)
0780:                    return val.callAsFunction(new Value[] {
0781:                            JavaBridge.convertToScriptObject(n),
0782:                            JavaBridge.convertToScriptObject(argu) });
0783:                return super .visit(n, argu);
0784:            }
0785:
0786:            /**
0787:             *   <PRE>
0788:             * f0 -> PrimaryPrefixNotFunction()
0789:             * f1 -> ( PrimaryPostfix() )*
0790:             * </PRE>
0791:             */
0792:            public Object visit(PrimaryExpressionNotFunction n, Object argu) {
0793:                Value val = get(PrimaryExpressionNotFunction.class);
0794:                if (val != null)
0795:                    return val.callAsFunction(new Value[] {
0796:                            JavaBridge.convertToScriptObject(n),
0797:                            JavaBridge.convertToScriptObject(argu) });
0798:                return super .visit(n, argu);
0799:            }
0800:
0801:            /**
0802:             *   <PRE>
0803:             * f0 -> PrimaryPrefix()
0804:             * f1 -> ( PrimaryPostfixWithTrailingFxnCallExpList() )*
0805:             * </PRE>
0806:             */
0807:            public Object visit(PrimaryExpressionWithTrailingFxnCallExpList n,
0808:                    Object argu) {
0809:                Value val = get(PrimaryExpressionWithTrailingFxnCallExpList.class);
0810:                if (val != null)
0811:                    return val.callAsFunction(new Value[] {
0812:                            JavaBridge.convertToScriptObject(n),
0813:                            JavaBridge.convertToScriptObject(argu) });
0814:                return super .visit(n, argu);
0815:            }
0816:
0817:            /**
0818:             *   <PRE>
0819:             * f0 -> PrimaryPrefixNotFunction()
0820:             *       | FunctionPrimaryPrefix()
0821:             *       | ShorthandFunctionPrimaryPrefix()
0822:             * </PRE>
0823:             */
0824:            public Object visit(PrimaryPrefix n, Object argu) {
0825:                Value val = get(PrimaryPrefix.class);
0826:                if (val != null)
0827:                    return val.callAsFunction(new Value[] {
0828:                            JavaBridge.convertToScriptObject(n),
0829:                            JavaBridge.convertToScriptObject(argu) });
0830:                return super .visit(n, argu);
0831:            }
0832:
0833:            /**
0834:             *   <PRE>
0835:             * f0 -> ThisPrimaryPrefix()
0836:             *       | SuperPrimaryPrefix()
0837:             *       | CalleePrimaryPrefix()
0838:             *       | ArrayDeclarationPrimaryPrefix()
0839:             *       | IdentifierPrimaryPrefix()
0840:             *       | ParenPrimaryPrefix()
0841:             *       | Literal()
0842:             * </PRE>
0843:             */
0844:            public Object visit(PrimaryPrefixNotFunction n, Object argu) {
0845:                Value val = get(PrimaryPrefixNotFunction.class);
0846:                if (val != null)
0847:                    return val.callAsFunction(new Value[] {
0848:                            JavaBridge.convertToScriptObject(n),
0849:                            JavaBridge.convertToScriptObject(argu) });
0850:                return super .visit(n, argu);
0851:            }
0852:
0853:            /**
0854:             *   <PRE>
0855:             * f0 -> "this"
0856:             * </PRE>
0857:             */
0858:            public Object visit(ThisPrimaryPrefix n, Object argu) {
0859:                Value val = get(ThisPrimaryPrefix.class);
0860:                if (val != null)
0861:                    return val.callAsFunction(new Value[] {
0862:                            JavaBridge.convertToScriptObject(n),
0863:                            JavaBridge.convertToScriptObject(argu) });
0864:                return super .visit(n, argu);
0865:            }
0866:
0867:            /**
0868:             *   <PRE>
0869:             * f0 -> "super"
0870:             * </PRE>
0871:             */
0872:            public Object visit(SuperPrimaryPrefix n, Object argu) {
0873:                Value val = get(SuperPrimaryPrefix.class);
0874:                if (val != null)
0875:                    return val.callAsFunction(new Value[] {
0876:                            JavaBridge.convertToScriptObject(n),
0877:                            JavaBridge.convertToScriptObject(argu) });
0878:                return super .visit(n, argu);
0879:            }
0880:
0881:            /**
0882:             *   <PRE>
0883:
0884:             * f0 -> "callee"
0885:             * </PRE>
0886:             */
0887:            public Object visit(CalleePrimaryPrefix n, Object argu) {
0888:                Value val = get(CalleePrimaryPrefix.class);
0889:                if (val != null)
0890:                    return val.callAsFunction(new Value[] {
0891:                            JavaBridge.convertToScriptObject(n),
0892:                            JavaBridge.convertToScriptObject(argu) });
0893:                return super .visit(n, argu);
0894:            }
0895:
0896:            /**
0897:             *   <PRE>
0898:             * f0 -> &lt;IDENTIFIER&gt;
0899:             * </PRE>
0900:             */
0901:            public Object visit(IdentifierPrimaryPrefix n, Object argu) {
0902:                Value val = get(IdentifierPrimaryPrefix.class);
0903:                if (val != null)
0904:                    return val.callAsFunction(new Value[] {
0905:                            JavaBridge.convertToScriptObject(n),
0906:                            JavaBridge.convertToScriptObject(argu) });
0907:                return super .visit(n, argu);
0908:            }
0909:
0910:            /**
0911:             *   <PRE>
0912:             * f0 -> "("
0913:             * f1 -> Expression()
0914:             * f2 -> ")"
0915:             * </PRE>
0916:             */
0917:            public Object visit(ParenPrimaryPrefix n, Object argu) {
0918:                Value val = get(ParenPrimaryPrefix.class);
0919:                if (val != null)
0920:                    return val.callAsFunction(new Value[] {
0921:                            JavaBridge.convertToScriptObject(n),
0922:                            JavaBridge.convertToScriptObject(argu) });
0923:                return super .visit(n, argu);
0924:            }
0925:
0926:            /**
0927:             *   <PRE>
0928:
0929:             * f0 -> "function"
0930:             * f1 -> "("
0931:             * f2 -> ( Arglist() )?
0932:             * f3 -> ")"
0933:             * f4 -> ( "extends" PrimaryExpressionWithTrailingFxnCallExpList() FunctionCallExpressionList() )?
0934:             * f5 -> "{"
0935:             * f6 -> Program(true)
0936:             * f7 -> "}"
0937:             * </PRE>
0938:             */
0939:            public Object visit(FunctionPrimaryPrefix n, Object argu) {
0940:                Value val = get(FunctionPrimaryPrefix.class);
0941:                if (val != null)
0942:                    return val.callAsFunction(new Value[] {
0943:                            JavaBridge.convertToScriptObject(n),
0944:                            JavaBridge.convertToScriptObject(argu) });
0945:                return super .visit(n, argu);
0946:            }
0947:
0948:            /**
0949:             *   <PRE>
0950:             * f0 -> "'{"
0951:             * f1 -> Program(true)
0952:             * f2 -> "}"
0953:             * </PRE>
0954:             */
0955:            public Object visit(ShorthandFunctionPrimaryPrefix n, Object argu) {
0956:                Value val = get(ShorthandFunctionPrimaryPrefix.class);
0957:                if (val != null)
0958:                    return val.callAsFunction(new Value[] {
0959:                            JavaBridge.convertToScriptObject(n),
0960:                            JavaBridge.convertToScriptObject(argu) });
0961:                return super .visit(n, argu);
0962:            }
0963:
0964:            /**
0965:             *   <PRE>
0966:             * f0 -> "["
0967:             * f1 -> ( FunctionCallExpressionListBody() )?
0968:             * f2 -> "]"
0969:             * </PRE>
0970:             */
0971:            public Object visit(ArrayDeclarationPrimaryPrefix n, Object argu) {
0972:                Value val = get(ArrayDeclarationPrimaryPrefix.class);
0973:                if (val != null)
0974:                    return val.callAsFunction(new Value[] {
0975:                            JavaBridge.convertToScriptObject(n),
0976:                            JavaBridge.convertToScriptObject(argu) });
0977:                return super .visit(n, argu);
0978:            }
0979:
0980:            /**
0981:             *   <PRE>
0982:             * f0 -> FunctionCallPrimaryPostfix()
0983:             *       | ArraySubscriptPrimaryPostfix()
0984:             *       | ThisScopeQualifierPrimaryPostfix()
0985:             *       | PropertyIdentifierPrimaryPostfix()
0986:             * </PRE>
0987:             */
0988:            public Object visit(PrimaryPostfix n, Object argu) {
0989:                Value val = get(PrimaryPostfix.class);
0990:                if (val != null)
0991:                    return val.callAsFunction(new Value[] {
0992:                            JavaBridge.convertToScriptObject(n),
0993:                            JavaBridge.convertToScriptObject(argu) });
0994:                return super .visit(n, argu);
0995:            }
0996:
0997:            /**
0998:             *   <PRE>
0999:             * f0 -> ArraySubscriptPrimaryPostfix()
1000:             *       | ThisScopeQualifierPrimaryPostfix()
1001:             *       | PropertyIdentifierPrimaryPostfix()
1002:             * </PRE>
1003:             */
1004:            public Object visit(PrimaryPostfixWithTrailingFxnCallExpList n,
1005:                    Object argu) {
1006:                Value val = get(PrimaryPostfixWithTrailingFxnCallExpList.class);
1007:                if (val != null)
1008:                    return val.callAsFunction(new Value[] {
1009:                            JavaBridge.convertToScriptObject(n),
1010:                            JavaBridge.convertToScriptObject(argu) });
1011:                return super .visit(n, argu);
1012:            }
1013:
1014:            /**
1015:             *   <PRE>
1016:             * f0 -> FunctionCallExpressionList()
1017:             * </PRE>
1018:             */
1019:            public Object visit(FunctionCallPrimaryPostfix n, Object argu) {
1020:                Value val = get(FunctionCallPrimaryPostfix.class);
1021:                if (val != null)
1022:                    return val.callAsFunction(new Value[] {
1023:                            JavaBridge.convertToScriptObject(n),
1024:                            JavaBridge.convertToScriptObject(argu) });
1025:                return super .visit(n, argu);
1026:            }
1027:
1028:            /**
1029:             *   <PRE>
1030:             * f0 -> "["
1031:             * f1 -> Expression()
1032:             * f2 -> ( ".." Expression() )?
1033:             * f3 -> "]"
1034:             * </PRE>
1035:             */
1036:            public Object visit(ArraySubscriptPrimaryPostfix n, Object argu) {
1037:                Value val = get(ArraySubscriptPrimaryPostfix.class);
1038:                if (val != null)
1039:                    return val.callAsFunction(new Value[] {
1040:                            JavaBridge.convertToScriptObject(n),
1041:                            JavaBridge.convertToScriptObject(argu) });
1042:                return super .visit(n, argu);
1043:            }
1044:
1045:            /**
1046:             *   <PRE>
1047:             * f0 -> "."
1048:             * f1 -> &lt;IDENTIFIER&gt;
1049:             * </PRE>
1050:             */
1051:            public Object visit(PropertyIdentifierPrimaryPostfix n, Object argu) {
1052:                Value val = get(PropertyIdentifierPrimaryPostfix.class);
1053:                if (val != null)
1054:                    return val.callAsFunction(new Value[] {
1055:                            JavaBridge.convertToScriptObject(n),
1056:                            JavaBridge.convertToScriptObject(argu) });
1057:                return super .visit(n, argu);
1058:            }
1059:
1060:            /**
1061:             *   <PRE>
1062:             * f0 -> "."
1063:             * f1 -> "this"
1064:             * </PRE>
1065:             */
1066:            public Object visit(ThisScopeQualifierPrimaryPostfix n, Object argu) {
1067:                Value val = get(ThisScopeQualifierPrimaryPostfix.class);
1068:                if (val != null)
1069:                    return val.callAsFunction(new Value[] {
1070:                            JavaBridge.convertToScriptObject(n),
1071:                            JavaBridge.convertToScriptObject(argu) });
1072:                return super .visit(n, argu);
1073:            }
1074:
1075:            /**
1076:             *   <PRE>
1077:             * f0 -> &lt;INTEGER_LITERAL&gt;
1078:             *       | &lt;FLOATING_POINT_LITERAL&gt;
1079:             *       | &lt;STRING_LITERAL&gt;
1080:             *       | &lt;REGEXP_LITERAL&gt;
1081:             *       | "true"
1082:             *       | "false"
1083:             *       | "null"
1084:             *       | "undefined"
1085:             * </PRE>
1086:             */
1087:            public Object visit(Literal n, Object argu) {
1088:                Value val = get(Literal.class);
1089:                if (val != null)
1090:                    return val.callAsFunction(new Value[] {
1091:                            JavaBridge.convertToScriptObject(n),
1092:                            JavaBridge.convertToScriptObject(argu) });
1093:                return super .visit(n, argu);
1094:            }
1095:
1096:            /**
1097:             *   <PRE>
1098:
1099:             * f0 -> ( "static" | "const" | "private" | "protected" | "public" )*
1100:             * </PRE>
1101:             */
1102:            public Object visit(Permissions n, Object argu) {
1103:                Value val = get(Permissions.class);
1104:                if (val != null)
1105:                    return val.callAsFunction(new Value[] {
1106:                            JavaBridge.convertToScriptObject(n),
1107:                            JavaBridge.convertToScriptObject(argu) });
1108:                return super.visit(n, argu);
1109:            }
1110:
1111:        }