verilog/analysis/checkers/explicit_begin_rule.cc - third_party/verible - Git at Google

 // Copyright 2017-2020 The Verible Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "verilog/analysis/checkers/explicit_begin_rule.h"

 #include <set>

 #include "absl/base/attributes.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "common/analysis/lint_rule_status.h"
 #include "common/analysis/token_stream_lint_rule.h"
 #include "common/text/config_utils.h"
 #include "common/text/token_info.h"
 #include "verilog/analysis/descriptions.h"
 #include "verilog/analysis/lint_rule_registry.h"
 #include "verilog/parser/verilog_token_enum.h"

 namespace verilog {
 namespace analysis {

 using verible::LintRuleStatus;
 using verible::LintViolation;
 using verible::TokenInfo;
 using verible::TokenStreamLintRule;

 // Register the lint rule
 VERILOG_REGISTER_LINT_RULE(ExplicitBeginRule);

 static const char kMessage[] =
     " block constructs shall explicitly use begin/end.";

 const LintRuleDescriptor &ExplicitBeginRule::GetDescriptor() {
   static const LintRuleDescriptor d{
       .name = "explicit-begin",
       .topic = "explicit-begin",
       .desc =
           "Checks that a Verilog ``begin`` directive follows all "
           "if, else, always, always_comb, always_latch, always_ff, "
           "for, forever, foreach, while and initial statements.",
       .param =
           {
               {"if_enable", "true",
                "All if statements require an explicit begin-end block"},
               {"else_enable", "true",
                "All else statements require an explicit begin-end block"},
               {"always_enable", "true",
                "All always statements require an explicit begin-end block"},
               {"always_comb_enable", "true",
                "All always_comb statements require an explicit begin-end "
                "block"},
               {"always_latch_enable", "true",
                "All always_latch statements require an explicit begin-end "
                "block"},
               {"always_ff_enable", "true",
                "All always_ff statements require an explicit begin-end block"},
               {"for_enable", "true",
                "All for statements require an explicit begin-end block"},
               {"forever_enable", "true",
                "All forever statements require an explicit begin-end block"},
               {"foreach_enable", "true",
                "All foreach statements require an explicit begin-end block"},
               {"while_enable", "true",
                "All while statements require an explicit begin-end block"},
               {"initial_enable", "true",
                "All initial statements require an explicit begin-end block"},
           },
   };
   return d;
 }

 absl::Status ExplicitBeginRule::Configure(absl::string_view configuration) {
   using verible::config::SetBool;
   return verible::ParseNameValues(
       configuration,
       {
           {"if_enable", SetBool(&if_enable_)},
           {"else_enable", SetBool(&else_enable_)},
           {"always_enable", SetBool(&always_enable_)},
           {"always_comb_enable", SetBool(&always_comb_enable_)},
           {"always_latch_enable", SetBool(&always_latch_enable_)},
           {"always_ff_enable", SetBool(&always_ff_enable_)},
           {"for_enable", SetBool(&for_enable_)},
           {"forever_enable", SetBool(&forever_enable_)},
           {"foreach_enable", SetBool(&foreach_enable_)},
           {"while_enable", SetBool(&while_enable_)},
           {"initial_enable", SetBool(&initial_enable_)},
       });
 }

 bool ExplicitBeginRule::IsTokenEnabled(const TokenInfo &token) {
   switch (token.token_enum()) {
     case TK_if:
       return if_enable_;
     case TK_else:
       return else_enable_;
     case TK_always:
       return always_enable_;
     case TK_always_comb:
       return always_comb_enable_;
     case TK_always_latch:
       return always_latch_enable_;
     case TK_always_ff:
       return always_ff_enable_;
     case TK_for:
       return for_enable_;
     case TK_forever:
       return forever_enable_;
     case TK_foreach:
       return foreach_enable_;
     case TK_while:
       return while_enable_;
     case TK_initial:
       return initial_enable_;
     default:
       return false;
   }
 }

 bool ExplicitBeginRule::HandleTokenStateMachine(const TokenInfo &token) {
   // Responds to a token by updating the state of the analysis.
   bool raise_violation = false;
   switch (state_) {
     case State::kNormal: {
       // Special handling for constraints
       switch (token.token_enum()) {
         case TK_constraint: {
           constraint_expr_level_ = 0;
           state_ = State::kConstraint;
           return false;
         }
         case TK_with: {
           constraint_expr_level_ = 0;
           state_ = State::kInlineConstraint;
           return false;
         }
         default: {
           // Do nothing
           break;
         }
       }

       if (!IsTokenEnabled(token)) {
         break;
       }

       switch (token.token_enum()) {
         // After token expect "begin"
         case TK_always_comb:
           ABSL_FALLTHROUGH_INTENDED;
         case TK_always_latch:
           ABSL_FALLTHROUGH_INTENDED;
         case TK_forever:
           ABSL_FALLTHROUGH_INTENDED;
         case TK_initial:
           start_token_ = token;
           state_ = State::kExpectBegin;
           break;
         // After token expect a "condition" followed by "begin". NOTE: there may
         // be tokens prior to the condition (like in an "always_ff" statement)
         // and these are all ignored.
         case TK_if:
           ABSL_FALLTHROUGH_INTENDED;
         case TK_always_ff:
           ABSL_FALLTHROUGH_INTENDED;
         case TK_for:
           ABSL_FALLTHROUGH_INTENDED;
         case TK_foreach:
           ABSL_FALLTHROUGH_INTENDED;
         case TK_while:
           condition_expr_level_ = 0;
           start_token_ = token;
           state_ = State::kInCondition;
           break;
         // always gets special handling, as somtimes there is a "condition" or
         // not before a "begin".
         case TK_always:
           condition_expr_level_ = 0;
           start_token_ = token;
           state_ = State::kInAlways;
           break;
         // else is also special as "if" or "begin" can follow
         case TK_else:
           start_token_ = token;
           state_ = State::kInElse;
           break;
         default:
           // Do nothing
           break;
       }
       break;
     }
     case State::kInAlways: {
       // always is a little more complicated in that it can be immediately
       // followed by a "begin" or followed by some special characters ("@" or
       // "*") and maybe a condition.
       switch (token.token_enum()) {
         case '@':
           break;
         case '*':
           break;
         case TK_begin:
           state_ = State::kNormal;
           break;
         case '(':
           condition_expr_level_++;
           state_ = State::kInCondition;
           break;
         default:
           raise_violation = true;
           break;
       }
       break;
     }
     case State::kInElse: {
       // An else statement can be followed by either a begin or an if.
       switch (token.token_enum()) {
         case TK_if:
           if (if_enable_) {
             condition_expr_level_ = 0;
             start_token_ = token;
             state_ = State::kInCondition;
           } else {
             state_ = State::kNormal;
           }
           break;
         case TK_begin:
           state_ = State::kNormal;
           break;
         default:
           raise_violation = true;
           break;
       }
       break;
     }
     case State::kInCondition: {
       // The last token expects a condition statement enclosed in a pair of
       // parentheses "()". This process also ignores any tokens between the last
       // token and the opening parentheses which simplifies "always_ff".
       switch (token.token_enum()) {
         case '(': {
           condition_expr_level_++;
           break;
         }
         case ')': {
           condition_expr_level_--;
           if (condition_expr_level_ == 0) {
             state_ = State::kExpectBegin;
           }
           break;
         }
         default: {
           // throw away everything else
           break;
         }
       }
       break;
     }
     case State::kExpectBegin: {
       // The next token must be a "begin"
       switch (token.token_enum()) {
         case TK_begin:
           // If we got our begin token, we go back to normal status
           state_ = State::kNormal;
           break;
         default: {
           raise_violation = true;
           break;
         }
       }
       break;
     }
     case State::kInlineConstraint: {
       switch (token.token_enum()) {
         case '{': {
           // An InlineConstraint
           constraint_expr_level_++;
           state_ = State::kConstraint;
           break;
         }
         default: {
           // throw away everything else
           state_ = State::kNormal;
           break;
         }
       }
     }
       ABSL_FALLTHROUGH_INTENDED;
     case State::kConstraint: {
       // System Verilog constraints are special and use curly braces {}
       // instead of begin-end. So ignore all constraints
       switch (token.token_enum()) {
         case '{': {
           constraint_expr_level_++;
           break;
         }
         case '}': {
           constraint_expr_level_--;
           if (constraint_expr_level_ == 0) {
             state_ = State::kNormal;
           }
           break;
         }
         default: {
           // throw away everything else
           break;
         }
       }
       break;
     }
     default: {
       // Do nothing
       break;
     }
   }  // switch (state_)

   if (raise_violation) {
     violations_.insert(LintViolation(
         start_token_, absl::StrCat(start_token_.text(), kMessage,
                                    " Expected begin, got ", token.text())));

     // Once the violation is raised, we go back to a normal, default, state
     state_ = State::kNormal;
   }

   return raise_violation;
 }

 void ExplicitBeginRule::HandleToken(const TokenInfo &token) {
   // Ignore all white space and comments and return immediately
   switch (token.token_enum()) {
     case TK_SPACE:
       return;
     case TK_NEWLINE:
       return;
     case TK_COMMENT_BLOCK:
       return;
     case TK_EOL_COMMENT:
       return;
     default:
       break;
   }

   bool retry = HandleTokenStateMachine(token);

   // If this token raises a violation, it was because the statemachine was
   // expecting a begin token. This token may expect a begin token too, so
   // check it.
   // Consider: forever if(a) #10; else #20; // 3 violations could be raised
   // [forever, if, else].
   if (retry) {
     HandleTokenStateMachine(token);
   }
 }

 LintRuleStatus ExplicitBeginRule::Report() const {
   return LintRuleStatus(violations_, GetDescriptor());
 }

 }  // namespace analysis
 }  // namespace verilog
	// Copyright 2017-2020 The Verible Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "verilog/analysis/checkers/explicit_begin_rule.h"

	#include <set>

	#include "absl/base/attributes.h"
	#include "absl/status/status.h"
	#include "absl/strings/str_cat.h"
	#include "absl/strings/string_view.h"
	#include "common/analysis/lint_rule_status.h"
	#include "common/analysis/token_stream_lint_rule.h"
	#include "common/text/config_utils.h"
	#include "common/text/token_info.h"
	#include "verilog/analysis/descriptions.h"
	#include "verilog/analysis/lint_rule_registry.h"
	#include "verilog/parser/verilog_token_enum.h"

	namespace verilog {
	namespace analysis {

	using verible::LintRuleStatus;
	using verible::LintViolation;
	using verible::TokenInfo;
	using verible::TokenStreamLintRule;

	// Register the lint rule
	VERILOG_REGISTER_LINT_RULE(ExplicitBeginRule);

	static const char kMessage[] =
	" block constructs shall explicitly use begin/end.";

	const LintRuleDescriptor &ExplicitBeginRule::GetDescriptor() {
	static const LintRuleDescriptor d{
	.name = "explicit-begin",
	.topic = "explicit-begin",
	.desc =
	"Checks that a Verilog ``begin`` directive follows all "
	"if, else, always, always_comb, always_latch, always_ff, "
	"for, forever, foreach, while and initial statements.",
	.param =
	{
	{"if_enable", "true",
	"All if statements require an explicit begin-end block"},
	{"else_enable", "true",
	"All else statements require an explicit begin-end block"},
	{"always_enable", "true",
	"All always statements require an explicit begin-end block"},
	{"always_comb_enable", "true",
	"All always_comb statements require an explicit begin-end "
	"block"},
	{"always_latch_enable", "true",
	"All always_latch statements require an explicit begin-end "
	"block"},
	{"always_ff_enable", "true",
	"All always_ff statements require an explicit begin-end block"},
	{"for_enable", "true",
	"All for statements require an explicit begin-end block"},
	{"forever_enable", "true",
	"All forever statements require an explicit begin-end block"},
	{"foreach_enable", "true",
	"All foreach statements require an explicit begin-end block"},
	{"while_enable", "true",
	"All while statements require an explicit begin-end block"},
	{"initial_enable", "true",
	"All initial statements require an explicit begin-end block"},
	},
	};
	return d;
	}

	absl::Status ExplicitBeginRule::Configure(absl::string_view configuration) {
	using verible::config::SetBool;
	return verible::ParseNameValues(
	configuration,
	{
	{"if_enable", SetBool(&if_enable_)},
	{"else_enable", SetBool(&else_enable_)},
	{"always_enable", SetBool(&always_enable_)},
	{"always_comb_enable", SetBool(&always_comb_enable_)},
	{"always_latch_enable", SetBool(&always_latch_enable_)},
	{"always_ff_enable", SetBool(&always_ff_enable_)},
	{"for_enable", SetBool(&for_enable_)},
	{"forever_enable", SetBool(&forever_enable_)},
	{"foreach_enable", SetBool(&foreach_enable_)},
	{"while_enable", SetBool(&while_enable_)},
	{"initial_enable", SetBool(&initial_enable_)},
	});
	}

	bool ExplicitBeginRule::IsTokenEnabled(const TokenInfo &token) {
	switch (token.token_enum()) {
	case TK_if:
	return if_enable_;
	case TK_else:
	return else_enable_;
	case TK_always:
	return always_enable_;
	case TK_always_comb:
	return always_comb_enable_;
	case TK_always_latch:
	return always_latch_enable_;
	case TK_always_ff:
	return always_ff_enable_;
	case TK_for:
	return for_enable_;
	case TK_forever:
	return forever_enable_;
	case TK_foreach:
	return foreach_enable_;
	case TK_while:
	return while_enable_;
	case TK_initial:
	return initial_enable_;
	default:
	return false;
	}
	}

	bool ExplicitBeginRule::HandleTokenStateMachine(const TokenInfo &token) {
	// Responds to a token by updating the state of the analysis.
	bool raise_violation = false;
	switch (state_) {
	case State::kNormal: {
	// Special handling for constraints
	switch (token.token_enum()) {
	case TK_constraint: {
	constraint_expr_level_ = 0;
	state_ = State::kConstraint;
	return false;
	}
	case TK_with: {
	constraint_expr_level_ = 0;
	state_ = State::kInlineConstraint;
	return false;
	}
	default: {
	// Do nothing
	break;
	}
	}

	if (!IsTokenEnabled(token)) {
	break;
	}

	switch (token.token_enum()) {
	// After token expect "begin"
	case TK_always_comb:
	ABSL_FALLTHROUGH_INTENDED;
	case TK_always_latch:
	ABSL_FALLTHROUGH_INTENDED;
	case TK_forever:
	ABSL_FALLTHROUGH_INTENDED;
	case TK_initial:
	start_token_ = token;
	state_ = State::kExpectBegin;
	break;
	// After token expect a "condition" followed by "begin". NOTE: there may
	// be tokens prior to the condition (like in an "always_ff" statement)
	// and these are all ignored.
	case TK_if:
	ABSL_FALLTHROUGH_INTENDED;
	case TK_always_ff:
	ABSL_FALLTHROUGH_INTENDED;
	case TK_for:
	ABSL_FALLTHROUGH_INTENDED;
	case TK_foreach:
	ABSL_FALLTHROUGH_INTENDED;
	case TK_while:
	condition_expr_level_ = 0;
	start_token_ = token;
	state_ = State::kInCondition;
	break;
	// always gets special handling, as somtimes there is a "condition" or
	// not before a "begin".
	case TK_always:
	condition_expr_level_ = 0;
	start_token_ = token;
	state_ = State::kInAlways;
	break;
	// else is also special as "if" or "begin" can follow
	case TK_else:
	start_token_ = token;
	state_ = State::kInElse;
	break;
	default:
	// Do nothing
	break;
	}
	break;
	}
	case State::kInAlways: {
	// always is a little more complicated in that it can be immediately
	// followed by a "begin" or followed by some special characters ("@" or
	// "*") and maybe a condition.
	switch (token.token_enum()) {
	case '@':
	break;
	case '*':
	break;
	case TK_begin:
	state_ = State::kNormal;
	break;
	case '(':
	condition_expr_level_++;
	state_ = State::kInCondition;
	break;
	default:
	raise_violation = true;
	break;
	}
	break;
	}
	case State::kInElse: {
	// An else statement can be followed by either a begin or an if.
	switch (token.token_enum()) {
	case TK_if:
	if (if_enable_) {
	condition_expr_level_ = 0;
	start_token_ = token;
	state_ = State::kInCondition;
	} else {
	state_ = State::kNormal;
	}
	break;
	case TK_begin:
	state_ = State::kNormal;
	break;
	default:
	raise_violation = true;
	break;
	}
	break;
	}
	case State::kInCondition: {
	// The last token expects a condition statement enclosed in a pair of
	// parentheses "()". This process also ignores any tokens between the last
	// token and the opening parentheses which simplifies "always_ff".
	switch (token.token_enum()) {
	case '(': {
	condition_expr_level_++;
	break;
	}
	case ')': {
	condition_expr_level_--;
	if (condition_expr_level_ == 0) {
	state_ = State::kExpectBegin;
	}
	break;
	}
	default: {
	// throw away everything else
	break;
	}
	}
	break;
	}
	case State::kExpectBegin: {
	// The next token must be a "begin"
	switch (token.token_enum()) {
	case TK_begin:
	// If we got our begin token, we go back to normal status
	state_ = State::kNormal;
	break;
	default: {
	raise_violation = true;
	break;
	}
	}
	break;
	}
	case State::kInlineConstraint: {
	switch (token.token_enum()) {
	case '{': {
	// An InlineConstraint
	constraint_expr_level_++;
	state_ = State::kConstraint;
	break;
	}
	default: {
	// throw away everything else
	state_ = State::kNormal;
	break;
	}
	}
	}
	ABSL_FALLTHROUGH_INTENDED;
	case State::kConstraint: {
	// System Verilog constraints are special and use curly braces {}
	// instead of begin-end. So ignore all constraints
	switch (token.token_enum()) {
	case '{': {
	constraint_expr_level_++;
	break;
	}
	case '}': {
	constraint_expr_level_--;
	if (constraint_expr_level_ == 0) {
	state_ = State::kNormal;
	}
	break;
	}
	default: {
	// throw away everything else
	break;
	}
	}
	break;
	}
	default: {
	// Do nothing
	break;
	}
	} // switch (state_)

	if (raise_violation) {
	violations_.insert(LintViolation(
	start_token_, absl::StrCat(start_token_.text(), kMessage,
	" Expected begin, got ", token.text())));

	// Once the violation is raised, we go back to a normal, default, state
	state_ = State::kNormal;
	}

	return raise_violation;
	}

	void ExplicitBeginRule::HandleToken(const TokenInfo &token) {
	// Ignore all white space and comments and return immediately
	switch (token.token_enum()) {
	case TK_SPACE:
	return;
	case TK_NEWLINE:
	return;
	case TK_COMMENT_BLOCK:
	return;
	case TK_EOL_COMMENT:
	return;
	default:
	break;
	}

	bool retry = HandleTokenStateMachine(token);

	// If this token raises a violation, it was because the statemachine was
	// expecting a begin token. This token may expect a begin token too, so
	// check it.
	// Consider: forever if(a) #10; else #20; // 3 violations could be raised
	// [forever, if, else].
	if (retry) {
	HandleTokenStateMachine(token);
	}
	}

	LintRuleStatus ExplicitBeginRule::Report() const {
	return LintRuleStatus(violations_, GetDescriptor());
	}

	} // namespace analysis
	} // namespace verilog