pure-data/src/x_connective.c

/* Copyright (c) 1997-1999 Miller Puckette.
* For information on usage and redistribution, and for a DISCLAIMER OF ALL
* WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */

/* connective objects */

#include "m_pd.h"

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef _WIN32
# include <malloc.h> /* MSVC or mingw on windows */
#elif defined(__linux__) || defined(__APPLE__) || defined(HAVE_ALLOCA_H)
# include <alloca.h> /* linux, mac, mingw, cygwin */
#endif

/* -------------------------- int ------------------------------ */
static t_class *pdint_class;

t_pdint;

static void *pdint_new(t_floatarg f)
{ … }

static void pdint_bang(t_pdint *x)
{ … }

static void pdint_float(t_pdint *x, t_float f)
{ … }

static void pdint_send(t_pdint *x, t_symbol *s)
{ … }

void pdint_setup(void)
{ … }

/* -------------------------- float ------------------------------ */
static t_class *pdfloat_class;

t_pdfloat;

    /* "float," "symbol," and "bang" are special because
    they're created by short-circuited messages to the "new"
    object which are handled specially in pd_typedmess(). */

void *pdfloat_new(t_pd *dummy, t_float f)
{ … }

static void *pdfloat_new2(t_floatarg f)
{ … }

static void pdfloat_bang(t_pdfloat *x)
{ … }

static void pdfloat_float(t_pdfloat *x, t_float f)
{ … }


static void pdfloat_symbol(t_pdfloat *x, t_symbol *s)
{ … }

static void pdfloat_send(t_pdfloat *x, t_symbol *s)
{ … }

void pdfloat_setup(void)
{ … }

/* -------------------------- symbol ------------------------------ */
static t_class *pdsymbol_class;

t_pdsymbol;

void *pdsymbol_new(t_pd *dummy, t_symbol *s)
{ … }

static void pdsymbol_bang(t_pdsymbol *x)
{ … }

static void pdsymbol_symbol(t_pdsymbol *x, t_symbol *s)
{ … }

static void pdsymbol_anything(t_pdsymbol *x, t_symbol *s, int ac, t_atom *av)
{ … }

    /* For "list" message don't just output "list"; if empty, we want to
    bang the symbol and if it starts with a symbol, we output that.
    Otherwise it's not clear what we should do so we just go for the
    "anything" method.  LATER figure out if there are other places where
    empty lists aren't equivalent to "bang"???  Should Pd's message passer
    always check and call the more specific method, or should it be the
    object's responsibility?  Dunno... */
static void pdsymbol_list(t_pdsymbol *x, t_symbol *s, int ac, t_atom *av)
{ … }

void pdsymbol_setup(void)
{ … }

/* -------------------------- bang ------------------------------ */
static t_class *bang_class;

t_bang;

void *bang_new(t_pd *dummy)
{ … }

static void *bang_new2(void)
{ … }

static void bang_bang(t_bang *x)
{ … }

static void bang_float(t_bang *x, t_float dummy)
{ … }

static void bang_symbol(t_bang *x, t_symbol *dummy)
{ … }

static void bang_gimme(t_bang *x, t_symbol *s, int argc, t_atom *argv)
{ … }

void bang_setup(void)
{ … }

/* -------------------- send ------------------------------ */

static t_class *send_class;

t_send;

static void send_bang(t_send *x)
{ … }

static void send_float(t_send *x, t_float f)
{ … }

static void send_symbol(t_send *x, t_symbol *s)
{ … }

static void send_pointer(t_send *x, t_gpointer *gp)
{ … }

static void send_list(t_send *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void send_anything(t_send *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void *send_new(t_symbol *s)
{ … }

static void send_setup(void)
{ … }
/* -------------------- receive ------------------------------ */

static t_class *receive_class;

t_receive;

static void receive_bang(t_receive *x)
{ … }

static void receive_float(t_receive *x, t_float f)
{ … }

static void receive_symbol(t_receive *x, t_symbol *s)
{ … }

static void receive_pointer(t_receive *x, t_gpointer *gp)
{ … }

static void receive_list(t_receive *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void receive_anything(t_receive *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void *receive_new(t_symbol *s)
{ … }

static void receive_free(t_receive *x)
{ … }

static void receive_setup(void)
{ … }

/* -------------------------- select ------------------------------ */

static t_class *sel1_class;

t_sel1;

static void sel1_float(t_sel1 *x, t_float f)
{ … }

static void sel1_symbol(t_sel1 *x, t_symbol *s)
{ … }

static t_class *sel2_class;

t_selectelement;

t_sel2;

static void sel2_float(t_sel2 *x, t_float f)
{ … }

static void sel2_symbol(t_sel2 *x, t_symbol *s)
{ … }

static void sel2_free(t_sel2 *x)
{ … }

static void *select_new(t_symbol *s, int argc, t_atom *argv)
{ … }

void select_setup(void)
{ … }

/* -------------------------- route ------------------------------ */

static t_class *route_class;

t_routeelement;

t_route;

static void route_anything(t_route *x, t_symbol *sel, int argc, t_atom *argv)
{ … }

static void route_list(t_route *x, t_symbol *sel, int argc, t_atom *argv)
{ … }


static void route_free(t_route *x)
{ … }

static void *route_new(t_symbol *s, int argc, t_atom *argv)
{ … }

void route_setup(void)
{ … }

/* -------------------------- pack ------------------------------ */

static t_class *pack_class;

t_pack;

static void *pack_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static void pack_bang(t_pack *x)
{ … }

static void pack_pointer(t_pack *x, t_gpointer *gp)
{ … }

static void pack_float(t_pack *x, t_float f)
{ … }

static void pack_symbol(t_pack *x, t_symbol *s)
{ … }

    /* without a list method, pack_anything() would be called */
static void pack_list(t_pack *x, t_symbol *s, int ac, t_atom *av)
{ … }

static void pack_anything(t_pack *x, t_symbol *s, int ac, t_atom *av)
{ … }

static void pack_free(t_pack *x)
{ … }

static void pack_setup(void)
{ … }

/* -------------------------- unpack ------------------------------ */

static t_class *unpack_class;

t_unpackout;

t_unpack;

static void *unpack_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static void unpack_list(t_unpack *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void unpack_anything(t_unpack *x, t_symbol *s, int ac, t_atom *av)
{ … }

static void unpack_free(t_unpack *x)
{ … }

static void unpack_setup(void)
{ … }

/* -------------------------- trigger ------------------------------ */

static t_class *trigger_class;
#define TR_BANG …
#define TR_FLOAT …
#define TR_SYMBOL …
#define TR_POINTER …
#define TR_LIST …
#define TR_ANYTHING …

t_triggerout;

t_trigger;

static void *trigger_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static void trigger_list(t_trigger *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void trigger_anything(t_trigger *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void trigger_bang(t_trigger *x)
{ … }

static void trigger_pointer(t_trigger *x, t_gpointer *gp)
{ … }

static void trigger_float(t_trigger *x, t_float f)
{ … }

static void trigger_symbol(t_trigger *x, t_symbol *s)
{ … }

static void trigger_free(t_trigger *x)
{ … }

static void trigger_setup(void)
{ … }

/* -------------------------- spigot ------------------------------ */
static t_class *spigot_class;

t_spigot;

static void *spigot_new(t_floatarg f)
{ … }

static void spigot_bang(t_spigot *x)
{ … }

static void spigot_pointer(t_spigot *x, t_gpointer *gp)
{ … }

static void spigot_float(t_spigot *x, t_float f)
{ … }

static void spigot_symbol(t_spigot *x, t_symbol *s)
{ … }

static void spigot_list(t_spigot *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void spigot_anything(t_spigot *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void spigot_setup(void)
{ … }

/* --------------------------- moses ----------------------------- */
static t_class *moses_class;

t_moses;

static void *moses_new(t_floatarg f)
{ … }

static void moses_float(t_moses *x, t_float f)
{ … }

static void moses_setup(void)
{ … }

/* ----------------------- until --------------------- */

static t_class *until_class;

t_until;

static void *until_new(void)
{ … }

static void until_bang(t_until *x)
{ … }

static void until_float(t_until *x, t_float f)
{ … }

static void until_bang2(t_until *x)
{ … }

static void until_setup(void)
{ … }

/* ----------------------- makefilename --------------------- */

static t_class *makefilename_class;

t_printtype;

t_makefilename;

static const char* _formatscan(const char*str, t_printtype*typ) { … }

static void makefilename_scanformat(t_makefilename *x)
{ … }

static void *makefilename_new(t_symbol *s)
{ … }

static void makefilename_float(t_makefilename *x, t_floatarg f)
{ … }

static void makefilename_symbol(t_makefilename *x, t_symbol *s)
{ … }

static void makefilename_bang(t_makefilename *x)
{ … }

static void makefilename_set(t_makefilename *x, t_symbol *s)
{ … }

static void makefilename_setup(void)
{ … }

/* -------------------------- swap ------------------------------ */
static t_class *swap_class;

t_swap;

static void *swap_new(t_floatarg f)
{ … }

static void swap_bang(t_swap *x)
{ … }

static void swap_float(t_swap *x, t_float f)
{ … }

void swap_setup(void)
{ … }

/* -------------------------- change ------------------------------ */
static t_class *change_class;

t_change;

static void *change_new(t_floatarg f)
{ … }

static void change_bang(t_change *x)
{ … }

static void change_float(t_change *x, t_float f)
{ … }

static void change_set(t_change *x, t_float f)
{ … }

void change_setup(void)
{ … }

/* -------------------- value ------------------------------ */

static t_class *value_class, *vcommon_class;

t_vcommon;

t_value;

    /* get a pointer to a named floating-point variable.  The variable
    belongs to a "vcommon" object, which is created if necessary. */
t_float *value_get(t_symbol *s)
{ … }

    /* release a variable.  This only frees the "vcommon" resource when the
    last interested party releases it. */
void value_release(t_symbol *s)
{ … }

/*
 * value_getfloat -- obtain the float value of a "value" object
 *                  return 0 on success, 1 otherwise
 */
int value_getfloat(t_symbol *s, t_float *f)
{ … }

/*
 * value_setfloat -- set the float value of a "value" object
 *                  return 0 on success, 1 otherwise
 */
int value_setfloat(t_symbol *s, t_float f)
{ … }

static void vcommon_float(t_vcommon *x, t_float f)
{ … }

static void *value_new(t_symbol *s)
{ … }

static void value_bang(t_value *x)
{ … }

static void value_float(t_value *x, t_float f)
{ … }

/* set method */
static void value_symbol2(t_value *x, t_symbol *s)
{ … }

static void value_send(t_value *x, t_symbol *s)
{ … }

static void value_ff(t_value *x)
{ … }

static void value_setup(void)
{ … }

/* -------------- overall setup routine for this file ----------------- */

void x_connective_setup(void)
{ … }