Changeset 2796


Ignore:
Timestamp:
Dec 20, 2012, 8:27:32 PM (7 years ago)
Author:
ksherdy
Message:

Compiles against g++ without Pablo while support.

Location:
proto/pablo
Files:
1 added
18 edited
2 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/grammar/scatter/pabloB.scatter

    r2773 r2796  
    44//
    55// PabloBlock (block-at-a-time language)
     6//
     7// TODO - Support '+','-'
     8//
     9//
    610//
    711context main {
  • proto/pablo/input/test/pabloS/py2pablo/parabix2_pablo.pablos

    r2787 r2796  
    1212};
    1313
    14 struct u8{
     14struct U8{
    1515    stream<1> unibyte;
    1616    stream<1> prefix;
     
    269269            var stream<1> u8error3 = (u8.xF0_scope & u8.x80_x8F);
    270270            var stream<1> u8error4 = (u8.xF4_scope & u8.x90_xBF);
    271             u8_error |= (((u8error1 | u8error2) | u8error3) | u8error4);
     271            //u8_error |= (((u8error1 | u8error2) | u8error3) | u8error4);
     272            u8_error = (u8_error | (((u8error1 | u8error2) | u8error3) | u8error4));
    272273            var stream<1> EF_BF_pending = pablo.Advance((u8.xEF_scope & u8.xBF));
    273274            u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
     
    357358    var stream<1> SQuoteDelim = (lex.SQuote | lex.LAngle);
    358359    var stream<1> AttListDelim = (lex.Slash | lex.RAngle);
     360   
     361    var stream<1> EqExpected = 0;
     362    var stream<1> AttListEnd = 0;
     363   
    359364    tag_Callouts.ElemName_starts = (marker.LAngle_scope & (~ lex.Slash));
    360365    tag_Callouts.EndTag_marks = (marker.LAngle_scope & lex.Slash);
     
    367372    if ((tag_Callouts.ElemName_ends & lex.WS)) {
    368373        var stream<1> AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS);
    369         var stream<1> AttListEnd = (AfterWS & AttListDelim);
     374        AttListEnd = (AfterWS & AttListDelim);
    370375        var stream<1> AttNameStart = (AfterWS & (~ AttListDelim));
    371376        while (AttNameStart) {
     
    375380            tag_Callouts.AttName_ends |= AttNameFollow;
    376381            if ((AttNameFollow & lex.WS)) {
    377                 var stream<1> EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
     382                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS);
    378383            }
    379384            else {
    380                 var stream<1> EqExpected = AttNameFollow;
     385                EqExpected = AttNameFollow;
    381386            }
    382387            ParseError |= (EqExpected & (~ lex.Equals));
     
    404409    }
    405410    else {
    406         var stream<1> AttListEnd = (tag_Callouts.ElemName_ends & AttListDelim);
     411        AttListEnd = (tag_Callouts.ElemName_ends & AttListDelim);
    407412        ParseError |= (tag_Callouts.ElemName_ends & (~ AttListDelim));
    408413    }
     
    474479}
    475480
     481/*
    476482function void Main(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, struct Xml_char xml_char, struct Scope1 scope1, struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Masks masks, struct Xml_names xml_names, struct Check_streams check_streams) {
    477483    Classify_bytes_Validate_utf8(basis_bits, lex, u8);
     
    482488    Do_check_streams(marker, tag_Callouts, check_streams);
    483489}
     490*/
  • proto/pablo/runConfigurations/pabloJ.launch

    r2788 r2796  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="applicationGenerator.PabloJ"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${workspace_loc}/pablo/input/test/pabloS/py2pablo/parabix2_pablo.pablos.exclude"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${workspace_loc}/pablo/input/test/pabloS/py2pablo/parabix2_pablo.pablos"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pablo"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pablo/src/applicationGenerator/ApplicationGenerator.java

    r2789 r2796  
    2121public class ApplicationGenerator {
    2222       
    23         public final static String generatedCodeWarning = "// DO NOT MODIFY\n//\n// PabloJ generated code.\n// Modifications will be lost with the next compiler run.\n//\n";
     23        public final static String generatedCodeWarning = "// DO NOT MODIFY\n//\n// Generated code.\n";
    2424       
    2525//  private static final String LOGGING_DIRECTORY          = "logging";
    26     private static final String APPLICATIONS_DIRECTORY     = "applications";
     26//  private static final String APPLICATIONS_DIRECTORY     = "applications";
    2727       
    2828    private CompilerConfig compilerConfig;
     
    3333        public ApplicationGenerator(CompilerConfig applicationConfiguration) {
    3434                pabloS.tokens.Tokens.setPrintLevel(pabloS.tokens.Tokens.Level.FULL);
     35               
     36               
    3537                this.compilerConfig = applicationConfiguration;
    3638                OutputCodeDirectory.setWarningMessage(generatedCodeWarning);
     
    8082                pabloS.ast.ASTNode decoratedTree = pabloSXFormer.xForm();
    8183
     84                //System.exit(0);
     85               
    8286                // Optimized AST transformation
    8387                pabloSXFormer.setFinalBlockMode(true);
     
    96100               
    97101                HeaderTemplateContentsGenerator contentsGenerator =
    98                                 new HeaderTemplateContentsGenerator(pabloBASTTree, symbolTable, outputDirectory, templateFile);
     102                                new HeaderTemplateContentsGenerator((pabloB.ast.ProgramNode)pabloBASTTree, symbolTable, outputDirectory, templateFile);
    99103               
    100104                contentsGenerator.generate();
  • proto/pablo/src/applicationGenerator/CompilerConfigFactory.java

    r2789 r2796  
    44
    55import org.apache.commons.cli.CommandLine;
    6 
    7 
    8 // Generates an application configuration object.
    9 
    10 
    116
    127public class CompilerConfigFactory {
     
    2318       
    2419        if (compilerConfig.targetLang.equals(CompilerConfig.CLANG)) { // C
    25                 compilerConfig.templateFile = cli.getOptionValue("t", "header.template");
     20                compilerConfig.templateFile = cli.getOptionValue("t", "pablo_definitions.template");
    2621                compilerConfig.templateDirectory = cli.getOptionValue("T", CompilerConfig.TEMPLATES_DIRECTORY + "C" + File.separator);
    2722                compilerConfig.outputFile = cli.getOptionValue("o", "code.c");
    2823                //compilerConfig.targetDirectory = cli.getOptionValue("O", CompilerConfig.CLANG);
    2924        } else { // CPP
    30                 compilerConfig.templateFile = cli.getOptionValue("t", "header.template");
     25                compilerConfig.templateFile = cli.getOptionValue("t", "pablo_definitions.template");
    3126                compilerConfig.templateDirectory = cli.getOptionValue("T", CompilerConfig.TEMPLATES_DIRECTORY + "CPP" + File.separator);
    3227                compilerConfig.outputFile = cli.getOptionValue("o", "code.cpp");
  • proto/pablo/src/applicationGenerator/HeaderTemplateContentsGenerator.java

    r2789 r2796  
    33import pabloB.ast.*;
    44
     5import compiler.ast.pabloB.Accessors;
    56import compiler.codeGenerator.visitors.CPPUnparser;
    67import compiler.symbols.SymbolTable;
     
    1112import java.io.File;
    1213import java.io.PrintStream;
     14import java.util.List;
    1315
    1416public class HeaderTemplateContentsGenerator extends TemplateContentsGenerator {
    1517   
    16         public HeaderTemplateContentsGenerator(ASTNode ASTTree,
     18        public HeaderTemplateContentsGenerator(ProgramNode ASTTree,
    1719                        SymbolTable symbolTable,
    1820                        String outputDirectory,
     
    2426               
    2527                 OutputCodeDirectory outputCodeDirectory = new OutputCodeDirectory(outputDirectory);
    26                  String targetFile = replaceFileNameExtension(new File(templateFile).getName(), ".hpp");         
    27                  outputCodeDirectory.generateFile(new HeaderContentsGenerator(), targetFile);                           
    2828                 
    29                  // TODO - Current callback approach *may* cause confusion.
    30        
    31                  /*
    32                         String globalDefinitions = makeGlobalDefinitions();
    33                        
    34                         String baseName = replaceFileNameExtension(new File(templateFile).getName(), "");
    35                        
    36                         Template template = outputCodeDirectory.fileTemplate(baseName, templateFile);
    37                         template.set("warningComment", CompilerConfig.WARNING_MESSAGE);
    38                         template.set("global", globalDefinitions);
    39                        
    40                         PrintStream ps = new PrintStream(System.out);
    41                        
    42                         template.print(ps);
    43                 */
     29                 String targetFileName = replaceFileNameExtension(new File(templateFile).getName(), ".hpp");
     30                 outputCodeDirectory.generateFile(new HeaderContentsGenerator(ASTTree, symbolTable), targetFileName);                           
    4431        }
    4532
    4633        private class HeaderContentsGenerator implements ContentsGenerator {
     34               
     35                private ProgramNode programNode;
     36                private SymbolTable symbolTable;
     37               
     38                public HeaderContentsGenerator(ProgramNode programNode, SymbolTable symbolTable) {
     39                        this.programNode = programNode;
     40                        this.symbolTable = symbolTable;
     41                }
    4742               
    4843                public void generate(PrintStream out, OutputCodeDirectory outputCodeDirectory) {
     
    5853               
    5954                private String makeGlobalDefinitions() {
     55                       
    6056                        CPPUnparser unparser = new CPPUnparser(symbolTable);
    61                         String code = unparser.getCode(ASTTree);                       
     57                       
     58                        StringBuffer codeBuffer = new StringBuffer();
     59
     60                        List<StructTypeNode> structTypeDeclNodes = Accessors.structTypeDeclNodes(programNode);
     61                        for(StructTypeNode structTypeNode : structTypeDeclNodes) {
     62                                codeBuffer.append(unparser.getCode(structTypeNode));
     63                        }                       
     64                       
     65                        List<KernelDefNode> kernelDefNodes = Accessors.kernelDefNodes(programNode);
     66                        for(KernelDefNode kernelDefNode : kernelDefNodes) {
     67                                codeBuffer.append(unparser.getCode(kernelDefNode));
     68                        }
     69                       
     70                        String code = codeBuffer.toString();                   
     71                       
    6272                        return code;
    6373                }
     74        }       
     75       
     76        /*
     77         *      Header per kernel definition.
     78         */
     79        /*
     80        private class HeaderContentsGenerator implements ContentsGenerator {
     81               
     82                private KernelDefNode kernelDefNode = null;
     83                private SymbolTable symbolTable = null;
     84               
     85                public HeaderContentsGenerator(KernelDefNode kernelDefNode, SymbolTable symbolTable) {
     86                        this.kernelDefNode = kernelDefNode;
     87                        this.symbolTable = symbolTable;
     88                }
     89               
     90                public void generate(PrintStream out, OutputCodeDirectory outputCodeDirectory) {
     91                        String globalDefinitions = makeGlobalDefinition();
     92               
     93                        String baseName = replaceFileNameExtension(new File(templateFile).getName(), "");
     94                       
     95                        Template template = outputCodeDirectory.fileTemplate(baseName, templateFile);
     96                        template.set("warningComment", CompilerConfig.WARNING_MESSAGE);
     97                        template.set("global", globalDefinitions);
     98                        template.print(out);
     99                }
     100               
     101                private String makeGlobalDefinition() {
     102                        CPPUnparser unparser = new CPPUnparser(symbolTable);
     103                        String code = unparser.getCode(kernelDefNode);                 
     104                        return code;
     105                }       
    64106        }
     107        */     
    65108       
    66109        public static String replaceFileNameExtension(String fileName, String ext) {
  • proto/pablo/src/applicationGenerator/TemplateContentsGenerator.java

    r2789 r2796  
    66abstract public class TemplateContentsGenerator {
    77   
    8         protected ASTNode ASTTree;
     8        protected ProgramNode ASTTree;
    99        protected SymbolTable symbolTable;
    1010    protected String outputDirectory;
    1111        protected String templateFile;
    1212       
    13         public TemplateContentsGenerator(ASTNode ASTTree,
     13        public TemplateContentsGenerator(ProgramNode ASTTree,
    1414                                                                        SymbolTable symbolTable,
    1515                                                                        String outputDirectory,
  • proto/pablo/src/applicationGenerator/templates/CPP/pablo_definitions.template

    r2789 r2796  
    1 ###@warningComment ###
    2 // header.hpp.templates
    3 //
     1// ###@warningComment ###
     2//
    43// (c) 2012 Robert D. Cameron, Ken Herdy
    54// All rights reserved.
     
    76//
    87//////////////////////////////////////////////////////////////////////////////////////////
    9 // @ global - Global stream structure and stream function declarations.
     8// @ global - Stream structure and stream function declarations.
    109//
    1110//////////////////////////////////////////////////////////////////////////////////////////
     11//
     12#ifndef PABLO_DEFINITIONS_HPP
     13#define PABLO_DEFINITIONS_HPP
     14
     15#define LocalCarryDeclare(name, count)\
     16CarryArray<count, 0> name;\
     17
     18#define assert_0_error(errkind, errstrm)
     19
     20#include <pablo/simd-lib/carryQ.hpp>
     21#include <pablo/simd-lib/bitblock.hpp>
     22
     23BitBlock EOF_mask = simd<1>::constant<1>();
     24
     25// namespace pablo
     26// {
     27
    1228###@global ###
     29
     30// } // pablo namespace
     31
     32#endif // PABLO_DEFINITIONS_HPP
  • proto/pablo/src/compiler/ast/pabloB/Accessors.java

    r2775 r2796  
    11package compiler.ast.pabloB;
     2
     3import java.util.ArrayList;
     4import java.util.List;
    25
    36import compiler.ast.pabloB.Accessors;
     
    1720
    1821        ////////////////////////////////////////////////////////////////////////////
     22        // Program helpers
     23        ////////////////////////////////////////////////////////////////////////////
     24               
     25        public static List<KernelDefNode> kernelDefNodes(ProgramNode node) {
     26                List<KernelDefNode> list = new ArrayList<KernelDefNode>();
     27                for(ASTNode child : node.getChildren()) {
     28                        if (child instanceof KernelDefNode) {
     29                                list.add((KernelDefNode) child);
     30                        }
     31                }
     32                return list;
     33        }
     34       
     35        public static List<StructTypeNode> structTypeDeclNodes(ProgramNode node) {
     36                List<StructTypeNode> list = new ArrayList<StructTypeNode>();
     37                for(ASTNode child: node.getChildren()) {
     38                        if (child instanceof TypeDeclNode) {
     39                                ASTNode type = child.child(0);
     40                                if(type instanceof StructTypeNode) {
     41                                        list.add((StructTypeNode)type);
     42                                }
     43                        }
     44                }
     45                return list;
     46        }
     47       
     48        ////////////////////////////////////////////////////////////////////////////
    1949        // Kernel Definition helpers
    2050        ////////////////////////////////////////////////////////////////////////////
     
    3464                assert hasOptFuncDef(node);
    3565                return (FuncDefNode) node.child(2);
     66        }
     67       
     68        public static String kernelName(KernelDefNode node) {
     69                return Accessors.name(node.child(0));
    3670        }
    3771       
  • proto/pablo/src/compiler/ast/pabloS/Accessors.java

    r2778 r2796  
    2020        // Program (global)
    2121        ////////////////////////////////////////////////////////////////////////////
    22         public static List<StructTypeNode> structTypeDecls(ProgramNode node) {
     22        public static List<StructTypeNode> structTypeDeclNodes(ProgramNode node) {
    2323               
    2424                List<StructTypeNode> structTypeDecls = new ArrayList<StructTypeNode>();
  • proto/pablo/src/compiler/ast/pabloS/Generators.java

    r2778 r2796  
    205205        }
    206206
    207         /** Makes a new BinaryOperatorNode
    208          * @param lhs                   left hand side
    209          * @param rhs                   right hand side
    210          * @param locationToken         a token containing the operation and TextLocation for this new node.
    211          * @return      the new IntegerConstantNode
    212          */
    213         public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token tokenLocation) {
    214                 BinaryOperatorNode node = new BinaryOperatorNode(tokenLocation);
    215                 node.appendChild(lhs);
    216                 node.appendChild(rhs);
     207        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token locationToken) {
     208                BinaryOperatorNode node = new BinaryOperatorNode(locationToken);
     209                node.appendChild(lhs.deepCopy());
     210                node.appendChild(rhs.deepCopy());
    217211                return node;
    218212        }       
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2778 r2796  
    100100                code.addFormattedLine(formatString, carryInfoSet.getCarryCount(), carryInfoSet.getAdvanceNCount());
    101101               
    102                 code.dedentedLine("}");
     102                code.dedentedLine("};");
    103103                       
    104104                return code;
     
    395395                        code.addAll(childResults.get(1),0);
    396396                }
    397                 code.dedentedLine("}");
     397                code.dedentedLine("};");
    398398
    399399                return code;
  • proto/pablo/src/compiler/lang/carry/CarrySetBuiltins2CPP.java

    r2775 r2796  
    1313       
    1414        carry2CPPCode.put(CarrySetBuiltins.CARRYINIT, "CarryArray<%s,%s> carryQ");
    15         carry2CPPCode.put(CarrySetBuiltins.CARRYTEST,"CarryTest");
     15        carry2CPPCode.put(CarrySetBuiltins.CARRYTEST,"PabloJCarryTest");
    1616        carry2CPPCode.put(CarrySetBuiltins.GETCARRYIN,"get_carry_in");
    1717        carry2CPPCode.put(CarrySetBuiltins.GETPENDING64,"get_pending64");
  • proto/pablo/src/compiler/lang/pabloS/Builtins2CPP.java

    r2757 r2796  
    2222        pablo2CPPCode.put(Builtins.EXCLUSIVESPAN, "BitBlock_exclusive_span");   
    2323
    24         pablo2CPPCode.put(Builtins.ADVANCE32, "BitBlock_advance_n_<32>");
    25         pablo2CPPCode.put(Builtins.ADVANCEN, "BitBlock_advance_n_<%d>");
     24        pablo2CPPCode.put(Builtins.ADVANCE32, "BitBlock_advance_n_<%s>");
     25        pablo2CPPCode.put(Builtins.ADVANCEN, "BitBlock_advance_n_<%s>");
    2626
    2727        pablo2CPPCode.put(Builtins.ATEOF, "atEOF");
  • proto/pablo/src/compiler/transformer/PabloSTransformer.java

    r2778 r2796  
    6262               
    6363                pabloS.ast.ASTNode decoratedTree = ASTTree.deepCopy();
    64                
    65             AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(decoratedTree);
    66             advanceCombiner.XForm();
    67                                
    68             AugAssignXFormer AugAssign = new AugAssignXFormer(decoratedTree);
    69                 AugAssign.XForm();
    70                
    71                 CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getCarrySet2Lang());
    72                 carryQIntro.XForm();
    73 
    74                 // Transform
    75                 Pablo2CarryXFormer pablo2CarryXFormer = new Pablo2CarryXFormer(decoratedTree, builtins2Lang, carrySet2Lang);
    76                 pablo2CarryXFormer.XForm(finalBlockMode);               
    77                
    78                 AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(decoratedTree, getBuiltins2Lang());
    79                 assertZeroXFormer.XForm();             
    80            
    81                 Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
    82                 bitwiseToIDISA.XForm();
    8364
    8465                if(isAddDumpStmts()) {
     
    9071                        AssertBitBlockAlignStmtsXFormer assertBitBlockAlignStmtsXFormer = new AssertBitBlockAlignStmtsXFormer(decoratedTree, getBuiltins2Lang()); 
    9172                        assertBitBlockAlignStmtsXFormer.XForm();
    92                 }                                                       
    93                                
     73                }                       
     74               
     75            AugAssignXFormer AugAssign = new AugAssignXFormer(decoratedTree);
     76                AugAssign.XForm();             
     77           
     78            AssertZeroXFormer assertZeroXFormer = new AssertZeroXFormer(decoratedTree, getBuiltins2Lang());
     79                assertZeroXFormer.XForm();                             
     80
     81            AdvanceCombinerXFormer advanceCombiner = new AdvanceCombinerXFormer(decoratedTree);
     82            advanceCombiner.XForm();
     83
     84            CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getCarrySet2Lang());
     85                carryQIntro.XForm();           
     86           
     87                // Dependency on CarryIntroXFormer to count PabloS builtins that produce carry values.
     88                Pablo2CarryXFormer pablo2CarryXFormer = new Pablo2CarryXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
     89                pablo2CarryXFormer.XForm(finalBlockMode);                           
     90                                   
     91                Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
     92                bitwiseToIDISA.XForm();
     93                                               
    9494                return decoratedTree;
     95               
    9596        }
    9697
  • proto/pablo/src/compiler/transformer/visitors/AssertZeroXFormer.java

    r2771 r2796  
    5555                                assert errorCode instanceof StringConstantNode;
    5656                               
     57                                /*
    5758                                ASTNode anyFuncCallNode =
    5859                                                Generators.makeFuncCallNode(BitBlock.ANY.IDISAName(),
    5960                                                                                                                                node.getToken(),                               
    6061                                                                                                                                new ASTNode [] {errorStream});
    61 
     62                                */     
     63                                //ASTNode errorStream = Generators.makeIdentifierNode(errorStream, node.getToken());
     64                               
    6265                                ASTNode assert0FuncCallNode
    6366                                                = Generators.makeFuncCallNode(builtins2Lang.getCode(Builtins.ASSERTZERO),
    6467                                                                                                                                node.getToken(),                               
    65                                                                                                                                 new ASTNode [] {errorStream, errorCode});
     68                                                                                                                                new ASTNode [] {errorStream.deepCopy(), errorCode.deepCopy()});
    6669                               
    6770                               
     
    7073                               
    7174                                IfStmtNode ifStmtNode = Generators.makeIfStmtNode(node.getToken(),
    72                                                                                                                                                                 anyFuncCallNode,
    73                                                                                                                                                                 blockStmt);
     75                                                                                                                                        errorStream.deepCopy(),
     76                                                                                                                                        blockStmt);
    7477                               
    7578                                node.updateSelf(ifStmtNode);
  • proto/pablo/src/compiler/transformer/visitors/AugAssignXFormer.java

    r2770 r2796  
    4949                        if(isAugAssignLextant(node.getToken())) {
    5050                               
    51                                 // TODO: bug here, simply use node.child(0) as lhs may fail if side effect exists.
    5251                                Lextant binaryOperatorLextant = getMappedLextant(node.getToken());
    5352                                String lexeme = binaryOperatorLextant.getPrimaryLexeme();
     
    6059                                                                                                                Lextant.ASSIGN.getPrimaryLexeme(),
    6160                                                                                                                Lextant.ASSIGN);
    62                                 node.setToken(assign);
    63                                                                
    64                                 //Accessors.rhs(node).updateSelf(binaryOperatorNode);
    65                                 node.replaceChild(rhs, binaryOperatorNode);
     61                                node.setToken(assign);                                 
     62                                node.replaceChild(rhs, binaryOperatorNode);     
    6663                        }
    6764                }
  • proto/pablo/src/compiler/transformer/visitors/Bitwise2IDISAXFormer.java

    r2770 r2796  
    3434                public void visitLeave(BinaryOperatorNode node) {
    3535                        Token token = node.getToken();
     36                       
    3637                        if(token.isLextant(Lextant.AND, Lextant.OR, Lextant.XOR)) {
    3738                                FuncCallNode funcCallNode = null;
     
    6263                                }
    6364                               
     65                                //funcCallNode.setParent(node.getParent());
     66                                //node = (BinaryOperatorNode)funcCallNode;
     67                               
    6468                                node.updateSelf(funcCallNode);
    65                         }
     69                               
     70                                //System.out.println(funcCallNode);
     71                               
     72                        }               
     73                       
    6674                }
    6775        }       
  • proto/pablo/src/compiler/transformer/visitors/Pablo2CarryXFormer.java

    r2778 r2796  
    118118        //                    return c                 
    119119                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName(), Builtins.ADVANCE.argCount())) {         
     120                               
     121                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     122                               
    120123                                replaceFuncCallNode(node,
    121124                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
    122125                                                builtins2Lang.getCode(Builtins.ADVANCE),
     126                                                arguments,
    123127                                                carryCall,
    124128                                                currentCarry);
     
    133137        //      return c                                                       
    134138                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloName(), Builtins.SCANTHRU.argCount())) {                           
    135                                 replaceFuncCallNode(node,
    136                                                 CarrySetBuiltins.CarryQ_IDENTIFIER,
    137                                                 builtins2Lang.getCode(Builtins.SCANTHRU),
     139                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     140                               
     141                                replaceFuncCallNode(node,
     142                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
     143                                                builtins2Lang.getCode(Builtins.SCANTHRU),
     144                                                arguments,
    138145                                                carryCall,
    139146                                                currentCarry);
     
    149156                       
    150157                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
     158                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     159                               
    151160                                replaceFuncCallNode(node,
    152161                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
    153162                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
     163                                                arguments,
    154164                                                carryCall,
    155165                                                currentCarry);
     
    164174        //      return c               
    165175                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloName(), Builtins.SPANUPTO.argCount())) {
     176                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     177                               
    166178                                replaceFuncCallNode(node,
    167179                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
    168180                                                builtins2Lang.getCode(Builtins.SPANUPTO),
     181                                                arguments,
    169182                                                carryCall,
    170183                                                currentCarry);                         
     
    187200                                }
    188201                               
    189                                 replaceFuncCallNode(node,
    190                                                 CarrySetBuiltins.CarryQ_IDENTIFIER,
    191                                                 builtins2Lang.getCode(Builtins.ADVANCETHENSCANTO),
     202                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     203                               
     204                                replaceFuncCallNode(node,
     205                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
     206                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
     207                                                arguments,
    192208                                                carryCall,
    193209                                                currentCarry);
     
    205221       
    206222                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloName(), Builtins.INCLUSIVESPAN.argCount())) {
    207                                 replaceFuncCallNode(node,
    208                                                 CarrySetBuiltins.CarryQ_IDENTIFIER,
    209                                                 builtins2Lang.getCode(Builtins.INCLUSIVESPAN),
     223                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     224                               
     225                                replaceFuncCallNode(node,
     226                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
     227                                                builtins2Lang.getCode(Builtins.INCLUSIVESPAN),
     228                                                arguments,
    210229                                                carryCall,
    211230                                                currentCarry);
     
    223242       
    224243                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloName(), Builtins.EXCLUSIVESPAN.argCount())) {
    225                                 replaceFuncCallNode(node,
    226                                                 CarrySetBuiltins.CarryQ_IDENTIFIER,
    227                                                 builtins2Lang.getCode(Builtins.EXCLUSIVESPAN),
     244                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     245                               
     246                                replaceFuncCallNode(node,
     247                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
     248                                                builtins2Lang.getCode(Builtins.EXCLUSIVESPAN),
     249                                                arguments,
    228250                                                carryCall,
    229251                                                currentCarry);
     
    248270                                        Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);                                   
    249271                                }
    250                                 replaceFuncCallNode(node,
    251                                                 CarrySetBuiltins.CarryQ_IDENTIFIER,
    252                                                 builtins2Lang.getCode(Builtins.SCANTO),
     272                               
     273                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     274                               
     275                                replaceFuncCallNode(node,
     276                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
     277                                                builtins2Lang.getCode(Builtins.SCANTHRU),
     278                                                arguments,
    253279                                                carryCall,
    254280                                                currentCarry);
     
    266292                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
    267293        //                      if(finalBlockMode) {
    268         //                             
     294        //                              // TODO - Wrap within simd_andc(scan_class, EOF_mask)
    269295        //                      }
     296                               
     297                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     298                               
    270299                                replaceFuncCallNode(node,
    271300                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
    272301                                                builtins2Lang.getCode(Builtins.SCANTOFIRST),
     302                                                arguments,
    273303                                                carryCall,
    274304                                                currentCarry);
     
    285315                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
    286316                                // TODO ==> Verify implementation.
     317                               
     318                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     319                               
    287320                                replaceFuncCallNode(node,
    288321                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
    289322                                                builtins2Lang.getCode(Builtins.ADVANCE32),
     323                                                arguments,
    290324                                                advNCall,
    291325                                                currentAdvN);
     
    301335                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloName(), Builtins.ADVANCEN.argCount())) {
    302336                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
    303                                 // TODO - Verify implementation.
    304                                 replaceFuncCallNode(node,
    305                                                 CarrySetBuiltins.CarryQ_IDENTIFIER,
    306                                                 builtins2Lang.getCode(Builtins.ADVANCE32),
     337                               
     338                                ASTNode formatValue = Accessors.funcCallArg(node, 1);
     339                                String value = Accessors.integerConstant((IntegerConstantNode)formatValue);
     340                               
     341                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     342                               
     343                                String formattedAdvanceN = String.format(builtins2Lang.getCode(Builtins.ADVANCEN), value);
     344                               
     345                                replaceFuncCallNode(node,
     346                                                CarrySetBuiltins.CarryQ_IDENTIFIER,
     347                                                formattedAdvanceN,
     348                                                arguments.subList(0, arguments.size()-1),
    307349                                                advNCall,
    308350                                                currentAdvN);           
     
    369411                                       
    370412                // Helpers             
    371                 private void replaceFuncCallNode(FuncCallNode node, String targetPackage, String targetName,
     413                private void replaceFuncCallNode(FuncCallNode node,
     414                                String targetPackage, String targetName,
     415                                List<ASTNode> arguments,
    372416                                ASTNode call, IntegerConstantNode carry) {
    373417                        FuncCallNode replacementNode;
    374418
    375419                        List<ASTNode> args = new ArrayList<ASTNode>();
    376                                                
    377                         for(ASTNode arg : Accessors.funcCallArgsListNode(node).getChildren()) {
     420                                                                       
     421                        for(ASTNode arg : arguments) {
    378422                                args.add(arg);
    379423                        }       
  • proto/pablo/src/pabloS/ast/ASTNode.java

    r2767 r2796  
    8181                return parent;
    8282        }
    83         protected void setParent(ASTNode parent) {
     83        public void setParent(ASTNode parent) {
    8484                this.parent = parent;
    8585        }
     
    112112        public void replaceChild(ASTNode node, ASTNode replacement) {
    113113                int index = children.indexOf(node);
    114                
    115                
    116                
    117114                replaceChild(index, replacement);
    118115        }
Note: See TracChangeset for help on using the changeset viewer.