ReversedDepthFirstAdapter.java Source File

00001 package edu.ksu.cis.bandera.abstraction.specification.analysis;
00002 
00003 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
00004  * Bandera, a Java(TM) analysis and transformation toolkit           *
00005  * Copyright (C) 1998-2001 SAnToS Laboratories (santos@cis.ksu.edu)  *
00006 
00007  * All rights reserved.                                              *
00008  *                                                                   *
00009  * This work was done as a project in the SAnToS Laboratory,         *
00010  * Department of Computing and Information Sciences, Kansas State    *
00011  * University, USA (http://www.cis.ksu.edu/santos).                  *
00012  * It is understood that any modification not identified as such is  *
00013  * not covered by the preceding statement.                           *
00014  *                                                                   *
00015  * This work is free software; you can redistribute it and/or        *
00016  * modify it under the terms of the GNU Library General Public       *
00017  * License as published by the Free Software Foundation; either      *
00018  * version 2 of the License, or (at your option) any later version.  *
00019  *                                                                   *
00020  * This work is distributed in the hope that it will be useful,      *
00021  * but WITHOUT ANY WARRANTY; without even the implied warranty of    *
00022  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU *
00023  * Library General Public License for more details.                  *
00024  *                                                                   *
00025  * You should have received a copy of the GNU Library General Public *
00026  * License along with this toolkit; if not, write to the             *
00027  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,      *
00028  * Boston, MA  02111-1307, USA.                                      *
00029  *                                                                   *
00030  * Java is a trademark of Sun Microsystems, Inc.                     *
00031  *                                                                   *
00032  * To submit a bug report, send a comment, or get the latest news on *
00033  * this project and other SAnToS projects, please visit the web-site *
00034  *                http://www.cis.ksu.edu/santos                      *
00035  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
00036 /* This file was generated by SableCC (http://www.sable.mcgill.ca/sablecc/). */
00037 
00038 import edu.ksu.cis.bandera.abstraction.specification.node.*;
00039 
00040 public class ReversedDepthFirstAdapter extends AnalysisAdapter
00041 {
00042     public void caseAAbstractFunction(AAbstractFunction node)
00043     {
00044         inAAbstractFunction(node);
00045         if(node.getEnd() != null)
00046         {
00047             node.getEnd().apply(this);
00048         }
00049         {
00050             Object temp[] = node.getAbstractDef().toArray();
00051             for(int i = temp.length - 1; i >= 0; i--)
00052             {
00053                 ((PAbstractDef) temp[i]).apply(this);
00054             }
00055         }
00056         if(node.getBegin() != null)
00057         {
00058             node.getBegin().apply(this);
00059         }
00060         if(node.getRParen() != null)
00061         {
00062             node.getRParen().apply(this);
00063         }
00064         if(node.getId() != null)
00065         {
00066             node.getId().apply(this);
00067         }
00068         if(node.getLParen() != null)
00069         {
00070             node.getLParen().apply(this);
00071         }
00072         if(node.getAbstract() != null)
00073         {
00074             node.getAbstract().apply(this);
00075         }
00076         outAAbstractFunction(node);
00077     }
00078     public void caseAAddExpShiftExp(AAddExpShiftExp node)
00079     {
00080         inAAddExpShiftExp(node);
00081         if(node.getAddExp() != null)
00082         {
00083             node.getAddExp().apply(this);
00084         }
00085         outAAddExpShiftExp(node);
00086     }
00087     public void caseAAndAndExp(AAndAndExp node)
00088     {
00089         inAAndAndExp(node);
00090         if(node.getInclusiveOrExp() != null)
00091         {
00092             node.getInclusiveOrExp().apply(this);
00093         }
00094         if(node.getAnd() != null)
00095         {
00096             node.getAnd().apply(this);
00097         }
00098         if(node.getAndExp() != null)
00099         {
00100             node.getAndExp().apply(this);
00101         }
00102         outAAndAndExp(node);
00103     }
00104     public void caseAAndBitAndExp(AAndBitAndExp node)
00105     {
00106         inAAndBitAndExp(node);
00107         if(node.getEqExp() != null)
00108         {
00109             node.getEqExp().apply(this);
00110         }
00111         if(node.getBitAnd() != null)
00112         {
00113             node.getBitAnd().apply(this);
00114         }
00115         if(node.getBitAndExp() != null)
00116         {
00117             node.getBitAndExp().apply(this);
00118         }
00119         outAAndBitAndExp(node);
00120     }
00121     public void caseAAndExclusiveOrExp(AAndExclusiveOrExp node)
00122     {
00123         inAAndExclusiveOrExp(node);
00124         if(node.getBitAndExp() != null)
00125         {
00126             node.getBitAndExp().apply(this);
00127         }
00128         outAAndExclusiveOrExp(node);
00129     }
00130     public void caseAAndOrExp(AAndOrExp node)
00131     {
00132         inAAndOrExp(node);
00133         if(node.getAndExp() != null)
00134         {
00135             node.getAndExp().apply(this);
00136         }
00137         outAAndOrExp(node);
00138     }
00139     public void caseAAnyAbstractDef(AAnyAbstractDef node)
00140     {
00141         inAAnyAbstractDef(node);
00142         if(node.getSemicolon() != null)
00143         {
00144             node.getSemicolon().apply(this);
00145         }
00146         if(node.getId() != null)
00147         {
00148             node.getId().apply(this);
00149         }
00150         if(node.getRightarrow() != null)
00151         {
00152             node.getRightarrow().apply(this);
00153         }
00154         if(node.getAny() != null)
00155         {
00156             node.getAny().apply(this);
00157         }
00158         outAAnyAbstractDef(node);
00159     }
00160     public void caseAAnyAnyId(AAnyAnyId node)
00161     {
00162         inAAnyAnyId(node);
00163         if(node.getAny() != null)
00164         {
00165             node.getAny().apply(this);
00166         }
00167         outAAnyAnyId(node);
00168     }
00169     public void caseAAnyPattern(AAnyPattern node)
00170     {
00171         inAAnyPattern(node);
00172         if(node.getSemicolon() != null)
00173         {
00174             node.getSemicolon().apply(this);
00175         }
00176         if(node.getTokenTokenSet() != null)
00177         {
00178             node.getTokenTokenSet().apply(this);
00179         }
00180         if(node.getRightarrow() != null)
00181         {
00182             node.getRightarrow().apply(this);
00183         }
00184         if(node.getAny() != null)
00185         {
00186             node.getAny().apply(this);
00187         }
00188         outAAnyPattern(node);
00189     }
00190     public void caseABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
00191     {
00192         inABitComplementUnaryNotPlusMinusExp(node);
00193         if(node.getUnaryExp() != null)
00194         {
00195             node.getUnaryExp().apply(this);
00196         }
00197         if(node.getBitComplement() != null)
00198         {
00199             node.getBitComplement().apply(this);
00200         }
00201         outABitComplementUnaryNotPlusMinusExp(node);
00202     }
00203     public void caseAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
00204     {
00205         inAComplementUnaryNotPlusMinusExp(node);
00206         if(node.getUnaryExp() != null)
00207         {
00208             node.getUnaryExp().apply(this);
00209         }
00210         if(node.getNot() != null)
00211         {
00212             node.getNot().apply(this);
00213         }
00214         outAComplementUnaryNotPlusMinusExp(node);
00215     }
00216     public void caseADecIntLiteral(ADecIntLiteral node)
00217     {
00218         inADecIntLiteral(node);
00219         if(node.getDecIntLiteral() != null)
00220         {
00221             node.getDecIntLiteral().apply(this);
00222         }
00223         outADecIntLiteral(node);
00224     }
00225     public void caseADecLongLiteral(ADecLongLiteral node)
00226     {
00227         inADecLongLiteral(node);
00228         if(node.getDecLongLiteral() != null)
00229         {
00230             node.getDecLongLiteral().apply(this);
00231         }
00232         outADecLongLiteral(node);
00233     }
00234     public void caseADefaultToken(ADefaultToken node)
00235     {
00236         inADefaultToken(node);
00237         if(node.getSemicolon() != null)
00238         {
00239             node.getSemicolon().apply(this);
00240         }
00241         if(node.getId() != null)
00242         {
00243             node.getId().apply(this);
00244         }
00245         if(node.getEq() != null)
00246         {
00247             node.getEq().apply(this);
00248         }
00249         if(node.getDefault() != null)
00250         {
00251             node.getDefault().apply(this);
00252         }
00253         outADefaultToken(node);
00254     }
00255     public void caseADivMultExp(ADivMultExp node)
00256     {
00257         inADivMultExp(node);
00258         if(node.getUnaryExp() != null)
00259         {
00260             node.getUnaryExp().apply(this);
00261         }
00262         if(node.getDiv() != null)
00263         {
00264             node.getDiv().apply(this);
00265         }
00266         if(node.getMultExp() != null)
00267         {
00268             node.getMultExp().apply(this);
00269         }
00270         outADivMultExp(node);
00271     }
00272     public void caseADivOp(ADivOp node)
00273     {
00274         inADivOp(node);
00275         if(node.getDiv() != null)
00276         {
00277             node.getDiv().apply(this);
00278         }
00279         outADivOp(node);
00280     }
00281     public void caseADoubleLiteral(ADoubleLiteral node)
00282     {
00283         inADoubleLiteral(node);
00284         if(node.getDoubleLiteral() != null)
00285         {
00286             node.getDoubleLiteral().apply(this);
00287         }
00288         outADoubleLiteral(node);
00289     }
00290     public void caseAEqBitAndExp(AEqBitAndExp node)
00291     {
00292         inAEqBitAndExp(node);
00293         if(node.getEqExp() != null)
00294         {
00295             node.getEqExp().apply(this);
00296         }
00297         outAEqBitAndExp(node);
00298     }
00299     public void caseAEqEqExp(AEqEqExp node)
00300     {
00301         inAEqEqExp(node);
00302         if(node.getRelExp() != null)
00303         {
00304             node.getRelExp().apply(this);
00305         }
00306         if(node.getEqual() != null)
00307         {
00308             node.getEqual().apply(this);
00309         }
00310         if(node.getEqExp() != null)
00311         {
00312             node.getEqExp().apply(this);
00313         }
00314         outAEqEqExp(node);
00315     }
00316     public void caseAEqualTOp(AEqualTOp node)
00317     {
00318         inAEqualTOp(node);
00319         if(node.getEqual() != null)
00320         {
00321             node.getEqual().apply(this);
00322         }
00323         outAEqualTOp(node);
00324     }
00325     public void caseAExp(AExp node)
00326     {
00327         inAExp(node);
00328         if(node.getConditionalExp() != null)
00329         {
00330             node.getConditionalExp().apply(this);
00331         }
00332         outAExp(node);
00333     }
00334     public void caseAExpAbstractDef(AExpAbstractDef node)
00335     {
00336         inAExpAbstractDef(node);
00337         if(node.getSemicolon() != null)
00338         {
00339             node.getSemicolon().apply(this);
00340         }
00341         if(node.getId() != null)
00342         {
00343             node.getId().apply(this);
00344         }
00345         if(node.getRightarrow() != null)
00346         {
00347             node.getRightarrow().apply(this);
00348         }
00349         if(node.getExp() != null)
00350         {
00351             node.getExp().apply(this);
00352         }
00353         outAExpAbstractDef(node);
00354     }
00355     public void caseAFloatLiteral(AFloatLiteral node)
00356     {
00357         inAFloatLiteral(node);
00358         if(node.getFloatLiteral() != null)
00359         {
00360             node.getFloatLiteral().apply(this);
00361         }
00362         outAFloatLiteral(node);
00363     }
00364     public void caseAGreaterEqualRelExp(AGreaterEqualRelExp node)
00365     {
00366         inAGreaterEqualRelExp(node);
00367         if(node.getShiftExp() != null)
00368         {
00369             node.getShiftExp().apply(this);
00370         }
00371         if(node.getGreaterEqual() != null)
00372         {
00373             node.getGreaterEqual().apply(this);
00374         }
00375         if(node.getRelExp() != null)
00376         {
00377             node.getRelExp().apply(this);
00378         }
00379         outAGreaterEqualRelExp(node);
00380     }
00381     public void caseAGreaterEqualTOp(AGreaterEqualTOp node)
00382     {
00383         inAGreaterEqualTOp(node);
00384         if(node.getGreaterEqual() != null)
00385         {
00386             node.getGreaterEqual().apply(this);
00387         }
00388         outAGreaterEqualTOp(node);
00389     }
00390     public void caseAGreaterRelExp(AGreaterRelExp node)
00391     {
00392         inAGreaterRelExp(node);
00393         if(node.getShiftExp() != null)
00394         {
00395             node.getShiftExp().apply(this);
00396         }
00397         if(node.getGreater() != null)
00398         {
00399             node.getGreater().apply(this);
00400         }
00401         if(node.getRelExp() != null)
00402         {
00403             node.getRelExp().apply(this);
00404         }
00405         outAGreaterRelExp(node);
00406     }
00407     public void caseAGreaterTOp(AGreaterTOp node)
00408     {
00409         inAGreaterTOp(node);
00410         if(node.getGreater() != null)
00411         {
00412             node.getGreater().apply(this);
00413         }
00414         outAGreaterTOp(node);
00415     }
00416     public void caseAHexIntLiteral(AHexIntLiteral node)
00417     {
00418         inAHexIntLiteral(node);
00419         if(node.getHexIntLiteral() != null)
00420         {
00421             node.getHexIntLiteral().apply(this);
00422         }
00423         outAHexIntLiteral(node);
00424     }
00425     public void caseAHexLongLiteral(AHexLongLiteral node)
00426     {
00427         inAHexLongLiteral(node);
00428         if(node.getHexLongLiteral() != null)
00429         {
00430             node.getHexLongLiteral().apply(this);
00431         }
00432         outAHexLongLiteral(node);
00433     }
00434     public void caseAIdAnyId(AIdAnyId node)
00435     {
00436         inAIdAnyId(node);
00437         if(node.getId() != null)
00438         {
00439             node.getId().apply(this);
00440         }
00441         outAIdAnyId(node);
00442     }
00443     public void caseAIdIdList(AIdIdList node)
00444     {
00445         inAIdIdList(node);
00446         if(node.getId() != null)
00447         {
00448             node.getId().apply(this);
00449         }
00450         outAIdIdList(node);
00451     }
00452     public void caseAIdPrimaryExp(AIdPrimaryExp node)
00453     {
00454         inAIdPrimaryExp(node);
00455         if(node.getId() != null)
00456         {
00457             node.getId().apply(this);
00458         }
00459         outAIdPrimaryExp(node);
00460     }
00461     public void caseAIdSet(AIdSet node)
00462     {
00463         inAIdSet(node);
00464         if(node.getRBrace() != null)
00465         {
00466             node.getRBrace().apply(this);
00467         }
00468         if(node.getIdList() != null)
00469         {
00470             node.getIdList().apply(this);
00471         }
00472         if(node.getLBrace() != null)
00473         {
00474             node.getLBrace().apply(this);
00475         }
00476         outAIdSet(node);
00477     }
00478     public void caseAIdsIdList(AIdsIdList node)
00479     {
00480         inAIdsIdList(node);
00481         if(node.getId() != null)
00482         {
00483             node.getId().apply(this);
00484         }
00485         if(node.getComma() != null)
00486         {
00487             node.getComma().apply(this);
00488         }
00489         if(node.getIdList() != null)
00490         {
00491             node.getIdList().apply(this);
00492         }
00493         outAIdsIdList(node);
00494     }
00495     public void caseAInclusiveOrAndExp(AInclusiveOrAndExp node)
00496     {
00497         inAInclusiveOrAndExp(node);
00498         if(node.getInclusiveOrExp() != null)
00499         {
00500             node.getInclusiveOrExp().apply(this);
00501         }
00502         outAInclusiveOrAndExp(node);
00503     }
00504     public void caseAIntegralType(AIntegralType node)
00505     {
00506         inAIntegralType(node);
00507         if(node.getIntegral() != null)
00508         {
00509             node.getIntegral().apply(this);
00510         }
00511         outAIntegralType(node);
00512     }
00513     public void caseALeftShiftExp(ALeftShiftExp node)
00514     {
00515         inALeftShiftExp(node);
00516         if(node.getAddExp() != null)
00517         {
00518             node.getAddExp().apply(this);
00519         }
00520         if(node.getShiftLeft() != null)
00521         {
00522             node.getShiftLeft().apply(this);
00523         }
00524         if(node.getShiftExp() != null)
00525         {
00526             node.getShiftExp().apply(this);
00527         }
00528         outALeftShiftExp(node);
00529     }
00530     public void caseALessEqualRelExp(ALessEqualRelExp node)
00531     {
00532         inALessEqualRelExp(node);
00533         if(node.getShiftExp() != null)
00534         {
00535             node.getShiftExp().apply(this);
00536         }
00537         if(node.getLessEqual() != null)
00538         {
00539             node.getLessEqual().apply(this);
00540         }
00541         if(node.getRelExp() != null)
00542         {
00543             node.getRelExp().apply(this);
00544         }
00545         outALessEqualRelExp(node);
00546     }
00547     public void caseALessEqualTOp(ALessEqualTOp node)
00548     {
00549         inALessEqualTOp(node);
00550         if(node.getLessEqual() != null)
00551         {
00552             node.getLessEqual().apply(this);
00553         }
00554         outALessEqualTOp(node);
00555     }
00556     public void caseALessRelExp(ALessRelExp node)
00557     {
00558         inALessRelExp(node);
00559         if(node.getShiftExp() != null)
00560         {
00561             node.getShiftExp().apply(this);
00562         }
00563         if(node.getLess() != null)
00564         {
00565             node.getLess().apply(this);
00566         }
00567         if(node.getRelExp() != null)
00568         {
00569             node.getRelExp().apply(this);
00570         }
00571         outALessRelExp(node);
00572     }
00573     public void caseALessTOp(ALessTOp node)
00574     {
00575         inALessTOp(node);
00576         if(node.getLess() != null)
00577         {
00578             node.getLess().apply(this);
00579         }
00580         outALessTOp(node);
00581     }
00582     public void caseALiteralPrimaryExp(ALiteralPrimaryExp node)
00583     {
00584         inALiteralPrimaryExp(node);
00585         if(node.getLiteral() != null)
00586         {
00587             node.getLiteral().apply(this);
00588         }
00589         outALiteralPrimaryExp(node);
00590     }
00591     public void caseAMinusAddExp(AMinusAddExp node)
00592     {
00593         inAMinusAddExp(node);
00594         if(node.getMultExp() != null)
00595         {
00596             node.getMultExp().apply(this);
00597         }
00598         if(node.getMinus() != null)
00599         {
00600             node.getMinus().apply(this);
00601         }
00602         if(node.getAddExp() != null)
00603         {
00604             node.getAddExp().apply(this);
00605         }
00606         outAMinusAddExp(node);
00607     }
00608     public void caseAMinusOp(AMinusOp node)
00609     {
00610         inAMinusOp(node);
00611         if(node.getMinus() != null)
00612         {
00613             node.getMinus().apply(this);
00614         }
00615         outAMinusOp(node);
00616     }
00617     public void caseAMinusUnaryExp(AMinusUnaryExp node)
00618     {
00619         inAMinusUnaryExp(node);
00620         if(node.getUnaryExp() != null)
00621         {
00622             node.getUnaryExp().apply(this);
00623         }
00624         if(node.getMinus() != null)
00625         {
00626             node.getMinus().apply(this);
00627         }
00628         outAMinusUnaryExp(node);
00629     }
00630     public void caseAModMultExp(AModMultExp node)
00631     {
00632         inAModMultExp(node);
00633         if(node.getUnaryExp() != null)
00634         {
00635             node.getUnaryExp().apply(this);
00636         }
00637         if(node.getMod() != null)
00638         {
00639             node.getMod().apply(this);
00640         }
00641         if(node.getMultExp() != null)
00642         {
00643             node.getMultExp().apply(this);
00644         }
00645         outAModMultExp(node);
00646     }
00647     public void caseAModOp(AModOp node)
00648     {
00649         inAModOp(node);
00650         if(node.getMod() != null)
00651         {
00652             node.getMod().apply(this);
00653         }
00654         outAModOp(node);
00655     }
00656     public void caseAMultAddExp(AMultAddExp node)
00657     {
00658         inAMultAddExp(node);
00659         if(node.getMultExp() != null)
00660         {
00661             node.getMultExp().apply(this);
00662         }
00663         outAMultAddExp(node);
00664     }
00665     public void caseANeqEqExp(ANeqEqExp node)
00666     {
00667         inANeqEqExp(node);
00668         if(node.getRelExp() != null)
00669         {
00670             node.getRelExp().apply(this);
00671         }
00672         if(node.getNotEqual() != null)
00673         {
00674             node.getNotEqual().apply(this);
00675         }
00676         if(node.getEqExp() != null)
00677         {
00678             node.getEqExp().apply(this);
00679         }
00680         outANeqEqExp(node);
00681     }
00682     public void caseANotEqualTOp(ANotEqualTOp node)
00683     {
00684         inANotEqualTOp(node);
00685         if(node.getNotEqual() != null)
00686         {
00687             node.getNotEqual().apply(this);
00688         }
00689         outANotEqualTOp(node);
00690     }
00691     public void caseAOctIntLiteral(AOctIntLiteral node)
00692     {
00693         inAOctIntLiteral(node);
00694         if(node.getOctIntLiteral() != null)
00695         {
00696             node.getOctIntLiteral().apply(this);
00697         }
00698         outAOctIntLiteral(node);
00699     }
00700     public void caseAOctLongLiteral(AOctLongLiteral node)
00701     {
00702         inAOctLongLiteral(node);
00703         if(node.getOctLongLiteral() != null)
00704         {
00705             node.getOctLongLiteral().apply(this);
00706         }
00707         outAOctLongLiteral(node);
00708     }
00709     public void caseAOne2oneSet(AOne2oneSet node)
00710     {
00711         inAOne2oneSet(node);
00712         if(node.getSemicolon() != null)
00713         {
00714             node.getSemicolon().apply(this);
00715         }
00716         if(node.getRBrace() != null)
00717         {
00718             node.getRBrace().apply(this);
00719         }
00720         if(node.getIdList() != null)
00721         {
00722             node.getIdList().apply(this);
00723         }
00724         if(node.getLBrace() != null)
00725         {
00726             node.getLBrace().apply(this);
00727         }
00728         if(node.getEq() != null)
00729         {
00730             node.getEq().apply(this);
00731         }
00732         if(node.getOne2one() != null)
00733         {
00734             node.getOne2one().apply(this);
00735         }
00736         outAOne2oneSet(node);
00737     }
00738     public void caseAOperator(AOperator node)
00739     {
00740         inAOperator(node);
00741         if(node.getEnd() != null)
00742         {
00743             node.getEnd().apply(this);
00744         }
00745         {
00746             Object temp[] = node.getPattern().toArray();
00747             for(int i = temp.length - 1; i >= 0; i--)
00748             {
00749                 ((PPattern) temp[i]).apply(this);
00750             }
00751         }
00752         if(node.getBegin() != null)
00753         {
00754             node.getBegin().apply(this);
00755         }
00756         if(node.getId() != null)
00757         {
00758             node.getId().apply(this);
00759         }
00760         if(node.getOp() != null)
00761         {
00762             node.getOp().apply(this);
00763         }
00764         if(node.getOperator() != null)
00765         {
00766             node.getOperator().apply(this);
00767         }
00768         outAOperator(node);
00769     }
00770     public void caseAOperatorOperatorTest(AOperatorOperatorTest node)
00771     {
00772         inAOperatorOperatorTest(node);
00773         if(node.getOperator() != null)
00774         {
00775             node.getOperator().apply(this);
00776         }
00777         outAOperatorOperatorTest(node);
00778     }
00779     public void caseAOrConditionalExp(AOrConditionalExp node)
00780     {
00781         inAOrConditionalExp(node);
00782         if(node.getOrExp() != null)
00783         {
00784             node.getOrExp().apply(this);
00785         }
00786         outAOrConditionalExp(node);
00787     }
00788     public void caseAOrInclusiveOrExp(AOrInclusiveOrExp node)
00789     {
00790         inAOrInclusiveOrExp(node);
00791         if(node.getExclusiveOrExp() != null)
00792         {
00793             node.getExclusiveOrExp().apply(this);
00794         }
00795         if(node.getBitOr() != null)
00796         {
00797             node.getBitOr().apply(this);
00798         }
00799         if(node.getInclusiveOrExp() != null)
00800         {
00801             node.getInclusiveOrExp().apply(this);
00802         }
00803         outAOrInclusiveOrExp(node);
00804     }
00805     public void caseAOrOrExp(AOrOrExp node)
00806     {
00807         inAOrOrExp(node);
00808         if(node.getAndExp() != null)
00809         {
00810             node.getAndExp().apply(this);
00811         }
00812         if(node.getOr() != null)
00813         {
00814             node.getOr().apply(this);
00815         }
00816         if(node.getOrExp() != null)
00817         {
00818             node.getOrExp().apply(this);
00819         }
00820         outAOrOrExp(node);
00821     }
00822     public void caseAParenPrimaryExp(AParenPrimaryExp node)
00823     {
00824         inAParenPrimaryExp(node);
00825         if(node.getRParen() != null)
00826         {
00827             node.getRParen().apply(this);
00828         }
00829         if(node.getExp() != null)
00830         {
00831             node.getExp().apply(this);
00832         }
00833         if(node.getLParen() != null)
00834         {
00835             node.getLParen().apply(this);
00836         }
00837         outAParenPrimaryExp(node);
00838     }
00839     public void caseAPatternPattern(APatternPattern node)
00840     {
00841         inAPatternPattern(node);
00842         if(node.getSemicolon() != null)
00843         {
00844             node.getSemicolon().apply(this);
00845         }
00846         if(node.getTokenTokenSet() != null)
00847         {
00848             node.getTokenTokenSet().apply(this);
00849         }
00850         if(node.getRightarrow() != null)
00851         {
00852             node.getRightarrow().apply(this);
00853         }
00854         if(node.getRParen() != null)
00855         {
00856             node.getRParen().apply(this);
00857         }
00858         if(node.getRId() != null)
00859         {
00860             node.getRId().apply(this);
00861         }
00862         if(node.getComma() != null)
00863         {
00864             node.getComma().apply(this);
00865         }
00866         if(node.getLId() != null)
00867         {
00868             node.getLId().apply(this);
00869         }
00870         if(node.getLParen() != null)
00871         {
00872             node.getLParen().apply(this);
00873         }
00874         outAPatternPattern(node);
00875     }
00876     public void caseAPlusAddExp(APlusAddExp node)
00877     {
00878         inAPlusAddExp(node);
00879         if(node.getMultExp() != null)
00880         {
00881             node.getMultExp().apply(this);
00882         }
00883         if(node.getPlus() != null)
00884         {
00885             node.getPlus().apply(this);
00886         }
00887         if(node.getAddExp() != null)
00888         {
00889             node.getAddExp().apply(this);
00890         }
00891         outAPlusAddExp(node);
00892     }
00893     public void caseAPlusOp(APlusOp node)
00894     {
00895         inAPlusOp(node);
00896         if(node.getPlus() != null)
00897         {
00898             node.getPlus().apply(this);
00899         }
00900         outAPlusOp(node);
00901     }
00902     public void caseAPlusUnaryExp(APlusUnaryExp node)
00903     {
00904         inAPlusUnaryExp(node);
00905         if(node.getUnaryExp() != null)
00906         {
00907             node.getUnaryExp().apply(this);
00908         }
00909         if(node.getPlus() != null)
00910         {
00911             node.getPlus().apply(this);
00912         }
00913         outAPlusUnaryExp(node);
00914     }
00915     public void caseAPrimaryUnaryNotPlusMinusExp(APrimaryUnaryNotPlusMinusExp node)
00916     {
00917         inAPrimaryUnaryNotPlusMinusExp(node);
00918         if(node.getPrimaryExp() != null)
00919         {
00920             node.getPrimaryExp().apply(this);
00921         }
00922         outAPrimaryUnaryNotPlusMinusExp(node);
00923     }
00924     public void caseAQuestionConditionalExp(AQuestionConditionalExp node)
00925     {
00926         inAQuestionConditionalExp(node);
00927         if(node.getFalseExp() != null)
00928         {
00929             node.getFalseExp().apply(this);
00930         }
00931         if(node.getColon() != null)
00932         {
00933             node.getColon().apply(this);
00934         }
00935         if(node.getTrueExp() != null)
00936         {
00937             node.getTrueExp().apply(this);
00938         }
00939         if(node.getQuestion() != null)
00940         {
00941             node.getQuestion().apply(this);
00942         }
00943         if(node.getOrExp() != null)
00944         {
00945             node.getOrExp().apply(this);
00946         }
00947         outAQuestionConditionalExp(node);
00948     }
00949     public void caseARealType(ARealType node)
00950     {
00951         inARealType(node);
00952         if(node.getReal() != null)
00953         {
00954             node.getReal().apply(this);
00955         }
00956         outARealType(node);
00957     }
00958     public void caseARelEqExp(ARelEqExp node)
00959     {
00960         inARelEqExp(node);
00961         if(node.getRelExp() != null)
00962         {
00963             node.getRelExp().apply(this);
00964         }
00965         outARelEqExp(node);
00966     }
00967     public void caseAShiftRelExp(AShiftRelExp node)
00968     {
00969         inAShiftRelExp(node);
00970         if(node.getShiftExp() != null)
00971         {
00972             node.getShiftExp().apply(this);
00973         }
00974         outAShiftRelExp(node);
00975     }
00976     public void caseASignedRightShiftExp(ASignedRightShiftExp node)
00977     {
00978         inASignedRightShiftExp(node);
00979         if(node.getAddExp() != null)
00980         {
00981             node.getAddExp().apply(this);
00982         }
00983         if(node.getSignedShiftRight() != null)
00984         {
00985             node.getSignedShiftRight().apply(this);
00986         }
00987         if(node.getShiftExp() != null)
00988         {
00989             node.getShiftExp().apply(this);
00990         }
00991         outASignedRightShiftExp(node);
00992     }
00993     public void caseATest(ATest node)
00994     {
00995         inATest(node);
00996         if(node.getEnd() != null)
00997         {
00998             node.getEnd().apply(this);
00999         }
01000         {
01001             Object temp[] = node.getPattern().toArray();
01002             for(int i = temp.length - 1; i >= 0; i--)
01003             {
01004                 ((PPattern) temp[i]).apply(this);
01005             }
01006         }
01007         if(node.getBegin() != null)
01008         {
01009             node.getBegin().apply(this);
01010         }
01011         if(node.getId() != null)
01012         {
01013             node.getId().apply(this);
01014         }
01015         if(node.getTOp() != null)
01016         {
01017             node.getTOp().apply(this);
01018         }
01019         if(node.getTest() != null)
01020         {
01021             node.getTest().apply(this);
01022         }
01023         outATest(node);
01024     }
01025     public void caseATestOperatorTest(ATestOperatorTest node)
01026     {
01027         inATestOperatorTest(node);
01028         if(node.getTest() != null)
01029         {
01030             node.getTest().apply(this);
01031         }
01032         outATestOperatorTest(node);
01033     }
01034     public void caseATimesMultExp(ATimesMultExp node)
01035     {
01036         inATimesMultExp(node);
01037         if(node.getUnaryExp() != null)
01038         {
01039             node.getUnaryExp().apply(this);
01040         }
01041         if(node.getTimes() != null)
01042         {
01043             node.getTimes().apply(this);
01044         }
01045         if(node.getMultExp() != null)
01046         {
01047             node.getMultExp().apply(this);
01048         }
01049         outATimesMultExp(node);
01050     }
01051     public void caseATimesOp(ATimesOp node)
01052     {
01053         inATimesOp(node);
01054         if(node.getTimes() != null)
01055         {
01056             node.getTimes().apply(this);
01057         }
01058         outATimesOp(node);
01059     }
01060     public void caseATokenSet(ATokenSet node)
01061     {
01062         inATokenSet(node);
01063         if(node.getSemicolon() != null)
01064         {
01065             node.getSemicolon().apply(this);
01066         }
01067         if(node.getIdSet() != null)
01068         {
01069             node.getIdSet().apply(this);
01070         }
01071         if(node.getEq() != null)
01072         {
01073             node.getEq().apply(this);
01074         }
01075         if(node.getTokens() != null)
01076         {
01077             node.getTokens().apply(this);
01078         }
01079         outATokenSet(node);
01080     }
01081     public void caseATokenSetTokenTokenSet(ATokenSetTokenTokenSet node)
01082     {
01083         inATokenSetTokenTokenSet(node);
01084         if(node.getIdSet() != null)
01085         {
01086             node.getIdSet().apply(this);
01087         }
01088         outATokenSetTokenTokenSet(node);
01089     }
01090     public void caseATokenTokenTokenSet(ATokenTokenTokenSet node)
01091     {
01092         inATokenTokenTokenSet(node);
01093         if(node.getId() != null)
01094         {
01095             node.getId().apply(this);
01096         }
01097         outATokenTokenTokenSet(node);
01098     }
01099     public void caseAUnaryExpMultExp(AUnaryExpMultExp node)
01100     {
01101         inAUnaryExpMultExp(node);
01102         if(node.getUnaryExp() != null)
01103         {
01104             node.getUnaryExp().apply(this);
01105         }
01106         outAUnaryExpMultExp(node);
01107     }
01108     public void caseAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
01109     {
01110         inAUnaryNotPlusMinusUnaryExp(node);
01111         if(node.getUnaryNotPlusMinusExp() != null)
01112         {
01113             node.getUnaryNotPlusMinusExp().apply(this);
01114         }
01115         outAUnaryNotPlusMinusUnaryExp(node);
01116     }
01117     public void caseAUnit(AUnit node)
01118     {
01119         inAUnit(node);
01120         if(node.getEnd() != null)
01121         {
01122             node.getEnd().apply(this);
01123         }
01124         {
01125             Object temp[] = node.getOperatorTest().toArray();
01126             for(int i = temp.length - 1; i >= 0; i--)
01127             {
01128                 ((POperatorTest) temp[i]).apply(this);
01129             }
01130         }
01131         if(node.getAbstractFunction() != null)
01132         {
01133             node.getAbstractFunction().apply(this);
01134         }
01135         if(node.getOne2oneSet() != null)
01136         {
01137             node.getOne2oneSet().apply(this);
01138         }
01139         if(node.getDefaultToken() != null)
01140         {
01141             node.getDefaultToken().apply(this);
01142         }
01143         if(node.getTokenSet() != null)
01144         {
01145             node.getTokenSet().apply(this);
01146         }
01147         if(node.getBegin() != null)
01148         {
01149             node.getBegin().apply(this);
01150         }
01151         if(node.getType() != null)
01152         {
01153             node.getType().apply(this);
01154         }
01155         if(node.getExtends() != null)
01156         {
01157             node.getExtends().apply(this);
01158         }
01159         if(node.getId() != null)
01160         {
01161             node.getId().apply(this);
01162         }
01163         if(node.getAbstraction() != null)
01164         {
01165             node.getAbstraction().apply(this);
01166         }
01167         outAUnit(node);
01168     }
01169     public void caseAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
01170     {
01171         inAUnsignedRightShiftExp(node);
01172         if(node.getAddExp() != null)
01173         {
01174             node.getAddExp().apply(this);
01175         }
01176         if(node.getUnsignedShiftRight() != null)
01177         {
01178             node.getUnsignedShiftRight().apply(this);
01179         }
01180         if(node.getShiftExp() != null)
01181         {
01182             node.getShiftExp().apply(this);
01183         }
01184         outAUnsignedRightShiftExp(node);
01185     }
01186     public void caseAXorExclusiveOrExp(AXorExclusiveOrExp node)
01187     {
01188         inAXorExclusiveOrExp(node);
01189         if(node.getBitAndExp() != null)
01190         {
01191             node.getBitAndExp().apply(this);
01192         }
01193         if(node.getBitXor() != null)
01194         {
01195             node.getBitXor().apply(this);
01196         }
01197         if(node.getExclusiveOrExp() != null)
01198         {
01199             node.getExclusiveOrExp().apply(this);
01200         }
01201         outAXorExclusiveOrExp(node);
01202     }
01203     public void caseAXorInclusiveOrExp(AXorInclusiveOrExp node)
01204     {
01205         inAXorInclusiveOrExp(node);
01206         if(node.getExclusiveOrExp() != null)
01207         {
01208             node.getExclusiveOrExp().apply(this);
01209         }
01210         outAXorInclusiveOrExp(node);
01211     }
01212     public void caseStart(Start node)
01213     {
01214         inStart(node);
01215         node.getEOF().apply(this);
01216         node.getPUnit().apply(this);
01217         outStart(node);
01218     }
01219     public void defaultIn(Node node)
01220     {
01221     }
01222     public void defaultOut(Node node)
01223     {
01224     }
01225     public void inAAbstractFunction(AAbstractFunction node)
01226     {
01227         defaultIn(node);
01228     }
01229     public void inAAddExpShiftExp(AAddExpShiftExp node)
01230     {
01231         defaultIn(node);
01232     }
01233     public void inAAndAndExp(AAndAndExp node)
01234     {
01235         defaultIn(node);
01236     }
01237     public void inAAndBitAndExp(AAndBitAndExp node)
01238     {
01239         defaultIn(node);
01240     }
01241     public void inAAndExclusiveOrExp(AAndExclusiveOrExp node)
01242     {
01243         defaultIn(node);
01244     }
01245     public void inAAndOrExp(AAndOrExp node)
01246     {
01247         defaultIn(node);
01248     }
01249     public void inAAnyAbstractDef(AAnyAbstractDef node)
01250     {
01251         defaultIn(node);
01252     }
01253     public void inAAnyAnyId(AAnyAnyId node)
01254     {
01255         defaultIn(node);
01256     }
01257     public void inAAnyPattern(AAnyPattern node)
01258     {
01259         defaultIn(node);
01260     }
01261     public void inABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
01262     {
01263         defaultIn(node);
01264     }
01265     public void inAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
01266     {
01267         defaultIn(node);
01268     }
01269     public void inADecIntLiteral(ADecIntLiteral node)
01270     {
01271         defaultIn(node);
01272     }
01273     public void inADecLongLiteral(ADecLongLiteral node)
01274     {
01275         defaultIn(node);
01276     }
01277     public void inADefaultToken(ADefaultToken node)
01278     {
01279         defaultIn(node);
01280     }
01281     public void inADivMultExp(ADivMultExp node)
01282     {
01283         defaultIn(node);
01284     }
01285     public void inADivOp(ADivOp node)
01286     {
01287         defaultIn(node);
01288     }
01289     public void inADoubleLiteral(ADoubleLiteral node)
01290     {
01291         defaultIn(node);
01292     }
01293     public void inAEqBitAndExp(AEqBitAndExp node)
01294     {
01295         defaultIn(node);
01296     }
01297     public void inAEqEqExp(AEqEqExp node)
01298     {
01299         defaultIn(node);
01300     }
01301     public void inAEqualTOp(AEqualTOp node)
01302     {
01303         defaultIn(node);
01304     }
01305     public void inAExp(AExp node)
01306     {
01307         defaultIn(node);
01308     }
01309     public void inAExpAbstractDef(AExpAbstractDef node)
01310     {
01311         defaultIn(node);
01312     }
01313     public void inAFloatLiteral(AFloatLiteral node)
01314     {
01315         defaultIn(node);
01316     }
01317     public void inAGreaterEqualRelExp(AGreaterEqualRelExp node)
01318     {
01319         defaultIn(node);
01320     }
01321     public void inAGreaterEqualTOp(AGreaterEqualTOp node)
01322     {
01323         defaultIn(node);
01324     }
01325     public void inAGreaterRelExp(AGreaterRelExp node)
01326     {
01327         defaultIn(node);
01328     }
01329     public void inAGreaterTOp(AGreaterTOp node)
01330     {
01331         defaultIn(node);
01332     }
01333     public void inAHexIntLiteral(AHexIntLiteral node)
01334     {
01335         defaultIn(node);
01336     }
01337     public void inAHexLongLiteral(AHexLongLiteral node)
01338     {
01339         defaultIn(node);
01340     }
01341     public void inAIdAnyId(AIdAnyId node)
01342     {
01343         defaultIn(node);
01344     }
01345     public void inAIdIdList(AIdIdList node)
01346     {
01347         defaultIn(node);
01348     }
01349     public void inAIdPrimaryExp(AIdPrimaryExp node)
01350     {
01351         defaultIn(node);
01352     }
01353     public void inAIdSet(AIdSet node)
01354     {
01355         defaultIn(node);
01356     }
01357     public void inAIdsIdList(AIdsIdList node)
01358     {
01359         defaultIn(node);
01360     }
01361     public void inAInclusiveOrAndExp(AInclusiveOrAndExp node)
01362     {
01363         defaultIn(node);
01364     }
01365     public void inAIntegralType(AIntegralType node)
01366     {
01367         defaultIn(node);
01368     }
01369     public void inALeftShiftExp(ALeftShiftExp node)
01370     {
01371         defaultIn(node);
01372     }
01373     public void inALessEqualRelExp(ALessEqualRelExp node)
01374     {
01375         defaultIn(node);
01376     }
01377     public void inALessEqualTOp(ALessEqualTOp node)
01378     {
01379         defaultIn(node);
01380     }
01381     public void inALessRelExp(ALessRelExp node)
01382     {
01383         defaultIn(node);
01384     }
01385     public void inALessTOp(ALessTOp node)
01386     {
01387         defaultIn(node);
01388     }
01389     public void inALiteralPrimaryExp(ALiteralPrimaryExp node)
01390     {
01391         defaultIn(node);
01392     }
01393     public void inAMinusAddExp(AMinusAddExp node)
01394     {
01395         defaultIn(node);
01396     }
01397     public void inAMinusOp(AMinusOp node)
01398     {
01399         defaultIn(node);
01400     }
01401     public void inAMinusUnaryExp(AMinusUnaryExp node)
01402     {
01403         defaultIn(node);
01404     }
01405     public void inAModMultExp(AModMultExp node)
01406     {
01407         defaultIn(node);
01408     }
01409     public void inAModOp(AModOp node)
01410     {
01411         defaultIn(node);
01412     }
01413     public void inAMultAddExp(AMultAddExp node)
01414     {
01415         defaultIn(node);
01416     }
01417     public void inANeqEqExp(ANeqEqExp node)
01418     {
01419         defaultIn(node);
01420     }
01421     public void inANotEqualTOp(ANotEqualTOp node)
01422     {
01423         defaultIn(node);
01424     }
01425     public void inAOctIntLiteral(AOctIntLiteral node)
01426     {
01427         defaultIn(node);
01428     }
01429     public void inAOctLongLiteral(AOctLongLiteral node)
01430     {
01431         defaultIn(node);
01432     }
01433     public void inAOne2oneSet(AOne2oneSet node)
01434     {
01435         defaultIn(node);
01436     }
01437     public void inAOperator(AOperator node)
01438     {
01439         defaultIn(node);
01440     }
01441     public void inAOperatorOperatorTest(AOperatorOperatorTest node)
01442     {
01443         defaultIn(node);
01444     }
01445     public void inAOrConditionalExp(AOrConditionalExp node)
01446     {
01447         defaultIn(node);
01448     }
01449     public void inAOrInclusiveOrExp(AOrInclusiveOrExp node)
01450     {
01451         defaultIn(node);
01452     }
01453     public void inAOrOrExp(AOrOrExp node)
01454     {
01455         defaultIn(node);
01456     }
01457     public void inAParenPrimaryExp(AParenPrimaryExp node)
01458     {
01459         defaultIn(node);
01460     }
01461     public void inAPatternPattern(APatternPattern node)
01462     {
01463         defaultIn(node);
01464     }
01465     public void inAPlusAddExp(APlusAddExp node)
01466     {
01467         defaultIn(node);
01468     }
01469     public void inAPlusOp(APlusOp node)
01470     {
01471         defaultIn(node);
01472     }
01473     public void inAPlusUnaryExp(APlusUnaryExp node)
01474     {
01475         defaultIn(node);
01476     }
01477     public void inAPrimaryUnaryNotPlusMinusExp(APrimaryUnaryNotPlusMinusExp node)
01478     {
01479         defaultIn(node);
01480     }
01481     public void inAQuestionConditionalExp(AQuestionConditionalExp node)
01482     {
01483         defaultIn(node);
01484     }
01485     public void inARealType(ARealType node)
01486     {
01487         defaultIn(node);
01488     }
01489     public void inARelEqExp(ARelEqExp node)
01490     {
01491         defaultIn(node);
01492     }
01493     public void inAShiftRelExp(AShiftRelExp node)
01494     {
01495         defaultIn(node);
01496     }
01497     public void inASignedRightShiftExp(ASignedRightShiftExp node)
01498     {
01499         defaultIn(node);
01500     }
01501     public void inATest(ATest node)
01502     {
01503         defaultIn(node);
01504     }
01505     public void inATestOperatorTest(ATestOperatorTest node)
01506     {
01507         defaultIn(node);
01508     }
01509     public void inATimesMultExp(ATimesMultExp node)
01510     {
01511         defaultIn(node);
01512     }
01513     public void inATimesOp(ATimesOp node)
01514     {
01515         defaultIn(node);
01516     }
01517     public void inATokenSet(ATokenSet node)
01518     {
01519         defaultIn(node);
01520     }
01521     public void inATokenSetTokenTokenSet(ATokenSetTokenTokenSet node)
01522     {
01523         defaultIn(node);
01524     }
01525     public void inATokenTokenTokenSet(ATokenTokenTokenSet node)
01526     {
01527         defaultIn(node);
01528     }
01529     public void inAUnaryExpMultExp(AUnaryExpMultExp node)
01530     {
01531         defaultIn(node);
01532     }
01533     public void inAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
01534     {
01535         defaultIn(node);
01536     }
01537     public void inAUnit(AUnit node)
01538     {
01539         defaultIn(node);
01540     }
01541     public void inAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
01542     {
01543         defaultIn(node);
01544     }
01545     public void inAXorExclusiveOrExp(AXorExclusiveOrExp node)
01546     {
01547         defaultIn(node);
01548     }
01549     public void inAXorInclusiveOrExp(AXorInclusiveOrExp node)
01550     {
01551         defaultIn(node);
01552     }
01553     public void inStart(Start node)
01554     {
01555         defaultIn(node);
01556     }
01557     public void outAAbstractFunction(AAbstractFunction node)
01558     {
01559         defaultOut(node);
01560     }
01561     public void outAAddExpShiftExp(AAddExpShiftExp node)
01562     {
01563         defaultOut(node);
01564     }
01565     public void outAAndAndExp(AAndAndExp node)
01566     {
01567         defaultOut(node);
01568     }
01569     public void outAAndBitAndExp(AAndBitAndExp node)
01570     {
01571         defaultOut(node);
01572     }
01573     public void outAAndExclusiveOrExp(AAndExclusiveOrExp node)
01574     {
01575         defaultOut(node);
01576     }
01577     public void outAAndOrExp(AAndOrExp node)
01578     {
01579         defaultOut(node);
01580     }
01581     public void outAAnyAbstractDef(AAnyAbstractDef node)
01582     {
01583         defaultOut(node);
01584     }
01585     public void outAAnyAnyId(AAnyAnyId node)
01586     {
01587         defaultOut(node);
01588     }
01589     public void outAAnyPattern(AAnyPattern node)
01590     {
01591         defaultOut(node);
01592     }
01593     public void outABitComplementUnaryNotPlusMinusExp(ABitComplementUnaryNotPlusMinusExp node)
01594     {
01595         defaultOut(node);
01596     }
01597     public void outAComplementUnaryNotPlusMinusExp(AComplementUnaryNotPlusMinusExp node)
01598     {
01599         defaultOut(node);
01600     }
01601     public void outADecIntLiteral(ADecIntLiteral node)
01602     {
01603         defaultOut(node);
01604     }
01605     public void outADecLongLiteral(ADecLongLiteral node)
01606     {
01607         defaultOut(node);
01608     }
01609     public void outADefaultToken(ADefaultToken node)
01610     {
01611         defaultOut(node);
01612     }
01613     public void outADivMultExp(ADivMultExp node)
01614     {
01615         defaultOut(node);
01616     }
01617     public void outADivOp(ADivOp node)
01618     {
01619         defaultOut(node);
01620     }
01621     public void outADoubleLiteral(ADoubleLiteral node)
01622     {
01623         defaultOut(node);
01624     }
01625     public void outAEqBitAndExp(AEqBitAndExp node)
01626     {
01627         defaultOut(node);
01628     }
01629     public void outAEqEqExp(AEqEqExp node)
01630     {
01631         defaultOut(node);
01632     }
01633     public void outAEqualTOp(AEqualTOp node)
01634     {
01635         defaultOut(node);
01636     }
01637     public void outAExp(AExp node)
01638     {
01639         defaultOut(node);
01640     }
01641     public void outAExpAbstractDef(AExpAbstractDef node)
01642     {
01643         defaultOut(node);
01644     }
01645     public void outAFloatLiteral(AFloatLiteral node)
01646     {
01647         defaultOut(node);
01648     }
01649     public void outAGreaterEqualRelExp(AGreaterEqualRelExp node)
01650     {
01651         defaultOut(node);
01652     }
01653     public void outAGreaterEqualTOp(AGreaterEqualTOp node)
01654     {
01655         defaultOut(node);
01656     }
01657     public void outAGreaterRelExp(AGreaterRelExp node)
01658     {
01659         defaultOut(node);
01660     }
01661     public void outAGreaterTOp(AGreaterTOp node)
01662     {
01663         defaultOut(node);
01664     }
01665     public void outAHexIntLiteral(AHexIntLiteral node)
01666     {
01667         defaultOut(node);
01668     }
01669     public void outAHexLongLiteral(AHexLongLiteral node)
01670     {
01671         defaultOut(node);
01672     }
01673     public void outAIdAnyId(AIdAnyId node)
01674     {
01675         defaultOut(node);
01676     }
01677     public void outAIdIdList(AIdIdList node)
01678     {
01679         defaultOut(node);
01680     }
01681     public void outAIdPrimaryExp(AIdPrimaryExp node)
01682     {
01683         defaultOut(node);
01684     }
01685     public void outAIdSet(AIdSet node)
01686     {
01687         defaultOut(node);
01688     }
01689     public void outAIdsIdList(AIdsIdList node)
01690     {
01691         defaultOut(node);
01692     }
01693     public void outAInclusiveOrAndExp(AInclusiveOrAndExp node)
01694     {
01695         defaultOut(node);
01696     }
01697     public void outAIntegralType(AIntegralType node)
01698     {
01699         defaultOut(node);
01700     }
01701     public void outALeftShiftExp(ALeftShiftExp node)
01702     {
01703         defaultOut(node);
01704     }
01705     public void outALessEqualRelExp(ALessEqualRelExp node)
01706     {
01707         defaultOut(node);
01708     }
01709     public void outALessEqualTOp(ALessEqualTOp node)
01710     {
01711         defaultOut(node);
01712     }
01713     public void outALessRelExp(ALessRelExp node)
01714     {
01715         defaultOut(node);
01716     }
01717     public void outALessTOp(ALessTOp node)
01718     {
01719         defaultOut(node);
01720     }
01721     public void outALiteralPrimaryExp(ALiteralPrimaryExp node)
01722     {
01723         defaultOut(node);
01724     }
01725     public void outAMinusAddExp(AMinusAddExp node)
01726     {
01727         defaultOut(node);
01728     }
01729     public void outAMinusOp(AMinusOp node)
01730     {
01731         defaultOut(node);
01732     }
01733     public void outAMinusUnaryExp(AMinusUnaryExp node)
01734     {
01735         defaultOut(node);
01736     }
01737     public void outAModMultExp(AModMultExp node)
01738     {
01739         defaultOut(node);
01740     }
01741     public void outAModOp(AModOp node)
01742     {
01743         defaultOut(node);
01744     }
01745     public void outAMultAddExp(AMultAddExp node)
01746     {
01747         defaultOut(node);
01748     }
01749     public void outANeqEqExp(ANeqEqExp node)
01750     {
01751         defaultOut(node);
01752     }
01753     public void outANotEqualTOp(ANotEqualTOp node)
01754     {
01755         defaultOut(node);
01756     }
01757     public void outAOctIntLiteral(AOctIntLiteral node)
01758     {
01759         defaultOut(node);
01760     }
01761     public void outAOctLongLiteral(AOctLongLiteral node)
01762     {
01763         defaultOut(node);
01764     }
01765     public void outAOne2oneSet(AOne2oneSet node)
01766     {
01767         defaultOut(node);
01768     }
01769     public void outAOperator(AOperator node)
01770     {
01771         defaultOut(node);
01772     }
01773     public void outAOperatorOperatorTest(AOperatorOperatorTest node)
01774     {
01775         defaultOut(node);
01776     }
01777     public void outAOrConditionalExp(AOrConditionalExp node)
01778     {
01779         defaultOut(node);
01780     }
01781     public void outAOrInclusiveOrExp(AOrInclusiveOrExp node)
01782     {
01783         defaultOut(node);
01784     }
01785     public void outAOrOrExp(AOrOrExp node)
01786     {
01787         defaultOut(node);
01788     }
01789     public void outAParenPrimaryExp(AParenPrimaryExp node)
01790     {
01791         defaultOut(node);
01792     }
01793     public void outAPatternPattern(APatternPattern node)
01794     {
01795         defaultOut(node);
01796     }
01797     public void outAPlusAddExp(APlusAddExp node)
01798     {
01799         defaultOut(node);
01800     }
01801     public void outAPlusOp(APlusOp node)
01802     {
01803         defaultOut(node);
01804     }
01805     public void outAPlusUnaryExp(APlusUnaryExp node)
01806     {
01807         defaultOut(node);
01808     }
01809     public void outAPrimaryUnaryNotPlusMinusExp(APrimaryUnaryNotPlusMinusExp node)
01810     {
01811         defaultOut(node);
01812     }
01813     public void outAQuestionConditionalExp(AQuestionConditionalExp node)
01814     {
01815         defaultOut(node);
01816     }
01817     public void outARealType(ARealType node)
01818     {
01819         defaultOut(node);
01820     }
01821     public void outARelEqExp(ARelEqExp node)
01822     {
01823         defaultOut(node);
01824     }
01825     public void outAShiftRelExp(AShiftRelExp node)
01826     {
01827         defaultOut(node);
01828     }
01829     public void outASignedRightShiftExp(ASignedRightShiftExp node)
01830     {
01831         defaultOut(node);
01832     }
01833     public void outATest(ATest node)
01834     {
01835         defaultOut(node);
01836     }
01837     public void outATestOperatorTest(ATestOperatorTest node)
01838     {
01839         defaultOut(node);
01840     }
01841     public void outATimesMultExp(ATimesMultExp node)
01842     {
01843         defaultOut(node);
01844     }
01845     public void outATimesOp(ATimesOp node)
01846     {
01847         defaultOut(node);
01848     }
01849     public void outATokenSet(ATokenSet node)
01850     {
01851         defaultOut(node);
01852     }
01853     public void outATokenSetTokenTokenSet(ATokenSetTokenTokenSet node)
01854     {
01855         defaultOut(node);
01856     }
01857     public void outATokenTokenTokenSet(ATokenTokenTokenSet node)
01858     {
01859         defaultOut(node);
01860     }
01861     public void outAUnaryExpMultExp(AUnaryExpMultExp node)
01862     {
01863         defaultOut(node);
01864     }
01865     public void outAUnaryNotPlusMinusUnaryExp(AUnaryNotPlusMinusUnaryExp node)
01866     {
01867         defaultOut(node);
01868     }
01869     public void outAUnit(AUnit node)
01870     {
01871         defaultOut(node);
01872     }
01873     public void outAUnsignedRightShiftExp(AUnsignedRightShiftExp node)
01874     {
01875         defaultOut(node);
01876     }
01877     public void outAXorExclusiveOrExp(AXorExclusiveOrExp node)
01878     {
01879         defaultOut(node);
01880     }
01881     public void outAXorInclusiveOrExp(AXorInclusiveOrExp node)
01882     {
01883         defaultOut(node);
01884     }
01885     public void outStart(Start node)
01886     {
01887         defaultOut(node);
01888     }
01889 }