tools/winedump/output.c

   1 /*
   2  *  Code generation functions
   3  *
   4  *  Copyright 2000-2002 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library 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 GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include "winedump.h"
  25
  26 /* Output files */
  27 static FILE *specfile = NULL;
  28 static FILE *hfile    = NULL;
  29 static FILE *cfile    = NULL;
  30
  31 static void  output_spec_postamble (void);
  32 static void  output_header_postamble (void);
  33 static void  output_c_postamble (void);
  34 static void  output_c_banner (const parsed_symbol *sym);
  35 static const char *get_format_str (int type);
  36 static const char *get_in_or_out (const parsed_symbol *sym, size_t arg);
  37
  38
  39 /*******************************************************************
  40  *         output_spec_preamble
  41  *
  42  * Write the first part of the .spec file
  43  */
  44 void  output_spec_preamble (void)
  45 {
  46   specfile = open_file (OUTPUT_DLL_NAME, ".spec", "w");
  47
  48   atexit (output_spec_postamble);
  49
  50   if (VERBOSE)
  51     puts ("Creating .spec preamble");
  52
  53   fprintf (specfile,
  54            "# Generated from %s by winedump\n\n", globals.input_name);
  55 }
  56
  57
  58 /*******************************************************************
  59  *         output_spec_symbol
  60  *
  61  * Write a symbol to the .spec file
  62  */
  63 void  output_spec_symbol (const parsed_symbol *sym)
  64 {
  65   char ord_spec[16];
  66
  67   assert (specfile);
  68   assert (sym && sym->symbol);
  69
  70   if (sym->ordinal >= 0)
  71     snprintf(ord_spec, 8, "%d", sym->ordinal);
  72   else
  73   {
  74     ord_spec[0] = '@';
  75     ord_spec[1] = '\0';
  76   }
  77   if (sym->flags & SYM_THISCALL)
  78     strcat (ord_spec, " -i386"); /* For binary compatibility only */
  79
  80   if (!globals.do_code || !sym->function_name)
  81   {
  82     if (sym->flags & SYM_DATA)
  83     {
  84       if (globals.forward_dll)
  85         fprintf (specfile, "%s forward %s %s.%s #", ord_spec, sym->symbol,
  86                  globals.forward_dll, sym->symbol);
  87
  88       fprintf (specfile, "%s extern %s %s\n", ord_spec, sym->symbol,
  89                sym->arg_name[0]);
  90       return;
  91     }
  92
  93     if (globals.forward_dll)
  94       fprintf (specfile, "%s forward %s %s.%s\n", ord_spec, sym->symbol,
  95                globals.forward_dll, sym->symbol);
  96     else
  97       fprintf (specfile, "%s stub %s\n", ord_spec, sym->symbol);
  98   }
  99   else
 100   {
 101     unsigned int i = sym->flags & SYM_THISCALL ? 1 : 0;
 102
 103     fprintf (specfile, "%s %s %s(", ord_spec, sym->varargs ? "varargs" :
 104              symbol_get_call_convention(sym), sym->symbol);
 105
 106     for (; i < sym->argc; i++)
 107       fprintf (specfile, " %s", symbol_get_spec_type(sym, i));
 108
 109     if (sym->argc)
 110       fputc (' ', specfile);
 111     fprintf (specfile, ") %s_%s", OUTPUT_UC_DLL_NAME, sym->function_name);
 112
 113     if (sym->flags & SYM_THISCALL)
 114       fputs (" # __thiscall", specfile);
 115
 116     fputc ('\n',specfile);
 117   }
 118 }
 119
 120
 121 /*******************************************************************
 122  *         output_spec_postamble
 123  *
 124  * Write the last part of the .spec file
 125  */
 126 static void output_spec_postamble (void)
 127 {
 128   if (specfile)
 129     fclose (specfile);
 130   specfile = NULL;
 131 }
 132
 133
 134 /*******************************************************************
 135  *         output_header_preamble
 136  *
 137  * Write the first part of the .h file
 138  */
 139 void  output_header_preamble (void)
 140 {
 141   hfile = open_file (OUTPUT_DLL_NAME, "_dll.h", "w");
 142
 143   atexit (output_header_postamble);
 144
 145   fprintf (hfile,
 146            "/*\n * %s.dll\n *\n * Generated from %s.dll by winedump.\n *\n"
 147            " * DO NOT SEND GENERATED DLLS FOR INCLUSION INTO WINE !\n * \n */"
 148            "\n#ifndef __WINE_%s_DLL_H\n#define __WINE_%s_DLL_H\n\n#include "
 149            "\"config.h\"\n#include \"windef.h\"\n#include \"wine/debug.h\"\n"
 150            "#include \"winbase.h\"\n#include \"winnt.h\"\n\n\n",
 151            OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_UC_DLL_NAME,
 152            OUTPUT_UC_DLL_NAME);
 153 }
 154
 155
 156 /*******************************************************************
 157  *         output_header_symbol
 158  *
 159  * Write a symbol to the .h file
 160  */
 161 void  output_header_symbol (const parsed_symbol *sym)
 162 {
 163   assert (hfile);
 164   assert (sym && sym->symbol);
 165
 166   if (!globals.do_code)
 167     return;
 168
 169   if (sym->flags & SYM_DATA)
 170     return;
 171
 172   if (!sym->function_name)
 173     fprintf (hfile, "/* __%s %s_%s(); */\n", symbol_get_call_convention(sym),
 174              OUTPUT_UC_DLL_NAME, sym->symbol);
 175   else
 176   {
 177     output_prototype (hfile, sym);
 178     fputs (";\n", hfile);
 179   }
 180 }
 181
 182
 183 /*******************************************************************
 184  *         output_header_postamble
 185  *
 186  * Write the last part of the .h file
 187  */
 188 static void output_header_postamble (void)
 189 {
 190   if (hfile)
 191   {
 192     fprintf (hfile, "\n\n\n#endif\t/* __WINE_%s_DLL_H */\n",
 193              OUTPUT_UC_DLL_NAME);
 194     fclose (hfile);
 195     hfile = NULL;
 196   }
 197 }
 198
 199
 200 /*******************************************************************
 201  *         output_c_preamble
 202  *
 203  * Write the first part of the .c file
 204  */
 205 void  output_c_preamble (void)
 206 {
 207   cfile = open_file (OUTPUT_DLL_NAME, "_main.c", "w");
 208
 209   atexit (output_c_postamble);
 210
 211   fprintf (cfile,
 212            "/*\n * %s.dll\n *\n * Generated from %s by winedump.\n *\n"
 213            " * DO NOT SUBMIT GENERATED DLLS FOR INCLUSION INTO WINE!\n * \n */"
 214            "\n\n#include \"%s_dll.h\"\n\nWINE_DEFAULT_DEBUG_CHANNEL(%s);\n\n",
 215            OUTPUT_DLL_NAME, globals.input_name, OUTPUT_DLL_NAME,
 216            OUTPUT_DLL_NAME);
 217
 218   if (globals.forward_dll)
 219   {
 220     if (VERBOSE)
 221       puts ("Creating a forwarding DLL");
 222
 223     fputs ("\nHMODULE hDLL=0;\t/* DLL to call */\n\n", cfile);
 224   }
 225
 226   fputs ("#ifdef __i386__\n#define GET_THIS(t,p) t p;\\\n__asm__ __volatile__"
 227          " (\"movl %%ecx, %0\" : \"=m\" (p))\n#endif\n\n\n", cfile);
 228
 229   fprintf (cfile,
 230            "BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID "
 231            "lpvReserved)\n{\n\tTRACE(\"(0x%%08x, %%ld, %%p)\\n\",hinstDLL,"
 232            "fdwReason,lpvReserved);\n\n\t"
 233            "if (fdwReason == DLL_PROCESS_ATTACH)\n\t{\n\t\t");
 234
 235   if (globals.forward_dll)
 236   {
 237     fprintf (cfile,
 238              "hDLL = LoadLibraryA( \"%s\" );\n\t\t"
 239              "TRACE(\":Forwarding DLL (%s) loaded (%%ld)\\n\",(LONG)hDLL);",
 240              globals.forward_dll, globals.forward_dll);
 241   }
 242   else
 243     fputs ("/* FIXME: Initialisation */", cfile);
 244
 245   fputs ("\n\t}\n\telse if (fdwReason == DLL_PROCESS_DETACH)\n\t{\n\t\t",
 246          cfile);
 247
 248   if (globals.forward_dll)
 249   {
 250     fprintf (cfile,
 251              "FreeLibrary( hDLL );\n\t\tTRACE(\":Forwarding DLL (%s)"
 252              " freed\\n\");", globals.forward_dll);
 253   }
 254   else
 255     fputs ("/* FIXME: Cleanup */", cfile);
 256
 257   fputs ("\n\t}\n\n\treturn TRUE;\n}\n\n\n", cfile);
 258 }
 259
 260
 261 #define CPP_END  if (sym->flags & SYM_THISCALL) \
 262   fputs ("#endif\n", cfile); fputs ("\n\n", cfile)
 263 #define GET_THIS if (sym->flags & SYM_THISCALL) \
 264   fprintf (cfile, "\tGET_THIS(%s,%s);\n", sym->arg_text[0],sym->arg_name[0])
 265
 266 /*******************************************************************
 267  *         output_c_symbol
 268  *
 269  * Write a symbol to the .c file
 270  */
 271 void  output_c_symbol (const parsed_symbol *sym)
 272 {
 273   unsigned int i, start = sym->flags & SYM_THISCALL ? 1 : 0;
 274   int is_void;
 275
 276   assert (cfile);
 277   assert (sym && sym->symbol);
 278
 279   if (!globals.do_code)
 280     return;
 281
 282   if (sym->flags & SYM_DATA)
 283   {
 284     fprintf (cfile, "/* FIXME: Move to top of file */\n%s;\n\n",
 285              sym->arg_text[0]);
 286     return;
 287   }
 288
 289   if (sym->flags & SYM_THISCALL)
 290     fputs ("#ifdef __i386__\n", cfile);
 291
 292   output_c_banner(sym);
 293
 294   if (!sym->function_name)
 295   {
 296     /* #ifdef'd dummy */
 297     fprintf (cfile, "#if 0\n__%s %s_%s()\n{\n\t/* %s in .spec */\n}\n#endif\n",
 298              symbol_get_call_convention(sym), OUTPUT_UC_DLL_NAME, sym->symbol,
 299              globals.forward_dll ? "@forward" : "@stub");
 300     CPP_END;
 301     return;
 302   }
 303
 304   is_void = !strcmp (sym->return_text, "void");
 305
 306   output_prototype (cfile, sym);
 307   fputs ("\n{\n", cfile);
 308
 309   if (!globals.do_trace)
 310   {
 311     GET_THIS;
 312     fputs ("\tFIXME(\":stub\\n\");\n", cfile);
 313     if (!is_void)
 314         fprintf (cfile, "\treturn (%s) 0;\n", sym->return_text);
 315     fputs ("}\n", cfile);
 316     CPP_END;
 317     return;
 318   }
 319
 320   /* Tracing, maybe forwarding as well */
 321   if (globals.forward_dll)
 322   {
 323     /* Write variables for calling */
 324     if (sym->varargs)
 325       fputs("\tva_list valist;\n", cfile);
 326
 327     fprintf (cfile, "\t%s (__%s *pFunc)(", sym->return_text,
 328              symbol_get_call_convention(sym));
 329
 330     for (i = start; i < sym->argc; i++)
 331       fprintf (cfile, "%s%s", i > start ? ", " : "", sym->arg_text [i]);
 332
 333     fprintf (cfile, "%s);\n", sym->varargs ? ",..." : sym->argc == 1 &&
 334              sym->flags & SYM_THISCALL ? "" : sym->argc ? "" : "void");
 335
 336     if (!is_void)
 337       fprintf (cfile, "\t%s retVal;\n", sym->return_text);
 338
 339     GET_THIS;
 340
 341     fprintf (cfile, "\tpFunc=(void*)GetProcAddress(hDLL,\"%s\");\n",
 342              sym->symbol);
 343   }
 344
 345   /* TRACE input arguments */
 346   fprintf (cfile, "\tTRACE(\"(%s", !sym->argc ? "void" : "");
 347
 348   for (i = 0; i < sym->argc; i++)
 349     fprintf (cfile, "%s(%s)%s", i ? "," : "", sym->arg_text [i],
 350              get_format_str (sym->arg_type [i]));
 351
 352   fprintf (cfile, "%s): %s\\n\"", sym->varargs ? ",..." : "",
 353            globals.forward_dll ? "forward" : "stub");
 354
 355   for (i = 0; i < sym->argc; i++)
 356     if (sym->arg_type[i] != ARG_STRUCT)
 357       fprintf(cfile, ",%s%s%s%s", sym->arg_type[i] == ARG_LONG ? "(LONG)" : "",
 358               sym->arg_type[i] == ARG_WIDE_STRING ? "debugstr_w(" : "",
 359               sym->arg_name[i],
 360               sym->arg_type[i] == ARG_WIDE_STRING ? ")" : "");
 361
 362   fputs (");\n", cfile);
 363
 364   if (!globals.forward_dll)
 365   {
 366     if (!is_void)
 367       fprintf (cfile, "\treturn (%s) 0;\n", sym->return_text);
 368     fputs ("}\n", cfile);
 369     CPP_END;
 370     return;
 371   }
 372
 373   /* Call the DLL */
 374   if (sym->varargs)
 375     fprintf (cfile, "\tva_start(valist,%s);\n", sym->arg_name[sym->argc-1]);
 376
 377   fprintf (cfile, "\t%spFunc(", !is_void ? "retVal = " : "");
 378
 379   for (i = 0; i < sym->argc; i++)
 380     fprintf (cfile, "%s%s", i ? "," : "", sym->arg_name [i]);
 381
 382   fputs (sym->varargs ? ",valist);\n\tva_end(valist);" : ");", cfile);
 383
 384   /* TRACE return value */
 385   fprintf (cfile, "\n\tTRACE(\"Returned (%s)\\n\"",
 386            get_format_str (sym->return_type));
 387
 388   if (!is_void)
 389   {
 390     if (sym->return_type == ARG_WIDE_STRING)
 391       fputs (",debugstr_w(retVal)", cfile);
 392     else
 393       fprintf (cfile, ",%s%s", sym->return_type == ARG_LONG ? "(LONG)" : "",
 394                sym->return_type == ARG_STRUCT ? "" : "retVal");
 395     fputs (");\n\treturn retVal;\n", cfile);
 396   }
 397   else
 398     fputs (");\n", cfile);
 399
 400   fputs ("}\n", cfile);
 401   CPP_END;
 402 }
 403
 404
 405 /*******************************************************************
 406  *         output_c_postamble
 407  *
 408  * Write the last part of the .c file
 409  */
 410 static void output_c_postamble (void)
 411 {
 412   if (cfile)
 413     fclose (cfile);
 414   cfile = NULL;
 415 }
 416
 417
 418 /*******************************************************************
 419  *         output_makefile
 420  *
 421  * Write a Wine compatible makefile.in
 422  */
 423 void  output_makefile (void)
 424 {
 425   FILE *makefile = open_file ("Makefile", ".in", "w");
 426
 427   if (VERBOSE)
 428     puts ("Creating makefile");
 429
 430   fprintf (makefile,
 431            "# Generated from %s by winedump.\nTOPSRCDIR = @top_srcdir@\n"
 432            "TOPOBJDIR = ../..\nSRCDIR    = @srcdir@\nVPATH     = @srcdir@\n"
 433            "MODULE    = %s.dll\n", globals.input_name, OUTPUT_DLL_NAME);
 434
 435   fprintf (makefile, "IMPORTS   = user32 advapi32 kernel32 ntdll");
 436   if (globals.forward_dll)
 437     fprintf (makefile, " %s", globals.forward_dll);
 438
 439   fprintf (makefile,
 440            "\nEXTRALIBS = $(LIBUNICODE)\n\nLDDLLFLAGS = @LDDLLFLAGS@\n"
 441            "SYMBOLFILE = $(MODULE).tmp.o\n\n"
 442            "C_SRCS = \\\n\t%s_main.c\n\n@MAKE_DLL_RULES@\n\n### Dependencies:",
 443            OUTPUT_DLL_NAME);
 444
 445   if (globals.forward_dll)
 446     fprintf (specfile,"#import %s.dll\n", globals.forward_dll);
 447
 448   fclose (makefile);
 449 }
 450
 451
 452 /*******************************************************************
 453  *         output_install_script
 454  *
 455  * Write a script to insert the DLL into Wine
 456  *
 457  * Rather than using diff/patch, several sed calls are generated
 458  * so the script can be re-run at any time without breaking.
 459  */
 460 void  output_install_script (void)
 461 {
 462   char cmd[128];
 463   FILE *install_file = open_file (OUTPUT_DLL_NAME, "_install", "w");
 464
 465   if (VERBOSE)
 466     puts ("Creating install script");
 467
 468   fprintf (install_file,
 469            "#!/bin/bash\n# Generated from %s.dll by winedump.\n\n"
 470            "if [ $# -ne 1 ] || [ ! -d $1 ] || [ ! -f"
 471            " $1/AUTHORS ]; then\n\t[ $# -eq 1 ] && echo \"Invalid path\"\n"
 472            "\techo \"Usage: $0 wine-base-dir\"\n\texit 1\nfi\n\n"
 473            "if [ -d $1/dlls/%s ]; then\n\techo \"DLL is already present\"\n"
 474            "\texit 1\nfi\n\necho Adding DLL %s to Wine build tree...\n"
 475            "echo\n\nmkdir $1/dlls/%s\ncp %s.spec $1/dlls/%s\n"
 476            "cp %s_main.c $1/dlls/%s\ncp %s_dll.h $1/dlls/%s\n"
 477            "cp Makefile.in $1/dlls/%s/Makefile.in\necho Copied DLL files\n\n"
 478            "cd $1\n\nsed '/dlls\\/"
 479            "x11drv\\/Makefile/{G;s/$/dlls\\/%s\\/Makefile/;}' configure.ac"
 480            " >t.tmp\nmv -f t.tmp configure.ac\necho Patched configure.ac\n\n"
 481            "sed '/^all:/{G;s/$/\\^%s.dll$(DLLEXT) \\\\/;}'"
 482            " dlls/Makefile.in| tr ^ \\\\t >t.tmp\n"
 483            "sed '/BASEDIRS =/{G;s/$/\\^%s \\\\/;}' t.tmp | tr ^ \\\\t >t.tmp2"
 484            "\nsed '/Map symlink name /{G;s/$/^\\$(RM) \\$\\@ \\&\\& \\$\\"
 485            "(LN_S\\) %s\\/%s.dll\\$(DLLEXT) \\$\\@/;}' t.tmp2 | tr ^ \\\\t"
 486            " > t.tmp\nsed '/Map symlink name /{G;s/$/%s.dll\\$(DLLEXT): "
 487            "%s\\/%s.dll\\$(DLLEXT)/;}' t.tmp > t.tmp2\nsed '/all dependencies"
 488            "/{G;s/$/%s\\/__install__: %s.dll$(DLLEXT)/;}' t.tmp2 > t.tmp\n"
 489            "sed '/dll dependencies/{G;s/$/%s: user32.dll\\$(DLLEXT) "
 490            "kernel32.dll\\$(DLLEXT) ntdll.dll\\$(DLLEXT) advapi32.dll"
 491            "\\$(DLLEXT)/;}' t.tmp > t.tmp2\n\nsed '/Map library name "
 492            "/{G;s/$/%s\\/%s.dll\\$(DLLEXT): %s/;}' t.tmp2 >t.tmp\n"
 493            "mv -f t.tmp dlls/Makefile.in\nrm -f t.tmp2\necho Patched dlls/"
 494            "Makefile.in\n\necho\necho ...done.\necho Run \\'autoconf\\', "
 495            "\\'./configure\\' then \\'make\\' to rebuild Wine\n\n",
 496            OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME,
 497            OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME,
 498            OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME,
 499            OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME,
 500            OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME,
 501            OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_DLL_NAME,
 502            OUTPUT_DLL_NAME);
 503
 504   fclose (install_file);
 505   snprintf (cmd, sizeof (cmd), "chmod a+x %s_install", OUTPUT_DLL_NAME);
 506   system (cmd);
 507 }
 508
 509
 510 /*******************************************************************
 511  *         output_prototype
 512  *
 513  * Write a C prototype for a parsed symbol
 514  */
 515 void  output_prototype (FILE *file, const parsed_symbol *sym)
 516 {
 517   unsigned int i, start = sym->flags & SYM_THISCALL ? 1 : 0;
 518
 519   fprintf (file, "%s __%s %s_%s(", sym->return_text, symbol_get_call_convention(sym),
 520            OUTPUT_UC_DLL_NAME, sym->function_name);
 521
 522   if (!sym->argc || (sym->argc == 1 && sym->flags & SYM_THISCALL))
 523     fputs ("void", file);
 524   else
 525     for (i = start; i < sym->argc; i++)
 526       fprintf (file, "%s%s %s", i > start ? ", " : "", sym->arg_text [i],
 527                sym->arg_name [i]);
 528   if (sym->varargs)
 529     fputs (", ...", file);
 530   fputc (')', file);
 531 }
 532
 533
 534 /*******************************************************************
 535  *         output_c_banner
 536  *
 537  * Write a function banner to the .c file
 538  */
 539 void  output_c_banner (const parsed_symbol *sym)
 540 {
 541   char ord_spec[16];
 542   size_t i;
 543
 544   if (sym->ordinal >= 0)
 545     snprintf(ord_spec, sizeof (ord_spec), "%d", sym->ordinal);
 546   else
 547   {
 548     ord_spec[0] = '@';
 549     ord_spec[1] = '\0';
 550   }
 551
 552   fprintf (cfile, "/*********************************************************"
 553            "*********\n *\t\t%s (%s.%s)\n *\n", sym->symbol,
 554            OUTPUT_UC_DLL_NAME, ord_spec);
 555
 556   if (globals.do_documentation && sym->function_name)
 557   {
 558     fputs (" *\n * PARAMS\n *\n", cfile);
 559
 560     if (!sym->argc)
 561       fputs (" *  None.\n *\n", cfile);
 562     else
 563     {
 564       for (i = 0; i < sym->argc; i++)
 565         fprintf (cfile, " *  %s [%s]%s\n", sym->arg_name [i],
 566                  get_in_or_out(sym, i),
 567                  strcmp (sym->arg_name [i], "_this") ? "" :
 568                  "     Pointer to the class object (in ECX)");
 569
 570       if (sym->varargs)
 571         fputs (" *  ...[I]\n", cfile);
 572       fputs (" *\n", cfile);
 573     }
 574
 575     fputs (" * RETURNS\n *\n", cfile);
 576
 577     if (sym->return_text && !strcmp (sym->return_text, "void"))
 578       fputs (" *  Nothing.\n", cfile);
 579     else
 580       fprintf (cfile, " *  %s\n", sym->return_text);
 581   }
 582   fputs (" *\n */\n", cfile);
 583 }
 584
 585
 586 /*******************************************************************
 587  *         get_format_str
 588  *
 589  * Get a string containing the correct format string for a type
 590  */
 591 static const char *get_format_str (int type)
 592 {
 593   switch (type)
 594   {
 595   case ARG_VOID:        return "void";
 596   case ARG_FLOAT:       return "%f";
 597   case ARG_DOUBLE:      return "%g";
 598   case ARG_POINTER:     return "%p";
 599   case ARG_WIDE_STRING:
 600   case ARG_STRING:      return "%s";
 601   case ARG_LONG:        return "%ld";
 602   case ARG_STRUCT:      return "struct";
 603   }
 604   assert (0);
 605   return "";
 606 }
 607
 608
 609 /*******************************************************************
 610  *         get_in_or_out
 611  *
 612  * Determine if a parameter is In or In/Out
 613  */
 614 static const char *get_in_or_out (const parsed_symbol *sym, size_t arg)
 615 {
 616   assert (sym && arg < sym->argc);
 617   assert (globals.do_documentation);
 618
 619   if (sym->arg_flag [arg] & CT_CONST)
 620     return "In";
 621
 622   switch (sym->arg_type [arg])
 623   {
 624   case ARG_FLOAT:
 625   case ARG_DOUBLE:
 626   case ARG_LONG:
 627   case ARG_STRUCT:      return "In";
 628   case ARG_POINTER:
 629   case ARG_WIDE_STRING:
 630   case ARG_STRING:      return "In/Out";
 631   }
 632   assert (0);
 633   return "";
 634 }