Exemplo n.º 1
0
// implement a stack with list
// list would always have a dummy header
// tree in dummy type-casted to store the size of stack (not counting the dummy)
//
void push(lnode *head, lnode *node) 
{
   node->next = head->next;
   head->next = node;
   set_stack_size(head, stack_size(head)+1);
}
Exemplo n.º 2
0
int main(int argc, char *argv[]) {
    int opt;

    char *scriptfile, prompt[50];
    extern void my_interfaceparse(char *my_string);
    /*  YY_BUFFER_STATE flex_command; */
    stack_init();
    while ((opt = getopt(argc, argv, "e:f:hl:pqrsv")) != -1) {
        switch(opt) {
        case 'e':
            my_interfaceparse(optarg);
            break;
        case 'f':
            scriptfile = file_to_mem(optarg);
            if (scriptfile != NULL) {
                input_is_file = 1;
                my_interfaceparse(scriptfile);
            }
            exit(0);
        case 'h':
            print_help();
            exit(0);
        case 'l':
            scriptfile = file_to_mem(optarg);
            if (scriptfile != NULL) {
                input_is_file = 1;
                my_interfaceparse(scriptfile);
		xxfree(scriptfile);
            }
            break;
        case 'p':
            pipe_mode = 1;
            break;
        case 'q':
            quiet_mode = 1;
            break;
        case 'r':
            use_readline = 0;
            break;
        case 's':
	  exit(0);
        case 'v':
            printf("%s %i.%i.%i%s\n",argv[0],MAJOR_VERSION,MINOR_VERSION,BUILD_VERSION,STATUS_VERSION);
            exit(0);
        default:
            fprintf(stderr, "%s", usagestring);
            exit(EXIT_FAILURE);
        }
    }

    if (!pipe_mode && !quiet_mode) 
        printf("%s",disclaimer);
    rl_basic_word_break_characters = " >";

    rl_attempted_completion_function = my_completion;
    for(;;) {
        if (promptmode == PROMPT_MAIN)
            sprintf(prompt, "foma[%i]: ",stack_size());
        if (promptmode == PROMPT_A && apply_direction == AP_D)
            sprintf(prompt, "apply down> ");
        if (promptmode == PROMPT_A && apply_direction == AP_U)
            sprintf(prompt, "apply up> ");
        if (promptmode == PROMPT_A && apply_direction == AP_M)
            sprintf(prompt, "apply med> ");
        if (pipe_mode || quiet_mode)
            prompt[0] = '\0';

        command = rl_gets(prompt);

        if (command == NULL && promptmode == PROMPT_MAIN) {
            printf("\n");
            exit(0);
        }
        if (command == NULL && promptmode == PROMPT_A) {
            /* apply_clear(); */
            promptmode = PROMPT_MAIN;
            printf("\n");
            continue;
        }
        input_is_file = 0;
        my_interfaceparse(command);
    }
}
Exemplo n.º 3
0
int _lru_free_mem(cache_t *c, segment_t *pseg, ex_off_t bytes_to_free)
{
    cache_lru_t *cp = (cache_lru_t *)c->fn.priv;
    cache_segment_t *s;
    cache_page_t *p;
    page_lru_t *lp;
    Stack_ele_t *ele;
    apr_thread_mutex_t *plock;
    ex_off_t total_bytes, pending_bytes;
    int gotlock, count, bits, err;

    total_bytes = 0;
    err = 0;

    log_printf(15, "START seg=" XIDT " bytes_to_free=" XOT " bytes_used=" XOT " stack_size=%d\n", segment_id(pseg), bytes_to_free, cp->bytes_used, stack_size(cp->stack));

    move_to_bottom(cp->stack);
    ele = get_ptr(cp->stack);
    while ((total_bytes < bytes_to_free) && (ele != NULL) && (err == 0)) {
        p = (cache_page_t *)get_stack_ele_data(ele);
        lp = (page_lru_t *)p->priv;
        plock = p->seg->lock;
        gotlock = apr_thread_mutex_trylock(plock);
        if ((gotlock == APR_SUCCESS) || (p->seg == pseg)) {
            bits = atomic_get(p->bit_fields);
            if ((bits & C_TORELEASE) == 0) { //** Skip it if already flagged for removal
                count = atomic_get(p->access_pending[CACHE_READ]) + atomic_get(p->access_pending[CACHE_WRITE]) + atomic_get(p->access_pending[CACHE_FLUSH]);
                if (count == 0) { //** No one is using it
                    s = (cache_segment_t *)p->seg->priv;
                    if ((bits & C_ISDIRTY) == 0) {  //** Don't have to flush it
                        total_bytes += s->page_size;
                        log_printf(15, "lru_free_mem: freeing page seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
                        list_remove(s->pages, &(p->offset), p);  //** Have to do this here cause p->offset is the key var
                        delete_current(cp->stack, 1, 0);
                        if (p->data[0].ptr) free(p->data[0].ptr);
                        if (p->data[1].ptr) free(p->data[1].ptr);
                        free(lp);
                    } else {         //** Got to flush the page first
                        err = 1;
                    }
                } else {
                    err = 1;
                }
            }
            if (gotlock == APR_SUCCESS) apr_thread_mutex_unlock(plock);
        } else {
            err = 1;
        }

        if ((total_bytes < bytes_to_free) && (err == 0)) ele = get_ptr(cp->stack);
    }

    cp->bytes_used -= total_bytes;
    pending_bytes = bytes_to_free - total_bytes;
    log_printf(15, "END seg=" XIDT " bytes_to_free=" XOT " pending_bytes=" XOT " bytes_used=" XOT "\n", segment_id(pseg), bytes_to_free, pending_bytes, cp->bytes_used);

    return(pending_bytes);
}
Exemplo n.º 4
0
ex_off_t _lru_attempt_free_mem(cache_t *c, segment_t *page_seg, ex_off_t bytes_to_free)
{
    cache_lru_t *cp = (cache_lru_t *)c->fn.priv;
    cache_segment_t *s;
    segment_t *pseg;
    cache_page_t *p;
    page_lru_t *lp;
    Stack_ele_t *ele;
    op_generic_t *gop;
    opque_t *q;
    ex_off_t total_bytes, freed_bytes, pending_bytes, *poff;
    ex_off_t *segid;
    ex_off_t min_off, max_off;
    list_iter_t sit;
    int count, bits, cw, flush_count;
    list_t *table;
    page_table_t *ptable;
    pigeon_coop_hole_t pch, pt_pch;

    log_printf(15, "START seg=" XIDT " bytes_to_free=" XOT " bytes_used=" XOT " stack_size=%d\n", segment_id(page_seg), bytes_to_free, cp->bytes_used, stack_size(cp->stack));

    freed_bytes = 0;
    pending_bytes = 0;
    total_bytes = 0;

    //** cache_lock(c) is already acquired
    pch = reserve_pigeon_coop_hole(cp->free_pending_tables);
    table = *(list_t **)pigeon_coop_hole_data(&pch);

    //** Get the list of pages to free
    move_to_bottom(cp->stack);
    ele = stack_unlink_current(cp->stack, 1);
    while ((total_bytes < bytes_to_free) && (ele != NULL)) {
        p = (cache_page_t *)get_stack_ele_data(ele);
        lp = (page_lru_t *)p->priv;

        bits = atomic_get(p->bit_fields);
        log_printf(15, "checking page for release seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
        flush_log();

        if ((bits & C_TORELEASE) == 0) { //** Skip it if already flagged for removal
            ptable = (page_table_t *)list_search(table, (list_key_t *)&(segment_id(p->seg)));
            if (ptable == NULL) {  //** Have to make a new segment entry
                pt_pch = reserve_pigeon_coop_hole(cp->free_page_tables);
                ptable = (page_table_t *)pigeon_coop_hole_data(&pt_pch);
                ptable->seg = p->seg;
                ptable->id = segment_id(p->seg);
                ptable->pch = pt_pch;
                list_insert(table, &(ptable->id), ptable);
            }

            cp->limbo_pages++;
            log_printf(15, "UNLINKING seg=" XIDT " p->offset=" XOT " bits=%d limbo=%d\n", segment_id(p->seg), p->offset, bits, cp->limbo_pages);

            atomic_inc(p->access_pending[CACHE_READ]);  //** Do this so it's not accidentally deleted
            push(ptable->stack, p);
            s = (cache_segment_t *)p->seg->priv;
            total_bytes += s->page_size;
            free(lp->ele);
            lp->ele = NULL;  //** Mark it as removed from the list so a page_release doesn't free also
        }

        if (total_bytes < bytes_to_free) ele = stack_unlink_current(cp->stack, 1);
    }


    if (total_bytes == 0) {  //** Nothing to do so exit
        log_printf(15, "Nothing to do so exiting\n");
        release_pigeon_coop_hole(cp->free_pending_tables, &pch);
        return(0);
    }

    cache_unlock(c);  //** Don't need the cache lock for the next part

    q = new_opque();
    opque_start_execution(q);

    //** Now cycle through the segments to be freed
    pending_bytes = 0;
    sit = list_iter_search(table, list_first_key(table), 0);
    list_next(&sit, (list_key_t **)&segid, (list_data_t **)&ptable);
    while (ptable != NULL) {
        //** Verify the segment is still valid.  If not then just delete everything
        pseg = list_search(c->segments, segid);
        if (pseg != NULL) {
            segment_lock(ptable->seg);
            min_off = s->total_size;
            max_off = -1;

            s = (cache_segment_t *)ptable->seg->priv;
            while ((p = pop(ptable->stack)) != NULL) {
                atomic_dec(p->access_pending[CACHE_READ]); //** Removed my access control from earlier
                flush_count = atomic_get(p->access_pending[CACHE_FLUSH]);
                cw = atomic_get(p->access_pending[CACHE_WRITE]);
                count = atomic_get(p->access_pending[CACHE_READ]) + cw + flush_count;
                bits = atomic_get(p->bit_fields);
                if (count != 0) { //** Currently in use so wait for it to be released
                    if (cw > 0) {  //** Got writes so need to wait until they complete otherwise the page may not get released
                        bits = bits | C_TORELEASE;  //** Mark it for release
                        atomic_set(p->bit_fields, bits);
                        _cache_drain_writes(p->seg, p);  //** Drain the write ops
                        bits = atomic_get(p->bit_fields);  //** Get the bit fields to see if it's dirty
                    }

                    if (flush_count == 0) {  //** Make sure it's not already being flushed
                        if ((bits & C_ISDIRTY) != 0) {  //** Have to flush it don't have to track it cause the flush will do the release
                            if (min_off > p->offset) min_off = p->offset;
                            if (max_off < p->offset) max_off = p->offset;
                        }
                    }
                    bits = bits | C_TORELEASE;

                    log_printf(15, "in use tagging for release seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
                    atomic_set(p->bit_fields, bits);

                    pending_bytes += s->page_size;
                } else {  //** Not in use
                    if ((bits & (C_ISDIRTY|C_EMPTY)) == 0) {  //** Don't have to flush it just drop the page
                        cp->limbo_pages--;
                        log_printf(15, "FREEING page seg=" XIDT " p->offset=" XOT " bits=%d limbo=%d\n", segment_id(p->seg), p->offset, bits, cp->limbo_pages);
                        list_remove(s->pages, &(p->offset), p);  //** Have to do this here cause p->offset is the key var
                        if (p->data[0].ptr) free(p->data[0].ptr);
                        if (p->data[1].ptr) free(p->data[1].ptr);
                        lp = (page_lru_t *)p->priv;
                        free(lp);
                        freed_bytes += s->page_size;
                    } else {         //** Got to flush the page first but don't have to track it cause the flush will do the release
                        if (p->offset > -1) { //** Skip blank pages
                            if (min_off > p->offset) min_off = p->offset;
                            if (max_off < p->offset) max_off = p->offset;
                        }

                        bits = bits | C_TORELEASE;
                        atomic_set(p->bit_fields, bits);

                        pending_bytes += s->page_size;
                        if (p->offset > -1) {
                            log_printf(15, "FLUSHING page seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
                        } else {
                            log_printf(15, "RELEASE trigger for empty page seg=" XIDT " p->offset=" XOT " bits=%d\n", segment_id(p->seg), p->offset, bits);
                        }
                    }
                }

                list_next(&sit, (list_key_t **)&poff, (list_data_t **)&p);
            }

            segment_unlock(ptable->seg);

            if (max_off>-1) {
                gop = cache_flush_range(ptable->seg, s->c->da, min_off, max_off + s->page_size - 1, s->c->timeout);
                opque_add(q, gop);
            }
        } else {  //** Segment has been deleted so drop everything cause it's already freeed
            empty_stack(ptable->stack, 0);
        }

        cache_lock(c);
        release_pigeon_coop_hole(cp->free_page_tables, &(ptable->pch));
        cache_unlock(c);

        list_next(&sit, (skiplist_key_t **)&pseg, (skiplist_data_t **)&ptable);
    }

    cache_lock(c);
    log_printf(15, "BEFORE waitall seg=" XIDT " bytes_to_free=" XOT " bytes_used=" XOT " freed_bytes=" XOT " pending_bytes=" XOT "\n",
               segment_id(page_seg), bytes_to_free, cp->bytes_used, freed_bytes, pending_bytes);
    cache_unlock(c);


    //** Wait for any tasks to complete
    opque_waitall(q);
    opque_free(q, OP_DESTROY);

    //** Had this when we came in
    cache_lock(c);

    log_printf(15, "AFTER waitall seg=" XIDT " bytes_used=" XOT "\n", segment_id(page_seg), cp->bytes_used);

    cp->bytes_used -= freed_bytes;  //** Update how much I directly freed

    log_printf(15, "AFTER used update seg=" XIDT " bytes_used=" XOT "\n", segment_id(page_seg), cp->bytes_used);

    //** Clean up
    empty_skiplist(table);
    release_pigeon_coop_hole(cp->free_pending_tables, &pch);

    log_printf(15, "total_bytes marked for removal =" XOT "\n", total_bytes);

    return(total_bytes);
}
Exemplo n.º 5
0
/*
 * build a stack in kernel
 * set up the contents in terms of user address
 * this is to be copied into user stack by copyout()
 */
void *setup_args_mem(struct runprogram_info *prog_info, vaddr_t *usr_stack, size_t *len) {
	unsigned int i;
	unsigned long argc = prog_info->argc;
	char **argv = prog_info->argv;
	/*
	 * .
	 * .
	 * .
	 * s
	 * g
	 * r
	 * a
	 * l
	 * a
	 * e
	 * r
	 * ---
	 * ---
	 * ---
	 * *(argv+argc-1) -> translate to user stack
	 * ........
	 * ---
	 * ---
	 * ---
	 * *(argv+1) -> translate to user stack
	 * ---
	 * ---
	 * ---
	 * *(argv+0) -> translate to user stack
	 * ---
	 * ---
	 * ---
	 * argc <-- ks_start
	 */
	// start addr of the user stack copy in kernel
	*len = stack_size(prog_info);
	int *ks_start = (int *)kmalloc(*len);
	
	unsigned long arg_offset[argc];
	/*
	 * offset in terms of num of words
	 */
	// arg[0] is always there, it stores the program name
	arg_offset[0] = (unsigned int)argc + 1;
	// offset of argv[i]: offset of argv[i-1] + len of argv[i-1]
	for (i = 1; i < argc; i++) {
		int len_arg = (strlen(*(argv+i-1))+1)/4;
		if ((strlen(*(argv+i-1))+1)%4 != 0) {
			len_arg ++ ;
		}
		arg_offset[i] = arg_offset[i-1] + len_arg;
	}

	//int *ks = ks_start + 1;
	
	//*ks_start = argc;
	
	/*
	 * setup the pointer address to point to the addr on the user stack
	 */
	// the stack size in terms of words
	int s_size_w = (*len)/4;
	for (i = 0; i < argc; i++) {
		*(ks_start + i) = (arg_offset[i] - s_size_w) + (int *)(*usr_stack);
	}
	
	*(ks_start + argc) = NULL;
	
	/*
	 * set up the actual contents in argvs
	 */
	for (i = 0; i < argc; i++) {
		char *argi = (char *)(arg_offset[i] + ks_start);
		char **x = (char **)(argv+i);
		int arglen = (strlen(*(argv+i))+1)/4;
		if ((strlen(*(argv+i))+1)%4 != 0) {
			arglen ++ ;
		}
		memmove((void *)argi, (void *)*x, 4*arglen);
	}
	/*
	 * ks_start will passed to copyout
	 * usr_stack will be passed to md_usermode
	 * basically they all point to the beginning of the stack
	 * ks_stack is in kernel, usr_stack is in user as
	 */
	// *usr_stack is int, so offset it with respect to num of bytes (*len)
	*usr_stack = *usr_stack - *len;
	return (void *)ks_start;
}
Exemplo n.º 6
0
int lru_pages_release(cache_t *c, cache_page_t **page, int n_pages)
{
    cache_lru_t *cp = (cache_lru_t *)c->fn.priv;
    cache_segment_t *s;
    page_lru_t *lp;
    cache_page_t *p;
    int bits, i;

    cache_lock(c);

    for (i=0; i<n_pages; i++) {
        p = page[i];
        bits = atomic_get(p->bit_fields);
        log_printf(15, "seg=" XIDT " p->offset=" XOT " bits=%d bytes_used=" XOT "\n", segment_id(p->seg), p->offset, bits, cp->bytes_used);
        if ((bits & C_TORELEASE) > 0) {
            log_printf(15, "DESTROYING seg=" XIDT " p->offset=" XOT " bits=%d bytes_used=" XOT "cache_pages=%d\n", segment_id(p->seg), p->offset, bits, cp->bytes_used, stack_size(cp->stack));
            s = (cache_segment_t *)p->seg->priv;
            lp = (page_lru_t *)p->priv;

            cp->bytes_used -= s->page_size;
            if (lp->ele != NULL) {
                move_to_ptr(cp->stack, lp->ele);
                delete_current(cp->stack, 0, 0);
            } else {
                cp->limbo_pages--;
                log_printf(15, "seg=" XIDT " limbo page p->offset=" XOT " limbo=%d\n", segment_id(p->seg), p->offset, cp->limbo_pages);
            }

            if (p->offset > -1) {
                list_remove(s->pages, &(p->offset), p);  //** Have to do this here cause p->offset is the key var
            }
            if (p->data[0].ptr) free(p->data[0].ptr);
            if (p->data[1].ptr) free(p->data[1].ptr);
            free(lp);
        }
    }

    //** Now check if we can handle some waiters
    _lru_process_waiters(c);

    cache_unlock(c);

    return(0);
}
uint8_t DataFlash_MAVLink::queue_size(dm_block_queue_t queue)
{
    return stack_size(queue.oldest);
}
Exemplo n.º 8
0
 void *return_address(unsigned frame_no) const
 {
     if(frame_no < stack_size())
         return frames_[frame_no];
     return 0;
 }
Exemplo n.º 9
0
void path_check1(){
    printf("Testing FindPath(...) on World1\n");
    Grid *g;
    g = ReadWorld("world1.txt");
    
    Search *s;
    s = FindPath(g);

    assert_i(s->Length, 20, "Shortest path length - World1");
    assert_i(stack_size(s->s), s->Length+1, "Stack size - World1");

    int currR, currC;
    int last_currR, last_currC;
    int continuous = 1;
    int diffR, diffC;

    stack_pop(s->s, &last_currR, &last_currC);

    assert_i(last_currR, 10, "Start Location (Row) - World1");
    assert_i(last_currC, 4, "Start Location (Col) - World1");
    g->data[last_currR][last_currC] = '*';

    while(stack_size(s->s) > 0){
        stack_pop(s->s, &currR, &currC);
        g->data[currR][currC] = '*';

        diffR = currR - last_currR;
        diffR *= diffR;

        diffC = currC - last_currC;
        diffC *= diffC;
        // XOR - Eith diffR or diffC should be 1, not both.
        if(!(!diffR != !diffC)){
            continuous = 0;
        }
        last_currR = currR;
        last_currC = currC;
    }

    assert_i(currR, 3, "Path Ends on Goal (Row) - World1");
    assert_i(currC, 13, "Path Ends on Goal (Col) - World1");
    assert_i(continuous, 1, "Continuous Path from source");


    int actual[14][17] = {{MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT},
                          {MAX_INT,     12,     11,     12,     13,     14,     15,     16,     17,     18,     19,     20,     21,     22,     23,     24,MAX_INT},
                          {MAX_INT,     11,     10,     11,     12,     13,     14,     15,     16,     17,     18,     19,     20,     21,     22,     23,MAX_INT},
                          {MAX_INT,     10,      9,     10,     11,     12,     13,     14,     15,     16,     17,     18,     19,     20,     21,     22,MAX_INT},
                          {MAX_INT,      9,      8,      9,     10,     11,     12,     13,     14,     15,     16,     17,     18,     19,     20,     21,MAX_INT},
                          {MAX_INT,      8,      7,      8,      9,     10,     11,     12,     13,     14,     15,     16,     17,     18,     19,     20,MAX_INT},
                          {MAX_INT,      7,      6,      7,      8,      9,     10,     11,     12,     13,     14,     15,     16,     17,     18,     19,MAX_INT},
                          {MAX_INT,      6,      5,      6,      7,      8,      9,     10,     11,     12,     13,     14,     15,     16,     17,     18,MAX_INT},
                          {MAX_INT,      5,      4,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,     14,     15,     16,     17,MAX_INT},
                          {MAX_INT,      4,      3,      2,      1,      2,      3,      4,      5,      6,      7,MAX_INT,     13,     14,     15,     16,MAX_INT},
                          {MAX_INT,      3,      2,      1,      0,      1,      2,      3,      4,      5,      6,MAX_INT,     12,     13,     14,     15,MAX_INT},
                          {MAX_INT,      4,      3,      2,      1,      2,      3,      4,      5,      6,      7,MAX_INT,     11,     12,     13,     14,MAX_INT},
                          {MAX_INT,      5,      4,      3,      2,      3,      4,      5,      6,      7,      8,      9,     10,     11,     12,     13,MAX_INT},
                          {MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT,MAX_INT}};

    int correct_dist = 1, i,j;
    // Compare Calculated Distances to Model Solution. We only check for the distances less than the path length (you can stop calculating distances when you find the goal).
    for(i = 0; i < 14; i++){
        for(j = 0; j < 17; j++){
            if(actual[i][j] < 20 && actual[i][j] != s->Distance[i][j]){
                correct_dist = 0;
            } 
        }
    }
    assert_i(correct_dist, 1, "Distance Array - World1");

    printf("Path (Not Marked):\n");
    for(i = 0; i < 14; i++){
        for(j = 0; j < 17; j++){
            printf("%c", g->data[i][j]);
        }
        printf("\n");
    }

}
Exemplo n.º 10
0
static inline
bool stack_empty(struct stack *stack)
{
	return stack_size(stack) == 0;
}
Exemplo n.º 11
0
Arquivo: pp.c Projeto: berkus/moto
void motopp_freeFrame(MotoPP *ppenv) {
   MotoPPFrame *frame;
   Enumeration *e;
   
   if (stack_size(ppenv->frames) <= 1) {
      frame = stack_pop(ppenv->frames);
      buf_cat(ppenv->out, frame->out);
      ppenv->frame = NULL;
   }
   else {
      MotoPPVal *val;
      MotoPPFrame *pframe;
      SymbolTable *macros;
      MotoMacro *m;
      char *catstr;
      int catstrlen;
      frame = stack_pop(ppenv->frames);
      pframe = stack_peek(ppenv->frames);
      
      switch (frame->type) {
         case MACRO_FRAME:
            m = frame->macro;
            val = motopp_createVal(ppenv);
            if (ppenv->flags & MACRO_DEBUG_FLAG) {
               buf_printf(frame->out, LINE_FMT_2, pframe->filename, pframe->lineno);
            }
            val->sval = buf_toString(frame->out);
            stack_push(pframe->opstack, val);
                                                                           
            macros = stack_pop(ppenv->macrostack);
            e = stab_getKeys(macros);
            while (enum_hasNext(e)) {
               char *name = (char *)enum_next(e);
               MotoMacro *m = (MotoMacro *)stab_get(macros, name);
               motopp_freeMacro(m);
            }
            stab_free(macros);
            enum_free(e);
            break;
         case INCLUDE_FRAME:
            catstr = buf_data(frame->out);
            catstrlen = strlen(catstr);            
            if (catstr[catstrlen - 1] == '\n') {
               catstr[catstrlen - 1] = '\0';
            }
            buf_puts(pframe->out, catstr);
            if (ppenv->flags & MACRO_DEBUG_FLAG) {
               buf_printf(pframe->out, LINE_FMT_2, pframe->filename, pframe->lineno);
            }
            break;
         default:
            buf_cat(pframe->out, frame->out);
            break;
      }
      
      /* reset pplineno */
      pplineno = pframe->lineno;

      /* reset frame */
      ppenv->frame = pframe;   
   } 

   if (frame->yybuf != NULL) {
      if (shared_check(frame->yybuf)) {
         motopp_freeYYBuffer(frame->yybuf);
      }
   }
   if (frame->yybufmem != NULL) {
      free(frame->yybufmem);
   }
   buf_free(frame->out);
   stack_free(frame->opstack);
   free(frame->filename);
   free(frame->relative_root);
   free(frame);
   
}
Exemplo n.º 12
0
Arquivo: pp.c Projeto: berkus/moto
void motopp_freeEnv(MotoPP *ppenv) {
   Enumeration *e;
   
   log_debug(__FILE__, ">>> motopp_freeEnv\n");
  
   buf_free(ppenv->out);
   buf_free(ppenv->err);
   buf_free(ppenv->argbuf);
   istack_free(ppenv->dirstack);
   stack_free(ppenv->frames);   

   /* free vals */
   e = hset_elements(ppenv->vallist);
   while (enum_hasNext(e)) {
      MotoPPVal *val = enum_next(e);
      if (shared_check(val->sval)) {
         free(val->sval);
         hset_remove(ppenv->ptrs, val->sval);
      }
      free(val);
   }
   enum_free(e);
   hset_free(ppenv->vallist);
   
   /* free macros */
   while (stack_size(ppenv->macrostack) > 0) {
      SymbolTable *macros = stack_pop(ppenv->macrostack);
      e = stab_getKeys(macros);
      while (enum_hasNext(e)) {
         char *name = (char *)enum_next(e);
         MotoMacro *m = (MotoMacro *)stab_get(macros, name);
         motopp_freeMacro(m);
      }
      stab_free(macros);
      enum_free(e);
   }
   
   /* free all remaining sys pointers */
   e = hset_elements(ppenv->sysptrs);
   while (enum_hasNext(e)) {
      void *ptr = enum_next(e);
      if (ptr) {
         sys_free(ptr);         
      }
   }
   enum_free(e);
      
   /* free all remaining pointers */
   e = hset_elements(ppenv->ptrs);
   while (enum_hasNext(e)) {
      void *ptr = enum_next(e);
      if (shared_check(ptr)) {
         free(ptr);         
      }
   }
   enum_free(e);
      
   /* free remaining pooled memory */
   mpool_free(ppenv->mpool);

   /* free remainder of env struct */
   hset_free(ppenv->sysptrs);
   hset_free(ppenv->ptrs);
   stack_free(ppenv->macrostack);   
   
   free(ppenv);

   log_debug(__FILE__, "<<< motopp_freeEnv\n");

}
Exemplo n.º 13
0
inline int 
opstack_size(MotoEnv *env) {
   return stack_size(env->frame->opstack);
}
Exemplo n.º 14
0
void _opque_cb(void *v, int mode)
{
    int type, n;
    op_status_t success;
    op_generic_t *gop = (op_generic_t *)v;
    que_data_t *q = &(gop->base.parent_q->qd);

    log_printf(15, "_opque_cb: START qid=%d gid=%d\n", gop_id(&(q->opque->op)), gop_id(gop));

    //** Get the status (gop is already locked)
    type = gop_get_type(gop);
    if (type == Q_TYPE_QUE) {
        n = stack_size(gop->q->failed);
        log_printf(15, "_opque_cb: qid=%d gid=%d  stack_size(q->failed)=%d gop->status=%d\n", gop_id(&(q->opque->op)), gop_id(gop), n, gop->base.status.op_status);
        success = (n == 0) ? gop->base.status : op_failure_status;
    } else {
        success = gop->base.status;
    }

    lock_opque(q);

    log_printf(15, "_opque_cb: qid=%d gid=%d success=%d gop_type(gop)=%d\n", gop_id(&(q->opque->op)), gop_id(gop), success, gop_get_type(gop));


    //** It always goes on the finished list
    move_to_bottom(q->finished);
    insert_below(q->finished, gop);

    log_printf(15, "PUSH finished gid=%d qid=%d\n", gop_id(gop), gop_id(&(q->opque->op)));
    log_printf(15, "Printing finished stack for qid=%d\n", gop_id(&(q->opque->op)));
    if (log_level() > 15) _opque_print_stack(q->finished);

    if (success.op_status == OP_STATE_FAILURE) push(q->failed, gop); //** Push it on the failed list if needed

    q->nleft--;
    log_printf(15, "_opque_cb: qid=%d gid=%d nleft=%d stack_size(q->failed)=%d stack_size(q->finished)=%d\n", gop_id(&(q->opque->op)), gop_id(gop), q->nleft, stack_size(q->failed), stack_size(q->finished));
    flush_log();

    if (q->nleft <= 0) {  //** we're finished
        if (stack_size(q->failed) == 0) {
            q->opque->op.base.status = op_success_status;
            callback_execute(q->opque->op.base.cb, OP_STATE_SUCCESS);

            //** Lastly trigger the signal. for anybody listening
            apr_thread_cond_broadcast(q->opque->op.base.ctl->cond);
        } else if (q->opque->op.base.retries == 0) {  //** How many times we're retried
            //** Trigger the callbacks
            q->opque->op.base.retries++;
            q->nleft = 0;
            q->opque->op.base.failure_mode = 0;
            callback_execute(&(q->failure_cb), OP_STATE_FAILURE);  //** Attempt to fix things

            if (q->opque->op.base.failure_mode == 0) {  //** No retry
                q->opque->op.base.status = op_failure_status;
                callback_execute(q->opque->op.base.cb, OP_STATE_FAILURE);  //**Execute the other CBs
                apr_thread_cond_broadcast(q->opque->op.base.ctl->cond);  //** and fail for good
            }

            //** If retrying don't send the broadcast
            log_printf(15, "_opque_cb: RETRY END qid=%d gid=%d\n", gop_id(&(q->opque->op)), gop_id(gop));
            flush_log();
        } else {
            //** Finished with errors but trigger the signal for anybody listening
            apr_thread_cond_broadcast(q->opque->op.base.ctl->cond);
        }
    } else {
        //** Not finished but trigger the signal for anybody listening
        apr_thread_cond_broadcast(q->opque->op.base.ctl->cond);
    }

    log_printf(15, "_opque_cb: END qid=%d gid=%d\n", gop_id(&(q->opque->op)), gop_id(gop));
    flush_log();

    unlock_opque(q);
}
Exemplo n.º 15
0
int main(int argc, char **argv) {

Stack              stack;

int                *data,
                   i;

/*****************************************************************************
*                                                                            *
*  Initialize the stack.                                                     *
*                                                                            *
*****************************************************************************/

stack_init(&stack, free);

/*****************************************************************************
*                                                                            *
*  Perform some stack operations.                                            *
*                                                                            *
*****************************************************************************/

fprintf(stdout, "Pushing 10 elements\n");

for (i = 0; i < 10; i++) {

   if ((data = (int *)malloc(sizeof(int))) == NULL)
      return 1;

   *data = i + 1;

   if (stack_push(&stack, data) != 0)
      return 1;

}

print_stack(&stack);

fprintf(stdout, "Popping 5 elements\n");

for (i = 0; i < 5; i++) {

   if (stack_pop(&stack, (void **)&data) == 0)
      free(data);
   else
      return 1;

}

print_stack(&stack);

fprintf(stdout, "Pushing 100 and 200\n");

if ((data = (int *)malloc(sizeof(int))) == NULL)
   return 1;

*data = 100;

if (stack_push(&stack, data) != 0)
   return 1;

if ((data = (int *)malloc(sizeof(int))) == NULL)
   return 1;

*data = 200;

if (stack_push(&stack, data) != 0)
   return 1;

print_stack(&stack);

if ((data = stack_peek(&stack)) != NULL)
   fprintf(stdout, "Peeking at the top element...Value=%03d\n", *data);
else
   fprintf(stdout, "Peeking at the top element...Value=NULL\n");

print_stack(&stack);

fprintf(stdout, "Popping all elements\n");

while (stack_size(&stack) > 0) {

   if (stack_pop(&stack, (void **)&data) == 0)
      free(data);
   
}

if ((data = stack_peek(&stack)) != NULL)
   fprintf(stdout, "Peeking at an empty stack...Value=%03d\n", *data);
else
   fprintf(stdout, "Peeking at an empty stack...Value=NULL\n");

print_stack(&stack);

/*****************************************************************************
*                                                                            *
*  Destroy the stack.                                                        *
*                                                                            *
*****************************************************************************/

fprintf(stdout, "Destroying the stack\n");
stack_destroy(&stack);

return 0;

}
Exemplo n.º 16
0
/** local data type declaration and local struct, union, enum section **/

/** local function prototype section **/

/** exported global variable definition section **/

/** local global variable definition section **/

/** exported function implementation section **/
void test_stack(void)
{
    {
        stack_t t_sk = create_stack(int);

        stack_init(&t_sk);
        printf("stack1 - size:%u, empty:%d\n", stack_size(&t_sk), stack_empty(&t_sk));

        stack_push(&t_sk, 100);
        printf("top:%d\n", *(int*)stack_top(&t_sk));
        *(int*)stack_top(&t_sk) = 3333;
        printf("top:%d\n", *(int*)stack_top(&t_sk));

        stack_destroy(&t_sk);
    }
    {
        stack_t t_st = create_stack(int);

        stack_init(&t_st);
        stack_push(&t_st, 1);
        stack_push(&t_st, 2);
        stack_push(&t_st, 3);
Exemplo n.º 17
0
cache_page_t *_lru_new_page(cache_t *c, segment_t *seg)
{
    cache_lru_t *cp = (cache_lru_t *)c->fn.priv;
    cache_segment_t *s = (cache_segment_t *)seg->priv;
    page_lru_t *lp;
    cache_page_t *p;

    type_malloc_clear(lp, page_lru_t, 1);
    p = &(lp->page);
    p->curr_data = &(p->data[0]);
    p->current_index = 0;
    type_malloc_clear(p->curr_data->ptr, char, s->page_size);

    cp->bytes_used += s->page_size;

    p->priv = (void *)lp;
    p->seg = seg;
//  p->offset = -1;
    p->offset = atomic_dec(lru_dummy);
    atomic_set(p->bit_fields, C_EMPTY);  //** This way it's not accidentally deleted

    //** Store my position
    push(cp->stack, p);
    lp->ele = get_ptr(cp->stack);

    log_printf(15, " seg=" XIDT " page created initial->offset=" XOT " page_size=" XOT " data[0]=%p bytes_used=" XOT " stack_size=%d\n", segment_id(seg), p->offset, s->page_size, p->curr_data->ptr, cp->bytes_used, stack_size(cp->stack));
    return(p);
}
Exemplo n.º 18
0
void FpuStackSim::push(int rnr) {
  if (TraceFPUStack) { tty->print("FPU-push %d", rnr); print(); tty->cr(); }
  assert(regs_at(stack_size()) == EMPTY, "should be empty");
  set_regs_at(stack_size(), rnr);
  inc_stack_size();
}
Exemplo n.º 19
0
int
main (int argc, char ** argv)
{
  stack_t stack;
  size_t i, size, j;
  void * tmp;

  /* Create a new stack */
  stack = stack_init ();
  if (stack == NULL)
    {
      printf ("Initial Memory allocation failed\n");
      return 99;
    }

  /* Test an empty stack */
  test_empty (stack);

  /* Small Number Test */
  size = 10;
  for (i = 0; i < size; i++)
    stack_push (stack, (void*)i);
  if (size != stack_size (stack))
    {
      printf ("Small Number: Size Failure\n");
      return EXIT_FAILURE;
    }
  for (i = size; i > 0; i--)
    if (stack_peek (stack) != (void*)(i-1) ||
	stack_pop (stack) != (void*)(i-1))
      {
	printf ("Small Number: Integrity Failure\n");
	return EXIT_FAILURE;
      }

  /* Make sure stack is empty */
  test_empty (stack);

  /* Clear Test */
  size = 100;
  for (i = 0; i < size; i++)
    stack_push (stack, (void*)i);
  stack_clear (stack);
  test_empty (stack);

  /* Many data test */
  size = 10000;
  for (i = 0; i < size; i++)
    {
      stack_push (stack, (void*)i);
      for (j = 0; j < 32; j++)
	stack_push (stack, (void*)(i+j));
      for (j = 32; j > 0; j--)
	if ((tmp = stack_peek (stack)) != (void*)(j+i-1) ||
	    (tmp = stack_pop (stack)) != (void*)(j+i-1))
	  {
	    printf ("Many Data: Integrity Failure\nExpected: %p Got: %p\n", j+i-1, tmp);
	    return EXIT_FAILURE;
	  }
    }
  if (size != stack_size (stack))
    {
      printf ("Many Data: Size Failure\nExpected: %lu Got: %lu\n", size, stack_size (stack));
      return EXIT_FAILURE;
    }
  for (i = size; i > 0; i--)
    if ((tmp = stack_peek (stack)) != (void*)(i-1) ||
	(tmp = stack_pop (stack)) != (void*)(i-1))
      {
	printf ("Many Data: Integrity Failure\nExpected: %p Got %p\n", i-1, tmp);
	return EXIT_FAILURE;
      }
    

  /* Destroy the stack */
  stack_destroy (stack);

  return EXIT_SUCCESS;
}