自学教程：C++ sporth_stack_pop_float函数代码示例

static void pop_args(sporth_stack *stack, sporth_oscmorph *om){    om->phase = sporth_stack_pop_float(stack);    om->wtpos = sporth_stack_pop_float(stack);    om->amp = sporth_stack_pop_float(stack);    om->freq = sporth_stack_pop_float(stack);}

int sporth_f(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    unsigned int fnum;    sporth_func_d *fd;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "aux (f)unction: creating/n");#endif            fd = malloc(sizeof(sporth_func_d));            plumber_add_module(pd, SPORTH_F, sizeof(sporth_func_d), fd);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            fprintf(stderr, "aux (f)unction: initialising/n");#endif           if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for aux (f)unction/n");                stack->error++;                return PLUMBER_NOTOK;            }            fnum = (int)sporth_stack_pop_float(stack);            if(fnum > 16) {                fprintf(stderr, "Invalid function number %d/n", fnum);                stack->error++;                return PLUMBER_NOTOK;            }            fd = pd->last->ud;            fd->fun = pd->f[fnum];            pd->mode = PLUMBER_CREATE;            fd->fun(stack, ud);            pd->mode = PLUMBER_INIT;            fd->fun(stack, ud);            break;        case PLUMBER_COMPUTE:            fnum = (int)sporth_stack_pop_float(stack);            fd = pd->last->ud;            fd->fun(stack, ud);            break;        case PLUMBER_DESTROY:            fd = pd->last->ud;            fd->fun(stack, ud);            free(fd);            break;        default:            fprintf(stderr, "aux (f)unction: unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_palias(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    char *name;    int id;    SPFLOAT *foo;    switch(pd->mode) {        case PLUMBER_CREATE:            plumber_add_ugen(pd, SPORTH_PALIAS, NULL);            if(sporth_check_args(stack, "sf") != SPORTH_OK) {                fprintf(stderr,"palias: Not enough arguments/n");                stack->error++;                return PLUMBER_NOTOK;            }            id = floor(sporth_stack_pop_float(stack));            name = sporth_stack_pop_string(stack);            foo = &pd->p[id];            plumber_ftmap_delete(pd, 0);            plumber_set_var(pd, name, foo);            plumber_ftmap_delete(pd, 1);            break;        case PLUMBER_INIT:            sporth_stack_pop_float(stack);            sporth_stack_pop_string(stack);            break;        case PLUMBER_COMPUTE:            sporth_stack_pop_float(stack);            break;        default:            break;    }    return PLUMBER_OK;}

int sporth_bpm2dur(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    bpm2val *data;    SPFLOAT val;    switch(pd->mode){        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "bpm2dur: Creating/n");#endif            data = malloc(sizeof(bpm2val));            data->pbpm = -100;            data->val= -100;            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr, "bpm2dur: not enough args/n");                stack->error++;                return PLUMBER_NOTOK;            }            val = sporth_stack_pop_float(stack);            data->pbpm= val;            data->val= 60.0 / val;            plumber_add_ugen(pd, SPORTH_BPM2DUR, data);            sporth_stack_push_float(stack, data->val);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            fprintf(stderr, "bpm2dur: Initializing/n");#endif            data = pd->last->ud;            val = sporth_stack_pop_float(stack);            if(data->pbpm != val) {                data->pbpm= val;                data->val= 60.0 / val;            }            sporth_stack_push_float(stack, data->val);            break;        case PLUMBER_COMPUTE:            data = pd->last->ud;            val = sporth_stack_pop_float(stack);            if(data->pbpm  != val) {                data->pbpm= val;                data->val = 60.0 / val;            }            sporth_stack_push_float(stack, data->val);            break;        case PLUMBER_DESTROY:            data = pd->last->ud;            free(data);            break;        default:            fprintf(stderr,"bpm2dur: unknown mode!");            stack->error++;            return PLUMBER_NOTOK;            break;    }    return PLUMBER_OK;}

int sporth_print(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    sporth_print_d *prnt;    char *str = NULL;     SPFLOAT val = 0;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "print: Creating/n");#endif            prnt = malloc(sizeof(sporth_print_d));            plumber_add_ugen(pd, SPORTH_PRINT, prnt);            if(sporth_check_args(stack, "fs") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for print/n");                stack->error++;                return PLUMBER_NOTOK;            }            str = sporth_stack_pop_string(stack);            val = sporth_stack_pop_float(stack);                        strncpy(prnt->label, str, 128);            prnt->pval = val;             prnt->init = 1;            sporth_stack_push_float(stack, val);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            fprintf(stderr, "print: Initialising/n");#endif            prnt = pd->last->ud;            str = sporth_stack_pop_string(stack);            val = sporth_stack_pop_float(stack);            sporth_stack_push_float(stack, val);            break;        case PLUMBER_COMPUTE:            prnt = pd->last->ud;            val = sporth_stack_pop_float(stack);            if(val != prnt->pval || prnt->init) {                prnt->pval = val;                prnt->init = 0;                printf("%s: %g/n", prnt->label, val);            }            sporth_stack_push_float(stack, val);            break;        case PLUMBER_DESTROY:            prnt = pd->last->ud;            free(prnt);            break;        default:            fprintf(stderr, "print: Unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_dmetro(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT out;    SPFLOAT time;    sp_dmetro *dmetro;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "dmetro: Creating/n");#endif            sp_dmetro_create(&dmetro);            plumber_add_ugen(pd, SPORTH_DMETRO, dmetro);            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for dmetro/n");                stack->error++;                return PLUMBER_NOTOK;            }            time = sporth_stack_pop_float(stack);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            fprintf(stderr, "dmetro: Initialising/n");#endif            time = sporth_stack_pop_float(stack);            dmetro = pd->last->ud;            sp_dmetro_init(pd->sp, dmetro);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for dmetro/n");                stack->error++;                return PLUMBER_NOTOK;            }            time = sporth_stack_pop_float(stack);            dmetro = pd->last->ud;            dmetro->time = time;            sp_dmetro_compute(pd->sp, dmetro, NULL, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            dmetro = pd->last->ud;            sp_dmetro_destroy(&dmetro);            break;        default:            fprintf(stderr, "dmetro: Uknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_comb(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT input;    SPFLOAT out;    SPFLOAT looptime;    SPFLOAT revtime;    sp_comb *comb;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            plumber_print(pd, "comb: Creating/n");#endif            sp_comb_create(&comb);            plumber_add_ugen(pd, SPORTH_COMB, comb);            if(sporth_check_args(stack, "fff") != SPORTH_OK) {                plumber_print(pd,"Not enough arguments for comb/n");                stack->error++;                return PLUMBER_NOTOK;            }            looptime = sporth_stack_pop_float(stack);            revtime = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            plumber_print(pd, "comb: Initialising/n");#endif            looptime = sporth_stack_pop_float(stack);            revtime = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            comb = pd->last->ud;            sp_comb_init(pd->sp, comb, looptime);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            looptime = sporth_stack_pop_float(stack);            revtime = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            comb = pd->last->ud;            comb->revtime = revtime;            sp_comb_compute(pd->sp, comb, &input, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            comb = pd->last->ud;            sp_comb_destroy(&comb);            break;        default:            plumber_print(pd, "comb: Unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_waveset(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT input;    SPFLOAT out;    SPFLOAT ilen;    SPFLOAT rep;    sp_waveset *waveset;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            plumber_print(pd, "waveset: Creating/n");#endif            sp_waveset_create(&waveset);            plumber_add_ugen(pd, SPORTH_WAVESET, waveset);            if(sporth_check_args(stack, "fff") != SPORTH_OK) {                plumber_print(pd,"Not enough arguments for waveset/n");                stack->error++;                return PLUMBER_NOTOK;            }            ilen = sporth_stack_pop_float(stack);            rep = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            plumber_print(pd, "waveset: Initialising/n");#endif            ilen = sporth_stack_pop_float(stack);            rep = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            waveset = pd->last->ud;            sp_waveset_init(pd->sp, waveset, ilen);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            ilen = sporth_stack_pop_float(stack);            rep = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            waveset = pd->last->ud;            waveset->rep = rep;            sp_waveset_compute(pd->sp, waveset, &input, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            waveset = pd->last->ud;            sp_waveset_destroy(&waveset);            break;        default:            plumber_print(pd, "waveset: Unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_crossfade(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT in1;    SPFLOAT in2;    SPFLOAT out;    SPFLOAT pos;    sp_crossfade *crossfade;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            plumber_print(pd, "crossfade: Creating/n");#endif            sp_crossfade_create(&crossfade);            plumber_add_ugen(pd, SPORTH_CROSSFADE, crossfade);            if(sporth_check_args(stack, "fff") != SPORTH_OK) {                plumber_print(pd,"Not enough arguments for crossfade/n");                stack->error++;                return PLUMBER_NOTOK;            }            pos = sporth_stack_pop_float(stack);            in1 = sporth_stack_pop_float(stack);            in2 = sporth_stack_pop_float(stack);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            plumber_print(pd, "crossfade: Initialising/n");#endif            pos = sporth_stack_pop_float(stack);            in1 = sporth_stack_pop_float(stack);            in2 = sporth_stack_pop_float(stack);            crossfade = pd->last->ud;            sp_crossfade_init(pd->sp, crossfade);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            pos = sporth_stack_pop_float(stack);            in1 = sporth_stack_pop_float(stack);            in2 = sporth_stack_pop_float(stack);            crossfade = pd->last->ud;            crossfade->pos = pos;            sp_crossfade_compute(pd->sp, crossfade, &in1, &in2, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            crossfade = pd->last->ud;            sp_crossfade_destroy(&crossfade);            break;        default:            plumber_print(pd, "crossfade: Unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_moogladder(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT input;    SPFLOAT out;    SPFLOAT freq;    SPFLOAT res;    sp_moogladder *moogladder;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "moogladder: Creating/n");#endif            sp_moogladder_create(&moogladder);            plumber_add_ugen(pd, SPORTH_MOOGLADDER, moogladder);            if(sporth_check_args(stack, "fff") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for moogladder/n");                stack->error++;                return PLUMBER_NOTOK;            }            res = sporth_stack_pop_float(stack);            freq = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            fprintf(stderr, "moogladder: Initialising/n");#endif            res = sporth_stack_pop_float(stack);            freq = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            moogladder = pd->last->ud;            sp_moogladder_init(pd->sp, moogladder);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            res = sporth_stack_pop_float(stack);            freq = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            moogladder = pd->last->ud;            moogladder->freq = freq;            moogladder->res = res;            sp_moogladder_compute(pd->sp, moogladder, &input, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            moogladder = pd->last->ud;            sp_moogladder_destroy(&moogladder);            break;        default:            fprintf(stderr, "moogladder: Unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_delay(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT input;    SPFLOAT out;    SPFLOAT time;    SPFLOAT feedback;    sp_delay *delay;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "delay: Creating/n");#endif            sp_delay_create(&delay);            plumber_add_ugen(pd, SPORTH_DELAY, delay);            if(sporth_check_args(stack, "fff") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for delay/n");                stack->error++;                return PLUMBER_NOTOK;            }            time = sporth_stack_pop_float(stack);            feedback = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            fprintf(stderr, "delay: Initialising/n");#endif            time = sporth_stack_pop_float(stack);            feedback = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            delay = pd->last->ud;            sp_delay_init(pd->sp, delay, time);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            time = sporth_stack_pop_float(stack);            feedback = sporth_stack_pop_float(stack);            input = sporth_stack_pop_float(stack);            delay = pd->last->ud;            delay->feedback = feedback;            sp_delay_compute(pd->sp, delay, &input, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            delay = pd->last->ud;            sp_delay_destroy(&delay);            break;        default:            fprintf(stderr, "delay: Unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_gen_line(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    int size;    sp_ftbl *ft;    char *str;    char *args;    switch(pd->mode){        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "gen_line: create mode/n");#endif            plumber_add_ugen(pd, SPORTH_GEN_LINE, NULL);            if(sporth_check_args(stack, "sfs") != SPORTH_OK) {                fprintf(stderr, "Init: not enough arguments for gen_line/n");                return PLUMBER_NOTOK;            }            args = sporth_stack_pop_string(stack);            size = (int)sporth_stack_pop_float(stack);            str = sporth_stack_pop_string(stack);#ifdef DEBUG_MODE            fprintf(stderr, "Creating line table %s of size %d/n", str, size);#endif            sp_ftbl_create(pd->sp, &ft, size);            if(sp_gen_line(pd->sp, ft, args) == SP_NOT_OK) {                fprintf(stderr, "There was an issue creating the line ftable /"%s/"./n", str);                stack->error++;                return PLUMBER_NOTOK;            }            plumber_ftmap_add(pd, str, ft);            break;        case PLUMBER_INIT:            args = sporth_stack_pop_string(stack);            size = (int)sporth_stack_pop_float(stack);            str = sporth_stack_pop_string(stack);            break;        case PLUMBER_COMPUTE:            sporth_stack_pop_float(stack);            break;        case PLUMBER_DESTROY:            break;        default:           printf("Error: Unknown mode!");           break;    }    return PLUMBER_OK;}

int sporth_sget(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    char *ftname;    uint32_t index = 0;    slist_d *sl;    char **str = NULL;    switch(pd->mode){        case PLUMBER_CREATE:            str = malloc(sizeof(char *));            plumber_add_ugen(pd, SPORTH_SGET, str);            if(sporth_check_args(stack, "fs") != SPORTH_OK) {               plumber_print(pd,"Not enough arguments for sget/n");                return PLUMBER_NOTOK;            }            ftname = sporth_stack_pop_string(stack);            index = sporth_stack_pop_float(stack);            if(plumber_ftmap_search_userdata(pd,ftname, (void *)&sl) !=                     PLUMBER_OK) {                plumber_print(pd, "Could not find ftable %s/n", ftname);                return PLUMBER_NOTOK;            }            if(index > sl->len - 1) {                plumber_print(pd, "Index %d exceeds slist length %d/n",                        index, sl->len);                return PLUMBER_NOTOK;            }            *str = sl->list[index];            sporth_stack_push_string(stack, &sl->list[index]);            break;        case PLUMBER_INIT:            str = pd->last->ud;            sporth_stack_pop_string(stack);            sporth_stack_pop_float(stack);            sporth_stack_push_string(stack, str);            break;        case PLUMBER_COMPUTE:            sporth_stack_pop_float(stack);            break;        case PLUMBER_DESTROY:            str = pd->last->ud;            free(str);            break;        default:            plumber_print(pd,"Error: Unknown mode!");            break;    }    return PLUMBER_OK;}

int sporth_tin(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT trig;    SPFLOAT out;    sp_tin *tin;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "tin: Creating/n");#endif            sp_tin_create(&tin);            plumber_add_module(pd, SPORTH_TIN, sizeof(sp_tin), tin);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            fprintf(stderr, "tin: Initialising/n");#endif            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for tin/n");                stack->error++;                return PLUMBER_NOTOK;            }            trig = sporth_stack_pop_float(stack);            tin = pd->last->ud;            sp_tin_init(pd->sp, tin);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for tin/n");                stack->error++;                return PLUMBER_NOTOK;            }            trig = sporth_stack_pop_float(stack);            tin = pd->last->ud;            sp_tin_compute(pd->sp, tin, &trig, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            tin = pd->last->ud;            sp_tin_destroy(&tin);            break;        default:            fprintf(stderr, "tin: Uknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_prop(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT bpm;    SPFLOAT out;    sp_prop *data;    char *str;    switch(pd->mode){        case PLUMBER_CREATE:            sp_prop_create(&data);            plumber_add_module(pd, SPORTH_PROP, sizeof(sp_prop), data);            break;        case PLUMBER_INIT:            if(sporth_check_args(stack, "fs") != SPORTH_OK) {                fprintf(stderr, "Not enough arguments for prop/n");                stack->error++;                return PLUMBER_NOTOK;            }            data = pd->last->ud;            str = sporth_stack_pop_string(stack);            bpm = sporth_stack_pop_float(stack);            if(sp_prop_init(pd->sp, data, str) == SP_NOT_OK) {                stack->error++;                free(str);                return PLUMBER_NOTOK;            }            sporth_stack_push_float(stack, 0);            free(str);            break;        case PLUMBER_COMPUTE:            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr, "Not enough arguments for prop/n");                stack->error++;                return PLUMBER_NOTOK;            }            bpm = sporth_stack_pop_float(stack);            data = pd->last->ud;            data->bpm = bpm;            sp_prop_compute(pd->sp, data, NULL, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            data = pd->last->ud;            sp_prop_destroy(&data);            break;        default:           printf("Error: Unknown mode!");           break;    }    return PLUMBER_NOTOK;}

int sporth_gen_composite(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    uint32_t size;    sp_ftbl *ft;    char *str, *args;    switch(pd->mode){        case PLUMBER_CREATE:            plumber_add_ugen(pd, SPORTH_GEN_COMPOSITE, NULL);            if(sporth_check_args(stack, "sfs") != SPORTH_OK) {               fprintf(stderr,"composite: not enough arguments for gen_vals/n");                return PLUMBER_NOTOK;            }            args = sporth_stack_pop_string(stack);            size = (uint32_t)sporth_stack_pop_float(stack);            str = sporth_stack_pop_string(stack);            sp_ftbl_create(pd->sp, &ft, size);            sp_gen_composite(pd->sp, ft, args);            plumber_ftmap_add(pd, str, ft);            free(args);            free(str);            break;        case PLUMBER_INIT:            args = sporth_stack_pop_string(stack);            size = (uint32_t)sporth_stack_pop_float(stack);            str = sporth_stack_pop_string(stack);            free(str);            free(args);            break;        case PLUMBER_COMPUTE:            sporth_stack_pop_float(stack);            break;        case PLUMBER_DESTROY:            break;        default:          fprintf(stderr,"Error: Unknown mode!");           break;    }    return PLUMBER_OK;}

int sporth_pinknoise(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT out;    SPFLOAT amp;    sp_pinknoise *pinknoise;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "pinknoise: Creating/n");#endif            sp_pinknoise_create(&pinknoise);            plumber_add_ugen(pd, SPORTH_PINKNOISE, pinknoise);            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for pinknoise/n");                stack->error++;                return PLUMBER_NOTOK;            }            amp = sporth_stack_pop_float(stack);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:#ifdef DEBUG_MODE            fprintf(stderr, "pinknoise: Initialising/n");#endif            amp = sporth_stack_pop_float(stack);            pinknoise = pd->last->ud;            sp_pinknoise_init(pd->sp, pinknoise);            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            amp = sporth_stack_pop_float(stack);            pinknoise = pd->last->ud;            pinknoise->amp = amp;            sp_pinknoise_compute(pd->sp, pinknoise, NULL, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            pinknoise = pd->last->ud;            sp_pinknoise_destroy(&pinknoise);            break;        default:            fprintf(stderr, "pinknoise: Unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_slist(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    char *ftname;    char *filename;    uint32_t size;    slist_d *sl;    switch(pd->mode){        case PLUMBER_CREATE:            sl = malloc(sizeof(slist_d));            sl->list = NULL;            plumber_add_ugen(pd, SPORTH_SLIST, sl);            if(sporth_check_args(stack, "sfs") != SPORTH_OK) {               plumber_print(pd,"Not enough arguments for slist/n");                return PLUMBER_NOTOK;            }            filename = sporth_stack_pop_string(stack);            size = sporth_stack_pop_float(stack);            ftname = sporth_stack_pop_string(stack);            if(slist_parse(sl, filename, size) != PLUMBER_OK) {                plumber_print(pd,                         "slist: could not load file %s/n",                        filename);                return PLUMBER_NOTOK;            }            plumber_ftmap_add_userdata(pd, ftname, sl);            break;        case PLUMBER_INIT:            sporth_stack_pop_string(stack);            sporth_stack_pop_float(stack);            sporth_stack_pop_string(stack);            break;        case PLUMBER_COMPUTE:            sporth_stack_pop_float(stack);            break;        case PLUMBER_DESTROY:            sl = pd->last->ud;            slist_destroy(sl);            break;        default:            plumber_print(pd,"Error: Unknown mode!");            break;    }    return PLUMBER_OK;}

int sporth_gen_file(sporth_stack *stack, void *ud){#ifndef NO_LIBSNDFILE    plumber_data *pd = ud;    sp_ftbl *ft;    char *str;    char *filename;    int size;    switch(pd->mode){        case PLUMBER_CREATE:            plumber_add_ugen(pd, SPORTH_GEN_FILE, NULL);            if(sporth_check_args(stack, "sfs") != SPORTH_OK) {                fprintf(stderr, "Init: not enough arguments for gen_file/n");                return PLUMBER_NOTOK;            }            filename = sporth_stack_pop_string(stack);            size = (int)sporth_stack_pop_float(stack);            str = sporth_stack_pop_string(stack);            sp_ftbl_create(pd->sp, &ft, size);            if(sp_gen_file(pd->sp, ft, filename) == SP_NOT_OK) {                fprintf(stderr, "There was an issue creating the ftable /"%s/"./n", str);                stack->error++;                return PLUMBER_NOTOK;            }            plumber_ftmap_add(pd, str, ft);            break;        case PLUMBER_INIT:            filename = sporth_stack_pop_string(stack);            size = (int)sporth_stack_pop_float(stack);            str = sporth_stack_pop_string(stack);            break;        case PLUMBER_COMPUTE:            sporth_stack_pop_float(stack);            break;        case PLUMBER_DESTROY:            break;        default:           printf("Error: Unknown mode!");           break;    }    return PLUMBER_OK;#else    return PLUMBER_NOTOK;#endif}

int sporth_tget(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    sporth_tbl_d *td;    char *ftname;    switch(pd->mode){        case PLUMBER_CREATE:            td = malloc(sizeof(sporth_tbl_d));            plumber_add_ugen(pd, SPORTH_TGET, td);            if(sporth_check_args(stack, "fs") != SPORTH_OK) {               fprintf(stderr,"Init: not enough arguments for tget/n");                return PLUMBER_NOTOK;            }            ftname = sporth_stack_pop_string(stack);            td->index = floor(sporth_stack_pop_float(stack));            if(plumber_ftmap_search(pd, ftname, &td->ft) == PLUMBER_NOTOK) {                fprintf(stderr, "tget: could not find table '%s'/n", ftname);                stack->error++;                return PLUMBER_NOTOK;            }            free(ftname);            sporth_stack_push_float(stack, 0.0);            break;        case PLUMBER_INIT:            td = pd->last->ud;            ftname = sporth_stack_pop_string(stack);            td->index = floor(sporth_stack_pop_float(stack));            free(ftname);            sporth_stack_push_float(stack, 0.0);            break;        case PLUMBER_COMPUTE:            td = pd->last->ud;            td->index = (unsigned int) floor(sporth_stack_pop_float(stack)) % td->ft->size;            sporth_stack_push_float(stack, td->ft->tbl[td->index]);            break;        case PLUMBER_DESTROY:            td = pd->last->ud;            free(td);            break;        default:            fprintf(stderr,"Error: Unknown mode!");            break;    }    return PLUMBER_OK;}

int sporth_talias(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    char *ftname;    char *varname;    uint32_t index;    SPFLOAT *var;    sp_ftbl *ft;    switch(pd->mode){        case PLUMBER_CREATE:            plumber_add_ugen(pd, SPORTH_TALIAS, NULL);            if(sporth_check_args(stack, "sfs") != SPORTH_OK) {               plumber_print(pd,"Init: incorrect arguments for talias/n");                return PLUMBER_NOTOK;            }            ftname = sporth_stack_pop_string(stack);            index = sporth_stack_pop_float(stack);            varname = sporth_stack_pop_string(stack);            if(plumber_ftmap_search(pd, ftname, &ft) == PLUMBER_NOTOK) {                plumber_print(pd, "talias: could not find table '%s'/n", ftname);                stack->error++;                return PLUMBER_NOTOK;            }                       var = &ft->tbl[index];            plumber_ftmap_delete(pd, 0);            plumber_ftmap_add_userdata(pd, varname, var);            plumber_ftmap_delete(pd, 1);            break;        case PLUMBER_INIT:            ftname = sporth_stack_pop_string(stack);            index = sporth_stack_pop_float(stack);            varname = sporth_stack_pop_string(stack);            break;        case PLUMBER_COMPUTE:            sporth_stack_pop_float(stack);            break;        case PLUMBER_DESTROY:            break;    }    return PLUMBER_OK;}

int sporth_p(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    int n;    switch(pd->mode) {        case PLUMBER_CREATE:#ifdef DEBUG_MODE            fprintf(stderr, "p: creating/n");#endif            plumber_add_ugen(pd, SPORTH_P, NULL);            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr,"Not enough arguments for P/n");                stack->error++;                return PLUMBER_NOTOK;            }            n = (int)sporth_stack_pop_float(stack);            if(n < 16)                sporth_stack_push_float(stack, pd->p[n]);            else                sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:            n = (int)sporth_stack_pop_float(stack);            if(n < 16)                sporth_stack_push_float(stack, pd->p[n]);            else                sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            n = (int)sporth_stack_pop_float(stack);            if(n < 16)                sporth_stack_push_float(stack, pd->p[n]);            else                sporth_stack_push_float(stack, 0);            break;        case PLUMBER_DESTROY:            break;        default:            fprintf(stderr, "switch: unknown mode!/n");            break;    }    return PLUMBER_OK;}

int sporth_set(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    char *ftname;    SPFLOAT **var;    SPFLOAT val;    switch(pd->mode){        case PLUMBER_CREATE:            var = malloc(sizeof(SPFLOAT *));            plumber_add_ugen(pd, SPORTH_SET, var);            if(sporth_check_args(stack, "fs") != SPORTH_OK) {               fprintf(stderr,"Not enough arguments for get/n");                return PLUMBER_NOTOK;            }            ftname = sporth_stack_pop_string(stack);            val = sporth_stack_pop_float(stack);            if(plumber_ftmap_search_userdata(pd, ftname, (void **)var) == PLUMBER_NOTOK) {                fprintf(stderr, "set: could not find table '%s'/n", ftname);                stack->error++;                return PLUMBER_NOTOK;            }            **var = val;            break;        case PLUMBER_INIT:            var = pd->last->ud;            sporth_stack_pop_string(stack);            val = sporth_stack_pop_float(stack);            **var = val;            break;        case PLUMBER_COMPUTE:            var = pd->last->ud;            val = sporth_stack_pop_float(stack);            **var = val;            break;        case PLUMBER_DESTROY:            var = pd->last->ud;            free(var);            break;        default:            fprintf(stderr,"Error: Unknown mode!");            break;    }    return PLUMBER_OK;}

int sporth_noise(sporth_stack *stack, void *ud){    plumber_data *pd = ud;    SPFLOAT gain;    SPFLOAT out;    sp_noise *data;    switch(pd->mode){        case PLUMBER_CREATE:            sp_noise_create(&data);            plumber_add_module(pd, SPORTH_NOISE, sizeof(sp_noise), data);            break;        case PLUMBER_INIT:            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr, "Not enough arguments for noise/n");                stack->error++;                return PLUMBER_NOTOK;            }            data = pd->last->ud;            gain = sporth_stack_pop_float(stack);            if(sp_noise_init(pd->sp, data) == SP_NOT_OK) {                stack->error++;                return PLUMBER_NOTOK;            }            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            if(sporth_check_args(stack, "f") != SPORTH_OK) {                fprintf(stderr, "Not enough arguments for noise/n");                stack->error++;                return PLUMBER_NOTOK;            }            gain = sporth_stack_pop_float(stack);            data = pd->last->ud;            data->gain = gain;            sp_noise_compute(pd->sp, data, NULL, &out);            sporth_stack_push_float(stack, out);            break;        case PLUMBER_DESTROY:            data = pd->last->ud;            sp_noise_destroy(&data);            break;        default:           printf("Error: Unknown mode!");           break;    }    return PLUMBER_NOTOK;}

void process(sp_data *sp, void *ud){    plumber_data *pd = ud;    plumber_compute(pd, PLUMBER_COMPUTE);    SPFLOAT out;    sp->out[0] = sporth_stack_pop_float(&pd->sporth.stack);}

static void process(sp_data *sp, void *udp){    UserData *ud = udp;    plumber_data *pd = &ud->pd;    plumber_compute(pd, PLUMBER_COMPUTE);    sp->out[0] = sporth_stack_pop_float(&pd->sporth.stack);}

    void process(AUAudioFrameCount frameCount, AUAudioFrameCount bufferOffset) override {                if (!started) {            outBufferListPtr->mBuffers[0] = inBufferListPtr->mBuffers[0];            outBufferListPtr->mBuffers[1] = inBufferListPtr->mBuffers[1];            return;        }        for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) {            int frameOffset = int(frameIndex + bufferOffset);                        for (int channel = 0; channel < channels; ++channel) {                float *in  = (float *)inBufferListPtr->mBuffers[channel].mData  + frameOffset;                if (channel < 2) {                    pd.p[channel+14] = *in;                }            }                        for (int i = 0; i < 14; i++) {                pd.p[i] = parameters[i];            }                        plumber_compute(&pd, PLUMBER_COMPUTE);            for (int channel = 0; channel < channels; ++channel) {                float *out = (float *)outBufferListPtr->mBuffers[channel].mData + frameOffset;                *out = sporth_stack_pop_float(&pd.sporth.stack);            }                        for (int i = 0; i < 14; i++) {                parameters[i] = pd.p[i];            }        }    }

static void process(sp_data *sp, void *udata){    UserData *ud = udata;    plumber_data *pd = &ud->pd;    int rc;    if(ud->counter == 0) {        struct stat attrib;        stat(pd->filename, &attrib);        if(attrib.st_mtime != ud->ltime) {            plumber_recompile(pd);            ud->ltime = attrib.st_mtime;        }    }    rc = plumber_compute(pd, PLUMBER_COMPUTE);    SPFLOAT out = 0;    int chan;    for (chan = 0; chan < pd->nchan; chan++) {        if(rc == PLUMBER_OK) {            out = sporth_stack_pop_float(&pd->sporth.stack);        }        sp->out[chan] = out;    }    ud->counter++;    ud->counter %= 4096;}

    void process(AUAudioFrameCount frameCount, AUAudioFrameCount bufferOffset) override {        // For each sample.        for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) {            int frameOffset = int(frameIndex + bufferOffset);                        pd.p[0] = internalTrigger;            pd.p[1] = internalTrigger;            for (int i = 0; i < 10; i++) {                pd.p[i+2] = parameters[i];            }            if (started) {                plumber_compute(&pd, PLUMBER_COMPUTE);            }            for (int channel = 0; channel < channels; ++channel) {                float *out = (float *)outBufferListPtr->mBuffers[channel].mData + frameOffset;                if (started) {                    *out = sporth_stack_pop_float(&pd.sporth.stack);                } else {                    *out = 0;                }            }        }        if (internalTrigger == 1) {            internalTrigger = 0;        }    }

int sporth_metro(sporth_stack *stack, void *ud){    DSP_data *data;    int i;    jwjw_data *pd = (jwjw_data *) ud;        switch(pd->mode){        case PLUMBER_CREATE:            fdsp_create(pd, &data);            jwjw_add_ugen(pd, SPORTH_METRO, data);            for(i = 0; i < data->nargs; i++) {                *data->argtbl[i] = (FAUSTFLOAT) sporth_stack_pop_float(stack);            }            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_INIT:            data = (DSP_data *) pd->last->ud;            for(i = 0; i < data->nargs; i++) {                *data->argtbl[i] = (FAUSTFLOAT) sporth_stack_pop_float(stack);            }            sporth_stack_push_float(stack, 0);            break;        case PLUMBER_COMPUTE:            data = (DSP_data *) pd->last->ud;            for(i = 0; i < data->noutputs; i++) {                data->out_tbl[i] = &pd->reg[i];            }            for(i = data->nargs; i > 0; i--) {                *data->argtbl[i - 1] = (FAUSTFLOAT) sporth_stack_pop_float(stack);            }            data->s->compute(1, data->in_tbl, data->out_tbl);            sporth_stack_push_float(stack, (JWFLOAT)*data->out_tbl[0]);            break;        case PLUMBER_DESTROY:            data = (DSP_data *) pd->last->ud;            fdsp_destroy(&data);            break;        default:            fprintf(stderr,"Error: Unknown mode!");            break;    }    return PLUMBER_OK;}