Add GSM full rate codec to LCR's source repository
[lcr.git] / libgsmfr / 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 }