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;
}
