CAbstractEq* CEqParserV2::_parseEquation(std::string &equation, int &it)
{
CChainEq* rVal = new CChainEq();
CAbstractEq* number = NULL;
bool hasNum = false;
bool hasOp = false;
bool inverseNum = false;
char chr = equation.at(it);
while ((unsigned)it < equation.length())
{
//// Fast exit if statement ends
//if(cc::isParClose(equation.at(it)))
//{
// DBOUT("Called break");
// it+=2;
// break;
//}
chr = equation.at(it);
DBOUT("it = " << it << ", char = " << chr);
eOpType op = eOpType::NULL_EQ;
if (cc::isDecimal(chr))
{
DBOUT("Found decimal: " << chr);
number = _parseNumber(equation, it);
}
else if (cc::isParOpen(chr))
{
std::string sub = _getEqSubstr(equation, ++it);
DBOUT("Found subEquation "<<sub);
int subIt = 0; // dummy
number = _parseEquation(sub, subIt);
}
else if (cc::isAlpha(chr))
{
DBOUT("Found alpha " << chr);
std::string fcnName = _parseIdentifier(equation, it);
number = _parseFunction(fcnName,equation, it);
}
else if (cc::isOperator(chr))
{
op = _parseOperator(equation, it);
}
else
{
it++;
}
hasNum = (number != NULL);
hasOp = (op != eOpType::NULL_EQ);
DBOUT("hasOp = " << hasOp << " hasNum = " << hasNum);
if (hasNum)
{
bool doAdd = false;
// Has Number and Operator
if (hasOp)
{
doAdd = true;
}
// Default Operator "CONST" if finished
else if ((unsigned)it >= equation.length())
{
op = eOpType::CONST_EQ;
doAdd = true;
}
// Default Operator "MPL" if undefined
else
{
chr = equation.at(it);
DBOUT("Try autoadd MPL (203) char is: " << chr);
// Subequation e.g. 4(2+3)
// ^ ^
doAdd |= cc::isParOpen(chr);
// Function e.g. 4x
// ^
doAdd |= cc::isAlpha(chr);
// Decimal e.g. (2+3)4
// ^
doAdd |= cc::isDecimal(chr);
if (doAdd)
{
op = eOpType::MPL_EQ;
}
}
if (doAdd)
{
if (inverseNum) number = new CInvEq(number);
DBOUT("Adding Operation "<<op);
rVal->addOperation(number, op);
op = eOpType::NULL_EQ;
number = NULL;
//
hasNum = false;
hasOp = false;
inverseNum = false;
}
}
// Inverse negative
else
{
if (op == eOpType::SUB_EQ)
{
DBOUT("Setting inversenum = true");
inverseNum = true;
}
}
}
if (hasNum)
{
if (inverseNum) number = new CInvEq(number);
DBOUT("Adding Operation 101");
rVal->addOperation(number, eOpType::CONST_EQ);
}
DBOUT("Returning equation, it = "<<it);
return rVal;
}
ir::Type* TypeParser::_parseType()
{
std::string nextToken = _lexer->peek();
ir::Type* type = nullptr;
if(isFunction(nextToken))
{
type = _parseFunction();
}
else if(isStructure(nextToken))
{
type = _parseStructure();
}
else if(isPrimitive(_compiler, nextToken))
{
type = _parsePrimitive();
nextToken = _lexer->peek();
if(isFunction(nextToken))
{
type = _parseFunction(type);
}
}
else if(isArray(nextToken))
{
type = _parseArray();
}
else if(isVariadic(nextToken))
{
_lexer->scan("...");
type = *_compiler->getOrInsertType(ir::VariadicType(_compiler));
}
else if(isTypeAlias(nextToken))
{
type = _parseTypeAlias();
}
else if(isOpaqueType(nextToken))
{
_lexer->scan("opaque");
type = *_compiler->getOrInsertType(ir::OpaqueType(_compiler));
}
nextToken = _lexer->peek();
while(isPointer(nextToken))
{
_lexer->scan("*");
type = *_compiler->getOrInsertType(ir::PointerType(_compiler, type));
nextToken = _lexer->peek();
}
if(type == nullptr)
{
throw std::runtime_error("Failed to parse type.");
}
hydrazine::log("TypeParser::Parser") << "Parsed type " << type->name
<< ".\n";
return type;
}
