![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-edsel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-edsel.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Interface to LUCID Cadillac system for GNU compiler.
2: Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC 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; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: #include "config.h"
21:
22: #include "tree.h"
23: #include "flags.h"
24: #include <stdio.h>
25: #include "cp-tree.h"
26: #include "obstack.h"
27:
28: #ifdef CADILLAC
29: #include <compilerreq.h>
30: #include <compilerconn.h>
31: #include <sys/time.h>
32: #include <sys/types.h>
33: #include <errno.h>
34: #include <sys/file.h>
35:
36: #define obstack_chunk_alloc xmalloc
37: #define obstack_chunk_free free
38:
39: void init_cadillac ();
40:
41: extern char *input_filename;
42: extern int lineno;
43:
44: /* Put random information we might want to get back from
45: Cadillac here. */
46: typedef struct
47: {
48: /* The connection to the Cadillac kernel. */
49: Connection *conn;
50:
51: /* Input and output file descriptors for Cadillac. */
52: short fd_input, fd_output;
53:
54: /* #include nesting of current file. */
55: short depth;
56:
57: /* State variables for the connection. */
58: char messages;
59: char conversion;
60: char emission;
61: char process_until;
62:
63: /* #if level of current file. */
64: int iflevel;
65:
66: /* Line number that starts current source file. */
67: int lineno;
68:
69: /* Name of current file. */
70: char *filename;
71:
72: /* Where to stop processing (if process_until is set). */
73: char *end_filename;
74: int end_position;
75:
76: } cadillac_struct;
77: static cadillac_struct cadillacObj;
78:
79: /* Nonzero if in the process of exiting. */
80: static int exiting;
81:
82: void cadillac_note_source ();
83: static void CWriteLanguageDecl ();
84: static void CWriteLanguageType ();
85: static void CWriteTopLevel ();
86: static void cadillac_note_filepos ();
87: static void cadillac_process_request (), cadillac_process_requests ();
88: static void cadillac_switch_source ();
89: static void exit_cadillac ();
90:
91: /* Blocking test. */
92: static int
93: readable_p (fd)
94: int fd;
95: {
96: fd_set f;
97:
98: FD_ZERO (&f);
99: FD_SET (fd, &f);
100:
101: return select (32, &f, NULL, NULL, 0) == 1;
102: }
103:
104: static CObjectType *tree_to_cadillac_map;
105: struct obstack cadillac_obstack;
106:
107:
108: #include "stack.h"
109:
110: struct context_level
111: {
112: struct stack_level base;
113:
114: tree context;
115: };
116:
117: /* Stack for maintaining contexts (in case functions or types are nested).
118: When defining a struct type, the `context' field is the RECORD_TYPE.
119: When defining a function, the `context' field is the FUNCTION_DECL. */
120:
121: static struct context_level *context_stack;
122:
123: static struct context_level *
124: push_context_level (stack, obstack)
125: struct stack_level *stack;
126: struct obstack *obstack;
127: {
128: struct context_level tem;
129:
130: tem.base.prev = stack;
131: return (struct context_level *)push_stack_level (obstack, &tem, sizeof (tem));
132: }
133:
134: /* Discard a level of search allocation. */
135:
136: static struct context_level *
137: pop_context_level (stack)
138: struct context_level *stack;
139: {
140: stack = (struct context_level *)pop_stack_level (stack);
141: return stack;
142: }
143:
144: void
145: init_cadillac ()
146: {
147: extern FILE *finput;
148: extern int errno;
149: CCompilerMessage* req;
150: cadillac_struct *cp = &cadillacObj;
151: int i;
152:
153: if (! flag_cadillac)
154: return;
155:
156: tree_to_cadillac_map = (CObjectType*) xmalloc (sizeof (CObjectType) * LAST_CPLUS_TREE_CODE);
157: for (i = 0; i < LAST_CPLUS_TREE_CODE; i++)
158: tree_to_cadillac_map[i] = MiscOType;
159: tree_to_cadillac_map[RECORD_TYPE] = StructOType;
160: tree_to_cadillac_map[UNION_TYPE] = UnionOType;
161: tree_to_cadillac_map[ENUMERAL_TYPE] = EnumTypeOType;
162: tree_to_cadillac_map[TYPE_DECL] = TypedefOType;
163: tree_to_cadillac_map[VAR_DECL] = VariableOType;
164: tree_to_cadillac_map[CONST_DECL] = EnumConstantOType;
165: tree_to_cadillac_map[FUNCTION_DECL] = FunctionOType;
166: tree_to_cadillac_map[FIELD_DECL] = FieldOType;
167:
168: #ifdef sun
169: on_exit (&exit_cadillac, 0);
170: #endif
171:
172: gcc_obstack_init (&cadillac_obstack);
173:
174: /* Yow! This is the way Cadillac was designed to deal with
175: Oregon C++ compiler! */
176: cp->fd_input = flag_cadillac;
177: cp->fd_output = flag_cadillac;
178:
179: /* Start in "turned-on" state. */
180: cp->messages = 1;
181: cp->conversion = 1;
182: cp->emission = 1;
183:
184: /* Establish a connection with Cadillac here. */
185: cp->conn = NewConnection (cp, cp->fd_input, cp->fd_output);
186:
187: CWriteHeader (cp->conn, WaitingMType, 0);
188: CWriteRequestBuffer (cp->conn);
189:
190: if (!readable_p (cp->fd_input))
191: ;
192:
193: req = CReadCompilerMessage (cp->conn);
194:
195: if (!req)
196: switch (errno)
197: {
198: case EWOULDBLOCK:
199: sleep (5);
200: return;
201:
202: case 0:
203: fatal ("init_cadillac: EOF on connection to kernel, exiting\n");
204: break;
205:
206: default:
207: perror ("Editor to kernel connection");
208: exit (0);
209: }
210: }
211:
212: static void
213: cadillac_process_requests (conn)
214: Connection *conn;
215: {
216: CCompilerMessage *req;
217: while (req = (CCompilerMessage*) CPeekNextRequest (conn))
218: {
219: req = CReadCompilerMessage (conn);
220: cadillac_process_request (&cadillacObj, req);
221: }
222: }
223:
224: static void
225: cadillac_process_request (cp, req)
226: cadillac_struct *cp;
227: CCompilerMessage *req;
228: {
229: if (! req)
230: return;
231:
232: switch (req->reqType)
233: {
234: case ProcessUntilMType:
235: if (cp->process_until)
236: my_friendly_abort (23);
237: cp->process_until = 1;
238: /* This is not really right. */
239: cp->end_position = ((CCompilerCommand*)req)->processuntil.position;
240: #if 0
241: cp->end_filename = req->processuntil.filename;
242: #endif
243: break;
244:
245: case CommandMType:
246: switch (req->header.data)
247: {
248: case MessagesOnCType:
249: cp->messages = 1;
250: break;
251: case MessagesOffCType:
252: cp->messages = 0;
253: break;
254: case ConversionOnCType:
255: cp->conversion = 1;
256: break;
257: case ConversionOffCType:
258: cp->conversion = 0;
259: break;
260: case EmissionOnCType:
261: cp->emission = 1;
262: break;
263: case EmissionOffCType:
264: cp->emission = 0;
265: break;
266:
267: case FinishAnalysisCType:
268: return;
269:
270: case PuntAnalysisCType:
271: case ContinueAnalysisCType:
272: case GotoFileposCType:
273: case OpenSucceededCType:
274: case OpenFailedCType:
275: fprintf (stderr, "request type %d not implemented\n", req->reqType);
276: return;
277:
278: case DieCType:
279: if (! exiting)
280: my_friendly_abort (24);
281: return;
282:
283: }
284: break;
285:
286: default:
287: fatal ("unknown request type %d", req->reqType);
288: }
289: }
290:
291: void
292: cadillac_start ()
293: {
294: Connection *conn = cadillacObj.conn;
295: CCompilerMessage *req;
296:
297: /* Let Cadillac know that we start in C++ language scope. */
298: CWriteHeader (conn, ForeignLinkageMType, LinkCPlus);
299: CWriteLength (conn);
300: CWriteRequestBuffer (conn);
301:
302: cadillac_process_requests (conn);
303: }
304:
305: static void
306: cadillac_printf (msg, name)
307: {
308: if (cadillacObj.messages)
309: printf ("[%s,%4d] %s `%s'\n", input_filename, lineno, msg, name);
310: }
311:
312: void
313: cadillac_start_decl (decl)
314: tree decl;
315: {
316: Connection *conn = cadillacObj.conn;
317: CObjectType object_type = tree_to_cadillac_map [TREE_CODE (decl)];
318:
319: if (context_stack)
320: switch (TREE_CODE (context_stack->context))
321: {
322: case FUNCTION_DECL:
323: /* Currently, cadillac only implements top-level forms. */
324: return;
325: case RECORD_TYPE:
326: case UNION_TYPE:
327: cadillac_printf ("start class-level decl", IDENTIFIER_POINTER (DECL_NAME (decl)));
328: break;
329: default:
330: my_friendly_abort (25);
331: }
332: else
333: {
334: cadillac_printf ("start top-level decl", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
335: CWriteTopLevel (conn, StartMType);
336: }
337:
338: CWriteLanguageDecl (conn, decl, tree_to_cadillac_map[TREE_CODE (decl)]);
339: CWriteRequestBuffer (conn);
340: cadillac_process_requests (conn);
341: }
342:
343: void
344: cadillac_finish_decl (decl)
345: tree decl;
346: {
347: Connection *conn = cadillacObj.conn;
348:
349: if (context_stack)
350: switch (TREE_CODE (context_stack->context))
351: {
352: case FUNCTION_DECL:
353: return;
354: case RECORD_TYPE:
355: case UNION_TYPE:
356: cadillac_printf ("end class-level decl", IDENTIFIER_POINTER (DECL_NAME (decl)));
357: CWriteHeader (conn, EndDefMType, 0);
358: CWriteLength (conn);
359: break;
360: default:
361: my_friendly_abort (26);
362: }
363: else
364: {
365: cadillac_printf ("end top-level decl", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
366: CWriteHeader (conn, EndDefMType, 0);
367: CWriteLength (conn);
368: CWriteTopLevel (conn, StopMType);
369: }
370:
371: CWriteRequestBuffer (conn);
372: cadillac_process_requests (conn);
373: }
374:
375: void
376: cadillac_start_function (fndecl)
377: tree fndecl;
378: {
379: Connection *conn = cadillacObj.conn;
380:
381: if (context_stack)
382: /* nested functions not yet handled. */
383: my_friendly_abort (27);
384:
385: cadillac_printf ("start top-level function", lang_printable_name (fndecl));
386: context_stack = push_context_level (context_stack, &cadillac_obstack);
387: context_stack->context = fndecl;
388:
389: CWriteTopLevel (conn, StartMType);
390: my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 202);
391: CWriteLanguageDecl (conn, fndecl,
392: (TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE
393: ? MemberFnOType : FunctionOType));
394: CWriteRequestBuffer (conn);
395: cadillac_process_requests (conn);
396: }
397:
398: void
399: cadillac_finish_function (fndecl)
400: tree fndecl;
401: {
402: Connection *conn = cadillacObj.conn;
403:
404: cadillac_printf ("end top-level function", lang_printable_name (fndecl));
405: context_stack = pop_context_level (context_stack);
406:
407: if (context_stack)
408: /* nested functions not yet implemented. */
409: my_friendly_abort (28);
410:
411: CWriteHeader (conn, EndDefMType, 0);
412: CWriteLength (conn);
413: CWriteTopLevel (conn, StopMType);
414: CWriteRequestBuffer (conn);
415: cadillac_process_requests (conn);
416: }
417:
418: void
419: cadillac_finish_anon_union (decl)
420: tree decl;
421: {
422: Connection *conn = cadillacObj.conn;
423:
424: if (! global_bindings_p ())
425: return;
426: cadillac_printf ("finish top-level anon union", "");
427: CWriteHeader (conn, EndDefMType, 0);
428: CWriteLength (conn);
429: CWriteTopLevel (conn, StopMType);
430: CWriteRequestBuffer (conn);
431: cadillac_process_requests (conn);
432: }
433:
434: void
435: cadillac_start_enum (type)
436: tree type;
437: {
438: Connection *conn = cadillacObj.conn;
439:
440: tree name = TYPE_NAME (type);
441:
442: if (TREE_CODE (name) == TYPE_DECL)
443: name = DECL_NAME (name);
444:
445: if (context_stack)
446: switch (TREE_CODE (context_stack->context))
447: {
448: case FUNCTION_DECL:
449: return;
450: case RECORD_TYPE:
451: case UNION_TYPE:
452: break;
453: default:
454: my_friendly_abort (29);
455: }
456: else
457: {
458: cadillac_printf ("start top-level enum", IDENTIFIER_POINTER (name));
459: CWriteTopLevel (conn, StartMType);
460: }
461:
462: CWriteLanguageType (conn, type, tree_to_cadillac_map[ENUMERAL_TYPE]);
463: }
464:
465: void
466: cadillac_finish_enum (type)
467: tree type;
468: {
469: Connection *conn = cadillacObj.conn;
470: tree name = TYPE_NAME (type);
471:
472: if (TREE_CODE (name) == TYPE_DECL)
473: name = DECL_NAME (name);
474:
475: if (context_stack)
476: switch (TREE_CODE (context_stack->context))
477: {
478: case FUNCTION_DECL:
479: return;
480: case RECORD_TYPE:
481: case UNION_TYPE:
482: CWriteHeader (conn, EndDefMType, 0);
483: CWriteLength (conn);
484: break;
485: default:
486: my_friendly_abort (30);
487: }
488: else
489: {
490: CWriteHeader (conn, EndDefMType, 0);
491: CWriteLength (conn);
492: cadillac_printf ("finish top-level enum", IDENTIFIER_POINTER (name));
493: CWriteTopLevel (conn, StopMType);
494: }
495:
496: CWriteRequestBuffer (conn);
497: cadillac_process_requests (conn);
498: }
499:
500: void
501: cadillac_start_struct (type)
502: tree type;
503: {
504: Connection *conn = cadillacObj.conn;
505: tree name = TYPE_NAME (type);
506:
507: if (TREE_CODE (name) == TYPE_DECL)
508: name = DECL_NAME (name);
509:
510: if (context_stack)
511: switch (TREE_CODE (context_stack->context))
512: {
513: case FUNCTION_DECL:
514: return;
515: case RECORD_TYPE:
516: case UNION_TYPE:
517: return;
518: default:
519: my_friendly_abort (31);
520: }
521: else
522: {
523: cadillac_printf ("start struct", IDENTIFIER_POINTER (name));
524: CWriteTopLevel (conn, StartMType);
525: }
526:
527: context_stack = push_context_level (context_stack, &cadillac_obstack);
528: context_stack->context = type;
529:
530: CWriteLanguageType (conn, type,
531: TYPE_LANG_SPECIFIC (type) && CLASSTYPE_DECLARED_CLASS (type) ? ClassOType : tree_to_cadillac_map[TREE_CODE (type)]);
532: }
533:
534: void
535: cadillac_finish_struct (type)
536: tree type;
537: {
538: Connection *conn = cadillacObj.conn;
539: tree name = TYPE_NAME (type);
540:
541: if (TREE_CODE (name) == TYPE_DECL)
542: name = DECL_NAME (name);
543:
544: context_stack = pop_context_level (context_stack);
545: if (context_stack)
546: return;
547:
548: cadillac_printf ("finish struct", IDENTIFIER_POINTER (name));
549: CWriteHeader (conn, EndDefMType, 0);
550: CWriteLength (conn);
551: CWriteTopLevel (conn, StopMType);
552: CWriteRequestBuffer (conn);
553: cadillac_process_requests (conn);
554: }
555:
556: void
557: cadillac_finish_exception (type)
558: tree type;
559: {
560: Connection *conn = cadillacObj.conn;
561:
562: fatal ("cadillac_finish_exception");
563: CWriteHeader (conn, EndDefMType, 0);
564: CWriteLength (conn);
565: CWriteTopLevel (conn, StopMType);
566: CWriteRequestBuffer (conn);
567: cadillac_process_requests (conn);
568: }
569:
570: void
571: cadillac_push_class (type)
572: tree type;
573: {
574: }
575:
576: void
577: cadillac_pop_class ()
578: {
579: }
580:
581: void
582: cadillac_push_lang (name)
583: tree name;
584: {
585: Connection *conn = cadillacObj.conn;
586: CLinkLanguageType m;
587:
588: if (name == lang_name_cplusplus)
589: m = LinkCPlus;
590: else if (name == lang_name_c)
591: m = LinkC;
592: else
593: my_friendly_abort (32);
594: CWriteHeader (conn, ForeignLinkageMType, m);
595: CWriteRequestBuffer (conn);
596: cadillac_process_requests (conn);
597: }
598:
599: void
600: cadillac_pop_lang ()
601: {
602: Connection *conn = cadillacObj.conn;
603:
604: CWriteHeader (conn, ForeignLinkageMType, LinkPop);
605: CWriteRequestBuffer (conn);
606: cadillac_process_requests (conn);
607: }
608:
609: void
610: cadillac_finish_stmt ()
611: {
612: }
613:
614: void
615: cadillac_note_source ()
616: {
617: cadillacObj.lineno = lineno;
618: cadillacObj.filename = input_filename;
619: }
620:
621: static void
622: CWriteTopLevel (conn, m)
623: Connection *conn;
624: CMessageSubType m;
625: {
626: static context_id = 0;
627: CWriteHeader (conn, TopLevelFormMType, m);
628: cadillac_note_filepos ();
629:
630: /* Eventually, this will point somewhere into the digest file. */
631: context_id += 1;
632: CWriteSomething (conn, &context_id, sizeof (BITS32));
633:
634: CWriteSomething (conn, &cadillacObj.iflevel, sizeof (BITS32));
635: CWriteLength (conn);
636: }
637:
638: static void
639: cadillac_note_filepos ()
640: {
641: extern FILE *finput;
642: int pos = ftell (finput);
643: CWriteSomething (cadillacObj.conn, &pos, sizeof (BITS32));
644: }
645:
646: void
647: cadillac_switch_source (startflag)
648: int startflag;
649: {
650: Connection *conn = cadillacObj.conn;
651: /* Send out the name of the source file being compiled. */
652:
653: CWriteHeader (conn, SourceFileMType, startflag ? StartMType : StopMType);
654: CWriteSomething (conn, &cadillacObj.depth, sizeof (BITS16));
655: CWriteVstring0 (conn, input_filename);
656: CWriteLength (conn);
657: CWriteRequestBuffer (conn);
658: cadillac_process_requests (conn);
659: }
660:
661: void
662: cadillac_push_source ()
663: {
664: cadillacObj.depth += 1;
665: cadillac_switch_source (1);
666: }
667:
668: void
669: cadillac_pop_source ()
670: {
671: cadillacObj.depth -= 1;
672: cadillac_switch_source (0);
673: }
674:
675: struct cadillac_mdep
676: {
677: short object_type;
678: char linkage;
679: char access;
680: short length;
681: };
682:
683: static void
684: CWriteLanguageElem (conn, p, name)
685: Connection *conn;
686: struct cadillac_mdep *p;
687: char *name;
688: {
689: CWriteSomething (conn, &p->object_type, sizeof (BITS16));
690: CWriteSomething (conn, &p->linkage, sizeof (BITS8));
691: CWriteSomething (conn, &p->access, sizeof (BITS8));
692: CWriteSomething (conn, &p->length, sizeof (BITS16));
693: CWriteVstring0 (conn, name);
694:
695: #if 0
696: /* Don't write date_type. */
697: CWriteVstring0 (conn, "");
698: #endif
699: CWriteLength (conn);
700: }
701:
702: static void
703: CWriteLanguageDecl (conn, decl, object_type)
704: Connection *conn;
705: tree decl;
706: CObjectType object_type;
707: {
708: struct cadillac_mdep foo;
709: tree name;
710:
711: CWriteHeader (conn, LanguageElementMType, StartDefineMType);
712: foo.object_type = object_type;
713: if (decl_type_context (decl))
714: {
715: foo.linkage = ParentLinkage;
716: if (TREE_PRIVATE (decl))
717: foo.access = PrivateAccess;
718: else if (TREE_PROTECTED (decl))
719: foo.access = ProtectedAccess;
720: else
721: foo.access = PublicAccess;
722: }
723: else
724: {
725: if (TREE_PUBLIC (decl))
726: foo.linkage = GlobalLinkage;
727: else
728: foo.linkage = FileLinkage;
729: foo.access = PublicAccess;
730: }
731: name = DECL_NAME (decl);
732: foo.length = IDENTIFIER_LENGTH (name);
733:
734: CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
735: CWriteRequestBuffer (conn);
736: cadillac_process_requests (conn);
737: }
738:
739: static void
740: CWriteLanguageType (conn, type, object_type)
741: Connection *conn;
742: tree type;
743: CObjectType object_type;
744: {
745: struct cadillac_mdep foo;
746: tree name = TYPE_NAME (type);
747:
748: CWriteHeader (conn, LanguageElementMType, StartDefineMType);
749: foo.object_type = object_type;
750: if (current_class_type)
751: {
752: foo.linkage = ParentLinkage;
753: if (TREE_PRIVATE (type))
754: foo.access = PrivateAccess;
755: else if (TREE_PROTECTED (type))
756: foo.access = ProtectedAccess;
757: else
758: foo.access = PublicAccess;
759: }
760: else
761: {
762: foo.linkage = NoLinkage;
763: foo.access = PublicAccess;
764: }
765: if (TREE_CODE (name) == TYPE_DECL)
766: name = DECL_NAME (name);
767:
768: foo.length = IDENTIFIER_LENGTH (name);
769:
770: CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
771: CWriteRequestBuffer (conn);
772: cadillac_process_requests (conn);
773: }
774:
775: static void
776: CWriteUseObject (conn, type, object_type, use)
777: Connection *conn;
778: tree type;
779: CObjectType object_type;
780: CMessageSubType use;
781: {
782: struct cadillac_mdep foo;
783: tree name = NULL_TREE;
784:
785: CWriteHeader (conn, LanguageElementMType, use);
786: foo.object_type = object_type;
787: if (current_class_type)
788: {
789: foo.linkage = ParentLinkage;
790: if (TREE_PRIVATE (type))
791: foo.access = PrivateAccess;
792: else if (TREE_PROTECTED (type))
793: foo.access = ProtectedAccess;
794: else
795: foo.access = PublicAccess;
796: }
797: else
798: {
799: foo.linkage = NoLinkage;
800: foo.access = PublicAccess;
801: }
802: switch (TREE_CODE (type))
803: {
804: case VAR_DECL:
805: case FIELD_DECL:
806: case TYPE_DECL:
807: case CONST_DECL:
808: case FUNCTION_DECL:
809: name = DECL_NAME (type);
810: break;
811:
812: default:
813: my_friendly_abort (33);
814: }
815:
816: foo.length = IDENTIFIER_LENGTH (name);
817:
818: CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
819: CWriteRequestBuffer (conn);
820: cadillac_process_requests (conn);
821: }
822:
823: /* Here's how we exit under cadillac. */
824:
825: static void
826: exit_cadillac ()
827: {
828: extern int errorcount;
829:
830: Connection *conn = cadillacObj.conn;
831:
832: if (flag_cadillac)
833: {
834: CCompilerMessage *req;
835:
836: CWriteHeader (conn, FinishedMType,
837: errorcount ? 0 : CsObjectWritten | CsComplete);
838: /* Bye, bye! */
839: CWriteRequestBuffer (conn);
840:
841: /* Block on read. */
842: while (! readable_p (cadillacObj.fd_input))
843: {
844: if (exiting)
845: my_friendly_abort (34);
846: exiting = 1;
847: }
848: exiting = 1;
849:
850: req = CReadCompilerMessage (conn);
851: cadillac_process_request (&cadillacObj, req);
852: }
853: }
854:
855: #else
856: /* Stubs. */
857: void init_cadillac () {}
858: void cadillac_start () {}
859: void cadillac_start_decl (decl)
860: tree decl;
861: {}
862: void
863: cadillac_finish_decl (decl)
864: tree decl;
865: {}
866: void
867: cadillac_start_function (fndecl)
868: tree fndecl;
869: {}
870: void
871: cadillac_finish_function (fndecl)
872: tree fndecl;
873: {}
874: void
875: cadillac_finish_anon_union (decl)
876: tree decl;
877: {}
878: void
879: cadillac_start_enum (type)
880: tree type;
881: {}
882: void
883: cadillac_finish_enum (type)
884: tree type;
885: {}
886: void
887: cadillac_start_struct (type)
888: tree type;
889: {}
890: void
891: cadillac_finish_struct (type)
892: tree type;
893: {}
894: void
895: cadillac_finish_exception (type)
896: tree type;
897: {}
898: void
899: cadillac_push_class (type)
900: tree type;
901: {}
902: void
903: cadillac_pop_class ()
904: {}
905: void
906: cadillac_push_lang (name)
907: tree name;
908: {}
909: void
910: cadillac_pop_lang ()
911: {}
912: void
913: cadillac_note_source ()
914: {}
915: void
916: cadillac_finish_stmt ()
917: {}
918: void
919: cadillac_switch_source ()
920: {}
921: void
922: cadillac_push_source ()
923: {}
924: void
925: cadillac_pop_source ()
926: {}
927: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.