C++ (Cpp) dict_load_next Examples

Example #1

File: kaz_tree.c Project: BackupTheBerlios/fc-solve-svn

void dict_merge(dict_t *dest, dict_t *source)
{
    dict_load_t load;
    dnode_t *leftnode = dict_first(dest), *rightnode = dict_first(source);

    assert (dict_similar(dest, source));

    if (source == dest)
        return;

#ifdef NO_FC_SOLVE
    dest->nodecount = 0;
#endif
    load_begin_internal(&load, dest);

    for (;;) {
        if (leftnode != NULL && rightnode != NULL) {
            if (dest->compare(leftnode->key, rightnode->key, source->context) < 0)
                goto copyleft;
            else
                goto copyright;
        } else if (leftnode != NULL) {
            goto copyleft;
        } else if (rightnode != NULL) {
            goto copyright;
        } else {
            assert (leftnode == NULL && rightnode == NULL);
            break;
        }

    copyleft:
        {
            dnode_t *next = dict_next(dest, leftnode);
            #ifndef NDEBUG
            leftnode->left = NULL;      /* suppress assertion in dict_load_next */
            #endif
            dict_load_next(&load, leftnode, leftnode->key);
            leftnode = next;
            continue;
        }

    copyright:
        {
            dnode_t *next = dict_next(source, rightnode);
            #ifndef NDEBUG
            rightnode->left = NULL;
            #endif
            dict_load_next(&load, rightnode, rightnode->key);
            rightnode = next;
            continue;
        }
    }

    dict_clear(source);
    dict_load_end(&load);
}

Example #2

File: dict.c Project: amuraru/libm2handler

static void construct(dict_t *d)
{
    input_t in;
    int done = 0;
    dict_load_t dl;
    dnode_t *dn;
    char *tok1, *tok2, *val;
    const char *key;
    char *help =
        "p                      turn prompt on\n"
        "q                      finish construction\n"
        "a <key> <val>          add new entry\n";

    if (!dict_isempty(d))
        puts("warning: dictionary not empty!");

    dict_load_begin(&dl, d);

    while (!done) {
        if (prompt)
            putchar('>');
        fflush(stdout);

        if (!fgets(in, sizeof(input_t), stdin))
            break;

        switch (in[0]) {
            case '?':
                puts(help);
                break;
            case 'p':
                prompt = 1;
                break;
            case 'q':
                done = 1;
                break;
            case 'a':
                if (tokenize(in+1, &tok1, &tok2, (char **) 0) != 2) {
                    puts("what?");
                    break;
                }
                key = dupstring(tok1);
                val = dupstring(tok2);
                dn = dnode_create(val);

                if (!key || !val || !dn) {
                    puts("out of memory");
                    free((void *) key);
                    free(val);
                    if (dn)
                        dnode_destroy(dn);
                }

                dict_load_next(&dl, dn, key);
                break;
            default:
                putchar('?');
                putchar('\n');
                break;
        }
    }

    dict_load_end(&dl);
}