static
int doctype2(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_LITERAL:
state->handler = doctype3;
return XML_ROLE_DOCTYPE_PUBLIC_ID;
}
return syntaxError(state);
}
static
int attlist9(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_LITERAL:
state->handler = attlist1;
return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
}
return syntaxError(state);
}
static
int ignore(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_DECL_CLOSE:
state->handler = internalSubset;
return 0;
default:
return XML_ROLE_NONE;
}
return syntaxError(state);
}
static
int attlist5(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_OPEN_PAREN:
state->handler = attlist6;
return XML_ROLE_NONE;
}
return syntaxError(state);
}
static
int attlist6(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_NAME:
state->handler = attlist7;
return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
}
return syntaxError(state);
}
static
int notation0(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_NAME:
state->handler = notation1;
return XML_ROLE_NOTATION_NAME;
}
return syntaxError(state);
}
static
int notation3(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_LITERAL:
state->handler = declClose;
return XML_ROLE_NOTATION_SYSTEM_ID;
}
return syntaxError(state);
}
static
int entity8(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_LITERAL:
state->handler = entity9;
return XML_ROLE_ENTITY_PUBLIC_ID;
}
return syntaxError(state);
}
static
int entity6(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_NAME:
state->handler = declClose;
return XML_ROLE_ENTITY_NOTATION_NAME;
}
return syntaxError(state);
}
static
int doctype5(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_DECL_CLOSE:
state->handler = prolog2;
return XML_ROLE_DOCTYPE_CLOSE;
}
return syntaxError(state);
}
void assignmentStatement (SymTableNodePtr varIdPtr) {
//-----------------------------------
// Grab the variable we're setting...
TypePtr varType = variable(varIdPtr);
ifTokenGetElseError(TKN_EQUAL, ABL_ERR_SYNTAX_MISSING_EQUAL);
//---------------------------------------------------------
// Now, get the expression we're setting the variable to...
TypePtr exprType = expression();
//----------------------------------------
// They better be assignment compatible...
if (!isAssignTypeCompatible(varType, exprType))
syntaxError(ABL_ERR_SYNTAX_INCOMPATIBLE_ASSIGNMENT);
}
static
int internalSubset(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_DECL_OPEN:
if (XmlNameMatchesAscii(enc,
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
"ENTITY")) {
state->handler = entity0;
return XML_ROLE_NONE;
}
if (XmlNameMatchesAscii(enc,
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
"ATTLIST")) {
state->handler = attlist0;
return XML_ROLE_NONE;
}
if (XmlNameMatchesAscii(enc,
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
"ELEMENT")) {
state->handler = element0;
return XML_ROLE_NONE;
}
if (XmlNameMatchesAscii(enc,
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
"NOTATION")) {
state->handler = notation0;
return XML_ROLE_NONE;
}
break;
case XML_TOK_PI:
case XML_TOK_COMMENT:
return XML_ROLE_NONE;
case XML_TOK_PARAM_ENTITY_REF:
return XML_ROLE_PARAM_ENTITY_REF;
case XML_TOK_CLOSE_BRACKET:
state->handler = doctype5;
return XML_ROLE_NONE;
}
return syntaxError(state);
}
WORD Processor::pop() {
if(instructions && SP >= instructions->addresses[0]-1 && SP < instructions->addresses[instructions->count-1]) {
syntaxError("Stack attempting to overwrite code. Please set SP before using push/pop.");
return 0;
}
WORD x;
x = memory[SP++];
x += memory[SP++] << 8;
if(onMemoryReadAt) {
onMemoryReadAt(SP-2);
onMemoryReadAt(SP-1);
}
return x;
}
static
int doctype0(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = doctype1;
return XML_ROLE_DOCTYPE_NAME;
}
return syntaxError(state);
}
void matchBegin(char *parseToken)
{
/* function matchBegin(char *)
Parameters: char *
Return: nothing
description: Matches the BEGIN token.*/
if(strcmp(parseToken,"BEGIN")==0) //matches BEGIN
{
beginFlag = 1;
//fprintf(temp3,"matching 0, token is 0, buffer is %s\n", parseToken);
parse = 1;
convertBegin();
}
else
syntaxError(parseToken, "\"BEGIN\"");
return;
}
static
int attlist0(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = attlist1;
return XML_ROLE_ATTLIST_ELEMENT_NAME;
}
return syntaxError(state);
}
PARSENODE_PTR SQLParser::parseSelect() {
if (!startsSelect(nowReading)) {
syntaxError(nowReading, "expect select token!");
return nullptr;
}
PARSENODE_PTR selectNode = PARSENODE_PTR(new ParseNode(SELECT));
readToken();
expect(STAR);
expect(FROM);
selectNode->children.push_back(parseIdentifier());
if (nowReading == WHERE) {
readToken();
selectNode->children.push_back(parseCondition());
}
expect(TERMINATOR);
return selectNode;
}
void synchronize(TokenCodeType* tokenList1,
TokenCodeType* tokenList2,
TokenCodeType* tokenList3)
{
bool badLists = (!tokenIn(tokenList1) && !tokenIn(tokenList2) && !tokenIn(tokenList3));
if(badLists)
{
syntaxError((curToken == TKN_EOF) ? ABL_ERR_SYNTAX_UNEXPECTED_EOF : ABL_ERR_SYNTAX_UNEXPECTED_TOKEN);
//----------------------------------------------
// Now, we need to re-sync by skipping tokens...
while(!tokenIn(tokenList1) &&
!tokenIn(tokenList2) &&
!tokenIn(tokenList3) &&
(curToken != TKN_EOF))
getToken();
}
}
static
int element4(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = element5;
return XML_ROLE_CONTENT_ELEMENT;
}
return syntaxError(state);
}
TreeNode * statement(void) //statement -> expression| if_stmt| while_stmt|for_stmt|var_stmt|assign_stmt
{ TreeNode * t = NULL;
switch (token) {
case IF : t = if_stmt(); break;
case FOR : t = for_stmt(); break;
case ID : t = assign_stmt(); break;
case WHILE : t = while_stmt(); break;
case INT :
case CHAR :
t = var_stmt(); break;
case RBRACE : match(RBRACE); break;
default : syntaxError("unexpected token -> ");
printToken(token,tokenString);
token = getToken();
break;
} /* end case */
return t;
}
static
int attlist3(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_NMTOKEN:
case XML_TOK_NAME:
case XML_TOK_PREFIXED_NAME:
state->handler = attlist4;
return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
}
return syntaxError(state);
}
void statement () {
std::cout << "\nIn statement\n";
nextToken = getNextToken();
switch (nextToken) {
case (scanner::Id) :
ident ();
match (scanner::AssignOp);
expression();
match (scanner::SemiColon);
break;
case (scanner::ReadSym) :
match (scanner::ReadSym);
match (scanner::LParen);
idList();
match (scanner::RParen);
match (scanner::SemiColon);
break;
case (scanner::WriteSym) :
match (scanner::WriteSym);
match (scanner::LParen);
exprList ();
match (scanner::RParen);
match (scanner::SemiColon);
break;
default:
syntaxError (nextToken);
}
std::cout << "\nEnd statement\n";
}
TreeNode * for_stmt(void)
{
TreeNode * t = newStmtNode(ForK);
TreeNode * temp ;
TreeNode * ultimoIrmao ;
match(FOR);
switch(token){
case LPAREN:
match(LPAREN);
if (t!= NULL) t->child[0] = assign_stmt();
match(COMMA);
if (t!= NULL) t->child[1] = expres();
match(COMMA);
if (temp!= NULL) temp = assign_stmt();
match(RPAREN);
if (t!= NULL) t->child[2] = stmt_sequence();
if (t->child[2] != NULL){ //Se o terceiro filho tiver algo,
if(t->child[2]->sibling != NULL){ //Se o nó tem irmão, vamos fazer um loop para chegar até o ultimo irmão.
ultimoIrmao = t->child[2]->sibling;
while ( ultimoIrmao->sibling != NULL){ //Loop para chegar em ultimo irmão
ultimoIrmao = ultimoIrmao->sibling;
}
ultimoIrmao->sibling = temp;
}
else {
t->child[2]->sibling = temp;
}
}
else{ //Se o que tem dentro do FOR for nada, então vamos só fazer as iterações
t->child[2] = temp;
}
match(ENDFOR);
break;
default:
syntaxError("unexpected token -> ");
printToken(token,tokenString);
token = getToken();
break;
}
return t;
}
static
int prolog2(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_PI:
case XML_TOK_COMMENT:
return XML_ROLE_NONE;
case XML_TOK_INSTANCE_START:
state->handler = error;
return XML_ROLE_INSTANCE_START;
}
return syntaxError(state);
}
static
int entity0(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_PERCENT:
state->handler = entity1;
return XML_ROLE_NONE;
case XML_TOK_NAME:
state->handler = entity2;
return XML_ROLE_GENERAL_ENTITY_NAME;
}
return syntaxError(state);
}
static
int element5(PROLOG_STATE *state,
int tok,
const char *ptr,
const char *end,
const ENCODING *enc)
{
switch (tok) {
case XML_TOK_PROLOG_S:
return XML_ROLE_NONE;
case XML_TOK_CLOSE_PAREN_ASTERISK:
state->handler = declClose;
return XML_ROLE_GROUP_CLOSE_REP;
case XML_TOK_OR:
state->handler = element4;
return XML_ROLE_NONE;
}
return syntaxError(state);
}
/**
* factor ->
* ident | ident '[' expression ']' | unsign
* | '(' expression ')' | fcallstmt
*/
FactorSP FactorB(void)
{
FactorSP t;
NEWNODE(FactorS, t);
t->idp = NULL;
t->ep = NULL;
t->usi = 0;
t->fcsp = NULL;
switch (token) {
case UNS:
t->type = Unsign_Factor_t;
t->usi = atoi(tokenString);
match(UNS);
break;
case LPAR:
match(LPAR);
t->type = Expr_Factor_t;
t->ep = ExprB();
match(RPAR);
break;
case ID:
getsym();
if (TEST(LBRA)) {
t->type = Array_Factor_t;
t->idp = IdentB(READPREV);
match(LBRA);
t->ep = ExprB();
match(RBRA);
} else if (TEST(LPAR)) {
t->type = Funcall_Factor_t;
t->fcsp = FcallStmtB();
} else {
t->type = Id_Factor_t;
t->idp = IdentB(READPREV);
}
break;
default:
--runlevel;
syntaxError(UNEXPECT, lineno, TRUE, tokenString);
break;
}
return t;
}
/**
* ifstmt ->
* IF condition THEN statement |
* IF condition THEN statement ELSE statement
*/
IfStmtSP IfStmtB(void)
{
IfStmtSP t;
NEWNODE(IfStmtS, t);
match(IF);
t->cp = CondB();
if (TEST(THEN)) {
match(THEN);
} else {
--runlevel;
syntaxError(MISSTHEN, lineno, FALSE, prevTokenString);
}
t->tp = StmtB();
if (TEST(ELSE)) {
match(ELSE);
t->ep = StmtB();
} else t->ep = NULL;
return t;
}
void ifStatement (void) {
getToken();
char* falseLocation = crunchAddressMarker(NULL);
TypePtr exprType = expression();
if (exprType != BooleanTypePtr)
syntaxError(ABL_ERR_SYNTAX_INCOMPATIBLE_TYPES);
ifTokenGetElseError(TKN_THEN, ABL_ERR_SYNTAX_MISSING_THEN);
if ((curToken != TKN_END_IF) && (curToken != TKN_ELSE))
do {
statement();
while (curToken == TKN_SEMICOLON)
getToken();
if ((curToken == TKN_END_IF) || (curToken == TKN_ELSE))
break;
} while (tokenIn(statementStartList));
fixupAddressMarker(falseLocation);
//-----------------------------
// ELSE branch, if necessary...
if (curToken == TKN_ELSE) {
getToken();
char* ifEndLocation = crunchAddressMarker(NULL);
if (curToken != TKN_END_IF)
do {
statement();
while (curToken == TKN_SEMICOLON)
getToken();
if (curToken == TKN_END_IF)
break;
} while (tokenIn(statementStartList));
fixupAddressMarker(ifEndLocation);
}
ifTokenGetElseError(TKN_END_IF, ABL_ERR_SYNTAX_MISSING_END_IF);
}
/** reads the masterconss section */
static
SCIP_RETCODE readMasterconss(
SCIP* scip, /**< SCIP data structure */
DECINPUT* decinput, /**< DEC reading data */
SCIP_READERDATA* readerdata /**< reader data */
)
{
assert(scip != NULL);
assert(decinput != NULL);
assert(readerdata != NULL);
while( getNextToken(decinput) )
{
SCIP_CONS* cons;
/* check if we reached a new section */
if( isNewSection(scip, decinput) )
break;
/* the token must be the name of an existing constraint */
cons = SCIPfindCons(scip, decinput->token);
if( cons == NULL )
{
syntaxError(scip, decinput, "unknown constraint in masterconss section");
break;
}
else
{
if( !SCIPhashmapExists( readerdata->constoblock, cons) )
{
SCIPwarningMessage(scip, "Cons <%s> has been deleted by presolving, skipping.\n", SCIPconsGetName(cons));
continue;
}
assert(SCIPhashmapGetImage(readerdata->constoblock, cons) == (void*)(size_t) LINKINGVALUE);
SCIPdebugMessage("cons %s is linking constraint\n", decinput->token);
}
}
return SCIP_OKAY;
}
