1 /* $Id: cgenstr.c,v 1.11 1995/12/21 15:13:30 cim Exp $ */
2
3 /* Copyright (C) 1994, 1998 Sverre Hvammen Johansen and Terje Mj�s,
4 * Department of Informatics, University of Oslo.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
18
19 /* Legger ut C-kode for hvert blokk objekt. */
20
21 #include "const.h"
22 #include "dekl.h"
23 #include "cimcomp.h"
24 #include "error.h"
25 #include "extspec.h"
26 #include "mapline.h"
27 #include "name.h"
28
29 static short plevnull; /* Hvis en blokks prefiksniv} er 0 s} er
30 * plevnull=TRUE.Brukes for } initsialisere
31 * offset adressene til pekerne.M} vite om
32 * structen til denne blokken inneholder
33 * deklarasjonen struct dhp h.Ellers s} m}
34 * .s f}lges plev ganger for } komme til h.pp
35 */
36
37
38 static int naref;
39
40 static write_decl (rd, type, output_refs)
41 struct DECL *rd; char *type, output_refs;
42 {
43 if (!output_refs)
44 {
45 fprintf (ccode, "\t%s %s;\n", type, rd->ident);
46 }
47 }
48
49
50 static write_refs (rb, rd, atrib, output_refs)
51 struct BLOCK *rb; struct DECL *rd; char *atrib, output_refs;
52 {
53
54 /* TBD Hvis rd alltil hadde v�rt forskjellig fra NULL kunne rb sl�yfes
55 og i stedet for rb->blno brukte man rd->encl->blno, Dersom
56 de laged DECL objekter or et, er samt connester kan det gj�res.*/
57
58 if (output_refs)
59 fprintf (ccode, "(short)((char *)&((__bs%d *)0)->%s%s-(char *)0),",
60 rb->blno, rd==NULL?"":rd->ident, atrib);
61 else
62 naref++;
63 }
64
65
66
67
68 /******************************************************************************
69 DECLSTRUCTURE */
70
71 static declstructure (rd, output_refs)
72 struct DECL *rd;
73 char output_refs;
74 {
75 char write = 0;
76 if (rd->kind == KSIMPLE)
77 {
78 if (rd->categ == CVAR)
79 {
80 if (rd->type == TREF)
81 write_decl (rd, "__refvarpar ", output_refs);
82 else if (rd->type == TINTG || rd->type == TREAL)
83 write_decl (rd, "__aritvarpar ", output_refs);
84 else if (rd->type == TLABEL)
85 write_decl (rd, "__labelswitchpar ", output_refs);
86 else
87 write_decl (rd, "__varpar ", output_refs);
88
89 if (rd->type == TLABEL)
90 write_refs (rd->encl, rd, ".ob", output_refs);
91 else
92 write_refs (rd->encl, rd, ".bp", output_refs);
93 }
94 else if (rd->categ == CNAME)
95 {
96 if (rd->type == TREF)
97 write_decl (rd, "__refnamepar ", output_refs);
98 else if (rd->type == TINTG || rd->type == TREAL)
99 write_decl (rd, "__aritnamepar ", output_refs);
100 else if (rd->type == TTEXT)
101 write_decl (rd, "__textnamepar ", output_refs);
102 else if (rd->type == TLABEL)
103 write_decl (rd, "__labelnamepar ", output_refs);
104 else
105 write_decl (rd, "__charboolnamepar ", output_refs);
106
107 if (rd->type == TLABEL)
108 write_refs (rd->encl, rd, ".ob", output_refs);
109 else
110 write_refs (rd->encl, rd, ".bp", output_refs);
111
112 if (rd->type == TLABEL)
113 write_refs (rd->encl, rd, ".sl", output_refs);
114 else
115 write_refs (rd->encl, rd, ".sl", output_refs);
116 }
117 else if (rd->categ == CCONST);
118 else
119 {
120 switch (rd->type)
121 {
122 case TINTG:
123 write_decl (rd, "long ", output_refs);
124 break;
125 case TREAL:
126 write_decl (rd, "double ", output_refs);
127 break;
128 case TBOOL:
129 write_decl (rd, "char ", output_refs);
130 break;
131 case TCHAR:
132 write_decl (rd, "char ", output_refs);
133 break;
134 case TLABEL:
135 if (rd->categ != CLOCAL)
136 {
137 write_decl (rd, "__labelswitchpar ", output_refs);
138 write_refs (rd->encl, rd, ".ob", output_refs);
139 }
140 break;
141 case TTEXT:
142 write_decl (rd, "__txt ", output_refs);
143 write_refs (rd->encl, rd, ".obj", output_refs);
144 break;
145 case TREF:
146 write_decl (rd, "__dhp ", output_refs);
147 write_refs (rd->encl, rd, "", output_refs);
148 break;
149 case TVOIDP:
150 write_decl (rd, "void *", output_refs);
151 break;
152 }
153 /* END-SWITCH */
154 }
155 }
156 else if (rd->kind == KARRAY)
157 {
158 if (rd->type == TLABEL && rd->categ != CLOCAL)
159 {
160 write_decl (rd, "__labelswitchpar ", output_refs);
161 write_refs (rd->encl, rd, ".ob", output_refs);
162 }
163 else if (rd->categ == CNAME)
164 {
165 write_decl (rd, "__arraynamepar ", output_refs);
166 write_refs (rd->encl, rd, ".sl", output_refs);
167 write_refs (rd->encl, rd, ".ap", output_refs);
168 }
169 else
170 {
171 write_decl (rd, "__arrp ", output_refs);
172
173 write_refs (rd->encl, rd, "", output_refs);
174 }
175 }
176 else if (rd->kind == KPROC)
177 {
178 if (rd->categ == CDEFLT || rd->categ == CVAR)
179 {
180 if (rd->type == TINTG || rd->type == TREAL)
181 write_decl (rd, "__aritprocpar ", output_refs);
182 else if (rd->type == TREF)
183 write_decl (rd, "__refprocpar ", output_refs);
184 else
185 write_decl (rd, "__forprocpar ", output_refs);
186
187 write_refs (rd->encl, rd, ".psl", output_refs);
188 }
189 else if (rd->categ == CNAME)
190 {
191 if (rd->type == TINTG || rd->type == TREAL)
192 write_decl (rd, "__aritprocnamepar ", output_refs);
193 else if (rd->type == TREF)
194 write_decl (rd, "__refprocnamepar ", output_refs);
195 else
196 write_decl (rd, "__simpleprocnamepar ", output_refs);
197 write_refs (rd->encl, rd, ".psl", output_refs);
198 write_refs (rd->encl, rd, ".sl", output_refs);
199 }
200 }
201 }
202
203
204 /******************************************************************************
205 skrivprefikspp() */
206
207 /* Hjelpe prosedyre som g}r rekursift gjennom prefikskjeden helt til
208 * plev=0,og mens den trekker seg tilbake skriver den ut &p<blno til klassen>
209 * til klassen.Kalles fra blockstructure for } initsiere prefiksarrayet
210 * i prototypene.Da blir det slik at en prototype for en klasse p}
211 * prefiksniv} n vil i arrayet sitt ha en peker til seg selv p} plass
212 * 0,til sin superklasse p} plass n-1,dens superklasse p} plass n-2
213 * osv. */
214
215 static skrivprefikspp (rd)
216 struct DECL *rd;
217 {
218 if (rd != NULL)
219 {
220 if (rd->plev > 0)
221 {
222 skrivprefikspp (rd->prefqual);
223 fprintf (ccode, ",");
224 }
225 gen_adr_prot (ccode, rd);
226 }
227 }
228
229
230
231 /******************************************************************************
232 BLOCKMAINSTRUCTURE */
233
234 static blockmainstructure (rb, output_refs)
235 struct BLOCK *rb; char output_refs;
236 {
237 int i;
238 struct DECL *rd;
239 if (rb->quant.kind == KPROC && rb->quant.type != TNOTY)
240 {
241 if (rb->quant.type == TTEXT)
242 write_refs (rb, NULL, "et.obj", output_refs);
243 else if (rb->quant.type == TREF)
244 write_refs (rb, NULL, "er", output_refs);
245 }
246
247 for (i = 1; i <= rb->connest; i++)
248 {
249 char s[10];
250 sprintf (s, "c%d", i);
251 write_refs (rb, NULL, s, output_refs);
252 };
253
254 for (rd = rb->parloc; rd != NULL; rd = rd->next)
255 declstructure (rd, output_refs);
256 }
257
258 /******************************************************************************
259 BLOCKSTRUCTURE */
260
261 void
blockstructure(rb)262 static blockstructure (rb)
263 struct BLOCK *rb;
264 {
265 int i;
266 struct DECL *rd;
267
268 #if 0
269 if (rb->blno < 11)
270 return;
271 #endif
272
273 if (rb->structure_written)
274 return; /* Blokken er allerede behandlet */
275
276
277 switch (rb->quant.kind)
278 {
279 case KPROC:
280 case KCLASS:
281 case KBLOKK:
282 case KPRBLK:
283 if (rb->quant.kind == KPROC)
284 {
285 if (rb->quant.categ == CCPROC)
286 {
287 /* Extern C-prosedyre */
288 fprintf (ccode, "extern ");
289 switch (rb->quant.type)
290 {
291 case TTEXT:
292 fprintf (ccode, "char *");
293 break;
294 case TINTG:
295 fprintf (ccode, "long ");
296 break;
297 case TREAL:
298 fprintf (ccode, "double ");
299 break;
300 case TBOOL:
301 case TCHAR:
302 fprintf (ccode, "char ");
303 break;
304 }
305 fprintf (ccode, "%s();\n", rb->rtname);
306 break;
307 }
308 else if (rb->codeclass != CCNO) break;
309 }
310
311 if ((rb->quant.kind == KCLASS || rb->quant.kind == KPROC)
312 && rb->timestamp != 0 &&
313 rb->quant.encl->timestamp != rb->timestamp)
314 {
315
316 if (&rb->quant == classtext || &rb->quant == commonprefiks) break;
317 /* Definerer den eksterne modulen som extern p� .h filen */
318 fprintf (ccode, "extern void __m_%s();\n",
319 rb->timestamp);
320
321 }
322
323 if ((rb->quant.kind == KCLASS || rb->quant.kind == KPRBLK)
324 && rb->timestamp == 0)
325 {
326 fprintf (ccode, "extern __ptyp __p%d%s;\n", rb->blno,
327 timestamp);
328 for (rd = rb->virt; rd != NULL; rd = rd->next)
329 if (rd->kind == KPROC && rd->match!= NULL)
330 blockstructure (rd->match->descr);
331 }
332
333 if ((rb->quant.kind == KCLASS && rb->quant.plev > 0)
334 || (rb->quant.kind == KPRBLK))
335 { /* G�r gjennom prefikskjeden */
336 blockstructure (rb->quant.prefqual->descr);
337 plevnull = FALSE;
338 }
339 else
340 plevnull= TRUE;
341
342 fprintf (ccode, "typedef struct /* %s */\n {\n"
343 ,rb->quant.ident == NULL ? "" : rb->quant.ident);
344
345 if ((rb->quant.kind == KCLASS && rb->quant.plev > 0)
346 || (rb->quant.kind == KPRBLK))
347 fprintf (ccode, " __bs%d s;\n",
348 rb->quant.prefqual->descr->blno);
349 else
350 fprintf (ccode, " __dh h;\n");
351
352 naref = 0;
353 /* NB !!!. Deklarasjonene m� skrives ut f�r evt. hjelpe variable
354 * (for,inspect) og f�r returverdivariabelen. Slipper da � skrive
355 * ut disse i structene for virtuelle og formelle prosedyre
356 * spesifikasjoner. Gjelder prosedyrer. */
357 blockmainstructure (rb, FALSE);
358
359 if (rb->quant.kind == KPROC && rb->quant.type != TNOTY)
360 {
361 if (rb->quant.type == TTEXT)
362 fprintf (ccode, " __txt et;\n");
363 else if (rb->quant.type == TREF)
364 fprintf (ccode, " __dhp er;\n");
365 else if (rb->quant.type == TINTG)
366 fprintf (ccode, " long ev;\n");
367 else if (rb->quant.type == TREAL)
368 fprintf (ccode, " double ef;\n");
369 else
370 fprintf (ccode, " char ec;\n");
371 }
372
373 for (i = 1; i <= rb->fornest; i++)
374 fprintf (ccode, " short f%d;\n", i);
375 for (i = 1; i <= rb->connest; i++)
376 fprintf (ccode, " __dhp c%d;\n", i);
377
378 fprintf (ccode, " } __bs%d;\n", rb->blno);
379
380 if (rb->stat)
381 {
382 if (rb->timestamp) fprintf (ccode, "extern ");
383 fprintf
384 (ccode, "__bs%d __blokk%d%s;\n", rb->blno, rb->blno,
385 rb->timestamp?rb->timestamp:timestamp);
386 }
387
388 if (rb->timestamp != 0)
389 {
390 fprintf (ccode, "extern __ptyp __p%d%s;\n", rb->ptypno,
391 rb->timestamp);
392 }
393 else
394 {
395 if (naref)
396 {
397 fprintf (ccode, "short __rl%d%s[%d]={",
398 rb->blno, timestamp, naref);
399
400 blockmainstructure (rb, TRUE);
401
402 fprintf (ccode, "};\n");
403 }
404
405 if ((rb->quant.kind == KCLASS || rb->quant.kind == KPRBLK) &&
406 (rb->navirt || rb->navirtlab))
407 {
408 if (rb->navirt)
409 {
410 fprintf (ccode, "__pty __vl%d%s[%d]={",
411 rb->blno, timestamp, rb->navirt);
412 for (rd = rb->virt; rd != NULL; rd = rd->next)
413 {
414 if (rd->kind == KPROC)
415 {
416 if (rd->match != NULL)
417 {
418 gen_adr_prot (ccode, rd->match);
419 fprintf (ccode, ",");
420 }
421 else
422 fprintf (ccode, "__NULL,");
423 }
424 }
425 fprintf (ccode, "};\n");
426 }
427
428 if (rb->navirtlab)
429 {
430 fprintf (ccode, "__progadr __labvl%d%s[%d]={", rb->blno,
431 timestamp, rb->navirtlab);
432 for (rd = rb->virt; rd != NULL; rd = rd->next)
433 {
434 if (rd->kind != KPROC)
435 {
436 if (rd->match != NULL)
437 {
438 if (rd->match->plev == 0)
439 rd->match->plev = newlabel ();
440
441 if (rd->match->encl->timestamp != 0)
442 fprintf (ccode, "%d,__m_%s,",
443 rd->match->plev,
444 rd->match->encl->timestamp);
445
446 else if (separat_comp)
447 fprintf (ccode, "%d,__m_%s,",
448 rd->match->plev, timestamp);
449 else
450 fprintf (ccode, "%d,__NULL,",
451 rd->match->plev);
452 }
453 else
454 fprintf (ccode, "0,__NULL,");
455 }
456 }
457 fprintf (ccode, "};\n");
458 }
459 }
460
461 fprintf (ccode, "extern __ptyp __p%d%s;__pty __pl%d%s[%d]={",
462 rb->blno, timestamp,
463 rb->blno, timestamp,
464 (rb->quant.prefqual==NULL)?1:
465 ((rb->quant.plev + 1 > DEF_PLEV_TAB_SIZE) ?
466 rb->quant.plev + 1 : DEF_PLEV_TAB_SIZE));
467 skrivprefikspp (&rb->quant);
468
469 fprintf (ccode, "};\n__ptyp __p%d%s={'%c',%d,%d,sizeof(__bs%d),%d,",
470 rb->blno, timestamp,
471 rb->quant.kind,
472 rb->quant.plev,
473 rb->blev, rb->blno,
474 rb->ent);
475
476 if (separat_comp && (rb->quant.kind == KCLASS
477 || rb->quant.kind == KPROC ||
478 rb->quant.kind == KPRBLK))
479 fprintf (ccode, "__m_%s", timestamp);
480 else
481 fprintf (ccode, "0");
482
483 fprintf (ccode, ",%d,%d,%d,%d",
484 rb->fornest,
485 rb->connest,
486 naref,
487 rb->navirt);
488
489 if (naref)
490 fprintf (ccode, ",__rl%d%s", rb->blno, timestamp);
491 else
492 fprintf (ccode, ",0");
493
494 if ((rb->quant.kind == KCLASS || rb->quant.kind == KPRBLK) && rb->navirt)
495 fprintf (ccode, ",__vl%d%s", rb->blno, timestamp);
496 else
497 fprintf (ccode, ",0");
498
499 fprintf (ccode, ",__pl%d%s", rb->blno, timestamp);
500
501 if ((rb->quant.kind == KCLASS || rb->quant.kind == KPRBLK)
502 && rb->navirtlab)
503 fprintf (ccode, ",__labvl%d%s};\n", rb->blno, timestamp);
504 else
505 fprintf (ccode, ",__NULL};\n");
506
507 }
508 rb->structure_written = TRUE; /* merker av at det er lagt ut type for denne
509 * blokken */
510
511 /* Sjekker om det m� skrives ut structer for virtuelle- og formelle
512 * prosedyre spesifikasjoner */
513 if (rb->quant.kind == KCLASS || rb->quant.kind == KPROC)
514 specifier_structure (rb);
515 break;
516 }
517 for (rd= rb->parloc; rd!= NULL; rd= rd->next)
518 {
519 switch (rd->kind)
520 {
521 case KPROC:
522 case KCLASS:
523 case KBLOKK:
524 case KPRBLK:
525 case KFOR:
526 case KINSP:
527 case KCON:
528 blockstructure (rd->descr);
529 break;
530 }
531 }
532 }
533
534 specifier_proc_structure (rd)
535 struct DECL *rd;
536 {
537 struct DECL *rdi;
538 if (rd->kind == KPROC)
539 {
540 if (rd->descr->parloc != NULL)
541 {
542 fprintf
543 (ccode, "typedef struct /* %s SPEC*/\n {\n", rd->ident);
544 fprintf (ccode, " __dh h;\n");
545
546 /* Skriver alle parameterne */
547 for (rdi = rd->descr->parloc; rdi != NULL; rdi = rdi->next)
548 declstructure (rdi, FALSE);
549 fprintf (ccode, " } __bs%d;\n", rd->descr->blno);
550
551 /* Flere niv�er ? */
552 specifier_structure (rd->descr);
553 }
554 /* merker av at det er lagt ut type for denne blokken */
555 rd->descr->structure_written = TRUE;
556 }
557 }
558
559 specifier_structure (rb)
560 struct BLOCK *rb;
561 { /* Kaller p� param_structure som skriver ut
562 * structer for evt. parameterspesifikasjoner
563 * til virtuelle og formelle prosedyre-
564 * spesifikasjoner. Alts� kun for de som
565 * inneholder parametere. */
566
567 struct DECL *rd,
568 *rdi;
569
570 /* Ser forst etter formell prosedyre spesifikasjoner */
571 for (rd = rb->parloc; rd != NULL && (rd->categ == CDEFLT
572 || rd->categ == CNAME &&
573 rd->categ == CVAR
574 && rd->categ == CVALUE); rd = rd->next)
575 specifier_proc_structure (rd);
576
577 /* G�r s� gjennom den virtuele listen, og skriver ut for evt. virtuelle
578 * prosedyre spesifikasjoner */
579
580 if (rb->quant.kind == KCLASS && rb->virt != NULL)
581 {
582 int i;
583 /* Skal evt. bare skrive ut structene for de prosedyrene som ikke */
584 /* er eller blir skrevet ut under behandlingen av prefiksklassen */
585 if (rb->quant.plev > 0)
586 i = rb->quant.prefqual->descr->navirt +
587 rb->quant.prefqual->descr->navirtlab;
588 else
589 i = 0;
590 for (rd = rb->virt; i-- > 0; rd = rd->next);
591 /* Har n� funnet f�rste 'nye' virtuelle spesifikasjon. */
592
593 for (; rd != NULL; rd = rd->next)
594 specifier_proc_structure (rd);
595 }
596 }
597
598 /******************************************************************************
599 STRUCTURE */
600
structure()601 structure ()
602 {
603 struct BLOCK *block;
604 if (separat_comp)
605 {
606 fprintf (ccode, "void __m_%s();\n", timestamp);
607 }
608 genmap ();
609 ssblock->timestamp= tag("FILE");
610 #if 0
611 for (block = ssblock; block != NULL; block = block->next_block)
612 {
613 switch (block->quant.kind)
614 {
615 case KPROC:
616 case KCLASS:
617 case KBLOKK:
618 case KPRBLK:
619 blockstructure (block);
620 break;
621 default:
622 /* IKKE NOE UTLEGG */ ;
623 }
624 }
625 #else
626 blockstructure (ssblock);
627 #endif
628 }
629
630 /******************************************************************************
631 UPDATEGLNULL */
632
doForEachStatPointer(block)633 static void doForEachStatPointer (block) struct BLOCK *block;
634 {
635 struct DECL *rd;
636 switch (block->quant.kind)
637 {
638 case KPROC:
639 case KCLASS:
640 case KBLOKK:
641 case KPRBLK:
642 if (block->stat)
643 fprintf (ccode, "if(((__dhp)&__blokk%d%s)->gl!=__NULL|force)"
644 "__do_for_each_pointer(&__blokk%d%s,doit,doit_notest);\n"
645 ,block->blno, timestamp, block->blno,
646 block->timestamp?block->timestamp:timestamp);
647 }
648 for (rd= block->parloc; rd!= NULL; rd= rd->next)
649 {
650 switch (rd->kind)
651 {
652 case KPROC:
653 case KCLASS:
654 case KBLOKK:
655 case KPRBLK:
656 case KFOR:
657 case KINSP:
658 case KCON:
659 doForEachStatPointer (rd->descr);
660 break;
661 }
662 }
663 }
664
665 /******************************************************************************
666 UPDATEGLNULL */
667
updateGlNull(block)668 static void updateGlNull (block) struct BLOCK *block;
669 {
670 struct DECL *rd;
671 switch (block->quant.kind)
672 {
673 case KPROC:
674 case KCLASS:
675 case KBLOKK:
676 case KPRBLK:
677 if (block->stat)
678 fprintf (ccode, "((__dhp)&__blokk%d%s)->gl=(__dhp)0;\n",block->blno,
679 block->timestamp?block->timestamp:timestamp);
680 }
681 for (rd= block->parloc; rd!= NULL; rd= rd->next)
682 {
683 switch (rd->kind)
684 {
685 case KPROC:
686 case KCLASS:
687 case KBLOKK:
688 case KPRBLK:
689 case KFOR:
690 case KINSP:
691 case KCON:
692 updateGlNull (rd->descr);
693 break;
694 }
695 }
696 }
697
698 /******************************************************************************
699 UPDATEGLOBJ */
700
updateGlObj(block)701 static void updateGlObj (block) struct BLOCK *block;
702 {
703 struct DECL *rd;
704 switch (block->quant.kind)
705 {
706 case KPROC:
707 case KCLASS:
708 case KBLOKK:
709 case KPRBLK:
710 if (block->stat)
711 fprintf
712 (ccode,
713 "if(((__dhp)&__blokk%d%s)->gl)((__dhp)&__blokk%d%s)->gl=(__dhp)&__blokk%d%s;\n"
714 ,block->blno, block->timestamp?block->timestamp:timestamp
715 ,block->blno, block->timestamp?block->timestamp:timestamp,
716 block->blno, block->timestamp?block->timestamp:timestamp);
717 }
718
719 for (rd= block->parloc; rd!= NULL; rd= rd->next)
720 {
721 switch (rd->kind)
722 {
723 case KPROC:
724 case KCLASS:
725 case KBLOKK:
726 case KPRBLK:
727 case KFOR:
728 case KINSP:
729 case KCON:
730 updateGlObj (rd->descr);
731 break;
732 }
733 }
734 }
735
736 /******************************************************************************
737 STAT_POINTERS */
738
stat_pointers()739 stat_pointers ()
740 {
741 struct BLOCK *block;
742 struct stamp *st;
743
744 if (!separat_comp)
745 { /* TBD __init(){__init_FILE();__init_SIMENVIR(); should be removed */
746 fprintf (ccode, "\n__init(){__init_FILE();__init_SIMENVIR();}\n");
747 fprintf
748 (ccode,
749 "__do_for_each_stat_pointer(doit,doit_notest,force)void(*doit)(),(*doit_notest)();int force;{\n");
750
751 doForEachStatPointer (sblock);
752
753 fprintf (ccode, "}\n__update_gl_to_obj(){\n");
754 updateGlObj (sblock);
755
756
757 fprintf (ccode, "}\n__update_gl_to_null(){\n");
758 updateGlNull (sblock);
759
760 fprintf (ccode, "}\n");
761 }
762 }
763
764