int main() { char s[MAXOP]; getop(s); printf("s=%s\n", s); ungets(s); getop(s); printf("s=%s\n", s); getop(s); printf("s=%s\n", s); return 0; }

/* * Write the record to the storage in case there are write and closes the * record and frees up the stuff. With the pickled buf for each udf_record * it create single pickled buf for the entire LDT to be sent to the remote * for replica. * * Parameter: * lrecord : LDT record to operate on * pickled_* (out) to be populated is null if there was delete * lrecord_op (out) is set properly for the entire ldt * set_id : Set id for record. Passed for delete operation. * * Returns: 0 on success * otherwise on failure */ static int rw_finish(ldt_record *lrecord, write_request *wr, udf_optype * lrecord_op, uint16_t set_id) { int subrec_count = 0; udf_optype h_urecord_op = UDF_OPTYPE_READ; *lrecord_op = UDF_OPTYPE_READ; udf_record *h_urecord = as_rec_source(lrecord->h_urec); bool is_ldt = false; int ret = 0; getop(h_urecord, &h_urecord_op); if (h_urecord_op == UDF_OPTYPE_DELETE) { post_processing(h_urecord, &h_urecord_op, set_id); wr->pickled_buf = NULL; wr->pickled_sz = 0; as_rec_props_clear(&wr->pickled_rec_props); *lrecord_op = UDF_OPTYPE_DELETE; } else { if (h_urecord_op == UDF_OPTYPE_WRITE) { *lrecord_op = UDF_OPTYPE_WRITE; } FOR_EACH_SUBRECORD(i, j, lrecord) { udf_optype c_urecord_op = UDF_OPTYPE_READ; udf_record *c_urecord = &lrecord->chunk[i].slots[j].c_urecord; getop(c_urecord, &c_urecord_op); if (UDF_OP_IS_WRITE(c_urecord_op)) { is_ldt = true; subrec_count++; } post_processing(c_urecord, &c_urecord_op, set_id); } // Process the parent record in the end .. this is to make sure // the lock is held till the end. post_processing(h_urecord, &h_urecord_op, set_id); if (is_ldt) { // Create the multiop pickled buf for thr_rw.c ret = as_ldt_record_pickle(lrecord, &wr->pickled_buf, &wr->pickled_sz); FOR_EACH_SUBRECORD(i, j, lrecord) { udf_record *c_urecord = &lrecord->chunk[i].slots[j].c_urecord; // Cleanup in case pickle code bailed out // 1. either because this single node run no replica // 2. failed to pack stuff up. udf_record_cleanup(c_urecord, true); } } else {

int main() { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case LIBFUNC: push(dofunc(s)); break; case GETVAR: // 1 a= a + push(get_var(s[0])); break; case SETVAR: // 1 a= op2 = pop(); save_var(op2, s[0]); push(op2); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error: zero divisor\n"); break; case '%': op2 = pop(); if (op2 != 0.0) push(fmod(pop(), op2)); else printf("error: zero divisor\n"); break; case '\n': recent_result = pop(); printf("\t = %.8g\n", recent_result); break; default: printf("error: unknown command %s\n", s); break; } } return 0; }

int main(){ int //type, len; int type; double op2; char s[MAXOP]; char line[MAXOP]; while ((len = get_line(line, MAXOP)) > 0){ lineindex = 0; while (lineindex < len){ type = getop(s, line,len); lineindex++; // printf("%f\n", (atof(s))); switch(type){ case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error: zero divisor\n"); break; case '%': op2 = pop(); push((long) pop() % (long) op2); break; case ('e'): push(exp(pop())); break; case ('^'): push(pow(pop(), pop())); break; case ('s'): push(sin(pop())); break; case '\n': printf("\t%.8g\n", pop()); break; default: printf("error: unknown command %s\n", s); break; } } } return 0; }

double calc() { double x, y; char op; pop(&x); pop(&y); op = *getop(); printf("%lf %c %lf", x, op, y); switch(op) { case POW: return pow(x, y); case MUL: return x * y; case DIV: return x / y; case SUM: return x + y; case SUB: return y - x; } printf("teste\n"); return 0; }

int main(int argc, char *argv[]) { double temp; while (--argc > 0) switch (getop(*++argv)) { case NUMBER: push(atof(argv[0])); break; case '+': push(pop() + pop()); break; case '-': temp = pop(); push(pop() - temp); break; case '*': push(pop() * pop()); break; case '/': temp = pop(); push(pop() / temp); break; default: printf("invalid operand '%s'\n", argv[0]); break; } printf("%f\n", pop()); return 0; }

void estiva_precondjacobi(MX *A, double *x, double *D, double *b) { int i,j,J,k,n, step = 2; static double *xo; if ( defop("-jacobistep") ) step = atoi(getop("-jacobistep")); n = dim1(D); ary1(xo,n+1); for (i=0; i<n; i++) xo[i] = 0.0; for(k=0;k<step;k++) { for(i=0;i<n;i++) { x[i]=b[i]; for(j=0; j< A->w; j++) { J = A->IA[i][j]; if (J != 0) if ( J-1 != i) if(A->A[i][j] !=0.0) { x[i] -= A->A[i][j]*xo[J-1]; } } x[i]=x[i]*D[i]; } for(i=0;i<n;i++) xo[i]=x[i]; } }

double cacul(char s[]) { int type; double op2; double quyu1,quyu2; double result; while((type = getop(s))!='q') { switch(type) { case NUMBER: push(sign * (atof(s))); sign=1; break; case '+': quyu1=pop(); quyu2=pop(); push(quyu1+quyu2); // push(pop()+pop()); break; case '*': push(pop()*pop()); break; case '-': op2=pop(); push(pop()-op2); break; case '/': op2=pop(); if(op2!=0.0) push(pop()/op2); else printf("error,zero divisor\n"); break; case '%': quyu1=pop(); quyu2=pop(); if(quyu2>=0) { op2=((int)quyu2%((int)quyu1)); push(op2); } else { push(-((-(int)quyu2) % (int)quyu1)); } break; case '\n': result=pop(); printf("\t%.8g\n",result); return result; default: printf("error:unknown command %s\n",s); return -1; } } return result; }

/* reverse Polish calculator */ main() { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) { push(pop() / op2); } else { printf("error: zero divisor for / operator\n"); } break; case '%': /* The modulus operator works on integers, * although the following implementation also works for floating-point numbers. * If b > 0, a % b >= 0, i.e., rounds towards negative infinity; * if b < 0, a % b <= 0, i.e., rounds towards positive infinity. * The implementation finds r = a % b, so that: * a = (k + r) * b, where k is an integer and r is in the range [0,1). */ op2 = pop(); if (op2 != 0.0) { double q = pop() / op2; double r = q - (int)q; while (r < 0 || r >= 1) { r += (r < 0) ? 1 : -1; } push(r * op2); } else { printf("error: zero divisor for \% operator\n"); } break; case '\n': printf("\t%.8g\n", pop()); break; default: printf("error: unknown command %s\n", s); break; } } return 0; }

int main(){ int type; double op2; char s[MAXOP]; while((type = getop(s)) != EOF){ switch(type) { case NUMBER: push(atof(s)); break; case '+': push(pop()+pop()); break; case '-': op2 = pop(); push(pop()-op2); break; case '*': push(pop()*pop()); break; case '/': op2 = pop(); push(pop()/op2); break; case '\n': printf("%f\n",pop()); break; default: printf("error in push():unknow command %s\n",s); break; } } return 0; }

static int pexpi (int k) { int ei0, ei1, ei2, ptok; if (lextab[k][0] == 0) return pexp5 (); if ((ei0 = pexpi (k + 1)) == -1) { SUwarning (0, "pexpi", "cannot create first expression"); return -1; } while ((ptok = getop (EEltok, k)) != -1) { if ((ei1 = EEcnew (ptok)) == -1) { SUwarning (0, "pexpi", "cannot create code"); return -1; } EEcsetfp (ei1, ei0); EElgtok (); if ((ei2 = pexpi (k + 1)) == -1) { SUwarning (0, "pexpi", "cannot create next expression"); return -1; } EEcsetnext (ei0, ei2); ei0 = ei1; } return ei0; }

int main(int argc, char *argv[]){ char s[100]; while(getop(s) != EOF){ printf("op=%s\n", s); } return 0; }

main() { char s[MAXLINE], s2[MAXLINE], s3[] = "ahoy hoy", s4[] = "oy", s5[MAXLINE]; int len, n = 12345, op; printf("Enter some text, testing getline:\n"); len = getline(s, MAXLINE); printf("echoing:\n%s\n", s); printf("converting the number %d to a string:\t", n); itoa(n, s2); printf("%s\n", s2); printf("index of '%s' in '%s': %d\n", s4, s3, strindex(s3, s4)); printf("index of '%s' in '%s': %d\n", s4, s, strindex(s, s4)); printf("Enter reverse Polish notation calculator input:\n"); while ((op = getop(s5)) != EOF) { printf("op = "); if (op) { printf("%c", op); } else { printf("%s", s5); } printf("\n"); } }

int main ( int argc, char *argv[] ) { int type; double op2; char s[MAXOP]; // 进入循环 while((type = getop(s) != EOF)) { switch (type) { case NUMBER: push(atof(s)); case '+': push(pop()+pop()); break; case '-': op2 = pop(); push(pop()-op2); break; case '*': break; case '/': break; default: break; } } return EXIT_SUCCESS; } /* ---------- end of function main ---------- */

main() { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case FUNCTION: push(calcfunctions(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error: zero divisor\n"); break; case '%': op2 = pop(); if (op2 != 0.0) push(fmod(pop(), op2)); else printf("error: zero divisor\n"); break; case '\n': printf("\t%.8g\n", pop()); break; default: printf("error: unknown command %s\n", s); break; } } return 0; }

int main() { int type; double op2; double op1; int coc; char s[MAXOP]; while ((type = getop(s)) != EOF){ switch(type){ case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error: divisor cero\n"); break; case 's': /* comando seno */ push(sin(pop())); break; case 'e': /* comando exponente de e */ push(exp(pop())); break; case 'p': /* comando potencia */ op2 = pop(); push(pow(pop(), op2)); break; case '%': op2 = pop(); op1 = pop(); if (op2 != 0.0){ coc = op1 / op2; push(op1 - (coc * op2)); } else printf("error: divisor cero\n"); break; case '\n': printf("\t%.8g\n", pop()); break; default: printf("error: comando desconocido %s\n", s); break; } } return 0; }

main() { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch(type) { case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(op2 + pop()); break; case '/': op2 = pop(); push(op2 + pop()); break; case '\n': printf("\t%.8g\n",pop()); break; default: printf("unknown character"); break; } } return 0; }

/* sort input lines */ int main(int argc, char *argv[]) { int nlines; /* number of input lines read */ int numeric = 0; /* 1 if numeric sort */ int reverse = 0; /* 1 if reverset sort */ getop(argc, argv, &numeric, &reverse); if ((nlines = readlines(lineptr, MAXLINES)) >= 0) { if (numeric){ if (reverse) { _qsort((void**) lineptr, 0, nlines - 1, (int (*) (void *, void *)) rnumcmp); } else { _qsort((void**) lineptr, 0, nlines - 1, (int (*) (void *, void *)) numcmp); } } else { if (reverse) { _qsort((void**) lineptr, 0, nlines - 1, (int (*) (void *, void *)) rstrcmp); } else { _qsort((void**) lineptr, 0, nlines - 1, (int (*) (void *, void *)) strcmp); } } writelines (lineptr, nlines); return 0; } else { printf ("input too big to sort\n"); return 1; } }

int main(int argc, char** argz) { static int count = 0; static int start = 0; static int max_size = 0; unsigned char * buffer; unsigned char * mp; mp = malloc(max_size); FILE * fp = fopen(argz[1],"rb"); //FILE * fp = fopen("/u/jiyinjie/CS429-hw3/prog9.yb","rb"); fread(buffer, 1, 2, fp); int i; // printf("%X %X\n",buffer[0],buffer[1]); // printf("\n"); if (buffer[0] != HEADER_0 || buffer[1] != HEADER_1) { printf("This is not a y86 file.\n"); return 1; // Error code 1 means incorrect file format. } while (fread(buffer, 1, 4, fp) == 4) { // printf("\nNext block:\n"); count = buffer[3] + buffer[2]*256; // printf("%d\n",count); start = buffer[1] + buffer[0]*256; int temp = count+start; max_size = (temp>max_size) ? temp : max_size; mp = realloc(mp,sizeof(char*)*max_size); static int check_count = 0; check_count = fread(buffer, 1, count, fp); if (! (count == check_count)) { printf("Corrupt object file!\n"); return 2; } for (i = 0; i < count; i++) mp[i+start] = buffer[i]; } int *tst = malloc(0); for (i = 0; i < max_size; i++) { tst = (int*) &mp[i]; printf("%04X\t",i); printf("%02X\t",mp[i]); printf("%08X\t",*tst); printf("%10d\t",*tst); printf("%s\n",getop(mp[i])); // printf("%04X\t%02X\t%08X\t%10d\t%s\n", i, mp[i], *tst, *tst, getop(mp[i])); } fclose(fp); return 0; }

/* reverse Polish calculator */ int main(){ int type; double op2; char s[MAXOP]; while((type = getop(s)) != EOF){ switch(type){ case NUMBER: push( atof(s) ); break; case '+': push(pop() + pop() ); break; case '*': push( pop() * pop() ); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if( op2 != 0.0 ){ push( pop() / op2); }else{ printf("Error: Division by zero.\n"); } break; case '\n': printf("\t%.8g\n", pop()); break; /* added modulus */ case '%': op2 = pop();/* get divisor */ push( ((int) pop()) % ((int) op2)); break; case 'p': printTop(); break; case 'd': duplicate(); break; case 's': swap(); break; case 'c': clear(); break; default: printf("Error: Unknown command %s.\n",s); break; } } return 0; }

// How many words an instruction is. static int instruction_len(uint32_t instr) { switch (getop(instr)) { case OP_SETDISPATCH: return 1 + ptr_words; case OP_TAGN: return 3; case OP_SETBIGGROUPNUM: return 2; default: return 1; } }

int testcmd(int argc, char **argv) { const struct t_op *op; enum token n; int res = 1; if (*argv[0] == '[') { if (*argv[--argc] != ']') error("missing ]"); argv[argc] = NULL; } t_wp_op = NULL; recheck: argv++; argc--; if (argc < 1) return res; /* * POSIX prescriptions: he who wrote this deserves the Nobel * peace prize. */ switch (argc) { case 3: op = getop(argv[1]); if (op && op->op_type == BINOP) { n = OPERAND; goto eval; } /* fall through */ case 4: if (!strcmp(argv[0], "(") && !strcmp(argv[argc - 1], ")")) { argv[--argc] = NULL; argv++; argc--; } else if (!strcmp(argv[0], "!")) { res = 0; goto recheck; } } n = t_lex(argv); eval: t_wp = argv; res ^= oexpr(n); argv = t_wp; if (argv[0] != NULL && argv[1] != NULL) syntax(argv[0], "unexpected operator"); return res; }

int main(void) { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case MATHLIB: if (strcmp(s, "sin") == 0) push(sin(pop())); else if (strcmp(s, "cos") == 0) push(cos(pop())); else if (strcmp(s, "pow") == 0) { op2 = pop(); push(pow(pop(), op2)); } else printf("error: unknown command %s\n", s); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error: zero divisor\n"); break; case '%': op2 = pop(); if (op2 != 0.0) push(fmod(pop(), op2)); else printf("error: zero divisor\n"); break; case '\n': printf("= %g\n", pop()); break; default: printf("error: unknown command %s\n", s); break; } } return 0; }

int main(void) { int type; double op2, op1; char s[MAXOP]; void clearsp(void); while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case '+': push(pop()+pop()); break; case '*': push(pop()*pop()); break; case '-': op2 = pop(); push(pop()-op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error:zero divisor\n"); break; case'?': op2 = pop(); printf("\t%.8g\n",op2); push(op2); break; case 'c': clearsp(); break; case 'd': op2 = pop(); push(op2); push(op2); break; case 's': op1 = pop(); op2 = pop(); push(op1); push(op2); break; case '\n': printf("\t%.8g\n", pop()); break; default: printf("error: unknown command %s\n",s); break; } } return 0; }

static void do_action1 (char *op_name, int *indx, int *op) { if (not_concrete(op_name)) { /* Delete trailing '#' from op_name. */ int len = strlen(op_name); { char s[len]; strncpy(s, op_name, len-1); s[len-1] = '\0'; (*op) = getop(s); } } else (*op) = getop(op_name); (*indx) = getindxop(*op); }

int main() /* Reverse Polish notation */ { int type; double op2; char s[MAXOP]; double ans = 0.0; while (Getline(expression, MAXOP)) while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case 'a': push(ans); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error: zero divisor\n"); break; case '%': op2 = pop(); if (op2 != 0.0) push(fmod(pop(), op2)); /* use g++ to compile */ else printf("error: zero divisor\n"); break; case SIN: push(sin(pop())); break; case EXP: push(exp(pop())); break; case POW: op2 = pop(); push(pow(pop(), op2)); break; case '\n': ans = pop(); printf("\t%.8g\n", ans); break; default: printf("error: unknown command %s\n", s); break; } if (type == '\n') break; } return 0; }

/* reverse Polish calculator */ int main() { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch (type) { case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error: zero divisor\n"); break; #ifndef ORIGINAL case '%': op2 = pop(); if ((int)op2 != 0) push((int)pop() % (int)op2); else printf("error: zero modulus\n"); break; case SIN: push(sin(pop())); break; case EXP: push(exp(pop())); break; case POW: op2 = pop(); push(pow(pop(), op2)); break; #endif case '\n': printf("\t%.8g\n", pop()); break; default: printf("error: unknown command %s\n", s); break; } } return 0; }

/** * reverse polish calculator\ * 1 2 - 4 5 + * == (1 - 2) * (4 + 5) */ int main (void) { int type; double op2; char s[MAXOP]; while ((type = getop(s)) != EOF) { switch(type) { case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': /** first pop second operand*/ op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if (op2 != 0.0) push(pop() / op2); else printf("error: division by zero\n"); break; case '%': op2 = pop(); if (op2 != 0.0) push(fmod(pop(), op2)); else printf("error: division by zero\n"); break; case '?': stack_show(); break; case '#': stack_duplicate(); break; case '~': stack_swap(); break; case '!': stack_clear(); break; case '\n': printf("\t%.8f\n", pop()); break; default: printf("error: unknown command %s\n", s); break; } } return 0; }

int main(void) { int type; char s[MAXOP]; while ((type = getop(s)) != EOF) printf("%c", type); return 0; }

main(void) { int type; double op1,op2,fracPart; char s[MAXOP]; while((type = getop(s))!= EOF){ switch(type){ case NUMBER: push(atof(s)); break; case '+': push(pop() + pop()); break; case '*': push(pop() * pop()); break; case '-': op2 = pop(); push(pop() - op2); break; case '/': op2 = pop(); if(op2 != 0.0){ push(pop() / op2); } else{ printf("error: zero divisor\n"); } break; case '%': op2 = pop(); op1 = pop(); fracPart = (op1 - ((int)op1)) + (op2 - ((int)op2)); if(fracPart != 0.0){ printf("Integer-only operation on floating point number.\n"); break; } if(op2 != 0.0){ push((int)(op1) % ((int)op2)); } else{ printf("error: zero divisor\n"); } break; case '\n': printf("\t%.8g\n",pop()); break; default: printf("error: unkown command %s\n",s); break; } } return 0; }