int main(){
char ch,ch1,ch2;
int i,len,pointer,cmp,repeat;
struct node * stack,*temp;
struct ret_val * res;
printf("Enter the given expression\n");
scanf("%s",arr);
len=strlen(arr);
pointer=0;
stack=NULL;
repeat=0;
for(i=0;i<len;i++){
if(repeat==0)
ch1=arr[i];
if(ch1>='A' && ch1<='Z'){
final[pointer]=ch1;
pointer++;
}
else if(ch1=='('){
temp=PUSH(stack,'(');
stack=temp;
}
else if(ch1==')'){
ch=TOP(stack);
while(ch!='('){
res=POP(stack);
ch2=res->ch;
stack=res->stack;
final[pointer]=ch2;
pointer++;
ch=TOP(stack);
}
void plus(VM* vm, VAL* oldbase) {
INITFRAME;
RESERVE(2);
ADDTOP(2);
switch(TAG(LOC(0))) {
case 0:
PROJECT(vm, LOC(0), 2, 0);
RVAL = LOC(1);
TOPBASE(0);
REBASE;
break;
case 1:
PROJECT(vm, LOC(0), 2, 1);
RESERVE(2);
TOP(0) = LOC(2);
TOP(1) = LOC(1);
STOREOLD;
BASETOP(0);
ADDTOP(2);
CALL(plus);
LOC(3) = RVAL;
RVAL = MKCON(vm, 1, 1, LOC(3));
TOPBASE(0);
REBASE;
break;
}
}
void su_vector_pop(su_state *s, int idx, int num) {
int i;
int n = (int)STK(TOP(num))->obj.num;
value_t vec = *STK(TOP(idx));
for (i = 0; i < n; i++)
vec = vector_pop(s, vec.obj.vec);
push_value(s, &vec);
}
NODE *
get_argument(int i)
{
NODE *t;
int arg_count, pcount;
INSTRUCTION *pc;
pc = TOP()->code_ptr; /* Op_ext_builtin instruction */
pcount = (pc + 1)->expr_count; /* max # of arguments */
arg_count = pc->expr_count; /* # of arguments supplied */
if (i < 0 || i >= pcount || i >= arg_count)
return NULL;
t = PEEK(arg_count - i);
if (t->type == Node_param_list)
t = GET_PARAM(t->param_cnt);
if (t->type == Node_array_ref) {
if (t->orig_array->type == Node_var) {
/* already a scalar, can no longer use it as array */
t->type = Node_var;
t->var_value = Nnull_string;
return t;
}
return t->orig_array; /* Node_var_new or Node_var_array */
}
if (t->type == Node_var) /* See Case Node_var in setup_frame(), eval.c */
return Nnull_string;
/* Node_var_new, Node_var_array or Node_val */
return t;
}
int su_map_has(su_state *s, int idx) {
value_t v = *STK(-1);
unsigned hash = hash_value(&v);
v = map_get(s, STK(TOP(idx))->obj.m, &v, hash);
s->stack_top--;
return v.type != SU_INV;
}
boolean Correct(char ext[], int n)
{
STACK S;
char x;
int j=0;
MAKENULL(S);
while(ext[j])
{
if(ext[j]=='(')
PUSH('(', S);
else if(ext[j]==')')
{
x=TOP(S);
if(x=='(')
POP(S);
else
return FALSE;
}
j++;
}
if(!EMPTY(S))
return FALSE;
else
return TRUE;
}
int adventurerCard(int z, int handPos, int currentPlayer, struct gameState *state, int drawntreasure, int cardDrawn) {
int origSize = state->playedCardCount;
for(drawntreasure = 0; drawntreasure < 2; )
{
//draw a card as needed
if(drawCard(currentPlayer, state) == -1)
break;
//check that the card drawn is on top
int cardDrawn = TOP(hand, currentPlayer);
if(isTreasure(cardDrawn))
drawntreasure++;
else
{
//discard all cards in play that have been drawn into a "reveal pile"
//if we put straight into discard then we can create an infinite loop
state->playedCards[state->playedCardCount++] = cardDrawn;
POP(hand, currentPlayer); //this should just remove the top card (the most recently drawn one).
}
}
moveFromOffset(state->discard[currentPlayer], state->playedCards,
state->discardCount+currentPlayer, &state->playedCardCount, origSize);
//put played card in discard pile
discardCard(handPos, currentPlayer, state, 0);
return 0;
}
void natToInt(VM* vm, VAL* oldbase) {
INITFRAME;
RESERVE(3);
ADDTOP(3);
switch(TAG(LOC(0))) {
case 0:
PROJECT(vm, LOC(0), 2, 0);
RVAL = MKINT(0);
TOPBASE(0);
REBASE;
break;
case 1:
PROJECT(vm, LOC(0), 1, 1);
RESERVE(1);
TOP(0) = LOC(1);
STOREOLD;
BASETOP(0);
ADDTOP(1);
CALL(natToInt);
LOC(2) = RVAL;
RVAL = ADD(LOC(2), MKINT(1));
TOPBASE(0);
REBASE;
break;
}
}
void *su_todata(su_state *s, const su_data_class_t **vt, int idx) {
value_t *v = STK(TOP(idx));
if (v->type == SU_NATIVEDATA) {
if (vt) *vt = v->obj.data->vt;
return (void*)v->obj.data->data;
}
return NULL;
}
void su_vector_push(su_state *s, int idx, int num) {
int i;
value_t vec = *STK(TOP(idx));
for (i = 0; i < num; i++)
vec = vector_push(s, vec.obj.vec, STK(-(num - i)));
s->stack_top -= num;
push_value(s, &vec);
}
int main() {
int* result;
printf("Starting:\n");
result = TOP();
dumpValue(result);
printf("Done: %d words allocated.\n",freeHeap);
printf("Result Address = %08x\n", result);
return 0;
}
int main(){
STACK S, *S_PTR = &S;
int x = 7;
MAKE_NULL(S_PTR);
PUSH(x, S_PTR);
printf("%d", TOP(S));
getchar();
}
const char *su_tostring(su_state *s, int idx, unsigned *size) {
string_t *str;
value_t *v = STK(TOP(idx));
if (v->type == SU_STRING) {
str = (string_t*)v->obj.gc_object;
if (size) *size = str->size;
return str->str;
}
if (size) *size = 0;
return NULL;
}
int su_map_get(su_state *s, int idx) {
value_t v = *STK(-1);
unsigned hash = hash_value(&v);
v = map_get(s, STK(TOP(idx))->obj.m, &v, hash);
if (v.type == SU_INV) {
s->stack_top--;
return 0;
}
s->stack[s->stack_top - 1] = v;
return 1;
}
void CSharpFlatCodeGen::RET( ostream &ret, bool inFinish )
{
ret << "{" << vCS() << " = " << STACK() << "[--" << TOP() << "];";
if ( postPopExpr != 0 ) {
ret << "{";
INLINE_LIST( ret, postPopExpr, 0, false );
ret << "}";
}
ret << CTRL_FLOW() << "goto _again;}";
}
int su_unpack_seq(su_state *s, int idx) {
int num = 0;
value_t tmp;
value_t v = *STK(TOP(idx));
while (isseq(s, &v)) {
tmp = v.obj.q->vt->first(s, v.obj.q);
push_value(s, &tmp);
v = v.obj.q->vt->rest(s, v.obj.q);
num++;
}
return num;
}
void OCamlTabCodeGen::RET( ostream &ret, bool inFinish )
{
ret << "begin " << vCS() << " <- " << AT(STACK(), PRE_DECR(TOP()) ) << "; ";
if ( postPopExpr != 0 ) {
ret << "begin ";
INLINE_LIST( ret, postPopExpr, 0, false );
ret << "end ";
}
ret << CTRL_FLOW() << "raise Goto_again end";
}
void OCamlTabCodeGen::CALL( ostream &ret, int callDest, int targState, bool inFinish )
{
if ( prePushExpr != 0 ) {
ret << "begin ";
INLINE_LIST( ret, prePushExpr, 0, false );
}
ret << "begin " << AT( STACK(), POST_INCR(TOP()) ) << " <- " << vCS() << "; ";
ret << vCS() << " <- " << callDest << "; " << CTRL_FLOW() << "raise Goto_again end ";
if ( prePushExpr != 0 )
ret << "end";
}
void TabCodeGen::CALL( ostream &ret, int callDest, int targState, bool inFinish )
{
if ( prePushExpr != 0 ) {
ret << "{";
INLINE_LIST( ret, prePushExpr, 0, false, false );
}
ret << "{" << STACK() << "[" << TOP() << "++] = " << vCS() << "; " << vCS() << " = " <<
callDest << "; " << CTRL_FLOW() << "goto _again;}";
if ( prePushExpr != 0 )
ret << "}";
}
int do_main(VM* vm, VAL* oldbase) {
INITFRAME;
RESERVE(2);
ADDTOP(2);
LOC(0) = MKCON(vm, 0, 0);
LOC(0) = MKCON(vm, 1, 1, LOC(0));
LOC(0) = MKCON(vm, 1, 1, LOC(0));
dumpVal(LOC(0));
printf("\n");
LOC(1) = MKCON(vm, 0, 0);
LOC(1) = MKCON(vm, 1, 1, LOC(1));
LOC(1) = MKCON(vm, 1, 1, LOC(1));
RESERVE(2);
TOP(0) = LOC(0);
TOP(1) = LOC(1);
STOREOLD;
BASETOP(0);
ADDTOP(2);
CALL(plus);
LOC(0) = RVAL;
RESERVE(1);
TOP(0) = LOC(0);
SLIDE(vm, 1);
TOPBASE(1);
TAILCALL(natToInt);
/* STOREOLD;
BASETOP(0);
ADDTOP(1);
CALL(natToInt);
TOPBASE(0);
REBASE; */
}
void OCamlTabCodeGen::CALL_EXPR( ostream &ret, GenInlineItem *ilItem, int targState, bool inFinish )
{
if ( prePushExpr != 0 ) {
ret << "begin ";
INLINE_LIST( ret, prePushExpr, 0, false );
}
ret << "begin " << AT(STACK(), POST_INCR(TOP()) ) << " <- " << vCS() << "; " << vCS() << " <- (";
INLINE_LIST( ret, ilItem->children, targState, inFinish );
ret << "); " << CTRL_FLOW() << "raise Goto_again end ";
if ( prePushExpr != 0 )
ret << "end";
}
void TabCodeGen::CALL_EXPR( ostream &ret, GenInlineItem *ilItem, int targState, bool inFinish )
{
if ( prePushExpr != 0 ) {
ret << "{";
INLINE_LIST( ret, prePushExpr, 0, false, false );
}
ret << "{" << STACK() << "[" << TOP() << "++] = " << vCS() << "; " << vCS() << " = (";
INLINE_LIST( ret, ilItem->children, targState, inFinish, false );
ret << "); " << CTRL_FLOW() << "goto _again;}";
if ( prePushExpr != 0 )
ret << "}";
}
void ESISAPI
ESIS_EmptyElem(ESIS_Writer pe, ESIS_Elem *elem)
{
size_t n;
if (elem->atts != NULL)
ESIS_Atts(pe, elem->atts);
pe->r_gi = TOP();
n = strlen(elem->elemGI) + 1U;
esisStackPush(pe->S, elem->elemGI, n);
ShipTag(pe, ESIS_EMPTY_, elem->elemGI, pe->n_att, pe->r_att);
pe->n_att = 0U;
}
void ESISAPI
ESIS_Start(ESIS_Writer pe, const ESIS_Char *elemGI,
const ESIS_Char **atts)
{
size_t n;
if (atts != NULL)
ESIS_Atts(pe, atts);
pe->r_gi = TOP();
n = strlen(elemGI) + 1U;
esisStackPush(pe->S, elemGI, n);
ShipTag(pe, ESIS_START_, elemGI, pe->n_att, pe->r_att);
pe->n_att = 0;
}
NODE *
get_actual_argument(int i, bool optional, bool want_array)
{
NODE *t;
char *fname;
int pcount;
INSTRUCTION *pc;
pc = TOP()->code_ptr; /* Op_ext_builtin instruction */
fname = (pc + 1)->func_name;
pcount = (pc + 1)->expr_count;
t = get_argument(i);
if (t == NULL) {
if (i >= pcount) /* must be fatal */
fatal(_("function `%s' defined to take no more than %d argument(s)"),
fname, pcount);
if (! optional)
fatal(_("function `%s': missing argument #%d"),
fname, i + 1);
return NULL;
}
if (t->type == Node_var_new) {
if (want_array)
return force_array(t, false);
else {
t->type = Node_var;
t->var_value = dupnode(Nnull_string);
return t->var_value;
}
}
if (want_array) {
if (t->type != Node_var_array)
fatal(_("function `%s': argument #%d: attempt to use scalar as an array"),
fname, i + 1);
} else {
if (t->type != Node_val)
fatal(_("function `%s': argument #%d: attempt to use array as a scalar"),
fname, i + 1);
}
assert(t->type == Node_var_array || t->type == Node_val);
return t;
}
int eval(int n, int m) {
matrix* mtx = ISEMPTY()? 0: TOP();
if (mtx) {
if (mtx->m == n) {
mtx->m = m;
comp += (mtx->n * n * m);
return 1;
} else {
return 0;
}
} else {
mtx = malloc(sizeof(*mtx));
mtx->n = n;
mtx->m = m;
PUSH(mtx);
return 1;
}
}
/**
* Calculate the combined advisory minimum size of all components
*
* @return Advisory minimum size for the container
*/
static size2_t minimum_size(__this__)
{
itk_component** children = CONTAINER(this)->children;
long i, n = CONTAINER(this)->children_count;
size2_t rc;
rc.width = rc.height = 0;
rc.defined = true;
for (i = 0; i < n; i++)
if ((*(children + i))->visible)
{
if (rc.width < (*(children + i))->minimum_size.width)
rc.width = (*(children + i))->minimum_size.width;
if (rc.height < (*(children + i))->minimum_size.height)
rc.height = (*(children + i))->minimum_size.height;
}
rc.width += LEFT(this) + RIGHT(this);
rc.height += TOP(this) + BOTTOM(this);
return rc;
}
/**
* Constructor
*
* @param container The container which uses the layout manager
* @param left The size of the left margin
* @param top The size of the top margin
* @param right The size of the right margin
* @param bottom The size of the bottom margin
*/
itk_layout_manager* itk_new_margin_layout(itk_component* container, dimension_t left, dimension_t top, dimension_t right, dimension_t bottom)
{
itk_layout_manager* rc = malloc(sizeof(itk_layout_manager));
dimension_t* margins = malloc(4 * sizeof(dimension_t));
rc->data = malloc(2 * sizeof(void*));
rc->prepare = prepare;
rc->done = done;
rc->locate = locate;
rc->minimum_size = minimum_size;
rc->preferred_size = preferred_size;
rc->maximum_size = maximum_size;
rc->free = free_margin_layout;
CONTAINER_(rc) = container;
MARGINS_(rc) = margins;
LEFT(rc) = left;
TOP(rc) = top;
RIGHT(rc) = right;
BOTTOM(rc) = bottom;
return rc;
}
void su_seq(su_state *s, int idx, int reverse) {
value_t v;
value_t *seq = STK(TOP(idx));
switch (su_type(s, idx)) {
case SU_NIL:
su_pushnil(s);
return;
case SU_VECTOR:
v = it_create_vector(s, seq->obj.vec, reverse);
break;
case SU_MAP:
v = tree_create_map(s, seq->obj.m);
break;
case SU_STRING:
v = it_create_string(s, seq->obj.str, reverse);
break;
case SU_SEQ:
if (reverse) {
su_seq_reverse(s, idx);
return;
} else {
v = *seq;
}
break;
case SU_NUMBER:
if (reverse)
v = range_create(s, (int)seq->obj.num, 0);
else
v = range_create(s, 0, (int)seq->obj.num);
break;
case SU_FUNCTION:
case SU_NATIVEFUNC:
if (!reverse) {
v = lazy_create(s, seq);
break;
}
default:
su_error(s, "Can't sequence object of type: %s", type_name((su_object_type_t)seq->type));
}
push_value(s, &v);
}
uint16_t * edges(uint16_t *strip) {
static unsigned int t;
unsigned int i = 0;
for(; LEFT(i); ++i) {
strip[i] = LED_RED;
}
for(; TOP(i); ++i) {
strip[i] = LED_GREEN;
}
for(; RIGHT(i); ++i) {
strip[i] = LED_BLUE;
}
for(; BOTTOM(i); ++i) {
strip[i] = LED_YELLOW;
}
++t;
return strip;
}
