kc3-lang/angle/src/compiler/translator/ValidateSwitch.cpp

• Show log

  Commit

• Hash : d0bad2c7
  Author :
  Date : 2016-09-09T18:01:16
  

  Split ternary node class from TIntermSelection
  
  Ternary operator nodes are typed parts of expressions, they always
  have two children and the children are also guaranteed to be
  TIntermTyped. "If" selection nodes can't be a part of an expression,
  they can have either one or two children and the children are code
  blocks. Due to all of these differences it makes sense to store these
  using two different AST node classes.
  
  BUG=angleproject:1490
  TEST=angle_unittests
  
  Change-Id: I913ab1d806e3cdb5c21106f078cc9c0b6c72ac54
  Reviewed-on: https://chromium-review.googlesource.com/384512
  Commit-Queue: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/compiler/translator/ValidateSwitch.cpp

• //
  // Copyright (c) 2002-2015 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #include "compiler/translator/ValidateSwitch.h"
  
  #include "compiler/translator/ParseContext.h"
  
  bool ValidateSwitch::validate(TBasicType switchType, TParseContext *context,
      TIntermAggregate *statementList, const TSourceLoc &loc)
  {
      ValidateSwitch validate(switchType, context);
      ASSERT(statementList);
      statementList->traverse(&validate);
      return validate.validateInternal(loc);
  }
  
  ValidateSwitch::ValidateSwitch(TBasicType switchType, TParseContext *context)
      : TIntermTraverser(true, false, true),
        mSwitchType(switchType),
        mContext(context),
        mCaseTypeMismatch(false),
        mFirstCaseFound(false),
        mStatementBeforeCase(false),
        mLastStatementWasCase(false),
        mControlFlowDepth(0),
        mCaseInsideControlFlow(false),
        mDefaultCount(0),
        mDuplicateCases(false)
  {}
  
  void ValidateSwitch::visitSymbol(TIntermSymbol *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
  }
  
  void ValidateSwitch::visitConstantUnion(TIntermConstantUnion *)
  {
      // Conditions of case labels are not traversed, so this is some other constant
      // Could be just a statement like "0;"
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
  }
  
  bool ValidateSwitch::visitBinary(Visit, TIntermBinary *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitUnary(Visit, TIntermUnary *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase    = false;
      return true;
  }
  
  bool ValidateSwitch::visitTernary(Visit, TIntermTernary *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitSelection(Visit visit, TIntermSelection *)
  {
      if (visit == PreVisit)
          ++mControlFlowDepth;
      if (visit == PostVisit)
          --mControlFlowDepth;
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitSwitch(Visit, TIntermSwitch *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      // Don't go into nested switch statements
      return false;
  }
  
  bool ValidateSwitch::visitCase(Visit, TIntermCase *node)
  {
      const char *nodeStr = node->hasCondition() ? "case" : "default";
      if (mControlFlowDepth > 0)
      {
          mContext->error(node->getLine(), "label statement nested inside control flow", nodeStr);
          mCaseInsideControlFlow = true;
      }
      mFirstCaseFound = true;
      mLastStatementWasCase = true;
      if (!node->hasCondition())
      {
          ++mDefaultCount;
          if (mDefaultCount > 1)
          {
              mContext->error(node->getLine(), "duplicate default label", nodeStr);
          }
      }
      else
      {
          TIntermConstantUnion *condition = node->getCondition()->getAsConstantUnion();
          if (condition == nullptr)
          {
              // This can happen in error cases.
              return false;
          }
          TBasicType conditionType = condition->getBasicType();
          if (conditionType != mSwitchType)
          {
              mContext->error(condition->getLine(),
                  "case label type does not match switch init-expression type", nodeStr);
              mCaseTypeMismatch = true;
          }
  
          if (conditionType == EbtInt)
          {
              int iConst = condition->getIConst(0);
              if (mCasesSigned.find(iConst) != mCasesSigned.end())
              {
                  mContext->error(condition->getLine(), "duplicate case label", nodeStr);
                  mDuplicateCases = true;
              }
              else
              {
                  mCasesSigned.insert(iConst);
              }
          }
          else if (conditionType == EbtUInt)
          {
              unsigned int uConst = condition->getUConst(0);
              if (mCasesUnsigned.find(uConst) != mCasesUnsigned.end())
              {
                  mContext->error(condition->getLine(), "duplicate case label", nodeStr);
                  mDuplicateCases = true;
              }
              else
              {
                  mCasesUnsigned.insert(uConst);
              }
          }
          // Other types are possible only in error cases, where the error has already been generated
          // when parsing the case statement.
      }
      // Don't traverse the condition of the case statement
      return false;
  }
  
  bool ValidateSwitch::visitAggregate(Visit visit, TIntermAggregate *)
  {
      if (getParentNode() != nullptr)
      {
          // This is not the statementList node, but some other node.
          if (!mFirstCaseFound)
              mStatementBeforeCase = true;
          mLastStatementWasCase = false;
      }
      return true;
  }
  
  bool ValidateSwitch::visitLoop(Visit visit, TIntermLoop *)
  {
      if (visit == PreVisit)
          ++mControlFlowDepth;
      if (visit == PostVisit)
          --mControlFlowDepth;
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::visitBranch(Visit, TIntermBranch *)
  {
      if (!mFirstCaseFound)
          mStatementBeforeCase = true;
      mLastStatementWasCase = false;
      return true;
  }
  
  bool ValidateSwitch::validateInternal(const TSourceLoc &loc)
  {
      if (mStatementBeforeCase)
      {
          mContext->error(loc,
              "statement before the first label", "switch");
      }
      if (mLastStatementWasCase)
      {
          mContext->error(loc,
              "no statement between the last label and the end of the switch statement", "switch");
      }
      return !mStatementBeforeCase && !mLastStatementWasCase && !mCaseInsideControlFlow &&
          !mCaseTypeMismatch && mDefaultCount <= 1 && !mDuplicateCases;
  }
  

Download