← Back to branch summary

~ubuntu-branches/ubuntu/vivid/sflphone/vivid

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/third_party/gsm/add-test/add_test.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2013-06-30 11:40:56 UTC
  • mfrom: (4.1.18 saucy-proposed)
  • Revision ID: package-import@ubuntu.com-20130630114056-0np50jkyqo6vnmii
Tags: 1.2.3-2
* changeset_r92d62cfc54732bbbcfff2b1d36c096b120b981a5.diff 
  - fixes automatic endian detection 
* Update Vcs: fixes vcs-field-not-canonical

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/third_party/gsm/add-test/add_test.c
 
1
/*
 
2
 * Copyright 1992 by Jutta Degener and Carsten Bormann, Technische
 
3
 * Universitaet Berlin.  See the accompanying file "COPYRIGHT" for
 
4
 * details.  THERE IS ABSOLUTELY NO WARRANTY FOR THIS SOFTWARE.
 
5
 */
 
6
 
 
7
/* $Header: /tmp_amd/presto/export/kbs/jutta/src/gsm/RCS/add_test.c,v 1.2 1994/05/10 20:18:17 jutta Exp $ */
 
8
 
 
9
#include <stdio.h>
 
10
#include <stdlib.h>
 
11
#include <string.h>
 
12
 
 
13
#include "gsm.h"
 
14
 
 
15
#include "../src/add.c"
 
16
 
 
17
int             interactive = 1;
 
18
 
 
19
char            * opname;
 
20
longword        L_op1, L_op2, L_expect;
 
21
word            op1, op2, expect;
 
22
int             do_expect;
 
23
 
 
24
word M_gsm_add P((word op1, word op2));
 
25
word M_gsm_sub P((word op1, word op2));
 
26
word M_gsm_mult P((word op1, word op2));
 
27
word M_gsm_mult_r P((word op1, word op2));
 
28
word M_gsm_abs P((word op1));
 
29
longword M_gsm_L_mult P((word op1, word op2));
 
30
longword M_gsm_L_add P((longword op1, longword op2));
 
31
 
 
32
help()
 
33
{
 
34
puts( "  add a b      sub a b     mult a b   div    a b" );
 
35
puts( "L_add A B    L_sub A B   L_mult A B   mult_r a b" );
 
36
puts( "" );
 
37
puts( "abs   a      norm  a        >> a b      << a b" );
 
38
puts( "                          L_>> A B    L_<< A B" );
 
39
 
 
40
}
 
41
 
 
42
char * strtek P2((str, sep), char * str, char * sep) {
 
43
 
 
44
        static char     * S = (char *)0;
 
45
        char            * c, * base;
 
46
 
 
47
        if (str) S = str;
 
48
 
 
49
        if (!S || !*S) return (char *)0;
 
50
 
 
51
        /*  Skip delimiters.
 
52
         */
 
53
        while (*S) {
 
54
                for (c = sep; *c && *c != *S; c++) ;
 
55
                if (*c) *S++ = 0;
 
56
                else break;
 
57
        }
 
58
 
 
59
        base = S;
 
60
 
 
61
        /*   Skip non-delimiters.
 
62
         */
 
63
        for (base = S; *S; S++) {
 
64
 
 
65
                for (c = sep; *c; c++)
 
66
                        if (*c == *S) {
 
67
                                *S++ = 0;
 
68
                                return base;
 
69
                        }
 
70
        }
 
71
 
 
72
        return base == S ? (char *)0 : base;
 
73
}
 
74
 
 
75
long value P1((s), char * s)
 
76
{
 
77
        switch (*s) {
 
78
        case '-': switch (s[1]) {
 
79
                  case '\0': return MIN_WORD;
 
80
                  case '-':  return MIN_LONGWORD;
 
81
                  default:   break;
 
82
                  }
 
83
                  break;
 
84
 
 
85
        case '+': switch (s[1]) {
 
86
                  case '\0': return MAX_WORD;
 
87
                  case '+':  return MAX_LONGWORD;
 
88
                  default:   break;
 
89
                  }
 
90
        default:  break;
 
91
        }
 
92
 
 
93
        return strtol(s, (char **)0, 0);
 
94
}
 
95
 
 
96
char * parse P1((buf), char * buf)
 
97
{
 
98
        char  * s, * a;
 
99
        long    l;
 
100
 
 
101
        if (a = strchr(buf, '=')) *a++ = 0;
 
102
 
 
103
        opname = s = strtek(buf, " \t(");
 
104
        if (!s) return (char *)0;
 
105
 
 
106
        op1 = op2 = L_op1 = L_op2 = 0;
 
107
 
 
108
        if (s = strtek( (char *)0, "( \t,")) {
 
109
                op1 = L_op1 = value(s);
 
110
                if (s = strtek( (char *)0, ", \t)")) op2 = L_op2 = value(s);
 
111
        }
 
112
 
 
113
        if (a) {
 
114
                do_expect = 1;
 
115
                while (*a == ' ' || *a == '\t') a++;
 
116
                expect = L_expect = value(a);
 
117
        }
 
118
 
 
119
        return opname;
 
120
}
 
121
 
 
122
void fprint_word P2((f, w), FILE * f,  word w)
 
123
{
 
124
        if (!w) putc('0', f);
 
125
        else fprintf(f, "0x%4.4x (%d%s)",
 
126
                (unsigned int)w,
 
127
                (int)w,
 
128
                w == MIN_WORD? "/-" : (w == MAX_WORD ? "/+" : ""));
 
129
}
 
130
 
 
131
void print_word P1((w), word w)
 
132
{
 
133
        fprint_word( stdout, w );
 
134
}
 
135
 
 
136
void fprint_longword P2((f, w), FILE * f, longword w)
 
137
{
 
138
        if (!w) putc('0', f);
 
139
        else fprintf(f, "0x%8.8x (%ld%s)",
 
140
                w, w, w == MIN_WORD ? "/-"
 
141
                : (w == MAX_WORD ? "/+"
 
142
                : (w == MIN_LONGWORD ? "/--"
 
143
                : (w == MAX_LONGWORD ? "/++" : ""))));
 
144
}
 
145
 
 
146
void print_longword P1((w),longword w)
 
147
{
 
148
        fprint_longword(stdout, w);
 
149
}
 
150
 
 
151
void do_longword P1((w), longword w)
 
152
{
 
153
        if (interactive) print_longword(w);
 
154
        if (do_expect) {
 
155
                if (w != L_expect) {
 
156
                        if (!interactive) fprint_longword(stderr, w);
 
157
                        fprintf(stderr, " != %s (%ld, %ld) -- expected ",
 
158
                                opname, L_op1, L_op2 );
 
159
                        fprint_longword(stderr, L_expect);
 
160
                        putc( '\n', stderr );
 
161
                }
 
162
        } else if (interactive) putchar('\n');
 
163
}
 
164
 
 
165
void do_word P1((w), word w )
 
166
{
 
167
        if (interactive) print_word(w);
 
168
        if (do_expect) {
 
169
                if (w != expect) {
 
170
                        if (!interactive) fprint_word(stderr, w);
 
171
                        fprintf(stderr, " != %s (%ld, %ld) -- expected ",
 
172
                                opname, L_op1, L_op2 );
 
173
                        fprint_word(stderr, expect);
 
174
                        putc('\n', stderr);
 
175
                }
 
176
        } else if (interactive) putchar('\n');
 
177
}
 
178
 
 
179
int main(ac, av) char ** av;
 
180
{
 
181
        char    buf[299];
 
182
        char    * c;
 
183
        FILE    * in;
 
184
 
 
185
        if (ac > 2) {
 
186
                fprintf(stderr, "Usage: %s [filename]\n", av[0]);
 
187
fail:
 
188
#ifdef EXIT_FAILURE
 
189
                exit(EXIT_FAILURE);
 
190
#else
 
191
                exit(1);
 
192
#endif
 
193
        }
 
194
        if (ac < 2) in = stdin;
 
195
        else if (!(in = fopen(av[1], "r"))) {
 
196
                perror(av[1]);
 
197
                fprintf(stderr, "%s: cannot open file \"%s\" for reading\n",
 
198
                        av[0], av[1]);
 
199
                goto fail;
 
200
        }
 
201
 
 
202
        interactive = isatty(fileno(in));
 
203
 
 
204
        for (;;) {
 
205
                if (interactive) fprintf(stderr, "? ");
 
206
 
 
207
                if (!fgets(buf, sizeof(buf), in)) exit(0);
 
208
                if (c = strchr(buf, '\n')) *c = 0;
 
209
 
 
210
                if (*buf == ';' || *buf == '#') continue;
 
211
                if (*buf == '\'') {
 
212
                        puts(buf + 1);
 
213
                        continue;
 
214
                }
 
215
                if (*buf == '\"') {
 
216
                        fprintf(stderr,  "%s\n", buf + 1);
 
217
                        continue;
 
218
                }
 
219
 
 
220
                c = parse(buf);
 
221
 
 
222
                if (!c) continue;
 
223
                if (!strcmp(c,   "add")) {
 
224
                        do_word(    gsm_add( op1, op2 ));
 
225
                        continue;
 
226
                }
 
227
                if (!strcmp(c,   "M_add")) {
 
228
                        do_word(    M_gsm_add( op1, op2 ));
 
229
                        continue;
 
230
                }
 
231
                if (!strcmp(c, "sub")) {
 
232
                        do_word(    gsm_sub( op1, op2 ));
 
233
                        continue;
 
234
                }
 
235
                if (!strcmp(c, "M_sub")) {
 
236
                        do_word(    M_gsm_sub( op1, op2 ));
 
237
                        continue;
 
238
                }
 
239
                if (!strcmp(c, "mult")) {
 
240
                        do_word(    gsm_mult( op1, op2 ));
 
241
                        continue;
 
242
                }
 
243
                if (!strcmp(c, "M_mult")) {
 
244
                        do_word(    M_gsm_mult( op1, op2 ));
 
245
                        continue;
 
246
                }
 
247
                if (!strcmp(c, "mult_r")) {
 
248
                        do_word(    gsm_mult_r(op1, op2));
 
249
                        continue;
 
250
                }
 
251
                if (!strcmp(c, "M_mult_r")) {
 
252
                        do_word(    M_gsm_mult_r(op1, op2));
 
253
                        continue;
 
254
                }
 
255
                if (!strcmp(c, "abs" )) {
 
256
                        do_word(    gsm_abs(op1) );
 
257
                        continue;
 
258
                }
 
259
                if (!strcmp(c, "M_abs" )) {
 
260
                        do_word(    M_gsm_abs(op1) );
 
261
                        continue;
 
262
                }
 
263
                if (!strcmp(c, "div" )) {
 
264
                        do_word(    gsm_div( op1, op2 ));
 
265
                        continue;
 
266
                }
 
267
                if (!strcmp(c,  "norm" )) {
 
268
                        do_word(        gsm_norm(L_op1));
 
269
                        continue;
 
270
                }
 
271
                if (!strcmp(c,  "<<" )) {
 
272
                        do_word(    gsm_asl( op1, op2));
 
273
                        continue;
 
274
                }
 
275
                if (!strcmp(c,  ">>" )) {
 
276
                        do_word(    gsm_asr( op1, op2 ));
 
277
                        continue;
 
278
                }
 
279
                if (!strcmp(c,  "L_mult")) {
 
280
                        do_longword( gsm_L_mult( op1, op2 ));
 
281
                        continue;
 
282
                }
 
283
                if (!strcmp(c,  "M_L_mult")) {
 
284
                        do_longword( M_gsm_L_mult( op1, op2 ));
 
285
                        continue;
 
286
                }
 
287
                if (!strcmp(c,  "L_add" )) {
 
288
                        do_longword( gsm_L_add( L_op1, L_op2 ));
 
289
                        continue;
 
290
                }
 
291
                if (!strcmp(c,  "M_L_add" )) {
 
292
                        do_longword( M_gsm_L_add( L_op1, L_op2 ));
 
293
                        continue;
 
294
                }
 
295
                if (!strcmp(c,  "L_sub" )) {
 
296
                        do_longword( gsm_L_sub( L_op1, L_op2 ));
 
297
                        continue;
 
298
                }
 
299
                if (!strcmp(c,  "L_<<" )) {
 
300
                        do_longword(    gsm_L_asl( L_op1, L_op2 ));
 
301
                        continue;
 
302
                }
 
303
                if (!strcmp(c,  "L_>>")) {
 
304
                        do_longword(    gsm_L_asr( L_op1, L_op2 ));
 
305
                        continue;
 
306
                }
 
307
                help();
 
308
        }
 
309
}
 
310
 
 
311
#include "private.h"
 
312
 
 
313
/*
 
314
 * Function stubs for macro implementations of commonly used
 
315
 * math functions
 
316
 */
 
317
word M_gsm_add P2((op1, op2),word op1, word op2)
 
318
{
 
319
        longword ltmp;
 
320
        return GSM_ADD(op1, op2);
 
321
}
 
322
 
 
323
word M_gsm_sub P2((op1, op2), word op1, word op2)
 
324
{
 
325
        longword ltmp;
 
326
        return GSM_SUB(op1, op2);
 
327
}
 
328
 
 
329
word M_gsm_mult P2((op1, op2), word op1, word op2)
 
330
{
 
331
        return GSM_MULT(op1, op2);
 
332
}
 
333
 
 
334
word M_gsm_mult_r P2((op1, op2), word op1, word op2)
 
335
{
 
336
        return GSM_MULT_R(op1, op2);
 
337
}
 
338
 
 
339
word M_gsm_abs P1((op1), word op1)
 
340
{
 
341
        return GSM_ABS(op1);
 
342
}
 
343
 
 
344
longword M_gsm_L_mult P2((op1, op2), word op1, word op2)
 
345
{
 
346
        return GSM_L_MULT(op1, op2);
 
347
}
 
348
 
 
349
longword M_gsm_L_add P2((op1, op2), longword op1, longword op2)
 
350
{
 
351
        ulongword utmp;
 
352
        return GSM_L_ADD(op1, op2);
 
353
}