exprtree*
make_for (scanner_ident_t *counter_name_ident, exprtree *counter_init, exprtree *start, exprtree *end, exprtree *body)
{
scanner_region_t region = counter_name_ident->region;
if (start->result.length != 1 || end->result.length != 1 || start->result.number != end->result.number)
{
sprintf(error_string, _("The start and end of a for loop interval must be tuples of the same tag and length 1."));
error_region = region;
JUMP(1);
}
else
{
char end_name_buf[MAX_GENSYM_LEN];
char *end_name = gensym(end_name_buf);
scanner_ident_t *end_name_ident = scanner_make_ident(scanner_null_region, end_name);
exprtree *end_init = make_assignment(end_name_ident, end);
exprtree *init = make_sequence(counter_init, end_init);
exprtree *inc = make_assignment(counter_name_ident,
make_function_from_string("__add",
exprlist_append(make_var(counter_name_ident),
make_int_number(1, scanner_null_region)),
scanner_null_region));
exprtree *invariant = make_function_from_string("__lessequal", exprlist_append(make_var(counter_name_ident),
make_var(end_name_ident)),
scanner_null_region);
free(end_name_ident);
return make_sequence(init, make_while(invariant, make_sequence(body, inc)));
}
}
//
// make_var
//
static SourceExpression::Pointer make_var(SourceTokenizerC *in,
SourceContext *context, LinkageSpecifier linkSpec, SourcePosition const &pos,
VariableType::Reference type, StoreData const &store, bool externDef)
{
// If not followed by an identifier, then don't try to read any names.
// (This is needed for standalone struct definitions.)
if (!in->peekType(SourceTokenC::TT_NAM))
return SourceExpression::create_value_data
(VariableType::get_bt_void(), context, pos);
SourceExpression::Vector vars;
// Read source name.
std::string nameSrc = in->get(SourceTokenC::TT_NAM)->data;
vars.push_back(make_var(in, context, linkSpec, pos, nameSrc, type, store, externDef));
// Read in any additional variables.
while (in->peekType(SourceTokenC::TT_COMMA))
{
in->get(SourceTokenC::TT_COMMA);
nameSrc = in->get(SourceTokenC::TT_NAM)->data;
vars.push_back(make_var(in, context, linkSpec, pos, nameSrc, type, store, externDef));
}
if (vars.size() == 1)
return vars[0];
else
return SourceExpression::create_value_block(vars, context, pos);
}
//
// make_var
//
static SourceExpression::Pointer make_var(SourceTokenizerC *in,
SourceContext *context, LinkageSpecifier linkSpec, SourcePosition const &pos,
StoreData &store, bool externDef)
{
// Read variable type.
VariableType::Reference type = SourceExpressionDS::make_type(in, context);
// STORE_CONST is used to signal automatic storetype selection.
if (store.type == STORE_CONST)
{
if(context->getType() == SourceContext::CT_NAMESPACE)
{
if (type->getBasicType() == VariableType::BT_ARR)
store.type = store_staticarray();
else
store.type = store_staticregister();
}
else
{
if (type->getBasicType() == VariableType::BT_ARR)
store.type = store_autoarray();
else
store.type = store_autoregister();
}
}
return make_var(in, context, linkSpec, pos, type, store, externDef);
}
static struct term *_term_parse(struct lexer *lex, enum term_parse_res *res)
{
struct term *ret = NULL;
switch(lex->type) {
case TOK_NONE:
*res = PARSE_EXPECTED_TERM;
break;
case TOK_LPAREN:
lexer_advance(lex);
ret = _lparen_parse(lex, res);
break;
case TOK_RPAREN:
*res = PARSE_UNEXPECTED_RPAREN;
break;
case TOK_LAMBDA:
lexer_advance(lex);
ret = _lambda_parse(lex, res);
break;
case TOK_DOT:
*res = PARSE_UNEXPECTED_DOT;
break;
case TOK_SYM:
ret = make_var(lex->sym);
lexer_advance(lex);
break;
}
return ret;
}
void sci_set_ifcpp(void *p_sci, int param,struct sci_var* p_s_v)
{
var *p_v;
sci_base *p_sci_base;
debug_3 ("[sci_set_ifcpp] ..................... \r\n");
try {
p_v = make_var(p_s_v);
}
catch (sci_exception except) {
cout<< "\n sci_set_ifcpp exception:" << except.get_msg() <<":" << except.get_info() << endl;
strcpy_s(p_sci_error_msg, SCI_ERR_MSG_LEN, except.get_msg());
sci_info = except.get_info();
sci_err = SCI_ERR_BAD_VAR_TYPE;
return;
}
// you cannot cast from a non-polymorphic type using dynamic_cast
p_sci_base = static_cast <sci_base *>(p_sci);
try {
sci_set(p_sci_base, param, p_v);
}
catch (sci_exception except) {
cout<< "\n sci_set_ifcpp exception:" << except.get_msg() <<":" << except.get_info() << endl;
strcpy_s(p_sci_error_msg, SCI_ERR_MSG_LEN, except.get_msg());
sci_info = except.get_info();
sci_err = SCI_ERR_CSCI;
return;
}
delete p_v;
debug_3 ("[sci_set_ifcpp] +++++++++++++++++++++ \r\n");
return;
}
struct sci_var sci_gen_ifcpp(void *p_sci, sci_var* p_s_ce )
{
var *p_y, *p_v_ce;
sci_base *p_sci_base;
debug_3 ("[sci_gen_ifcpp] ..................... \r\n");
try {
p_v_ce = make_var(p_s_ce);
}
catch (sci_exception except) {
cout<< "\n sci_gen_ifcpp exception:" << except.get_msg() <<":" << except.get_info() << endl;
strcpy_s(p_sci_error_msg, SCI_ERR_MSG_LEN, except.get_msg());
sci_info = except.get_info();
sci_err = SCI_ERR_BAD_VAR_TYPE;
return(dummy_sci_var());
}
// you cannot cast from a non-polymorphic type using dynamic_cast
p_sci_base = static_cast <sci_base *>(p_sci);
try {
p_y = sci_gen((sci_base*)p_sci, p_v_ce);
}
catch (sci_exception except) {
cout<< "\n sci_gen_ifcpp exception:" << except.get_msg() <<":" << except.get_info() << endl;
strcpy_s(p_sci_error_msg, SCI_ERR_MSG_LEN, except.get_msg());
sci_info = except.get_info();
sci_err = SCI_ERR_CSCI;
return(dummy_sci_var());
}
delete p_v_ce;
debug_3 ("[sci_gen_ifcpp] +++++++++++++++++++++ \r\n");
return (var_to_sci(p_y));
}
term* make_implicit(variable* name) {
term* ans = make_term();
ans->tag = IMPLICIT;
ans->right = make_var(name);
return ans;
}
void
insert_target_syms::visit (t_target_definition &n)
{
if (!symtab.insert (T_VARIABLE, "TARGET", make_var (id (n.name ()))))
throw std::runtime_error ("unable to add $(TARGET) variable");
if (!symtab.insert (node_type_to_symbol_type (current_symtype), "TARGET", &n))
throw std::runtime_error ("unable to add $(TARGET) variable");
}
exprtree*
make_var_from_string (const char *name)
{
scanner_ident_t *ident = scanner_make_ident(scanner_null_region, name);
exprtree *tree = make_var(ident);
free(ident);
return tree;
}
m1_var *
var(M1_compiler *comp, char *varname, m1_expression *init) {
/* a single var is just size 1. */
m1_var *v = make_var(comp, varname, init, 1);
/* get a pointer to the type declaration */
v->sym->typedecl = type_find_def(comp, comp->parsingtype);
assert(v->sym->typedecl != NULL);
return v;
}
/*
* Create a new variable V and add V=e to the cxt.
*/
static expr_t context_update(context_t cxt, expr_t e)
{
if (expr_gettype(e) == EXPRTYPE_VAR)
panic("unexpected CSE var type");
expr_t v;
if (cseinfo_search(cxt->cseinfo, e, &v))
return v;
char *name = unique_name("F", &cxt->varid);
var_t v0 = make_var(name);
v = expr_var(v0);
cxt->cseinfo = cseinfo_destructive_insert(cxt->cseinfo, e, v);
return v;
}
void symAdd(char *id)
{
symbol = make_var();
if(!symbol_head)
{
symbol_head = symbol;
}
else
{
symbol_tail->next = symbol;
}
symbol_tail = symbol;
}
int main ()
{
typedef make_tree<std::string, std::string>::type tree;
typedef std::list<tree> term_list;
std::string const* tag_str=(std::string const*)0L;
// a(b(), c)
term_list terms;
terms.push_back (make_term(std::string("b"), term_list (), tag_str));
terms.push_back (make_var(std::string("c")));
tree t = make_term(std::string("a"), terms, tag_str);
std::cout << string_of_term (t) << std::endl;
return 0;
}
void symAdd(struct varNode* symbol)
{
symbol = make_var();
if(!symbol_head)
{
symbol_head = symbol;
}
else
{
symbol_tail->next = symbol;
}
symbol_tail = symbol;
}
void create_random_gate( gate& g, unsigned lines, bool negative, std::default_random_engine& generator )
{
std::uniform_int_distribution<unsigned> dist( 0u, lines - 1u );
std::uniform_int_distribution<unsigned> bdist( 0u, 1u );
auto controls = random_bitset( lines, generator );
auto target = dist( generator );
g.set_type( toffoli_tag() );
g.add_target( target );
auto pos = controls.find_first();
while ( pos != controls.npos )
{
if ( pos != target )
{
g.add_control( make_var( pos, negative ? ( bdist( generator ) == 1u ) : true ) );
}
pos = controls.find_next( pos );
}
}
//
// make_var
//
static SourceExpression::Pointer make_var(SourceTokenizerC *in,
SourceContext *context, LinkageSpecifier linkSpec, bool linkCheck,
SourcePosition const &pos, bool externDef)
{
// Read storage class.
StoreData store;
if(in->peekType(SourceTokenC::TT_NAM) && context->isAddressSpace(in->peek()->data))
{
SourceTokenC::Reference tok = in->get();
SourceContext::AddressSpace const &addr = context->getAddressSpace(tok->data, tok->pos);
store.type = addr.store;
store.name = addr.array;
}
else
store.type = SourceExpressionDS::make_store(in, context, &store.area);
if (linkCheck && (store.type == STORE_AUTO || store.type == STORE_REGISTER))
linkSpec = LINKAGE_INTERN;
return make_var(in, context, linkSpec, pos, store, externDef);
}
/*
invariant: no sharing between returned term and *any* arguments.
the caller must free the result.
*/
term* substitute(variable* from, term* to, term* haystack) {
if (haystack == NULL) return NULL;
check(from != NULL && to != NULL, "substitute requires non-NULL arguments");
check(term_locally_well_formed(to), "substitute requires %W to be locally well-formed", to, print_term);
check(term_locally_well_formed(haystack),"substitute requires %W to be locally well-formed", haystack, print_term);
switch(haystack->tag) {
case VAR:
if (variable_equal(from, haystack->var)) {
return term_dup(to);
} else {
return term_dup(haystack);
}
case HOLE:
return term_dup(haystack);
case LAM:
if (variable_equal(from, haystack->var)) {
return make_lambda(variable_dup(haystack->var),
substitute(from, to, haystack->left),
term_dup(haystack->right));
} else {
if (is_free(haystack->var, to)) {
variable *g = gensym(haystack->var->name);
term *tg = make_var(g);
term* new_haystack = make_lambda(variable_dup(g), term_dup(haystack->left),
substitute(haystack->var, tg, haystack->right));
free_term(tg);
term* ans = substitute(from, to, new_haystack);
free_term(new_haystack);
return ans;
}
return make_lambda(variable_dup(haystack->var),
substitute(from, to, haystack->left),
substitute(from, to, haystack->right));
}
case PI:
if (variable_equal(from, haystack->var)) {
return make_pi(variable_dup(haystack->var),
substitute(from, to, haystack->left),
term_dup(haystack->right));
} else {
if (is_free(haystack->var, to)) {
variable *g = gensym(haystack->var->name);
term *tg = make_var(g);
term* new_haystack = make_pi(variable_dup(g), term_dup(haystack->left),
substitute(haystack->var, tg, haystack->right));
free_term(tg);
term* ans = substitute(from, to, new_haystack);
free_term(new_haystack);
return ans;
}
return make_pi(variable_dup(haystack->var),
substitute(from, to, haystack->left),
substitute(from, to, haystack->right));
}
case APP:
return make_app(substitute(from, to, haystack->left),
substitute(from, to, haystack->right));
case TYPE:
return term_dup(haystack);
case DATATYPE:
{
term* ans = make_datatype_term(variable_dup(haystack->var),
haystack->num_params, haystack->num_indices);
#define SUB_VEC(dst, src, n) do { \
int __i; \
for (__i = 0; __i < n; __i++) { \
dst[__i] = substitute(from, to, src[__i]); \
} \
} while(0)
SUB_VEC(ans->params, haystack->params, haystack->num_params);
SUB_VEC(ans->indices, haystack->indices, haystack->num_indices);
return ans;
}
case INTRO:
{
term* ans = make_intro(variable_dup(haystack->var),
substitute(from, to, haystack->left),
haystack->num_args,
haystack->num_params,
haystack->num_indices);
SUB_VEC(ans->args, haystack->args, haystack->num_args);
SUB_VEC(ans->params, haystack->params, haystack->num_params);
SUB_VEC(ans->indices, haystack->indices, haystack->num_indices);
return ans;
}
case ELIM:
{
term* ans = make_elim(variable_dup(haystack->var), haystack->num_args, haystack->num_params, haystack->num_indices);
SUB_VEC(ans->args, haystack->args, haystack->num_args);
SUB_VEC(ans->params, haystack->params, haystack->num_params);
SUB_VEC(ans->indices, haystack->indices, haystack->num_indices);
return ans;
}
case IMPLICIT:
return term_dup(haystack);
default:
sentinel("malformed term with tag %d", haystack->tag);
}
error:
return NULL;
}
int syntactically_identical(term* a, term* b) {
if (a == NULL || b == NULL) return a == b;
check(term_locally_well_formed(a) && term_locally_well_formed(b),
"alpha equiv requires well-formed arguments");
if (a->tag == HOLE) {
log_info("Hole should unify with %W", b, print_term);
return 1;
}
if (b->tag == HOLE) {
log_info("Hole should unify with %W", a, print_term);
return 1;
}
if (a->tag != b-> tag) return 0;
switch (a->tag) {
case VAR:
return variable_equal(a->var, b->var);
case LAM:
{
if (a->left != NULL && b->left != NULL && !syntactically_identical(a->left, b->left))
return 0;
if (variable_equal(a->var, b->var))
return syntactically_identical(a->right, b->right);
term* va = make_var(variable_dup(a->var));
term* bsubs = substitute(b->var, va, b->right);
free_term(va);
term* c = make_lambda(variable_dup(a->var), term_dup(b->left), bsubs);
int ans = syntactically_identical(a, c);
free_term(c);
return ans;
}
case PI:
{
if (!syntactically_identical(a->left, b->left))
return 0;
if (variable_equal(a->var, b->var))
return syntactically_identical(a->right, b->right);
term* va = make_var(variable_dup(a->var));
term* bsubs = substitute(b->var, va, b->right);
free_term(va);
term* c = make_pi(variable_dup(a->var), term_dup(b->left), bsubs);
int ans = syntactically_identical(a, c);
free_term(c);
return ans;
}
case APP:
return
syntactically_identical(a->left, b->left) &&
syntactically_identical(a->right, b->right);
case DATATYPE:
{
if (!variable_equal(a->var, b->var)) {
return 0;
}
#define EQ_VEC(a, an, b, bn) do { \
if (an != bn) return 0; \
int __i; \
for (__i = 0; __i < an; __i++) { \
if (!syntactically_identical(a[__i], b[__i])) return 0; \
} \
} while(0)
EQ_VEC(a->params, a->num_params, b->params, b->num_params);
EQ_VEC(a->indices, a->num_indices, b->indices, b->num_indices);
return 1;
}
case INTRO:
case ELIM:
{
if (!variable_equal(a->var, b->var)) {
return 0;
}
EQ_VEC(a->args, a->num_args, b->args, b->num_args);
EQ_VEC(a->params, a->num_params, b->params, b->num_params);
EQ_VEC(a->indices, a->num_indices, b->indices, b->num_indices);
return 1;
}
case TYPE:
return 1;
case IMPLICIT:
return syntactically_identical(a->right, b->right);
default:
sentinel("malformed term");
}
error:
return 0;
}
/*
* Create a new CNF Boolean variable.
*/
static expr_t cnf_new_var(context_t context)
{
var_t v0 = make_var(unique_name("C", &context->varid));
expr_t v = expr_var(v0);
return v;
}
/*
* Get a name token.
*/
static token_t token_getname(context_t cxt, term_t *val)
{
char buf0[TOKEN_MAXLEN+1];
char *buf = buf0;
size_t len = 0;
if (*cxt->str == '\'')
{
cxt->str++;
buf = token_readstring(cxt, '\'');
if (buf == NULL)
return TOKEN_ERROR;
}
else
{
while (isalnum(*cxt->str) || *cxt->str == '_')
{
buf[len++] = *cxt->str++;
if (len >= TOKEN_MAXLEN)
return TOKEN_ERROR;
}
buf[len] = '\0';
}
// Check for anonymous variable:
if (buf[0] == '_' && buf[1] == '\0')
{
var_t v = make_var(NULL);
term_t t = term_var(v);
*val = t;
return TOKEN_VARIABLE;
}
// Check for special name:
name_t entry = name_lookup(buf);
if (entry != NULL)
{
*val = entry->val;
return entry->token;
}
// Check for variable:
term_t t;
if (varset_search(cxt->vars, buf, &t))
{
*val = t;
return TOKEN_VARIABLE;
}
// By default, create a new variable:
char *name;
if (buf == buf0)
{
name = (char *)gc_malloc(len+1);
strcpy(name, buf);
}
else
name = buf;
register_name(name);
var_t v = make_var(name);
t = term_var(v);
cxt->vars = varset_insert(cxt->vars, name, t);
*val = t;
return TOKEN_VARIABLE;
}
m1_var *
array(M1_compiler *comp, char *varname, unsigned num_elems, m1_expression *init) {
m1_var *v = make_var(comp, varname, init, num_elems);
return v;
}
struct assignNode* assignment()
{
struct assignNode* assign;
struct varNode* var;
struct varNode* op;
int oper;
var = symSearch(token);
if(var != NULL)
{
//printf("var: %s\n",var->vID);
assign = make_assign(var);
ttype = getToken();
if(ttype == EQUAL)
{
//printf("EQUAL: %d\n",ttype);
//assign = expr(assign);
ttype = getToken();
if (ttype == NUM)
{
//printf("NUM: %d\n",ttype);
op = make_var();
if(symSearch(token) == NULL)
{
symAdd(op);
}
assign->op1 = symSearch(token);
/*assign->op1 = primary(assign->op1);
ttype = getToken();
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype; //op is set + - * /
assign->op2 = primary(assign->op2);
}
ungetToken();
return assign;*/
}
else if (ttype == ID)
{
assign->op1 = symSearch(token);
//printf("assign->op1->vValue %d\n", assign->op1->vValue);
/*printf("ID: %d\n",ttype);
assign->op1 = primary(assign->op1);
printf("ASSIGN ID %s\n", assign->op1->id);
ttype = getToken();
printf("PLUS: %d\n",ttype);
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype;
ttype = getToken();
if(ttype == ID)
{
printf("ID: %d\n",ttype);
assign->op2 = primary(assign->op2);
return assign;
}
else
{
ungetToken();
}
}
else
{
return NULL;
}
*/
}
ttype = getToken();
//printf("SIGN %d\n", ttype);
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype;
ttype = getToken();
if (ttype == NUM)
{
//printf("NUM: %d\n",ttype);
op = make_var();
if(symSearch(token) == NULL)
{
symAdd(op);
}
assign->op2 = symSearch(token);
/*assign->op1 = primary(assign->op1);
ttype = getToken();
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype; //op is set + - * /
assign->op2 = primary(assign->op2);
}
ungetToken();
return assign;*/
}
else if (ttype == ID)
{
assign->op2 = symSearch(token);
//printf("assign->op2->vValue %d\n", assign->op2->vValue);
/*printf("ID: %d\n",ttype);
assign->op1 = primary(assign->op1);
printf("ASSIGN ID %s\n", assign->op1->id);
ttype = getToken();
printf("PLUS: %d\n",ttype);
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype;
ttype = getToken();
if(ttype == ID)
{
printf("ID: %d\n",ttype);
assign->op2 = primary(assign->op2);
return assign;
}
else
{
ungetToken();
}
}
else
{
return NULL;
}
*/
}
return assign;
}
else
{
ungetToken();
return assign;
}
}
else
{
return NULL;
}
}
else
{
return NULL;
}
}
struct conditionNode* condition()
{
struct conditionNode* cNode;
struct varNode* var;
//struct varNode* op2;
struct statementNode* tBranch;
struct statementNode* fBranch;
int op;
cNode = make_condition();
ttype = getToken();
//printf("ttype %d ln 1272\n", ttype);
if ((ttype == ID)||(ttype == NUM))
{
//ungetToken(); //ungetToken since it still be parsed
if(ttype == NUM)
{
var = make_var();
if(symSearch(token) == NULL)
{
symAdd(var);
}
cNode->op1 = symSearch(token);
}
else if (ttype == ID)
{
cNode->op1 = symSearch(token); //left operand of a condition is a primary
}
ttype = getToken();
//printf("ttype %d ln 1273\n", ttype);
if ((ttype == GREATER)||(ttype == GTEQ)||(ttype == LESS)
||(ttype == NOTEQUAL)||(ttype == LTEQ))
{
cNode->operator = ttype; //relop is set to >, <, etc.
ttype = getToken();
//printf("ttype %d ln 1280\n", ttype);
if ((ttype == ID)|(ttype == NUM))
{
//ungetToken(); //ungetToken since it still be parsed
//cNode->op2 = symSearch(token); //right operand of a condition is a primary
if(ttype == NUM)
{
var = make_var();
if(symSearch(token) == NULL)
{
symAdd(var);
}
cNode->op2 = symSearch(token);
}
else if (ttype == ID)
{
cNode->op2 = symSearch(token); //left operand of a condition is a primary
}
return cNode;
}
else
{
return NULL;
}
}
else
{
return NULL;
}
}
else
{
return NULL;
}
}
struct assignNode* expr(struct assignNode* assign)
{
struct varNode* op;
struct varNode* oper2;
int oper;
ttype = getToken();
if (ttype == NUM)
{
//printf("NUM: %d\n",ttype);
op = make_var();
if(symSearch(token) == NULL)
{
symAdd(op);
}
assign->op1 = symSearch(token);
/*assign->op1 = primary(assign->op1);
ttype = getToken();
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype; //op is set + - * /
assign->op2 = primary(assign->op2);
}
ungetToken();
return assign;*/
}
else if (ttype == ID)
{
assign->op1 = symSearch(token);
/*printf("ID: %d\n",ttype);
assign->op1 = primary(assign->op1);
printf("ASSIGN ID %s\n", assign->op1->id);
ttype = getToken();
printf("PLUS: %d\n",ttype);
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype;
ttype = getToken();
if(ttype == ID)
{
printf("ID: %d\n",ttype);
assign->op2 = primary(assign->op2);
return assign;
}
else
{
ungetToken();
}
}
else
{
return NULL;
}
*/
}
ttype = getToken();
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype;
}
ttype = getToken();
if (ttype == NUM)
{
//printf("NUM: %d\n",ttype);
op = make_var();
if(symSearch(token) == NULL)
{
symAdd(op);
}
assign->op1 = symSearch(token);
/*assign->op1 = primary(assign->op1);
ttype = getToken();
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype; //op is set + - * /
assign->op2 = primary(assign->op2);
}
ungetToken();
return assign;*/
}
else if (ttype == ID)
{
assign->op2 = symSearch(token);
/*printf("ID: %d\n",ttype);
assign->op1 = primary(assign->op1);
printf("ASSIGN ID %s\n", assign->op1->id);
ttype = getToken();
printf("PLUS: %d\n",ttype);
if ((ttype == PLUS) | (ttype == MINUS) | (ttype == MULT) | (ttype == DIV))
{
assign->oper = ttype;
ttype = getToken();
if(ttype == ID)
{
printf("ID: %d\n",ttype);
assign->op2 = primary(assign->op2);
return assign;
}
else
{
ungetToken();
}
}
else
{
return NULL;
}
*/
}
return assign;
}
