checking in version 0.38test5.

Oops, I realize I forgot some more nice files, will add them and re-commit.

svn path=/trunk/; revision=2010

1 files changed, 66 insertions, 62 deletions

diff --git a/pd/src/x_arithmetic.c b/pd/src/x_arithmetic.c
index b7a94a2d..095e2c7d 100644
--- a/pd/src/x_arithmetic.c
+++ b/pd/src/x_arithmetic.c
@@ -111,14 +111,14 @@ static void *binop1_div_new(t_floatarg f)
 static void binop1_div_bang(t_binop *x)
 {
     outlet_float(x->x_obj.ob_outlet,
-    	(x->x_f2 != 0 ? x->x_f1 / x->x_f2 : 0));
+        (x->x_f2 != 0 ? x->x_f1 / x->x_f2 : 0));
 }
 
 static void binop1_div_float(t_binop *x, t_float f)
 {
     x->x_f1 = f;
     outlet_float(x->x_obj.ob_outlet,
-    	(x->x_f2 != 0 ? x->x_f1 / x->x_f2 : 0));
+        (x->x_f2 != 0 ? x->x_f1 / x->x_f2 : 0));
 }
 
 /* ------------------------ pow -------------------------------- */
@@ -133,14 +133,14 @@ static void *binop1_pow_new(t_floatarg f)
 static void binop1_pow_bang(t_binop *x)
 {
     outlet_float(x->x_obj.ob_outlet,
-    	(x->x_f1 > 0 ? powf(x->x_f1, x->x_f2) : 0));
+        (x->x_f1 > 0 ? powf(x->x_f1, x->x_f2) : 0));
 }
 
 static void binop1_pow_float(t_binop *x, t_float f)
 {
     x->x_f1 = f;
     outlet_float(x->x_obj.ob_outlet,
-    	(x->x_f1 > 0 ? powf(x->x_f1, x->x_f2) : 0));
+        (x->x_f1 > 0 ? powf(x->x_f1, x->x_f2) : 0));
 }
 
 /* ------------------------ max -------------------------------- */
@@ -155,14 +155,14 @@ static void *binop1_max_new(t_floatarg f)
 static void binop1_max_bang(t_binop *x)
 {
     outlet_float(x->x_obj.ob_outlet,
-    	(x->x_f1 > x->x_f2 ? x->x_f1 : x->x_f2));
+        (x->x_f1 > x->x_f2 ? x->x_f1 : x->x_f2));
 }
 
 static void binop1_max_float(t_binop *x, t_float f)
 {
     x->x_f1 = f;
     outlet_float(x->x_obj.ob_outlet,
-    	(x->x_f1 > x->x_f2 ? x->x_f1 : x->x_f2));
+        (x->x_f1 > x->x_f2 ? x->x_f1 : x->x_f2));
 }
 
 /* ------------------------ min -------------------------------- */
@@ -177,14 +177,14 @@ static void *binop1_min_new(t_floatarg f)
 static void binop1_min_bang(t_binop *x)
 {
     outlet_float(x->x_obj.ob_outlet,
-    	(x->x_f1 < x->x_f2 ? x->x_f1 : x->x_f2));
+        (x->x_f1 < x->x_f2 ? x->x_f1 : x->x_f2));
 }
 
 static void binop1_min_float(t_binop *x, t_float f)
 {
     x->x_f1 = f;
     outlet_float(x->x_obj.ob_outlet,
-    	(x->x_f1 < x->x_f2 ? x->x_f1 : x->x_f2));
+        (x->x_f1 < x->x_f2 ? x->x_f1 : x->x_f2));
 }
 
 /* ------------------ binop2: ==, !=, >, <, >=, <=. -------------------- */
@@ -512,7 +512,7 @@ static void binop3_div_float(t_binop *x, t_float f)
 
 /* -------------------- mathematical functions ------------------ */
 
-static t_class *sin_class;   	/* ----------- sin --------------- */
+static t_class *sin_class;      /* ----------- sin --------------- */
 
 static void *sin_new(void)
 {
@@ -526,7 +526,7 @@ static void sin_float(t_object *x, t_float f)
     outlet_float(x->ob_outlet, sinf(f));
 }
 
-static t_class *cos_class;   	/* ----------- cos --------------- */
+static t_class *cos_class;      /* ----------- cos --------------- */
 
 static void *cos_new(void)
 {
@@ -540,7 +540,7 @@ static void cos_float(t_object *x, t_float f)
     outlet_float(x->ob_outlet, cosf(f));
 }
 
-static t_class *tan_class;   	/* ----------- tan --------------- */
+static t_class *tan_class;      /* ----------- tan --------------- */
 
 static void *tan_new(void)
 {
@@ -556,7 +556,7 @@ static void tan_float(t_object *x, t_float f)
     outlet_float(x->ob_outlet, t);
 }
 
-static t_class *atan_class;   	/* ----------- atan --------------- */
+static t_class *atan_class;     /* ----------- atan --------------- */
 
 static void *atan_new(void)
 {
@@ -570,29 +570,33 @@ static void atan_float(t_object *x, t_float f)
     outlet_float(x->ob_outlet, atanf(f));
 }
 
-static t_class *atan2_class;   	/* ----------- atan2 --------------- */
+static t_class *atan2_class;    /* ----------- atan2 --------------- */
 
 typedef struct _atan2
 {
     t_object x_ob;
-    float x_y;
+    float x_f;
 } t_atan2;
 
 static void *atan2_new(void)
 {
     t_atan2 *x = (t_atan2 *)pd_new(atan2_class);
-    floatinlet_new(&x->x_ob, &x->x_y);
+    static int warned;
+    if (!warned)
+        post("warning: atan2 inlets switched from Pd 0.37 to 0.38"), warned=1;
+    floatinlet_new(&x->x_ob, &x->x_f);
+    x->x_f = 0;
     outlet_new(&x->x_ob, &s_float);
     return (x);
 }
 
 static void atan2_float(t_atan2 *x, t_float f)
 {
-    float r = (f == 0 && x->x_y == 0 ? 0 : atan2f(x->x_y, f));
+    float r = (f == 0 && x->x_f == 0 ? 0 : atan2f(f, x->x_f));
     outlet_float(x->x_ob.ob_outlet, r);
 }
 
-static t_class *sqrt_class;   	/* ----------- sqrt --------------- */
+static t_class *sqrt_class;     /* ----------- sqrt --------------- */
 
 static void *sqrt_new(void)
 {
@@ -607,7 +611,7 @@ static void sqrt_float(t_object *x, t_float f)
     outlet_float(x->ob_outlet, r);
 }
 
-static t_class *log_class;   	/* ----------- log --------------- */
+static t_class *log_class;      /* ----------- log --------------- */
 
 static void *log_new(void)
 {
@@ -623,7 +627,7 @@ static void log_float(t_object *x, t_float f)
 }
 
 
-static t_class *exp_class;   	/* ----------- exp --------------- */
+static t_class *exp_class;      /* ----------- exp --------------- */
 
 static void *exp_new(void)
 {
@@ -644,7 +648,7 @@ static void exp_float(t_object *x, t_float f)
     outlet_float(x->ob_outlet, g);
 }
 
-static t_class *abs_class;   	/* ----------- abs --------------- */
+static t_class *abs_class;      /* ----------- abs --------------- */
 
 static void *abs_new(void)
 {
@@ -683,13 +687,13 @@ static void *clip_new(t_floatarg f1, t_floatarg f2)
 static void clip_float(t_clip *x, t_float f)
 {
     outlet_float(x->x_ob.ob_outlet, (f < x->x_f1 ? x->x_f1 : (
-    	f > x->x_f2 ? x->x_f2 : f)));
+        f > x->x_f2 ? x->x_f2 : f)));
 }
 
 static void clip_setup(void)
 {
     clip_class = class_new(gensym("clip"), (t_newmethod)clip_new, 0,
-    	sizeof(t_clip), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
+        sizeof(t_clip), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
     class_addfloat(clip_class, clip_float);
 }
 
@@ -700,191 +704,191 @@ void x_arithmetic_setup(void)
     t_symbol *math_sym = gensym("math");
 
     binop1_plus_class = class_new(gensym("+"), (t_newmethod)binop1_plus_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop1_plus_class, binop1_plus_bang);
     class_addfloat(binop1_plus_class, (t_method)binop1_plus_float);
     class_sethelpsymbol(binop1_plus_class, binop1_sym);
     
     binop1_minus_class = class_new(gensym("-"),
-    	(t_newmethod)binop1_minus_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        (t_newmethod)binop1_minus_new, 0,
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop1_minus_class, binop1_minus_bang);
     class_addfloat(binop1_minus_class, (t_method)binop1_minus_float);
     class_sethelpsymbol(binop1_minus_class, binop1_sym);
 
     binop1_times_class = class_new(gensym("*"),
-    	(t_newmethod)binop1_times_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        (t_newmethod)binop1_times_new, 0,
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop1_times_class, binop1_times_bang);
     class_addfloat(binop1_times_class, (t_method)binop1_times_float);
     class_sethelpsymbol(binop1_times_class, binop1_sym);
 
     binop1_div_class = class_new(gensym("/"),
-    	(t_newmethod)binop1_div_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        (t_newmethod)binop1_div_new, 0,
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop1_div_class, binop1_div_bang);
     class_addfloat(binop1_div_class, (t_method)binop1_div_float);
     class_sethelpsymbol(binop1_div_class, binop1_sym);
 
     binop1_pow_class = class_new(gensym("pow"),
-    	(t_newmethod)binop1_pow_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        (t_newmethod)binop1_pow_new, 0,
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop1_pow_class, binop1_pow_bang);
     class_addfloat(binop1_pow_class, (t_method)binop1_pow_float);
     class_sethelpsymbol(binop1_pow_class, binop1_sym);
 
     binop1_max_class = class_new(gensym("max"),
-    	(t_newmethod)binop1_max_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        (t_newmethod)binop1_max_new, 0,
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop1_max_class, binop1_max_bang);
     class_addfloat(binop1_max_class, (t_method)binop1_max_float);
     class_sethelpsymbol(binop1_max_class, binop1_sym);
 
     binop1_min_class = class_new(gensym("min"),
-    	(t_newmethod)binop1_min_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        (t_newmethod)binop1_min_new, 0,
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop1_min_class, binop1_min_bang);
     class_addfloat(binop1_min_class, (t_method)binop1_min_float);
     class_sethelpsymbol(binop1_min_class, binop1_sym);
 
-    	/* ------------------ binop2 ----------------------- */
+        /* ------------------ binop2 ----------------------- */
 
     binop2_ee_class = class_new(gensym("=="), (t_newmethod)binop2_ee_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop2_ee_class, binop2_ee_bang);
     class_addfloat(binop2_ee_class, (t_method)binop2_ee_float);
     class_sethelpsymbol(binop2_ee_class, binop23_sym);
 
     binop2_ne_class = class_new(gensym("!="), (t_newmethod)binop2_ne_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop2_ne_class, binop2_ne_bang);
     class_addfloat(binop2_ne_class, (t_method)binop2_ne_float);
     class_sethelpsymbol(binop2_ne_class, binop23_sym);
 
     binop2_gt_class = class_new(gensym(">"), (t_newmethod)binop2_gt_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop2_gt_class, binop2_gt_bang);
     class_addfloat(binop2_gt_class, (t_method)binop2_gt_float);
     class_sethelpsymbol(binop2_gt_class, binop23_sym);
 
     binop2_lt_class = class_new(gensym("<"), (t_newmethod)binop2_lt_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop2_lt_class, binop2_lt_bang);
     class_addfloat(binop2_lt_class, (t_method)binop2_lt_float);
     class_sethelpsymbol(binop2_lt_class, binop23_sym);
 
     binop2_ge_class = class_new(gensym(">="), (t_newmethod)binop2_ge_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop2_ge_class, binop2_ge_bang);
     class_addfloat(binop2_ge_class, (t_method)binop2_ge_float);
     class_sethelpsymbol(binop2_ge_class, binop23_sym);
 
     binop2_le_class = class_new(gensym("<="), (t_newmethod)binop2_le_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop2_le_class, binop2_le_bang);
     class_addfloat(binop2_le_class, (t_method)binop2_le_float);
     class_sethelpsymbol(binop2_le_class, binop23_sym);
 
-    	/* ------------------ binop3 ----------------------- */
+        /* ------------------ binop3 ----------------------- */
 
     binop3_ba_class = class_new(gensym("&"), (t_newmethod)binop3_ba_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_ba_class, binop2_ba_bang);
     class_addfloat(binop3_ba_class, (t_method)binop2_ba_float);
     class_sethelpsymbol(binop3_ba_class, binop23_sym);
 
     binop3_la_class = class_new(gensym("&&"), (t_newmethod)binop3_la_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_la_class, binop2_la_bang);
     class_addfloat(binop3_la_class, (t_method)binop2_la_float);
     class_sethelpsymbol(binop3_la_class, binop23_sym);
 
     binop3_bo_class = class_new(gensym("|"), (t_newmethod)binop3_bo_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_bo_class, binop2_bo_bang);
     class_addfloat(binop3_bo_class, (t_method)binop2_bo_float);
     class_sethelpsymbol(binop3_bo_class, binop23_sym);
 
     binop3_lo_class = class_new(gensym("||"), (t_newmethod)binop3_lo_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_lo_class, binop2_lo_bang);
     class_addfloat(binop3_lo_class, (t_method)binop2_lo_float);
     class_sethelpsymbol(binop3_lo_class, binop23_sym);
 
     binop3_ls_class = class_new(gensym("<<"), (t_newmethod)binop3_ls_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_ls_class, binop2_ls_bang);
     class_addfloat(binop3_ls_class, (t_method)binop2_ls_float);
     class_sethelpsymbol(binop3_ls_class, binop23_sym);
 
     binop3_rs_class = class_new(gensym(">>"), (t_newmethod)binop3_rs_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_rs_class, binop2_rs_bang);
     class_addfloat(binop3_rs_class, (t_method)binop2_rs_float);
     class_sethelpsymbol(binop3_rs_class, binop23_sym);
 
     binop3_pc_class = class_new(gensym("%"), (t_newmethod)binop3_pc_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_pc_class, binop2_pc_bang);
     class_addfloat(binop3_pc_class, (t_method)binop2_pc_float);
     class_sethelpsymbol(binop3_pc_class, binop23_sym);
 
     binop3_mod_class = class_new(gensym("mod"), (t_newmethod)binop3_mod_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_mod_class, binop3_mod_bang);
     class_addfloat(binop3_mod_class, (t_method)binop3_mod_float);
     class_sethelpsymbol(binop3_mod_class, binop23_sym);
 
     binop3_div_class = class_new(gensym("div"), (t_newmethod)binop3_div_new, 0,
-    	sizeof(t_binop), 0, A_DEFFLOAT, 0);
+        sizeof(t_binop), 0, A_DEFFLOAT, 0);
     class_addbang(binop3_div_class, binop3_div_bang);
     class_addfloat(binop3_div_class, (t_method)binop3_div_float);
     class_sethelpsymbol(binop3_div_class, binop23_sym);
 
-    	/* ------------------- math functions --------------- */
+        /* ------------------- math functions --------------- */
     
     sin_class = class_new(gensym("sin"), sin_new, 0,
-    	sizeof(t_object), 0, 0);
+        sizeof(t_object), 0, 0);
     class_addfloat(sin_class, (t_method)sin_float);
     class_sethelpsymbol(sin_class, math_sym);
     
     cos_class = class_new(gensym("cos"), cos_new, 0,
-    	sizeof(t_object), 0, 0);
+        sizeof(t_object), 0, 0);
     class_addfloat(cos_class, (t_method)cos_float);
     class_sethelpsymbol(cos_class, math_sym);
     
     tan_class = class_new(gensym("tan"), tan_new, 0,
-    	sizeof(t_object), 0, 0);
+        sizeof(t_object), 0, 0);
     class_addfloat(tan_class, (t_method)tan_float);
     class_sethelpsymbol(tan_class, math_sym);
 
     atan_class = class_new(gensym("atan"), atan_new, 0,
-    	sizeof(t_object), 0, 0);
+        sizeof(t_object), 0, 0);
     class_addfloat(atan_class, (t_method)atan_float);
     class_sethelpsymbol(atan_class, math_sym);
 
     atan2_class = class_new(gensym("atan2"), atan2_new, 0,
-    	sizeof(t_atan2), 0, 0);
+        sizeof(t_atan2), 0, 0);
     class_addfloat(atan2_class, (t_method)atan2_float);    
     class_sethelpsymbol(atan2_class, math_sym);
 
     sqrt_class = class_new(gensym("sqrt"), sqrt_new, 0,
-    	sizeof(t_object), 0, 0);
+        sizeof(t_object), 0, 0);
     class_addfloat(sqrt_class, (t_method)sqrt_float);
     class_sethelpsymbol(sqrt_class, math_sym);
 
     log_class = class_new(gensym("log"), log_new, 0,
-    	sizeof(t_object), 0, 0);
+        sizeof(t_object), 0, 0);
     class_addfloat(log_class, (t_method)log_float);    
     class_sethelpsymbol(log_class, math_sym);
 
     exp_class = class_new(gensym("exp"), exp_new, 0,
-    	sizeof(t_object), 0, 0);
+        sizeof(t_object), 0, 0);
     class_addfloat(exp_class, (t_method)exp_float);
     class_sethelpsymbol(exp_class, math_sym);
 
     abs_class = class_new(gensym("abs"), abs_new, 0,
-    	sizeof(t_object), 0, 0);
+        sizeof(t_object), 0, 0);
     class_addfloat(abs_class, (t_method)abs_float);    
     class_sethelpsymbol(abs_class, math_sym);