// Return a function type.
llvm::Type*
Generator::gen_type(Function_type const& t)
{
std::vector<llvm::Type*> parms;
parms.reserve(t.parameter_types().size());
for (Type const& pt : t.parameter_types())
parms.push_back(gen_type(pt));
llvm::Type* ret = gen_type(t.return_type());
return llvm::FunctionType::get(ret, parms, false);
}
// Return an array type.
//
// FIXME: The complete array type's extent should already have been
// evaluated.
llvm::Type*
Generator::gen_type(Array_type const& t)
{
llvm::Type* t1 = gen_type(t.element_type());
Value v = evaluate(banjo, t.extent());
return llvm::ArrayType::get(t1, v.get_integer());
}
// Return a tuple type.
llvm::Type*
Generator::gen_type(Tuple_type const& t)
{
Type_list const& ts = t.element_types();
// Handle the empty case specially.
if (ts.empty())
return llvm::StructType::get(cxt);
// Generate a literal struct type.
std::vector<llvm::Type*> types;
types.reserve(t.element_types().size());
for (Type const& t1 : t.element_types())
types.push_back(gen_type(t1));
return llvm::StructType::get(cxt, types);
}
void jvmcodegen::gen_node(const ast::node_ptr &node) {
switch (node->type) {
// case ast::no_node: gen_node(node); break;
case ast::integer_node: gen_integer(node); break;
case ast::string_node: gen_string(node); break;
case ast::if_stmt_node: gen_if_stmt(node); break;
case ast::while_stmt_node: gen_while_stmt(node); break;
case ast::return_stmt_node: gen_return_stmt(node); break;
case ast::variable_node: gen_variable(node); break;
case ast::assign_stmt_node: gen_assign_stmt(node); break;
case ast::call_node: gen_call(node); break;
case ast::op_arithm_node: gen_op_arithm(node); break;
case ast::op_logical_node: gen_op_logical(node); break;
case ast::program_node: gen_program(node); break;
case ast::type_node: gen_type(node); break;
case ast::argument_node: gen_argument(node); break;
case ast::variable_decl_node: gen_variable_decl(node); break;
case ast::function_decl_node: gen_function_decl(node); break;
case ast::read_stmt_node: gen_read_stmt(node); break;
case ast::write_stmt_node: gen_write_stmt(node); break;
}
}
static const char *
gen_decl (tree decl, int is_func_definition, formals_style style)
{
const char *ret_val;
if (DECL_NAME (decl))
ret_val = IDENTIFIER_POINTER (DECL_NAME (decl));
else
ret_val = "";
/* If we are just generating a list of names of formal parameters, we can
simply return the formal parameter name (with no typing information
attached to it) now. */
if (style == k_and_r_names)
return ret_val;
/* Note that for the declaration of some entity (either a function or a
data object, like for instance a parameter) if the entity itself was
declared as either const or volatile, then const and volatile properties
are associated with just the declaration of the entity, and *not* with
the `type' of the entity. Thus, for such declared entities, we have to
generate the qualifiers here. */
if (TREE_THIS_VOLATILE (decl))
ret_val = concat ("volatile ", ret_val, NULL);
if (TREE_READONLY (decl))
ret_val = concat ("const ", ret_val, NULL);
data_type = "";
/* For FUNCTION_DECL nodes, there are two possible cases here. First, if
this FUNCTION_DECL node was generated from a function "definition", then
we will have a list of DECL_NODE's, one for each of the function's formal
parameters. In this case, we can print out not only the types of each
formal, but also each formal's name. In the second case, this
FUNCTION_DECL node came from an actual function declaration (and *not*
a definition). In this case, we do nothing here because the formal
argument type-list will be output later, when the "type" of the function
is added to the string we are building. Note that the ANSI-style formal
parameter list is considered to be a (suffix) part of the "type" of the
function. */
if (TREE_CODE (decl) == FUNCTION_DECL && is_func_definition)
{
ret_val = concat (ret_val, gen_formal_list_for_func_def (decl, ansi),
NULL);
/* Since we have already added in the formals list stuff, here we don't
add the whole "type" of the function we are considering (which
would include its parameter-list info), rather, we only add in
the "type" of the "type" of the function, which is really just
the return-type of the function (and does not include the parameter
list info). */
ret_val = gen_type (ret_val, TREE_TYPE (TREE_TYPE (decl)), style);
}
else
ret_val = gen_type (ret_val, TREE_TYPE (decl), style);
ret_val = affix_data_type (ret_val);
if (TREE_CODE (decl) != FUNCTION_DECL && C_DECL_REGISTER (decl))
ret_val = concat ("register ", ret_val, NULL);
if (TREE_PUBLIC (decl))
ret_val = concat ("extern ", ret_val, NULL);
if (TREE_CODE (decl) == FUNCTION_DECL && !TREE_PUBLIC (decl))
ret_val = concat ("static ", ret_val, NULL);
return ret_val;
}
static const char *
gen_type (const char *ret_val, tree t, formals_style style)
{
tree chain_p;
/* If there is a typedef name for this type, use it. */
if (TYPE_NAME (t) && TREE_CODE (TYPE_NAME (t)) == TYPE_DECL)
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
else
{
switch (TREE_CODE (t))
{
case POINTER_TYPE:
if (TYPE_READONLY (t))
ret_val = concat ("const ", ret_val, NULL);
if (TYPE_VOLATILE (t))
ret_val = concat ("volatile ", ret_val, NULL);
ret_val = concat ("*", ret_val, NULL);
if (TREE_CODE (TREE_TYPE (t)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (t)) == FUNCTION_TYPE)
ret_val = concat ("(", ret_val, ")", NULL);
ret_val = gen_type (ret_val, TREE_TYPE (t), style);
return ret_val;
case ARRAY_TYPE:
if (!COMPLETE_TYPE_P (t) || TREE_CODE (TYPE_SIZE (t)) != INTEGER_CST)
ret_val = gen_type (concat (ret_val, "[]", NULL),
TREE_TYPE (t), style);
else if (int_size_in_bytes (t) == 0)
ret_val = gen_type (concat (ret_val, "[0]", NULL),
TREE_TYPE (t), style);
else
{
int size = (int_size_in_bytes (t) / int_size_in_bytes (TREE_TYPE (t)));
char buff[10];
sprintf (buff, "[%d]", size);
ret_val = gen_type (concat (ret_val, buff, NULL),
TREE_TYPE (t), style);
}
break;
case FUNCTION_TYPE:
ret_val = gen_type (concat (ret_val,
gen_formal_list_for_type (t, style),
NULL),
TREE_TYPE (t), style);
break;
case IDENTIFIER_NODE:
data_type = IDENTIFIER_POINTER (t);
break;
/* The following three cases are complicated by the fact that a
user may do something really stupid, like creating a brand new
"anonymous" type specification in a formal argument list (or as
part of a function return type specification). For example:
int f (enum { red, green, blue } color);
In such cases, we have no name that we can put into the prototype
to represent the (anonymous) type. Thus, we have to generate the
whole darn type specification. Yuck! */
case RECORD_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_FIELDS (t);
while (chain_p)
{
data_type = concat (data_type, gen_decl (chain_p, 0, ansi),
NULL);
chain_p = TREE_CHAIN (chain_p);
data_type = concat (data_type, "; ", NULL);
}
data_type = concat ("{ ", data_type, "}", NULL);
}
data_type = concat ("struct ", data_type, NULL);
break;
case UNION_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_FIELDS (t);
while (chain_p)
{
data_type = concat (data_type, gen_decl (chain_p, 0, ansi),
NULL);
chain_p = TREE_CHAIN (chain_p);
data_type = concat (data_type, "; ", NULL);
}
data_type = concat ("{ ", data_type, "}", NULL);
}
data_type = concat ("union ", data_type, NULL);
break;
case ENUMERAL_TYPE:
if (TYPE_NAME (t))
data_type = IDENTIFIER_POINTER (TYPE_NAME (t));
else
{
data_type = "";
chain_p = TYPE_VALUES (t);
while (chain_p)
{
data_type = concat (data_type,
IDENTIFIER_POINTER (TREE_PURPOSE (chain_p)), NULL);
chain_p = TREE_CHAIN (chain_p);
if (chain_p)
data_type = concat (data_type, ", ", NULL);
}
data_type = concat ("{ ", data_type, " }", NULL);
}
data_type = concat ("enum ", data_type, NULL);
break;
case TYPE_DECL:
data_type = IDENTIFIER_POINTER (DECL_NAME (t));
break;
case INTEGER_TYPE:
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
/* Normally, `unsigned' is part of the deal. Not so if it comes
with a type qualifier. */
if (TYPE_UNSIGNED (t) && TYPE_QUALS (t))
data_type = concat ("unsigned ", data_type, NULL);
break;
case REAL_TYPE:
data_type = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (t)));
break;
case VOID_TYPE:
data_type = "void";
break;
case ERROR_MARK:
data_type = "[ERROR]";
break;
default:
gcc_unreachable ();
}
}
if (TYPE_READONLY (t))
ret_val = concat ("const ", ret_val, NULL);
if (TYPE_VOLATILE (t))
ret_val = concat ("volatile ", ret_val, NULL);
if (TYPE_RESTRICT (t))
ret_val = concat ("restrict ", ret_val, NULL);
return ret_val;
}
static const char *
gen_formal_list_for_type (tree fntype, formals_style style)
{
const char *formal_list = "";
tree formal_type;
if (style != ansi)
return "()";
formal_type = TYPE_ARG_TYPES (fntype);
while (formal_type && TREE_VALUE (formal_type) != void_type_node)
{
const char *this_type;
if (*formal_list)
formal_list = concat (formal_list, ", ", NULL);
this_type = gen_type ("", TREE_VALUE (formal_type), ansi);
formal_list
= ((strlen (this_type))
? concat (formal_list, affix_data_type (this_type), NULL)
: concat (formal_list, data_type, NULL));
formal_type = TREE_CHAIN (formal_type);
}
/* If we got to here, then we are trying to generate an ANSI style formal
parameters list.
New style prototyped ANSI formal parameter lists should in theory always
contain some stuff between the opening and closing parens, even if it is
only "void".
The brutal truth though is that there is lots of old K&R code out there
which contains declarations of "pointer-to-function" parameters and
these almost never have fully specified formal parameter lists associated
with them. That is, the pointer-to-function parameters are declared
with just empty parameter lists.
In cases such as these, protoize should really insert *something* into
the vacant parameter lists, but what? It has no basis on which to insert
anything in particular.
Here, we make life easy for protoize by trying to distinguish between
K&R empty parameter lists and new-style prototyped parameter lists
that actually contain "void". In the latter case we (obviously) want
to output the "void" verbatim, and that what we do. In the former case,
we do our best to give protoize something nice to insert.
This "something nice" should be something that is still valid (when
re-compiled) but something that can clearly indicate to the user that
more typing information (for the parameter list) should be added (by
hand) at some convenient moment.
The string chosen here is a comment with question marks in it. */
if (!*formal_list)
{
if (TYPE_ARG_TYPES (fntype))
/* assert (TREE_VALUE (TYPE_ARG_TYPES (fntype)) == void_type_node); */
formal_list = "void";
else
formal_list = "/* ??? */";
}
else
{
/* If there were at least some parameters, and if the formals-types-list
petered out to a NULL (i.e. without being terminated by a
void_type_node) then we need to tack on an ellipsis. */
if (!formal_type)
formal_list = concat (formal_list, ", ...", NULL);
}
return concat (" (", formal_list, ")", NULL);
}
int main(int argc, char** argv)
{
printf("-- Generated by utildgen.c from system includes\n");
if (argc > 1 && strcmp(argv[1], "curl") == 0) {
printf("private package Util.Http.Clients.Curl.Constants is\n");
#ifdef HAVE_CURL
printf("\n");
printf(" CURLOPT_URL : constant Curl_Option := %d;\n", CURLOPT_URL);
printf(" CURLOPT_READFUNCTION : constant Curl_Option := %d;\n", CURLOPT_READFUNCTION);
printf(" CURLOPT_WRITEUNCTION : constant Curl_Option := %d;\n", CURLOPT_WRITEFUNCTION);
printf(" CURLOPT_HTTPHEADER : constant Curl_Option := %d;\n", CURLOPT_HTTPHEADER);
printf(" CURLOPT_INTERFACE : constant Curl_Option := %d;\n", CURLOPT_INTERFACE);
printf(" CURLOPT_USERPWD : constant Curl_Option := %d;\n", CURLOPT_USERPWD);
printf(" CURLOPT_HTTPAUTH : constant Curl_Option := %d;\n", CURLOPT_HTTPAUTH);
printf(" CURLOPT_MAXFILESIZE : constant Curl_Option := %d;\n", CURLOPT_MAXFILESIZE);
printf(" CURLOPT_WRITEDATA : constant Curl_Option := %d;\n", CURLOPT_WRITEDATA);
printf(" CURLOPT_HEADER : constant Curl_Option := %d;\n", CURLOPT_HEADER);
printf(" CURLOPT_POSTFIELDS : constant Curl_Option := %d;\n", CURLOPT_POSTFIELDS);
printf(" CURLOPT_POSTFIELDSIZE : constant Curl_Option := %d;\n", CURLOPT_POSTFIELDSIZE);
printf("\n");
printf(" CURLINFO_RESPONSE_CODE : constant CURL_Info := %d;\n", CURLINFO_RESPONSE_CODE);
printf("\n");
#endif
printf("end Util.Http.Clients.Curl.Constants;\n");
} else if (argc > 1 && strcmp(argv[1], "types") == 0) {
struct timespec tv;
#if !defined(_WIN32) && !defined(_MIPS_ARCH)
struct stat st;
#else
struct stat64 st;
#endif
printf("with Interfaces.C;\n");
printf("package Util.Systems.Types is\n");
printf("\n");
gen_type("dev_t", UNSIGNED, sizeof(st.st_dev));
gen_type("ino_t", UNSIGNED, sizeof(st.st_ino));
gen_type("off_t", SIGNED, sizeof(st.st_size));
#ifndef _WIN32
gen_type("blksize_t", SIGNED, sizeof(blksize_t));
gen_type("blkcnt_t", SIGNED, sizeof(blkcnt_t));
gen_type("uid_t", UNSIGNED, sizeof(uid_t));
gen_type("gid_t", UNSIGNED, sizeof(gid_t));
gen_type("nlink_t", UNSIGNED, sizeof(nlink_t));
#else
gen_type("uid_t", UNSIGNED, sizeof(st.st_uid));
gen_type("gid_t", UNSIGNED, sizeof(st.st_gid));
gen_type("nlink_t", UNSIGNED, sizeof(st.st_nlink));
#endif
gen_type("mode_t", UNSIGNED, sizeof(mode_t));
printf("\n");
printf(" S_IFMT : constant mode_t := 8#%08o#;\n", S_IFMT);
printf(" S_IFDIR : constant mode_t := 8#%08o#;\n", S_IFDIR);
printf(" S_IFCHR : constant mode_t := 8#%08o#;\n", S_IFCHR);
printf(" S_IFBLK : constant mode_t := 8#%08o#;\n", S_IFBLK);
printf(" S_IFREG : constant mode_t := 8#%08o#;\n", S_IFREG);
printf(" S_IFIFO : constant mode_t := 8#%08o#;\n", S_IFIFO);
printf(" S_IFLNK : constant mode_t := 8#%08o#;\n", S_IFLNK);
printf(" S_IFSOCK : constant mode_t := 8#%08o#;\n", S_IFSOCK);
printf(" S_ISUID : constant mode_t := 8#%08o#;\n", S_ISUID);
printf(" S_ISGID : constant mode_t := 8#%08o#;\n", S_ISGID);
printf(" S_IREAD : constant mode_t := 8#%08o#;\n", S_IREAD);
printf(" S_IWRITE : constant mode_t := 8#%08o#;\n", S_IWRITE);
printf(" S_IEXEC : constant mode_t := 8#%08o#;\n", S_IEXEC);
printf("\n");
#ifndef _WIN32
printf(" subtype Time_Type is %s;\n", get_type(UNSIGNED, sizeof(tv.tv_sec)));
printf("\n");
printf(" type Timespec is record\n");
printf(" tv_sec : Time_Type;\n");
printf(" tv_nsec : %s;\n", get_type(SIGNED, sizeof(tv.tv_nsec)));
printf(" end record;\n");
#else
printf(" subtype Time_Type is %s;\n", get_type(UNSIGNED, sizeof(st.st_mtime)));
printf("\n");
printf(" type Timespec is record\n");
printf(" tv_sec : Time_Type;\n");
printf(" end record;\n");
#endif
printf(" pragma Convention (C_Pass_By_Copy, Timespec);\n");
printf("\n");
gen_stat();
printf("\nend Util.Systems.Types;\n");
} else {
printf("with Interfaces.C;\n");
printf("package Util.Systems.Constants is\n");
printf("\n");
printf(" pragma Pure;\n");
printf("\n -- Flags used when opening a file with open/creat.\n");
printf(" O_RDONLY : constant Interfaces.C.int := 8#%06o#;\n", O_RDONLY);
printf(" O_WRONLY : constant Interfaces.C.int := 8#%06o#;\n", O_WRONLY);
printf(" O_RDWR : constant Interfaces.C.int := 8#%06o#;\n", O_RDWR);
printf(" O_CREAT : constant Interfaces.C.int := 8#%06o#;\n", O_CREAT);
printf(" O_EXCL : constant Interfaces.C.int := 8#%06o#;\n", O_EXCL);
printf(" O_TRUNC : constant Interfaces.C.int := 8#%06o#;\n", O_TRUNC);
printf(" O_APPEND : constant Interfaces.C.int := 8#%06o#;\n", O_APPEND);
#ifdef O_NONBLOCK
printf(" O_NONBLOCK : constant Interfaces.C.int := 8#%06o#;\n", O_NONBLOCK);
#endif
printf("\n");
#ifdef F_SETFL
printf(" -- Flags used by fcntl\n");
printf(" F_SETFL : constant Interfaces.C.int := %d;\n", F_SETFL);
printf(" F_GETFL : constant Interfaces.C.int := %d;\n", F_GETFL);
printf(" FD_CLOEXEC : constant Interfaces.C.int := %d;\n", FD_CLOEXEC);
#endif
#ifdef HAVE_DLFCN_H
printf("\n");
printf(" -- Flags used by dlopen\n");
printf(" RTLD_LAZY : constant Interfaces.C.int := 8#%06o#;\n", RTLD_LAZY);
printf(" RTLD_NOW : constant Interfaces.C.int := 8#%06o#;\n", RTLD_NOW);
printf(" RTLD_NOLOAD : constant Interfaces.C.int := 8#%06o#;\n", RTLD_NOLOAD);
printf(" RTLD_DEEPBIND : constant Interfaces.C.int := 8#%06o#;\n", RTLD_DEEPBIND);
printf(" RTLD_GLOBAL : constant Interfaces.C.int := 8#%06o#;\n", RTLD_GLOBAL);
printf(" RTLD_LOCAL : constant Interfaces.C.int := 8#%06o#;\n", RTLD_LOCAL);
printf(" RTLD_NODELETE : constant Interfaces.C.int := 8#%06o#;\n", RTLD_NODELETE);
#endif
printf("\n");
#ifdef HAVE_DLOPEN
printf(" DLL_OPTIONS : constant String := \"-ldl\";\n");
#else
printf(" DLL_OPTIONS : constant String := \"\";\n");
#endif
printf("\n");
printf("end Util.Systems.Constants;\n");
}
return 0;
}
void gen_stat(void)
{
#ifdef __linux__
#ifdef _MIPS_ARCH
printf(" STAT_NAME : constant String := \"stat64\";\n");
printf(" FSTAT_NAME : constant String := \"fstat64\";\n");
#else
printf(" STAT_NAME : constant String := \"stat\";\n");
printf(" FSTAT_NAME : constant String := \"fstat\";\n");
#endif
printf(" type Stat_Type is record\n");
printf(" st_dev : dev_t;\n");
#ifdef _MIPS_ARCH
printf(" pad0_1 : Interfaces.C.unsigned_long;\n");
printf(" pad0_2 : Interfaces.C.unsigned_long;\n");
printf(" pad0_3 : Interfaces.C.unsigned_long;\n");
#else
if (NEED_PADDING) {
printf(" pad1 : Interfaces.C.unsigned_short;\n");
}
#endif
printf(" st_ino : ino_t;\n");
#ifndef __x86_64__
printf(" st_mode : mode_t;\n");
printf(" st_nlink : nlink_t;\n");
#else
printf(" st_nlink : nlink_t;\n");
printf(" st_mode : mode_t;\n");
#endif
printf(" st_uid : uid_t;\n");
printf(" st_gid : gid_t;\n");
printf(" st_rdev : dev_t;\n");
#ifdef _MIPS_ARCH
printf(" pad1_0 : Interfaces.C.unsigned_long;\n");
printf(" pad1_1 : Interfaces.C.unsigned_long;\n");
printf(" pad1_2 : Interfaces.C.unsigned_long;\n");
#else
if (NEED_PADDING) {
printf(" pad2 : Interfaces.C.unsigned_short;\n");
}
#endif
printf(" st_size : off_t;\n");
#ifndef _MIPS_ARCH
printf(" st_blksize : blksize_t;\n");
printf(" st_blocks : blkcnt_t;\n");
printf(" pad3_1 : Interfaces.C.unsigned_long;\n");
#endif
printf(" st_atim : Timespec;\n");
printf(" st_mtim : Timespec;\n");
printf(" st_ctim : Timespec;\n");
#ifdef _MIPS_ARCH
printf(" st_blksize : blksize_t;\n");
printf(" pad2 : Interfaces.C.unsigned_long;\n");
printf(" st_blocks : blkcnt_t;\n");
#else
if (NEED_PADDING) {
printf(" pad3 : Interfaces.C.unsigned_long;\n");
printf(" pad4 : Interfaces.C.unsigned_long;\n");
}
#endif
#ifdef __x86_64__
printf(" pad5 : Interfaces.C.unsigned_long;\n");
printf(" pad6 : Interfaces.C.unsigned_long;\n");
printf(" pad7 : Interfaces.C.unsigned_long;\n");
#endif
printf(" end record;\n");
printf(" pragma Convention (C_Pass_By_Copy, Stat_Type);\n");
printf("\n");
#elif defined(__FreeBSD__)
struct stat st;
gen_type("fflags_t", UNSIGNED, sizeof(fflags_t));
printf(" STAT_NAME : constant String := \"stat\";\n");
printf(" FSTAT_NAME : constant String := \"fstat\";\n");
printf(" type Stat_Type is record\n");
printf(" st_dev : dev_t;\n");
printf(" st_ino : ino_t;\n");
printf(" st_mode : mode_t;\n");
printf(" st_nlink : nlink_t;\n");
printf(" st_uid : uid_t;\n");
printf(" st_gid : gid_t;\n");
printf(" st_rdev : dev_t;\n");
printf(" st_atim : Timespec;\n");
printf(" st_mtim : Timespec;\n");
printf(" st_ctim : Timespec;\n");
printf(" st_size : off_t;\n");
printf(" st_blocks : blkcnt_t;\n");
printf(" st_blksize : blksize_t;\n");
printf(" st_flags : fflags_t;\n");
printf(" st_gen : %s;\n", get_type(UNSIGNED, sizeof(st.st_gen)));
printf(" st_lspare : %s;\n", get_type(UNSIGNED, sizeof(st.st_lspare)));
printf(" st_birthtim : Timespec;\n");
printf(" st_spare1 : %s;\n", get_type(UNSIGNED, sizeof(unsigned)));
printf(" st_spare2 : %s;\n", get_type(UNSIGNED, sizeof(unsigned)));
printf(" end record;\n");
printf(" pragma Convention (C_Pass_By_Copy, Stat_Type);\n");
printf("\n");
#elif defined(__NetBSD__)
struct stat st;
printf(" STAT_NAME : constant String := \"__stat50\";\n");
printf(" FSTAT_NAME : constant String := \"__fstat50\";\n");
printf(" type Stat_Type is record\n");
printf(" st_dev : dev_t;\n");
printf(" st_mode : mode_t;\n");
printf(" st_ino : ino_t;\n");
printf(" st_nlink : nlink_t;\n");
printf(" st_uid : uid_t;\n");
printf(" st_gid : gid_t;\n");
printf(" st_rdev : dev_t;\n");
printf(" st_atim : Timespec;\n");
printf(" st_mtim : Timespec;\n");
printf(" st_ctim : Timespec;\n");
printf(" st_birthtime : Timespec;\n");
printf(" st_size : off_t;\n");
printf(" st_blocks : blkcnt_t;\n");
printf(" st_blksize : blksize_t;\n");
printf(" st_flags : %s;\n", get_type(UNSIGNED, sizeof(st.st_gen)));
printf(" st_gen : %s;\n", get_type(UNSIGNED, sizeof(st.st_gen)));
printf(" st_spare1 : %s;\n", get_type(UNSIGNED, sizeof(st.st_spare[0])));
printf(" st_spare2 : %s;\n", get_type(UNSIGNED, sizeof(st.st_spare[1])));
printf(" end record;\n");
printf(" pragma Convention (C_Pass_By_Copy, Stat_Type);\n");
printf("\n");
#elif defined(_WIN32)
printf(" type Stat_Type is record\n");
printf(" st_dev : dev_t;\n");
printf(" st_ino : ino_t;\n");
printf(" st_mode : mode_t;\n");
printf(" st_nlink : nlink_t;\n");
printf(" st_uid : uid_t;\n");
printf(" st_gid : gid_t;\n");
printf(" st_rdev : dev_t;\n");
printf(" st_size : off_t;\n");
printf(" st_atime : Time_Type;\n");
printf(" st_mtime : Time_Type;\n");
printf(" st_ctime : Time_Type;\n");
printf(" end record;\n");
printf(" pragma Convention (C_Pass_By_Copy, Stat_Type);\n");
printf("\n");
#endif
}
void INT_CXX_action( const act* action, int column)
{
// Put leading braces where required
switch (action->act_type)
{
case ACT_for:
case ACT_insert:
case ACT_modify:
case ACT_store:
case ACT_s_fetch:
case ACT_s_start:
begin(column);
align(column);
}
switch (action->act_type)
{
case ACT_at_end:
gen_at_end(action, column);
return;
case ACT_b_declare:
case ACT_database:
gen_database();
return;
case ACT_endfor:
gen_endfor(action, column);
break;
case ACT_endmodify:
gen_emodify(action, column);
break;
case ACT_endstore:
gen_estore(action, column, false);
break;
case ACT_endstore_special:
gen_estore(action, column, true);
break;
case ACT_erase:
gen_erase(action, column);
return;
case ACT_for:
gen_for(action, column);
return;
case ACT_hctef:
break;
case ACT_insert:
case ACT_routine:
gen_routine(action, column);
return;
case ACT_s_end:
gen_s_end(action, column);
return;
case ACT_s_fetch:
gen_s_fetch(action, column);
return;
case ACT_s_start:
gen_s_start(action, column);
break;
case ACT_type_number:
gen_type(action, column);
return;
case ACT_variable:
gen_variable(action, column);
return;
default:
return;
}
// Put in a trailing brace for those actions still with us
endp(column);
}
// Return a tuple type.
llvm::Type*
Generator::gen_type(Pointer_type const& t)
{
llvm::Type* inner = gen_type(t.type());
return llvm::PointerType::getUnqual(inner);
}
