void
skipBinop(void)
{
overByte();
skipExpression();
skipExpression();
}
addressType
evaluateMfor(void)
{
expressionPCType testPoint;
expressionPCType incrPoint;
expressionPCType endPoint;
expressionPCType bodyPoint;
evaluateExpression();
testPoint = pc;
if (evaluateExpression()) {
incrPoint = pc;
skipExpression();
bodyPoint = pc;
do {
pc = bodyPoint;
evaluateExpression();
endPoint = pc;
pc = incrPoint;
evaluateExpression();
pc = testPoint;
} while (evaluateExpression());
pc = endPoint;
} else {
skipExpression();
skipExpression();
}
return(0);
}
void
skipMif(void)
{
skipExpression();
skipExpression();
skipExpression();
}
void
skipMfor(void)
{
skipExpression();
skipExpression();
skipExpression();
skipExpression();
}
addressType
evaluateMif(void)
{
if (evaluateExpression()) {
evaluateExpression();
skipExpression();
} else {
skipExpression();
evaluateExpression();
}
return(0);
}
bool
ClParserParser::
skipDictionary()
{
bool in_brackets = true;
while (in_brackets) {
bool assign;
if (! skipExpression(&assign) && error_code_ != int(ClErr::INVALID_CHARACTER))
return false;
if (parse_.isChar(','))
parse_.skipChar();
else if (parse_.isString("}}")) {
parse_.skipChars(2);
in_brackets = false;
}
else {
error_code_ = int(ClErr::INVALID_CHARACTER);
return false;
}
}
return true;
}
void
skipBlock(void)
{
while (*pc != END_TAG)
skipExpression();
overByte();
}
bool
ClParserParser::
skipList()
{
bool in_brackets = true;
while (in_brackets) {
bool assign;
if (! skipExpression(&assign) && error_code_ != int(ClErr::INVALID_CHARACTER))
return false;
if (parse_.isChar(','))
parse_.skipChar();
else if (parse_.isChar('}') && ! parse_.isCharAfter('}')) {
parse_.skipChar();
in_brackets = false;
}
else {
error_code_ = int(ClErr::INVALID_CHARACTER);
return false;
}
}
return true;
}
bool
evaluateClause(addressType pattern)
{
bool match;
match = FALSE;
while (*pc != BLOCK_TAG)
if (match)
skipExpression();
else
match = (evaluateExpression() == pattern);
if (match)
evaluateExpression();
else
skipExpression();
return(match);
}
void
skipMswitch(void)
{
skipExpression();
while (*pc != END_TAG)
skipClause();
overByte();
}
void
skipFunctionCall(void)
{
int argCount;
overFunction();
nextByte(argCount);
while (argCount-- > 0)
skipExpression();
}
addressType
evaluateBlock(void)
{
while (*pc != END_TAG) {
evaluateExpression();
if (hitFreturn)
while (*pc != END_TAG)
skipExpression();
}
overByte();
return(0);
}
addressType
evaluateMdoWhile(void)
{
expressionPCType testPoint;
expressionPCType endPoint;
testPoint = pc;
skipExpression();
do {
evaluateExpression;
endPoint = pc;
pc = testPoint;
} while (evaluateExpression());
pc = endPoint;
return(0);
}
addressType
evaluateMwhile(void)
{
expressionPCType testPoint;
expressionPCType endPoint;
testPoint = pc;
if (evaluateExpression()) {
do {
evaluateExpression();
endPoint = pc;
pc = testPoint;
} while (evaluateExpression());
pc = endPoint;
} else {
skipExpression();
}
}
void
bindFunctionArguments(functionType *theFunction, int argCount)
{
argumentListType *argList;
argList = theFunction->functionArguments;
while (argCount > 0) {
if (argList == NULL) {
error(TOO_MANY_FUNCTION_ARGUMENTS_ERROR);
while (argCount-- > 0)
skipExpression();
} else {
pushSymbol(argList->argumentSymbol,
evaluateExpression());
argList = argList->nextArgument;
argCount--;
}
}
while (argList != NULL) {
pushSymbol(argList->argumentSymbol, 0);
argList = argList->nextArgument;
}
}
void
skipExpression(void)
{
if (pc == NULL)
return;
switch (*pc++) {
case IDENTIFIER_TAG:
overSymbol();
break;
case FUNCTION_CALL_TAG:
skipFunctionCall();
break;
case NUMBER_TAG:
case RELOCATABLE_TAG:
overNumber();
break;
case CONDITION_CODE_TAG:
overByte();
break;
case SUBEXPRESSION_TAG:
skipExpression();
break;
case UNOP_TAG:
skipUnop();
break;
case BINOP_TAG:
skipBinop();
break;
case PREOP_TAG:
skipPreop();
break;
case POSTOP_TAG:
skipPostop();
break;
case HERE_TAG:
break;
case STRING_TAG:
skipString();
break;
case ARRAY_TAG:
skipArray();
break;
case VALUE_TAG:
overNumber();
break;
case NULL_TAG:
break;
case BLOCK_TAG:
skipBlock();
break;
case MDEFINE_TAG:
skipMdefine();
break;
case MVARIABLE_TAG:
skipMvariable();
break;
case MIF_TAG:
skipMif();
break;
case MFOR_TAG:
skipMfor();
break;
case MWHILE_TAG:
skipMwhile();
break;
case MDOWHILE_TAG:
skipMdoWhile();
break;
case MDOUNTIL_TAG:
skipMdoUntil();
break;
case PERFORM_TAG:
skipExpression();
break;
case GROUP_TAG:
skipBlock();
break;
case ASSERT_TAG:
skipAssert();
break;
case MSWITCH_TAG:
skipMswitch();
break;
case CLAUSE_TAG:
skipClause();
break;
case END_TAG:
break;
}
}
void
skipPreop(void)
{
overByte();
skipExpression();
}
void
skipMwhile(void)
{
skipExpression();
skipExpression();
}
void
skipMvariable(void)
{
overSymbol();
skipExpression();
}
void
skipArray(void)
{
overSymbol();
skipExpression();
}
void
skipMdoUntil(void)
{
skipExpression();
skipExpression();
}
void
skipAssert(void)
{
skipExpression();
skipString();
}
bool
ClParserParser::
skipExpression(bool *assign)
{
bool expression = false;
error_code_ = 0;
parse_.skipSpace();
while (! parse_.eof()) {
/* <expression> := <unary_operator> <expression> */
if (! expression && strchr(parser_unary_operator_chars, parse_.getCharAt()) != nullptr) {
skipUnaryOperator();
if (! skipExpression(assign))
return false;
if (*assign) {
error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT);
return false;
}
expression = true;
}
/* <expression> := '(' <expression> ')' */
else if (! expression && parse_.isChar('(')) {
bool assign1 = false;
parse_.skipChar();
if (! skipExpression(&assign1) && error_code_ != int(ClErr::INVALID_CHARACTER))
return false;
error_code_ = 0;
parse_.skipSpace();
if (! parse_.isChar(')')) {
error_code_ = int(ClErr::MISSING_CLOSE_ROUND_BRACKET);
return false;
}
parse_.skipChar();
expression = true;
}
/* <expression> := <numeric_value> */
else if (! expression &&
(parse_.isDigit() || parse_.isChar('.'))) {
if (! skipNumericValue())
return false;
expression = true;
}
/* <expression> := <string_value> */
else if (! expression && parse_.isOneOf(parser_string_chars)) {
if (! skipStringValue())
return false;
expression = true;
}
/* <expression> := <array_value> */
else if (! expression && parse_.isChar('[')) {
parse_.skipChar();
if (! skipArray())
return false;
expression = true;
}
/* <expression> := <dict_value> */
else if (! expression && parse_.isString("{{")) {
parse_.skipChars(2);
if (! skipDictionary())
return false;
expression = true;
}
/* <expression> := <list_value> */
else if (! expression && parse_.isChar('{')) {
parse_.skipChar();
if (! skipList())
return false;
expression = true;
}
/* <expression> := <expression> <binary_operator> <expression> */
else if (expression && parse_.isOneOf(parser_binary_operator_chars)) {
bool assign1 = false;
skipBinaryOperator(&assign1);
if (error_code_ != 0)
return false;
if (! skipExpression(assign))
return false;
if (! assign1 && *assign) {
error_code_ = int(ClErr::INVALID_LVALUE_FOR_ASSIGNMENT);
return false;
}
if (assign1)
*assign = true;
expression = true;
}
/* <expression> := <expression> '?' <expression> ':' <expression> */
else if (expression && parse_.isChar('?')) {
bool assign1 = false;
bool assign2 = false;
parse_.skipChar();
if (! skipExpression(&assign1) && error_code_ != int(ClErr::INVALID_CHARACTER))
return false;
error_code_ = 0;
parse_.skipSpace();
if (! parse_.isChar(':')) {
error_code_ = int(ClErr::MISSING_COLON_OPERATOR);
return false;
}
parse_.skipChar();
if (! skipExpression(&assign2))
return false;
expression = true;
*assign = assign1 | assign2;
}
/* <expression> := <expression> '[' <expression> ',' .... ']' */
else if (expression && parse_.isChar('[')) {
parse_.skipChar();
if (! skipArray())
return false;
expression = true;
}
/* <expression> := <expression> ',' <expression> */
else if (expression && parse_.isChar(',')) {
bool assign1 = false;
ClParserStackMgrInst->push(CL_PARSER_OP_COMMA);
ClParserStackMgrInst->toNext();
parse_.skipChar();
if (! skipExpression(&assign1))
return false;
expression = true;
}
/* <expression> := <variable> */
/* <expression> := <variable> '.' <variable> '.' <...> */
/* <expression> := <variable> '[' <expression> ',' .... ']' */
/* <expression> := <function> '(' <expression> ',' .... ')' */
/* <expression> := <type> '(' <expression> ',' .... ')' */
else if (! expression && (parse_.isAlpha() || parse_.isChar('_'))) {
skipIdentifier();
if (error_code_ != 0)
return false;
parse_.skipSpace();
if (parse_.isChar('(')) {
parse_.skipChar();
if (! skipArgList())
return false;
expression = true;
}
else {
if (parse_.isChar('[')) {
parse_.skipChar();
if (! skipArray())
return false;
parse_.skipSpace();
}
while (parse_.isChar('.')) {
parse_.skipChar();
parse_.skipSpace();
skipIdentifier();
if (error_code_ != 0)
return false;
if (parse_.isChar('[')) {
parse_.skipChar();
if (! skipArray())
return false;
parse_.skipSpace();
}
}
expression = true;
}
}
else {
error_code_ = int(ClErr::INVALID_CHARACTER);
return false;
}
parse_.skipSpace();
}
if (! expression) {
error_code_ = int(ClErr::NULL_EXPRESSION);
return false;
}
return true;
}
void
skipMdefine(void)
{
overSymbol();
skipExpression();
}
