← Back to branch summary

~ubuntu-branches/ubuntu/natty/pd-zexy/natty

« back to all changes in this revision

Viewing changes to src/list2symbol.c

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard, IOhannes m zmölnig, Jonas Smedegaard
  • Date: 2010-08-20 12:17:41 UTC
  • mfrom: (2.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100820121741-4kxozn8b9rhee9fr
Tags: 2.2.3-1
http://bugs.debian.org/546964
http://bugs.debian.org/437763
* New upstream version

[ IOhannes m zmölnig ]
* Adopt package, on behalf of Multimedia Team.
  Closes: #546964
* Simply debian/rules with CDBS, and don't unconditionally strip
  binaries.
  Closes: #437763
* Install into /usr/lib/pd/extra/zexy/. Document usage in REAME.Debian
  and warn about change in NEWS.
* git'ify package. Add Vcs-* stanzas to control file.
* Use dpkg source format 3.0 (quilt). Drop build-dependency on quilt.

[ Jonas Smedegaard ]
* Enable CDBS copyright-check routine.
* Add copyright and licensing header to debian/rules.
* Add myself as uploader.
* Rewrite debian/copyright using rev. 135 of draft DEP5 format.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/list2symbol.c
 
1
/******************************************************
 
2
 *
 
3
 * zexy - implementation file
 
4
 *
 
5
 * copyleft (c) IOhannes m zm�lnig
 
6
 *
 
7
 *   1999:forum::f�r::uml�ute:2004
 
8
 *
 
9
 *   institute of electronic music and acoustics (iem)
 
10
 *
 
11
 ******************************************************
 
12
 *
 
13
 * license: GNU General Public License v.2
 
14
 *
 
15
 ******************************************************/
 
16
 
 
17
#include "zexy.h"
 
18
#include <string.h>
 
19
 
 
20
/*
 
21
 * list2symbol: convert a list into a single symbol
 
22
*/
 
23
 
 
24
/* ------------------------- list2symbol ------------------------------- */
 
25
 
 
26
static t_class *list2symbol_class;
 
27
 
 
28
typedef struct _list2symbol
 
29
{
 
30
  t_object x_obj;
 
31
  int       ac;
 
32
  t_atom   *ap;
 
33
  t_symbol *s,*connector;
 
34
  t_inlet *x_inlet2;
 
35
  t_outlet*x_outlet;
 
36
} t_list2symbol;
 
37
 
 
38
static void list2symbol_connector(t_list2symbol *x, t_symbol *s){
 
39
  x->connector = s;
 
40
}
 
41
 
 
42
static void list2symbol_bang(t_list2symbol *x)
 
43
{
 
44
  t_atom *argv=x->ap;
 
45
  int     argc=x->ac;
 
46
  char *result = 0;
 
47
  int length = 0, len=0;
 
48
  int i= argc;
 
49
  char *connector=0;
 
50
  char connlen=0;
 
51
  char*buffer = (char*)getbytes(MAXPDSTRING*sizeof(char));
 
52
  if(x->connector){
 
53
    connector=x->connector->s_name;
 
54
    connlen=strlen(connector);
 
55
  }
 
56
      
 
57
  /* 1st get the length of the symbol */
 
58
  if(x->s)length+=strlen(x->s->s_name);
 
59
  else length-=connlen;
 
60
 
 
61
  length+=i*connlen;
 
62
 
 
63
  while(i--){
 
64
    int len2=0;
 
65
    if(A_SYMBOL==argv->a_type){
 
66
      len2=strlen(argv->a_w.w_symbol->s_name);
 
67
    } else {
 
68
      atom_string(argv, buffer, MAXPDSTRING);
 
69
      len2=strlen(buffer);
 
70
    }
 
71
    length+=len2;
 
72
    argv++;
 
73
  }
 
74
 
 
75
  if (length<=0){
 
76
    outlet_symbol(x->x_obj.ob_outlet, gensym(""));
 
77
    return;
 
78
  }
 
79
 
 
80
  result = (char*)getbytes((length+1)*sizeof(char));
 
81
 
 
82
  /* 2nd create the symbol */
 
83
  if (x->s){
 
84
    char *buf = x->s->s_name;
 
85
    int buflen=strlen(buf);
 
86
    strncpy(result+len, buf, length-len);
 
87
    len+=buflen;
 
88
    if(i && connector){
 
89
      strncpy(result+len, connector, length-len);
 
90
      len += connlen;
 
91
    }
 
92
  }
 
93
  i=argc;
 
94
  argv=x->ap;
 
95
  while(i--){
 
96
    if(A_SYMBOL==argv->a_type){
 
97
      strncpy(result+len, argv->a_w.w_symbol->s_name, length-len);
 
98
      len+= strlen(argv->a_w.w_symbol->s_name);
 
99
    } else {
 
100
      atom_string(argv, buffer, MAXPDSTRING);
 
101
      strncpy(result+len, buffer, length-len);
 
102
      len += strlen(buffer);
 
103
    }
 
104
    argv++;
 
105
    if(i && connector){
 
106
      strncpy(result+len, connector, length-len);
 
107
      len += connlen;
 
108
    }
 
109
  }
 
110
  freebytes(buffer, MAXPDSTRING*sizeof(char));
 
111
 
 
112
  result[length]=0;
 
113
  outlet_symbol(x->x_obj.ob_outlet, gensym(result));
 
114
  freebytes(result, (length+1)*sizeof(char));
 
115
}
 
116
 
 
117
static void list2symbol_anything(t_list2symbol *x, t_symbol *s, int argc, t_atom *argv)
 
118
{
 
119
  if(x->ap){
 
120
    freebytes(x->ap, x->ac*sizeof(t_atom));
 
121
    x->ap=0;
 
122
  }
 
123
 
 
124
  x->s =s;
 
125
  x->ac=argc;
 
126
 
 
127
  if(x->ac){
 
128
    x->ap=(t_atom*)getbytes(x->ac*sizeof(t_atom));
 
129
  }
 
130
  if(x->ap){
 
131
    t_atom*ap=x->ap;
 
132
    while(argc--){
 
133
      *ap++=*argv++;
 
134
    }
 
135
  }
 
136
  list2symbol_bang(x);
 
137
}
 
138
 
 
139
static void list2symbol_list(t_list2symbol *x, t_symbol *s, int argc, t_atom *argv)
 
140
{
 
141
  list2symbol_anything(x, 0, argc, argv);
 
142
}
 
143
static void *list2symbol_new(t_symbol *s, int argc, t_atom *argv)
 
144
{
 
145
  t_list2symbol *x = (t_list2symbol *)pd_new(list2symbol_class);
 
146
 
 
147
  x->x_outlet=outlet_new(&x->x_obj, 0);
 
148
  x->x_inlet2=inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("symbol"), gensym(""));
 
149
 
 
150
#if 0
 
151
  /* old behaviour: the argument list is used as the list-to-be-converted */
 
152
  x->connector = gensym(" ");
 
153
  list2symbol_anything(x, 0, argc, argv);
 
154
#else
 
155
  /* new behaviour: set the delimiter with the argument */
 
156
  list2symbol_connector(x, (argc)?atom_getsymbol(argv):gensym(" "));
 
157
#endif
 
158
   
 
159
 
 
160
  return (x);
 
161
}
 
162
 
 
163
static void list2symbol_free(t_list2symbol *x)
 
164
{
 
165
  if(x->ap){
 
166
    freebytes(x->ap, x->ac*sizeof(t_atom));
 
167
    x->ap=0;
 
168
  }
 
169
  outlet_free(x->x_outlet);
 
170
  inlet_free(x->x_inlet2);
 
171
}
 
172
 
 
173
 
 
174
void list2symbol_setup(void)
 
175
{
 
176
  list2symbol_class = class_new(gensym("list2symbol"), (t_newmethod)list2symbol_new, 
 
177
                                (t_method)list2symbol_free, sizeof(t_list2symbol), 0,
 
178
                                A_GIMME, 0);
 
179
 
 
180
  class_addcreator((t_newmethod)list2symbol_new, gensym("l2s"), A_GIMME, 0);
 
181
  class_addbang    (list2symbol_class, list2symbol_bang);
 
182
  class_addlist    (list2symbol_class, list2symbol_list);
 
183
  class_addanything(list2symbol_class, list2symbol_anything);
 
184
  class_addmethod  (list2symbol_class, (t_method)list2symbol_connector, gensym(""), A_SYMBOL, 0);
 
185
 
 
186
  zexy_register("list2symbol");
 
187
}
 
188
void l2s_setup(void)
 
189
{
 
190
  list2symbol_setup();
 
191
}