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