Changeset 1262


Ignore:
Timestamp:
Aug 3, 2011, 10:46:39 AM (8 years ago)
Author:
shermer
Message:

Fixed problem with instantiating lexical structs even when those structs weren't produced.

Location:
proto/pebble/trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • proto/pebble/trunk/inputs/input-11.pbl

    r1261 r1262  
    2424       
    2525        if v & d | x not allone then {
    26                 x = [abc]
    27                 y = >[cd]
    28                 z = "r[st]u[vw]"
     26#               x = [abc]
     27#               y = >[cd]
     28#               z = "r[st]u[vw]"
    2929                g = a +> d
    3030                h = x1
     
    3232        else {
    3333                m = 1
    34                 y = >>>>[cd]
     34                while m not allzero {
     35#                       y = >>>>[cd]
     36#                       y = "pqr"
     37                        y = "p"
     38                        m = 0
     39                }
    3540                f = r <> m
    3641                g = x2
  • proto/pebble/trunk/src/lexicalStream/LexicalCollector.java

    r1261 r1262  
    299299
    300300        private void insertShiftedStruct(SymbolTable symbolTable) {
    301                 List<CharClassPositionsPair> filteredPairs = condenseDescendentCCPairs();
     301                List<CharClassPositionsPair> filteredPairs = condenseDescendantCCPairs();
    302302                if(filteredPairs.size()==0) {
    303303                        return;
     
    329329                return result;
    330330        }
    331         private List<CharClassPositionsPair> descendentCCPairs() {
     331        private List<CharClassPositionsPair> descendantCCPairs() {
    332332                List<CharClassPositionsPair> result = new ArrayList<CharClassPositionsPair>(ccPairs.values());
    333333
    334334                for(LexicalCollector child: children) {
    335                         result.addAll(child.descendentCCPairs());
    336                 }
    337                 return result;
    338         }
    339 
    340         private List<CharClassPositionsPair> condenseDescendentCCPairs() {
    341                 List<CharClassPositionsPair> descendentPairs = descendentCCPairs();
     335                        result.addAll(child.descendantCCPairs());
     336                }
     337                return result;
     338        }
     339
     340        private List<CharClassPositionsPair> condenseDescendantCCPairs() {
     341                List<CharClassPositionsPair> descendantPairs = descendantCCPairs();
    342342                Map<String, CharClassPositionsPair> filteredPairsMap =
    343343                        new HashMap<String, CharClassPositionsPair>();
    344344               
    345                 for(CharClassPositionsPair pair: descendentPairs) {
     345                for(CharClassPositionsPair pair: descendantPairs) {
    346346                        CharClassDescriptor descriptor = pair.descriptor;
    347347                        String specifier = descriptor.getSpecifier();
     
    369369                return result;
    370370        }
     371
     372        ///////////////////////////////////////////////////////////
     373        // Checking to see if each of the three types of streams
     374        // are present.  This is hopefully faster than recomputing
     375        // them all, as in insertSequencesStruct, etc. above
     376        ///////////////////////////////////////////////////////////
     377       
     378        public boolean hasDescendantLex() {
     379                if(!unshiftedPairs().isEmpty())
     380                        return true;
     381                for(LexicalCollector child: children) {
     382                        if(child.hasDescendantLex()) {
     383                                return true;
     384                        }
     385                }
     386                return false;
     387        }
     388        public boolean hasDescendantShift() {
     389                if(!shiftedPairs().isEmpty())
     390                        return true;
     391                for(LexicalCollector child: children) {
     392                        if(child.hasDescendantShift()) {
     393                                return true;
     394                        }
     395                }
     396                return false;
     397        }
     398        public boolean hasDescendantSeq() {
     399                if(!sqStreams.isEmpty())
     400                        return true;
     401                for(LexicalCollector child: children) {
     402                        if(child.hasDescendantSeq()) {
     403                                return true;
     404                        }
     405                }
     406                return false;
     407        }
     408        private List<CharClassPositionsPair> unshiftedPairs() {
     409                List<CharClassPositionsPair> result = new ArrayList<CharClassPositionsPair>();
     410                for(CharClassPositionsPair pair : ccPairs.values()) {
     411                        if(pair.positions.contains(zero)) {
     412                                if(pair.positions.size()>1) {
     413                                        CharClassPositionsPair newPair = new CharClassPositionsPair();
     414                                        newPair.positions = new HashSet<Position>();
     415                                        newPair.positions.add(zero);
     416                                        newPair.descriptor = pair.descriptor;
     417                                        result.add(newPair);
     418                                }
     419                                else {
     420                                        result.add(pair);
     421                                }
     422                        }
     423                }
     424                return result;
     425        }
     426        private List<CharClassPositionsPair> shiftedPairs() {
     427                List<CharClassPositionsPair> result = new ArrayList<CharClassPositionsPair>();
     428                for(CharClassPositionsPair pair : ccPairs.values()) {
     429                        if(pair.positions.contains(zero) && pair.positions.size()==1) {
     430                                        continue;
     431                        }
     432                       
     433                        if(pair.positions.contains(zero)) {
     434                                CharClassPositionsPair newPair = new CharClassPositionsPair();
     435                                newPair.positions = new HashSet<Position>(pair.positions);
     436                                newPair.positions.remove(zero);
     437                                newPair.descriptor = pair.descriptor;
     438                                result.add(newPair);
     439                        }
     440                        else {
     441                                result.add(pair);
     442                        }
     443                }
     444                return result;
     445        }
     446
     447       
     448        ///////////////////////////////////////////////////////////
     449        // Comparators for sorting Descriptors and Pairs
     450        ///////////////////////////////////////////////////////////
    371451        @SuppressWarnings("unused")
    372452        private class sqDescriptorSortByVar implements Comparator<SequenceDescriptor> {
  • proto/pebble/trunk/src/lexicalStream/MoveLexdefsToBranchStarts.java

    r1261 r1262  
    4141                }
    4242                private void insertInstances(AST node) {
    43                         AST lex = instanceAST("lex", "Lex");
    44                         AST seq = instanceAST("seq", "Seq");
    45                         AST shift = instanceAST("shift", "Shift");
     43                        ProgramBlockASTN parent = (ProgramBlockASTN)node.getParent();
     44                        LexicalCollector collector = parent.getCollector();
    4645                       
    47                         node.insertChild(shift);        // TODO: this is overkill and error if there is no Lex, Seq, or Shift
    48                         node.insertChild(seq);
    49                         node.insertChild(lex);
     46                        if(collector.hasDescendantSeq()) {
     47                                AST seq = instanceAST("seq", "Seq");
     48                                node.insertChild(seq);
     49                        }
     50                        if(collector.hasDescendantShift()) {
     51                                AST shift = instanceAST("shift", "Shift");
     52                                node.insertChild(shift);
     53                        }
     54                        if(collector.hasDescendantLex()) {
     55                                AST lex = instanceAST("lex", "Lex");
     56                                node.insertChild(lex);
     57                        }
    5058                }
    5159                private AST instanceAST(String instanceName, String structName) {
     
    8593                public void visitLeave(ProgramBlockASTN node) {
    8694                        // no streams to insert.  Collector is used as root of collector tree.
     95                       
     96                        // this is here rather than in ExecutionBlockASTN because
     97                        // we want to wait until the end of all ExecutionBlocks.
     98                        for(AST child: node.children()) {
     99                                if(child instanceof ExecutionBlockASTN) {
     100                                        insertInstances(child);
     101                                }
     102                        }
    87103                }
    88104                public void visitLeave(ExecutionBlockASTN node) {
    89105                        insertLexicalStreams(node);
    90                         insertInstances(node);
    91106                }
    92107                public void visitLeave(BlockStatementASTN node) {
Note: See TracChangeset for help on using the changeset viewer.