contrib/gcc/cp/edsel.c

   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 \f
 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 \f
 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 \f
 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 \f
 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