/**
* @Do_Control_Cmd
* description: pross 'if' 'then' 'fi' 'else' -- change state
* @args: input string
*
* @return: True or Fail
*/
int Do_Control_Cmd(char **args)
{
char *cmd = args[0];
int flag = R_FALSE;
//enter if area
if (strcmp(cmd, "if") == 0)
{
if (if_state != NATRULE)
{
Syntax_Error("if unexpected!");
flag = R_FALSE;
}
else
{
/*any backspace in "if_string" is inadmissibility,
otherwise it will be divide into a few conditions*/
last_state = Process(args + 1);
if_result = last_state;
if_state = WANT_THEN;
flag = R_TRUE;
}
}
else if (strcmp(cmd, "then") == 0)
{
if (if_state != WANT_THEN)
{
Syntax_Error("then unexpected");
flag = R_FALSE;
}
else
{
if_state = THEN_BLOCK;
flag = R_TRUE;
}
}
else if (strcmp(cmd, "fi") == 0)
{
if (if_state != THEN_BLOCK)
{
Syntax_Error("fi unexpected");
flag = R_FALSE;
}
else
{
//enter NATRULE area agian
if_state = NATRULE;
flag = R_TRUE;
}
}
else
{
fatal("internal error:", cmd, 2);
}
return flag;
}
/**
* @Ok_Execute
* description: 1 for yes, 0 for no
* @return: R_TRUE or R_FALSE
*/
int Ok_Execute()
{
int flag = R_TRUE;
/*if in THEN_BLOCK then syntax error*/
if (WANT_THEN == if_state)
{
Syntax_Error("then expected");
flag = R_FALSE;
}
/*if in THEN_BLOCK and if_result is R_TRUE then yes else no*/
else if ((THEN_BLOCK == if_state) && (R_TRUE == if_result))
{
flag = R_TRUE;
}
else if ((THEN_BLOCK == if_state) && (R_FALSE == if_result))
{
flag = R_FALSE;
}
return flag;
}
bool User_Program::Initial_Table (String &line)
{
int i, j, index, lnum, len;
Int_Itr litr, litr0;
double fnum;
Dbl_Itr fitr, fitr0;
String token;
Str_Itr sitr, sitr0;
string::iterator ch, ch0;
i = cmd.token;
j = cmd.value;
for (;;) {
//---- remove leading spaces ----
line.Trim_Left (" \t");
if (line.empty ()) return (false);
ch = ch0 = line.begin ();
//---- determine the token type ----
if ((*ch >= '0' && *ch <= '9') || (*ch == '.' && *(ch+1) != '.') ||
(*ch == '-' && (*(ch+1) >= '0' && *(ch+1) <= '9'))) {
//---- process a number ----
if (*ch == '-') ch++;
do {
if (++ch == line.end ()) break;
} while ((*ch >= '0' && *ch <= '9') || (*ch == '.' && *(ch+1) != '.'));
len = (int) (ch - ch0);
token = line.substr (0, len);
line.erase (0, len);
//---- set the table size ----
if (open_par) {
lnum = token.Integer ();
if (lnum < 1) {
exe->Error (String ("%s Table %d Size %d is Out of Range") % Data_Type (i) % j % lnum);
return (false);
}
if (table [i] [j].size () > 0) {
exe->Write (1);
exe->Warning (String ("%s Table %d is Redefined") % Data_Type (i) % j);
table [i] [j].clear ();
}
table [i] [j].reserve (lnum);
} else {
if (table_type == STAB) {
exe->Error ("Attempt to Assign a Number to a String Table");
return (false);
}
//---- search for the value in the list ----
if (table_type == ITAB) {
lnum = token.Integer ();
for (litr = litr0 = lvalue.begin (); litr != lvalue.end (); litr++) {
if (*litr == lnum) break;
}
if (litr == lvalue.end ()) {
index = (int) lvalue.size (); //---- 0 based ----
lvalue.push_back (lnum);
} else {
index = (int) (litr - litr0); //---- 0 based ----
}
} else {
fnum = token.Double ();
for (fitr = fitr0 = fvalue.begin (); fitr != fvalue.end (); fitr++) {
if (*fitr == fnum) break;
}
if (fitr == fvalue.end ()) {
index = (int) fvalue.size (); //---- 0 based ----
fvalue.push_back (fnum);
} else {
index = (int) (fitr - fitr0); //---- 0 based ----
}
}
table [i] [j].push_back (index);
}
} else if (*ch == '"') {
if (table_type != STAB) goto error;
//---- process a string ----
ch++;
token.clear ();
while (ch != line.end () && *ch != '"') {
token += *ch++;
}
ch++;
line.erase (0, ch - ch0);
for (sitr = sitr0 = svalue.begin (); sitr != svalue.end (); sitr++) {
if (token.Equals (*sitr)) break;
}
if (sitr == svalue.end ()) {
index = (int) svalue.size ();
svalue.push_back (token);
} else {
index = (int) (sitr - sitr0); //---- 0 based ----
}
table [i] [j].push_back (index);
} else if ((*ch >= 'A' && *ch <= 'Z') || (*ch >= 'a' && *ch <= 'z')) {
do {
if (++ch == line.end ()) break;
} while ((*ch >= 'A' && *ch <= 'Z') || (*ch >= 'a' && *ch <= 'z') ||
(*ch >= '0' && *ch <= '9') || (*ch == '.' && *(ch+1) != '.') || *ch == '_');
len = (int) (ch - ch0);
token = line.substr (0, len);
line.erase (0, len);
if (token.Equals ("ENDTAB")) {
table_flag = false;
open_par = false;
return (true);
} else {
goto error;
}
} else if (*ch == '(' || *ch == ')' || *ch == ',' || *ch == '=') {
if (*ch == '(') {
open_par = true;
} else if (*ch == ')') {
open_par = false;
} else if (*ch == ',' || *ch == '=') {
if (open_par) {
goto error;
}
}
ch++;
line.erase (0, ch - ch0);
} else {
goto error;
}
}
return (true);
error:
return (Syntax_Error ("Table Declaration"));
}
bool User_Program::Initial_Table (void)
{
char *token_ptr;
double fnum, *fptr;
int i, j, lnum, *lptr;
Svalue_Data *sptr, srec;
i = cmd.token;
j = cmd.value;
for (;;) {
while (*buf == ' ' && *buf != '\0') {
buf++;
}
if (*buf == '\0') break;
token_ptr = token;
//---- determine the token type ----
if ((*buf >= '0' && *buf <= '9') || (*buf == '.' && *(buf+1) != '.')) {
//---- process a number ----
do {
*token_ptr++ = *buf++;
} while ((*buf >= '0' && *buf <= '9') || (*buf == '.' && *(buf+1) != '.'));
*token_ptr = '\0';
//---- set the table size ----
if (open_par) {
lnum = atol (token);
if (lnum < 1) {
exe->Error ("%s Table %d Size %d is Out of Range", Data_Type (i), j, lnum);
return (false);
}
if (table [i] [j].Num_Records () > 0) {
exe->Write (1);
exe->Warning ("%s Table %d is Redefined", Data_Type (i), j);
table [i] [j].Reset ();
}
if (!table [i] [j].Max_Records (lnum)) goto mem_error;
} else {
if (table_type == STAB) {
exe->Error ("Attempt to Assign a Number to a String Table");
return (false);
}
//---- search for the value in the list ----
if (table_type == ITAB) {
lnum = atol (token);
for (lptr = lvalue.First (); lptr != NULL; lptr = lvalue.Next ()) {
if (*lptr == lnum) break;
}
if (lptr == NULL) {
if (!lvalue.Add (lnum)) goto mem_error;
}
lnum = lvalue.Record_Index ();
} else {
fnum = atof (token);
for (fptr = fvalue.First (); fptr != NULL; fptr = fvalue.Next ()) {
if (*fptr == fnum) break;
}
if (fptr == NULL) {
if (!fvalue.Add (fnum)) goto mem_error;
}
lnum = fvalue.Record_Index ();
}
table [i] [j].Add (lnum);
}
} else if (*buf == '"') {
if (table_type != STAB) goto error;
//---- process a string ----
buf++;
while (*buf != '"' && *buf != '\0') {
*token_ptr++ = *buf++;
}
buf++;
*token_ptr = '\0';
for (sptr = svalue.First (); sptr != NULL; sptr = svalue.Next ()) {
if (!str_cmp (sptr->string, token)) break;
}
if (sptr == NULL) {
srec.length = (int) strlen (token) + 1;
srec.string = new char [srec.length];
if (srec.string == NULL) goto mem_error;
str_cpy (srec.string, srec.length, token);
if (!svalue.Add (&srec)) goto mem_error;
}
lnum = svalue.Record_Index ();
table [i] [j].Add (lnum);
} else if ((*buf >= 'A' && *buf <= 'Z') || (*buf >= 'a' && *buf <= 'z')) {
do {
*token_ptr++ = *buf++;
} while ((*buf >= 'A' && *buf <= 'Z') || (*buf >= 'a' && *buf <= 'z') ||
(*buf >= '0' && *buf <= '9') || (*buf == '.' && *(buf+1) != '.') || *buf == '_');
*token_ptr = '\0';
if (!(str_cmp ("ENDTAB", token))) {
table_flag = false;
open_par = false;
return (true);
} else {
goto error;
}
} else if (*buf == '(' || *buf == ')' || *buf == ',' || *buf == '=') {
if (*buf == '(') {
open_par = true;
} else if (*buf == ')') {
open_par = false;
} else if (*buf == ',' || *buf == '=') {
if (open_par) {
goto error;
}
}
buf++;
} else {
goto error;
}
}
return (true);
error:
return (Syntax_Error ("Table Declaration"));
mem_error:
exe->Error ("Insufficient Memory for %s Table %d", Data_Type (i), j);
return (false);
}
bool User_Program::Process_Command (int type)
{
static int math_level [] = {
0, 0, 1, 1, 2, 3, 4
};
static int rel_level [] = {
2, 2, 2, 2, 2, 2, 1, 0, 0
};
int i, jump;
while (level > 1) {
cmd_ptr = token_level [level];
if (type == MATH) {
if (cmd_ptr->type != MATH) return (true);
if (math_level [cmd_ptr->token - PLUS] <
math_level [cmd.token - PLUS]) return (true);
} else if (type == RELATION) {
if (cmd_ptr->type != RELATION) return (true);
if (rel_level [cmd_ptr->token - EQ] < rel_level [cmd.token - EQ]) return (true);
} else if (type == LIMIT && cmd_ptr->token == OPEN_PAR) {
if (cmd.token == CLOSE_PAR) {
cmd_ptr = token_level [--level];
if (cmd_ptr->type == FUNCTION || cmd_ptr->type == CONVERT ||
cmd_ptr->type == DATETIME || cmd_ptr->type == IN_OUT ||
cmd_ptr->type == TABLE || cmd_ptr->type == RETURN) {
cmd_ptr = token_level [level--];
if (!command.Add (cmd_ptr)) goto mem_error;
}
}
return (true);
} else if (type == LIMIT && cmd_ptr->token == IF) {
if (cmd.token == THEN) {
if (level == if_level + 1) level--;
return (true);
}
return (Syntax_Error ("Logical"));
}
if (cmd_ptr->token == EQUALS) {
if (!command.Add (cmd_ptr)) goto mem_error;
cmd_ptr = token_level [--level];
if (!command.Add (cmd_ptr)) goto mem_error;
level--;
if (type == LIMIT) return (true);
} else if (cmd_ptr->type == LOGICAL) {
if (type != LOGICAL) return (true);
level--;
if (cmd_ptr->token == WHILE) {
if (cmd.token != LOOP) {
return (Syntax_Error ("Loop"));
}
if (!command.Add (cmd_ptr)) goto mem_error;
while_jump [loop] = command.Record_Index ();
num_break [loop] = 0;
} else if (cmd_ptr->token == LOOP) {
if (cmd.token == ENDLOOP) {
//---- add the loop jump ----
cmd_ptr->value = loop_jump [loop];
if (!command.Add (cmd_ptr)) goto mem_error;
//---- add the break jumps ----
jump = command.Record_Index ();
for (i=0; i < num_break [loop]; i++) {
cmd_ptr = command [break_jump [loop] [i]];
if (cmd_ptr != NULL) {
cmd_ptr->value = jump;
}
}
//---- add the while jump ----
cmd_ptr = command [while_jump [loop]];
if (cmd_ptr != NULL) {
cmd_ptr->value = jump;
}
} else {
return (Syntax_Error ("Loop"));
}
} else if (cmd_ptr->token == IF) {
if (cmd.token != THEN) {
return (Syntax_Error ("Logical"));
}
if (!command.Add (cmd_ptr)) goto mem_error;
if_jump [nest] = command.Record_Index ();
} else if (cmd_ptr->token == THEN) {
if (cmd.token == ELSE || cmd.token == ENDIF) {
if (cmd.token == ELSE) {
if (!command.Add (cmd_ptr)) goto mem_error;
then_jump [nest] = jump = command.Record_Index ();
} else {
jump = command.Num_Records ();
}
cmd_ptr = command [if_jump [nest]];
if (cmd_ptr != NULL) {
cmd_ptr->value = jump;
}
} else {
return (Syntax_Error ("Logical"));
}
} else if (cmd_ptr->token == ELSE) {
if (cmd.token != ENDIF) {
return (Syntax_Error ("Logical"));
}
jump = command.Num_Records ();
cmd_ptr = command [then_jump [nest]];
if (cmd_ptr != NULL) {
cmd_ptr->value = jump;
}
}
return (true);
} else {
if (!command.Add (cmd_ptr)) goto mem_error;
level--;
}
}
return (true);
mem_error:
exe->Error ("Insufficient Memory for Token Processing");
return (false);
}
