void printStack(stack* s){ if(emptyStack(s) == 1){ printf("\nThe stack is empty.\n"); return; } stack* tempS = createStack(); dnode* tempN = frontStack(s); data* d = createData(tempN->d->i1,tempN->d->i2,tempN->d->f1); while(emptyStack(s) != 1){ tempN = frontStack(s); printData(tempN->d); d = createData(tempN->d->i1,tempN->d->i2,tempN->d->f1); pushStack(tempS,d); popStack(s); } while(emptyStack(tempS) != 1){ tempN = frontStack(tempS); d = createData(tempN->d->i1,tempN->d->i2,tempN->d->f1); pushStack(s,d); popStack(tempS); } return; }
//=================================================================== // Function to undo a delete of a company. Does not allow to undo // delete of a company that is already in the BST //=================================================================== void undoDelete(DATA_HEAD *data) { COMPANY* companyNode; int isDuplicate; //If there is something in the stack if(!emptyStack(data->pStack)) { companyNode = (COMPANY*)popStack(data->pStack); //Check to see if there is duplicate isDuplicate = searchHash(data, companyNode->companyName, companyNode); //If there is, print and error, else, insert into the hashed array if(isDuplicate == 1) { printf("ERROR: DUPLICATE DATA\n"); printf("%s has already been entered into the system\n", companyNode->companyName); free(companyNode); } else { printf("%s reinserted into the system\n", companyNode->companyName); insertManager(data, companyNode); updateCollision(data); (data->count)++; printf("\nNumber Of Data Records: %d\n", data->count); } } else printf("Nothing to undo.\n"); //nothing in the stack printf("\n"); }
/*-------------------------------- convert infix to postfix --------------------------------*/ void infixToPostfix(char infix[max], char postfix[max]){ emptyStack(); int i=0,j=0; while(infix[i]!='\0'){ if(isOperator(infix[i])!=1){ // if is operand postfix[j++]=infix[i]; }else if(infix[i]== '(') push(infix[i]); else if(infix[i]==')'){ while(stack[top]!='(') postfix[j++]=pop(); top--; }else{ while(top!=-1 && prcd(infix[i])<=prcd(stack[top])) postfix[j++]=pop(); push(infix[i]); } i++; } while(top!=-1) if(stack[top]!=')' || stack[top]!='(') postfix[j++]=pop(); else top--; postfix[j]='\0'; }
stackElementT pop(stackT *stackP){ if(emptyStack(stackP)){ fprintf(stderr, "Can't pop element from stack: stack is empty. \n"); exit(1); } return stackP->contents[stackP->top--]; }
int main(int argc, char **argv) { int N = (argc < 2) ? 20 : atoi(argv[1]); if (N < 20) N = 20; Stack s = newStack(); int i; char x[50]; for (i = 0; i < N; i++) { if (random()%10 > 5) { if (!emptyStack(s)) { char *str = popFrom(s); printf("Remove %s\n",str); free(str); } } else { randomString(x); pushOnto(s,x); printf("Insert %s\n",x); } showStack(s); } disposeStack(s); return 0; }
int main(){ bracHold *head=NULL; bracHold *tail=NULL; char scanChar,popChar; int flag=0; while(scanf("%c",&scanChar)!=EOF){ if((scanChar=='(') || (scanChar=='{') || (scanChar=='[')){ push(&head,&tail,scanChar); // print(&head); } else if((scanChar==')') || (scanChar=='}') || (scanChar==']')){ if(!emptyStack(&head)){ popChar=pop(&head,&tail); //printf("poped->%c\n",popChar); if(scanChar==')' && popChar=='(') continue; else if(scanChar=='}' && popChar=='{') continue; else if(scanChar==']' && popChar=='[') continue; else{ flag=1; printf("Not Valid\n"); break; } } else{ printf("Not Valid\n"); } } } if(flag==0) printf("Valid\n"); return 0; }
int main(int argc, char *argv[]) { int i, len; char buf[1000]; FILE *f; struct stack s; char *tmp; initStack(&s); if (argc == 2) { f =fopen(argv[1], "r"); //open with read only mod if ( f == NULL) { printf("file open fail, please check filename and privilege\n"); return 1; } while (fscanf(f, "%s", buf) != EOF) { addStack(&s, buf); } while(!emptyStack(&s)) { printf("%s\n", tmp=deleteStack(&s)); free(tmp); //用完再釋出記憶體空間 } } else { printf("please specify filename as the first argument\n"); } return 0; }
void Waltz::setSensor(const AbstractSensor& _sensor) { sensor = &_sensor; emptyStack(); currentLocation = zero; memory.clear(); timeLeft = INT_MAX; batteryRemianing = config.BatteryCapacity; }
///******************************** ///Function: top ///Task: as long as the stack is not empty, returns the double on the top of the stack ///Returns: top element from the stack ///******************************** double calcStack::top() const { if (isEmpty()) { throw emptyStack(); } return nums[topIndex]; }
///******************************** ///Function: pop ///Task: as long as the stack is not empty, removes the top element from the stack by decrementing topIndex ///Returns: nothing ///******************************** void calcStack::pop() { if (isEmpty()) { throw emptyStack(); } topIndex--; }
int pop(struct Stack *stack, long *data) { if (emptyStack(stack)) { fprintf(stderr, "%s", "\nempty stack!\n"); return -EEMPTYSTACK; } *data = stack->stack[--stack->sp]; return 0; }
void constructChildValues(ESA *esa) { int n = esa->n+1; stack *s = newStack(); push(s, 0); // TODO: Make sure that this correctly reaches the end. for (int i=1; i<n; i++) { while (esa->LCP[i] < esa->LCP[ peek(s) ]) pop(s); if (esa->LCP[i] == esa->LCP[ peek(s) ]) esa->accross[pop(s)] = i; push(s, i); } /** Construct Up/Down values. ***************/ // Reset the stack. emptyStack(s); int lastIndex = -1; push(s, 0); for (int i=1; i<n; i++) { while (esa->LCP[i] < esa->LCP[ peek(s) ] ) { lastIndex = pop(s); int top = peek(s); if ( esa->LCP[i] <= esa->LCP[top] && esa->LCP[top] != esa->LCP[lastIndex] ) esa->down[top] = lastIndex; if (lastIndex != -1) { esa->up[i] = lastIndex; lastIndex = -1; } } push(s, i); } freeStack(s); }
Operand popOperand(OperandStack **topAddress) { OperandStack *p1; Operand operand; if (!emptyStack(*topAddress)) { operand = (*topAddress)->operand; p1 = *topAddress; *topAddress = (*topAddress)->nextOperand; free(p1); } else { printf("A pilha esta vazia\n"); exit(1); } return operand; }
//=================================================================== // Writes to output file and calls function to clear out the stack //=================================================================== void saveToFile(DATA_HEAD *data) { COMPANY *temp; FILE *outputFile; char filename[MAX_CHARS]; int i, len; char ch; do { printf("Please enter a filename for output file [enter for default]:"); fgets(filename, MAX_CHARS, stdin); if (filename[0] == '\n') strcpy(filename, "out.txt"); else { //flush new line len = strlen(filename); if (filename[len - 1] == '\n' || filename[len - 1] == '\r') filename[len - 1] = '\0'; // change '\n' to '\0' else while ((ch = getchar()) != '\n' && ch != '\r'); } outputFile = fopen(filename, "w"); } while (!outputFile); //Writes to output file in hashed sequence printf("Writing to %s...\n", filename); for (i = 0; i < data->arraySize; i++) { if (data->pHash[i].status == 1) //status is filled, data exists at index fprintf(outputFile, "%s,%d,%d,%d\n", data->pHash[i].hashData->companyName, data->pHash[i].hashData->revenuePerBillion, data->pHash[i].hashData->profitPerMillion, data->pHash[i].hashData->numberOfEmployees); } //need to free the company name as well as the company //modifying stack ADT does not work since this is specific to this program while (!emptyStack(data->pStack)) { temp = (COMPANY *)popStack(data->pStack); //pop everything from the stack free(temp->companyName); //free company name and then company free(temp); } data->pStack->count = 0; //reset stack data->pStack->top = NULL; fclose(outputFile); printf("\n"); }
/** * Push one element in the stack * @param STACK **head pointer to the stack * @param char *value The value that you want to enqueue in the stack */ void pushElement(STACK **head, char *value) { STACK *buffer; buffer = malloc(sizeof (STACK)); if (buffer != NULL) { buffer->value = (char*) malloc(sizeof (char) * strlen(value)); memcpy(buffer->value,value, strlen(value)+1); if( emptyStack(head) ) { buffer->link = NULL; } else { buffer->link = *head; } *head = buffer; } else { fputs("Not enough memory.", stdout); abort(); } }
int main(){ char string[] = "istore 12 32"; char *ptr; ptr = strtok(string, delimiter); while(ptr != NULL) { printf("Abschnitt gefunden: %s\n", ptr); ptr = strtok(NULL, delimiter); } FILE *fp; int i, temp; fp = fopen("test.ovm", "r"); if(fp == NULL) { printf("Datei konnte nicht geöffnet werden.\n"); }else { while((temp = fgetc(fp))!=EOF) { printf("%c ", temp); } fclose(fp); } printf("\n"); stackT s1; memoryT m1; initStack(&s1, 10); initMemory(&m1, 10); push(&s1, 'Z'); set(&m1, 'L', 2); while(!emptyStack(&s1)){ printf("%c", pop(&s1)); } printf("%c", get(&m1, 2)); return 0; }
static int cs_operate(int (*func)(struct frame_state const *, void *), void *usrarg, size_t starting_frame, size_t num_frames) { dbghelp_functions dbg; if (!load_dbghelp_library_if_needed (&dbg)) { ACE_OS::strcpy (static_cast<char *> (usrarg), "<error loading dbghelp.dll>"); if (dbg.hMod) FreeLibrary (dbg.hMod); return 1; } frame_state fs; ZeroMemory (&fs.sf, sizeof (fs.sf)); fs.pDbg = &dbg; emptyStack (); //Not sure what this should do, Chad? CONTEXT c; ZeroMemory (&c, sizeof (CONTEXT)); c.ContextFlags = CONTEXT_FULL; # if defined (_M_IX86) DWORD machine = IMAGE_FILE_MACHINE_I386; __asm { call x x: pop eax mov c.Eip, eax mov c.Ebp, ebp mov c.Esp, esp } fs.sf.AddrPC.Offset = c.Eip; fs.sf.AddrStack.Offset = c.Esp; fs.sf.AddrFrame.Offset = c.Ebp; fs.sf.AddrPC.Mode = AddrModeFlat; fs.sf.AddrStack.Mode = AddrModeFlat; fs.sf.AddrFrame.Mode = AddrModeFlat; # elif defined (_M_X64) DWORD machine = IMAGE_FILE_MACHINE_AMD64; RtlCaptureContext (&c); fs.sf.AddrPC.Offset = c.Rip; fs.sf.AddrFrame.Offset = c.Rsp; //should be Rbp or Rdi instead? fs.sf.AddrStack.Offset = c.Rsp; fs.sf.AddrPC.Mode = AddrModeFlat; fs.sf.AddrFrame.Mode = AddrModeFlat; fs.sf.AddrStack.Mode = AddrModeFlat; # elif defined (_M_IA64) DWORD machine = IMAGE_FILE_MACHINE_IA64; RtlCaptureContext (&c); fs.sf.AddrPC.Offset = c.StIIP; fs.sf.AddrFrame.Offset = c.RsBSP; fs.sf.AddrBStore.Offset = c.RsBSP; fs.sf.AddrStack.Offset = c.IntSp; fs.sf.AddrPC.Mode = AddrModeFlat; fs.sf.AddrFrame.Mode = AddrModeFlat; fs.sf.AddrBStore.Mode = AddrModeFlat; fs.sf.AddrStack.Mode = AddrModeFlat; # endif fs.pSym = (PSYMBOL_INFO) GlobalAlloc (GMEM_FIXED, sizeof (SYMBOL_INFO) + sizeof (ACE_TCHAR) * (SYMSIZE - 1)); fs.pSym->SizeOfStruct = sizeof (SYMBOL_INFO); fs.pSym->MaxNameLen = SYMSIZE * sizeof (ACE_TCHAR); dbg.SymSetOptions (SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES | SYMOPT_FAIL_CRITICAL_ERRORS | dbg.SymGetOptions ()); dbg.SymInitialize (GetCurrentProcess (), 0, true); //What does the "true" parameter mean when tracing the current process? for (size_t current_frame = 0; current_frame < num_frames + starting_frame; ++current_frame) { BOOL ok = dbg.StackWalk64 (machine, GetCurrentProcess (), GetCurrentThread (), &fs.sf, &c, 0, dbg.SymFunctionTableAccess64, dbg.SymGetModuleBase64, 0); if (!ok || fs.sf.AddrFrame.Offset == 0) break; if (current_frame < starting_frame) continue; func (&fs, usrarg); } dbg.SymCleanup (GetCurrentProcess ()); GlobalFree (fs.pSym); FreeLibrary (dbg.hMod); return 0; }
//search linear structure starting with the root of a tree static int startEdgeFromNode ( kmer_t * node1, FILE * fp ) { int node_c, palindrome; unsigned char flag; KMER_PT * ite_pt, *temp_pt; Kmer word1, bal_word1; char ch1; if ( node1->linear || node1->deleted ) { return 0; } // ignore floating loop word1 = node1->seq; bal_word1 = reverseComplement ( word1, overlaplen ); // linear structure for ( ch1 = 0; ch1 < 4; ch1++ ) // for every node on outgoing list { flag = get_kmer_right_cov ( *node1, ch1 ); if ( !flag ) { continue; } emptyStack ( nodeStack ); temp_pt = ( KMER_PT * ) stackPush ( nodeStack ); temp_pt->node = node1; temp_pt->isSmaller = 1; temp_pt->kmer = word1; stringBeads ( temp_pt, ch1, &node_c ); //printf("%d nodes\n",node_c); if ( node_c < 2 ) { printf ( "%d nodes in this line!!!!!!!!!!!\n", node_c ); } else { //make a reverse complement node list stackBackup ( nodeStack ); emptyStack ( bal_nodeStack ); while ( ( ite_pt = ( KMER_PT * ) stackPop ( nodeStack ) ) != NULL ) { temp_pt = ( KMER_PT * ) stackPush ( bal_nodeStack ); temp_pt->kmer = reverseComplement ( ite_pt->kmer, overlaplen ); } stackRecover ( nodeStack ); palindrome = check_iden_kmerList ( nodeStack, bal_nodeStack ); stackRecover ( nodeStack ); if ( palindrome ) { merge_linearV2 ( 0, nodeStack, node_c, fp ); } else { merge_linearV2 ( 1, nodeStack, node_c, fp ); } } } //every possible outgoing edges for ( ch1 = 0; ch1 < 4; ch1++ ) // for every node on incoming list { flag = get_kmer_left_cov ( *node1, ch1 ); if ( !flag ) { continue; } emptyStack ( nodeStack ); temp_pt = ( KMER_PT * ) stackPush ( nodeStack ); temp_pt->node = node1; temp_pt->isSmaller = 0; temp_pt->kmer = bal_word1; stringBeads ( temp_pt, int_comp ( ch1 ), &node_c ); if ( node_c < 2 ) { printf ( "%d nodes in this line!!!!!!!!!!!\n", node_c ); } else { //make a reverse complement node list stackBackup ( nodeStack ); emptyStack ( bal_nodeStack ); while ( ( ite_pt = ( KMER_PT * ) stackPop ( nodeStack ) ) != NULL ) { temp_pt = ( KMER_PT * ) stackPush ( bal_nodeStack ); temp_pt->kmer = reverseComplement ( ite_pt->kmer, overlaplen ); } stackRecover ( nodeStack ); palindrome = check_iden_kmerList ( nodeStack, bal_nodeStack ); stackRecover ( nodeStack ); if ( palindrome ) { merge_linearV2 ( 0, nodeStack, node_c, fp ); //printf("edge is palindrome with length %d\n",temp_edge.length); } else { merge_linearV2 ( 1, nodeStack, node_c, fp ); } } } //every possible incoming edges return 0; }
int main(int argc,char* argv[]){ printf("\nPROGRAM BEGUN\n"); //generating a readable .txt file srand(time(NULL)); FILE* out = fopen(argv[2],"w"); int i; int v1; int v2; float v3; for(i = 0;i < atoi(argv[1]);i++){ v1 = rand() % 100; v2 = rand() % 200; v3 = (rand() % 10000)/100.00; fprintf(out,"%d %d %f\n",v1,v2,v3); } fclose(out); //opening the generated .txt file w/ read privileges //then reading the data structures into a stack FILE* read = fopen(argv[2],"r"); stack* s = createStack(); data* d = malloc(sizeof(data)); while(1){ d = readData(read); if(d == NULL){ break; } pushStack(s,d); } //printing the stack printf("\nPRINTING STACK\n\n"); printStack(s); //creating a queue and pushing the data from the stack to it dnode* tempN = frontStack(s); queue* q = createQueue(); //remember that to do this we must: //1. begin a while loop that runs while [emptyStack(s) != 0] //2. set a temp dnode equal to the head of the stack //3. create a NEW data structure from the data within this temp dnode //4. use the pushQueue function with this newly created data struct //5. pop the front element off of the stack, effectively deleting it while(emptyStack(s) != 1){ tempN = frontStack(s); d = createData(tempN->d->i1,tempN->d->i2,tempN->d->f1); pushQueue(q,d); popStack(s); } //printing the queue printf("\nPRINTING QUEUE\n\n"); printQueue(q); if(emptyStack(s) == 1){ printf("\nSTACK EMPTY\n\n"); } return 0; }
int main () { int i; double result; if (getStackSize() ==0) printf ("Passed 1\n"); else printf ("Failed 1\n"); /* Make sure a pop of an empty stack returns NAN.*/ result = pop(); if (isnan(result)) printf ("Passed 2\n"); else printf ("Failed 2\n"); /* Check if an empty stack returns a non-zero (true) value. */ emptyStack(); if (isStackEmpty()) printf ("Passed 3\n"); else printf ("Failed 3\n"); /************************************************ /* Push 15 values on the stack -- Check result, isStackEmpty, and getStackSize */ for (i=0; i<15; i++) result = push (i); if (result == 0) printf ("Passed 4\n"); else printf ("Failed 4\n"); if (getStackSize() == 15) printf ("Passed 5\n"); else printf ("Failed 5\n"); if (!isStackEmpty()) printf ("Passed 6\n"); else printf ("Failed 6\n"); /************************************************ /* Check two pops */ /* Then make sure stack size is now 13. */ if (pop() == 14) printf ("Passed 6\n"); else printf ("Failed 6\n"); if (pop() == 13) printf ("Passed 7\n"); else printf ("Failed 7\n"); if (getStackSize() == 13) printf ("Passed 8\n"); else printf ("Failed 8\n"); /************************************************ * Push 100 values on the stack -- * All should have a result of 0. * Then push a 101th value and make sure the result is -1. */ emptyStack(); for (i=0; i<100; i++) { result = push (i); if (result != 0) { printf("Push 100 failed on %d\n", i); break; } } result = push(101); if (result == -1) printf ("Passed 9\n"); else printf ("Failed 9\n"); }
int main() { FILE *fp; Pile pile; tInfo info; char op; printf("\t\t\tEjercicio 4 tp3 Pila estatica\n"); if(!openFile(&fp,"r+b",FILENAME,!CON_SIN_MSJ)) { createFile(); if(!openFile(&fp,"r+b",FILENAME,CON_SIN_MSJ)) return 0; } createStack(&pile); fread(&info,1,sizeof(tInfo),fp); while(!feof(fp) && !isStackFull(&pile)) { putInStack(&pile,&info); fread(&info,1,sizeof(tInfo),fp); } fclose(fp); op = menuOption(MSJ,OPTION); while(op != 'D') { switch(op) { case 'A': { newInfo(&info); if(putInStack(&pile, &info) == PILA_LLENA) puts("pila llena no se pudo cargar la nueva informacion"); break; } case 'B': { puts("Viendo tope de la pila: "); if(showTop(&pile,&info) != PILA_VACIA) showInfo(&info); else puts("Pila vacia, no se puede ver tope"); break; } case 'C': { puts("Sacando de pila..."); if(takeOfStack(&pile,&info) != PILA_VACIA) showInfo(&info); else puts("No se puede sacar de pila, pila vacia"); break; } } op = menuOption(MSJ,OPTION); } if(!openFile(&fp,"r+b",FILENAME,CON_SIN_MSJ)) { puts("Vaciando pila..."); emptyStack(&pile); return 0; } while(!isStackEmpty(&pile)) { takeOfStack(&pile,&info); putInTheEndFile(&fp,&info); } emptyStack(&pile); fclose(fp); return 0; }
void scan_fill_do_action(int x, int y, texture_info * tex, VALUE hash_arg, texplay_sync sync_mode, bool primary, action_struct * payload) { action_struct cur; rgba old_color; int y1; bool spanLeft, spanRight; if(!bound_by_rect(x, y, 0, 0, tex->width - 1, tex->height - 1)) return; /* NB: using XMAX_OOB etc since we dont know the drawing area yet; drawing area will be set by update_bounds() function in main loop */ draw_prologue(&cur, tex, XMAX_OOB, YMAX_OOB, XMIN_OOB, YMIN_OOB, &hash_arg, sync_mode, primary, &payload); /* fill hates alpha_blend so let's turn it off */ payload->pen.alpha_blend = false; old_color = get_pixel_color(tex, x, y); if(cmp_color(old_color, cur.color)) return; emptyStack(); if(!push(x, y, tex->width - 1)) return; while(pop(&x, &y, tex->width - 1)) { y1 = y; while(y1 >= 0 && cmp_color(old_color, get_pixel_color(tex, x, y1))) y1--; y1++; spanLeft = spanRight = false; while(y1 < tex->height && cmp_color(old_color, get_pixel_color(tex, x, y1)) ) { set_pixel_color_with_style(payload, tex, x, y1); /* update the drawing rectangle */ update_bounds(payload, x, y1, x, y1); if(!spanLeft && x > 0 && cmp_color(old_color, get_pixel_color(tex, x - 1, y1))) { if(!push(x - 1, y1, tex->width - 1)) return; spanLeft = true; } else if(spanLeft && !cmp_color(old_color, get_pixel_color(tex, x - 1, y1))) { spanLeft = false; } if(!spanRight && x < tex->width - 1 && cmp_color(old_color, get_pixel_color(tex, x + 1, y1))) { if(!push(x + 1, y1, tex->width - 1)) return; spanRight = true; } else if(spanRight && x < tex->width - 1 && !cmp_color(old_color,get_pixel_color(tex, x + 1, y1))) { spanRight = false; } y1++; } } draw_epilogue(&cur, tex, primary); }