void ParsedObject::Fail()
{
if (iLookAhead && !iLookAhead->empty())
throw LispErrGeneric(std::string("Error parsing expression, near token ") + *iLookAhead);
throw LispErrGeneric("Error parsing expression");
}
void LispDebugLine(LispEnvironment& aEnvironment, LispInt aStackTop)
{
#ifndef YACAS_DEBUG
throw LispErrGeneric("Cannot call DebugLine in non-debug version of Yacas");
#else
RESULT = LispAtom::New(aEnvironment, std::to_string(ARGUMENT(1)->iLine));
#endif
}
void LispDebugFile(LispEnvironment& aEnvironment, LispInt aStackTop)
{
#ifndef YACAS_DEBUG
throw LispErrGeneric("Cannot call DebugFile in non-debug version of Yacas");
#else
const LispChar * file = ARGUMENT(1)->iFileName;
if (!file) file = "";
LispString * str = aEnvironment.HashTable().LookUpStringify(file);
RESULT = LispAtom::New(aEnvironment, *str);
#endif
}
void ParsedObject::ReadAtom()
{
LispOperators::const_iterator opi =
iParser.iPrefixOperators.find(iLookAhead);
if (opi != iParser.iPrefixOperators.end()) {
const LispString* theOperator = iLookAhead;
MatchToken(iLookAhead);
{
ReadExpression(opi->second.iPrecedence);
InsertAtom(theOperator);
Combine(1);
}
} // Else parse brackets
else if (iLookAhead == iParser.iEnvironment.iBracketOpen->String()) {
MatchToken(iLookAhead);
ReadExpression(KMaxPrecedence); // least precedence
MatchToken(iParser.iEnvironment.iBracketClose->String());
} //Parse lists
else if (iLookAhead == iParser.iEnvironment.iListOpen->String()) {
LispInt nrargs = 0;
MatchToken(iLookAhead);
while (iLookAhead != iParser.iEnvironment.iListClose->String()) {
ReadExpression(KMaxPrecedence); // least precedence
nrargs++;
if (iLookAhead == iParser.iEnvironment.iComma->String()) {
MatchToken(iLookAhead);
} else if (iLookAhead != iParser.iEnvironment.iListClose->String()) {
throw LispErrGeneric(std::string("Expecting a } close bracket for program block, but got ") + *iLookAhead + std::string(" instead"));
}
}
MatchToken(iLookAhead);
const LispString* theOperator = iParser.iEnvironment.iList->String();
InsertAtom(theOperator);
Combine(nrargs);
} // Parse prog bodies
else if (iLookAhead == iParser.iEnvironment.iProgOpen->String()) {
LispInt nrargs = 0;
MatchToken(iLookAhead);
while (iLookAhead != iParser.iEnvironment.iProgClose->String()) {
ReadExpression(KMaxPrecedence); // least precedence
nrargs++;
if (iLookAhead == iParser.iEnvironment.iEndStatement->String()) {
MatchToken(iLookAhead);
} else {
throw LispErrGeneric(std::string("Expecting ; end of statement in program block, but got ") + *iLookAhead + std::string(" instead"));
}
}
MatchToken(iLookAhead);
const LispString* theOperator = iParser.iEnvironment.iProg->String();
InsertAtom(theOperator);
Combine(nrargs);
} // Else we have an atom.
else {
const LispString* theOperator = iLookAhead;
MatchToken(iLookAhead);
LispInt nrargs = -1;
if (iLookAhead == iParser.iEnvironment.iBracketOpen->String()) {
nrargs = 0;
MatchToken(iLookAhead);
while (iLookAhead != iParser.iEnvironment.iBracketClose->String()) {
ReadExpression(KMaxPrecedence); // least precedence
nrargs++;
if (iLookAhead == iParser.iEnvironment.iComma->String()) {
MatchToken(iLookAhead);
} else if (iLookAhead != iParser.iEnvironment.iBracketClose->String()) {
throw LispErrGeneric(std::string("Expecting a ) closing bracket for sub-expression, but got ") + *iLookAhead + std::string(" instead"));
}
}
MatchToken(iLookAhead);
opi = iParser.iBodiedOperators.find(theOperator);
if (opi != iParser.iBodiedOperators.end()) {
ReadExpression(opi->second.iPrecedence); // KMaxPrecedence
nrargs++;
}
}
InsertAtom(theOperator);
if (nrargs >= 0)
Combine(nrargs);
}
// Parse postfix operators
while (iParser.iPostfixOperators.find(iLookAhead) != iParser.iPostfixOperators.end()) {
InsertAtom(iLookAhead);
MatchToken(iLookAhead);
Combine(1);
}
}
void ParsedObject::ReadExpression(LispInt depth)
{
ReadAtom();
for (;;) {
//Handle special case: a[b]. a is matched with lowest precedence!!
if (iLookAhead == iParser.iEnvironment.iProgOpen->String()) {
// Match opening bracket
MatchToken(iLookAhead);
// Read "index" argument
ReadExpression(KMaxPrecedence);
// Match closing bracket
if (iLookAhead != iParser.iEnvironment.iProgClose->String())
throw LispErrGeneric(std::string("Expecting a ] close bracket for program block, but got ") + *iLookAhead + std::string(" instead"));
MatchToken(iLookAhead);
// Build into Ntn(...)
const LispString* theOperator = iParser.iEnvironment.iNth->String();
InsertAtom(theOperator);
Combine(2);
} else {
LispOperators::const_iterator opi = iParser.iInfixOperators.find(iLookAhead);
if (opi == iParser.iInfixOperators.end()) {
if (!IsSymbolic((*iLookAhead)[0]))
return;
const std::size_t origlen = iLookAhead->size();
std::size_t len = origlen;
while (len > 1) {
len -= 1;
const LispString* lookUp =
iParser.iEnvironment.HashTable().LookUp(iLookAhead->substr(0, len));
opi = iParser.iInfixOperators.find(lookUp);
if (opi != iParser.iInfixOperators.end()) {
const LispString* lookUpRight =
iParser.iEnvironment.HashTable().LookUp(iLookAhead->substr(len, origlen - len));
if (iParser.iPrefixOperators.find(lookUpRight) != iParser.iPrefixOperators.end()) {
iLookAhead = lookUp;
LispInput& input = iParser.iInput;
LispInt newPos = input.Position() - (origlen - len);
input.SetPosition(newPos);
break;
}
opi = iParser.iInfixOperators.end();
}
}
if (opi == iParser.iInfixOperators.end())
return;
}
if (depth < opi->second.iPrecedence)
return;
LispInt upper = opi->second.iPrecedence;
if (!opi->second.iRightAssociative)
upper--;
GetOtherSide(2, upper);
}
}
}