NAPA Compiler V4.50
Author: Yves Leduc, yves.leduc.be@gmail.com
Loading...
Searching...
No Matches
C:/Simulate/Napados/Source/bn.c
Go to the documentation of this file.
1/* ** OUTPUT CODE CORRESPONDING TO NAPA NODES *********************************************************************************** */
2
3#undef EXTERN
4#define EXTERN extern
5
6#include "./napa.h"
7#include "./proto.h"
8
9
10/* *** In this file: ************************************************************************************************************ */
11
12/* void print_adc(char *str, long out) */
13/* void print_algebra(char *str, long out) */
14/* void print_alu(char *str, long out) */
15/* void print_average(char *str, long out) */
16/* void print_bshift(char *str, long out) */
17/* void print_btoi(char *str, long out) */
18/* void print_buf(char *str, long out) */
19/* void print_bwinv(char *str, long out) */
20/* void print_change(char *str, long out) */
21/* void print_clip(char *str, long out) */
22/* void print_clock(char *str, long out) */
23/* void print_comp(char *str, long out) */
24/* void print_copy(char *str, long out) */
25/* void print_dac(char *str, long out) */
26/* void print_dc(long out) */
27/* void print_delay(char *str, long out) */
28/* void print_delay1(char *str, long out) */
29/* void print_delay2(char *str, long out) */
30/* void print_delay3(char *str, long out) */
31/* void print_differentiator(char *str, long out) */
32/* void print_dtoi(char *str, long out) */
33/* void print_dyadic0(char *str, long out, long k) */
34/* void print_dyadic1(char *str, long out, long k) */
35/* void print_dyadic2(char *str, long out, long k) */
36/* void print_dyadic3(char *str, long out, long k) */
37/* void print_dyadic4(char *str, long out, long k) */
38/* void print_dyadic5(char *str, long out, long k) */
39/* void print_dyadic6(char *str, long out, long k) */
40/* void print_dyadic7(char *str, long out, long k) */
41/* void print_equal(char *str, long out) */
42/* void print_fzbuf(char *str, long out) */
43/* void print_fzinv(char *str, long out) */
44/* void print_gain(char *str, long out) */
45/* void print_holdtrack(char *str, long out, long k) */
46/* void print_inv(char *str, long out) */
47/* void print_integrator(char *str, long out) */
48/* void print_itob(char *str, long out) */
49/* void print_itod(char *str, long out) */
50/* void print_latch(char *str, long out) */
51/* void print_merge(char *str, long out) */
52/* void print_minmax(char *str, long out, long k) */
53/* void print_muller(char *str, long out) */
54/* void print_mux(char *str, long out) */
55/* void print_noise(char *str, long out) */
56/* void print_offset(char *str, long out) */
57/* void print_osc(char *str, long out) */
58/* void print_poly(char *str, long out) */
59/* void print_quant(char *str, long out) */
60/* void print_ram(char *str, long out) */
61/* void print_rect(char *str, long out) */
62/* void print_relay(char *str, long out) */
63/* void print_rip(char *str, long out) */
64/* void print_rlshift(char *str, long out, long k) */
65/* void print_rom(char *str, long out) */
66/* void print_rshift1(char *str, long out) */
67/* void print_rshift2(char *str, long out) */
68/* void print_sign(char *str, long out) */
69/* void print_sincos(char *str, long out, long k) */
70/* void print_square(char *str, long out) */
71/* void print_step(char *str, long out) */
72/* void print_test(char *str, long out) */
73/* void print_toggle(char *str, long out) */
74/* void print_triangle(char *str, long out) */
75/* void print_trig(char *str, long out) */
76/* void print_uadc(char *str, long out) */
77/* void print_udac(char *str, long out) */
78/* void print_usertool(char *str, long out, long k) */
79/* void print_wsum(char *str, long out) */
80/* void print_zero(char *str, long out) */
81
82
83/* ****************************************************************************************************************************** */
84
85/* These functions write dedicated in-line code respective to the node kinds. */
86/* Register width limitation is implemented by postprocessing the node value (with one exception: 'bshift' node). */
87
88
89/* ****************************************************************************************************************************** */
90
91void print_delay(char *str, long out) { /* unprocessed node_value: number in_node_name */
92 char *s = (char*) NULL;
93 char *nm = (char*) NULL;
94 char tok[STRLENGTH] = {'\0'};
95 char v1[STRLENGTH] = {'\0'};
96 char v2[STRLENGTH] = {'\0'};
97 char v3[STRLENGTH] = {'\0'};
98 char sgn[2] = {'\0'};
99 long v;
100 long w1, w2;
101 long ndel;
102 s = str;
103 nm = Node_List[out].name1;
104 (void) strcpy(v1, nm);
105 (void) build_name("", v1, LEFT_VALUE);
106 s = get_sign_and_token(s, sgn, tok); /* number of delays: variable or constant */
107 v = var_id(tok);
108 if (UNDEFINED != v) {
109 (void) strcpy(v3, Var_List[v].name1);
110 (void) build_name("", v3, RIGHT_VALUE);
111 s = get_sign_and_token(s, sgn, v2);
112 w1 = Node_List[node_id(v2)].width; /* width of input */
113 w2 = Node_List[out].width; /* width of output */
114 (void) build_name(sgn, v2, RIGHT_VALUE);
115 (void) fprintf(STDOUT, " %s_delay[pnode_%s_ptr] = %s;\n", v1, nm, v2);
116 (void) fprintf(STDOUT, " pnode_%s_ptr++;\n", nm);
117 (void) fprintf(STDOUT, " if ( %s <= pnode_%s_ptr ) {\n", v3, nm);
118 (void) fprintf(STDOUT, " pnode_%s_ptr = 0L;\n", nm);
119 (void) fprintf(STDOUT, " }\n");
120 (void) fprintf(STDOUT, " %s = %s_delay[pnode_%s_ptr];\n", v1, v1, nm);
121 if ((w1 == w2) && (0 != strcmp(sgn, "-"))) {
122 Node_List[out].width = 0L; /* no width adjustment */
123 }
124 } else {
125 if (1 != sscanf(tok, "%li", &ndel)) { /* sign is ignored */
126 print_error_location("delay", Node_List[out].mline, Node_List[out].mfile);
127 (void) fprintf(STDERR, " the number of delays is not a well-formed positive C long integer <%s>\n", tok);
128 return;
129 }
130 s = get_sign_and_token(s, sgn, v2);
131 w1 = Node_List[node_id(v2)].width; /* width of input */
132 w2 = Node_List[out].width; /* width of output */
133 (void) build_name(sgn, v2, RIGHT_VALUE);
134 (void) fprintf(STDOUT, " %s_delay[pnode_%s_ptr] = %s;\n", v1, nm, v2);
135 (void) fprintf(STDOUT, " pnode_%s_ptr++;\n", nm);
136 (void) fprintf(STDOUT, " if ( %ldL <= pnode_%s_ptr ) {\n", ndel, nm);
137 (void) fprintf(STDOUT, " pnode_%s_ptr = 0L;\n", nm);
138 (void) fprintf(STDOUT, " }\n");
139 (void) fprintf(STDOUT, " %s = %s_delay[pnode_%s_ptr];\n", v1, v1, nm);
140 if ((w1 == w2) && (0 != strcmp(sgn, "-"))) {
141 Node_List[out].width = 0L; /* no width adjustment */
142 }
143 }
144 return;
145}
146
147
148void print_delay1(char *str, long out) { /* unprocessed node_value: input_node_name */
149 char *s = (char*) NULL;
150 char v0[STRLENGTH] = {'\0'};
151 char v1[STRLENGTH] = {'\0'};
152 char sgn[2] = {'\0'};
153 long w1, w2;
154 s = str;
155 (void) strcpy(v0, Node_List[out].name1);
156 (void) build_name("", v0, LEFT_VALUE);
157 s = get_sign_and_token(s, sgn, v1); /* skip number */
158 s = get_sign_and_token(s, sgn, v1);
159 w1 = Node_List[node_id(v1)].width; /* width of input */
160 w2 = Node_List[out].width; /* width of output */
161 (void) build_name(sgn, v1, RIGHT_VALUE);
162 (void) fprintf(STDOUT, " %s = %s;\n", v0, v1);
163 if ((w1 == w2) && (0 != strcmp(sgn, "-"))) {
164 Node_List[out].width = 0L; /* no width adjustment */
165 }
166 return;
167}
168
169
170void print_delay2(char *str, long out) { /* unprocessed node_value: input_node_name */
171 char *s = (char*) NULL;
172 char v0[STRLENGTH] = {'\0'};
173 char v1[STRLENGTH] = {'\0'};
174 char sgn[2] = {'\0'};
175 long w1, w2;
176 s = str;
177 (void) strcpy(v0, Node_List[out].name1);
178 (void) build_name("", v0, LEFT_VALUE);
179 s = get_sign_and_token(s, sgn, v1); /* skip number */
180 s = get_sign_and_token(s, sgn, v1);
181 w1 = Node_List[node_id(v1)].width; /* width of input */
182 w2 = Node_List[out].width; /* width of output */
183 (void) build_name(sgn, v1, RIGHT_VALUE);
184 (void) fprintf(STDOUT, " %s = %s_delay;\n", v0, v0);
185 (void) fprintf(STDOUT, " %s_delay = %s;\n", v0, v1);
186 if ((w1 == w2) && (0 != strcmp(sgn, "-"))) {
187 Node_List[out].width = 0L; /* no width adjustment */
188 }
189 return;
190}
191
192
193void print_delay3(char *str, long out) { /* unprocessed node_value: input_node_name */
194 char *s = (char*) NULL;
195 char v0[STRLENGTH] = {'\0'};
196 char v1[STRLENGTH] = {'\0'};
197 char sgn[2] = {'\0'};
198 long w1, w2;
199 s = str;
200 (void) strcpy(v0, Node_List[out].name1);
201 (void) build_name("", v0, LEFT_VALUE);
202 s = get_sign_and_token(s, sgn, v1); /* skip number */
203 s = get_sign_and_token(s, sgn, v1);
204 w1 = Node_List[node_id(v1)].width; /* width of input */
205 w2 = Node_List[out].width; /* width of output */
206 (void) build_name(sgn, v1, RIGHT_VALUE);
207 (void) fprintf(STDOUT, " %s = %s_delay[1];\n", v0, v0);
208 (void) fprintf(STDOUT, " %s_delay[1] = %s_delay[0];\n", v0, v0);
209 (void) fprintf(STDOUT, " %s_delay[0] = %s;\n", v0, v1);
210 if ((w1 == w2) && (0 != strcmp(sgn, "-"))) {
211 Node_List[out].width = 0L; /* no width adjustment */
212 }
213 return;
214}
215
216
217void print_dc(long out) { /* unprocessed node_value: input_node_name ... */
218 char v0[STRLENGTH] = {'\0'};
219 (void) strcpy(v0, Node_List[out].name1);
220 (void) build_name("", v0, LEFT_VALUE);
221 (void) fprintf(STDOUT, " %s = %s_dc;\n", v0, v0); /* value was precomputed */
222 return;
223}
224
225
226void print_differentiator(char *str, long out) { /* unprocessed node_value: in_node_name */
227 char *s = (char*) NULL;
228 char *nm = (char*) NULL;
229 char v1[STRLENGTH] = {'\0'};
230 char v2[STRLENGTH] = {'\0'};
231 char sgn[2] = {'\0'};
232 s = str;
233 nm = Node_List[out].name1;
234 (void) strcpy(v1, nm);
235 (void) build_name("", v1, LEFT_VALUE);
236 s = get_sign_and_token(s, sgn, v2);
237 (void) build_name("", v2, RIGHT_VALUE);
238 if (0 == strcmp(sgn, "-")) {
239 (void) fprintf(STDOUT, " %s = -%s - %s_delay;\n", v1, v2, v1);
240 } else {
241 (void) fprintf(STDOUT, " %s = %s - %s_delay;\n", v1, v2, v1);
242 }
243 (void) fprintf(STDOUT, " %s_delay = %s;\n", v1, v2);
244 return;
245}
246
247
248
249void print_integrator(char *str, long out) { /* unprocessed node_value: in_node_name */
250 char *s = (char*) NULL;
251 char *nm = (char*) NULL;
252 char v1[STRLENGTH] = {'\0'};
253 char v2[STRLENGTH] = {'\0'};
254 char sgn[2] = {'\0'};
255 s = str;
256 nm = Node_List[out].name1;
257 (void) strcpy(v1, nm);
258 (void) build_name("", v1, LEFT_VALUE);
259 s = get_sign_and_token(s, sgn, v2);
260 (void) build_name("", v2, RIGHT_VALUE);
261 if (0 == strcmp(sgn, "-")) {
262 (void) fprintf(STDOUT, " %s -= %s;\n", v1, v2);
263 } else {
264 (void) fprintf(STDOUT, " %s += %s;\n", v1, v2);
265 }
266 return;
267}
268
269
270void print_osc(char *str, long out) { /* unprocessed node_val: off ampl freq phase */
271 char *s = (char*) NULL;
272 char v0[STRLENGTH] = {'\0'};
273 char v1[STRLENGTH] = {'\0'};
274 char v2[STRLENGTH] = {'\0'};
275 char v3[STRLENGTH] = {'\0'};
276 char v4[STRLENGTH] = {'\0'};
277 char nm[STRLENGTH] = {'\0'};
278 char sgn[2] = {'\0'};
279 double dtemp1;
280 int flag;
281 s = str;
282 (void) strcpy(nm, Node_List[out].name1);
283 (void) strcpy(v0, Node_List[out].name1);
284 (void) build_name("", v0, LEFT_VALUE);
285 s = get_sign_and_token(s, sgn, v1); /* offset */
286 (void) build_name(sgn, v1, RIGHT_VALUE);
287 s = get_sign_and_token(s, sgn, v2); /* amplitude */
288 (void) build_name(sgn, v2, RIGHT_VALUE);
289 s = get_sign_and_token(s, sgn, v3); /* frequency */
290 (void) build_name(sgn, v3, RIGHT_VALUE);
291 s = get_sign_and_token(s, sgn, v4); /* phase */
292 (void) build_name(sgn, v4, RIGHT_VALUE);
293 (void) fprintf(STDOUT, " hnode_%s_osc2 = hnode_%s_osc1;\n", nm, nm);
294 (void) fprintf(STDOUT, " hnode_%s_osc1 = hnode_%s_osc0;\n", nm, nm);
295 (void) fprintf(STDOUT, " hnode_%s_osc0 = (hnode_%s_fctr * hnode_%s_osc1) - hnode_%s_osc2;\n", nm, nm, nm, nm);
296 flag = sscanf(v2, "%lf", &dtemp1); /* amplitude ? */
297 if ((1 != flag) || ISNOTEQUAL(1.0, dtemp1)) {
298 (void) fprintf(STDOUT, " %s = ((R_TYPE) hnode_%s_osc1) * %s;\n", v0, nm, v2);
299 } else {
300 (void) fprintf(STDOUT, " %s = (R_TYPE) hnode_%s_osc1;\n", v0, nm );
301 }
302 flag = sscanf(v1, "%lf", &dtemp1);
303 if ((1 != flag) || ISNOTSMALL(dtemp1)) { /* offset ? */
304 (void) fprintf(STDOUT, " %s += %s;\n", v0, v1);
305 }
306 return;
307}
308
309
310void print_sincos(char *str, long out, long k) { /* unprocessed node_val: off ampl freq phase */
311 char *s = (char*) NULL;
312 char v0[STRLENGTH] = {'\0'};
313 char v1[STRLENGTH] = {'\0'};
314 char v2[STRLENGTH] = {'\0'};
315 char v3[STRLENGTH] = {'\0'};
316 char v4[STRLENGTH] = {'\0'};
317 char v5[STRLENGTH] = {'\0'};
318 char v6[STRLENGTH] = {'\0'};
319 char v7[STRLENGTH] = {'\0'};
320 char nm[STRLENGTH] = {'\0'};
321 char sgn[2] = {'\0'};
322 double dtemp1;
323 long d;
324 int flag1;
325 int flag2;
326 s = str;
327 (void) strcpy(nm, Node_List[out].name1);
328 (void) strcpy(v0, Node_List[out].name1);
329 (void) build_name("", v0, LEFT_VALUE);
330 s = get_sign_and_token(s, sgn, v1); /* offset */
331 (void) build_name(sgn, v1, RIGHT_VALUE);
332 s = get_sign_and_token(s, sgn, v2); /* amplitude */
333 (void) build_name(sgn, v2, RIGHT_VALUE);
334 s = get_sign_and_token(s, sgn, v3); /* frequency */
335 flag1 = sscanf(v3, "%lf", &dtemp1);
336 (void) strcpy(v7, v3);
337 (void) build_name(sgn, v3, RIGHT_VALUE);
338 if (1 == flag1) {
339 (void) strcat(v3, "L");
340 }
341 s = get_sign_and_token(s, sgn, v4); /* phase */
342 flag1 = sscanf(v4, "%lf", &dtemp1);
343 (void) build_name(sgn, v4, RIGHT_VALUE);
344 if (1 == flag1) {
345 (void) strcat(v4, "L");
346 }
347 if ((SIN_KIND == k) || (SIN2_KIND == k)) {
348 (void) strcpy(v5, "sinl");
349 (void) strcpy(v6, "sine");
350 }
351 if ((COS_KIND == k) || (COS2_KIND == k)) {
352 (void) strcpy(v5, "cosl");
353 (void) strcpy(v6, "cosine");
354 }
355 if ((SIN2_KIND == k) || (COS2_KIND == k)) { /* Continuity of phase must be guaranteed */
356 (void) fprintf(STDOUT, " if ( 0.0 > %s ) {\n", v3);
357 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (%s)\\n\");\n", v6);
358 if (!Cmdline_Flag) {
359 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", Node_List[out].mline[0]);
360 for (d = 1L; d < MAXDEPTH; d++) {
361 if (0UL == Node_List[out].mline[d]) {
362 break;
363 }
364 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
365 Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
366 }
367 }
368 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n value of control frequency <%s> cannot be negative\\n\");\n", v7);
369 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
370 (void) fprintf(STDOUT, " }\n");
371 (void) fprintf(STDOUT, " if ( !inode_%s_first ) {\n", nm);
372 (void) fprintf(STDOUT, " if ( hnode_%s_freq != (H_PREC) %s ) {\n", nm, v3);
373 (void) fprintf(STDOUT, " hnode_%s_phase += _2PI_ * (hnode_%s_freq - ((H_PREC) %s)) * napa_abs_time;\n", nm, nm, v3);
374 (void) fprintf(STDOUT, " hnode_%s_phase -= _2PI_ * floorl(hnode_%s_phase / _2PI_);\n", nm, nm );
375 (void) fprintf(STDOUT, " hnode_%s_freq = (H_PREC) %s;\n", nm, v3);
376 (void) fprintf(STDOUT, " }\n");
377 (void) fprintf(STDOUT, " } else {\n");
378 (void) fprintf(STDOUT, " inode_%s_first = false;\n", nm);
379 (void) fprintf(STDOUT, " hnode_%s_freq = (H_PREC) %s;\n", nm, v3);
380 (void) fprintf(STDOUT, " }\n");
381 }
382 (void) fprintf(STDOUT, " %s = ", v0);
383 flag2 = sscanf(v1, "%lf", &dtemp1);
384 if ((1 != flag2) || ISNOTSMALL(dtemp1)) {
385 (void) fprintf(STDOUT, "%s + ", v1);
386 }
387 flag2 = sscanf(v2, "%lf", &dtemp1);
388 if ((1 != flag2) || ISNOTEQUAL(1.0, dtemp1)) {
389 (void) fprintf(STDOUT, "(%s) * ", v2);
390 }
391 if ((SIN2_KIND == k) || (COS2_KIND == k)) {
392 (void) fprintf(STDOUT, "((R_TYPE) %s((_2PI_ * hnode_%s_freq * napa_abs_time) + hnode_%s_phase", v5, nm, nm);
393 } else {
394 flag2 = sscanf(v3, "%lf", &dtemp1);
395 if (1 == flag2) {
396 (void) fprintf(STDOUT, "((R_TYPE) %s(%.21LfL * napa_abs_time", v5, _2PI_ * (long double) dtemp1);
397 } else {
398 (void) fprintf(STDOUT, "((R_TYPE) %s(_2PI_ * ((H_PREC) %s) * napa_abs_time", v5, v3);
399 }
400 }
401 flag2 = sscanf(v4, "%lf", &dtemp1);
402 if ((1 != flag2) || ISNOTSMALL(dtemp1)) {
403 (void) fprintf(STDOUT, " + ((H_PREC) (%s))", v4);
404 }
405 (void) fprintf(STDOUT, "));\n");
406 return;
407}
408
409
410void print_square(char *str, long out) { /* unprocessed node_value: off ampl freq delay duty */
411 char *s = (char*) NULL;
412 char v0[STRLENGTH] = {'\0'};
413 char v1[STRLENGTH] = {'\0'};
414 char v2[STRLENGTH] = {'\0'};
415 char v3[STRLENGTH] = {'\0'};
416 char v4[STRLENGTH] = {'\0'};
417 char v5[STRLENGTH] = {'\0'};
418 char sgn[2] = {'\0'};
419 double dtemp1;
420 int flag;
421 s = str;
422 (void) strcpy(v0, Node_List[out].name1);
423 (void) build_name("", v0, LEFT_VALUE);
424 s = get_sign_and_token(s, sgn, v1);
425 (void) build_name(sgn, v1, RIGHT_VALUE); /* offset */
426 s = get_sign_and_token(s, sgn, v2);
427 (void) build_name(sgn, v2, RIGHT_VALUE); /* amplitude */
428 s = get_sign_and_token(s, sgn, v3);
429 (void) build_name(sgn, v3, RIGHT_VALUE); /* frequency */
430 s = get_sign_and_token(s, sgn, v4);
431 (void) build_name(sgn, v4, RIGHT_VALUE); /* delay */
432 flag = sscanf(v4, "%lf", &dtemp1);
433 if ((1 == flag) && ISSMALL(dtemp1)) {
434 (void) fprintf(STDOUT, " %s = %s * TIME;\n", v0, v3);
435 } else {
436 (void) fprintf(STDOUT, " %s = %s * (TIME + (%s));\n", v0, v3, v4);
437 }
438 (void) fprintf(STDOUT, " %s = %s - floor(%s);\n", v0, v0, v0);
439 s = get_sign_and_token(s, sgn, v5); /* duty cycle */
440 if (ISEMPTY(v5)) {
441 (void) fprintf(STDOUT, " if ( 0.50 > %s ) {\n", v0);
442 } else {
443 (void) build_name(sgn, v5, RIGHT_VALUE);
444 (void) fprintf(STDOUT, " if ( %s < %s ) {\n", v0, v5);
445 }
446 flag = sscanf(v1, "%lf", &dtemp1);
447 if ((1 == flag) && ISSMALL(dtemp1)) {
448 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
449 (void) fprintf(STDOUT, " } else {\n");
450 (void) fprintf(STDOUT, " %s = - (%s);\n", v0, v2);
451 } else {
452 (void) fprintf(STDOUT, " %s = %s + (%s);\n", v0, v1, v2);
453 (void) fprintf(STDOUT, " } else {\n");
454 (void) fprintf(STDOUT, " %s = %s - (%s);\n", v0, v1, v2);
455 }
456 (void) fprintf(STDOUT, " }\n");
457 return;
458}
459
460
461void print_triangle(char *str, long out) { /* unprocessed node_val: off ampl freq delay duty */
462 char *s = (char*) NULL;
463 char v0[STRLENGTH] = {'\0'};
464 char v1[STRLENGTH] = {'\0'};
465 char v2[STRLENGTH] = {'\0'};
466 char v3[STRLENGTH] = {'\0'};
467 char v4[STRLENGTH] = {'\0'};
468 char v5[STRLENGTH] = {'\0'};
469 char sgn[2] = {'\0'};
470 double dtemp1, dtemp2;
471 int flag1, flag2;
472 s = str;
473 (void) strcpy(v0, Node_List[out].name1);
474 (void) build_name("", v0, LEFT_VALUE);
475 s = get_sign_and_token(s, sgn, v1); /* offset */
476 (void) build_name(sgn, v1, RIGHT_VALUE);
477 s = get_sign_and_token(s, sgn, v2); /* amplitude */
478 (void) build_name(sgn, v2, RIGHT_VALUE);
479 s = get_sign_and_token(s, sgn, v3); /* frequency */
480 (void) build_name(sgn, v3, RIGHT_VALUE);
481 s = get_sign_and_token(s, sgn, v4); /* delay */
482 (void) build_name(sgn, v4, RIGHT_VALUE);
483 s = get_sign_and_token(s, sgn, v5); /* duty cycle */
484 if (ISEMPTY(v5)) {
485 (void) strcpy(v5, "0.5"); /* default duty cycle is 0.5 */
486 }
487 (void) build_name(sgn, v5, RIGHT_VALUE);
488 flag1 = sscanf(v4, "%lf", &dtemp1); /* delay */
489 if ((1 == flag1) && ISSMALL(dtemp1)) {
490 (void) fprintf(STDOUT, " %s = %s * TIME;\n", v0, v3);
491 } else {
492 (void) fprintf(STDOUT, " %s = %s * (TIME + (%s));\n", v0, v3, v4);
493 }
494 (void) fprintf(STDOUT, " %s = %s - floor(%s);\n", v0, v0, v0);
495 flag1 = sscanf(v5, "%lf", &dtemp1); /* duty cycle */
496 if (1 != flag1) {
497 (void) fprintf(STDOUT, " if ( (%s * 0.5) > %s ) {\n", v5, v0);
498 (void) fprintf(STDOUT, " %s = (2.0 / %s) * %s;\n", v0, v5, v0);
499 (void) fprintf(STDOUT, " } else if ( (1.0 - (0.5 * %s)) > %s ) {\n", v5, v0);
500 (void) fprintf(STDOUT, " %s = (1.0 - (2.0 * %s)) / (1.0 - %s);\n", v0, v0, v5);
501 (void) fprintf(STDOUT, " } else {\n");
502 (void) fprintf(STDOUT, " %s = (2.0 / %s) * (%s - 1.0);\n", v0, v5, v0);
503 (void) fprintf(STDOUT, " }\n");
504 } else if (ISSMALL(dtemp1)) {
505 (void) fprintf(STDOUT, " %s = %.15e * (0.5 - %s);\n", v0, 2.0 / (1.0 - dtemp1), v0);
506 } else if (ISEQUAL(1.0, dtemp1)) {
507 (void) fprintf(STDOUT, " if ( %.15e > %s ) {\n", dtemp1 * 0.5, v0);
508 (void) fprintf(STDOUT, " %s = %.15e * %s;\n", v0, 2.0 / dtemp1, v0);
509 (void) fprintf(STDOUT, " } else {\n");
510 (void) fprintf(STDOUT, " %s = %.15e * (%s - 1.0);\n", v0, 2.0 / dtemp1, v0);
511 (void) fprintf(STDOUT, " }\n");
512 } else {
513 (void) fprintf(STDOUT, " if ( %.15e > %s ) {\n", dtemp1 * 0.5, v0);
514 (void) fprintf(STDOUT, " %s = %.15e * %s;\n", v0, 2.0 / dtemp1, v0);
515 (void) fprintf(STDOUT, " } else if ( %.15e > %s ) {\n", 1.0 - (dtemp1 * 0.5), v0);
516 (void) fprintf(STDOUT, " %s = %.15e * (0.5 - %s);\n", v0, 2.0 / (1.0 - dtemp1), v0);
517 (void) fprintf(STDOUT, " } else {\n");
518 (void) fprintf(STDOUT, " %s = %.15e * (%s - 1.0);\n", v0, 2.0 / dtemp1, v0);
519 (void) fprintf(STDOUT, " }\n");
520 }
521 flag1 = sscanf(v1, "%lf", &dtemp1); /* offset */
522 flag2 = sscanf(v2, "%lf", &dtemp2); /* amplitude */
523 if ((1 == flag1) && (1 == flag2) && ISSMALL(dtemp1) && ISEQUAL(dtemp2, 1.0)) {
524 return;
525 }
526 if ((1 != flag1) || (1 != flag2) || ISNOTSMALL(dtemp1) || ISNOTSMALL(dtemp2)) {
527 (void) fprintf(STDOUT, " %s = ", v0);
528 if ((1 != flag1) || ISNOTSMALL(dtemp1)) {
529 (void) fprintf(STDOUT, "%s + (", v1);
530 }
531 if ((1 != flag2) || ISNOTEQUAL(1.0, dtemp2)) {
532 (void) fprintf(STDOUT, "%s * ", v2);
533 }
534 (void) fprintf(STDOUT, "%s", v0);
535 if ((1 != flag1) || ISNOTSMALL(dtemp1)) {
536 (void) fprintf(STDOUT, ");\n");
537 } else {
538 (void) fprintf(STDOUT, ";\n" );
539 }
540 }
541 return;
542}
543
544
545void print_step(char *str, long out) { /* unprocessed node_value: val1 val2 tim1... */
546 char *s = (char*) NULL;
547 char v0[STRLENGTH] = {'\0'};
548 char v1[STRLENGTH] = {'\0'};
549 char v2[STRLENGTH] = {'\0'};
550 char v3[STRLENGTH] = {'\0'};
551 char v4[STRLENGTH] = {'\0'};
552 char sgn[2] = {'\0'};
553 s = str;
554 (void) strcpy(v0, Node_List[out].name1);
555 (void) build_name("", v0, LEFT_VALUE);
556 s = get_sign_and_token(s, sgn, v1);
557 (void) build_name(sgn, v1, RIGHT_VALUE);
558 s = get_sign_and_token(s, sgn, v2);
559 (void) build_name(sgn, v2, RIGHT_VALUE);
560 s = get_sign_and_token(s, sgn, v3);
561 (void) build_name(sgn, v3, RIGHT_VALUE);
562 if (ISEMPTY(s)) {
563 (void) fprintf(STDOUT, " %s = (%s > TIME)", v0, v3);
564 } else {
565 s = get_sign_and_token(s, sgn, v4);
566 (void) build_name(sgn, v4, RIGHT_VALUE);
567 (void) fprintf(STDOUT, " %s = (%s > TIME) || (%s < TIME)", v0, v3, v4);
568 }
569 (void) fprintf(STDOUT, " ? %s : %s;\n", v1, v2);
570 return;
571}
572
573
574void print_itob(char *str, long out) { /* unprocessed node_value: bit_value input_node */
575 char *s = (char*) NULL;
576 char v0[STRLENGTH] = {'\0'};
577 char v1[STRLENGTH] = {'\0'};
578 char v2[STRLENGTH] = {'\0'};
579 char sgn[2] = {'\0'};
580 s = str;
581 (void) strcpy(v0, Node_List[out].name1);
582 (void) build_name("", v0, LEFT_VALUE);
583 s = get_sign_and_token(s, sgn, v1);
584 (void) build_name("", v1, RIGHT_VALUE);
585 s = get_sign_and_token(s, sgn, v2);
586 (void) build_name(sgn, v2, RIGHT_VALUE);
587 (void) fprintf(STDOUT, " %s = (%s >> %s) & 1LL;\n", v0, v2, v1);
588 return;
589}
590
591
592void print_offset(char *str, long out) { /* unprocessed node_value: [sgn] val in_node */
593 char *s = (char*) NULL;
594 char v0[STRLENGTH] = {'\0'};
595 char v1[STRLENGTH] = {'\0'};
596 char v2[STRLENGTH] = {'\0'};
597 char sgn[2] = {'\0'};
598 int flag;
599 double dtemp1;
600 s = str;
601 (void) strcpy(v0, Node_List[out].name1);
602 (void) build_name("", v0, LEFT_VALUE);
603 s = get_sign_and_token(s, sgn, v1);
604 (void) build_name(sgn, v1, RIGHT_VALUE);
605 s = get_sign_and_token(s, sgn, v2);
606 (void) build_name(sgn, v2, RIGHT_VALUE);
607 flag = sscanf(v1, "%lf", &dtemp1);
608 if ((1 == flag) && ISSMALL(dtemp1)) {
609 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
610 } else {
611 (void) fprintf(STDOUT, " %s = (%s) + (%s);\n", v0, v1, v2);
612 }
613 return;
614}
615
616
617void print_gain(char *str, long out) { /* unprocessed node_value: [sgn] val in_node */
618 char *s = (char*) NULL;
619 char v0[STRLENGTH] = {'\0'};
620 char v1[STRLENGTH] = {'\0'};
621 char v2[STRLENGTH] = {'\0'};
622 char sgn[2] = {'\0'};
623 long long lltemp1;
624 double dtemp2;
625 int flag;
626 s = str;
627 (void) strcpy(v0, Node_List[out].name1);
628 (void) build_name("", v0, LEFT_VALUE);
629 s = get_sign_and_token(s, sgn, v1);
630 (void) build_name(sgn, v1, RIGHT_VALUE); /* gain parameter */
631 s = get_sign_and_token(s, sgn, v2);
632 (void) build_name(sgn, v2, RIGHT_VALUE); /* input node, no sign by syntax */
633 if (DIGITAL_DATA_TYPE == Node_List[out].type) {
634 flag = sscanf(v1, "%lli", &lltemp1);
635 if ((1 == flag) && (0LL == lltemp1)) {
636 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
637 return;
638 }
639 if ((1 == flag) && (1LL == lltemp1)) {
640 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2); /* faster implementation */
641 return;
642 }
643 if ((1 == flag) && (-1LL == lltemp1)) {
644 (void) fprintf(STDOUT, " %s = -%s;\n", v0, v2); /* faster implementation */
645 return;
646 }
647 if ((1 == flag) && (2LL == lltemp1)) {
648 (void) fprintf(STDOUT, " %s = %s + %s;\n", v0, v2, v2); /* faster implementation */
649 return;
650 }
651 } else {
652 flag = sscanf(v1, "%lf", &dtemp2);
653 if ((1 == flag) && ISSMALL(dtemp2)) {
654 (void) fprintf(STDOUT, " %s = 0.0;\n", v0);
655 return;
656 }
657 if ((1 == flag) && (ISEQUAL(1.0, dtemp2))) {
658 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2); /* faster implementation */
659 return;
660 }
661 if ((1 == flag) && (ISEQUAL(-1.0, dtemp2))) {
662 (void) fprintf(STDOUT, " %s = -%s;\n", v0, v2); /* faster implementation */
663 return;
664 }
665 if ((1 == flag) && (ISEQUAL(2.0, dtemp2))) {
666 (void) fprintf(STDOUT, " %s = %s + %s;\n", v0, v2, v2); /* faster implementation */
667 return;
668 }
669 }
670 (void) fprintf(STDOUT, " %s = %s * %s;\n", v0, v1, v2);
671 return;
672}
673
674
675void print_wsum(char *str, long out) { /* unprocessed value: [sgn]val nod.. [[sgn]val nod] */
676 long n;
677 char *s = (char*) NULL;
678 char v0[STRLENGTH] = {'\0'};
679 char v1[STRLENGTH] = {'\0'};
680 char v2[STRLENGTH] = {'\0'};
681 char sgn[2] = {'\0'};
682 long long lltemp1;
683 double dtemp2;
684 int flag;
685 (void) strcpy(v0, Node_List[out].name1);
686 (void) build_name("", v0, LEFT_VALUE);
687 n = 0L;
688 s = str;
689 for (;;) {
690 n++;
691 if (ISEMPTY(s)) {
692 if (0L != Node_List[out].width) {
693 print_warning_location("width limitation", Node_List[out].mline, Node_List[out].mfile);
694 (void) fprintf(STDERR, " the node <%s> is far too complex to model accurately the under/overflow\n", Node_List[out].name1);
695 (void) fprintf(STDERR, " behavior of an actual realization, we suggest to use a lower level model\n\n");
696 }
697 return;
698 }
699 s = get_sign_and_token(s, sgn, v1);
700 (void) build_name(sgn, v1, RIGHT_VALUE);
701 s = get_sign_and_token(s, sgn, v2);
702 (void) build_name(sgn, v2, RIGHT_VALUE);
703 if (DIGITAL_DATA_TYPE == Node_List[out].type) {
704 flag = sscanf(v1, "%lli", &lltemp1);
705 if ((1 == flag) && (0LL == lltemp1)) {
706 if (1L == n) {
707 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
708 }
709 continue;
710 }
711 if ((1 == flag) && (1LL == lltemp1)) {
712 if (1L == n) {
713 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
714 } else {
715 (void) fprintf(STDOUT, " %s += %s;\n", v0, v2);
716 }
717 continue;
718 }
719 } else {
720 flag = sscanf(v1, "%lf", &dtemp2);
721 if ((1 == flag) && ISSMALL(dtemp2)) {
722 if (1L == n) {
723 (void) fprintf(STDOUT, " %s = 0.0;\n", v0);
724 }
725 continue;
726 }
727 if ((1 == flag) && (ISEQUAL(1.0, dtemp2))) {
728 if (1L == n) {
729 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
730 } else {
731 (void) fprintf(STDOUT, " %s += %s;\n", v0, v2);
732 }
733 continue;
734 }
735 if ((1 == flag) && (ISEQUAL(-1.0, dtemp2))) {
736 if (1L == n) {
737 (void) fprintf(STDOUT, " %s = -%s;\n", v0, v2);
738 } else {
739 (void) fprintf(STDOUT, " %s -= %s;\n", v0, v2);
740 }
741 continue;
742 }
743 }
744 if (1L == n) {
745 (void) fprintf(STDOUT, " %s = (%s) * (%s);\n", v0, v1, v2);
746 } else {
747 (void) fprintf(STDOUT, " %s += (%s) * (%s);\n", v0, v1, v2);
748 }
749 }
750 return;
751}
752
753
754void print_holdtrack(char *str, long out, long k) { /* unprocessed node_val: ctr_node in_node */
755 char *s = (char*) NULL;
756 char v0[STRLENGTH] = {'\0'};
757 char v1[STRLENGTH] = {'\0'};
758 char v2[STRLENGTH] = {'\0'};
759 char sgn[2] = {'\0'};
760 long w1, w2;
761 s = str;
762 (void) strcpy(v0, Node_List[out].name1);
763 (void) build_name("", v0, LEFT_VALUE);
764 s = get_sign_and_token(s, sgn, v1);
765 (void) build_name("", v1, RIGHT_VALUE);
766 s = get_sign_and_token(s, sgn, v2);
767 w1 = Node_List[node_id(v2)].width; /* width of input */
768 w2 = Node_List[out].width; /* width of output */
769 (void) build_name(sgn, v2, RIGHT_VALUE);
770 if (TRACK_KIND == k) {
771 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v1);
772 }
773 if (HOLD_KIND == k) {
774 (void) fprintf(STDOUT, " if ( 0LL == %s ) {\n", v1);
775 }
776 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
777 (void) fprintf(STDOUT, " }\n");
778 if ((w1 == w2) && (0 != strcmp(sgn, "-"))) {
779 Node_List[out].width = 0L; /* no width adjustment */
780 }
781 return;
782}
783
784
785void print_clip(char *str, long out) { /* unprocessed node_val: [sgn]refm [sgn]refp in_nod */
786 char *s = (char*) NULL;
787 char v0[STRLENGTH] = {'\0'};
788 char v1[STRLENGTH] = {'\0'};
789 char v2[STRLENGTH] = {'\0'};
790 char v3[STRLENGTH] = {'\0'};
791 char sgn[2] = {'\0'};
792 s = str;
793 (void) strcpy(v0, Node_List[out].name1);
794 (void) build_name("", v0, LEFT_VALUE);
795 s = get_sign_and_token(s, sgn, v1);
796 (void) build_name(sgn, v1, RIGHT_VALUE);
797 s = get_sign_and_token(s, sgn, v2);
798 (void) build_name(sgn, v2, RIGHT_VALUE);
799 s = get_sign_and_token(s, sgn, v3);
800 (void) build_name(sgn, v3, RIGHT_VALUE);
801 (void) fprintf(STDOUT, " if ( %s > %s ) {\n", v3, v2);
802 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
803 (void) fprintf(STDOUT, " } else if ( %s < %s ) {\n", v3, v1);
804 (void) fprintf(STDOUT, " %s = %s;\n", v0, v1);
805 (void) fprintf(STDOUT, " } else {\n");
806 (void) fprintf(STDOUT, " %s = %s;\n", v0, v3);
807 (void) fprintf(STDOUT, " }\n");
808 return;
809}
810
811
812void print_noise(char *str, long out) { /* unprocessed node_value: [sgn]DC RMS */
813 char *s = (char*) NULL; /* [sgn]min [sgn]max */
814 char *nm = (char*) NULL;
815 char v1[STRLENGTH] = {'\0'};
816 char v2[STRLENGTH] = {'\0'}; /* using the Marsaglia polar method, a variant of */
817 char v3[STRLENGTH] = {'\0'}; /* the Box Muller transform, to compute a pair of */
818 char sgn[2] = {'\0'}; /* standard normal random numbers. */
819 double dtemp1, dtemp2;
820 int flag;
821 s = str;
822 nm = Node_List[out].name1;
823 (void) strcpy(v1, nm);
824 (void) build_name("", v1, LEFT_VALUE);
825 s = get_sign_and_token(s, sgn, v2);
826 (void) build_name(sgn, v2, RIGHT_VALUE);
827 s = get_sign_and_token(s, sgn, v3);
828 (void) build_name(sgn, v3, RIGHT_VALUE);
829 (void) fprintf(STDOUT, " inode_%s_ok = -inode_%s_ok;\n", nm, nm);
830 (void) fprintf(STDOUT, " if ( 0LL < inode_%s_ok ) {\n", nm);
831 (void) fprintf(STDOUT, " %s = ", v1);
832 flag = sscanf(v2, "%lf", &dtemp1);
833 if ((1 != flag) || ISNOTSMALL(dtemp1)) {
834 (void) fprintf(STDOUT, "%s + ", v2);
835 }
836 (void) fprintf(STDOUT, "dnode_%s_g1", nm);
837 flag = sscanf(v3, "%lf", &dtemp2);
838 if ((1 != flag) || ISNOTEQUAL(1.0, dtemp2)) {
839 (void) fprintf(STDOUT, " * %s", v3);
840 }
841 (void) fprintf(STDOUT, ";\n");
842 (void) fprintf(STDOUT, " } else {\n");
843 (void) fprintf(STDOUT, " do {\n");
844 (void) fprintf(STDOUT, " dnode_%s_g1 = (2.22044604925031332e-16*((R_TYPE) (napa_rand()>>10))) - 1.0;\n", nm);
845 (void) fprintf(STDOUT, " dnode_%s_g2 = (2.22044604925031332e-16*((R_TYPE) (napa_rand()>>10))) - 1.0;\n", nm);
846 (void) fprintf(STDOUT, " dnode_%s_rd = SQR(dnode_%s_g1) + SQR(dnode_%s_g2);\n", nm, nm, nm);
847 (void) fprintf(STDOUT, " } while ( (1.0 < dnode_%s_rd) || (0.0 >= dnode_%s_rd) );\n", nm, nm);
848 (void) fprintf(STDOUT, " dnode_%s_f = sqrt((-FSL * log(dnode_%s_rd)) / dnode_%s_rd);\n", nm, nm, nm);
849 (void) fprintf(STDOUT, " dnode_%s_g1 *= dnode_%s_f;\n", nm, nm);
850 (void) fprintf(STDOUT, " dnode_%s_g2 *= dnode_%s_f;\n", nm, nm);
851 (void) fprintf(STDOUT, " %s = ", v1);
852 flag = sscanf(v2, "%lf", &dtemp1);
853 if ((1 != flag) || ISNOTSMALL(dtemp1)) {
854 (void) fprintf(STDOUT, "%s + ", v2);
855 }
856 (void) fprintf(STDOUT, "dnode_%s_g2", nm);
857 flag = sscanf(v3, "%lf", &dtemp2);
858 if ((1 != flag) || ISNOTEQUAL(1.0, dtemp2)) {
859 (void) fprintf(STDOUT, " * %s", v3);
860 }
861 (void) fprintf(STDOUT, ";\n");
862 (void) fprintf(STDOUT, " }\n");
863 return;
864}
865
866
867void print_bshift(char *str, long out) { /* unprocessed node_value: shift value input_node */
868 char *s = (char*) NULL;
869 char v0[STRLENGTH] = {'\0'};
870 char v1[STRLENGTH] = {'\0'};
871 char v2[STRLENGTH] = {'\0'};
872 char v3[STRLENGTH] = {'\0'};
873 char sgn[2] = {'\0'};
874 long w1, w2;
875 long sh;
876 long right;
877 long ltemp1, ltemp2;
878 s = str;
879 (void) strcpy(v0, Node_List[out].name1);
880 (void) build_name("", v0, LEFT_VALUE);
881 s = get_sign_and_token(s, sgn, v1);
882 right = (0 != strcmp(sgn, "-")) ? true : false; /* right or left shift */
883 (void) build_name("", v1, RIGHT_VALUE); /* without sign */
884 s = get_sign_and_token(s, sgn, v2);
885 (void) strcpy(v3, v2);
886 (void) build_name(sgn, v3, RIGHT_VALUE);
887 w1 = Node_List[node_id(v2)].width; /* width of INPUT */
888 if (0L == w1) {
889 w1 = 8L * (long) sizeof(NAPA_DIGITAL_TYPE); /* default width */
890 }
891 w2 = Node_List[out].width; /* width of OUTPUT */
892 if (0L == w2) {
893 w2 = 8L * (long) sizeof(NAPA_DIGITAL_TYPE); /* default width */
894 }
895 if (UNKNOWN_TYPE != constant_type(v1)) { /* constant shift */
896 if (1 != sscanf(v1, "%li", &sh)) {
897 print_error_location("bshift", Node_List[out].mline, Node_List[out].mfile);
898 (void) fprintf(STDERR, " the shift value is not a well-formed positive C long integer <%s>\n", v1);
899 return;
900 }
901 sh = sh % labs(w1);
902 if (0L == sh) {
903 (void) fprintf(STDOUT, " %s = %s;\n", v0, v3);
904 return;
905 }
906 if (right) { /* right barrel constant shift */
907 (void) fprintf(STDOUT, " %s = ((%s & %ldLL) << %ld) | ((%s >> %ld) & %ldLL);\n",
908 v0, v3, (1L << sh) - 1L, (labs(w1)-sh), v3, sh, (1L << (labs(w1)-sh)) - 1L);
909 } else { /* left barrel constant shift */
910 (void) fprintf(STDOUT, " %s = ((%s & %ldLL) << %ld) | ((%s >> %ld) & %ldLL);\n",
911 v0, v3, (1L << (labs(w1)-sh)) - 1L, sh, v3, (labs(w1)-sh), (1L << sh) - 1L);
912 }
913 if (((0L > w1) && (0L < w2)) || ((0L < w1) && (0L > w2))
914 || ((0L > w1) && (w1 > w2)) || ((0L < w1) && (w1 < w2))) { /* width process according to width input ! */
915 if (0L < w1) {
916 ltemp1 = (1L << (w1-1L));
917 ltemp2 = ((2*ltemp1) - 1L);
918 (void) fprintf(STDOUT, " %s = (%s & ( %ldLL))\n", v0, v0, ltemp1);
919 (void) fprintf(STDOUT, " %*s ? (%s | (-%ldLL))\n", (int) strlen(v0), " ", v0, ltemp1);
920 (void) fprintf(STDOUT, " %*s : (%s & ( %ldLL));\n", (int) strlen(v0), " ", v0, ltemp2);
921 } else if (0L > w1) {
922 ltemp1 = (1L << -w1) - 1L;
923 (void) fprintf(STDOUT, " %s &= %ldLL;\n", v0, ltemp1);
924 }
925 Node_List[out].width = 0L; /* width already processed ! */
926 }
927 } else { /* shift driven by variable */
928 (void) fprintf(STDOUT, " %s_s = labs(%s) %% %ldLL;\n", v0, v1, labs(w1));
929 (void) fprintf(STDOUT, " if ( 0L == %s_s ) {\n", v0);
930 (void) fprintf(STDOUT, " %s = %s;\n", v0, v3);
931 (void) fprintf(STDOUT, " } else {\n");
932 if (right) {
933 (void) fprintf(STDOUT, " if ( 0 < %s ) {\n", v1); /* right shift */
934 } else {
935 (void) fprintf(STDOUT, " if ( 0 > %s ) {\n", v1); /* right shift also ! */
936 }
937 (void) fprintf(STDOUT, " %s = ((%s & ((1LL << %s_s)-1LL)) << (%ld-%s_s))\n", v0, v3, v0, labs(w1), v0);
938 (void) fprintf(STDOUT, " %*s | ((%s >> %s_s) & ((1LL << (%ld-%s_s))-1LL));\n", (int) strlen(v0), " ", v3, v0, labs(w1), v0);
939 (void) fprintf(STDOUT, " } else {\n");
940 (void) fprintf(STDOUT, " %s = ((%s & ((1LL << (%ld-%s_s))-1LL)) << %s_s)\n", v0, v3, labs(w1), v0, v0);
941 (void) fprintf(STDOUT, " %*s | ((%s >> (%ld-%s_s)) & ((1LL << %s_s)-1LL));\n", (int) strlen(v0), " ", v3, labs(w1), v0, v0);
942 (void) fprintf(STDOUT, " }\n");
943 if (((0L > w1) && (0L < w2)) || ((0L < w1) && (0L > w2))|| ((0L > w1) && (w1 > w2)) || ((0L < w1) && (w1 < w2))) {
944 /* width process according to width input ! */
945 if (0L < w1) {
946 ltemp1 = (1L << (w1-1L));
947 ltemp2 = ((2*ltemp1) - 1L);
948 (void) fprintf(STDOUT, " %s = (%s & ( %ldLL))\n", v0, v0, ltemp1);
949 (void) fprintf(STDOUT, " %*s ? (%s | (-%ldLL))\n", (int) strlen(v0), " ", v0, ltemp1);
950 (void) fprintf(STDOUT, " %*s : (%s & ( %ldLL));\n", (int) strlen(v0), " ", v0, ltemp2);
951 } else if (0L > w1) {
952 ltemp1 = (1L << -w1) - 1L;
953 (void) fprintf(STDOUT, " %s &= %ldLL;\n", v0, ltemp1);
954 }
955 Node_List[out].width = 0L; /* width already processed ! */
956 }
957 (void) fprintf(STDOUT, " }\n");
958 }
959 return;
960}
961
962
963void print_rlshift(char *str, long out, long k) { /* unprocessed node_val: shift val in_node */
964 char *s = (char*) NULL;
965 char v0[STRLENGTH] = {'\0'};
966 char v1[STRLENGTH] = {'\0'};
967 char v2[STRLENGTH] = {'\0'};
968 char v3[STRLENGTH] = {'\0'};
969 char sgn[2] = {'\0'};
970 long w1;
971 long sh;
972 s = str;
973 (void) strcpy(v0, Node_List[out].name1);
974 (void) build_name("", v0, LEFT_VALUE);
975 s = get_sign_and_token(s, sgn, v1); /* get shift value */
976 (void) build_name("", v1, RIGHT_VALUE);
977 s = get_sign_and_token(s, sgn, v2); /* get input_node */
978 (void) strcpy(v3, v2);
979 (void) build_name(sgn, v3, RIGHT_VALUE);
980 w1 = Node_List[node_id(v2)].width; /* width of input */
981 if (0L == w1) {
982 w1 = 8L * (long) sizeof(NAPA_DIGITAL_TYPE);
983 }
984 if (UNKNOWN_TYPE != constant_type(v1)) {
985 if (1 != sscanf(v1, "%li", &sh)) {
986 print_error_location("shift", Node_List[out].mline, Node_List[out].mfile);
987 (void) fprintf(STDERR, " the shift value is not a well-formed positive C long integer <%s>\n", v1);
988 return;
989 }
990 if ((0L > sh) || (sh >= labs(w1))) {
991 print_error_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
992 (void) fprintf(STDERR, " shift value <%ld> is outside the allowed range [0..%ld]\n", sh, labs(w1)-1L);
993 if ((8L * (long) sizeof(NAPA_DIGITAL_TYPE)) != w1) {
994 (void) fprintf(STDERR, " determined by the width <%ld> of input node <%s>\n", labs(w1), v2);
995 }
996 return;
997 }
998 if (0L == sh) {
999 (void) fprintf(STDOUT, " %s = %s;\n", v0, v3);
1000 return;
1001 }
1002 switch (k) {
1003 case LSHIFT_KIND:
1004 (void) fprintf(STDOUT, " %s = %s << %ld;\n", v0, v3, sh);
1005 break;
1006 case RSHIFT_KIND:
1007 (void) fprintf(STDOUT, " %s = %s >> %ld;\n", v0, v3, sh);
1008 break;
1009 default:
1010 break;
1011 }
1012 } else {
1013 switch (k) {
1014 case LSHIFT_KIND:
1015 (void) fprintf(STDOUT, " %s = %s << %s;\n", v0, v3, v1);
1016 break;
1017 case RSHIFT_KIND:
1018 (void) fprintf(STDOUT, " %s = %s >> %s;\n", v0, v3, v1);
1019 break;
1020 default:
1021 break;
1022 }
1023 }
1024 return;
1025}
1026
1027
1028void print_rshift1(char *str, long out) { /* unprocessed node_value: shift val input_node */
1029 char *s = (char*) NULL;
1030 char *nm = (char*) NULL;
1031 char v0[STRLENGTH] = {'\0'};
1032 char v1[STRLENGTH] = {'\0'};
1033 char v2[STRLENGTH] = {'\0'};
1034 char v3[STRLENGTH] = {'\0'};
1035 char sgn[2] = {'\0'};
1036 long w1;
1037 long sh;
1038 double dtemp2;
1039 s = str;
1040 nm = Node_List[out].name1;
1041 (void) strcpy(v0, nm);
1042 (void) build_name("", v0, LEFT_VALUE);
1043 s = get_sign_and_token(s, sgn, v1); /* get shift value */
1044 (void) build_name("", v1, RIGHT_VALUE);
1045 s = get_sign_and_token(s, sgn, v2); /* get input_node */
1046 (void) strcpy(v3, v2);
1047 (void) build_name(sgn, v3, RIGHT_VALUE);
1048 w1 = Node_List[node_id(v2)].width; /* width of input */
1049 if (0L == w1) {
1050 w1 = 8L * (long) sizeof(NAPA_DIGITAL_TYPE);
1051 }
1052 if (UNKNOWN_TYPE != constant_type(v1)) {
1053 if (1 != sscanf(v1, "%li", &sh)) {;
1054 print_error_location("shift", Node_List[out].mline, Node_List[out].mfile);
1055 (void) fprintf(STDERR, " the shift value is not a well-formed positive C long integer <%s>\n", v1);
1056 return;
1057 }
1058 if ((0L > sh) || (sh >= labs(w1))) {
1059 print_error_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
1060 (void) fprintf(STDERR, " shift value <%ld> is outside the allowed range [0..%ld]\n", sh, labs(w1)-1L);
1061 if ((8L * (long) sizeof(NAPA_DIGITAL_TYPE)) != w1) {
1062 (void) fprintf(STDERR, " determined by the width <%ld> of input node <%s>\n", labs(w1), v2);
1063 }
1064 return;
1065 }
1066 if (0L == sh) {
1067 (void) fprintf(STDOUT, " %s = %s;\n", v0, v3);
1068 return;
1069 }
1070 dtemp2 = (double) (1L << sh);
1071 (void) fprintf(STDOUT, " %s = (0LL > %s)\n", v0, v3);
1072 (void) fprintf(STDOUT, " %*s ? (I_TYPE) ((((R_TYPE) %s)/%.1f) - 0.5)\n", (int) strlen(v0), " ", v3, dtemp2);
1073 (void) fprintf(STDOUT, " %*s : (I_TYPE) ((((R_TYPE) %s)/%.1f) + 0.5);\n", (int) strlen(v0), " ", v3, dtemp2);
1074 } else {
1075 (void) fprintf(STDOUT, " dnode_%s_s = ((R_TYPE) %s) / ((R_TYPE) (1LL << %s));\n", nm, v3, v1);
1076 (void) fprintf(STDOUT, " %s = (0LL > %s)\n", v0, v3);
1077 (void) fprintf(STDOUT, " %*s ? (I_TYPE) (dnode_%s_s - 0.5)\n", (int) strlen(v0), " ", nm);
1078 (void) fprintf(STDOUT, " %*s : (I_TYPE) (dnode_%s_s + 0.5);\n", (int) strlen(v0), " ", nm);
1079 }
1080 return;
1081}
1082
1083
1084void print_rshift2(char *str, long out) { /* unprocessed node_value: shift value input_node */
1085 char *s = (char*) NULL;
1086 char *nm = (char*) NULL;
1087 char v0[STRLENGTH] = {'\0'};
1088 char v1[STRLENGTH] = {'\0'};
1089 char v2[STRLENGTH] = {'\0'};
1090 char v3[STRLENGTH] = {'\0'};
1091 char sgn[2] = {'\0'};
1092 long w1;
1093 long sh;
1094 double dtemp2;
1095 s = str;
1096 nm = Node_List[out].name1;
1097 (void) strcpy(v0, nm);
1098 (void) build_name("", v0, LEFT_VALUE);
1099 s = get_sign_and_token(s, sgn, v1); /* get shift value */
1100 (void) build_name("", v1, RIGHT_VALUE);
1101 s = get_sign_and_token(s, sgn, v2); /* get input_node */
1102 (void) strcpy(v3, v2);
1103 (void) build_name(sgn, v3, RIGHT_VALUE);
1104 w1 = Node_List[node_id(v2)].width; /* width of input */
1105 if (0L == w1) {
1106 w1 = 8L * (long) sizeof(NAPA_DIGITAL_TYPE);
1107 }
1108 if (UNKNOWN_TYPE != constant_type(v1)) {
1109 if (1 != sscanf(v1, "%li", &sh)) {
1110 print_error_location("shift", Node_List[out].mline, Node_List[out].mfile);
1111 (void) fprintf(STDERR, " the shift value is not a well-formed positive C long integer <%s>\n", v1);
1112 return;
1113 }
1114 if ((0L > sh) || (sh >= labs(w1))) {
1115 print_error_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
1116 (void) fprintf(STDERR, " shift value <%ld> is outside the allowed range [0..%ld]\n", sh, labs(w1)-1L);
1117 if ((8L * (long) sizeof(NAPA_DIGITAL_TYPE)) != w1) {
1118 (void) fprintf(STDERR, " determined by the width <%ld> of input node <%s>\n", labs(w1), v2);
1119 }
1120 return;
1121 }
1122 if (0L == sh) {
1123 (void) fprintf(STDOUT, " %s = %s;\n", v0, v3);
1124 return;
1125 }
1126 dtemp2 = (double) (1L << sh);
1127 (void) fprintf(STDOUT, " if ( 0LL > %s ) {\n", v3);
1128 (void) fprintf(STDOUT, " dnode_%s_d = -((R_TYPE) %s) / %.1f;\n", nm, v3, dtemp2);
1129 (void) fprintf(STDOUT, " %s_l = (I_TYPE) dnode_%s_d;\n", v0, nm);
1130 (void) fprintf(STDOUT, " dnode_%s_r = dnode_%s_d - ((R_TYPE) %s_l);\n", nm, nm, v0);
1131 (void) fprintf(STDOUT, " if ( ISEVEN(%s_l) && (0.5 == dnode_%s_r) ) {\n", v0, nm);
1132 (void) fprintf(STDOUT, " %s = -%s_l;\n", v0, v0);
1133 (void) fprintf(STDOUT, " } else {\n");
1134 (void) fprintf(STDOUT, " %s = -(I_TYPE) (dnode_%s_d + 0.5);\n", v0, nm);
1135 (void) fprintf(STDOUT, " }\n");
1136 (void) fprintf(STDOUT, " } else {\n");
1137 (void) fprintf(STDOUT, " dnode_%s_d = ((R_TYPE) %s) / %.1f;\n", nm, v3, dtemp2);
1138 (void) fprintf(STDOUT, " %s_l = (I_TYPE) dnode_%s_d;\n", v0, nm);
1139 (void) fprintf(STDOUT, " dnode_%s_r = dnode_%s_d - ((R_TYPE) %s_l);\n", nm, nm, v0);
1140 (void) fprintf(STDOUT, " if ( ISEVEN(%s_l) && (0.5 == dnode_%s_r) ) {\n", v0, nm);
1141 (void) fprintf(STDOUT, " %s = %s_l;\n", v0, v0);
1142 (void) fprintf(STDOUT, " } else {\n");
1143 (void) fprintf(STDOUT, " %s = (I_TYPE) (dnode_%s_d + 0.5);\n", v0, nm);
1144 (void) fprintf(STDOUT, " }\n");
1145 (void) fprintf(STDOUT, " }\n");
1146 } else {
1147 (void) fprintf(STDOUT, " if ( 0LL <= %s ) {\n", v3);
1148 (void) fprintf(STDOUT, " dnode_%s_d = (R_TYPE) %s / ((R_TYPE) (1LL << %s));\n", nm, v3, v1);
1149 (void) fprintf(STDOUT, " %s_l = (I_TYPE) dnode_%s_d;\n", v0, nm);
1150 (void) fprintf(STDOUT, " dnode_%s_r = dnode_%s_d - ((R_TYPE) %s_l);\n", nm, nm, v0);
1151 (void) fprintf(STDOUT, " if ( ISEVEN(%s_l) && (0.5 == dnode_%s_r) ) {\n", v0, nm);
1152 (void) fprintf(STDOUT, " %s = %s_l;\n", v0, v0);
1153 (void) fprintf(STDOUT, " } else {\n");
1154 (void) fprintf(STDOUT, " %s = (I_TYPE) (dnode_%s_d + 0.5);\n", v0, nm);
1155 (void) fprintf(STDOUT, " }\n");
1156 (void) fprintf(STDOUT, " } else {\n");
1157 (void) fprintf(STDOUT, " dnode_%s_d = -((R_TYPE) %s) / ((R_TYPE) (1LL << %s));\n", nm, v3, v1);
1158 (void) fprintf(STDOUT, " %s_l = (I_TYPE) dnode_%s_d;\n", v0, nm);
1159 (void) fprintf(STDOUT, " dnode_%s_r = dnode_%s_d - ((R_TYPE) %s_l);\n", nm, nm, v0);
1160 (void) fprintf(STDOUT, " if ( ISEVEN(%s_l) && (0.5 == dnode_%s_r) ) {\n", v0, nm);
1161 (void) fprintf(STDOUT, " %s = -%s_l;\n", v0, v0);
1162 (void) fprintf(STDOUT, " } else {\n");
1163 (void) fprintf(STDOUT, " %s = -(I_TYPE) (dnode_%s_d + 0.5);\n", v0, nm);
1164 (void) fprintf(STDOUT, " }\n");
1165 (void) fprintf(STDOUT, " }\n");
1166 }
1167 return;
1168}
1169
1170
1171void print_clock(char *str, long out) { /* unprocessed node_value: input_val width */
1172 int flag;
1173 long itemp;
1174 char *s = (char*) NULL;
1175 char *nm = (char*) NULL;
1176 char v0[STRLENGTH] = {'\0'};
1177 char v1[STRLENGTH] = {'\0'};
1178 char v2[STRLENGTH] = {'\0'};
1179 char sgn[2] = {'\0'};
1180 s = str;
1181 s = get_sign_and_token(s, sgn, v1); /* skip pattern */
1182 s = get_sign_and_token(s, sgn, v2); /* get width */
1183 nm = Node_List[out].name1;
1184 (void) strcpy(v0, nm);
1185 (void) build_name("", v0, LEFT_VALUE);
1186 flag = sscanf(v2, "%li", &itemp);
1187 if ((1 == flag) && (1L == itemp)) { /* width = 1: simpler implementation */
1188 (void) fprintf(STDOUT, " if ( %ldL <= pnode_%s_ptr1 ) {\n", Node_List[out].ID2, nm);
1189 (void) fprintf(STDOUT, " pnode_%s_ptr1 = pnode_%s_ini;\n", nm, nm);
1190 (void) fprintf(STDOUT, " }\n");
1191 (void) fprintf(STDOUT, " %s = %s_clock[pnode_%s_ptr1];\n", v0, v0, nm);
1192 (void) fprintf(STDOUT, " pnode_%s_ptr1++;\n", nm);
1193 } else {
1194 (void) fprintf(STDOUT, " pnode_%s_ptr2++;\n", nm);
1195 (void) fprintf(STDOUT, " if ( pnode_%s_width <= pnode_%s_ptr2 ) {\n", nm, nm);
1196 (void) fprintf(STDOUT, " pnode_%s_ptr1++;\n", nm);
1197 (void) fprintf(STDOUT, " pnode_%s_ptr2 = 0L;\n", nm);
1198 (void) fprintf(STDOUT, " }\n");
1199 (void) fprintf(STDOUT, " if ( %ldL <= pnode_%s_ptr1 ) {\n", Node_List[out].ID2, nm);
1200 (void) fprintf(STDOUT, " pnode_%s_ptr1 = pnode_%s_ini;\n", nm, nm);
1201 (void) fprintf(STDOUT, " }\n");
1202 (void) fprintf(STDOUT, " %s = %s_clock[pnode_%s_ptr1];\n", v0, v0, nm);
1203 }
1204 return;
1205}
1206
1207
1208void print_inv(char *str, long out) { /* unprocessed node_value: input_node */
1209 char *s = (char*) NULL;
1210 char v0[STRLENGTH] = {'\0'};
1211 char v1[STRLENGTH] = {'\0'};
1212 char sgn[2] = {'\0'};
1213 s = str;
1214 (void) strcpy(v0, Node_List[out].name1);
1215 (void) build_name("", v0, LEFT_VALUE);
1216 s = get_sign_and_token(s, sgn, v1);
1217 (void) build_name("", v1, RIGHT_VALUE);
1218 (void) fprintf(STDOUT, " %s = (I_TYPE) !(%s);\n", v0, v1);
1219 return;
1220}
1221
1222
1223void print_buf(char *str, long out) { /* unprocessed node_value: input_node */
1224 char *s = (char*) NULL;
1225 char v0[STRLENGTH] = {'\0'};
1226 char v1[STRLENGTH] = {'\0'};
1227 char sgn[2] = {'\0'};
1228 s = str;
1229 (void) strcpy(v0, Node_List[out].name1);
1230 (void) build_name("", v0, LEFT_VALUE);
1231 s = get_sign_and_token(s, sgn, v1);
1232 (void) build_name("", v1, RIGHT_VALUE);
1233 (void) fprintf(STDOUT, " %s = (I_TYPE) (0LL != %s);\n", v0, v1);
1234 return;
1235}
1236
1237
1238void print_toggle(char *str, long out) { /* unprocessed node_value: input_node */
1239 char *s = (char*) NULL;
1240 char v0[STRLENGTH] = {'\0'};
1241 char v1[STRLENGTH] = {'\0'};
1242 char sgn[2] = {'\0'};
1243 s = str;
1244 (void) strcpy(v0, Node_List[out].name1);
1245 (void) build_name("", v0, LEFT_VALUE);
1246 s = get_sign_and_token(s, sgn, v1);
1247 if (ISEMPTY(v1)) {
1248 (void) fprintf(STDOUT, " %s = (I_TYPE) !(%s);\n", v0, v0); /* unconditional toggle */
1249 } else {
1250 (void) build_name("", v1, RIGHT_VALUE);
1251 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v1);
1252 (void) fprintf(STDOUT, " %s = (I_TYPE) !(%s);\n", v0, v0);
1253 (void) fprintf(STDOUT, " }\n");
1254 }
1255 return;
1256}
1257
1258
1259void print_bwinv(char *str, long out) { /* unprocessed node_value: input_node */
1260 char *s = (char*) NULL;
1261 char v0[STRLENGTH] = {'\0'};
1262 char v1[STRLENGTH] = {'\0'};
1263 char sgn[2] = {'\0'};
1264 s = str;
1265 (void) strcpy(v0, Node_List[out].name1);
1266 (void) build_name("", v0, LEFT_VALUE);
1267 s = get_sign_and_token(s, sgn, v1);
1268 (void) build_name("", v1, RIGHT_VALUE);
1269 (void) fprintf(STDOUT, " %s = ~(%s);\n", v0, v1);
1270 return;
1271}
1272
1273
1274void print_rip(char *str, long out) { /* unprocessed node_value: mask input_node */
1275 char *s = (char*) NULL;
1276 char v0[STRLENGTH] = {'\0'};
1277 char v1[STRLENGTH] = {'\0'};
1278 char v2[STRLENGTH] = {'\0'};
1279 char v3[STRLENGTH] = {'\0'};
1280 char sgn[2] = {'\0'};
1281 long i, j;
1282 long w1;
1283 unsigned long long msk;
1284 s = str;
1285 (void) strcpy(v0, Node_List[out].name1);
1286 (void) build_name("", v0, LEFT_VALUE);
1287 s = get_sign_and_token(s, sgn, v1);
1288 if (1 != sscanf(v1, "0x%llx", &msk)) {;
1289 print_error_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
1290 (void) fprintf(STDERR, " mask <%s> is not a valid hexadecimal constant\n", v1);
1291 return;
1292 }
1293 s = get_sign_and_token(s, sgn, v2);
1294 (void) strcpy(v3, v2);
1295 (void) build_name(sgn, v3, RIGHT_VALUE);
1296 w1 = Node_List[node_id(v2)].width;
1297 if (0L == w1) {
1298 w1 = 8L * (long) sizeof(NAPA_DIGITAL_TYPE);
1299 }
1300 j = 0L;
1301 for (i = 0L; i < (8L * ((long) sizeof(NAPA_DIGITAL_TYPE))); i++) {
1302 if (0L != ((msk >> i) & 1L)) {
1303 if (i >= labs(w1)) {
1304 print_error_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
1305 (void) fprintf(STDERR, " mask <%s> selects a bit row [0..%ld] outside the allowed range\n", v1, labs(w1)-1L);
1306 (void) fprintf(STDERR, " determined by the width <%ld> of input node <%s>\n", labs(w1), v2);
1307 return;
1308 }
1309 if (0L == j) {
1310 if (0L == i) {
1311 (void) fprintf(STDOUT, " %s = (%s & 1LL);\n", v0, v3);
1312 } else {
1313 (void) fprintf(STDOUT, " %s = ((%s >> %2ld) & 1LL);\n", v0, v3, i);
1314 }
1315 } else {
1316 (void) fprintf(STDOUT, " %s += ((%s >> %2ld) & 1LL) * %ld;\n", v0, v3, i, (1L << j));
1317 }
1318 j++;
1319 }
1320 }
1321 if (0L == j) {
1322 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
1323 }
1324 return;
1325}
1326
1327
1328/* FZBUF(A,B) = A */
1329
1330void print_fzbuf(char *str, long out) { /* unprocessed node_value: input_node */
1331 char *s = (char*) NULL;
1332 char v0[STRLENGTH] = {'\0'};
1333 char v1[STRLENGTH] = {'\0'};
1334 char sgn[2] = {'\0'};
1335 s = str;
1336 (void) strcpy(v0, Node_List[out].name1);
1337 (void) build_name("", v0, LEFT_VALUE);
1338 s = get_sign_and_token(s, sgn, v1);
1339 (void) build_name("", v1, RIGHT_VALUE);
1340 (void) fprintf(STDOUT, " %s = CLIP(%s, 0.0, 1.0);\n", v0, v1);
1341 return;
1342}
1343
1344
1345/* FZNOT(A,B) = 1 - A */
1346
1347void print_fzinv(char *str, long out) { /* unprocessed node_value: input_node */
1348 char *s = (char*) NULL;
1349 char v0[STRLENGTH] = {'\0'};
1350 char v1[STRLENGTH] = {'\0'};
1351 char sgn[2] = {'\0'};
1352 s = str;
1353 (void) strcpy(v0, Node_List[out].name1);
1354 (void) build_name("", v0, LEFT_VALUE);
1355 s = get_sign_and_token(s, sgn, v1);
1356 (void) build_name("", v1, RIGHT_VALUE);
1357 (void) fprintf(STDOUT, " %s = CLIP(1.0 - %s, 0.0, 1.0);\n", v0, v1);
1358 return;
1359}
1360
1361
1362void print_alu(char *str, long out) { /* unprocessed : opcode_owner opcode_node in_node.. */
1363 char *s = (char*) NULL;
1364 char *t = (char*) NULL;
1365 char v0[STRLENGTH] = {'\0'};
1366 char v1[STRLENGTH] = {'\0'};
1367 char v2[STRLENGTH] = {'\0'};
1368 char v3[STRLENGTH] = {'\0'};
1369 char v4[STRLENGTH] = {'\0'};
1370 char v5[STRLENGTH] = {'\0'};
1371 char v6[STRLENGTH] = {'\0'};
1372 long d, i, j, m;
1373 int flag;
1374 s = str;
1375 (void) strcpy(v0, Node_List[out].name1);
1376 (void) build_name("", v0, LEFT_VALUE);
1377 s = get_token(s, v1, false); /* v1 contains the opcode owner name */
1378 s = get_token(s, v2, false); /* v2 contains the opcode node name */
1379 (void) strcpy(v6, v2);
1380 (void) build_name("", v2, RIGHT_VALUE);
1381 (void) strcpy(v3, s); /* v3 contains the list of input names */
1382 (void) fprintf(STDOUT, " switch (%s) {\n", v2);
1383 for (i = 0L; i < Num_Opcodes; i++) {
1384 if (0 == strcmp(Opcode_List[i].name, v1)) { /* owner corresponds to opcode definition */
1385 (void) fprintf(STDOUT, " case %ld:\n", Opcode_List[i].code);
1386 s = Opcode_List[i].function; /* get opcode template e.g. (#1 + #2) */
1387 if (ISNOTEMPTY(s)) {
1388 (void) fprintf(STDOUT, " %s =", v0);
1389 for (;;) {
1390 s = get_token(s, v4, true); /* scan template, token by token */
1391 if (ISEMPTY(v4)) {
1392 (void) fprintf(STDOUT, ";\n");
1393 break;
1394 }
1395 if ('#'== v4[0]) { /* a token beginning by '#' is a dummy entry */
1396 t = v4 + 1; /* number of dummy entry is following '#' */
1397 flag = sscanf(t, "%li", &m); /* rank of input */
1398 if ((1 != flag) || (0L > m)) {
1399 print_error_location("opcode", Opcode_List[i].mline, Opcode_List[i].mfile);
1400 (void) fprintf(STDERR, " illegal symbol inside template <%s> of opcode %ld of alu <%s>\n",
1401 Opcode_List[i].function, Opcode_List[i].code, Opcode_List[i].name);
1402 (void) fprintf(STDOUT, ";\n");
1403 return;
1404 }
1405 t = v3; /* find the corresponding input name */
1406 for (j = 0L; j < m; j++) {
1407 t = get_token(t, v5, false);
1408 if (ISEMPTY(v5)) {
1409 print_error_location("opcode", Opcode_List[i].mline, Opcode_List[i].mfile);
1410 (void) fprintf(STDERR, " mismatch between templates and arguments for opcode %ld of alu <%s>\n",
1411 Opcode_List[i].code, Opcode_List[i].name);
1412 (void) fprintf(STDOUT, ";\n");
1413 return;
1414 }
1415 (void) build_name("", v5, RIGHT_VALUE); /* contains replacement for ith input */
1416 }
1417 } else { /* other tokens are simply copied */
1418 (void) strcpy(v5, v4);
1419 }
1420 (void) fprintf(STDOUT, " %s", v5);
1421 }
1422 }
1423 (void) fprintf(STDOUT, " break;\n");
1424 }
1425 }
1426 (void) fprintf(STDOUT, " default:\n");
1427 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (alu)\\n\");\n");
1428 if (!Cmdline_Flag) {
1429 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", Node_List[out].mline[0]);
1430 for (d = 1L; d < MAXDEPTH; d++) {
1431 if (0UL == Node_List[out].mline[d]) {
1432 break;
1433 }
1434 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
1435 Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
1436 }
1437 }
1438 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n unexpected value <%%lld> for opcode <%s>\\n\", %s);\n", v6, v2);
1439 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
1440 (void) fprintf(STDOUT, " }\n");
1441 return;
1442}
1443
1444
1445void print_average(char *str, long out) { /* unprocessed: sgn_in_node sgn_in_node... */
1446 char *s = (char*) NULL;
1447 char tok[STRLENGTH] = {'\0'};
1448 char v0[STRLENGTH] = {'\0'};
1449 char v1[STRLENGTH] = {'\0'};
1450 char v2[STRLENGTH] = {'\0'};
1451 char v3[STRLENGTH] = {'\0'};
1452 long n;
1453 int first;
1454 s = str;
1455 (void) strcpy(v0, Node_List[out].name1);
1456 (void) build_name("", v0, LEFT_VALUE);
1457 (void) fprintf(STDOUT, " %s =", v0);
1458 (void) strcpy(v2, "");
1459 first = true;
1460 n = 0L;
1461 for (;;) {
1462 s = get_token(s, tok, false); /* sign or input node name */
1463 n++;
1464 if (ISEMPTY(tok)) {
1465 (void) fprintf(STDOUT, ";\n");
1466 if (((char*) NULL) != strstr(Node_List[out].option, "geometric")) {
1467 (void) fprintf(STDOUT, " %s = ROOT(%s, %g.0);\n", v0, v0, (double)(n-1L));
1468 } else if (((char*) NULL) != strstr(Node_List[out].option, "harmonic" )) {
1469 (void) fprintf(STDOUT, " %s = 1.0 / %s;\n", v0, v0);
1470 (void) fprintf(STDOUT, " %s *= %.15e;\n", v0, 1.0/((double)(n-1L)));
1471 } else if (((char*) NULL) != strstr(Node_List[out].option, "rms" )) {
1472 (void) fprintf(STDOUT, " %s = sqrt(%s * %.15e);\n", v0, v0, 1.0/((double)(n-1L)));
1473 } else {
1474 (void) fprintf(STDOUT, " %s *= %.15e;\n", v0, 1.0/((double)(n-1L)));
1475 }
1476 return;
1477 }
1478 if (2L < n) {
1479 (void) fprintf(STDOUT, ";\n");
1480 break;
1481 }
1482 if (first) {
1483 (void) strcat(v2, "(");
1484 if (0 == strcmp(tok, "+")) {
1485 s = get_token(s, v1, false);
1486 } else if (0 == strcmp(tok, "-")) {
1487 s = get_token(s, v1, false);
1488 (void) strcat(v2, "-");
1489 } else {
1490 (void) strcpy(v1, tok);
1491 }
1492 (void) strcpy(v3, ")");
1493 first = false;
1494 } else {
1495 if (((char*) NULL) != strstr(Node_List[out].option, "geometric")) {
1496 (void) strcpy(v2, "* (");
1497 } else {
1498 (void) strcpy(v2, "+ (");
1499 }
1500 if (0 == strcmp(tok, "+")) {
1501 s = get_token(s, v1, false);
1502 } else if (0 == strcmp(tok, "-")) {
1503 s = get_token(s, v1, false);
1504 (void) strcat(v2, "-");
1505 } else {
1506 (void) strcpy(v1, tok);
1507 }
1508 }
1509 (void) build_name("", v1, RIGHT_VALUE);
1510 if (((char*) NULL) != strstr(Node_List[out].option, "harmonic" )) {
1511 (void) fprintf(STDOUT, " %s1.0 / MAX(EPSILON, %s)%s", v2, v1, v3);
1512 } else if (((char*) NULL) != strstr(Node_List[out].option, "geometric")) {
1513 (void) fprintf(STDOUT, " %sMAX(0.0, %s)%s", v2, v1, v3);
1514 } else if (((char*) NULL) != strstr(Node_List[out].option, "rms" )) {
1515 (void) fprintf(STDOUT, " %s%s * %s%s", v2, v1, v1, v3);
1516 } else {
1517 (void) fprintf(STDOUT, " %s%s%s", v2, v1, v3);
1518 }
1519 }
1520 first = true;
1521 for (;;) {
1522 if (!first) {
1523 s = get_token(s, tok, false);
1524 if (ISEMPTY(tok)) {
1525 (void) fprintf(STDOUT, ";\n");
1526 if (((char*) NULL) != strstr(Node_List[out].option, "geometric")) {
1527 (void) fprintf(STDOUT, " %s = ROOT(%s, %g.0);\n", v0, v0, (double)(n-1L));
1528 } else if (((char*) NULL) != strstr(Node_List[out].option, "harmonic")) {
1529 (void) fprintf(STDOUT, " %s = 1.0 / %s;\n", v0, v0);
1530 (void) fprintf(STDOUT, " %s *= %.15e;\n", v0, 1.0/((double)(n-1L)));
1531 } else if (((char*) NULL) != strstr(Node_List[out].option, "rms")) {
1532 (void) fprintf(STDOUT, " %s = sqrt(%s * %.15e);\n", v0, v0, 1.0/((double)(n-1L)));
1533 } else {
1534 (void) fprintf(STDOUT, " %s *= %.15e;\n", v0, 1.0/((double)(n-1L)));
1535 }
1536 return;
1537 }
1538 }
1539 n++;
1540 (void) fprintf(STDOUT, " %s = (%s)", v0, v0);
1541 first = false;
1542 if (((char*) NULL) != strstr(Node_List[out].option, "geometric")) {
1543 (void) strcpy(v2, "* (");
1544 } else {
1545 (void) strcpy(v2, "+ (");
1546 }
1547 if (0 == strcmp(tok, "+")) {
1548 s = get_token(s, v1, false);
1549 } else if (0 == strcmp(tok, "-")) {
1550 s = get_token(s, v1, false);
1551 (void) strcat(v2, "-");
1552 } else {
1553 (void) strcpy(v1, tok);
1554 }
1555 (void) build_name("", v1, RIGHT_VALUE);
1556 if (((char*) NULL) != strstr(Node_List[out].option, "harmonic")) {
1557 (void) fprintf(STDOUT, " %s1.0 / MAX(%s, EPSILON)%s", v2, v1, v3);
1558 } else if (((char*) NULL) != strstr(Node_List[out].option, "geometric")) {
1559 (void) fprintf(STDOUT, " %sMAX(%s, 0.0)%s", v2, v1, v3);
1560 } else if (((char*) NULL) != strstr(Node_List[out].option, "rms")) {
1561 (void) fprintf(STDOUT, " %s%s * %s%s", v2, v1, v1, v3);
1562 } else {
1563 (void) fprintf(STDOUT, " %s%s%s", v2, v1, v3);
1564 }
1565 }
1566}
1567
1568
1569void print_copy(char *str, long out) { /* unprocessed: sgn_in_node */
1570 char *s = (char*) NULL;
1571 char tok[STRLENGTH] = {'\0'};
1572 char v0[STRLENGTH] = {'\0'};
1573 char v1[STRLENGTH] = {'\0'};
1574 char v2[STRLENGTH] = {'\0'};
1575 int first;
1576 s = str;
1577 (void) strcpy(v0, Node_List[out].name1);
1578 (void) build_name("", v0, LEFT_VALUE);
1579 (void) fprintf(STDOUT, " %s =", v0);
1580 first = true;
1581 (void) strcpy(v1, "");
1582 for (;;) {
1583 s = get_token(s, tok, false); /* sign or input node name */
1584 if (ISEMPTY(tok)) {
1585 (void) fprintf(STDOUT, ";\n");
1586 break;
1587 }
1588 if (first) {
1589 if (0 == strcmp(tok, "+")) {
1590 s = get_token(s, v2, false);
1591 } else if (0 == strcmp(tok, "-")) {
1592 s = get_token(s, v2, false);
1593 (void) strcat(v1, "-");
1594 } else {
1595 (void) strcpy(v2, tok);
1596 }
1597 first = false;
1598 } else {
1599 (void) strcpy(v2, tok);
1600 }
1601 (void) build_name("", v2, RIGHT_VALUE);
1602 (void) fprintf(STDOUT, " %s%s", v1, v2);
1603 }
1604 return;
1605}
1606
1607
1608void print_dyadic0(char *str, long out, long k) { /* unprocessed: sgn_in_node sgn_in_node... */
1609 char *s = (char*) NULL;
1610 char tok[STRLENGTH] = {'\0'};
1611 char v0[STRLENGTH] = {'\0'};
1612 char v1[STRLENGTH] = {'\0'};
1613 char v2[STRLENGTH] = {'\0'};
1614 char v3[STRLENGTH] = {'\0'};
1615 long n;
1616 int first;
1617 s = str;
1618 (void) strcpy(v0, Node_List[out].name1);
1619 (void) build_name("", v0, LEFT_VALUE);
1620 (void) fprintf(STDOUT, " %s =", v0);
1621 (void) strcpy(v2, "");
1622 first = true;
1623 n = 0L;
1624 for (;;) {
1625 s = get_token(s, tok, false); /* sign or input node name */
1626 n++;
1627 if (ISEMPTY(tok)) {
1628 (void) fprintf(STDOUT, ";\n");
1629 return;
1630 }
1631 if (2L < n) {
1632 (void) fprintf(STDOUT, ";\n");
1633 break;
1634 }
1635 if (first) {
1636 (void) strcat(v2, "(");
1637 if (0 == strcmp(tok, "+")) {
1638 s = get_token(s, v1, false);
1639 } else if (0 == strcmp(tok, "-")) {
1640 s = get_token(s, v1, false);
1641 (void) strcat(v2, "-");
1642 } else {
1643 (void) strcpy(v1, tok);
1644 }
1645 (void) strcpy(v3, ")");
1646 first = false;
1647 } else {
1648 switch (k) {
1649 case SUM_KIND:
1650 (void) strcpy(v2, "+ (");
1651 break;
1652 case PROD_KIND:
1653 (void) strcpy(v2, "* (");
1654 break;
1655 default:
1656 break;
1657 }
1658 if (0 == strcmp(tok, "+")) {
1659 s = get_token(s, v1, false);
1660 } else if (0 == strcmp(tok, "-")) {
1661 s = get_token(s, v1, false);
1662 (void) strcat(v2, "-");
1663 } else {
1664 (void) strcpy(v1, tok);
1665 }
1666 }
1667 (void) build_name("", v1, RIGHT_VALUE);
1668 (void) fprintf(STDOUT, " %s%s%s", v2, v1, v3);
1669 }
1670 first = true;
1671 for (;;) {
1672 if (!first) {
1673 s = get_token(s, tok, false);
1674 if (ISEMPTY(tok)) {
1675 if ((0L != Node_List[out].width) && (PROD_KIND != k)) {
1676 print_warning_location("width limitation", Node_List[out].mline, Node_List[out].mfile);
1677 (void) fprintf(STDERR, " the node <%s> is too complex to model accurately the under/overflow\n", Node_List[out].name1);
1678 (void) fprintf(STDERR, " behavior of an actual realization, we suggest to limit these nodes to 2 inputs\n\n");
1679 }
1680 return;
1681 }
1682 }
1683 n++;
1684 (void) fprintf(STDOUT, " %s = (%s)", v0, v0);
1685 (void) strcpy(v2, "");
1686 first = false;
1687 switch (k) {
1688 case SUM_KIND:
1689 (void) strcpy(v2, "+ (");
1690 break;
1691 case PROD_KIND:
1692 (void) strcpy(v2, "* (");
1693 break;
1694 default:
1695 break;
1696 }
1697 if (0 == strcmp(tok, "+")) {
1698 s = get_token(s, v1, false);
1699 } else if (0 == strcmp(tok, "-")) {
1700 s = get_token(s, v1, false);
1701 (void) strcat(v2, "-");
1702 } else {
1703 (void) strcpy(v1, tok);
1704 }
1705 (void) build_name("", v1, RIGHT_VALUE);
1706 (void) fprintf(STDOUT, " %s%s%s;\n", v2, v1, v3);
1707 }
1708}
1709
1710
1711void print_dyadic1(char *str, long out, long k) { /* unprocessed: sgn_in_node sgn_in_node */
1712 char *s = (char*) NULL;
1713 char tok[STRLENGTH] = {'\0'};
1714 char v0[STRLENGTH] = {'\0'};
1715 char v1[STRLENGTH] = {'\0'};
1716 char v2[STRLENGTH] = {'\0'};
1717 char v3[STRLENGTH] = {'\0'};
1718 int first;
1719 s = str;
1720 (void) strcpy(v0, Node_List[out].name1);
1721 (void) build_name("", v0, LEFT_VALUE);
1722 (void) fprintf(STDOUT, " %s =", v0);
1723 (void) strcpy(v2, "");
1724 first = true;
1725 for (;;) {
1726 s = get_token(s, tok, false); /* sign or input node name */
1727 if (ISEMPTY(tok)) {
1728 (void) fprintf(STDOUT, ";\n");
1729 break;
1730 }
1731 if (first) {
1732 (void) strcat(v2, "(");
1733 if (0 == strcmp(tok, "+")) {
1734 s = get_token(s, v1, false);
1735 } else if (0 == strcmp(tok, "-")) {
1736 s = get_token(s, v1, false);
1737 (void) strcat(v2, "-");
1738 } else {
1739 (void) strcpy(v1, tok);
1740 }
1741 (void) strcpy(v3, ")");
1742 first = false;
1743 } else {
1744 if (SUB_KIND == k) {
1745 (void) strcpy(v2, "- (");
1746 }
1747 if (0 == strcmp(tok, "+")) {
1748 s = get_token(s, v1, false);
1749 } else if (0 == strcmp(tok, "-")) {
1750 s = get_token(s, v1, false);
1751 (void) strcat(v2, "-");
1752 } else {
1753 (void) strcpy(v1, tok);
1754 }
1755 }
1756 (void) build_name("", v1, RIGHT_VALUE);
1757 (void) fprintf(STDOUT, " %s%s%s", v2, v1, v3);
1758 }
1759 return;
1760}
1761
1762
1763void print_dyadic2(char *str, long out, long k) { /* unprocessed: input_node input_node... */
1764 char *s = (char*) NULL;
1765 char v0[STRLENGTH] = {'\0'};
1766 char v1[STRLENGTH] = {'\0'};
1767 char v2[STRLENGTH] = {'\0'};
1768 int first;
1769 s = str;
1770 (void) strcpy(v0, Node_List[out].name1);
1771 (void) build_name("", v0, LEFT_VALUE);
1772 (void) fprintf(STDOUT, " %s = (I_TYPE) ", v0);
1773 if ((NAND_KIND == k) || (NOR_KIND == k)) {
1774 (void) fprintf(STDOUT, "!(");
1775 } else {
1776 (void) fprintf(STDOUT, "(");
1777 }
1778 first = true;
1779 for (;;) {
1780 s = get_token(s, v2, false); /* input node name */
1781 if (ISEMPTY(v2)) {
1782 (void) fprintf(STDOUT, ");\n");
1783 break;
1784 }
1785 if (first) {
1786 (void) strcpy(v1, "");
1787 first = false;
1788 } else {
1789 if ((AND_KIND == k) || (NAND_KIND == k)) {
1790 (void) strcpy(v1, " && ");
1791 }
1792 if ((OR_KIND == k) || (NOR_KIND == k) ) {
1793 (void) strcpy(v1, " || ");
1794 }
1795 }
1796 (void) build_name("", v2, RIGHT_VALUE);
1797 (void) fprintf(STDOUT, "%s%s", v1, v2);
1798 }
1799 return;
1800}
1801
1802
1803void print_dyadic3(char *str, long out, long k) { /* unprocessed: input_node input_node... */
1804 char *s = (char*) NULL;
1805 char v0[STRLENGTH] = {'\0'};
1806 char v1[STRLENGTH] = {'\0'};
1807 char v2[STRLENGTH] = {'\0'};
1808 int first;
1809 s = str;
1810 (void) strcpy(v0, Node_List[out].name1);
1811 (void) build_name("", v0, LEFT_VALUE);
1812 (void) fprintf(STDOUT, " %s = ", v0);
1813 if ((BWNAND_KIND == k) || (BWNOR_KIND == k) || (BWXNOR_KIND == k)) {
1814 (void) fprintf(STDOUT, "~(");
1815 }
1816 first = true;
1817 for (;;) {
1818 s = get_token(s, v2, false); /* input node name */
1819 if (ISEMPTY(v2)) {
1820 if ((BWNAND_KIND == k) || (BWNOR_KIND == k) || (BWXNOR_KIND == k)) {
1821 (void) fprintf(STDOUT, ")");
1822 }
1823 (void) fprintf(STDOUT, ";\n");
1824 break;
1825 }
1826 if (first) {
1827 (void) strcpy(v1, "");
1828 first = false;
1829 } else {
1830 if ((BWAND_KIND == k) || (BWNAND_KIND == k)) {
1831 (void) strcpy(v1, " & ");
1832 }
1833 if ((BWOR_KIND == k) || (BWNOR_KIND == k)) {
1834 (void) strcpy(v1, " | ");
1835 }
1836 if ((BWXOR_KIND == k) || (BWXNOR_KIND == k)) {
1837 (void) strcpy(v1, " ^ ");
1838 }
1839 }
1840 (void) build_name("", v2, RIGHT_VALUE);
1841 (void) fprintf(STDOUT, "%s%s", v1, v2);
1842 }
1843 return;
1844}
1845
1846
1847void print_dyadic4(char *str, long out, long k) { /* unprocessed: input_node input_node... */
1848 char *s = (char*) NULL;
1849 char v0[STRLENGTH] = {'\0'};
1850 char v1[STRLENGTH] = {'\0'};
1851 char v2[STRLENGTH] = {'\0'};
1852 char v3[STRLENGTH] = {'\0'};
1853 int first;
1854 s = str;
1855 (void) strcpy(v0, Node_List[out].name1);
1856 (void) build_name("", v0, LEFT_VALUE);
1857 (void) fprintf(STDOUT, " %s = ", v0);
1858 first = true;
1859 for (;;) {
1860 s = get_token(s, v3, false); /* input node name */
1861 if (ISEMPTY(v3)) {
1862 (void) fprintf(STDOUT, ";\n");
1863 break;
1864 }
1865 if (first) {
1866 (void) strcpy(v1, "(I_TYPE) (");
1867 (void) strcpy(v2, ")");
1868 first = false;
1869 } else {
1870 (void) strcpy(v1, " + (I_TYPE) (");
1871 (void) strcpy(v2, ")");
1872 }
1873 (void) build_name("", v3, RIGHT_VALUE);
1874 (void) fprintf(STDOUT, "%s%s != 0%s", v1, v3, v2);
1875 }
1876 (void) fprintf(STDOUT, " %s = (I_TYPE) ((", v0);
1877 if (XOR_KIND == k) {
1878 (void) fprintf(STDOUT, "%s %% 2LL) != 0LL);\n", v0);
1879 } else if (XNOR_KIND == k) {
1880 (void) fprintf(STDOUT, "%s %% 2LL) == 0LL);\n", v0);
1881 }
1882 return;
1883}
1884
1885
1886/* FZAND(A,B) = min(A, B) */
1887/* FZNAND(A,B) = 1 - min(A, B) */
1888/* FZOR(A,B) = max(A, B) */
1889/* FZNOR(A,B) = 1 - max(A, B) */
1890
1891void print_dyadic5(char *str, long out, long k) { /* unprocessed: input_node [input_node...] */
1892 char *s = (char*) NULL;
1893 char v0[STRLENGTH] = {'\0'};
1894 char v1[STRLENGTH] = {'\0'};
1895 int first;
1896 s = str;
1897 (void) strcpy(v0, Node_List[out].name1);
1898 (void) build_name("", v0, LEFT_VALUE);
1899 first = true;
1900 for (;;) {
1901 s = get_token(s, v1, false); /* input node name */
1902 if (ISEMPTY(v1)) {
1903 break;
1904 }
1905 (void) build_name("", v1, RIGHT_VALUE);
1906 (void) fprintf(STDOUT, " %s = ", v0);
1907 if ((FZAND_KIND == k) || (FZNAND_KIND == k)) {
1908 (void) fprintf(STDOUT, "MIN(%s, ", v1); /* MIN: macro defined at beginning of C code */
1909 }
1910 if ((FZOR_KIND == k) || (FZNOR_KIND == k)) {
1911 (void) fprintf(STDOUT, "MAX(%s, ", v1); /* MAX: macro defined at beginning of C code */
1912 }
1913 if (first) {
1914 s = get_token(s, v1, false); /* input node name */
1915 (void) build_name("", v1, RIGHT_VALUE);
1916 (void) fprintf(STDOUT, "%s);\n", v1);
1917 first = false;
1918 } else {
1919 (void) fprintf(STDOUT, "%s);\n", v0);
1920 }
1921 }
1922 if ((FZNAND_KIND == k) || (FZNOR_KIND == k)) { /* CLIP: a macro defined at beginning of C code */
1923 (void) fprintf(STDOUT, " %s = CLIP(1.0 - %s, 0.0, 1.0);\n", v0, v0);
1924 } else {
1925 (void) fprintf(STDOUT, " %s = CLIP(%s, 0.0, 1.0);\n", v0, v0);
1926 }
1927 return;
1928}
1929
1930
1931/* FZXOR(A,B) = (A OR B) AND NOT (A AND B) = A + B - 2 min(A, B) */
1932/* FZXNOR(A,B) = 1 - (A + B) + 2 min(A, B) */
1933
1934void print_dyadic6(char *str, long out, long k) { /* unprocessed: input_node input_node */
1935 char *s = (char*) NULL;
1936 char v0[STRLENGTH] = {'\0'};
1937 char v1[STRLENGTH] = {'\0'};
1938 char v2[STRLENGTH] = {'\0'};
1939 s = str;
1940 (void) strcpy(v0, Node_List[out].name1);
1941 (void) build_name("", v0, LEFT_VALUE);
1942 s = get_token(s, v1, false); /* first input node name */
1943 (void) build_name("", v1, RIGHT_VALUE);
1944 s = get_token(s, v2, false); /* second input node name */
1945 (void) build_name("", v2, RIGHT_VALUE);
1946 (void) fprintf(STDOUT, " %s = %s + %s - (2.0 * MIN(%s, %s));\n", v0, v1, v2, v1, v2);
1947 if (FZXNOR_KIND == k) { /* CLIP: a macro defined at beginning of C code */
1948 (void) fprintf(STDOUT, " %s = CLIP(1.0 - %s, 0.0, 1.0);\n", v0, v0);
1949 } else {
1950 (void) fprintf(STDOUT, " %s = CLIP(%s, 0.0, 1.0);\n", v0, v0);
1951 }
1952 return;
1953}
1954
1955
1956void print_dyadic7(char *str, long out, long k) { /* unprocessed: sgn_in_node sgn_in_node */
1957 char *s = (char*) NULL;
1958 char tok[STRLENGTH] = {'\0'};
1959 char v0[STRLENGTH] = {'\0'};
1960 char v1[STRLENGTH] = {'\0'};
1961 char v2[STRLENGTH] = {'\0'};
1962 char v3[STRLENGTH] = {'\0'};
1963 char v4[STRLENGTH] = {'\0'};
1964 char v5[STRLENGTH] = {'\0'};
1965 char v6[STRLENGTH] = {'\0'};
1966 long d, type;
1967 long constant;
1968 long long lltemp;
1969 double dtemp;
1970 int flag;
1971 s = str;
1972 type = Node_List[out].type;
1973 (void) strcpy(v0, Node_List[out].name1);
1974 (void) build_name("", v0, LEFT_VALUE);
1975 if ((MOD_KIND == k) && (ANALOG_DATA_TYPE == type)) {
1976 (void) strcpy(v2, "fmod(");
1977 } else {
1978 (void) strcpy(v2, "");
1979 }
1980 (void) strcat(v2, "(");
1981 s = get_token(s, tok, false); /* sign or input node name */
1982 if (0 == strcmp(tok, "+")) {
1983 s = get_token(s, v1, false);
1984 } else if (0 == strcmp(tok, "-")) {
1985 s = get_token(s, v1, false);
1986 (void) strcat(v2, "-");
1987 } else {
1988 (void) strcpy(v1, tok);
1989 }
1990 (void) strcpy(v3, ")");
1991 (void) build_name("", v1, RIGHT_VALUE);
1992 switch (k) {
1993 case DIV_KIND:
1994 (void) strcpy(v5, " / (");
1995 break;
1996 case MOD_KIND:
1997 if (DIGITAL_DATA_TYPE == type) {
1998 (void) strcpy(v5, " % (");
1999 } else {
2000 (void) strcpy(v5, ", (" );
2001 }
2002 break;
2003 default:
2004 break;
2005 }
2006 s = get_token(s, tok, false); /* sign or input node name */
2007 if (0 == strcmp(tok, "+")) {
2008 s = get_token(s, v4, false);
2009 } else if (0 == strcmp(tok, "-")) {
2010 s = get_token(s, v4, false);
2011 (void) strcat(v5, "-");
2012 } else {
2013 (void) strcpy(v4, tok);
2014 }
2015 if ((MOD_KIND == k) && (ANALOG_DATA_TYPE == type)) {
2016 (void) strcat(v6, "))");
2017 } else {
2018 (void) strcat(v6, ")" );
2019 }
2020 (void) build_name("", v4, RIGHT_VALUE);
2021 constant = false;
2022 if (DIGITAL_DATA_TYPE == type) {
2023 flag = sscanf(v4, "%lli", &lltemp);
2024 if (1 == flag) {
2025 (void) snprintf(v4, (size_t) (STRLENGTH-1L), "%lldLL", lltemp);
2026 constant = true;
2027 if (0LL == lltemp) {
2028 switch (k) {
2029 case DIV_KIND:
2030 print_error_location("div", Node_List[out].mline, Node_List[out].mfile);
2031 break;
2032 case MOD_KIND:
2033 print_error_location("mod", Node_List[out].mline, Node_List[out].mfile);
2034 break;
2035 default:
2036 break;
2037 }
2038 (void) fprintf(STDERR, " division by 0!\n");
2039 }
2040 }
2041 } else {
2042 flag = sscanf(v4, "%lf", &dtemp);
2043 if (1 == flag) {
2044 constant = true;
2045 if (ISSMALL(dtemp)) {
2046 switch (k) {
2047 case DIV_KIND:
2048 print_error_location("div", Node_List[out].mline, Node_List[out].mfile);
2049 break;
2050 case MOD_KIND:
2051 print_error_location("mod", Node_List[out].mline, Node_List[out].mfile);
2052 break;
2053 default:
2054 break;
2055 }
2056 (void) fprintf(STDERR, " division by 0.0!\n");
2057 }
2058 }
2059 }
2060 if ((((char*) NULL) == strstr(Node_List[out].option, "nocheck")) && (!constant)) {
2061 if (DIGITAL_DATA_TYPE == type) {
2062 (void) fprintf(STDOUT, " if ( 0LL == %s ) {\n", v4);
2063 } else {
2064 (void) fprintf(STDOUT, " if ( ISSMALL(%s) ) {\n", v4);
2065 }
2066 switch (k) {
2067 case DIV_KIND:
2068 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (div)\\n\");\n");
2069 break;
2070 case MOD_KIND:
2071 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (mod)\\n\");\n");
2072 break;
2073 default:
2074 break;
2075 }
2076 if (!Cmdline_Flag) {
2077 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", Node_List[out].mline[0]);
2078 for (d = 1L; d < MAXDEPTH; d++) {
2079 if (0UL == Node_List[out].mline[d]) {
2080 break;
2081 }
2082 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
2083 Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
2084 }
2085 }
2086 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n division by zero\\n\");\n");
2087 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
2088 (void) fprintf(STDOUT, " }\n");
2089 }
2090 (void) fprintf(STDOUT, " %s = %s%s%s%s%s%s;\n", v0, v2, v1, v3, v5, v4, v6);
2091 if (0L != Node_List[out].width) {
2092 print_warning_location("width limitation", Node_List[out].mline, Node_List[out].mfile);
2093 (void) fprintf(STDERR, " the node <%s> is too complex to model accurately the under/overflow\n", Node_List[out].name1);
2094 (void) fprintf(STDERR, " behavior of an actual realization, we suggest to use a lower level model\n\n");
2095 }
2096 return;
2097}
2098
2099
2100void print_rect(char *str, long out) { /* unprocessed node_value: signed_input_node */
2101 char *s = (char*) NULL;
2102 char v0[STRLENGTH] = {'\0'};
2103 char v1[STRLENGTH] = {'\0'};
2104 char sgn[2] = {'\0'};
2105 long tp;
2106 s = str;
2107 (void) strcpy(v0, Node_List[out].name1);
2108 (void) build_name("", v0, LEFT_VALUE);
2109 s = get_sign_and_token(s, sgn, v1);
2110 tp = get_type(v1);
2111 (void) build_name("", v1, RIGHT_VALUE); /* no need to keep the sign here ! */
2112 (void) fprintf(STDOUT, " %s = ", v0);
2113 if (ANALOG_DATA_TYPE == tp) {
2114 (void) fprintf(STDOUT, "fabs(%s);\n", v1);
2115 } else {
2116 (void) fprintf(STDOUT, "labs(%s);\n", v1);
2117 }
2118 return; /* output width must be adjusted. No simplification possible */
2119}
2120
2121
2122void print_quant(char *str, long out) { /* unprocessed node_val: parameter input_node */
2123 char *s = (char*) NULL;
2124 char v0[STRLENGTH] = {'\0'};
2125 char v1[STRLENGTH] = {'\0'};
2126 char v2[STRLENGTH] = {'\0'};
2127 char sgn[2] = {'\0'};
2128 long d;
2129 long itemp1;
2130 double dtemp2;
2131 int flag;
2132 s = str;
2133 (void) strcpy(v0, Node_List[out].name1); /* v0: output */
2134 (void) build_name("", v0, LEFT_VALUE);
2135 s = get_sign_and_token(s, sgn, v1);
2136 (void) build_name(sgn, v1, RIGHT_VALUE); /* v1: signed quantification step */
2137 s = get_sign_and_token(s, sgn, v2);
2138 (void) build_name(sgn, v2, RIGHT_VALUE); /* v2: signed input */
2139 if (DIGITAL_DATA_TYPE == Node_List[out].type) {
2140 flag = sscanf(v1, "%li", &itemp1);
2141 if ((1 == flag) && (itemp1 <= 0L)) { /* quantification level is not a positive number */
2142 print_error_location("quant", Node_List[out].mline, Node_List[out].mfile);
2143 (void) fprintf(STDERR, " quantification level <%ld> must be strictly positive\n", itemp1);
2144 return;
2145 }
2146 if ((1 == flag) && (1L == itemp1)) { /* quantification level is a number equal to 1 */
2147 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
2148 return;
2149 }
2150 if ((1 == flag) && (1L < itemp1)) { /* quantification level is a number larger than 1 */
2151 (void) fprintf(STDOUT, " if ( 0LL < %s ) {\n", v2);
2152 (void) fprintf(STDOUT, " %s = %ldLL * ( %s / %ldLL);\n", v0, itemp1, v2, itemp1);
2153 (void) fprintf(STDOUT, " } else {\n");
2154 (void) fprintf(STDOUT, " %s = -%ldLL * (-%s / %ldLL);\n", v0, itemp1, v2, itemp1);
2155 (void) fprintf(STDOUT, " }\n");
2156 return;
2157 }
2158 (void) fprintf(STDOUT, " if ( 0LL < %s ) {\n", v1); /* quantification level is a ivar larger than 0 */
2159 (void) fprintf(STDOUT, " if ( 0LL < %s ) {\n", v2);
2160 (void) fprintf(STDOUT, " %s = %s * ( %s / %s);\n", v0, v1, v2, v1);
2161 (void) fprintf(STDOUT, " } else {\n");
2162 (void) fprintf(STDOUT, " %s = -%s * (-%s / %s);\n", v0, v1, v2, v1);
2163 (void) fprintf(STDOUT, " }\n");
2164 (void) fprintf(STDOUT, " } else {\n"); /* quantification level is a ivar smaller than 0 */
2165 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (quant)\\n\");\n");
2166 if (!Cmdline_Flag) {
2167 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", Node_List[out].mline[0]);
2168 for (d = 1L; d < MAXDEPTH; d++) {
2169 if (0UL == Node_List[out].mline[d]) {
2170 break;
2171 }
2172 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
2173 Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
2174 }
2175 }
2176 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n quantification level <%s> must be strictly positive\\n\");\n", v1);
2177 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
2178 (void) fprintf(STDOUT, " }\n");
2179 return;
2180 }
2181 if (ANALOG_DATA_TYPE == Node_List[out].type) {
2182 flag = sscanf(v1, "%lf", &dtemp2);
2183 if ((1 == flag) && (0.0 >= dtemp2)) { /* quantification level is a negative number */
2184 print_error_location("quant", Node_List[out].mline, Node_List[out].mfile);
2185 (void) fprintf(STDERR, " quantification level <%f> must be strictly positive\n", dtemp2);
2186 return;
2187 }
2188 if ((1 == flag) && ISEQUAL(1.0, dtemp2)) { /* quantification level is a number equal to 1.0 */
2189 (void) fprintf(STDOUT, " if ( 0.0 < %s ) {\n", v2);
2190 (void) fprintf(STDOUT, " %s = floor( %s + 0.5);\n", v0, v2);
2191 (void) fprintf(STDOUT, " } else {\n");
2192 (void) fprintf(STDOUT, " %s = -floor(-%s + 0.5);\n", v0, v2);
2193 (void) fprintf(STDOUT, " }\n");
2194 return;
2195 }
2196 if ((1 == flag) && (1.0 < dtemp2)) { /* quantification level is a number larger than 1.0 */
2197 (void) fprintf(STDOUT, " if ( 0.0 < %s ) {\n", v2);
2198 (void) fprintf(STDOUT, " %s = %.15e * floor(( %s / %.15e) + 0.5);\n", v0, dtemp2, v2, dtemp2);
2199 (void) fprintf(STDOUT, " } else {\n");
2200 (void) fprintf(STDOUT, " %s = -%.15e * floor((-%s / %.15e) + 0.5);\n", v0, dtemp2, v2, dtemp2);
2201 (void) fprintf(STDOUT, " }\n");
2202 return;
2203 }
2204 (void) fprintf(STDOUT, " if ( 0.0 < %s ) {\n", v1); /* quantification level is a dvar larger than 0 */
2205 (void) fprintf(STDOUT, " if ( 0.0 < %s ) {\n", v2);
2206 (void) fprintf(STDOUT, " %s = %s * floor(( %s / %s) + 0.5);\n", v0, v1, v2, v1);
2207 (void) fprintf(STDOUT, " } else {\n");
2208 (void) fprintf(STDOUT, " %s = -%s * floor((-%s / %s) + 0.5);\n", v0, v1, v2, v1);
2209 (void) fprintf(STDOUT, " }\n");
2210 (void) fprintf(STDOUT, " } else {\n"); /* quantification level is a dvar smaller than 0 */
2211 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (quant)\\n\");\n");
2212 if (!Cmdline_Flag) {
2213 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", Node_List[out].mline[0]);
2214 for (d = 1L; d < MAXDEPTH; d++) {
2215 if (0UL == Node_List[out].mline[d]) {
2216 break;
2217 }
2218 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
2219 Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
2220 }
2221 }
2222 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n quantification level <%s> must be strictly positive\\n\");\n", v1);
2223 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
2224 (void) fprintf(STDOUT, " }\n");
2225 }
2226 return;
2227}
2228
2229
2230void print_muller(char *str, long out) { /* unprocessed node_val: input_node input_node... */
2231 char *s = (char*) NULL;
2232 char v0[STRLENGTH] = {'\0'};
2233 char v1[STRLENGTH] = {'\0'};
2234 char v2[STRLENGTH] = {'\0'};
2235 char v3[STRLENGTH] = {'\0'};
2236 int first;
2237 s = str;
2238 first = true;
2239 (void) strcpy(v0, Node_List[out].name1);
2240 (void) build_name("", v0, LEFT_VALUE);
2241 (void) strcpy(v1, "");
2242 (void) strcpy(v2, "");
2243 for (;;) {
2244 s = get_token(s, v3, false); /* input node name */
2245 if (ISEMPTY(v3)) {
2246 break;
2247 }
2248 (void) build_name("", v3, RIGHT_VALUE);
2249 if (first) {
2250 first = false;
2251 } else {
2252 (void) strcat(v1, " && ");
2253 (void) strcat(v2, " && ");
2254 }
2255 (void) strcat(v1, "(0LL != ");
2256 (void) strcat(v2, "(0LL == ");
2257 (void) strcat(v1, v3);
2258 (void) strcat(v2, v3);
2259 (void) strcat(v1, ")");
2260 (void) strcat(v2, ")");
2261 }
2262 (void) fprintf(STDOUT, " if ( %s ) {\n", v1);
2263 (void) fprintf(STDOUT, " %s = 1LL;\n", v0);
2264 (void) fprintf(STDOUT, " } else if (%s) {\n", v2);
2265 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
2266 (void) fprintf(STDOUT, " }\n");
2267 return;
2268}
2269
2270
2271void print_minmax(char *str, long out, long k) { /* unprocessed: input_node [input_node...] */
2272 char *s = (char*) NULL;
2273 char tok[STRLENGTH] = {'\0'};
2274 char v0[STRLENGTH] = {'\0'};
2275 char v1[STRLENGTH] = {'\0'};
2276 char v2[STRLENGTH] = {'\0'};
2277 int first;
2278 s = str;
2279 (void) strcpy(v0, Node_List[out].name1);
2280 (void) build_name("", v0, LEFT_VALUE);
2281 first = true;
2282 for (;;) {
2283 s = get_token(s, tok, false); /* input node name */
2284 if (ISEMPTY(tok)) {
2285 break;
2286 }
2287 (void) strcpy(v2, "");
2288 if (0 == strcmp(tok, "+")) {
2289 s = get_token(s, v1, false);
2290 } else if (0 == strcmp(tok, "-")) {
2291 s = get_token(s, v1, false);
2292 (void) strcat(v2, "-");
2293 } else {
2294 (void) strcpy(v1, tok);
2295 }
2296 (void) fprintf(STDOUT, " %s = ", v0);
2297 if (MIN_KIND == k) { /* MIN is a macro defined at beginning of C code */
2298 (void) build_name("", v1, RIGHT_VALUE);
2299 (void) fprintf(STDOUT, "MIN(%s%s, ", v2, v1);
2300 }
2301 if (MAX_KIND == k) { /* MAX is a macro defined at beginning of C code */
2302 (void) build_name("", v1, RIGHT_VALUE);
2303 (void) fprintf(STDOUT, "MAX(%s%s, ", v2, v1);
2304 }
2305 if (first) {
2306 s = get_token(s, tok, false); /* input node name */
2307 if (ISEMPTY(tok)) {
2308 break;
2309 }
2310 (void) strcpy(v2, "");
2311 if (0 == strcmp(tok, "+")) {
2312 s = get_token(s, v1, false);
2313 } else if (0 == strcmp(tok, "-")) {
2314 s = get_token(s, v1, false);
2315 (void) strcat(v2, "-");
2316 } else {
2317 (void) strcpy(v1, tok);
2318 }
2319 (void) build_name("", v1, RIGHT_VALUE);
2320 (void) fprintf(STDOUT, "%s%s);\n", v2, v1);
2321 first = false;
2322 } else {
2323 (void) fprintf(STDOUT, "%s);\n", v0);
2324 }
2325 }
2326 return;
2327}
2328
2329
2330void print_usertool(char *str, long out, long k) { /* unprocessed value: fun_nam ... */
2331 char *s = (char*) NULL;
2332 char tok1[LINLENGTH] = {'\0'};
2333 char tok2[STRLENGTH] = {'\0'};
2334 char tok3[STRLENGTH] = {'\0'};
2335 char v0[STRLENGTH] = {'\0'};
2336 char v1[STRLENGTH] = {'\0'};
2337 char v2[STRLENGTH] = {'\0'};
2338 long i, n;
2339 int first;
2340 s = str;
2341 i = user_id(Node_List[out].name1);
2342 (void) strcpy(v0, Node_List[out].name1);
2343 (void) build_name("", v0, LEFT_VALUE);
2344 s = get_token(s, tok1, false); /* function_name */
2345 if ((DTOOL_KIND == k) || (ITOOL_KIND == k)) {
2346 if (1L < Num_Tools) {
2347 (void) fprintf(STDOUT, " napa_msg = &(napa_mailbox[%ld]);\n", UserTool_List[i].mailbox);
2348 (void) fprintf(STDOUT, " napa_msg->o = napa_packet;\n");
2349 } else {
2350 (void) fprintf(STDOUT, " napa_msg->o = napa_packet;\n");
2351 }
2352 }
2353 (void) fprintf(STDOUT, " %s = %s_%02ld(", v0, UserTool_List[i].function, UserTool_List[i].number);
2354 first = true;
2355 for (;;) {
2356 s = get_token(s, tok1, true); /* some parameters can be strings (file names...) */
2357 if (ISEMPTY(tok1)) {
2358 if (first) {
2359 (void) fprintf(STDOUT, " %ld);\n", Node_List[out].ID2); /* function id */
2360 } else {
2361 (void) fprintf(STDOUT, ", %ld);\n", Node_List[out].ID2); /* last parm is function id */
2362 }
2363 break;
2364 }
2365 (void) strcpy(tok2, tok1); /* store keyword 'after' */
2366 if (0 == strcmp(tok1, "after")) {
2367 s = get_token(s, tok1, false);
2368 if (ISEMPTY(tok1)) {
2369 print_error_location(tok2, Node_List[out].mline, Node_List[out].mfile);
2370 (void) fprintf(STDERR, " keyword <%s> must be followed by a node\n", tok2);
2371 (void) fprintf(STDOUT, ";\n");
2372 return;
2373 }
2374 n = node_id(tok1);
2375 if (UNDEFINED == n) {
2376 if (UNDEFINED != var_id(tok1)) {
2377 print_error_location(tok2, Node_List[out].mline, Node_List[out].mfile);
2378 (void) fprintf(STDERR, " after keyword <%s>, <%s> cannot be a variable\n", tok2, tok1);
2379 } else {
2380 print_error_location(tok2, Node_List[out].mline, Node_List[out].mfile);
2381 (void) fprintf(STDERR, " after keyword <%s>, <%s> must be a defined node\n", tok2, tok1);
2382 process_node_error(tok1);
2383 }
2384 (void) fprintf(STDOUT, ";\n");
2385 return;
2386 }
2387 (void) build_name("", tok1, RIGHT_VALUE); /* mark "after" node as used */
2388 continue;
2389 }
2390 if (0 == strcmp(tok1, "-")) {
2391 (void) strcpy(v1, "-");
2392 s = get_token(s, tok1, true);
2393 } else {
2394 (void) strcpy(v1, "");
2395 }
2396 if ('$' == tok1[(LENGTH(tok1))-1L]) {
2397 replace_dollar(tok1);
2398 (void) strcat(v1, tok1);
2399 } else if (UNDEFINED != (n = node_id(tok1))) {
2400 (void) strcpy(v2, Node_List[n].name1);
2401 (void) build_name("", v2, RIGHT_VALUE);
2402 (void) strcat(v1, v2);
2403 } else if (UNDEFINED != (n = var_id(tok1))) {
2404 (void) strcpy(v2, Var_List[n].name1);
2405 (void) build_name("", v2, RIGHT_VALUE);
2406 (void) strcat(v1, v2);
2407 } else if (UNDEFINED != (n = record_id(tok1))) {
2408 if (0 == strcmp(v1, "-")) {
2409 print_error_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
2410 (void) fprintf(STDERR, " an array of pointers cannot be signed\n");
2411 (void) fprintf(STDOUT, ";\n");
2412 break;
2413 }
2414 (void) strcpy(v1, Record_List[n].name);
2415 (void) build_name("", v1, RIGHT_VALUE);
2416 } else if (UNDEFINED != (n = array_id(tok1))) {
2417 if ((RAM_KIND == Array_List[n].kind) || (RAM2_KIND == Array_List[n].kind)) {
2418 print_error_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
2419 (void) fprintf(STDERR, " a RAM cannot be a parameter of a user-defined function\n");
2420 (void) fprintf(STDOUT, ";\n");
2421 break;
2422 }
2423 (void) strcpy(v2, Array_List[n].name);
2424 (void) build_name("", v2, RIGHT_VALUE);
2425 (void) strcat(v1, v2);
2426 } else if ((0 == strcmp(tok1, "stdout")) || (0 == strcmp(tok1, "stdin")) || (0 == strcmp(tok1, "stderr"))) { /* IO without "" */
2427 (void) strcpy(tok3, tok1);
2428 (void) snprintf(tok1, (size_t) (LINLENGTH-1L), "\"%s\"", tok3); /* place IO token between double quotes */
2429 (void) strcat(v1, tok1);
2430 } else {
2431 (void) strcat(v1, tok1);
2432 }
2433 if (!first) {
2434 (void) fprintf(STDOUT, ",");
2435 }
2436 (void) fprintf(STDOUT, "%s", v1);
2437 first = false;
2438 }
2439 return;
2440}
2441
2442
2443void print_algebra(char *str, long out) { /* unprocessed node_value: expression */
2444 char *s = (char*) NULL;
2445 char v0[STRLENGTH] = {'\0'};
2446 char v1[STRLENGTH] = {'\0'};
2447 long n;
2448 s = str;
2449 (void) strcpy(v0, Node_List[out].name1);
2450 (void) build_name("", v0, LEFT_VALUE);
2451 (void) fprintf(STDOUT, " %s = ", v0);
2452 if (ANALOG_DATA_TYPE == Node_List[out].type) {
2453 (void) fprintf(STDOUT, "(R_TYPE) ( ");
2454 } else {
2455 (void) fprintf(STDOUT, "(I_TYPE) ( ");
2456 }
2457 for (;;) {
2458 s = get_token(s, v1, true);
2459 if (ISEMPTY(v1)) {
2460 (void) fprintf(STDOUT, ");\n");
2461 break;
2462 }
2463 if (0 == strcmp(v1, "after")) { /* skip "after" keyword and following node */
2464 s = get_token(s, v1, false);
2465 if (ISEMPTY(v1)) {
2466 print_error_location("after", Node_List[out].mline, Node_List[out].mfile);
2467 (void) fprintf(STDERR, " keyword <after> must be followed by a node\n");
2468 (void) fprintf(STDOUT, ");\n");
2469 return;
2470 }
2471 n = node_id(v1);
2472 if (UNDEFINED == n) {
2473 if (UNDEFINED != var_id(v1)) {
2474 print_error_location("after", Node_List[out].mline, Node_List[out].mfile);
2475 (void) fprintf(STDERR, " <%s> cannot be a variable\n", v1);
2476 } else {
2477 print_error_location("after", Node_List[out].mline, Node_List[out].mfile);
2478 (void) fprintf(STDERR, " <%s> must be a defined node\n", v1);
2479 process_node_error(v1);
2480 }
2481 (void) fprintf(STDOUT, ");\n");
2482 return;
2483 }
2484 (void) build_name("", v1, RIGHT_VALUE); /* to get node marked as used */
2485 continue; /* skip node */
2486 }
2487 (void) build_name("", v1, RIGHT_VALUE);
2488 (void) fprintf(STDOUT, "%s ", v1);
2489 }
2490 return;
2491}
2492
2493
2494
2495
2496void print_test(char *str, long out) { /* unprocessed node_value: expression */
2497 char *s = (char*) NULL;
2498 char v0[STRLENGTH] = {'\0'};
2499 char v1[STRLENGTH] = {'\0'};
2500 long n;
2501 s = str;
2502 (void) strcpy(v0, Node_List[out].name1);
2503 (void) build_name("", v0, LEFT_VALUE);
2504 (void) fprintf(STDOUT, " %s = (I_TYPE) (0 != (", v0);
2505 for (;;) {
2506 s = get_token(s, v1, true);
2507 if (ISEMPTY(v1)) {
2508 (void) fprintf(STDOUT, "));\n");
2509 break;
2510 }
2511 if (0 == strcmp(v1, "after")) { /* skip "after" keyword and following node */
2512 s = get_token(s, v1, false);
2513 if (ISEMPTY(v1)) {
2514 print_error_location("after", Node_List[out].mline, Node_List[out].mfile);
2515 (void) fprintf(STDERR, " keyword <after> must be followed by a node\n");
2516 (void) fprintf(STDOUT, ");\n");
2517 return;
2518 }
2519 n = node_id(v1);
2520 if (UNDEFINED == n) {
2521 if (UNDEFINED != var_id(v1)) {
2522 print_error_location("after", Node_List[out].mline, Node_List[out].mfile);
2523 (void) fprintf(STDERR, " <%s> cannot be a variable\n", v1);
2524 } else {
2525 print_error_location("after", Node_List[out].mline, Node_List[out].mfile);
2526 (void) fprintf(STDERR, " <%s> must be a defined node\n", v1);
2527 process_node_error(v1);
2528 }
2529 (void) fprintf(STDOUT, ");\n");
2530 return;
2531 }
2532 (void) build_name("", v1, RIGHT_VALUE); /* to get node marked as used */
2533 continue; /* skip node */
2534 }
2535 (void) build_name("", v1, RIGHT_VALUE);
2536 (void) fprintf(STDOUT, "%s", v1);
2537 }
2538 return;
2539}
2540
2541
2542void print_adc(char *str, long out) { /* unprocessed node_value: num_lvl in_node ref_node */
2543 char *s = (char*) NULL;
2544 char *nm = (char*) NULL;
2545 char tok[STRLENGTH] = {'\0'};
2546 char v0[STRLENGTH] = {'\0'};
2547 char v1[STRLENGTH] = {'\0'};
2548 char v2[STRLENGTH] = {'\0'};
2549 char sgn[2] = {'\0'};
2550 long num;
2551 double dtemp1, dtemp2;
2552 int flag;
2553 s = str;
2554 nm = Node_List[out].name1;
2555 (void) strcpy(v0, nm);
2556 (void) build_name("", v0, LEFT_VALUE);
2557 s = get_sign_and_token(s, sgn, tok); /* get number of levels */
2558 if (1 != sscanf(tok, "%li", &num)) { /* number of levels: num */
2559 print_error_location("adc", Node_List[out].mline, Node_List[out].mfile);
2560 (void) fprintf(STDERR, " the number of levels is not a well-formed positive C long integer <%s>\n", tok);
2561 return;
2562 }
2563 s = get_sign_and_token(s, sgn, v1);
2564 (void) build_name(sgn, v1, RIGHT_VALUE);
2565 s = get_sign_and_token(s, sgn, v2);
2566 (void) build_name(sgn, v2, RIGHT_VALUE);
2567 flag = sscanf(v2, "%lf", &dtemp1);
2568 if ((1 == flag) && ISEQUAL(1.0, dtemp1)) {
2569 (void) fprintf(STDOUT, " dnode_%s_norm = %s;\n", nm, v1);
2570 } else {
2571 (void) fprintf(STDOUT, " dnode_%s_norm = %s / %s;\n", nm, v1, v2);
2572 }
2573 if (0L == (num % 2L)) {
2574 dtemp1 = 2.0 / ((double) num); /* step */
2575 dtemp2 = ((double) num)*dtemp1 * 0.5; /* threshold */
2576 (void) fprintf(STDOUT, " if ( %.15e < dnode_%s_norm ) {\n", dtemp2-dtemp1, nm);
2577 (void) fprintf(STDOUT, " %s = % ldLL;\n", v0, (num/2) - 1);
2578 (void) fprintf(STDOUT, " } else if ( %.15e > dnode_%s_norm ) {\n", -dtemp2, nm);
2579 (void) fprintf(STDOUT, " %s = % ldLL;\n", v0, -(num/2));
2580 (void) fprintf(STDOUT, " } else {\n");
2581 (void) fprintf(STDOUT, " %s = (I_TYPE) ((dnode_%s_norm * %.15e)", v0, nm, 1.0/dtemp1);
2582 (void) fprintf(STDOUT, " + ( (0.0 < dnode_%s_norm) ? 0.5 : -0.5) );\n", nm);
2583 (void) fprintf(STDOUT, " }\n");
2584 } else {
2585 dtemp1 = 2.0 / ((double) (num-1L)); /* step */
2586 dtemp2 = ((double) (num-2L))*dtemp1 * 0.5; /* threshold */
2587 (void) fprintf(STDOUT, " if ( %.15e < dnode_%s_norm ) {\n", dtemp2, nm);
2588 (void) fprintf(STDOUT, " %s = % ldLL;\n", v0, (num-1L)/2L);
2589 (void) fprintf(STDOUT, " } else if ( %.15e > dnode_%s_norm ) {\n", -dtemp2, nm);
2590 (void) fprintf(STDOUT, " %s = % ldLL;\n", v0, -(num-1L)/2L);
2591 (void) fprintf(STDOUT, " } else {\n");
2592 (void) fprintf(STDOUT, " %s = (I_TYPE) ((dnode_%s_norm * %.15e)", v0, nm, 1.0/dtemp1);
2593 (void) fprintf(STDOUT, " + ( (0.0 < dnode_%s_norm) ? 0.5 : -0.5) );\n", nm);
2594 (void) fprintf(STDOUT, " }\n");
2595 }
2596 return;
2597}
2598
2599
2600void print_dac(char *str, long out) { /* unprocessed node_value: num_lvl in_node ref_node */
2601 char *s = (char*) NULL;
2602 char tok[STRLENGTH] = {'\0'};
2603 char v0[STRLENGTH] = {'\0'};
2604 char v1[STRLENGTH] = {'\0'};
2605 char v2[STRLENGTH] = {'\0'};
2606 char sgn[2] = {'\0'};
2607 long num;
2608 long ltemp2;
2609 double dtemp1;
2610 int flag;
2611 s = str;
2612 (void) strcpy(v0, Node_List[out].name1);
2613 (void) build_name("", v0, LEFT_VALUE);
2614 s = get_sign_and_token(s, sgn, tok); /* get number of levels */
2615 if (1 != sscanf(tok, "%li", &num)) {
2616 print_error_location("dac", Node_List[out].mline, Node_List[out].mfile);
2617 (void) fprintf(STDERR, " the number of levels is not a well-formed positive C long integer <%s>\n", tok);
2618 return;
2619 }
2620 s = get_sign_and_token(s, sgn, v1); /* get input */
2621 (void) build_name(sgn, v1, RIGHT_VALUE);
2622 s = get_sign_and_token(s, sgn, v2); /* get reference */
2623 (void) build_name(sgn, v2, RIGHT_VALUE);
2624 if (0L == (num % 2L)) {
2625 dtemp1 = 2.0 / ((double) num); /* step */
2626 ltemp2 = num / 2L; /* threshold */
2627 (void) fprintf(STDOUT, " if ( %ldLL < %s ) {\n", ltemp2-1L, v1);
2628 (void) fprintf(STDOUT, " %s = %.15e;\n", v0, 1.0-dtemp1);
2629 (void) fprintf(STDOUT, " } else if ( %ldLL > %s ) {\n", -ltemp2, v1);
2630 (void) fprintf(STDOUT, " %s = %.15e;\n", v0, -1.0);
2631 (void) fprintf(STDOUT, " } else {\n");
2632 (void) fprintf(STDOUT, " %s = ((R_TYPE) %s) * %.15e;\n", v0, v1, dtemp1);
2633 (void) fprintf(STDOUT, " }\n");
2634 } else {
2635 dtemp1 = 2.0 / ((double) (num - 1L)); /* step */
2636 ltemp2 = num / 2L; /* threshold */
2637 (void) fprintf(STDOUT, " if ( %ldLL < %s ) {\n", ltemp2, v1);
2638 (void) fprintf(STDOUT, " %s = %.15e;\n", v0, 1.0);
2639 (void) fprintf(STDOUT, " } else if ( %ldLL > %s ) {\n", -ltemp2, v1);
2640 (void) fprintf(STDOUT, " %s = %.15e;\n", v0, -1.0);
2641 (void) fprintf(STDOUT, " } else {\n");
2642 (void) fprintf(STDOUT, " %s = ((R_TYPE) %s) * %.15e;\n", v0, v1, dtemp1);
2643 (void) fprintf(STDOUT, " }\n");
2644 }
2645 flag = sscanf(v2, "%lf", &dtemp1);
2646 if ((1 != flag) || ISNOTEQUAL(1.0, dtemp1)) {
2647 (void) fprintf(STDOUT, " %s *= %s;\n", v0, v2);
2648 }
2649 return;
2650}
2651
2652
2653void print_uadc(char *str, long out) { /* unprocessed node_value: num_lvl in_node ref_node */
2654 char *s = (char*) NULL;
2655 char *nm = (char*) NULL;
2656 char tok[STRLENGTH] = {'\0'};
2657 char v0[STRLENGTH] = {'\0'};
2658 char v1[STRLENGTH] = {'\0'};
2659 char v2[STRLENGTH] = {'\0'};
2660 char sgn[2] = {'\0'};
2661 long num;
2662 double dtemp1, dtemp2;
2663 int flag;
2664 s = str;
2665 nm = Node_List[out].name1;
2666 (void) strcpy(v0, nm);
2667 (void) build_name("", v0, LEFT_VALUE);
2668 s = get_sign_and_token(s, sgn, tok); /* get number of levels */
2669 if (1 != sscanf(tok, "%li", &num)) { /* number of levels: num */
2670 print_error_location("uadc", Node_List[out].mline, Node_List[out].mfile);
2671 (void) fprintf(STDERR, " the number of levels is not a well-formed positive C long integer <%s>\n", tok);
2672 return;
2673 }
2674 s = get_sign_and_token(s, sgn, v1);
2675 (void) build_name(sgn, v1, RIGHT_VALUE);
2676 s = get_sign_and_token(s, sgn, v2);
2677 (void) build_name(sgn, v2, RIGHT_VALUE);
2678 flag = sscanf(v2, "%lf", &dtemp1);
2679 if ((1 == flag) && ISEQUAL(1.0, dtemp1)) {
2680 (void) fprintf(STDOUT, " dnode_%s_norm = %s;\n", nm, v1);
2681 } else {
2682 (void) fprintf(STDOUT, " dnode_%s_norm = %s / %s;\n", nm, v1, v2);
2683 }
2684 dtemp1 = 1.0 / ((double) (num-1L)); /* step */
2685 dtemp2 = ((double) (num-1L))*dtemp1; /* threshold */
2686 (void) fprintf(STDOUT, " if ( %.15e < dnode_%s_norm ) {\n", dtemp2, nm);
2687 (void) fprintf(STDOUT, " %s = %ldLL;\n", v0, (num-1L));
2688 (void) fprintf(STDOUT, " } else if ( 0.0 >= dnode_%s_norm ) {\n", nm);
2689 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
2690 (void) fprintf(STDOUT, " } else {\n");
2691 (void) fprintf(STDOUT, " %s = (I_TYPE) ((dnode_%s_norm * %.15e) + 0.5);\n", v0, nm, 1.0/dtemp1);
2692 (void) fprintf(STDOUT, " }\n");
2693 return;
2694}
2695
2696
2697void print_udac(char *str, long out) { /* unprocessed node_value: num_lvl in_node ref_node */
2698 char *s = (char*) NULL;
2699 char tok[STRLENGTH] = {'\0'};
2700 char v0[STRLENGTH] = {'\0'};
2701 char v1[STRLENGTH] = {'\0'};
2702 char v2[STRLENGTH] = {'\0'};
2703 char sgn[2] = {'\0'};
2704 long num;
2705 long ltemp2;
2706 double dtemp1;
2707 int flag;
2708 s = str;
2709 (void) strcpy(v0, Node_List[out].name1);
2710 (void) build_name("", v0, LEFT_VALUE);
2711 s = get_sign_and_token(s, sgn, tok); /* get number of levels */
2712 if (1 != sscanf(tok, "%li", &num)) {
2713 print_error_location("udac", Node_List[out].mline, Node_List[out].mfile);
2714 (void) fprintf(STDERR, " the number of levels is not a well-formed positive C long integer <%s>\n", tok);
2715 return;
2716 }
2717 s = get_sign_and_token(s, sgn, v1); /* get input */
2718 (void) build_name(sgn, v1, RIGHT_VALUE);
2719 s = get_sign_and_token(s, sgn, v2); /* get reference */
2720 (void) build_name(sgn, v2, RIGHT_VALUE);
2721 dtemp1 = 1.0 / ((double) (num - 1L)); /* step */
2722 ltemp2 = num; /* threshold */
2723 (void) fprintf(STDOUT, " if ( %ldLL < %s ) {\n", ltemp2, v1);
2724 (void) fprintf(STDOUT, " %s = %.15e;\n", v0, 1.0);
2725 (void) fprintf(STDOUT, " } else if ( 0LL >= %s ) {\n", v1);
2726 (void) fprintf(STDOUT, " %s = %.15e;\n", v0, 0.0);
2727 (void) fprintf(STDOUT, " } else {\n");
2728 (void) fprintf(STDOUT, " %s = ((R_TYPE) %s) * %.15e;\n", v0, v1, dtemp1);
2729 (void) fprintf(STDOUT, " }\n");
2730 flag = sscanf(v2, "%lf", &dtemp1);
2731 if ((1 != flag) || ISNOTEQUAL(1.0, dtemp1)) {
2732 (void) fprintf(STDOUT, " %s *= %s;\n", v0, v2);
2733 }
2734 return;
2735}
2736
2737
2738void print_equal(char *str, long out) { /* unprocessed node_value: input input */
2739 char *s = (char*) NULL;
2740 char v0[STRLENGTH] = {'\0'};
2741 char v1[STRLENGTH] = {'\0'};
2742 char v2[STRLENGTH] = {'\0'};
2743 char v3[STRLENGTH] = {'\0'};
2744 char sgn1[2] = {'\0'};
2745 char sgn2[2] = {'\0'};
2746 char sgn3[2] = {'\0'};
2747 long tp;
2748 s = str;
2749 (void) strcpy(v0, Node_List[out].name1);
2750 (void) build_name("", v0, LEFT_VALUE);
2751 s = get_sign_and_token(s, sgn1, v1);
2752 tp = get_type(v1);
2753 (void) build_name("", v1, RIGHT_VALUE);
2754 s = get_sign_and_token(s, sgn2, v2);
2755 (void) build_name("", v2, RIGHT_VALUE);
2756 if (0 == strcmp(s, "")) { /* no precision indicated, use 'absolute precision' */
2757 (void) fprintf(STDOUT, " %s =", v0);
2758 if (DIGITAL_DATA_TYPE == tp) {
2759 if (0 == strcmp(sgn1, sgn2)) {
2760 (void) fprintf(STDOUT, " (%s == %s);\n", v1, v2);
2761 } else {
2762 (void) fprintf(STDOUT, " (%s == -%s);\n", v1, v2);
2763 }
2764 } else {
2765 (void) fprintf(STDOUT, " (((fabs(%s) + fabs(%s))*EPSILON) >= ", v1, v2);
2766 if ((0 == strcmp(sgn1, sgn2))) {
2767 (void) fprintf(STDOUT, "fabs(%s - %s));\n", v1, v2);
2768 } else {
2769 (void) fprintf(STDOUT, "fabs(%s + %s));\n", v1, v2);
2770 }
2771 }
2772 } else { /* precision indicated in the instruction */
2773 s = get_sign_and_token(s, sgn3, v3);
2774 (void) build_name("", v3, RIGHT_VALUE);
2775 (void) fprintf(STDOUT, " %s =", v0);
2776 if (DIGITAL_DATA_TYPE == tp) {
2777 (void) fprintf(STDOUT, " (%s >= ", v3);
2778 if (0 == strcmp(sgn1, sgn2)) {
2779 (void) fprintf(STDOUT, "labs(%s - %s));\n", v1, v2);
2780 } else {
2781 (void) fprintf(STDOUT, "labs(%s + %s));\n", v1, v2);
2782 }
2783 } else {
2784 (void) fprintf(STDOUT, " (%s >= ", v3);
2785 if (0 == strcmp(sgn1, sgn2)) {
2786 (void) fprintf(STDOUT, "fabs(%s - %s));\n", v1, v2);
2787 } else {
2788 (void) fprintf(STDOUT, "fabs(%s + %s));\n", v1, v2);
2789 }
2790 }
2791 }
2792 return;
2793}
2794
2795
2796void print_comp(char *str, long out) { /* unprocessed node_value: input input */
2797 char *s = (char*) NULL;
2798 char v0[STRLENGTH] = {'\0'};
2799 char v1[STRLENGTH] = {'\0'};
2800 char v2[STRLENGTH] = {'\0'};
2801 char sgn[2] = {'\0'};
2802 s = str;
2803 (void) strcpy(v0, Node_List[out].name1);
2804 (void) build_name("", v0, LEFT_VALUE);
2805 s = get_sign_and_token(s, sgn, v1);
2806 (void) build_name(sgn, v1, RIGHT_VALUE);
2807 s = get_sign_and_token(s, sgn, v2);
2808 (void) build_name(sgn, v2, RIGHT_VALUE);
2809 (void) fprintf(STDOUT, " %s = ( %s >= %s ) ? 1LL : 0LL;\n", v0, v1, v2);
2810 return;
2811}
2812
2813
2814void print_latch(char *str, long out) { /* unprocessed node_value: set_node rst_node */
2815 char *s = (char*) NULL;
2816 char v0[STRLENGTH] = {'\0'};
2817 char v1[STRLENGTH] = {'\0'};
2818 char v2[STRLENGTH] = {'\0'};
2819 char v3[STRLENGTH] = {'\0'};
2820 char v4[STRLENGTH] = {'\0'};
2821 char sgn[2] = {'\0'};
2822 long d;
2823 s = str;
2824 (void) strcpy(v0, Node_List[out].name1);
2825 (void) build_name("", v0, LEFT_VALUE);
2826 s = get_sign_and_token(s, sgn, v1);
2827 (void) strcpy(v3, v1);
2828 (void) build_name("", v1, RIGHT_VALUE); /* Set */
2829 s = get_sign_and_token(s, sgn, v2);
2830 (void) strcpy(v4, v2);
2831 (void) build_name("", v2, RIGHT_VALUE); /* Reset */
2832 (void) fprintf(STDOUT, " if ( (0LL != %s_set) && (0LL == %s)\n", v0, v1);
2833 (void) fprintf(STDOUT, " && (0LL != %s_rst) && (0LL == %s) ) {\n", v0, v2);
2834 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (latch)\\n\");\n");
2835 if (!Cmdline_Flag) {
2836 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", Node_List[out].mline[0]);
2837 for (d = 1L; d < MAXDEPTH; d++) {
2838 if (0UL == Node_List[out].mline[d]) {
2839 break;
2840 }
2841 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
2842 Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
2843 }
2844 }
2845 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n forbidden simultaneity of input transitions caused undetermination\\n\");\n");
2846 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" set: %%lld -> 0 <%s>\\n\", %s_set);\n", v3, v0);
2847 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" reset: %%lld -> 0 <%s>\\n\", %s_rst);\n", v4, v0);
2848 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
2849 (void) fprintf(STDOUT, " }\n");
2850 (void) fprintf(STDOUT, " %s_set = %s;\n", v0, v1);
2851 (void) fprintf(STDOUT, " %s_rst = %s;\n", v0, v2);
2852 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v2);
2853 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
2854 (void) fprintf(STDOUT, " }\n");
2855 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v1); /* priority to Set */
2856 (void) fprintf(STDOUT, " %s = 1LL;\n", v0);
2857 (void) fprintf(STDOUT, " }\n");
2858 return;
2859}
2860
2861
2862void print_mux(char *str, long out) { /* unprocessed: ctr_nam sgn_in_node [sgn_in_node..] */
2863 char *s = (char*) NULL;
2864 char v0[STRLENGTH] = {'\0'};
2865 char v1[STRLENGTH] = {'\0'};
2866 char v2[STRLENGTH] = {'\0'};
2867 char v3[STRLENGTH] = {'\0'};
2868 char sgn[2] = {'\0'};
2869 long d, i, n;
2870 s = str;
2871 (void) strcpy(v0, Node_List[out].name1);
2872 (void) build_name("", v0, LEFT_VALUE);
2873 s = get_sign_and_token(s, sgn, v1);
2874 if (1 == sscanf(v1, "%li", &n)) { /* control is a constant */
2875 i = 0L;
2876 for (;;) {
2877 s = get_sign_and_token(s, sgn, v2);
2878 if (ISEMPTY(v2)) {
2879 print_error_location("mux", Node_List[out].mline, Node_List[out].mfile);
2880 (void) fprintf(STDERR, " value <%s> of control is out of allowed range [0..%ld]\n", v1, n-1L);
2881 return;
2882 }
2883 if (i >= n) {
2884 (void) build_name(sgn, v2, RIGHT_VALUE);
2885 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
2886 break;
2887 }
2888 i++;
2889 }
2890 return;
2891 }
2892 (void) strcpy(v3, v1); /* build_name will modify 'v1' ! */
2893 (void) build_name(sgn, v1, RIGHT_VALUE);
2894 (void) fprintf(STDOUT, " switch (%s) {\n", v1);
2895 i = 0L;
2896 for (;;) {
2897 s = get_sign_and_token(s, sgn, v2);
2898 if (ISEMPTY(v2)) {
2899 (void) fprintf(STDOUT, " default:\n");
2900 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (mux)\\n\");\n");
2901 if (!Cmdline_Flag) {
2902 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", Node_List[out].mline[0]);
2903 for (d = 1L; d < MAXDEPTH; d++) {
2904 if (0UL == Node_List[out].mline[d]) {
2905 break;
2906 }
2907 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
2908 Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
2909 }
2910 }
2911 if (11L >= LENGTH(v3)) {
2912 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n unexpected value <%%lld> for control <%s>\\n\", %s);\n", v3, v1);
2913 } else {
2914 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n unexpected value <%%lld> for control <%s>\\n\",\n", v3 );
2915 (void) fprintf(STDOUT, " (I_TYPE) %s);\n", v1);
2916 }
2917 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
2918 (void) fprintf(STDOUT, " }\n");
2919 break;
2920 }
2921 if (0 != strcmp(v2, "void")) { /* skip 'void' input */
2922 (void) build_name(sgn, v2, RIGHT_VALUE);
2923 (void) fprintf(STDOUT, " case %ldLL:\n", i);
2924 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
2925 (void) fprintf(STDOUT, " break;\n");
2926 }
2927 i++;
2928 }
2929 return;
2930}
2931
2932
2933void print_merge(char *str, long out) { /* unprocessed: sgn_in_node [sgn_in_node...] */
2934 char *s = (char*) NULL;
2935 char v0[STRLENGTH] = {'\0'};
2936 char v1[STRLENGTH] = {'\0'};
2937 char sgn[2] = {'\0'};
2938 long d, i, n;
2939 int first;
2940 first = true;
2941 (void) strcpy(v0, Node_List[out].name1);
2942 (void) build_name("", v0, LEFT_VALUE);
2943 s = str;
2944 for (;;) {
2945 s = get_sign_and_token(s, sgn, v1);
2946 if (ISEMPTY(v1)) {
2947 break;
2948 }
2949 if (first) {
2950 (void) fprintf(STDOUT, " if ( napa_segment_run_%-2ld) {\n", Node_List[node_id(v1)].segment);
2951 (void) build_name(sgn, v1, RIGHT_VALUE);
2952 (void) fprintf(STDOUT, " %s = %s;\n", v0, v1);
2953 first = false;
2954 } else {
2955 (void) fprintf(STDOUT, " } else if ( napa_segment_run_%-2ld) {\n", Node_List[node_id(v1)].segment);
2956 (void) build_name(sgn, v1, RIGHT_VALUE);
2957 (void) fprintf(STDOUT, " %s = %s;\n", v0, v1);
2958 }
2959 }
2960 (void) fprintf(STDOUT, " }\n");
2961 if (((char*) NULL) == strstr(Node_List[out].option, "nocheck")) {
2962 s = str;
2963 i = 0L;
2964 (void) fprintf(STDOUT, " if ( 1 < (");
2965 for (;;) {
2966 s = get_sign_and_token(s, sgn, v1);
2967 if (ISEMPTY(v1)) {
2968 break;
2969 }
2970 if (0L == i) {
2971 (void) fprintf(STDOUT, "napa_segment_run_%-2ld", Node_List[node_id(v1)].segment);
2972 } else {
2973 (void) fprintf(STDOUT, " + napa_segment_run_%-2ld", Node_List[node_id(v1)].segment);
2974 }
2975 i++;
2976 }
2977 (void) fprintf(STDOUT, ") ) {\n");
2978 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\nNAPA Run Time Error: (merge)\\n\");\n");
2979 if (!Cmdline_Flag) {
2980 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", Node_List[out].mline[0]);
2981 for (d = 1L; d < MAXDEPTH; d++) {
2982 if (0UL == Node_List[out].mline[d]) {
2983 break;
2984 }
2985 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
2986 Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
2987 }
2988 }
2989 (void) fprintf(STDOUT, " (void) fprintf(stderr, \"\\n node <%s>,", Node_List[out].name1);
2990 (void) fprintf(STDOUT, " no more than one input must be active at each merge:\\n\");\n");
2991 s = str;
2992 n = 0L;
2993 for (;;) {
2994 s = get_sign_and_token(s, sgn, v1);
2995 if (ISEMPTY(v1)) {
2996 break;
2997 }
2998 n++;
2999 }
3000 s = str;
3001 i = 0L;
3002 if (2L >= n) {
3003 for (;;) {
3004 s = get_sign_and_token(s, sgn, v1);
3005 if (ISEMPTY(v1)) {
3006 break;
3007 }
3008 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -active- node <%s>\\n\");\n", v1);
3009 }
3010 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
3011 (void) fprintf(STDOUT, " }\n");
3012 } else {
3013 for (;;) {
3014 s = get_sign_and_token(s, sgn, v1);
3015 if (ISEMPTY(v1)) {
3016 break;
3017 }
3018 (void) fprintf(STDOUT, " if ( napa_segment_run_%-2ld) {\n", Node_List[node_id(v1)].segment);
3019 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -active- node <%s>\\n\");\n", v1);
3020 (void) fprintf(STDOUT, " } else {\n");
3021 (void) fprintf(STDOUT, " (void) fprintf(stderr, \" -inactive- node <%s>\\n\");\n", v1);
3022 (void) fprintf(STDOUT, " }\n");
3023 }
3024 (void) fprintf(STDOUT, " napa_exit(EXIT_FAILURE);\n");
3025 (void) fprintf(STDOUT, " }\n");
3026 }
3027 }
3028 return;
3029}
3030
3031
3032void print_relay(char *str, long out) { /* unprocessed node_val: ctr_nam in_nod setting val */
3033 char *s = (char*) NULL;
3034 char v0[STRLENGTH] = {'\0'};
3035 char v1[STRLENGTH] = {'\0'};
3036 char v2[STRLENGTH] = {'\0'};
3037 char v3[STRLENGTH] = {'\0'};
3038 char sgn[2] = {'\0'};
3039 long itemp;
3040 long w1, w2;
3041 int flag;
3042 s = str;
3043 (void) strcpy(v0, Node_List[out].name1);
3044 (void) build_name("", v0, LEFT_VALUE);
3045 s = get_sign_and_token(s, sgn, v1);
3046 (void) build_name("", v1, RIGHT_VALUE);
3047 s = get_sign_and_token(s, sgn, v2);
3048 w1 = Node_List[node_id(v2)].width; /* width of input */
3049 w2 = Node_List[out].width; /* width of output */
3050 (void) build_name(sgn, v2, RIGHT_VALUE);
3051 flag = sscanf(v1, "%li", &itemp);
3052 if (1 == flag) {
3053 if (!itemp) {
3054 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2); /* always pass through */
3055 } else {
3056 if (ISNOTEMPTY(s)) { /* optional setting value */
3057 s = get_sign_and_token(s, sgn, v3);
3058 (void) build_name(sgn, v3, RIGHT_VALUE); /* always reset */
3059 (void) fprintf(STDOUT, " %s = %s;\n", v0, v3);
3060 } else {
3061 if (DIGITAL_DATA_TYPE == Node_List[out].type) {
3062 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
3063 } else {
3064 (void) fprintf(STDOUT, " %s = 0.0;\n", v0);
3065 }
3066 }
3067 }
3068 } else {
3069 if (ISNOTEMPTY(s)) { /* optional setting value */
3070 s = get_sign_and_token(s, sgn, v3);
3071 (void) build_name(sgn, v3, RIGHT_VALUE);
3072 (void) fprintf(STDOUT, " %s = ( 0LL != %s ) ? %s : %s;\n", v0, v1, v3, v2);
3073 } else {
3074 if (DIGITAL_DATA_TYPE == Node_List[out].type) {
3075 (void) fprintf(STDOUT, " %s = ( 0LL != %s ) ? 0LL : %s;\n", v0, v1, v2);
3076 } else {
3077 (void) fprintf(STDOUT, " %s = ( 0LL != %s ) ? 0.0 : %s;\n", v0, v1, v2);
3078 }
3079 }
3080 }
3081 if ((w1 == w2) && (0 != strcmp(sgn, "-"))) {
3082 Node_List[out].width = 0L; /* no width adjustment */
3083 }
3084 return;
3085}
3086
3087
3088void print_zero(char *str, long out) { /* unprocessed node_value: decim offset input_node */
3089 char *s = (char*) NULL;
3090 char nm[STRLENGTH] = {'\0'};
3091 char v0[STRLENGTH] = {'\0'};
3092 char v1[STRLENGTH] = {'\0'};
3093 char v2[STRLENGTH] = {'\0'};
3094 char v3[STRLENGTH] = {'\0'};
3095 char sgn[2] = {'\0'};
3096 long w1, w2;
3097 long num1, num2;
3098 s = str;
3099 (void) strcpy(nm, Node_List[out].name1);
3100 (void) strcpy(v0, Node_List[out].name1);
3101 (void) build_name("", v0, LEFT_VALUE);
3102 s = get_sign_and_token(s, sgn, v1);
3103 if (1 != sscanf(v1, "%li", &num1)) {
3104 print_error_location("zero", Node_List[out].mline, Node_List[out].mfile);
3105 (void) fprintf(STDERR, " decimation factor is not a well-formed positive C long integer <%s>\n", v1);
3106 return;
3107 }
3108 if (2L > num1) {
3109 print_error_location("zero", Node_List[out].mline, Node_List[out].mfile);
3110 (void) fprintf(STDERR, " decimation factor <%ld> must be larger then 1\n", num1);
3111 return;
3112 }
3113 s = get_sign_and_token(s, sgn, v2);
3114 if (1 != sscanf(v2, "%li", &num2)) {
3115 print_error_location("zero", Node_List[out].mline, Node_List[out].mfile);
3116 (void) fprintf(STDERR, " decimation offset is not a well-formed positive C long integer <%s>\n", v2);
3117 return;
3118 }
3119 if (0L > num2) {
3120 print_error_location("zero", Node_List[out].mline, Node_List[out].mfile);
3121 (void) fprintf(STDERR, " decimation offset <%ld> cannot be negative\n", num2);
3122 return;
3123 }
3124 if (num2 >= num1) {
3125 print_error_location("zero", Node_List[out].mline, Node_List[out].mfile);
3126 (void) fprintf(STDERR, " decimation offset <%ld> must be smaller then decimation factor <%ld>\n", num2, num1);
3127 return;
3128 }
3129 s = get_sign_and_token(s, sgn, v3);
3130 w1 = Node_List[node_id(v3)].width; /* width of input */
3131 w2 = Node_List[out].width; /* width of output */
3132 (void) build_name(sgn, v3, RIGHT_VALUE);
3133 (void) fprintf(STDOUT, " inode_%s_ctr++;\n", nm);
3134 (void) fprintf(STDOUT, " inode_%s_ctr = inode_%s_ctr %% %ldLL;\n", nm, nm, num1);
3135 (void) fprintf(STDOUT, " %s = (%ldLL == inode_%s_ctr)", v0, num2, nm);
3136 if (DIGITAL_DATA_TYPE == Node_List[out].type) {
3137 (void) fprintf(STDOUT, " ? %s : 0LL;\n", v3);
3138 } else {
3139 (void) fprintf(STDOUT, " ? %s : 0.0;\n", v3);
3140 }
3141 if ((w1 == w2) && (0 != strcmp(sgn, "-"))) {
3142 Node_List[out].width = 0L; /* no width adjustment */
3143 }
3144 return;
3145}
3146
3147
3148void print_trig(char *str, long out) { /* unprocessed: [sgn] trig_val in_node [trig_mode] */
3149 char *s = (char*) NULL;
3150 char *nm = (char*) NULL;
3151 char tok[STRLENGTH] = {'\0'};
3152 char v0[STRLENGTH] = {'\0'};
3153 char v1[STRLENGTH] = {'\0'};
3154 char v2[STRLENGTH] = {'\0'};
3155 char prefix[STRLENGTH] = {'\0'};
3156 char sgn[2] = {'\0'};
3157 s = str;
3158 nm = Node_List[out].name1;
3159 (void) strcpy(v0, nm);
3160 (void) build_name("", v0, LEFT_VALUE);
3161 s = get_sign_and_token(s, sgn, v1);
3162 (void) build_name(sgn, v1, RIGHT_VALUE);
3163 s = get_sign_and_token(s, sgn, v2);
3164 if (DIGITAL_DATA_TYPE == Node_List[node_id(v2)].type) {
3165 (void) strcpy(prefix, "inode");
3166 } else {
3167 (void) strcpy(prefix, "dnode");
3168 }
3169 (void) build_name(sgn, v2, RIGHT_VALUE);
3170 s = get_sign_and_token(s, sgn, tok);
3171 if (((char*) NULL) != strstr(Node_List[out].option, "positive")) {
3172 (void) fprintf(STDOUT, " if ( (%s_%s_store < %s) && (%s >= %s) && (0.0L < napa_abs_loop) ) {\n", prefix, nm, v1, v2, v1);
3173 } else if (((char*) NULL) != strstr(Node_List[out].option, "negative")) {
3174 (void) fprintf(STDOUT, " if ( (%s_%s_store > %s) && (%s <= %s) && (0.0L < napa_abs_loop) ) {\n", prefix, nm, v1, v2, v1);
3175 } else {
3176 (void) fprintf(STDOUT, " if ( (((%s_%s_store > %s) && (%s <= %s))", prefix, nm, v1, v2, v1);
3177 (void) fprintf(STDOUT, " || ((%s_%s_store < %s) && (%s >= %s))) && (0.0L < napa_abs_loop) ) {\n", prefix, nm, v1, v2, v1);
3178 }
3179 (void) fprintf(STDOUT, " %s = 1LL;\n", v0);
3180 (void) fprintf(STDOUT, " } else {\n");
3181 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
3182 (void) fprintf(STDOUT, " }\n");
3183 (void) fprintf(STDOUT, " %s_%s_store = %s;\n", prefix, nm, v2);
3184 return;
3185}
3186
3187
3188void print_change(char *str, long out) {
3189 char *s = (char*) NULL;
3190 char *nm = (char*) NULL;
3191 char v0[STRLENGTH] = {'\0'};
3192 char v1[STRLENGTH] = {'\0'};
3193 char prefix[STRLENGTH] = {'\0'};
3194 char sgn[2] = {'\0'};
3195 s = str;
3196 nm = Node_List[out].name1;
3197 (void) strcpy(v0, nm);
3198 (void) build_name("", v0, LEFT_VALUE);
3199 s = get_sign_and_token(s, sgn, v1);
3200 if (DIGITAL_DATA_TYPE == Node_List[node_id(v1)].type) {
3201 (void) strcpy(prefix, "inode");
3202 } else {
3203 (void) strcpy(prefix, "dnode");
3204 }
3205 (void) build_name(sgn, v1, RIGHT_VALUE);
3206 if (((char*) NULL) != strstr(Node_List[out].option, "dual")) {
3207 (void) fprintf(STDOUT, " if ( %s_%s_store < %s ) {\n", prefix, nm, v1);
3208 (void) fprintf(STDOUT, " %s = 1LL;\n", v0);
3209 (void) fprintf(STDOUT, " } else if ( %s_%s_store > %s ) {\n", prefix, nm, v1);
3210 (void) fprintf(STDOUT, " %s = -1LL;\n", v0);
3211 (void) fprintf(STDOUT, " } else {\n");
3212 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
3213 (void) fprintf(STDOUT, " }\n");
3214 } else if (((char*) NULL) != strstr(Node_List[out].option, "both")) {
3215 (void) fprintf(STDOUT, " if ( (%s_%s_store < %s) || (%s_%s_store > %s) ) {\n", prefix, nm, v1, prefix, nm, v1);
3216 (void) fprintf(STDOUT, " %s = 1LL;\n", v0);
3217 (void) fprintf(STDOUT, " } else {\n");
3218 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
3219 (void) fprintf(STDOUT, " }\n");
3220 } else if (((char*) NULL) != strstr(Node_List[out].option, "positive")) {
3221 (void) fprintf(STDOUT, " if ( %s_%s_store < %s ) {\n", prefix, nm, v1);
3222 (void) fprintf(STDOUT, " %s = 1LL;\n", v0);
3223 (void) fprintf(STDOUT, " } else {\n");
3224 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
3225 (void) fprintf(STDOUT, " }\n");
3226 } else if (((char*) NULL) != strstr(Node_List[out].option, "negative")) {
3227 (void) fprintf(STDOUT, " if ( %s_%s_store > %s ) {\n", prefix, nm, v1);
3228 (void) fprintf(STDOUT, " %s = 1LL;\n", v0);
3229 (void) fprintf(STDOUT, " } else {\n");
3230 (void) fprintf(STDOUT, " %s = 0LL;\n", v0);
3231 (void) fprintf(STDOUT, " }\n");
3232 }
3233 (void) fprintf(STDOUT, " %s_%s_store = %s;\n", prefix, nm, v1);
3234 return;
3235}
3236
3237
3238void print_sign(char *str, long out) {
3239 char *s = (char*) NULL;
3240 char *nm = (char*) NULL;
3241 char v0[STRLENGTH] = {'\0'};
3242 char v1[STRLENGTH] = {'\0'};
3243 char sgn[2] = {'\0'};
3244 s = str;
3245 nm = Node_List[out].name1;
3246 (void) strcpy(v0, nm);
3247 (void) build_name("", v0, LEFT_VALUE);
3248 s = get_sign_and_token(s, sgn, v1);
3249 if (DIGITAL_DATA_TYPE == Node_List[node_id(v1)].type) {
3250 (void) build_name(sgn, v1, RIGHT_VALUE); /* place after type comparison */
3251 (void) fprintf(STDOUT, " %s = ((I_TYPE) (0LL < %s)) - ((I_TYPE) (0LL < %s));\n", v0, v1, v1);
3252 } else {
3253 (void) build_name(sgn, v1, RIGHT_VALUE);
3254 (void) fprintf(STDOUT, " %s = ((I_TYPE) (EPSILON < %s)) - ((I_TYPE) (-EPSILON > %s));\n", v0, v1, v1);
3255 }
3256 return;
3257}
3258
3259
3260void print_itod(char *str, long out) { /* unprocessed node_value: input_node_name */
3261 char *s = (char*) NULL;
3262 char v0[STRLENGTH] = {'\0'};
3263 char v1[STRLENGTH] = {'\0'};
3264 char sgn[2] = {'\0'};
3265 s = str;
3266 (void) strcpy(v0, Node_List[out].name1);
3267 (void) build_name("", v0, LEFT_VALUE);
3268 s = get_sign_and_token(s, sgn, v1);
3269 (void) build_name(sgn, v1, RIGHT_VALUE);
3270 (void) fprintf(STDOUT, " %s = (R_TYPE) (%s);\n", v0, v1);
3271 return;
3272}
3273
3274
3275void print_dtoi(char *str, long out) { /* unprocessed node_value: input_node_name */
3276 char *s = (char*) NULL;
3277 char v0[STRLENGTH] = {'\0'};
3278 char v1[STRLENGTH] = {'\0'};
3279 char sgn[2] = {'\0'};
3280 s = str;
3281 (void) strcpy(v0, Node_List[out].name1);
3282 (void) build_name("", v0, LEFT_VALUE);
3283 s = get_sign_and_token(s, sgn, v1);
3284 (void) build_name(sgn, v1, RIGHT_VALUE);
3285 (void) fprintf(STDOUT, " %s = ( 0.0 < %s ) ? (I_TYPE) (%s + 0.5) : (I_TYPE) (%s - 0.5);\n", v0, v1, v1, v1);
3286 return;
3287}
3288
3289
3290void print_btoi(char *str, long out) { /* unprocessed: input_node [input_node...] */
3291 char *s = (char*) NULL;
3292 char v0[STRLENGTH] = {'\0'};
3293 char v1[STRLENGTH] = {'\0'};
3294 char sgn[2] = {'\0'};
3295 int first, second;
3296 s = str;
3297 (void) strcpy(v0, Node_List[out].name1);
3298 (void) build_name("", v0, LEFT_VALUE);
3299 first = true;
3300 second = false;
3301 for (;;) {
3302 s = get_sign_and_token(s, sgn, v1); /* input node name */
3303 if (ISEMPTY(v1)) {
3304 if (second) {
3305 print_error_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
3306 (void) fprintf(STDERR, " at least 2 bits must be combined to form a word\n");
3307 (void) fprintf(STDOUT, "\n");
3308 }
3309 break;
3310 }
3311 (void) build_name(sgn, v1, RIGHT_VALUE);
3312 if (first) {
3313 if (0 == strcmp(v1, "0")) {
3314 /* do nothing */;
3315 } else if (0 == strcmp(v1, "1")) {
3316 (void) fprintf(STDOUT, " %s = 2LL", v0);
3317 first = false;
3318 second = true;
3319 } else {
3320 (void) fprintf(STDOUT, " %s = (%s * 2LL)", v0, v1);
3321 first = false;
3322 second = true;
3323 }
3324 } else if (second) {
3325 if (0 == strcmp(v1, "0")) {
3326 (void) fprintf(STDOUT, ";\n");
3327 } else {
3328 (void) fprintf(STDOUT, " + %s;\n", v1);
3329 }
3330 second = false;
3331 } else {
3332 if (0 == strcmp(v1, "0")) {
3333 (void) fprintf(STDOUT, " %s = (%s * 2LL);\n", v0, v0);
3334 } else {
3335 (void) fprintf(STDOUT, " %s = (%s * 2LL) + %s;\n", v0, v0, v1);
3336 }
3337 }
3338 }
3339 return;
3340}
3341
3342
3343void print_rom(char *str, long out) { /* unprocessed node_value: name[address] CS */
3344 char *s = (char*) NULL;
3345 char tok[STRLENGTH] = {'\0'};
3346 char v0[STRLENGTH] = {'\0'};
3347 char v1[STRLENGTH] = {'\0'};
3348 char v2[STRLENGTH] = {'\0'};
3349 char v3[STRLENGTH] = {'\0'};
3350 char v4[STRLENGTH] = {'\0'};
3351 char v5[STRLENGTH] = {'\0'};
3352 char brck[3] = {'\0'};
3353 long d, n;
3354 long nn, nv;
3355 s = str;
3356 (void) strcpy(v0, Node_List[out].name1);
3357 (void) build_name("", v0, LEFT_VALUE);
3358 s = get_token(s, v1, false); /* v1: ROM name */
3359 (void) strcpy(v2, v1);
3360 (void) build_name("", v2, RIGHT_VALUE);
3361 s = get_token_between_braces(s, brck, tok);
3362 n = node_id(tok);
3363 if (UNDEFINED == n) {
3364 (void) strcpy(v3, tok); /* v3: address constant */
3365 } else {
3366 (void) strcpy(v3, Node_List[n].name1); /* v3: address node name */
3367 (void) build_name("", v3, RIGHT_VALUE);
3368 }
3369 s = get_token(s, v4, false); /* v4: chip select node name */
3370 if (0 == strcmp(v4, "false")) {
3371 print_warning_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
3372 (void) fprintf(STDERR, " ROM <%s> is never selected, no code is generated\n", v1);
3373 return; /* no translation */
3374 }
3375 nn = node_id(v4);
3376 nv = var_id(v4);
3377 if (UNDEFINED != nn) {
3378 (void) strcpy(v4, Node_List[nn].name1);
3379 (void) build_name("", v4, RIGHT_VALUE);
3380 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v4);
3381 (void) strcpy(v5, " ");
3382 } else if (UNDEFINED != nv) {
3383 (void) strcpy(v4, Var_List[nv].name1);
3384 (void) build_name("", v4, RIGHT_VALUE);
3385 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v4);
3386 (void) strcpy(v5, " ");
3387 } else {
3388 if ((0 != strcmp(v4, "1")) && (0 != strcmp(v4, "true"))) {
3389 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v4);
3390 (void) strcpy(v5, " ");
3391 } else {
3392 (void) strcpy(v5, "");
3393 }
3394 }
3395 (void) fprintf(STDOUT, "%s if ( (0LL > %s) || (%s >= %s.length) ) {\n", v5, v3, v3, v2);
3396 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\nNAPA Run Time Error: (rom)\\n\");\n", v5);
3397 if (!Cmdline_Flag) {
3398 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n",
3399 v5, Node_List[out].mline[0]);
3400 for (d = 1L; d < MAXDEPTH; d++) {
3401 if (0UL == Node_List[out].mline[d]) {
3402 break;
3403 }
3404 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
3405 v5, Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
3406 }
3407 }
3408 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\n unexpected value <%%lld> for address of ROM <%s[%%lld]>\\n\", %s, %s.length);\n",
3409 v5, v1, v3, v2);
3410 (void) fprintf(STDOUT, "%s napa_exit(EXIT_FAILURE);\n", v5);
3411 (void) fprintf(STDOUT, "%s }\n", v5);
3412 (void) fprintf(STDOUT, "%s %s = %s.data[%s];\n", v5, v0, v2, v3);
3413 if ((ROM2_KIND == Array_List[array_id(v1)].kind) && (0 == Array_List[array_id(v1)].port)) {
3414 (void) fprintf(STDOUT, "%s if (%s == %s.address) {\n", v5, v3, v2);
3415 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\nNAPA Run Time Error: (rom)\\n\");\n", v5);
3416 if (!Cmdline_Flag) {
3417 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n",
3418 v5, Node_List[out].mline[0]);
3419 for (d = 1L; d < MAXDEPTH; d++) {
3420 if (0UL == Node_List[out].mline[d]) {
3421 break;
3422 }
3423 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
3424 v5, Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
3425 }
3426 }
3427 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\n access collision at address <%%lld> of dual port ROM <%s[%%lld]>\\n\", %s, %s.length);\n",
3428 v5, v1, v3, v2);
3429 (void) fprintf(STDOUT, "%s napa_exit(EXIT_FAILURE);\n", v5);
3430 (void) fprintf(STDOUT, "%s }\n", v5);
3431 }
3432 if (ROM2_KIND == Array_List[array_id(v1)].kind) {
3433 if (1L < Array_List[array_id(v1)].port) {
3434 Array_List[array_id(v1)].port = 0L;
3435 (void) fprintf(STDOUT, "%s %s.address = %s;\n", v5, v2, v3); /* store address */
3436 }
3437 }
3438 if ((0 != strcmp(v4, "1")) && (0 != strcmp(v4, "true"))) {
3439 (void) fprintf(STDOUT, " }\n");
3440 }
3441 return;
3442}
3443
3444
3445void print_ram(char *str, long out) { /* unprocessed: name[address] CS R/WB input_node */
3446 char *s = (char*) NULL;
3447 char tok[STRLENGTH] = {'\0'};
3448 char v0[STRLENGTH] = {'\0'};
3449 char v1[STRLENGTH] = {'\0'};
3450 char v2[STRLENGTH] = {'\0'};
3451 char v3[STRLENGTH] = {'\0'};
3452 char v4[STRLENGTH] = {'\0'};
3453 char v5[STRLENGTH] = {'\0'};
3454 char v6[STRLENGTH] = {'\0'};
3455 char v7[STRLENGTH] = {'\0'};
3456 char brck[3] = {'\0'};
3457 long n, d;
3458 long nn, nv;
3459 s = str;
3460 (void) strcpy(v0, Node_List[out].name1);
3461 (void) build_name("", v0, LEFT_VALUE);
3462 s = get_token(s, v1, false); /* v1: RAM name */
3463 (void) strcpy(v2, v1);
3464 (void) build_name("", v2, RIGHT_VALUE);
3465 s = get_token_between_braces(s, brck, tok);
3466 n = node_id(tok);
3467 if (UNDEFINED == n) {
3468 (void) strcpy(v3, tok); /* v3: address constant */
3469 } else {
3470 (void) strcpy(v3, Node_List[n].name1); /* v3: address node name */
3471 (void) build_name("", v3, RIGHT_VALUE);
3472 }
3473 s = get_token(s, v4, false); /* v4: chip select node name */
3474 if (0 == strcmp(v4, "false")) {
3475 print_warning_location(Node_List[out].tag, Node_List[out].mline, Node_List[out].mfile);
3476 (void) fprintf(STDERR, " RAM <%s> is never selected, no code is generated\n", v1);
3477 return; /* no translation */
3478 }
3479 nn = node_id(v4);
3480 nv = var_id(v4);
3481 s = get_token(s, tok, false); /* v5: R/W control node name */
3482 n = node_id(tok);
3483 if (UNDEFINED != n) {
3484 (void) strcpy(v5, Node_List[n].name1);
3485 (void) build_name("", v5, RIGHT_VALUE);
3486 } else {
3487 (void) strcpy(v5, tok);
3488 }
3489 s = get_token(s, tok, false); /* v6: input node name */
3490 n = node_id(tok);
3491 (void) strcpy(v6, Node_List[n].name1);
3492 (void) build_name("", v6, RIGHT_VALUE);
3493 if (UNDEFINED != nn) {
3494 (void) strcpy(v4, Node_List[nn].name1);
3495 (void) build_name("", v4, RIGHT_VALUE);
3496 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v4);
3497 (void) strcpy(v7, " ");
3498 } else if (UNDEFINED != nv) {
3499 (void) strcpy(v4, Var_List[nv].name1);
3500 (void) build_name("", v4, RIGHT_VALUE);
3501 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v4);
3502 (void) strcpy(v7, " ");
3503 } else {
3504 if ((0 != strcmp(v4, "1")) && (0 != strcmp(v4, "true"))) {
3505 (void) fprintf(STDOUT, " if ( 0LL != %s ) {\n", v4);
3506 (void) strcpy(v7, " ");
3507 } else {
3508 (void) strcpy(v7, "");
3509 }
3510 }
3511 (void) fprintf(STDOUT, "%s if ( (%s < 0LL) || (%s >= %s.length) ) {\n", v7, v3, v3, v2);
3512 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\nNAPA Run Time Error: (ram)\\n\");\n", v7);
3513 if (!Cmdline_Flag) {
3514 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n",
3515 v7, Node_List[out].mline[0]);
3516 for (d = 1; d < MAXDEPTH; d++) {
3517 if (0UL == Node_List[out].mline[d]) {
3518 break;
3519 }
3520 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
3521 v7, Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
3522 }
3523 }
3524 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\n unexpected value <%%lld> for address of RAM <%s[%%lld]>\\n\", %s, %s.length);\n",
3525 v7, v1, v3, v2);
3526 (void) fprintf(STDOUT, "%s napa_exit(EXIT_FAILURE);\n", v7);
3527 (void) fprintf(STDOUT, "%s }\n", v7);
3528 (void) fprintf(STDOUT, "%s if ( 0LL == %s ) {\n", v7, v5); /* write ! */
3529 (void) fprintf(STDOUT, "%s %s.data[%s] = %s;\n", v7, v2, v3, v6);
3530 (void) fprintf(STDOUT, "%s %s.flag[%s] = true;\n", v7, v2, v3);
3531 (void) fprintf(STDOUT, "%s %s = %s;\n", v7, v0, v6);
3532 (void) fprintf(STDOUT, "%s } else {\n", v7); /* read ! */
3533 (void) fprintf(STDOUT, "%s if ( !%s.flag[%s] ) {\n", v7, v2, v3);
3534 (void) fprintf(STDOUT, "%s %s.last = napa_abs_loop;\n", v7, v2);
3535 (void) fprintf(STDOUT, "%s }\n", v7);
3536 (void) fprintf(STDOUT, "%s %s = %s.data[%s];\n", v7, v0, v2, v3);
3537 (void) fprintf(STDOUT, "%s }\n", v7);
3538 if ((RAM2_KIND == Array_List[array_id(v1)].kind) && (0 == Array_List[array_id(v1)].port)) {
3539 (void) fprintf(STDOUT, "%s if ( %s == %s.address ) {\n", v7, v3, v2);
3540 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\nNAPA Run Time Error: (ram)\\n\");\n", v7);
3541 if (!Cmdline_Flag) {
3542 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n",
3543 v7, Node_List[out].mline[0]);
3544 for (d = 1L; d < MAXDEPTH; d++) {
3545 if (0UL == Node_List[out].mline[d]) {
3546 break;
3547 }
3548 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
3549 v7, Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
3550 }
3551 }
3552 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\n access collision at address <%%lld> of dual port RAM <%s[%%lld]>\\n\", %s, %s.length);\n",
3553 v7, v1, v3, v2);
3554 (void) fprintf(STDOUT, "%s napa_exit(EXIT_FAILURE);\n", v7);
3555 (void) fprintf(STDOUT, "%s }\n", v7);
3556 }
3557 if (RAM2_KIND == Array_List[array_id(v1)].kind) {
3558 if (1L < Array_List[array_id(v1)].port) {
3559 Array_List[array_id(v1)].port = 0L;
3560 (void) fprintf(STDOUT, "%s %s.address = %s;\n", v7, v2, v3); /* store address */
3561 (void) fprintf(STDOUT, "%s %s.rw = %s;\n", v7, v2, v5); /* store RW command */
3562 } else {
3563 (void) fprintf(STDOUT, "%s if ( %s != %s.rw ) {\n", v7, v5, v2);
3564 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\nNAPA Run Time Error: (ram)\\n\");\n", v7);
3565 if (!Cmdline_Flag) {
3566 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of main netlist\\n\");\n", v7, Node_List[out].mline[0]);
3567 for (d = 1L; d < MAXDEPTH; d++) {
3568 if (0UL == Node_List[out].mline[d]) {
3569 break;
3570 }
3571 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \" -> at line %3lu of \\\"%s\\\"\\n\");\n",
3572 v7, Node_List[out].mline[d], Record_Cell_File_Table[Node_List[out].mfile[d]]);
3573 }
3574 }
3575 (void) fprintf(STDOUT, "%s (void) fprintf(stderr, \"\\n uncompatible R/W command for dual port RAM <%s[%%lld]>\\n\", %s.length);\n",
3576 v7, v1, v2);
3577 (void) fprintf(STDOUT, "%s napa_exit(EXIT_FAILURE);\n", v7);
3578 (void) fprintf(STDOUT, "%s }\n", v7);
3579 }
3580 }
3581 if ((0 != strcmp(v4, "1")) && (0 != strcmp(v4, "true"))) {
3582 (void) fprintf(STDOUT, " }\n");
3583 }
3584 return;
3585}
3586
3587
3588void print_poly(char *str, long out) {
3589 char *s = (char*) NULL;
3590 char tok[STRLENGTH] = {'\0'};
3591 char v0[STRLENGTH] = {'\0'};
3592 char v1[STRLENGTH] = {'\0'};
3593 char v2[STRLENGTH] = {'\0'};
3594 char sgn[2] = {'\0'};
3595 double dtemp1;
3596 long long lltemp2;
3597 long tp;
3598 long i, n;
3599 int flag;
3600 (void) strcpy(v0, Node_List[out].name1);
3601 (void) build_name("", v0, LEFT_VALUE);
3602 n = 0L;
3603 s = str;
3604 for (;;) {
3605 str = get_sign_and_token(str, sgn, tok);
3606 if (ISEMPTY(tok)) {
3607 break;
3608 }
3609 (void) strcpy(v1, tok);
3610 n++;
3611 }
3612 tp = Node_List[node_id(v1)].type; /* last entry is the input node */
3613 (void) build_name(sgn, v1, RIGHT_VALUE);
3614 str = s;
3615 if (ANALOG_DATA_TYPE == tp) {
3616 for (i = 0L; i < n-1L; i++) { /* other entries are coefficients */
3617 str = get_sign_and_token(str, sgn, tok);
3618 (void) strcpy(v2, tok);
3619 (void) build_name(sgn, v2, RIGHT_VALUE);
3620 flag = sscanf(v2, "%lf", &dtemp1);
3621 if (0L == i) {
3622 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
3623 } else {
3624 (void) fprintf(STDOUT, " %s *= %s;\n", v0, v1);
3625 if ((0 == flag) || ((1 == flag) && ISNOTSMALL(dtemp1))) {
3626 (void) fprintf(STDOUT, " %s += %s;\n", v0, v2);
3627 }
3628 }
3629 }
3630 } else {
3631 for (i = 0L; i < n-1L; i++) { /* other entries are coefficients */
3632 str = get_sign_and_token(str, sgn, tok);
3633 (void) strcpy(v2, tok);
3634 (void) build_name(sgn, v2, RIGHT_VALUE);
3635 flag = sscanf(v2, "%lli", &lltemp2);
3636 if (1 == flag) {
3637 (void) snprintf(v2, (size_t) (STRLENGTH-1L), "%lldLL", lltemp2);
3638 }
3639 if (0L == i) {
3640 (void) fprintf(STDOUT, " %s = %s;\n", v0, v2);
3641 } else {
3642 (void) fprintf(STDOUT, " %s *= %s;\n", v0, v1);
3643 if ((0 == flag) || ((1 == flag) && (0LL != lltemp2))) {
3644 (void) fprintf(STDOUT, " %s += %s;\n", v0, v2);
3645 }
3646 }
3647 }
3648 }
3649 return;
3650}
3651
3652
3653/* ****************************************************************************************************************************** */
3654/* end of file */
print_fzinv
void print_fzinv(char *str, long out)
Definition bn.c:1347
print_delay1
void print_delay1(char *str, long out)
Definition bn.c:148
print_toggle
void print_toggle(char *str, long out)
Definition bn.c:1238
print_fzbuf
void print_fzbuf(char *str, long out)
Definition bn.c:1330
print_triangle
void print_triangle(char *str, long out)
Definition bn.c:461
print_uadc
void print_uadc(char *str, long out)
Definition bn.c:2653
print_offset
void print_offset(char *str, long out)
Definition bn.c:592
print_muller
void print_muller(char *str, long out)
Definition bn.c:2230
print_algebra
void print_algebra(char *str, long out)
Definition bn.c:2443
print_latch
void print_latch(char *str, long out)
Definition bn.c:2814
print_dyadic3
void print_dyadic3(char *str, long out, long k)
Definition bn.c:1803
print_relay
void print_relay(char *str, long out)
Definition bn.c:3032
print_holdtrack
void print_holdtrack(char *str, long out, long k)
Definition bn.c:754
print_noise
void print_noise(char *str, long out)
Definition bn.c:812
print_alu
void print_alu(char *str, long out)
Definition bn.c:1362
print_btoi
void print_btoi(char *str, long out)
Definition bn.c:3290
print_osc
void print_osc(char *str, long out)
Definition bn.c:270
print_mux
void print_mux(char *str, long out)
Definition bn.c:2862
print_square
void print_square(char *str, long out)
Definition bn.c:410
print_equal
void print_equal(char *str, long out)
Definition bn.c:2738
print_wsum
void print_wsum(char *str, long out)
Definition bn.c:675
print_dyadic5
void print_dyadic5(char *str, long out, long k)
Definition bn.c:1891
print_change
void print_change(char *str, long out)
Definition bn.c:3188
print_dyadic4
void print_dyadic4(char *str, long out, long k)
Definition bn.c:1847
print_step
void print_step(char *str, long out)
Definition bn.c:545
print_itod
void print_itod(char *str, long out)
Definition bn.c:3260
print_average
void print_average(char *str, long out)
Definition bn.c:1445
print_udac
void print_udac(char *str, long out)
Definition bn.c:2697
print_gain
void print_gain(char *str, long out)
Definition bn.c:617
print_dac
void print_dac(char *str, long out)
Definition bn.c:2600
print_minmax
void print_minmax(char *str, long out, long k)
Definition bn.c:2271
print_poly
void print_poly(char *str, long out)
Definition bn.c:3588
print_delay2
void print_delay2(char *str, long out)
Definition bn.c:170
print_rlshift
void print_rlshift(char *str, long out, long k)
Definition bn.c:963
print_bwinv
void print_bwinv(char *str, long out)
Definition bn.c:1259
print_ram
void print_ram(char *str, long out)
Definition bn.c:3445
print_sincos
void print_sincos(char *str, long out, long k)
Definition bn.c:310
print_dyadic2
void print_dyadic2(char *str, long out, long k)
Definition bn.c:1763
print_usertool
void print_usertool(char *str, long out, long k)
Definition bn.c:2330
print_rip
void print_rip(char *str, long out)
Definition bn.c:1274
print_test
void print_test(char *str, long out)
Definition bn.c:2496
print_trig
void print_trig(char *str, long out)
Definition bn.c:3148
print_quant
void print_quant(char *str, long out)
Definition bn.c:2122
print_differentiator
void print_differentiator(char *str, long out)
Definition bn.c:226
print_integrator
void print_integrator(char *str, long out)
Definition bn.c:249
print_inv
void print_inv(char *str, long out)
Definition bn.c:1208
print_zero
void print_zero(char *str, long out)
Definition bn.c:3088
print_dyadic7
void print_dyadic7(char *str, long out, long k)
Definition bn.c:1956
print_sign
void print_sign(char *str, long out)
Definition bn.c:3238
print_comp
void print_comp(char *str, long out)
Definition bn.c:2796
print_clock
void print_clock(char *str, long out)
Definition bn.c:1171
print_adc
void print_adc(char *str, long out)
Definition bn.c:2542
print_clip
void print_clip(char *str, long out)
Definition bn.c:785
print_dc
void print_dc(long out)
Definition bn.c:217
print_merge
void print_merge(char *str, long out)
Definition bn.c:2933
print_rect
void print_rect(char *str, long out)
Definition bn.c:2100
print_delay
void print_delay(char *str, long out)
Definition bn.c:91
print_buf
void print_buf(char *str, long out)
Definition bn.c:1223
print_bshift
void print_bshift(char *str, long out)
Definition bn.c:867
print_dtoi
void print_dtoi(char *str, long out)
Definition bn.c:3275
print_dyadic0
void print_dyadic0(char *str, long out, long k)
Definition bn.c:1608
print_rshift2
void print_rshift2(char *str, long out)
Definition bn.c:1084
print_rshift1
void print_rshift1(char *str, long out)
Definition bn.c:1028
print_delay3
void print_delay3(char *str, long out)
Definition bn.c:193
print_dyadic6
void print_dyadic6(char *str, long out, long k)
Definition bn.c:1934
print_itob
void print_itob(char *str, long out)
Definition bn.c:574
print_copy
void print_copy(char *str, long out)
Definition bn.c:1569
print_rom
void print_rom(char *str, long out)
Definition bn.c:3343
print_dyadic1
void print_dyadic1(char *str, long out, long k)
Definition bn.c:1711
print_warning_location
void print_warning_location(const char *type, const unsigned long *mlin, const unsigned long *mfil)
Definition fc.c:1484
print_error_location
void print_error_location(const char *type, const unsigned long *mlin, const unsigned long *mfil)
Definition fc.c:1476
constant_type
long constant_type(char *identifier)
Definition id.c:1130
get_type
long get_type(char *identifier)
Definition id.c:1190
user_id
long user_id(const char *identifier)
Definition id.c:844
array_id
long array_id(const char *identifier)
Definition id.c:635
node_id
long node_id(const char *identifier)
Definition id.c:718
var_id
long var_id(const char *identifier)
Definition id.c:855
record_id
long record_id(const char *identifier)
Definition id.c:796
process_node_error
void process_node_error(const char *tok1)
Definition mp.c:259
RIGHT_VALUE
#define RIGHT_VALUE
Definition napa.h:416
MAXDEPTH
#define MAXDEPTH
Definition napa.h:212
ISSMALL
#define ISSMALL(x)
Definition napa.h:386
Var_List
EXTERN VAR_TYPE Var_List[2047L]
Definition napa.h:970
Record_List
EXTERN RECORD_TYPE Record_List[127L]
Definition napa.h:965
MOD_KIND
#define MOD_KIND
Definition napa.h:286
Array_List
EXTERN ARRAY_TYPE Array_List[63L]
Definition napa.h:950
LENGTH
#define LENGTH(s)
Definition napa.h:397
TRACK_KIND
#define TRACK_KIND
Definition napa.h:318
UNKNOWN_TYPE
#define UNKNOWN_TYPE
Definition napa.h:332
UNDEFINED
#define UNDEFINED
Definition napa.h:331
AND_KIND
#define AND_KIND
Definition napa.h:229
ROM2_KIND
#define ROM2_KIND
Definition napa.h:304
STDERR
#define STDERR
Definition napa.h:105
Node_List
EXTERN NODE_TYPE Node_List[4095L]
Definition napa.h:962
LSHIFT_KIND
#define LSHIFT_KIND
Definition napa.h:282
BWNAND_KIND
#define BWNAND_KIND
Definition napa.h:236
UserTool_List
EXTERN USERTOOL_TYPE UserTool_List[511L]
Definition napa.h:969
FZNOR_KIND
#define FZNOR_KIND
Definition napa.h:267
NOR_KIND
#define NOR_KIND
Definition napa.h:291
ANALOG_DATA_TYPE
#define ANALOG_DATA_TYPE
Definition napa.h:338
OR_KIND
#define OR_KIND
Definition napa.h:293
Record_Cell_File_Table
EXTERN char * Record_Cell_File_Table[511L]
Definition napa.h:940
MIN_KIND
#define MIN_KIND
Definition napa.h:285
NAND_KIND
#define NAND_KIND
Definition napa.h:289
COS2_KIND
#define COS2_KIND
Definition napa.h:249
Cmdline_Flag
EXTERN int Cmdline_Flag
Definition napa.h:846
LINLENGTH
#define LINLENGTH
Definition napa.h:216
PROD_KIND
#define PROD_KIND
Definition napa.h:296
HOLD_KIND
#define HOLD_KIND
Definition napa.h:273
XOR_KIND
#define XOR_KIND
Definition napa.h:325
RAM_KIND
#define RAM_KIND
Definition napa.h:298
Num_Tools
EXTERN long Num_Tools
Definition napa.h:833
SIN_KIND
#define SIN_KIND
Definition napa.h:310
STDOUT
#define STDOUT
Definition napa.h:104
XNOR_KIND
#define XNOR_KIND
Definition napa.h:324
BWXNOR_KIND
#define BWXNOR_KIND
Definition napa.h:239
Opcode_List
EXTERN OPCODE_TYPE Opcode_List[127L]
Definition napa.h:963
FZXNOR_KIND
#define FZXNOR_KIND
Definition napa.h:269
ISEQUAL
#define ISEQUAL(x, y)
Definition napa.h:379
SUM_KIND
#define SUM_KIND
Definition napa.h:315
BWXOR_KIND
#define BWXOR_KIND
Definition napa.h:240
FZNAND_KIND
#define FZNAND_KIND
Definition napa.h:266
LEFT_VALUE
#define LEFT_VALUE
Definition napa.h:415
ISNOTEMPTY
#define ISNOTEMPTY(s)
Definition napa.h:395
ITOOL_KIND
#define ITOOL_KIND
Definition napa.h:279
DTOOL_KIND
#define DTOOL_KIND
Definition napa.h:260
RAM2_KIND
#define RAM2_KIND
Definition napa.h:299
SUB_KIND
#define SUB_KIND
Definition napa.h:314
DIV_KIND
#define DIV_KIND
Definition napa.h:258
FZOR_KIND
#define FZOR_KIND
Definition napa.h:268
BWOR_KIND
#define BWOR_KIND
Definition napa.h:238
RSHIFT_KIND
#define RSHIFT_KIND
Definition napa.h:305
ISNOTEQUAL
#define ISNOTEQUAL(x, y)
Definition napa.h:380
MAX_KIND
#define MAX_KIND
Definition napa.h:283
STRLENGTH
#define STRLENGTH
Definition napa.h:217
BWNOR_KIND
#define BWNOR_KIND
Definition napa.h:237
Num_Opcodes
EXTERN long Num_Opcodes
Definition napa.h:826
NAPA_DIGITAL_TYPE
#define NAPA_DIGITAL_TYPE
Definition napa.h:129
ISEMPTY
#define ISEMPTY(s)
Definition napa.h:394
ISNOTSMALL
#define ISNOTSMALL(x)
Definition napa.h:385
FZAND_KIND
#define FZAND_KIND
Definition napa.h:263
SIN2_KIND
#define SIN2_KIND
Definition napa.h:311
_2PI_
#define _2PI_
Definition napa.h:140
BWAND_KIND
#define BWAND_KIND
Definition napa.h:234
COS_KIND
#define COS_KIND
Definition napa.h:248
DIGITAL_DATA_TYPE
#define DIGITAL_DATA_TYPE
Definition napa.h:337
get_token
char * get_token(char *str, char *tok, long keep_quotes)
Definition tk.c:1210
build_name
char * build_name(const char *sgn, char *tok, long lr_type)
Definition tk.c:69
replace_dollar
void replace_dollar(char *tok)
Definition tk.c:1713
get_token_between_braces
char * get_token_between_braces(char *str, char *brc, char *tok)
Definition tk.c:1110
get_sign_and_token
char * get_sign_and_token(char *str, char *sgn, char *tok)
Definition tk.c:1188