function _processCascade(context, cascade, parentItem) {
      var stackView = parentItem ? parentItem.view : null;
      var subViews = [];
      var curViews = [];
      var subView = void 0;
      if (stackView) {
        cascade.push({ view: stackView });
        curViews.push(stackView);
      }
      for (var i = 0; i < cascade.length; i++) {
        var item = cascade[i];
        if (!Array.isArray(item) && item.hasOwnProperty('view') || Array.isArray(item) && item[0].view && !item[0].relation) {
          var items = Array.isArray(item) ? item : [item];
          for (var z = 0; z < items.length; z++) {
            item = items[z];
            var viewRange = item === ',' ? [] : item.view ? _getRange(item.view, item.range) : [null];
            for (var r = 0; r < viewRange.length; r++) {
              var curView = viewRange[r];
              curViews.push(curView);
    
              //
              // Add this view to the collection of subViews
              //
              if (curView !== stackView) {
                subViews.push(curView);
                subView = context.subViews[curView];
                if (!subView) {
                  subView = { orientations: 0 };
                  context.subViews[curView] = subView;
                }
                subView.orientations = subView.orientations | context.orientation;
                if (subView.stack) {
                  _processStackView(context, curView, subView);
                }
              }
    
              //
              // Process the relationship between this and the previous views
              //
              if (context.prevViews !== undefined && curView !== undefined && context.relation) {
                if (context.relation.relation !== 'none') {
                  for (var p = 0; p < context.prevViews.length; p++) {
                    var prevView = context.prevViews[p];
                    switch (context.orientation) {
                      case Orientation.HORIZONTAL:
                        context.prevAttr = prevView !== stackView ? Attribute.RIGHT : Attribute.LEFT;
                        context.curAttr = curView !== stackView ? Attribute.LEFT : Attribute.RIGHT;
                        break;
                      case Orientation.VERTICAL:
                        context.prevAttr = prevView !== stackView ? Attribute.BOTTOM : Attribute.TOP;
                        context.curAttr = curView !== stackView ? Attribute.TOP : Attribute.BOTTOM;
                        break;
                      case Orientation.ZINDEX:
                        context.prevAttr = Attribute.ZINDEX;
                        context.curAttr = Attribute.ZINDEX;
                        context.relation.constant = !prevView ? 0 : context.relation.constant || 'default';
                        break;
                    }
                    context.constraints.push({
                      view1: prevView,
                      attr1: context.prevAttr,
                      relation: context.relation.relation,
                      view2: curView,
                      attr2: context.curAttr,
                      multiplier: context.relation.multiplier,
                      constant: context.relation.constant === 'default' || !context.relation.constant ? context.relation.constant : -context.relation.constant,
                      priority: context.relation.priority
                    });
                  }
                }
              }
    
              //
              // Process view size constraints
              //
              var constraints = item.constraints;
              if (constraints) {
                for (var n = 0; n < constraints.length; n++) {
                  context.prevAttr = context.horizontal ? Attribute.WIDTH : Attribute.HEIGHT;
                  context.curAttr = constraints[n].view || constraints[n].multiplier ? constraints[n].attribute || context.prevAttr : constraints[n].variable ? Attribute.VARIABLE : Attribute.CONST;
                  context.constraints.push({
                    view1: curView,
                    attr1: context.prevAttr,
                    relation: constraints[n].relation,
                    view2: constraints[n].view,
                    attr2: context.curAttr,
                    multiplier: constraints[n].multiplier,
                    constant: constraints[n].constant,
                    priority: constraints[n].priority
                  });
                }
              }
    
              //
              // Process cascaded data (child stack-views)
              //
              if (item.cascade) {
                _processCascade(context, item.cascade, item);
              }
            }
          }
        } else if (item !== ',') {
          context.prevViews = curViews;
          curViews = [];
          context.relation = item[0];
          if (context.prevViews !== undefined) {
            if (context.relation.equalSpacing) {
              _processEqualSpacer(context, stackView);
            }
            if (context.relation.multiplier) {
              _processProportionalSpacer(context, stackView);
            }
          }
        }
      }
    
      if (stackView) {
        subView = context.subViews[stackView];
        if (!subView) {
          subView = { orientations: context.orientation };
          context.subViews[stackView] = subView;
        } else if (subView.stack) {
          var err = new Error('A stack named "' + stackView + '" has already been created');
          err.column = parentItem.$parserOffset + 1;
          throw err;
        }
        subView.stack = {
          orientation: context.orientation,
          processedOrientations: context.orientation,
          subViews: subViews
        };
        _processStackView(context, stackView, subView);
      }
    }
Recursive helper function that processes the cascaded data.
@private