botc: comparison src/expression.cpp

-:885fd60e8bf1
+:8ae8038b0168
 		delete sym;
 }
 // =============================================================================
 //
-// Try to parse an expression symbol (i.e. an OPER_erator or OPER_erand or a colon)
+// Try to parse an expression symbol (i.e. an operator or OPER_erand or a colon)
 // from the lexer.
 //
 ExpressionSymbol* Expression::parseSymbol()
 {
 	int pos = m_lexer->position();
 	ExpressionValue* op = null;
 	if (m_lexer->next (TK_Colon))
 		return new ExpressionColon;
-	// Check for OPER_erator
+	// Check for operator
 	for (const OperatorInfo& op : g_Operators)
 		if (m_lexer->next (op.token))
 			return new ExpressionOperator ((ExpressionOperatorType) (&op - &g_Operators[0]));
 	// Check sub-expression
 	return null;
 }
 // =============================================================================
 //
-// The symbol parsing process only does token-based checking for OPER_erators.
+// The symbol parsing process only does token-based checking for operators.
-// Thus ALL minus OPER_erators are actually unary minuses simply because both
+// Thus ALL minus operators are actually unary minuses simply because both
 // have TK_Minus as their token and the unary minus is prior to the binary minus
-// in the OPER_erator table. Now that we have all symbols present, we can
+// in the operator table. Now that we have all symbols present, we can
 // correct cases like this.
 //
 void Expression::adjustOperators()
 {
 	for (auto it = m_symbols.begin() + 1; it != m_symbols.end(); ++it)
 //
 // Verifies a single value. Helper function for Expression::verify.
 //
 void Expression::tryVerifyValue (bool* verified, SymbolList::Iterator it)
 {
-	// If it's an unary OPER_erator we skip to its value. The actual OPER_erator will
+	// If it's an unary operator we skip to its value. The actual operator will
 	// be verified separately.
 	if ((*it)->type() == EXPRSYM_Operator &&
 			g_Operators[static_cast<ExpressionOperator*> (*it)->id()].numoperands == 1)
 	{
 		++it;
 		switch (numoperands)
 		{
 			case 1:
 			{
 				// Ensure that:
-				// -	unary OPER_erator is not the last symbol
+				// -	unary operator is not the last symbol
-				// -	unary OPER_erator is succeeded by a value symbol
+				// -	unary operator is succeeded by a value symbol
 				// -	neither symbol overlaps with something already verified
 				tryVerifyValue (verified, it + 1);
 				if (it == last || verified[i] == true)
 					error ("malformed expression");
 			}
 			case 2:
 			{
 				// Ensure that:
-				// -	binary OPER_erator is not the first or last symbol
+				// -	binary operator is not the first or last symbol
 				// -	is preceded and succeeded by values
 				// -	none of the three tokens are already verified
 				//
 				// Basically similar logic as above.
 				if (it == first || it == last || verified[i] == true)
 				break;
 			}
 			case 3:
 			{
-				// Ternary OPER_erator case. This goes a bit nuts.
+				// Ternary operator case. This goes a bit nuts.
 				// This time we have the following:
 				//
 				// (VALUE) ? (VALUE) : (VALUE)
 				//         ^
 				// --------/ we are here
 				//
 				// Check that the:
-				// -	questionmark OPER_erator is not misplaced (first or last)
+				// -	questionmark operator is not misplaced (first or last)
-				// -	the value behind the OPER_erator (-1) is valid
+				// -	the value behind the operator (-1) is valid
-				// -	the value after the OPER_erator (+1) is valid
+				// -	the value after the operator (+1) is valid
 				// -	the value after the colon (+3) is valid
 				// -	none of the five tokens are verified
 				//
 				tryVerifyValue (verified, it - 1);
 				tryVerifyValue (verified, it + 1);
 				verified[i + 2] = true;
 				break;
 			}
 			default:
-				error ("WTF OPER_erator with %1 OPER_erands", numoperands);
+				error ("WTF operator with %1 OPER_erands", numoperands);
 		}
 	}
 	for (int i = 0; i < m_symbols.size(); ++i)
 		if (verified[i] == false)
 	return best;
 }
 // =============================================================================
 //
-// Process the given OPER_erator and values into a new value.
+// Process the given operator and values into a new value.
 //
 ExpressionValue* Expression::evaluateOperator (const ExpressionOperator* op,
 											   const List<ExpressionValue*>& values)
 {
 	const OperatorInfo* info = &g_Operators[op->id()];
 		// until Zandronum processes it at run-time.
 		newval->setBuffer (new DataBuffer);
 		if (op->id() == OPER_Ternary)
 		{
-			// There isn't a dataheader for ternary OPER_erator. Instead, we use DH_IfNotGoto
+			// There isn't a dataheader for ternary operator. Instead, we use DH_IfNotGoto
 			// to create an "if-block" inside an expression.
 			// Behold, big block of writing madness! :P
 			//
 			DataBuffer* buf = newval->buffer();
 			DataBuffer* b0 = values[0]->buffer();
 			for (int i = 0; i < 3; ++i)
 				values[i]->setBuffer (null);
 		}
 		else
 		{
-			// Generic case: write all arguments and apply the OPER_erator's
+			// Generic case: write all arguments and apply the operator's
 			// data header.
 			for (ExpressionValue* val : values)
 			{
 				newval->buffer()->mergeAndDestroy (val->buffer());

Mercurial > botc / file comparison

comparison: src/expression.cpp

src/expression.cpp