Ignore:
Timestamp:
May 30, 2013, 12:16:33 PM (6 years ago)
Author:
ksherdy
Message:

Partial update to Locator style generators.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Generators.java

    r3208 r3238  
    11/*
    2  *
    3  * Static factories for various node types.
    4  *
    5  * Add factories as needed.
    6  *
    7  * @author <ksherdy at sfu dot ca>
     2 * TODO: KS: Continue to migrate 'locator' based PabloS generators from PabloS to PabloB.
    83 */
    94
     
    127
    138import pabloB.ast.*;
    14 //import pabloB.lexicalAnalyzer.*;
    15 import pabloB.tokens.IntConstantToken;
    16 import pabloB.tokens.LextantToken;
    17 import pabloB.tokens.StringConstantToken;
    18 import pabloB.tokens.Token;
    19 import pabloB.ast.IdentifierNode;
     9import pabloB.tokens.*;
    2010import pabloB.inputHandler.Locator;
    2111import pabloB.lexicalAnalyzer.LexicalType;
    2212import pabloB.tokens.IdentifierToken;
    23 import pabloB.ast.ASTNode;
    24 import pabloB.ast.CompoundIdentifierNode;
    25 import pabloB.ast.FuncCallArgListNode;
    26 import pabloB.ast.FuncCallNode;
     13
    2714import pabloB.lexicalAnalyzer.Lextant;
    28 
    2915import toolchain.pabloB.ast.Accessors;
    3016
     
    119105                        FuncDefNode funcDefNode,
    120106                        FuncDefNode optFuncDefNode,
    121                         Token locationToken) {
    122                
    123                         LextantToken token = Generators.makeLextantToken(Lextant.KERNEL, locationToken);
     107                        Locator locator) {
     108               
     109                        LextantToken token = Generators.makeLextantToken(Lextant.KERNEL, locator);
    124110                        KernelDefNode kernelDefNode = new KernelDefNode(token);
    125                         pabloB.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);           
     111                        pabloB.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);         
    126112                       
    127113                        kernelDefNode.appendChild(identifierNode);
     
    144130        }       
    145131       
    146         public static InitDefNode makeInitDefNode (Token locationToken) {
    147                
    148                 LextantToken initDefToken = Generators.makeLextantToken(Lextant.KERNEL, locationToken);
     132        public static InitDefNode makeInitDefNode (Locator locator) {
     133               
     134                LextantToken initDefToken = Generators.makeLextantToken(Lextant.KERNEL, locator);
    149135                InitDefNode initDefNode = new InitDefNode(initDefToken);
    150136               
    151                 LextantToken initBlockToken = Generators.makeLextantToken(Lextant.LCURLY, locationToken);;
     137                LextantToken initBlockToken = Generators.makeLextantToken(Lextant.LCURLY, locator);
    152138                InitBlockNode initBlockNode = new InitBlockNode(initBlockToken);
    153139               
     
    210196        }
    211197
    212         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode ...args) {
    213                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
     198        public static FuncCallNode makeFuncCallNode(String pckage, String name, Locator locator) {
     199                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(pckage, name, locator);   
     200                return Generators.makeFuncCallNode(compoundIdentifierNode, locator);
     201        }
     202       
     203        public static FuncCallNode makeFuncCallNode(String pckage, String name, Locator locator, ASTNode ...args) {
     204                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(pckage, name, locator);   
     205                FuncCallNode node = Generators.makeFuncCallNode(compoundIdentifierNode, locator);
    214206                Generators.addFuncCallArgs(node, args);
    215207                return node;
    216         }
    217 
    218         public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, List<ASTNode> args) {
    219                
    220                 FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
     208        }       
     209
     210        public static FuncCallNode makeFuncCallNode(String pckage, String name, Locator locator, List<ASTNode> args) {
     211                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(pckage, name, locator);   
     212                FuncCallNode node = Generators.makeFuncCallNode(compoundIdentifierNode, locator);
    221213                Generators.addFuncCallArgs(node, args);
    222214                return node;
    223         }               
    224        
     215        }
     216               
     217        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Locator locator) {
     218                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
     219
     220                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locator);
     221                FuncCallNode FuncCallNode = new FuncCallNode(token);
     222                FuncCallNode.appendChild(identifier);
     223                FuncCallNode.appendChild(new FuncCallArgListNode(token));               // TODO: verify the token is okay for the ArgListNode
     224
     225                return FuncCallNode;
     226        }       
     227               
    225228        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {               
    226229                CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
     
    238241                return FuncCallNode;
    239242        }       
     243
    240244               
    241245        private static void addFuncCallArgs(FuncCallNode node, ASTNode[] args) {
     
    310314        }
    311315       
    312         public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Token locationToken) {
    313                 Token dotToken = Generators.makeLextantToken(Lextant.DOT, locationToken);
     316        public static CompoundIdentifierNode makeCompoundIdentifierNode(String pckage, String name, Locator locator) {
     317                return makeCompoundIdentifierNode(new String [] {pckage, name}, locator);
     318        }
     319       
     320        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from locator.
     321         * Currently, no special consideration with only one identifier in the array.
     322         * (Maybe we can return a IdentifierNode directly in later versions.)
     323         * @param identifiers           all identifiers
     324         * @param locator               a token containing the TextLocation for this new node.
     325         * @return      the new CompoundIdentifierNode
     326         */
     327        public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Locator locator) {
     328                Token dotToken = Generators.makeLextantToken(Lextant.DOT, locator);
    314329                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
    315330                for (String identifier : identifiers) {
    316                         IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);
     331                        IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locator);
    317332                        CompoundIdentifierNode.appendChild(identifierNode);
    318333                }
     
    320335        }
    321336
    322         public static IdentifierNode makeIdentifierNode(String identifier, Token locationToken) {
    323                 IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locationToken);
     337        /** Makes a new LextantToken with the given lextant and location taken from the given locator.
     338         * @param lextant
     339         * @param locator
     340         * @return the new LextantToken
     341         */
     342        public static LextantToken makeLextantToken(Lextant lextant, Locator locator) {
     343                return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
     344        }       
     345       
     346        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
     347         * @param identifier
     348         * @param locator               a token containing the TextLocation for this new node.
     349         * @return      the new IdentifierNode
     350         */
     351        public static IdentifierNode makeIdentifierNode(String identifier, Locator locator) {
     352                IdentifierToken newToken = makeIdentifierToken(identifier, locator);
    324353                return new IdentifierNode(newToken);
    325354        }       
    326355               
    327         public static IdentifierToken makeIdentifierToken(String identifier, Token locationToken) {
    328                 return IdentifierToken.make(LexicalType.IDENTIFIER, locationToken.getLocation(), identifier);
    329         }       
    330        
    331         public static IntegerConstantNode makeIntegerConstantNode(int n, Token locationToken) {
    332                 IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(n,
    333                                 locationToken));
     356        /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
     357         * @param identifier
     358         * @param locator
     359         * @return the new IdentifierToken
     360         */
     361        public static IdentifierToken makeIdentifierToken(String identifier, Locator locator) {
     362                return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
     363        }
     364        public static IntegerConstantNode makeIntegerConstantNode(int n, Locator locator) {
     365                IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(n, locator));
    334366                integerConstantNode.setValue(n);
    335367            return integerConstantNode;
    336368        }       
    337369       
    338         public static IntConstantToken makeIntegerConstantToken(int n, Token locationToken) {
    339                 return  (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
    340         }               
     370        public static IntConstantToken makeIntegerConstantToken(int n,  Locator locator) {
     371                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
     372        }                      
    341373
    342374        private static LextantToken makeLextantToken(Lextant lextant, Token locationToken) {
Note: See TracChangeset for help on using the changeset viewer.