ICU 56 update step 1

source/common/rbbiscan.cpp

-
 //
 //  file:  rbbiscan.cpp
 //
-//  Copyright (C) 2002-2014, International Business Machines Corporation and others.
+//  Copyright (C) 2002-2015, International Business Machines Corporation and others.
 //  All Rights Reserved.
 //
 //  This file contains the Rule Based Break Iterator Rule Builder functions for
 //   scanning the rules and assembling a parse tree.  This is the first phase
 //   of compiling the rules.
 //
 //  The overall of the rules is managed by class RBBIRuleBuilder, which will
 //  create and use an instance of this class as part of the process.
 //
 
@@ skipping 188 matching lines @@
         pushNewNode(RBBINode::opStart);
         fRuleNum++;
         break;
 
 
     case doExprOrOperator:
         {
             fixOpStack(RBBINode::precOpCat);
             RBBINode  *operandNode = fNodeStack[fNodeStackPtr--];
             RBBINode  *orNode      = pushNewNode(RBBINode::opOr);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             orNode->fLeftChild     = operandNode;
             operandNode->fParent   = orNode;
         }
         break;
 
     case doExprCatOperator:
         // concatenation operator.
         // For the implicit concatenation of adjacent terms in an expression that are
         //   not separated by any other operator.  Action is invoked between the
         //   actions for the two terms.
         {
             fixOpStack(RBBINode::precOpCat);
             RBBINode  *operandNode = fNodeStack[fNodeStackPtr--];
             RBBINode  *catNode     = pushNewNode(RBBINode::opCat);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             catNode->fLeftChild    = operandNode;
             operandNode->fParent   = catNode;
         }
         break;
 
     case doLParen:
         // Open Paren.
         //   The openParen node is a dummy operation type with a low precedence,
         //     which has the affect of ensuring that any real binary op that
         //     follows within the parens binds more tightly to the operands than
@@ skipping 75 matching lines @@
         if (fRB->fDebugEnv && uprv_strstr(fRB->fDebugEnv, "rtree")) {printNodeStack("end of rule");}
 #endif
         U_ASSERT(fNodeStackPtr == 1);
 
         // If this rule includes a look-ahead '/', add a endMark node to the
         //   expression tree.
         if (fLookAheadRule) {
             RBBINode  *thisRule       = fNodeStack[fNodeStackPtr];
             RBBINode  *endNode        = pushNewNode(RBBINode::endMark);
             RBBINode  *catNode        = pushNewNode(RBBINode::opCat);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             fNodeStackPtr -= 2;
             catNode->fLeftChild       = thisRule;
             catNode->fRightChild      = endNode;
             fNodeStack[fNodeStackPtr] = catNode;
             endNode->fVal             = fRuleNum;
             endNode->fLookAheadEnd    = TRUE;
         }
 
         // All rule expressions are ORed together.
         // The ';' that terminates an expression really just functions as a '|' with
         //   a low operator prededence.
         //
         // Each of the four sets of rules are collected separately.
         //  (forward, reverse, safe_forward, safe_reverse)
         //  OR this rule into the appropriate group of them.
         //
         RBBINode **destRules = (fReverseRule? &fRB->fReverseTree : fRB->fDefaultTree);
 
         if (*destRules != NULL) {
             // This is not the first rule encounted.
             // OR previous stuff  (from *destRules)
             // with the current rule expression (on the Node Stack)
             //  with the resulting OR expression going to *destRules
             //
             RBBINode  *thisRule    = fNodeStack[fNodeStackPtr];
             RBBINode  *prevRules   = *destRules;
             RBBINode  *orNode      = pushNewNode(RBBINode::opOr);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             orNode->fLeftChild     = prevRules;
             prevRules->fParent     = orNode;
             orNode->fRightChild    = thisRule;
             thisRule->fParent      = orNode;
             *destRules             = orNode;
         }
         else
         {
             // This is the first rule encountered (for this direction).
             // Just move its parse tree from the stack to *destRules.
@@ skipping 20 matching lines @@
     //
     //  Unary operands  + ? *
     //    These all appear after the operand to which they apply.
     //    When we hit one, the operand (may be a whole sub expression)
     //    will be on the top of the stack.
     //    Unary Operator becomes TOS, with the old TOS as its one child.
     case doUnaryOpPlus:
         {
             RBBINode  *operandNode = fNodeStack[fNodeStackPtr--];
             RBBINode  *plusNode    = pushNewNode(RBBINode::opPlus);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             plusNode->fLeftChild   = operandNode;
             operandNode->fParent   = plusNode;
         }
         break;
 
     case doUnaryOpQuestion:
         {
             RBBINode  *operandNode = fNodeStack[fNodeStackPtr--];
             RBBINode  *qNode       = pushNewNode(RBBINode::opQuestion);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             qNode->fLeftChild      = operandNode;
             operandNode->fParent   = qNode;
         }
         break;
 
     case doUnaryOpStar:
         {
             RBBINode  *operandNode = fNodeStack[fNodeStackPtr--];
             RBBINode  *starNode    = pushNewNode(RBBINode::opStar);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             starNode->fLeftChild   = operandNode;
             operandNode->fParent   = starNode;
         }
         break;
 
     case doRuleChar:
         // A "Rule Character" is any single character that is a literal part
         // of the regular expression.  Like a, b and c in the expression "(abc*) | [:L:]"
         // These are pretty uncommon in break rules; the terms are more commonly
         //  sets.  To keep things uniform, treat these characters like as
         // sets that just happen to contain only one character.
         {
             n = pushNewNode(RBBINode::setRef);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             findSetFor(UnicodeString(fC.fChar), n);
             n->fFirstPos = fScanIndex;
             n->fLastPos  = fNextIndex;
             fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText);
             break;
         }
 
     case doDotAny:
         // scanned a ".", meaning match any single character.
         {
             n = pushNewNode(RBBINode::setRef);
+            if (U_FAILURE(*fRB->fStatus)) {
+                break;
+            }
             findSetFor(UnicodeString(TRUE, kAny, 3), n);
             n->fFirstPos = fScanIndex;
             n->fLastPos  = fNextIndex;
             fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText);
             break;
         }
 
     case doSlash:
         // Scanned a '/', which identifies a look-ahead break position in a rule.
         n = pushNewNode(RBBINode::lookAhead);
+        if (U_FAILURE(*fRB->fStatus)) {
+            break;
+        }
         n->fVal      = fRuleNum;
         n->fFirstPos = fScanIndex;
         n->fLastPos  = fNextIndex;
         fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText);
         fLookAheadRule = TRUE;
         break;
 
 
     case doStartTagValue:
         // Scanned a '{', the opening delimiter for a tag value within a rule.
         n = pushNewNode(RBBINode::tag);
+        if (U_FAILURE(*fRB->fStatus)) {
+            break;
+        }
         n->fVal      = 0;
         n->fFirstPos = fScanIndex;
         n->fLastPos  = fNextIndex;
         break;
 
     case doTagDigit:
         // Just scanned a decimal digit that's part of a tag value
         {
             n = fNodeStack[fNodeStackPtr];
             uint32_t v = u_charDigitValue(fC.fChar);
@@ skipping 90 matching lines @@
 
     case doScanUnicodeSet:
         scanSet();
         break;
 
     default:
         error(U_BRK_INTERNAL_ERROR);
         returnVal = FALSE;
         break;
     }
-    return returnVal;
+    return returnVal && U_SUCCESS(*fRB->fStatus);
 }
 
 
 
 
 //------------------------------------------------------------------------------
 //
 //  Error         Report a rule parse error.
 //                Only report it if no previous error has been recorded.
 //
@@ skipping 470 matching lines @@
         }
 
     }
 
     //
     // If there were NO user specified reverse rules, set up the equivalent of ".*;"
     //
     if (fRB->fReverseTree == NULL) {
         fRB->fReverseTree  = pushNewNode(RBBINode::opStar);
         RBBINode  *operand = pushNewNode(RBBINode::setRef);
+        if (U_FAILURE(*fRB->fStatus)) {
+            return;
+        }
         findSetFor(UnicodeString(TRUE, kAny, 3), operand);
         fRB->fReverseTree->fLeftChild = operand;
         operand->fParent              = fRB->fReverseTree;
         fNodeStackPtr -= 2;
     }
 
 
     //
     // Parsing of the input RBBI rules is complete.
     // We now have a parse tree for the rule expressions
@@ skipping 32 matching lines @@
 
 
 
 //------------------------------------------------------------------------------
 //
 //  pushNewNode   create a new RBBINode of the specified type and push it
 //                onto the stack of nodes.
 //
 //------------------------------------------------------------------------------
 RBBINode  *RBBIRuleScanner::pushNewNode(RBBINode::NodeType  t) {
+    if (U_FAILURE(*fRB->fStatus)) {
+        return NULL;
+    }
     fNodeStackPtr++;
     if (fNodeStackPtr >= kStackSize) {
         error(U_BRK_INTERNAL_ERROR);
         RBBIDebugPuts("RBBIRuleScanner::pushNewNode - stack overflow.");
         *fRB->fStatus = U_BRK_INTERNAL_ERROR;
         return NULL;
     }
     fNodeStack[fNodeStackPtr] = new RBBINode(t);
     if (fNodeStack[fNodeStackPtr] == NULL) {
         *fRB->fStatus = U_MEMORY_ALLOCATION_ERROR;
@@ skipping 69 matching lines @@
         if (fNextIndex >= i) {
             break;
         }
         nextCharLL();
     }
 
     if (U_SUCCESS(*fRB->fStatus)) {
         RBBINode         *n;
 
         n = pushNewNode(RBBINode::setRef);
+        if (U_FAILURE(*fRB->fStatus)) {
+            return;
+        }
         n->fFirstPos = startPos;
         n->fLastPos  = fNextIndex;
         fRB->fRules.extractBetween(n->fFirstPos, n->fLastPos, n->fText);
         //  findSetFor() serves several purposes here:
         //     - Adopts storage for the UnicodeSet, will be responsible for deleting.
         //     - Mantains collection of all sets in use, needed later for establishing
         //          character categories for run time engine.
         //     - Eliminates mulitiple instances of the same set.
         //     - Creates a new uset node if necessary (if this isn't a duplicate.)
         findSetFor(n->fText, n, uset);
     }
 
 }
 
 U_NAMESPACE_END
 
 #endif /* #if !UCONFIG_NO_BREAK_ITERATION */