Changeset 3359 for proto/pabloj


Ignore:
Timestamp:
Jun 26, 2013, 3:15:51 PM (6 years ago)
Author:
ksherdy
Message:

svn blues, partial commits

Location:
proto/pabloj/trunk/src/toolchain/pabloS/ast
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3347 r3359  
    11/*
    2  * PabloS AST accessors and helpers.
     2 * PabloS AST accessor methods.
    33 *
    44 * @author <ksherdy at sfu dot ca>
    55 *
    6  * KH: TODO: Add name() calls in a similar fashion as PabloB accessors.
    7  *
    86 */
    9 
    107package toolchain.pabloS.ast;
    118
     
    1916
    2017        ////////////////////////////////////////////////////////////////////////////
    21         //
    22         // Narrowest node type returned whenever possible. ASTNode type otherwise.
    23         //
    24         // WARNING: Add addition methods as needed. Avoid hard coding child index
    25         //                      values in general compiler code. Use the accessor methods of
    26         //                      this class.
    27         //
    28         ////////////////////////////////////////////////////////////////////////////
    29 
    30         ////////////////////////////////////////////////////////////////////////////
    3118        // Program
    3219        ////////////////////////////////////////////////////////////////////////////
    33                
    3420        public static List<StructDeclNode> structDeclNodes(ProgramNode node) {
    3521               
     
    6147                return 0 == node.nChildren();
    6248        }
    63                
    64         /*
    65         public static boolean hasDeclList(TypeDeclNode node) {
    66 
    67                 if (node.nChildren() > 1) {
    68                         ASTNode child = node.child(1);
    69                         assert child instanceof DeclListNode;
    70                         return true;
    71                 }
    72                 return false;
    73         }
    74         */
    7549
    7650        public static boolean isAssignmentRhs(ASTNode node) {
     
    141115        }       
    142116
    143         public static String varDeclName(VarDeclNode node) {
    144         return identifier(node).getToken().getLexeme();
    145     }
     117        public static ASTNode nameNode(VarDeclNode node) {
     118            return node.child(1);
     119        }
    146120       
    147121        ////////////////////////////////////////////////////////////////////////////
     
    214188        public static ASTNode typeNode(FuncDefNode node) {
    215189                return node.child(0);
     190        }
     191        public static ASTNode nameNode(FuncDefNode node) {
     192            return node.child(1);
    216193        }
    217194        public static Type type(FuncDefNode node) {
     
    269246                return node.child(0);
    270247        }
     248       
     249        public static ASTNode nameNode(ParameterNode node) {
     250            return node.child(1);
     251        }
     252       
    271253        public static Type declarationType(ParameterNode node) {
    272254                ASTNode typeNode = typeNode(node);
     
    276258                return (IdentifierNode)(node.child(1));
    277259        }
    278         public static String variableName(ParameterNode node) {
    279                 return lexeme(variableNode(node));
    280         }
    281260
    282261        ////////////////////////////////////////////////////////////////////////////
     
    286265                return node.child(0);
    287266        }
     267    public static ASTNode nameNode(StructMemberNode node) {
     268        return node.child(1);
     269    }
    288270        public static Type declarationType(StructMemberNode node) {
    289271                ASTNode typeNode = typeNode(node);
    290272                return typeNode.getType();
    291273        }
    292         public static IdentifierNode variableNode(StructMemberNode node) {
    293                 return (IdentifierNode)(node.child(1));
    294         }
    295         public static String variableName(StructMemberNode node) {
    296                 return lexeme(variableNode(node));
    297         }
    298 
     274       
    299275        ////////////////////////////////////////////////////////////////////////////
    300276        // FuncCallNode
     
    325301                return Accessors.argsListNode(node).getChildren();
    326302        }
    327     public static String funcCallName(ASTNode node) {
     303    public static String funcCallName(ASTNode node) { // special case
    328304        String name = new String();
    329305        if(node instanceof IdentifierNode) {
     
    342318        return name;
    343319    }   
     320   
     321    public static String baseName(CompoundIdentifierNode node) {
     322        ASTNode member = node.child(node.nChildren()-1);
     323        return Accessors.name(member);
     324    }
    344325
    345326        public static List<Type> argumentTypes(FuncCallNode node) {
     
    350331        // StructDeclNode
    351332        ////////////////////////////////////////////////////////////////////////////
    352         public static String structName(StructDeclNode node) {
    353         String name = new String();
    354         name = Accessors.name((IdentifierNode)node.child(0));
    355         return name;
     333        public static ASTNode nameNode(StructDeclNode node) {
     334            return node.child(0);
    356335        }
    357336
     
    361340        return (StructDeclBodyNode) child;
    362341        }       
    363        
    364 //      public static boolean hasStructBody(StructTypeNode node) {
    365 //              if (node.nChildren() > 1) {
    366 //                      ASTNode child = node.child(1);
    367 //                      assert child instanceof StructTypeBodyNode;
    368 //                      return true;
    369 //              }
    370 //              return false;
    371 //      }       
    372        
    373         public static String structMemberName(StructMemberNode node) {
    374         return Accessors.name((IdentifierNode)node.child(1));
    375         }       
    376342
    377343        ////////////////////////////////////////////////////////////////////////////
     
    379345        ////////////////////////////////////////////////////////////////////////////
    380346
    381         public static IdentifierNode nameNode(StructTypeNode node) {
    382                 return (IdentifierNode)(node.child(0));
    383         }
    384         public static String structName(StructTypeNode node) {
    385                 return lexeme(nameNode(node));
     347        public static ASTNode nameNode(StructTypeNode node) {
     348                return node.child(0);
    386349        }
    387350       
     
    434397                return (IdentifierNode)compound.child(0);
    435398        }
    436         public static String funcName(CompoundIdentifierNode compound) {
    437             IdentifierNode funcNameNode = funcNameNode(compound);
    438                 return name(funcNameNode);
    439         }
     399
    440400        public static IdentifierNode funcNameNode(CompoundIdentifierNode compound) {
    441401                return (IdentifierNode)compound.child(1);
     
    455415        // any node
    456416        ////////////////////////////////////////////////////////////////////////////
     417        public static String name(ASTNode node) {
     418            if(node instanceof IdentifierNode) {
     419                return name((IdentifierNode) node);
     420            } else if(node instanceof CompoundIdentifierNode) {
     421                return name((CompoundIdentifierNode) node);
     422            } else if(node instanceof FuncCallNode) {
     423                return funcCallName(nameNode((FuncCallNode)node)); // special case
     424            } else if(node instanceof FuncDefNode) {
     425                return name(nameNode((FuncDefNode)node));
     426            } else if(node instanceof StructDeclNode) {
     427                return name(nameNode((StructDeclNode)node));
     428            } else if(node instanceof StructMemberNode) {
     429                return name(nameNode((StructMemberNode)node));
     430            } else if(node instanceof StructTypeNode) {
     431                return name(nameNode((StructTypeNode)node));
     432            }  else if(node instanceof VarDeclNode) {
     433                return name(nameNode((VarDeclNode)node));
     434            }  else if(node instanceof ParameterNode) {
     435                return name(nameNode((ParameterNode)node));
     436            }
     437            assert false : "Accessors.name(ASTNode node) method not implemented on node class : " + node.getClass();
     438            return null;
     439        }
    457440        public static String lexeme(ASTNode node) {
    458441                return node.getToken().getLexeme();
     
    471454                }
    472455                return result;
    473         }
    474            
     456        }           
    475457}
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3347 r3359  
    1616import pabloS.tokens.*;
    1717
    18 import toolchain.pabloB.lang.idisa.*; // TODO - IDISA builtins
     18import toolchain.pabloB.lang.idisa.*;
    1919import toolchain.pabloS.lang.*;
    2020import toolchain.pabloS.lang.carrySet.CarrySetBuiltin;
    2121
    22 import toolchain.pabloS.transformer.visitors.carry.Context;
     22import toolchain.pabloS.transformer.visitors.pabloS2PabloB.Context;
    2323
    2424public class Generators {
     
    367367    }
    368368   
     369    public static BinaryOperatorNode makeBitwiseOrCarryTest(ASTNode condition,
     370            int carryBase,
     371            int carryCount,
     372            Context context) {
     373        Locator location = (Locator)condition;
     374       
     375        ASTNode carryBaseNode  = Generators.leaf(carryBase, location);
     376        ASTNode carryCountNode = Generators.leaf(carryCount, location);
     377        ASTNode carryRange = Generators.makeFuncCallNode(
     378                                location,
     379                                context.getCarrySetIdentifier(),
     380                                context.getCarrySetEncoder().getName(CarrySetBuiltin.CARRYRANGE),
     381                                Generators.arguments(carryBaseNode, carryCountNode));
     382
     383        LextantToken or = Generators.makeLextantToken(condition, Lextant.OR);
     384        return Generators.makeBinaryOperatorNode(condition, carryRange, or);
     385    }
     386   
    369387    public static IntegerConstantNode leaf(int n, Locator locator) {
    370388        return Generators.makeIntegerConstantNode(locator, n);
Note: See TracChangeset for help on using the changeset viewer.