Changeset 2819 for proto


Ignore:
Timestamp:
Jan 20, 2013, 1:21:29 AM (7 years ago)
Author:
ksherdy
Message:

Experimental notion of types.

Location:
proto/pablo
Files:
8 edited

Legend:

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

    r2816 r2819  
    158158       
    159159        expr3           #-> LROUND expr RROUND
     160                                        | stringConstant
    160161                                        | streamConstant
    161                                         | stringConstant
    162162                                        | compoundIdentifier (funcCallRest _promote_)?
    163163                                        ;
  • proto/pablo/output/cpplang/pablo_definitions.hpp

    r2816 r2819  
    1313#define PABLO_DEFINITIONS_HPP
    1414
    15 // Stream struct and function headers and definitions
     15#define LocalCarryDeclare(name, count)\
     16CarryArray<count, 0> name;\
    1617
     18// runtime libraries
    1719#include "../lib/simd-lib/bitblock.hpp"
    1820#include "../lib/simd-lib/carryQ.hpp"
    1921#include "../lib/simd-lib/pabloSupport.hpp"
    2022
    21 #define LocalCarryDeclare(name, count)\
    22 CarryArray<count, 0> name;\
     23// migrate error tracker, line/column tracker to compiler runtime
     24#include "../util/ErrorTracker.h"
     25ErrorTracker error_tracker;
    2326
    24 #define assert_0_error(errkind, errstrm)
    25 
     27#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
    2628BitBlock EOF_mask = simd<1>::constant<1>();
    2729
     
    809811                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    810812                        ctCDPI_mask = carryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(14), 14);
    811                         if (bitblock::any(simd_andc(EOF_mask, ctCDPI_mask)))
    812                         {
    813                                 assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(EOF_mask, ctCDPI_mask));
     813                        if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
     814                        {
     815                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    814816                        }
    815817                        CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(15), 15);
     
    863865                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    864866                                ctCDPI_mask = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
    865                                 if (bitblock::any(simd_andc(EOF_mask, ctCDPI_mask)))
    866                                 {
    867                                         assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(EOF_mask, ctCDPI_mask));
     867                                if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
     868                                {
     869                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    868870                                }
    869871                                CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 12);
  • proto/pablo/src/applicationGenerator/templates/CPP/pablo_definitions.template

    r2809 r2819  
    1313#define PABLO_DEFINITIONS_HPP
    1414
    15 // Stream struct and function headers and definitions
     15#define LocalCarryDeclare(name, count)\
     16CarryArray<count, 0> name;\
    1617
     18// runtime libraries
    1719#include "../lib/simd-lib/bitblock.hpp"
    1820#include "../lib/simd-lib/carryQ.hpp"
    1921#include "../lib/simd-lib/pabloSupport.hpp"
    2022
    21 #define LocalCarryDeclare(name, count)\
    22 CarryArray<count, 0> name;\
     23// migrate error tracker, line/column tracker to compiler runtime
     24#include "../util/ErrorTracker.h"
     25ErrorTracker error_tracker;
    2326
    24 #define assert_0_error(errkind, errstrm)
    25 
     27#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
    2628BitBlock EOF_mask = simd<1>::constant<1>();
    2729
  • proto/pablo/src/compiler/ast/pabloS/Generators.java

    r2816 r2819  
    205205        }
    206206
     207        public static StreamConstantNode makeStreamConstantNode(int n, Token locationToken) {
     208                Token newToken = IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
     209                StreamConstantNode streamConstantNode = new StreamConstantNode(newToken);
     210                streamConstantNode.setValue(n);
     211            return streamConstantNode;
     212        }       
     213       
    207214        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token locationToken) {
    208215                BinaryOperatorNode node = new BinaryOperatorNode(locationToken);
  • proto/pablo/src/compiler/transformer/visitors/AdvanceCombinerXFormer.java

    r2775 r2819  
    5858       
    5959        private int valueOf(ASTNode node) {
    60                 assert node instanceof IntegerConstantNode;
     60                //assert node instanceof IntegerConstantNode;
    6161                IntConstantToken token = (IntConstantToken) node.getToken();
    6262                return token.getValue();
     
    9090                                                        Accessors.funcCallArgsListNode(child));
    9191               
    92                 IntegerConstantNode integerConstantNode = Generators.makeIntegerConstantNode(amount1+amount2, node.getToken());
     92                StreamConstantNode integerConstantNode = Generators.makeStreamConstantNode(amount1+amount2, node.getToken());
    9393                if(Accessors.funcCallArgsListNode(node).nChildren()==1) {
    9494                        Accessors.funcCallArgsListNode(child).appendChild(integerConstantNode);
  • proto/pablo/src/compiler/transformer/visitors/Bitwise2IDISAXFormer.java

    r2816 r2819  
    122122                // public void visitLeave()
    123123               
    124                 private void streamConstant2IDISA(ASTNode node) {
     124                private void streamConstant2IDISA(ASTNode node) {                       
    125125                        if(node instanceof StreamConstantNode) {
    126126                       
  • proto/pablo/src/compiler/transformer/visitors/CarryIntroXFormer.java

    r2816 r2819  
    394394                                ASTNode argNode = Accessors.funcCallArg(node, 1);
    395395                                if(isFinalBlockMode()) {
    396                                         replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);
    397                                                                                
     396                                        replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);                                                                   
    398397                                } else {
    399398                                        replacementNode = Generators.makeSIMDNotFuncCall(argNode, builtins2Lang);
     
    486485                                if(isFinalBlockMode()) {
    487486                                        ASTNode argNode = Accessors.funcCallArg(node, 0);
    488                                         replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);
     487                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    489488                                } else {
    490489                                        replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                 
     
    623622                        CompoundIdentifierNode localCarryQArrayQName   
    624623                                                                = Generators.makeCompoundIdentifierNode(
    625                                                                                 new String [] {CarrySetBuiltins2Lang.LOCALCARRYQNAME, CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME},
     624                                                                                new String [] {CarrySetBuiltins2Lang.LOCALCARRYQNAME,
     625                                                                                                CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME},
    626626                                                                                node.getToken());
    627                        
    628                         CompoundIdentifierNode localCarryQArrayQName =
    629                                         Generators.makeCompoundIdentifierNode(new String [] {CarrySetBuiltins2Lang.LOCALCARRYQNAME,
    630                                                                                                                                                         CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME},
    631                                                                                                                                                         node.getToken());
    632627                       
    633628                        /*
  • proto/pablo/src/pabloS/parser/Parser.java

    r2815 r2819  
    754754                        expect(Lextant.RROUND);
    755755                }
     756                else if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     757                        {
     758                                ASTNode child = parseStringConstant();
     759                                result.appendChild(child);
     760                                allChildren.add(child);
     761                        }
     762                }
    756763                else if( (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) ) {
    757764                        {
    758765                                ASTNode child = parseStreamConstant();
    759                                 result.appendChild(child);
    760                                 allChildren.add(child);
    761                         }
    762                 }
    763                 else if( (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    764                         {
    765                                 ASTNode child = parseStringConstant();
    766766                                result.appendChild(child);
    767767                                allChildren.add(child);
Note: See TracChangeset for help on using the changeset viewer.