928 lines
20 KiB
C
928 lines
20 KiB
C
/* Interface to LUCID Cadillac system for GNU compiler.
|
||
Copyright (C) 1988, 1992, 1993 Free Software Foundation, Inc.
|
||
|
||
This file is part of GNU CC.
|
||
|
||
GNU CC is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 2, or (at your option)
|
||
any later version.
|
||
|
||
GNU CC is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with GNU CC; see the file COPYING. If not, write to
|
||
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||
|
||
#include "config.h"
|
||
|
||
#include "tree.h"
|
||
#include "flags.h"
|
||
#include <stdio.h>
|
||
#include "cp-tree.h"
|
||
#include "obstack.h"
|
||
|
||
#ifdef CADILLAC
|
||
#include <compilerreq.h>
|
||
#include <compilerconn.h>
|
||
#include <sys/time.h>
|
||
#include <sys/types.h>
|
||
#include <errno.h>
|
||
#include <sys/file.h>
|
||
|
||
#define obstack_chunk_alloc xmalloc
|
||
#define obstack_chunk_free free
|
||
|
||
void init_cadillac ();
|
||
|
||
extern char *input_filename;
|
||
extern int lineno;
|
||
|
||
/* Put random information we might want to get back from
|
||
Cadillac here. */
|
||
typedef struct
|
||
{
|
||
/* The connection to the Cadillac kernel. */
|
||
Connection *conn;
|
||
|
||
/* Input and output file descriptors for Cadillac. */
|
||
short fd_input, fd_output;
|
||
|
||
/* #include nesting of current file. */
|
||
short depth;
|
||
|
||
/* State variables for the connection. */
|
||
char messages;
|
||
char conversion;
|
||
char emission;
|
||
char process_until;
|
||
|
||
/* #if level of current file. */
|
||
int iflevel;
|
||
|
||
/* Line number that starts current source file. */
|
||
int lineno;
|
||
|
||
/* Name of current file. */
|
||
char *filename;
|
||
|
||
/* Where to stop processing (if process_until is set). */
|
||
char *end_filename;
|
||
int end_position;
|
||
|
||
} cadillac_struct;
|
||
static cadillac_struct cadillacObj;
|
||
|
||
/* Nonzero if in the process of exiting. */
|
||
static int exiting;
|
||
|
||
void cadillac_note_source ();
|
||
static void CWriteLanguageDecl ();
|
||
static void CWriteLanguageType ();
|
||
static void CWriteTopLevel ();
|
||
static void cadillac_note_filepos ();
|
||
static void cadillac_process_request (), cadillac_process_requests ();
|
||
static void cadillac_switch_source ();
|
||
static void exit_cadillac ();
|
||
|
||
/* Blocking test. */
|
||
static int
|
||
readable_p (fd)
|
||
int fd;
|
||
{
|
||
fd_set f;
|
||
|
||
FD_ZERO (&f);
|
||
FD_SET (fd, &f);
|
||
|
||
return select (32, &f, NULL, NULL, 0) == 1;
|
||
}
|
||
|
||
static CObjectType *tree_to_cadillac_map;
|
||
struct obstack cadillac_obstack;
|
||
|
||
|
||
#include "stack.h"
|
||
|
||
struct context_level
|
||
{
|
||
struct stack_level base;
|
||
|
||
tree context;
|
||
};
|
||
|
||
/* Stack for maintaining contexts (in case functions or types are nested).
|
||
When defining a struct type, the `context' field is the RECORD_TYPE.
|
||
When defining a function, the `context' field is the FUNCTION_DECL. */
|
||
|
||
static struct context_level *context_stack;
|
||
|
||
static struct context_level *
|
||
push_context_level (stack, obstack)
|
||
struct stack_level *stack;
|
||
struct obstack *obstack;
|
||
{
|
||
struct context_level tem;
|
||
|
||
tem.base.prev = stack;
|
||
return (struct context_level *)push_stack_level (obstack, &tem, sizeof (tem));
|
||
}
|
||
|
||
/* Discard a level of search allocation. */
|
||
|
||
static struct context_level *
|
||
pop_context_level (stack)
|
||
struct context_level *stack;
|
||
{
|
||
stack = (struct context_level *)pop_stack_level (stack);
|
||
return stack;
|
||
}
|
||
|
||
void
|
||
init_cadillac ()
|
||
{
|
||
extern FILE *finput;
|
||
extern int errno;
|
||
CCompilerMessage* req;
|
||
cadillac_struct *cp = &cadillacObj;
|
||
int i;
|
||
|
||
if (! flag_cadillac)
|
||
return;
|
||
|
||
tree_to_cadillac_map = (CObjectType*) xmalloc (sizeof (CObjectType) * LAST_CPLUS_TREE_CODE);
|
||
for (i = 0; i < LAST_CPLUS_TREE_CODE; i++)
|
||
tree_to_cadillac_map[i] = MiscOType;
|
||
tree_to_cadillac_map[RECORD_TYPE] = StructOType;
|
||
tree_to_cadillac_map[UNION_TYPE] = UnionOType;
|
||
tree_to_cadillac_map[ENUMERAL_TYPE] = EnumTypeOType;
|
||
tree_to_cadillac_map[TYPE_DECL] = TypedefOType;
|
||
tree_to_cadillac_map[VAR_DECL] = VariableOType;
|
||
tree_to_cadillac_map[CONST_DECL] = EnumConstantOType;
|
||
tree_to_cadillac_map[FUNCTION_DECL] = FunctionOType;
|
||
tree_to_cadillac_map[FIELD_DECL] = FieldOType;
|
||
|
||
#ifdef sun
|
||
on_exit (&exit_cadillac, 0);
|
||
#endif
|
||
|
||
gcc_obstack_init (&cadillac_obstack);
|
||
|
||
/* Yow! This is the way Cadillac was designed to deal with
|
||
Oregon C++ compiler! */
|
||
cp->fd_input = flag_cadillac;
|
||
cp->fd_output = flag_cadillac;
|
||
|
||
/* Start in "turned-on" state. */
|
||
cp->messages = 1;
|
||
cp->conversion = 1;
|
||
cp->emission = 1;
|
||
|
||
/* Establish a connection with Cadillac here. */
|
||
cp->conn = NewConnection (cp, cp->fd_input, cp->fd_output);
|
||
|
||
CWriteHeader (cp->conn, WaitingMType, 0);
|
||
CWriteRequestBuffer (cp->conn);
|
||
|
||
if (!readable_p (cp->fd_input))
|
||
;
|
||
|
||
req = CReadCompilerMessage (cp->conn);
|
||
|
||
if (!req)
|
||
switch (errno)
|
||
{
|
||
case EWOULDBLOCK:
|
||
sleep (5);
|
||
return;
|
||
|
||
case 0:
|
||
fatal ("init_cadillac: EOF on connection to kernel, exiting\n");
|
||
break;
|
||
|
||
default:
|
||
perror ("Editor to kernel connection");
|
||
exit (0);
|
||
}
|
||
}
|
||
|
||
static void
|
||
cadillac_process_requests (conn)
|
||
Connection *conn;
|
||
{
|
||
CCompilerMessage *req;
|
||
while (req = (CCompilerMessage*) CPeekNextRequest (conn))
|
||
{
|
||
req = CReadCompilerMessage (conn);
|
||
cadillac_process_request (&cadillacObj, req);
|
||
}
|
||
}
|
||
|
||
static void
|
||
cadillac_process_request (cp, req)
|
||
cadillac_struct *cp;
|
||
CCompilerMessage *req;
|
||
{
|
||
if (! req)
|
||
return;
|
||
|
||
switch (req->reqType)
|
||
{
|
||
case ProcessUntilMType:
|
||
if (cp->process_until)
|
||
my_friendly_abort (23);
|
||
cp->process_until = 1;
|
||
/* This is not really right. */
|
||
cp->end_position = ((CCompilerCommand*)req)->processuntil.position;
|
||
#if 0
|
||
cp->end_filename = req->processuntil.filename;
|
||
#endif
|
||
break;
|
||
|
||
case CommandMType:
|
||
switch (req->header.data)
|
||
{
|
||
case MessagesOnCType:
|
||
cp->messages = 1;
|
||
break;
|
||
case MessagesOffCType:
|
||
cp->messages = 0;
|
||
break;
|
||
case ConversionOnCType:
|
||
cp->conversion = 1;
|
||
break;
|
||
case ConversionOffCType:
|
||
cp->conversion = 0;
|
||
break;
|
||
case EmissionOnCType:
|
||
cp->emission = 1;
|
||
break;
|
||
case EmissionOffCType:
|
||
cp->emission = 0;
|
||
break;
|
||
|
||
case FinishAnalysisCType:
|
||
return;
|
||
|
||
case PuntAnalysisCType:
|
||
case ContinueAnalysisCType:
|
||
case GotoFileposCType:
|
||
case OpenSucceededCType:
|
||
case OpenFailedCType:
|
||
fprintf (stderr, "request type %d not implemented\n", req->reqType);
|
||
return;
|
||
|
||
case DieCType:
|
||
if (! exiting)
|
||
my_friendly_abort (24);
|
||
return;
|
||
|
||
}
|
||
break;
|
||
|
||
default:
|
||
fatal ("unknown request type %d", req->reqType);
|
||
}
|
||
}
|
||
|
||
void
|
||
cadillac_start ()
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
CCompilerMessage *req;
|
||
|
||
/* Let Cadillac know that we start in C++ language scope. */
|
||
CWriteHeader (conn, ForeignLinkageMType, LinkCPlus);
|
||
CWriteLength (conn);
|
||
CWriteRequestBuffer (conn);
|
||
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
static void
|
||
cadillac_printf (msg, name)
|
||
{
|
||
if (cadillacObj.messages)
|
||
printf ("[%s,%4d] %s `%s'\n", input_filename, lineno, msg, name);
|
||
}
|
||
|
||
void
|
||
cadillac_start_decl (decl)
|
||
tree decl;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
CObjectType object_type = tree_to_cadillac_map [TREE_CODE (decl)];
|
||
|
||
if (context_stack)
|
||
switch (TREE_CODE (context_stack->context))
|
||
{
|
||
case FUNCTION_DECL:
|
||
/* Currently, cadillac only implements top-level forms. */
|
||
return;
|
||
case RECORD_TYPE:
|
||
case UNION_TYPE:
|
||
cadillac_printf ("start class-level decl", IDENTIFIER_POINTER (DECL_NAME (decl)));
|
||
break;
|
||
default:
|
||
my_friendly_abort (25);
|
||
}
|
||
else
|
||
{
|
||
cadillac_printf ("start top-level decl", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
|
||
CWriteTopLevel (conn, StartMType);
|
||
}
|
||
|
||
CWriteLanguageDecl (conn, decl, tree_to_cadillac_map[TREE_CODE (decl)]);
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_finish_decl (decl)
|
||
tree decl;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
|
||
if (context_stack)
|
||
switch (TREE_CODE (context_stack->context))
|
||
{
|
||
case FUNCTION_DECL:
|
||
return;
|
||
case RECORD_TYPE:
|
||
case UNION_TYPE:
|
||
cadillac_printf ("end class-level decl", IDENTIFIER_POINTER (DECL_NAME (decl)));
|
||
CWriteHeader (conn, EndDefMType, 0);
|
||
CWriteLength (conn);
|
||
break;
|
||
default:
|
||
my_friendly_abort (26);
|
||
}
|
||
else
|
||
{
|
||
cadillac_printf ("end top-level decl", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
|
||
CWriteHeader (conn, EndDefMType, 0);
|
||
CWriteLength (conn);
|
||
CWriteTopLevel (conn, StopMType);
|
||
}
|
||
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_start_function (fndecl)
|
||
tree fndecl;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
|
||
if (context_stack)
|
||
/* nested functions not yet handled. */
|
||
my_friendly_abort (27);
|
||
|
||
cadillac_printf ("start top-level function", lang_printable_name (fndecl));
|
||
context_stack = push_context_level (context_stack, &cadillac_obstack);
|
||
context_stack->context = fndecl;
|
||
|
||
CWriteTopLevel (conn, StartMType);
|
||
my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 202);
|
||
CWriteLanguageDecl (conn, fndecl,
|
||
(TREE_CODE (TREE_TYPE (fndecl)) == METHOD_TYPE
|
||
? MemberFnOType : FunctionOType));
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_finish_function (fndecl)
|
||
tree fndecl;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
|
||
cadillac_printf ("end top-level function", lang_printable_name (fndecl));
|
||
context_stack = pop_context_level (context_stack);
|
||
|
||
if (context_stack)
|
||
/* nested functions not yet implemented. */
|
||
my_friendly_abort (28);
|
||
|
||
CWriteHeader (conn, EndDefMType, 0);
|
||
CWriteLength (conn);
|
||
CWriteTopLevel (conn, StopMType);
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_finish_anon_union (decl)
|
||
tree decl;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
|
||
if (! global_bindings_p ())
|
||
return;
|
||
cadillac_printf ("finish top-level anon union", "");
|
||
CWriteHeader (conn, EndDefMType, 0);
|
||
CWriteLength (conn);
|
||
CWriteTopLevel (conn, StopMType);
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_start_enum (type)
|
||
tree type;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
|
||
tree name = TYPE_NAME (type);
|
||
|
||
if (TREE_CODE (name) == TYPE_DECL)
|
||
name = DECL_NAME (name);
|
||
|
||
if (context_stack)
|
||
switch (TREE_CODE (context_stack->context))
|
||
{
|
||
case FUNCTION_DECL:
|
||
return;
|
||
case RECORD_TYPE:
|
||
case UNION_TYPE:
|
||
break;
|
||
default:
|
||
my_friendly_abort (29);
|
||
}
|
||
else
|
||
{
|
||
cadillac_printf ("start top-level enum", IDENTIFIER_POINTER (name));
|
||
CWriteTopLevel (conn, StartMType);
|
||
}
|
||
|
||
CWriteLanguageType (conn, type, tree_to_cadillac_map[ENUMERAL_TYPE]);
|
||
}
|
||
|
||
void
|
||
cadillac_finish_enum (type)
|
||
tree type;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
tree name = TYPE_NAME (type);
|
||
|
||
if (TREE_CODE (name) == TYPE_DECL)
|
||
name = DECL_NAME (name);
|
||
|
||
if (context_stack)
|
||
switch (TREE_CODE (context_stack->context))
|
||
{
|
||
case FUNCTION_DECL:
|
||
return;
|
||
case RECORD_TYPE:
|
||
case UNION_TYPE:
|
||
CWriteHeader (conn, EndDefMType, 0);
|
||
CWriteLength (conn);
|
||
break;
|
||
default:
|
||
my_friendly_abort (30);
|
||
}
|
||
else
|
||
{
|
||
CWriteHeader (conn, EndDefMType, 0);
|
||
CWriteLength (conn);
|
||
cadillac_printf ("finish top-level enum", IDENTIFIER_POINTER (name));
|
||
CWriteTopLevel (conn, StopMType);
|
||
}
|
||
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_start_struct (type)
|
||
tree type;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
tree name = TYPE_NAME (type);
|
||
|
||
if (TREE_CODE (name) == TYPE_DECL)
|
||
name = DECL_NAME (name);
|
||
|
||
if (context_stack)
|
||
switch (TREE_CODE (context_stack->context))
|
||
{
|
||
case FUNCTION_DECL:
|
||
return;
|
||
case RECORD_TYPE:
|
||
case UNION_TYPE:
|
||
return;
|
||
default:
|
||
my_friendly_abort (31);
|
||
}
|
||
else
|
||
{
|
||
cadillac_printf ("start struct", IDENTIFIER_POINTER (name));
|
||
CWriteTopLevel (conn, StartMType);
|
||
}
|
||
|
||
context_stack = push_context_level (context_stack, &cadillac_obstack);
|
||
context_stack->context = type;
|
||
|
||
CWriteLanguageType (conn, type,
|
||
TYPE_LANG_SPECIFIC (type) && CLASSTYPE_DECLARED_CLASS (type) ? ClassOType : tree_to_cadillac_map[TREE_CODE (type)]);
|
||
}
|
||
|
||
void
|
||
cadillac_finish_struct (type)
|
||
tree type;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
tree name = TYPE_NAME (type);
|
||
|
||
if (TREE_CODE (name) == TYPE_DECL)
|
||
name = DECL_NAME (name);
|
||
|
||
context_stack = pop_context_level (context_stack);
|
||
if (context_stack)
|
||
return;
|
||
|
||
cadillac_printf ("finish struct", IDENTIFIER_POINTER (name));
|
||
CWriteHeader (conn, EndDefMType, 0);
|
||
CWriteLength (conn);
|
||
CWriteTopLevel (conn, StopMType);
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_finish_exception (type)
|
||
tree type;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
|
||
fatal ("cadillac_finish_exception");
|
||
CWriteHeader (conn, EndDefMType, 0);
|
||
CWriteLength (conn);
|
||
CWriteTopLevel (conn, StopMType);
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_push_class (type)
|
||
tree type;
|
||
{
|
||
}
|
||
|
||
void
|
||
cadillac_pop_class ()
|
||
{
|
||
}
|
||
|
||
void
|
||
cadillac_push_lang (name)
|
||
tree name;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
CLinkLanguageType m;
|
||
|
||
if (name == lang_name_cplusplus)
|
||
m = LinkCPlus;
|
||
else if (name == lang_name_c)
|
||
m = LinkC;
|
||
else
|
||
my_friendly_abort (32);
|
||
CWriteHeader (conn, ForeignLinkageMType, m);
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_pop_lang ()
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
|
||
CWriteHeader (conn, ForeignLinkageMType, LinkPop);
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_finish_stmt ()
|
||
{
|
||
}
|
||
|
||
void
|
||
cadillac_note_source ()
|
||
{
|
||
cadillacObj.lineno = lineno;
|
||
cadillacObj.filename = input_filename;
|
||
}
|
||
|
||
static void
|
||
CWriteTopLevel (conn, m)
|
||
Connection *conn;
|
||
CMessageSubType m;
|
||
{
|
||
static context_id = 0;
|
||
CWriteHeader (conn, TopLevelFormMType, m);
|
||
cadillac_note_filepos ();
|
||
|
||
/* Eventually, this will point somewhere into the digest file. */
|
||
context_id += 1;
|
||
CWriteSomething (conn, &context_id, sizeof (BITS32));
|
||
|
||
CWriteSomething (conn, &cadillacObj.iflevel, sizeof (BITS32));
|
||
CWriteLength (conn);
|
||
}
|
||
|
||
static void
|
||
cadillac_note_filepos ()
|
||
{
|
||
extern FILE *finput;
|
||
int pos = ftell (finput);
|
||
CWriteSomething (cadillacObj.conn, &pos, sizeof (BITS32));
|
||
}
|
||
|
||
void
|
||
cadillac_switch_source (startflag)
|
||
int startflag;
|
||
{
|
||
Connection *conn = cadillacObj.conn;
|
||
/* Send out the name of the source file being compiled. */
|
||
|
||
CWriteHeader (conn, SourceFileMType, startflag ? StartMType : StopMType);
|
||
CWriteSomething (conn, &cadillacObj.depth, sizeof (BITS16));
|
||
CWriteVstring0 (conn, input_filename);
|
||
CWriteLength (conn);
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
void
|
||
cadillac_push_source ()
|
||
{
|
||
cadillacObj.depth += 1;
|
||
cadillac_switch_source (1);
|
||
}
|
||
|
||
void
|
||
cadillac_pop_source ()
|
||
{
|
||
cadillacObj.depth -= 1;
|
||
cadillac_switch_source (0);
|
||
}
|
||
|
||
struct cadillac_mdep
|
||
{
|
||
short object_type;
|
||
char linkage;
|
||
char access;
|
||
short length;
|
||
};
|
||
|
||
static void
|
||
CWriteLanguageElem (conn, p, name)
|
||
Connection *conn;
|
||
struct cadillac_mdep *p;
|
||
char *name;
|
||
{
|
||
CWriteSomething (conn, &p->object_type, sizeof (BITS16));
|
||
CWriteSomething (conn, &p->linkage, sizeof (BITS8));
|
||
CWriteSomething (conn, &p->access, sizeof (BITS8));
|
||
CWriteSomething (conn, &p->length, sizeof (BITS16));
|
||
CWriteVstring0 (conn, name);
|
||
|
||
#if 0
|
||
/* Don't write date_type. */
|
||
CWriteVstring0 (conn, "");
|
||
#endif
|
||
CWriteLength (conn);
|
||
}
|
||
|
||
static void
|
||
CWriteLanguageDecl (conn, decl, object_type)
|
||
Connection *conn;
|
||
tree decl;
|
||
CObjectType object_type;
|
||
{
|
||
struct cadillac_mdep foo;
|
||
tree name;
|
||
|
||
CWriteHeader (conn, LanguageElementMType, StartDefineMType);
|
||
foo.object_type = object_type;
|
||
if (decl_type_context (decl))
|
||
{
|
||
foo.linkage = ParentLinkage;
|
||
if (TREE_PRIVATE (decl))
|
||
foo.access = PrivateAccess;
|
||
else if (TREE_PROTECTED (decl))
|
||
foo.access = ProtectedAccess;
|
||
else
|
||
foo.access = PublicAccess;
|
||
}
|
||
else
|
||
{
|
||
if (TREE_PUBLIC (decl))
|
||
foo.linkage = GlobalLinkage;
|
||
else
|
||
foo.linkage = FileLinkage;
|
||
foo.access = PublicAccess;
|
||
}
|
||
name = DECL_NAME (decl);
|
||
foo.length = IDENTIFIER_LENGTH (name);
|
||
|
||
CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
static void
|
||
CWriteLanguageType (conn, type, object_type)
|
||
Connection *conn;
|
||
tree type;
|
||
CObjectType object_type;
|
||
{
|
||
struct cadillac_mdep foo;
|
||
tree name = TYPE_NAME (type);
|
||
|
||
CWriteHeader (conn, LanguageElementMType, StartDefineMType);
|
||
foo.object_type = object_type;
|
||
if (current_class_type)
|
||
{
|
||
foo.linkage = ParentLinkage;
|
||
if (TREE_PRIVATE (type))
|
||
foo.access = PrivateAccess;
|
||
else if (TREE_PROTECTED (type))
|
||
foo.access = ProtectedAccess;
|
||
else
|
||
foo.access = PublicAccess;
|
||
}
|
||
else
|
||
{
|
||
foo.linkage = NoLinkage;
|
||
foo.access = PublicAccess;
|
||
}
|
||
if (TREE_CODE (name) == TYPE_DECL)
|
||
name = DECL_NAME (name);
|
||
|
||
foo.length = IDENTIFIER_LENGTH (name);
|
||
|
||
CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
static void
|
||
CWriteUseObject (conn, type, object_type, use)
|
||
Connection *conn;
|
||
tree type;
|
||
CObjectType object_type;
|
||
CMessageSubType use;
|
||
{
|
||
struct cadillac_mdep foo;
|
||
tree name = NULL_TREE;
|
||
|
||
CWriteHeader (conn, LanguageElementMType, use);
|
||
foo.object_type = object_type;
|
||
if (current_class_type)
|
||
{
|
||
foo.linkage = ParentLinkage;
|
||
if (TREE_PRIVATE (type))
|
||
foo.access = PrivateAccess;
|
||
else if (TREE_PROTECTED (type))
|
||
foo.access = ProtectedAccess;
|
||
else
|
||
foo.access = PublicAccess;
|
||
}
|
||
else
|
||
{
|
||
foo.linkage = NoLinkage;
|
||
foo.access = PublicAccess;
|
||
}
|
||
switch (TREE_CODE (type))
|
||
{
|
||
case VAR_DECL:
|
||
case FIELD_DECL:
|
||
case TYPE_DECL:
|
||
case CONST_DECL:
|
||
case FUNCTION_DECL:
|
||
name = DECL_NAME (type);
|
||
break;
|
||
|
||
default:
|
||
my_friendly_abort (33);
|
||
}
|
||
|
||
foo.length = IDENTIFIER_LENGTH (name);
|
||
|
||
CWriteLanguageElem (conn, &foo, IDENTIFIER_POINTER (name));
|
||
CWriteRequestBuffer (conn);
|
||
cadillac_process_requests (conn);
|
||
}
|
||
|
||
/* Here's how we exit under cadillac. */
|
||
|
||
static void
|
||
exit_cadillac ()
|
||
{
|
||
extern int errorcount;
|
||
|
||
Connection *conn = cadillacObj.conn;
|
||
|
||
if (flag_cadillac)
|
||
{
|
||
CCompilerMessage *req;
|
||
|
||
CWriteHeader (conn, FinishedMType,
|
||
errorcount ? 0 : CsObjectWritten | CsComplete);
|
||
/* Bye, bye! */
|
||
CWriteRequestBuffer (conn);
|
||
|
||
/* Block on read. */
|
||
while (! readable_p (cadillacObj.fd_input))
|
||
{
|
||
if (exiting)
|
||
my_friendly_abort (34);
|
||
exiting = 1;
|
||
}
|
||
exiting = 1;
|
||
|
||
req = CReadCompilerMessage (conn);
|
||
cadillac_process_request (&cadillacObj, req);
|
||
}
|
||
}
|
||
|
||
#else
|
||
/* Stubs. */
|
||
void init_cadillac () {}
|
||
void cadillac_start () {}
|
||
void cadillac_start_decl (decl)
|
||
tree decl;
|
||
{}
|
||
void
|
||
cadillac_finish_decl (decl)
|
||
tree decl;
|
||
{}
|
||
void
|
||
cadillac_start_function (fndecl)
|
||
tree fndecl;
|
||
{}
|
||
void
|
||
cadillac_finish_function (fndecl)
|
||
tree fndecl;
|
||
{}
|
||
void
|
||
cadillac_finish_anon_union (decl)
|
||
tree decl;
|
||
{}
|
||
void
|
||
cadillac_start_enum (type)
|
||
tree type;
|
||
{}
|
||
void
|
||
cadillac_finish_enum (type)
|
||
tree type;
|
||
{}
|
||
void
|
||
cadillac_start_struct (type)
|
||
tree type;
|
||
{}
|
||
void
|
||
cadillac_finish_struct (type)
|
||
tree type;
|
||
{}
|
||
void
|
||
cadillac_finish_exception (type)
|
||
tree type;
|
||
{}
|
||
void
|
||
cadillac_push_class (type)
|
||
tree type;
|
||
{}
|
||
void
|
||
cadillac_pop_class ()
|
||
{}
|
||
void
|
||
cadillac_push_lang (name)
|
||
tree name;
|
||
{}
|
||
void
|
||
cadillac_pop_lang ()
|
||
{}
|
||
void
|
||
cadillac_note_source ()
|
||
{}
|
||
void
|
||
cadillac_finish_stmt ()
|
||
{}
|
||
void
|
||
cadillac_switch_source ()
|
||
{}
|
||
void
|
||
cadillac_push_source ()
|
||
{}
|
||
void
|
||
cadillac_pop_source ()
|
||
{}
|
||
#endif
|