* rpc_parse.c, Parser for the RPC protocol compiler
* Copyright (C) 1987 Sun Microsystems, Inc.
*/
-#include <afs/param.h>
#include <afsconfig.h>
+#include <afs/param.h>
+
+RCSID("$Header$");
+
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
-#ifdef HAVE_STRINGS_H
-#include <strings.h>
-#else
#ifdef HAVE_STRING_H
#include <string.h>
+#else
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
#endif
#endif
-#include "rpc_util.h"
#include "rpc_scan.h"
#include "rpc_parse.h"
-
-RCSID("$Header$");
+#include "rpc_util.h"
list *proc_defined[MAX_PACKAGES], *special_defined, *typedef_defined, *uniondef_defined;
char *SplitStart = NULL;
[MAX_FUNCTION_NAME_LEN];
int function_list_index;
-extern int pushed, scan_print;
-
-static isdefined();
-static def_struct();
-static def_program();
-static def_enum();
-static def_const();
-static def_union();
-static def_typedef();
-static get_declaration();
-static get_type();
-static unsigned_dec();
-static def_package();
-static def_prefix();
-static def_startingopcode();
-static def_statindex();
-static def_split();
-static customize_struct();
-static def_special();
-static check_proc();
-static int InvalidConstant();
-static opcodenum_is_defined();
-static analyze_ProcParams();
-static generate_code();
-static handle_split_proc();
-static do_split();
-static hdle_param_tok();
-static get1_param_type();
-static get_param_type();
-static cs_Proc_CodeGeneration();
-static cs_ProcName_setup();
-static cs_ProcParams_setup();
-static cs_ProcMarshallInParams_setup();
-static cs_ProcSendPacket_setup();
-static cs_ProcUnmarshallOutParams_setup();
-static cs_ProcTail_setup();
-static ss_Proc_CodeGeneration();
-static ss_ProcName_setup();
-static ss_ProcParams_setup();
-static ss_ProcProto_setup();
-static ss_ProcSpecial_setup();
-static ss_ProcUnmarshallInParams_setup();
-static ss_ProcCallRealProc_setup();
-static ss_ProcMarshallOutParams_setup();
-static ss_ProcTail_setup();
-static er_ProcDeclExterns_setup();
-static er_ProcProcsArray_setup();
-static er_ProcMainBody_setup();
-static er_HeadofOldStyleProc_setup();
-static er_BodyofOldStyleProc_setup();
-static proc_er_case();
-static er_TailofOldStyleProc_setup();
+/* static prototypes */
+static void isdefined(definition *defp);
+static void def_struct(definition *defp);
+static void def_program(definition *defp);
+static void def_enum(definition *defp);
+static void def_const(definition *defp);
+static void def_union(definition *defp);
+static void def_typedef(definition *defp);
+static void get_declaration(declaration *dec, defkind dkind);
+static void get_type(char **prefixp, char **typep, defkind dkind);
+static void unsigned_dec(char **typep);
+static void def_package(definition *defp);
+static void def_prefix(definition *defp);
+static void def_statindex(definition *defp);
+static void def_startingopcode(definition *defp);
+static void def_split(definition *defp);
+static void customize_struct(definition *defp);
+static char *structname(char *name);
+static void def_special(declaration *dec, definition *defp);
+static void check_proc(definition *defp, token *tokp, int noname);
+static int InvalidConstant(char *name);
+static int opcodenum_is_defined(int opcode_num);
+static void analyze_ProcParams(definition *defp, token *tokp);
+static void generate_code(definition *defp, int proc_split_flag, int multi_flag);
+static void handle_split_proc(definition *defp, int multi_flag);
+static void do_split(definition *defp, int direction, int *numofparams, defkind param_kind, int restore_flag);
+static void hdle_param_tok(definition *defp, declaration *dec, token *tokp, defkind par_kind);
+static void get1_param_type(definition *defp, declaration *dec, char **param_type);
+static void get_param_type(definition *defp, declaration *dec, char **param_type, char **typename);
+#ifdef undef
+static void hndle_param_tail(definition *defp, declaration *dec, token *tokp, char *typename);
+#endif
+static void cs_Proc_CodeGeneration(definition *defp, int split_flag, char *procheader);
+static void cs_ProcName_setup(definition *defp, char *procheader, int split_flag);
+static void cs_ProcParams_setup(definition *defp, int split_flag);
+static void cs_ProcMarshallInParams_setup(definition *defp, int split_flag);
+static void cs_ProcSendPacket_setup(definition *defp, int split_flag);
+static void cs_ProcUnmarshallOutParams_setup(definition *defp);
+static void cs_ProcTail_setup(definition *defp, int split_flag);
+static void ss_Proc_CodeGeneration(definition *defp);
+static void ss_ProcName_setup(definition *defp);
+static void ss_ProcParams_setup(definition *defp, int *somefrees);
+static void ss_ProcSpecial_setup(definition *defp, int *somefrees);
+static void ss_ProcUnmarshallInParams_setup(definition *defp);
+static void ss_ProcCallRealProc_setup(definition *defp);
+static void ss_ProcMarshallOutParams_setup(definition *defp);
+static void ss_ProcTail_setup(definition *defp, int somefrees);
+static int opcode_holes_exist(void);
+static void er_ProcDeclExterns_setup(void);
+static void er_ProcProcsArray_setup(void);
+static void er_ProcMainBody_setup(void);
+static void er_HeadofOldStyleProc_setup(void);
+static void er_BodyofOldStyleProc_setup(void);
+static void proc_er_case(definition *defp);
+static void er_TailofOldStyleProc_setup(void);
+
+
/*
* return the next definition you see
*/
-definition *
-get_definition()
+definition *get_definition(void)
{
definition *defp;
token tok;
defp = ALLOC(definition);
- bzero((char *)defp, sizeof(definition));
+ memset((char *)defp, 0, sizeof(definition));
get_token(&tok);
switch (tok.kind) {
case TOK_STRUCT:
return (defp);
}
-static
-isdefined(defp)
- definition *defp;
+static void isdefined(definition *defp)
{
STOREVAL(&defined, defp);
}
-static
-def_struct(defp)
- definition *defp;
+static void def_struct(definition *defp)
{
token tok;
declaration dec;
*tailp = NULL;
}
-static
-def_program(defp)
- definition *defp;
+static void def_program(definition *defp)
{
token tok;
version_list *vlist;
*vtailp = NULL;
}
-static
-def_enum(defp)
- definition *defp;
+static void def_enum(definition *defp)
{
token tok;
enumval_list *elist;
*tailp = NULL;
}
-static
-def_const(defp)
- definition *defp;
+static void def_const(definition *defp)
{
token tok;
defp->def.co = tok.str;
}
-static
-def_union(defp)
- definition *defp;
+static void def_union(definition *defp)
{
token tok;
declaration dec;
}
-static
-def_typedef(defp)
- definition *defp;
+static void def_typedef(definition *defp)
{
declaration dec;
}
-static
-get_declaration(dec, dkind)
- declaration *dec;
- defkind dkind;
+static void get_declaration(declaration *dec, defkind dkind)
{
token tok;
}
-static
-get_type(prefixp, typep, dkind)
- char **prefixp;
- char **typep;
- defkind dkind;
+static void get_type(char **prefixp, char **typep, defkind dkind)
{
token tok;
}
-static
-unsigned_dec(typep)
- char **typep;
+static void unsigned_dec(char **typep)
{
token tok;
}
-static
-def_package(defp)
-definition *defp;
+static void def_package(definition *defp)
{
token tok;
PackageStatIndex[PackageIndex] = NULL;
}
-static
-def_prefix(defp)
-definition *defp;
+static void def_prefix(definition *defp)
{
token tok;
ServerPrefix = tok.str;
}
-static
-def_statindex(defp)
-definition *defp;
+static void def_statindex(definition *defp)
{
token tok;
char *name;
PackageStatIndex[PackageIndex] = name;
}
-static
-def_startingopcode(defp)
-definition *defp;
+static void def_startingopcode(definition *defp)
{
token tok;
opcodesnotallowed[PackageIndex]=1;
}
-static
-def_split(defp)
-definition *defp;
+static void def_split(definition *defp)
{
token tok;
}
-static
-customize_struct(defp)
-definition *defp;
+static void customize_struct(definition *defp)
{
decl_list *listp;
declaration *dec;
STOREVAL(&special_defined, defp1);
}
-static
-char *
-structname(name)
-char *name;
+static char *structname(char *name)
{
char namecontents[150], *pnt, *pnt1;
}
-static
-def_special(dec, defp)
-declaration *dec;
-definition *defp;
+static void def_special(declaration *dec, definition *defp)
{
char *typename;
spec_list *specs, **tailp;
proc1_list *Proc_list, **Proc_listp;
-static
-check_proc(defp, tokp, noname)
-definition *defp;
-token *tokp;
-int noname;
+static void check_proc(definition *defp, token *tokp, int noname)
{
token tok;
int proc_split = 0;
int proc_multi = 0;
+ if (PackageIndex < 0)
+ error("Procedure must be in a package!\n");
+
tokp->kind = TOK_PROC;
defp->def_kind = DEF_PROC;
if (noname)
}
if (tok.kind == TOK_SPLIT) {
proc_split = 1;
+ defp->pc.split_flag = 1;
scan2(TOK_EQUAL, TOK_SEMICOLON, &tok);
}
+ else {
+ defp->pc.split_flag = 0;
+ }
if (tok.kind == TOK_EQUAL) {
if (opcodesnotallowed[PackageIndex])
error("Opcode assignment isn't allowed here!");
#define LEGALNUMS "0123456789"
-static int
-InvalidConstant(name)
-char *name;
+static int InvalidConstant(char *name)
{
char *map;
int slen;
return(slen != strspn(name, map));
}
-static
-opcodenum_is_defined(opcode_num)
-int opcode_num;
+static int opcodenum_is_defined(int opcode_num)
{
list *listp;
definition *defp;
}
-static
-analyze_ProcParams(defp, tokp)
-definition *defp;
-token *tokp;
+static void analyze_ProcParams(definition *defp, token *tokp)
{
declaration dec;
decl_list *decls, **tailp;
do {
get_token(tokp);
Proc_list = ALLOC(proc1_list);
- bzero((char *)Proc_list, sizeof(proc1_list));
+ memset((char *)Proc_list, 0, sizeof(proc1_list));
Proc_list->pl.param_flag = 0;
switch (tokp->kind) {
case TOK_IN:
*Proc_listp = Proc_list;
Proc_listp = &Proc_list->next;
decls = ALLOC(decl_list);
- bzero((char *)decls, sizeof(decl_list));
+ memset((char *)decls, 0, sizeof(decl_list));
decls->decl = dec;
*tailp = decls;
tailp = &decls->next;
}
-static
-generate_code(defp, proc_split_flag, multi_flag)
-definition *defp;
-int proc_split_flag;
-int multi_flag;
+static void generate_code(definition *defp, int proc_split_flag, int multi_flag)
{
if (proc_split_flag)
handle_split_proc(defp, multi_flag);
}
-static
-handle_split_proc(defp, multi_flag)
-definition *defp;
-int multi_flag;
+static void handle_split_proc(definition *defp, int multi_flag)
{
char *startname = SplitStart, *endname = SplitEnd;
int numofparams;
}
-static
-do_split(defp, direction, numofparams, param_kind, restore_flag)
-definition *defp;
-int direction, *numofparams, restore_flag;
-defkind param_kind;
+static void do_split(definition *defp, int direction, int *numofparams, defkind param_kind, int restore_flag)
{
proc1_list *plist;
}
-static
-hdle_param_tok(defp, dec, tokp, par_kind)
-definition *defp;
-declaration *dec;
-token *tokp;
-defkind par_kind;
+static void hdle_param_tok(definition *defp, declaration *dec, token *tokp, defkind par_kind)
{
static defkind last_param_kind = DEF_NULL;
}
-static
-get1_param_type(defp, dec, param_type)
-definition *defp;
-declaration *dec;
-char **param_type;
+static void get1_param_type(definition *defp, declaration *dec, char **param_type)
{
char typecontents[100];
}
-static
-get_param_type(defp, dec, param_type, typename)
-definition *defp;
-declaration *dec;
-char **param_type, **typename;
+static void get_param_type(definition *defp, declaration *dec, char **param_type, char **typename)
{
char typecontents[100];
}
-static
-hndle_param_tail(defp, dec, tokp, typename)
-definition *defp;
-declaration *dec;
-token *tokp;
-char *typename;
+#ifdef undef
+static void hndle_param_tail(definition *defp, declaration *dec, token *tokp, char *typename)
{
char *amp;
if (tokp->kind == TOK_COMMA)
peek(tokp);
}
+#endif
-static
-cs_Proc_CodeGeneration(defp, split_flag, procheader)
-definition *defp;
-int split_flag;
-char *procheader;
+static void cs_Proc_CodeGeneration(definition *defp, int split_flag, char *procheader)
{
defp->can_fail = 0;
cs_ProcName_setup(defp, procheader, split_flag);
}
-static
-cs_ProcName_setup(defp, procheader, split_flag)
-definition *defp;
-char *procheader;
-int split_flag;
+static void cs_ProcName_setup(definition *defp, char *procheader, int split_flag)
{
proc1_list *plist;
}
-static
-cs_ProcParams_setup(defp, split_flag)
-definition *defp;
-int split_flag;
+static void cs_ProcParams_setup(definition *defp, int split_flag)
{
proc1_list *plist, *plist1;
for (plist1 = defp->pc.plists; plist1; plist1 = plist1->next) {
if ((plist1->component_kind == DEF_PARAM) && streq(plist->pl.param_type, plist1->pl.param_type) && !(plist1->pl.param_flag & PROCESSED_PARAM)) {
char *star="";
- char *pntr = index(plist1->pl.param_type, '*');
+ char *pntr = strchr(plist1->pl.param_type, '*');
if (pntr) star = "*";
if (plist1->pl.param_flag & OUT_STRING) {
f_print(fout, ", *%s%s", star, plist1->pl.param_name);
}
-static
-cs_ProcMarshallInParams_setup(defp, split_flag)
-definition *defp;
-int split_flag;
+static void cs_ProcMarshallInParams_setup(definition *defp, int split_flag)
{
int noofparams, i=0;
proc1_list *plist;
}
-static
-cs_ProcSendPacket_setup(defp, split_flag)
-definition *defp;
-int split_flag;
+static void cs_ProcSendPacket_setup(definition *defp, int split_flag)
{
int noofoutparams = defp->pc.paramtypes[INOUT] + defp->pc.paramtypes[OUT];
}
-static
-cs_ProcUnmarshallOutParams_setup(defp)
-definition *defp;
+static void cs_ProcUnmarshallOutParams_setup(definition *defp)
{
int noofparams, i;
proc1_list *plist;
}
-static
-cs_ProcTail_setup(defp, split_flag)
-definition *defp;
-int split_flag;
+static void cs_ProcTail_setup(definition *defp, int split_flag)
{
f_print(fout, "\tz_result = RXGEN_SUCCESS;\n");
if (defp->can_fail) {
}
-static
-ss_Proc_CodeGeneration(defp)
-definition *defp;
+static void ss_Proc_CodeGeneration(definition *defp)
{
int somefrees=0;
ss_ProcName_setup(defp);
if (!cflag) {
ss_ProcParams_setup(defp, &somefrees);
- ss_ProcProto_setup(defp, &somefrees);
ss_ProcSpecial_setup(defp, &somefrees);
ss_ProcUnmarshallInParams_setup(defp);
ss_ProcCallRealProc_setup(defp);
}
-static
-ss_ProcName_setup(defp)
-definition *defp;
+static void ss_ProcName_setup(definition *defp)
{
proc1_list *plist;
}
if (!cflag) {
- f_print(fout, "afs_int32 _%s%s%s(z_call, z_xdrs)\n", prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
- f_print(fout, "\tstruct rx_call *z_call;\n\tXDR *z_xdrs;\n{\n");
+ f_print(fout, "static afs_int32 _%s%s%s(", prefix, PackagePrefix[PackageIndex], defp->pc.proc_name);
+ f_print(fout, "struct rx_call *z_call, XDR *z_xdrs)\n{\n");
f_print(fout, "\t" "afs_int32 z_result;\n");
if (xflag) {
f_print(fout, "\tstruct clock __QUEUE, __EXEC;\n");
for (plist = defp->pc.plists; plist; plist = plist->next)
if (plist->component_kind == DEF_PARAM) {
plist->pl.param_flag &= ~(PROCESSED_PARAM);
- plist->pl.string_name = (char *)0;
+ plist->pl.string_name = NULL;
}
}
}
-static
-ss_ProcParams_setup(defp, somefrees)
-definition *defp;
-int *somefrees;
+static void ss_ProcParams_setup(definition *defp, int *somefrees)
{
proc1_list *plist, *plist1;
list *listp;
definition *defp1;
- int preserve_flag = 0;
for (plist = defp->pc.plists; plist; plist = plist->next) {
if ((plist->component_kind == DEF_PARAM) && !(plist->pl.param_flag & PROCESSED_PARAM)) {
if (plist->pl.param_flag & INDIRECT_PARAM) {
- char pres, *pntr = index(plist->pl.param_type, '*');
+ char pres='\0', *pntr = strchr(plist->pl.param_type, '*');
if (pntr){ --pntr; pres = *pntr; *pntr = (char)0; }
f_print(fout, "\t%s %s", plist->pl.param_type, plist->pl.param_name);
*pntr = pres;
- } else if (index(plist->pl.param_type, '*') == 0) {
+ } else if (strchr(plist->pl.param_type, '*') == 0) {
f_print(fout, "\t%s %s", plist->pl.param_type, plist->pl.param_name);
} else {
plist->pl.param_flag |= FREETHIS_PARAM;
if ((plist1->component_kind == DEF_PARAM) && streq(plist->pl.param_type, plist1->pl.param_type) && !(plist1->pl.param_flag & PROCESSED_PARAM)) {
if (plist1->pl.param_flag & INDIRECT_PARAM) {
f_print(fout, ", %s", plist1->pl.param_name);
- } else if (index(plist1->pl.param_type, '*') == 0) {
+ } else if (strchr(plist1->pl.param_type, '*') == 0) {
f_print(fout, ", %s", plist1->pl.param_name);
} else {
plist1->pl.param_flag |= FREETHIS_PARAM;
}
-static
-ss_ProcProto_setup(defp, somefrees)
-definition *defp;
-int *somefrees;
-{
- proc1_list *plist, *plist1;
- list *listp;
- definition *defp1;
- int preserve_flag = 0;
-
- f_print(fout, "#ifndef KERNEL\n");
- f_print(fout, "\tafs_int32 %s%s%s%s();\n", prefix, ServerPrefix,
- PackagePrefix[PackageIndex], defp->pc.proc_name);
- f_print(fout, "#endif\n");
-}
-
-
-static
-ss_ProcSpecial_setup(defp, somefrees)
-definition *defp;
-int *somefrees;
+static void ss_ProcSpecial_setup(definition *defp, int *somefrees)
{
proc1_list *plist;
definition *defp1;
}
-static
-ss_ProcUnmarshallInParams_setup(defp)
-definition *defp;
+static void ss_ProcUnmarshallInParams_setup(definition *defp)
{
int noofparams, noofoutparams, i;
proc1_list *plist;
}
-static
-ss_ProcCallRealProc_setup(defp)
-definition *defp;
+static void ss_ProcCallRealProc_setup(definition *defp)
{
extern char zflag;
proc1_list *plist;
}
-static
-ss_ProcMarshallOutParams_setup(defp)
-definition *defp;
+static void ss_ProcMarshallOutParams_setup(definition *defp)
{
proc1_list *plist;
int noofparams, i;
}
-static
-ss_ProcTail_setup(defp, somefrees)
-definition *defp;
-int somefrees;
+static void ss_ProcTail_setup(definition *defp, int somefrees)
{
proc1_list *plist;
definition *defp1;
}
-static
-opcode_holes_exist()
+static int opcode_holes_exist(void)
{
int i;
}
-int
-er_Proc_CodeGeneration()
+void er_Proc_CodeGeneration(void)
{
int temp;
}
-static
-er_ProcDeclExterns_setup()
+static void er_ProcDeclExterns_setup(void)
{
list *listp;
definition *defp;
defp = (definition *)listp->val;
if (defp->pc.proc_serverstub) {
f_print(fout, "afs_int32 %s();\n", defp->pc.proc_serverstub);
- } else {
- f_print(fout, "afs_int32 _%s%s%s();\n", prefix, defp->pc.proc_prefix, defp->pc.proc_name);
}
}
}
-static
-er_ProcProcsArray_setup()
+static void er_ProcProcsArray_setup(void)
{
list *listp;
definition *defp;
- if (listp = proc_defined[PackageIndex]) {
+ if ((listp = proc_defined[PackageIndex])) {
defp = (definition *)listp->val;
if (defp->pc.proc_serverstub){
- f_print(fout, "\nstatic afs_int32 (*StubProcsArray%d[])() = {%s", PackageIndex, defp->pc.proc_serverstub);
+ f_print(fout, "\nstatic afs_int32 (*StubProcsArray%d[])() = {%s",
+ PackageIndex, defp->pc.proc_serverstub);
} else {
- f_print(fout, "\nstatic afs_int32 (*StubProcsArray%d[])() = {_%s%s%s", PackageIndex, prefix, defp->pc.proc_prefix, (defp = (definition *)listp->val)->pc.proc_name);
+ f_print(fout,
+ "\nstatic afs_int32 (*StubProcsArray%d[])(struct rx_call *z_call, XDR *z_xdrs) = {_%s%s%s",
+ PackageIndex, prefix, defp->pc.proc_prefix,
+ ((definition *)listp->val)->pc.proc_name);
+ defp = (definition *)listp->val;
}
listp = listp->next;
}
}
-static
-er_ProcMainBody_setup()
+static void er_ProcMainBody_setup(void)
{
- f_print(fout, "int %s%sExecuteRequest(z_call)\n", prefix, PackagePrefix[PackageIndex]);
- f_print(fout, "\tregister struct rx_call *z_call;\n");
+ f_print(fout, "int %s%sExecuteRequest(register struct rx_call *z_call)\n", prefix, PackagePrefix[PackageIndex]);
f_print(fout, "{\n\tint op;\n");
f_print(fout, "\tXDR z_xdrs;\n");
f_print(fout, "\t" "afs_int32 z_result;\n\n");
}
-static
-er_HeadofOldStyleProc_setup()
+static void er_HeadofOldStyleProc_setup(void)
{
- f_print(fout, "\nint %s%sExecuteRequest (z_call)\n", prefix, (combinepackages ? MasterPrefix : PackagePrefix[PackageIndex]));
- f_print(fout, "\tregister struct rx_call *z_call;\n");
+ f_print(fout, "\nint %s%sExecuteRequest (register struct rx_call *z_call)\n",
+ prefix, (combinepackages ? MasterPrefix : PackagePrefix[PackageIndex]));
f_print(fout, "{\n");
f_print(fout, "\tint op;\n");
f_print(fout, "\tXDR z_xdrs;\n");
f_print(fout, "\tswitch (op) {\n");
}
-static
-er_BodyofOldStyleProc_setup()
+static void er_BodyofOldStyleProc_setup(void)
{
list *listp;
}
-static
-proc_er_case(defp)
-definition *defp;
+static void proc_er_case(definition *defp)
{
if (opcodesnotallowed[PackageIndex]) {
- f_print(fout, "\t\tcase %d: {\n", defp->pc.proc_opcodenum);
+ f_print(fout, "\t\tcase %d:\n", defp->pc.proc_opcodenum);
} else {
- f_print(fout, "\t\tcase %s: {\n", defp->pc.proc_opcodename);
+ f_print(fout, "\t\tcase %s:\n", defp->pc.proc_opcodename);
}
if (defp->pc.proc_serverstub) {
- f_print(fout, "\t\t\t" "afs_int32 %s();\n", defp->pc.proc_serverstub);
f_print(fout, "\t\t\tz_result = %s(z_call, &z_xdrs);\n", defp->pc.proc_serverstub);
} else {
- f_print(fout, "\t\t\t" "afs_int32 _%s%s%s();\n", prefix, defp->pc.proc_prefix, defp->pc.proc_name);
f_print(fout, "\t\t\tz_result = _%s%s%s(z_call, &z_xdrs);\n", prefix, defp->pc.proc_prefix, defp->pc.proc_name);
}
- f_print(fout, "\t\t\tbreak;\n\t\t}\n");
+ f_print(fout, "\t\t\tbreak;\n");
}
-static
-er_TailofOldStyleProc_setup()
+static void er_TailofOldStyleProc_setup(void)
{
f_print(fout, "\t\tdefault:\n");
f_print(fout, "\t\t\tz_result = RXGEN_OPCODE;\n");
}
-int h_opcode_stats()
+void h_opcode_stats(void)
{
if (combinepackages) {
f_print(fout, "\n/* Opcode-related useful stats for Master package: %s */\n", MasterPrefix);
}
-int generate_multi_macros(defp)
-definition *defp;
+void generate_multi_macros(definition *defp)
{
char *startname = SplitStart, *endname = SplitEnd;
proc1_list *plist;
}
-int
-IsRxgenToken(tokp)
-token *tokp;
+int IsRxgenToken(token *tokp)
{
if (tokp->kind == TOK_PACKAGE || tokp->kind == TOK_PREFIX ||
tokp->kind == TOK_SPECIAL || tokp->kind == TOK_STARTINGOPCODE ||
return 0;
}
-int
-IsRxgenDefinition(def)
-definition *def;
+int IsRxgenDefinition(definition *def)
{
if (def->def_kind == DEF_PACKAGE || def->def_kind == DEF_PREFIX || def->def_kind == DEF_SPECIAL || def->def_kind == DEF_STARTINGOPCODE || def->def_kind == DEF_SPLITPREFIX || def->def_kind == DEF_PROC)
return 1;
git://git.openafs.org / openafs.git / blobdiff