botc: comparison src/expression.cpp

-:eca2fc0acaa2
+:8b9132fea327
 #include "dataBuffer.h"
 #include "lexer.h"
 struct OperatorInfo
 {
-	Token	token;
+	Token		token;
 	int			priority;
 	int			numoperands;
 	DataHeader	header;
 };
 		{
 			m_lexer->mustGetNext (Token::BracketStart);
 			Expression expr (m_parser, m_lexer, TYPE_Int);
 			expr.getResult()->convertToBuffer();
 			DataBuffer* buf = expr.getResult()->buffer()->clone();
-			buf->writeDWord (DataHeader::PushGlobalArray);
+			buf->writeHeader (DataHeader::PushGlobalArray);
 			buf->writeDWord (var->index);
 			op->setBuffer (buf);
 			m_lexer->mustGetNext (Token::BracketEnd);
 		}
 		elif (var->writelevel == WRITE_Constexpr)
 		else
 		{
 			DataBuffer* buf = new DataBuffer (8);
 			if (var->isGlobal())
-				buf->writeDWord (DataHeader::PushGlobalVar);
+				buf->writeHeader (DataHeader::PushGlobalVar);
 			else
-				buf->writeDWord (DataHeader::PushLocalVar);
+				buf->writeHeader (DataHeader::PushLocalVar);
 			buf->writeDWord (var->index);
 			op->setBuffer (buf);
 		}
 // -------------------------------------------------------------------------------------------------
 //
 // Verifies a single value. Helper function for Expression::verify.
 //
-void Expression::tryVerifyValue (bool* verified, SymbolList::Iterator it)
+void Expression::tryVerifyValue (List<bool>& verified, SymbolList::Iterator it)
 {
 	// If it's an unary operator we skip to its value. The actual operator will
 	// be verified separately.
 	if ((*it)->type() == EXPRSYM_Operator and
 			g_Operators[static_cast<ExpressionOperator*> (*it)->id()].numoperands == 1)
 	}
 	if (m_type == TYPE_String)
 		error ("Cannot perform operations on strings");
-	bool* verified = new bool[m_symbols.size()];
+	List<bool> verified (m_symbols.size());
-	memset (verified, 0, m_symbols.size() * sizeof (decltype (*verified)));
+	for (bool& a : verified)
+		a = false;
 	const auto last = m_symbols.end() - 1;
 	const auto first = m_symbols.begin();
 	for (auto it = m_symbols.begin(); it != m_symbols.end(); ++it)
 	{
 	for (int i = 0; i < m_symbols.size(); ++i)
 	{
 		if (verified[i] == false)
 			error ("malformed expression: expr symbol #%1 is was left unverified", i);
 	}
-	delete verified;
 }
 // -------------------------------------------------------------------------------------------------
 //
 			DataBuffer* b1 = values[1]->buffer();
 			DataBuffer* b2 = values[2]->buffer();
 			ByteMark* mark1 = buf->addMark (""); // start of "else" case
 			ByteMark* mark2 = buf->addMark (""); // end of expression
 			buf->mergeAndDestroy (b0);
-			buf->writeDWord (DataHeader::IfNotGoto); // if the first operand (condition)
+			buf->writeHeader (DataHeader::IfNotGoto); // if the first operand (condition)
 			buf->addReference (mark1); // didn't eval true, jump into mark1
 			buf->mergeAndDestroy (b1); // otherwise, perform second operand (true case)
-			buf->writeDWord (DataHeader::Goto); // afterwards, jump to the end, which is
+			buf->writeHeader (DataHeader::Goto); // afterwards, jump to the end, which is
 			buf->addReference (mark2); // marked by mark2.
 			buf->adjustMark (mark1); // move mark1 at the end of the true case
 			buf->mergeAndDestroy (b2); // perform third operand (false case)
 			buf->adjustMark (mark2); // move the ending mark2 here
 				// Null the pointer out so that the value's destructor will not
 				// attempt to double-free it.
 				val->setBuffer (null);
 			}
-			newval->buffer()->writeDWord (info->header);
+			newval->buffer()->writeHeader (info->header);
 		}
 	}
 	else
 	{
 		// We have a constant expression. We know all the values involved and
 		// can thus compute the result of this expression on compile-time.
 		List<int> nums;
-		int a;
+		int a = 0;
 		for (ExpressionValue* val : values)
 			nums << val->value();
 		switch (op->id())
 	{
 		int i = it - m_symbols.begin();
 		List<SymbolList::Iterator> operands;
 		ExpressionOperator* op = static_cast<ExpressionOperator*> (*it);
 		const OperatorInfo* info = &g_Operators[op->id()];
-		int lower, upper; // Boundaries of area to replace
+		// Boundaries of area to replace
+		int lower = 0;
+		int upper = 0;
 		switch (info->numoperands)
 		{
 			case 1:
-			{
 				lower = i;
 				upper = i + 1;
 				operands << it + 1;
 				break;
-			}
 			case 2:
-			{
 				lower = i - 1;
 				upper = i + 1;
 				operands << it - 1
 				         << it + 1;
 				break;
-			}
 			case 3:
-			{
 				lower = i - 1;
 				upper = i + 3;
 				operands << it - 1
 				         << it + 1
 				         << it + 3;
 				break;
-			}
 			default:
 				error ("WTF bad expression with %1 operands", info->numoperands);
 		}
 	switch (m_valueType)
 	{
 		case TYPE_Bool:
 		case TYPE_Int:
-			buffer()->writeDWord (DataHeader::PushNumber);
+			buffer()->writeHeader (DataHeader::PushNumber);
 			buffer()->writeDWord (abs (value()));
 			if (value() < 0)
-				buffer()->writeDWord (DataHeader::UnaryMinus);
+				buffer()->writeHeader (DataHeader::UnaryMinus);
 			break;
 		case TYPE_String:
-			buffer()->writeDWord (DataHeader::PushStringIndex);
+			buffer()->writeHeader (DataHeader::PushStringIndex);
 			buffer()->writeDWord (value());
 			break;
 		case TYPE_Void:
 		case TYPE_Unknown:

Mercurial > botc / file comparison

comparison: src/expression.cpp

src/expression.cpp