int Get_Assign (node* tree)
{
int err_index;
ASSERT_TREE_OK (tree);
node* new_tree = Node_NEW();
Tree_Add_Left (new_tree, Node_NEW());
node* tmp_tree = new_tree -> left;
int ret = Get_V (tmp_tree);
if (ret != HAPPY) if (ret == 0) return ret;
if ((*CUR) -> op != OP_ASSIGN) return ERR_CALL_GET_ASSIGN;
CUR++;
ret = Tree_Add_Right (new_tree, Node_NEW());
if (ret != HAPPY) if (ret == 0) return ret;
tmp_tree = new_tree -> right;
ret = Get_E (tmp_tree);
if (ret != HAPPY) if (ret == 0) return ret;
if ((*CUR) -> op != SEP_SEMICOLON) return ERR_SEMICOLON;
new_tree -> type = OP_ASSIGN;
Tree_Add_Left (tree, new_tree);
CUR++;
ASSERT_TREE_OK (tree);
return HAPPY;
}
int Get_P (double* result)
{
int ret = 0;
double val = 0;
switch (*CUR)
{
case '+':
CUR++;
break;
case '-':
CUR++;
ret = Get_P (&val);
val *= -1;
break;
case '(':
CUR++;
ret = Get_E (&val);
if (*CUR == ')') CUR++;
else return ERR_CLOSE_BRACKET;
break;
default:
ret = Get_N (&val);
break;
}
*result = val;
return HAPPY;
}
int Get_E (node* tree)
{
int err_index = 0;
ASSERT_TREE_OK (tree);
Tree_Add_Left (tree, Node_NEW());
Tree_Add_Right (tree, Node_NEW());
int ret = Get_T (tree -> left);
if (ret != HAPPY) if (ret == 0) return ret;
tree -> type = MATH_OP;
tree -> op = (*CUR) -> op;
if ((*CUR) -> op == MATH_OP_ADD || (*CUR) -> op == MATH_OP_SUB)
{
CUR++;
Get_E (tree -> right);
}
node* new_tree = tree -> left;
if (tree -> right -> type == 0)
{
Tree_Replace_Left (tree);
ASSERT_TREE_OK (new_tree);
return HAPPY;
}
ASSERT_TREE_OK (tree);
return HAPPY;
}
int Get_F (node* tree)
{
int err_index = 0;
ASSERT_TREE_OK (tree);
char tmp_word[TMPLEN] = {};
strcpy (tmp_word, (*CUR) -> word);
strupr (tmp_word);
int func = 0;
if (0);
CHECK_FUNC(tmp_word, SIN)
CHECK_FUNC(tmp_word, COS)
CHECK_FUNC(tmp_word, TAN)
CHECK_FUNC(tmp_word, CTAN)
CHECK_FUNC(tmp_word, LN)
CHECK_FUNC(tmp_word, LOG)
if (func == 0) return ERR_WRONG_FUNC;
CUR++;
if ((*CUR) -> op != SEP_OPEN_BRACKET) return ERR_FUNC_OPEN_BRACKET;
CUR++;
Tree_Add_Left (tree, Node_NEW());
int ret = Get_E (tree -> left);
if (ret != HAPPY) if (ret == 0) return ret;
if (func == FUNC_LOG)
{
if ((*CUR) -> op != SEP_COMMA) return ERR_FUNC_COMMA;
CUR++;
ret = Tree_Add_Right (tree, Node_NEW());
if (ret != HAPPY) if (ret == 0) return ret;
ret = Get_E (tree -> right);
if (ret != HAPPY) if (ret == 0) return ret;
}
if ((*CUR) -> op != SEP_CLOSE_BRACKET) return ERR_FUNC_CLOSE_BRACKET;
CUR++;
tree -> type = FUNC;
tree -> op = func;
ASSERT_TREE_OK (tree);
return HAPPY;
}
int Get_G3 (const char* input, double* result)
{
CUR = input;
int ret = Get_E (result);
if (!*result) *result = 0;
return HAPPY;
}
int Get_Cmp (node* tree)
{
int err_index = 0;
ASSERT_TREE_OK (tree);
node* new_tree = Node_NEW();
Tree_Add_Left (new_tree, Node_NEW());
Tree_Add_Right (new_tree, Node_NEW());
int ret = Get_E (new_tree -> left);
if (ret != HAPPY) if (ret == 0) return ret;
switch ((*CUR) -> op)
{
case CMP_JB: case CMP_JBE: case CMP_JE:
case CMP_JAE: case CMP_JA: case CMP_JNE:
new_tree -> type = CMP;
new_tree -> op = (*CUR) -> op;
CUR++;
break;
case SEP_CLOSE_BRACKET:
new_tree -> type = CMP;
new_tree -> op = CMP_JNE;
new_tree -> right -> type = NUMBER;
new_tree -> right -> num = 0;
Tree_Add_Left (tree, new_tree);
ASSERT_NODE_OK (tree);
return HAPPY;
break;
default:
return ERR_GET_CMP_WRONG_CMP;
break;
}
ret = Get_E (new_tree -> right);
if (ret != HAPPY) if (ret == 0) return ret;
Tree_Add_Left (tree, new_tree);
ASSERT_NODE_OK (tree);
return HAPPY;
}
double Get_G (const char expr_str [BUF_SIZE])
{
EXPR_PTR = expr_str;
double res = Get_E ();
if (*EXPR_PTR != '\0')
syntax_error ();
return res;
}
double Get_P ()
{
if (*EXPR_PTR == '(')
{
EXPR_PTR++;
double val1 = Get_E ();
if (*EXPR_PTR != ')')
syntax_error ();
EXPR_PTR++;
return val1;
}
else
return Get_N ();
}
int Get_Print (node* tree)
{
int err_index = 0;
ASSERT_NODE_OK (tree);
if ((*CUR) -> op != OP_PRINT) return ERR_CALL_PRINT;
node* new_tree = Node_NEW();
Tree_Add_Left (new_tree, Node_NEW());
Tree_Add_Right (new_tree, Node_NEW());
CUR++;
if ((*CUR) -> op != SEP_OPEN_BRACKET) return ERR_PRINT_OPEN_BRACKET;
CUR++;
if ((*CUR) -> type == STR)
{
new_tree -> left -> type = STR;
int ret = Get_Str (new_tree -> right);
if (ret != HAPPY) if (ret == 0) return ret;
}
else
{
new_tree -> left -> type = NUMBER;
int ret = Get_E (new_tree -> right);
if (ret != HAPPY) if (ret == 0) return ret;
}
if ((*CUR) -> op != SEP_CLOSE_BRACKET) return ERR_PRINT_CLOSE_BRACKET;
CUR++;
if ((*CUR) -> op != SEP_SEMICOLON) return ERR_PRINT_SEMICOLON;
CUR++;
new_tree -> type = OP_PRINT;
Tree_Add_Left (tree, new_tree);
ASSERT_NODE_OK (tree);
return HAPPY;
}
int Get_P (node* tree)
{
int ret = 0;
int err_index = 0;
ASSERT_TREE_OK (tree);
int sign = 1;
while ((*CUR) -> op == MATH_OP_ADD || (*CUR) -> op == MATH_OP_SUB)
{
if ((*CUR) -> op == MATH_OP_SUB) sign *= -1;
CUR++;
}
if (sign == -1)
{
tree -> type = MATH_OP;
tree -> op = MATH_OP_MUL;
tree -> left -> type = NUMBER;
tree -> left -> num = -1;
Tree_Add_Right (tree, Node_NEW());
ret = Get_E (tree -> right);
if (ret != HAPPY) if (ret == 0) return ret;
if (tree -> right -> type == 0) return ERR_GET_P_LONELY_SIGN;
ASSERT_TREE_OK (tree);
return HAPPY;
}
if ((*CUR) -> op == SEP_OPEN_BRACKET)
{
CUR++;
ret = Get_E (tree);
if (ret != HAPPY) if (ret == 0) return ret;
if ((*CUR) -> op != SEP_CLOSE_BRACKET) return ERR_GET_P_CLOSE_BRACKET;
CUR++;
ASSERT_TREE_OK (tree);
return HAPPY;
}
if ((*CUR) -> type == ID)
{
if ((*(CUR + 1)) -> op == SEP_OPEN_BRACKET) Get_F (tree);
else Get_V (tree);
ASSERT_TREE_OK (tree);
return HAPPY;
}
if ((*CUR) -> type == NUMBER)
{
ret = Get_N (tree);
ASSERT_TREE_OK (tree);
return HAPPY;
}
ASSERT_TREE_OK (tree);
return HAPPY;
}
