int eval_del(struct eval *eval) { struct eval *e0 = eval; int ret = 0; if (e0) { ret += stack_del(e0->stk, NULL, NULL); ret += stack_del(e0->opstk, NULL, NULL); ret += varray_del(e0->toks); free(e0); } return ret ? -1 : 0; }
void TestStackCreation(CuTest* tc) { struct Stack* stack = stack_new(16); CuAssertIntEquals(tc, 16, stack->size); CuAssertTrue(tc, stack_is_empty(stack)); stack_del(stack); }
char stack_pop (stack* ctack) { if (ctack->pointer == 0) { return -1; }; stack_del (ctack); char ret_char = ctack->Stack[ctack->pointer - 1]; ctack->pointer--; return ret_char; }
void TestStackExpansion(CuTest* tc) { struct Stack* stack = stack_new(2); stack_push(stack, &t_data[0]); stack_push(stack, &t_data[1]); CuAssertIntEquals(tc, 2, stack->size); stack_push(stack, &t_data[1]); CuAssertIntEquals(tc, 4, stack->size); stack_del(stack); }
void test_del() { int capacity = 16; stack_int_t stack = stack_new(capacity); stack_del(&stack); ok( stack.capacity == 0 && stack.size == 0 && stack.array == NULL, "stack_del." ); }
void TestStackTrim(CuTest* tc) { struct Stack* stack = stack_new(100); stack_push(stack, &t_data[0]); stack_push(stack, &t_data[1]); CuAssertIntEquals(tc, 100, stack->size); CuAssertIntEquals(tc, 2, stack->pos); stack_trim(stack); CuAssertIntEquals(tc, 2, stack->size); stack_del(stack); }
void TestStackPop(CuTest* tc) { struct Stack* stack = stack_new(16); stack_push(stack, &t_data[0]); stack_push(stack, &t_data[1]); int32_t* popped = stack_pop(stack); CuAssertIntEquals(tc, 1, stack->pos); CuAssertPtrEquals(tc, &t_data[0], stack->data[0]); CuAssertPtrEquals(tc, &t_data[1], popped); stack_del(stack); }
void TestStackPush(CuTest* tc) { struct Stack* stack = stack_new(16); stack_push(stack, &t_data[0]); stack_push(stack, &t_data[1]); stack_push(stack, &t_data[2]); stack_push(stack, &t_data[3]); CuAssertIntEquals(tc, 4, stack->pos); CuAssertPtrEquals(tc, &t_data[0], stack->data[0]); CuAssertPtrEquals(tc, &t_data[1], stack->data[1]); CuAssertPtrEquals(tc, &t_data[2], stack->data[2]); CuAssertPtrEquals(tc, &t_data[3], stack->data[3]); stack_del(stack); }
static void quick_sort_with_stack(int arr[], int left, int right) { struct stack* s = stack_new(); stack_push(s, left, right); while (! stack_empty(s)) { int l; int r; stack_pop(s, &l, &r); if (l < r) { int m = lomuto_partition(arr, l, r); stack_push(s, l, m-1); stack_push(s, m+1, r); } } stack_del(s); }
p_dfa dfa_compile_from_string( const char* str ) { p_dfa pdfa; p_regc prc; p_stack ps; p_stack_ele pse; p_nfa pa, pa_x, pa_y, pa_z, pa_w; char *buffer, *ch; int v, i, j, k, x, y, z; prc = regc_compile( str ); if ( prc == NULL ) { return NULL; } regc_print( prc ); ps = stack_new(); buffer = (char*)t_alloc( sizeof(char) * BUFF_SIZE ); ch = (char*)t_alloc( sizeof(char) * CHARACTER_SET_END ); /* TODO: check the str is comfortable */ for (i = 0;i < prc->size; i++ ) { switch ( prc->buffer[i] ) { case REG_NUMBER: //printf( "%s\n", chset_num ); pa = nfa_make_from_stringbranch( chset_num ); stack_push_nfa( ps, pa ); break; case REG_WORDS: //printf( "%s\n", chset_word ); pa = nfa_make_from_stringbranch( chset_word ); stack_push_nfa( ps, pa ); break; case REG_BLACK: //printf( "%s\n", chset_black ); pa = nfa_make_from_stringbranch( chset_black ); stack_push_nfa( ps, pa ); break; case REG_LEFTPAR: stack_push_op( ps, LEFT_PAR ); break; case REG_RIGHTPAR: stack_process( ps, RIGHT_PAR ); break; case REG_LEFTSQUARE: v = 1; if ( prc->buffer[++i] == REG_NOT ) { v = 0; i ++; } for (j = 0; j < CHARACTER_SET_END; j ++ ) ch[j] = 0; do { if ( prc->buffer[i] == REG_RIGHTSQUARE ) break; else if ( prc->buffer[i] == REG_BETWEEN ) { i ++; x = prc->buffer[i++]; y = prc->buffer[i++]; if ( x > y ) { z = x; x = y; y = z; } while ( x <= y ) ch[x++] = 1; } else { x = prc->buffer[i++]; ch[x] = 1; } } while ( i < prc->size ); for (j = CHARACTER_SET_START, k = 0; j < CHARACTER_SET_END; j ++ ) { if ( !( ch[j] ^ v ) ) { buffer[k++] = (char)j; } } if ( !( ch['\t'] ^ v ) ) { buffer[k++] = (char)'\t'; } if ( !( ch['\n'] ^ v ) ) { buffer[k++] = (char)'\n'; } buffer[k] = '\0'; //printf( "%s\n", buffer ); pa = nfa_make_from_stringbranch( buffer ); stack_push_nfa( ps, pa ); break; case REG_RIGHTSQUARE: printf( "FATALERROR: right square\n" ); break; case REG_LEFTBRACE: pse = stack_top( ps ); if ( pse->type != e_nfa ) { printf( "error!" ); break; } i ++; x = prc->buffer[i++]; y = prc->buffer[i++]; pa = pse->value.pa; pa_z = nfa_multiple( pa, x ); if ( y == REG_INFINITE ) { pa_y = nfa_closure( pa ); } else { for (j = 0; j <= y-x; j ++ ) { pa_x = nfa_multiple( pa, j ); if ( j == 0 ) { pa_y = nfa_copy( pa_x ); } else { pa_w = pa_y; pa_y = nfa_branch( pa_w, pa_x ); nfa_del( pa_w ); } nfa_del( pa_x ); } } nfa_del( pa ); pa = nfa_concat( pa_z, pa_y ); nfa_del( pa_z ); nfa_del( pa_y ); stack_pop( ps ); stack_push_nfa( ps, pa ); break; case REG_RIGHTBRACE: printf( "FATALERROR: right brace\n" ); break; case REG_BRANCH: stack_process( ps, BRANCH ); stack_push_op( ps, BRANCH ); break; case REG_CONCAT: stack_process( ps, CONCAT ); stack_push_op( ps, CONCAT ); break; case REG_STAR: pse = stack_top( ps ); if ( pse->type != e_nfa ) { printf( "error!" ); break; } pa = pse->value.pa; pa_x = nfa_closure( pa ); nfa_del( pa ); stack_pop( ps ); stack_push_nfa( ps, pa_x ); break; case REG_PLUS: pse = stack_top( ps ); if ( pse->type != e_nfa ) { printf( "error!" ); break; } pa = pse->value.pa; pa_x = nfa_closure( pa ); pa_y = nfa_copy( pa ); nfa_del( pa ); pa = nfa_concat( pa_y, pa_x ); nfa_del( pa_x ); nfa_del( pa_y ); stack_pop( ps ); stack_push_nfa( ps, pa ); break; case REG_QUESTION: pse = stack_top( ps ); if ( pse->type != e_nfa ) { printf( "error!" ); break; } pa = pse->value.pa; pa_x = nfa_make_from_stringconcat( "" ); pa_y = nfa_branch( pa, pa_x ); nfa_del( pa_x ); nfa_del( pa ); stack_pop( ps ); stack_push_nfa( ps, pa_y ); break; case REG_WILDCAST: for (j = CHARACTER_SET_START, k = 0; j < CHARACTER_SET_END; j ++ ) { buffer[k++] = (char)j; } buffer[k++] = '\t'; buffer[k] = '\0'; //printf( "%s\n", buffer ); pa = nfa_make_from_stringbranch( buffer ); stack_push_nfa( ps, pa ); break; case REG_BOL: pa = nfa_make_from_stringbranch( "\2\n" ); stack_push_nfa( ps, pa ); break; case REG_EOL: pa = nfa_make_from_stringbranch( "\3\n" ); stack_push_nfa( ps, pa ); break; case REG_STRFRAGMENT: i ++; for (j = i; j < prc->size; j ++ ) { if ( prc->buffer[j] <= 0 ) { buffer[j-i] = '\0'; break; } else { buffer[j-i] = (char)prc->buffer[j]; } } if ( j == prc->size ) buffer[j-i] = '\0'; //printf( "%d %s\n", j, buffer ); pa = nfa_make_from_stringconcat( buffer ); stack_push_nfa( ps, pa ); i = j-1; break; default: printf( "FATAL ERROR %s\n", regc_str[ -prc->buffer[i] ] ); } } stack_process( ps, END ); if ( ps->top->next != NULL ) printf( "error!\n" ); pse = stack_top( ps ); pa = pse->value.pa; regc_del( prc ); pdfa = dfa_convert_from_nfa( pa ); nfa_del( pa ); stack_del( ps ); t_free( ch ); t_free( buffer ); return pdfa; }
int DOM_DocumentLS_load(DOM_Document *doc, const DOM_String *uri) { FILE *fd; XML_Parser p; struct stack *stk; size_t n; // was ssize_t (DBL) void *buf; int ret, done; DOM_Exception=DOM_NO_ERR; //line added by DBL if (doc == NULL || uri == NULL) { DOM_Exception = DOM_NULL_POINTER_ERR; return 0; } fd = fopen(uri, "r"); if (fd == NULL) { DOM_Exception = DOM_SYSTEM_ERR; return 0; } p = XML_ParserCreate(NULL); if (p == NULL) { DOM_Exception = DOM_XML_PARSER_ERR; fclose(fd); return 0; } stk = stack_new(INT_MAX); if (stk == NULL || stack_push(stk, doc) == 0) { DOM_Exception = DOM_SYSTEM_ERR; XML_ParserFree(p); fclose(fd); stack_del(stk, NULL); return 0; } XML_SetElementHandler(p, start_fn, end_fn); XML_SetCharacterDataHandler(p, chardata_fn); XML_SetCommentHandler(p, comment_fn); XML_SetProcessingInstructionHandler(p , processing_fn); XML_SetUserData(p, stk); ret = 1; for ( ;; ) { if ((buf = XML_GetBuffer(p, BUF_SIZ)) == NULL) { DOM_Exception = DOM_NO_MEMORY_ERR; ret = 0; break; } if ((n = fread(buf, 1, BUF_SIZ, fd)) == 0 && ferror(fd)) { DOM_Exception = DOM_SYSTEM_ERR; ret = 0; break; } if (XML_ParseBuffer(p, (int) n, (done = feof(fd))) == 0 || DOM_Exception) { if (DOM_Exception == 0) { DOM_Exception = DOM_XML_PARSER_ERR; } ret = 0; break; } if (done) { break; } } stack_del(stk, NULL); XML_ParserFree(p); fclose(fd); return ret; }