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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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     fputs (") ", specfile);
 112
 113     if (sym->flags & SYM_THISCALL)
 114       fputs ("__thiscall_", specfile);
 115     fprintf (specfile, "%s_%s", OUTPUT_UC_DLL_NAME, sym->function_name);
 116
 117     fputc ('\n',specfile);
 118   }
 119 }
 120
 121
 122 /*******************************************************************
 123  *         output_spec_postamble
 124  *
 125  * Write the last part of the .spec file
 126  */
 127 static void output_spec_postamble (void)
 128 {
 129   if (specfile)
 130     fclose (specfile);
 131   specfile = NULL;
 132 }
 133
 134
 135 /*******************************************************************
 136  *         output_header_preamble
 137  *
 138  * Write the first part of the .h file
 139  */
 140 void  output_header_preamble (void)
 141 {
 142   if (!globals.do_code)
 143       return;
 144
 145   hfile = open_file (OUTPUT_DLL_NAME, "_dll.h", "w");
 146
 147   atexit (output_header_postamble);
 148
 149   fprintf (hfile,
 150            "/*\n * %s.dll\n *\n * Generated from %s.dll by winedump.\n *\n"
 151            " * DO NOT SEND GENERATED DLLS FOR INCLUSION INTO WINE !\n * \n */"
 152            "\n#ifndef __WINE_%s_DLL_H\n#define __WINE_%s_DLL_H\n\n"
 153            "#include \"windef.h\"\n#include \"wine/debug.h\"\n"
 154            "#include \"winbase.h\"\n#include \"winnt.h\"\n\n\n",
 155            OUTPUT_DLL_NAME, OUTPUT_DLL_NAME, OUTPUT_UC_DLL_NAME,
 156            OUTPUT_UC_DLL_NAME);
 157 }
 158
 159
 160 /*******************************************************************
 161  *         output_header_symbol
 162  *
 163  * Write a symbol to the .h file
 164  */
 165 void  output_header_symbol (const parsed_symbol *sym)
 166 {
 167   if (!globals.do_code)
 168       return;
 169
 170   assert (hfile);
 171   assert (sym && sym->symbol);
 172
 173   if (!globals.do_code)
 174     return;
 175
 176   if (sym->flags & SYM_DATA)
 177     return;
 178
 179   if (!sym->function_name)
 180     fprintf (hfile, "/* __%s %s_%s(); */\n", symbol_get_call_convention(sym),
 181              OUTPUT_UC_DLL_NAME, sym->symbol);
 182   else
 183   {
 184     output_prototype (hfile, sym);
 185     fputs (";\n", hfile);
 186   }
 187 }
 188
 189
 190 /*******************************************************************
 191  *         output_header_postamble
 192  *
 193  * Write the last part of the .h file
 194  */
 195 static void output_header_postamble (void)
 196 {
 197   if (hfile)
 198   {
 199     fprintf (hfile, "\n\n\n#endif\t/* __WINE_%s_DLL_H */\n",
 200              OUTPUT_UC_DLL_NAME);
 201     fclose (hfile);
 202     hfile = NULL;
 203   }
 204 }
 205
 206
 207 /*******************************************************************
 208  *         output_c_preamble
 209  *
 210  * Write the first part of the .c file
 211  */
 212 void  output_c_preamble (void)
 213 {
 214   cfile = open_file (OUTPUT_DLL_NAME, "_main.c", "w");
 215
 216   atexit (output_c_postamble);
 217
 218   fprintf (cfile,
 219            "/*\n * %s.dll\n *\n * Generated from %s by winedump.\n *\n"
 220            " * DO NOT SUBMIT GENERATED DLLS FOR INCLUSION INTO WINE!\n *\n */"
 221            "\n\n#include \"config.h\"\n\n#include <stdarg.h>\n\n"
 222            "#include \"windef.h\"\n#include \"winbase.h\"\n",
 223            OUTPUT_DLL_NAME, globals.input_name);
 224
 225   if (globals.do_code)
 226     fprintf (cfile, "#include \"%s_dll.h\"\n", OUTPUT_DLL_NAME);
 227
 228   fprintf (cfile,"#include \"wine/debug.h\"\n\nWINE_DEFAULT_DEBUG_CHANNEL(%s);\n\n",
 229            OUTPUT_DLL_NAME);
 230
 231   if (globals.forward_dll)
 232   {
 233     if (VERBOSE)
 234       puts ("Creating a forwarding DLL");
 235
 236     fputs ("\nHMODULE hDLL=0;\t/* DLL to call */\n\n", cfile);
 237   }
 238
 239   fprintf (cfile,
 240            "BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID "
 241            "lpvReserved)\n{\n"
 242            "\tTRACE(\"(0x%%p, %%d, %%p)\\n\", hinstDLL, fdwReason, lpvReserved);\n"
 243            "\n\tswitch (fdwReason)\n\t{\n"
 244            "\t\tcase DLL_WINE_PREATTACH:\n"
 245            "\t\t\treturn FALSE;    /* prefer native version */\n"
 246            "\t\tcase DLL_PROCESS_ATTACH:\n");
 247
 248   if (globals.forward_dll)
 249     fprintf (cfile, "\t\t\thDLL = LoadLibraryA(\"%s\");\n"
 250              "\t\t\tTRACE(\"Forwarding DLL (%s) loaded (%%p)\\n\", hDLL);\n",
 251              globals.forward_dll, globals.forward_dll);
 252   else
 253     fprintf (cfile, "\t\t\t/* FIXME: Initialisation */\n"
 254              "\t\t\tDisableThreadLibraryCalls(hinstDLL);\n\t\t\tbreak;\n");
 255
 256   fprintf (cfile, "\t\t\tbreak;\n\t\tcase DLL_PROCESS_DETACH:\n");
 257
 258   if (globals.forward_dll)
 259     fprintf (cfile, "\t\t\tFreeLibrary(hDLL);\n"
 260              "\t\t\tTRACE(\"Forwarding DLL (%s) freed\\n\");\n",
 261              globals.forward_dll);
 262
 263   fprintf (cfile, "\t\t\tbreak;\n\t\tdefault:\n\t\t\tbreak;\n\t}\n\n"
 264            "\treturn TRUE;\n}\n\n\n");
 265 }
 266
 267
 268 /*******************************************************************
 269  *         output_c_symbol
 270  *
 271  * Write a symbol to the .c file
 272  */
 273 void  output_c_symbol (const parsed_symbol *sym)
 274 {
 275   unsigned int i, start = sym->flags & SYM_THISCALL ? 1 : 0;
 276   int is_void;
 277   static int has_thiscall = 0;
 278
 279   assert (cfile);
 280   assert (sym && sym->symbol);
 281
 282   if (!globals.do_code)
 283     return;
 284
 285   if (sym->flags & SYM_DATA)
 286   {
 287     fprintf (cfile, "/* FIXME: Move to top of file */\n%s;\n\n",
 288              sym->arg_text[0]);
 289     return;
 290   }
 291
 292   if (sym->flags & SYM_THISCALL && !has_thiscall)
 293   {
 294     fputs ("#ifdef __i386__  /* thiscall functions are i386-specific */\n\n"
 295            "#define THISCALL(func) __thiscall_ ## func\n"
 296            "#define THISCALL_NAME(func) __ASM_NAME(\"__thiscall_\" #func)\n"
 297            "#define DEFINE_THISCALL_WRAPPER(func) \\\n"
 298            "\textern void THISCALL(func)(); \\\n"
 299            "\t__ASM_GLOBAL_FUNC(__thiscall_ ## func, \\\n"
 300            "\t\t\t\"popl %eax\\n\\t\" \\\n"
 301            "\t\t\t\"pushl %ecx\\n\\t\" \\\n"
 302            "\t\t\t\"pushl %eax\\n\\t\" \\\n"
 303            "\t\t\t\"jmp \" __ASM_NAME(#func) )\n"
 304            "#else /* __i386__ */\n\n"
 305            "#define THISCALL(func) func\n"
 306            "#define THISCALL_NAME(func) __ASM_NAME(#func)\n"
 307            "#define DEFINE_THISCALL_WRAPPER(func) /* nothing */\n\n"
 308            "#endif /* __i386__ */\n\n", cfile);
 309     has_thiscall = 1;
 310   }
 311
 312   output_c_banner(sym);
 313
 314   if (sym->flags & SYM_THISCALL)
 315     fprintf(cfile, "DEFINE_THISCALL_WRAPPER(%s)\n", sym->function_name);
 316
 317   if (!sym->function_name)
 318   {
 319     /* #ifdef'd dummy */
 320     fprintf (cfile, "#if 0\n__%s %s_%s()\n{\n\t/* %s in .spec */\n}\n#endif\n",
 321              symbol_get_call_convention(sym), OUTPUT_UC_DLL_NAME, sym->symbol,
 322              globals.forward_dll ? "@forward" : "@stub");
 323     return;
 324   }
 325
 326   is_void = !strcmp (sym->return_text, "void");
 327
 328   output_prototype (cfile, sym);
 329   fputs ("\n{\n", cfile);
 330
 331   if (!globals.do_trace)
 332   {
 333     fputs ("\tFIXME(\":stub\\n\");\n", cfile);
 334     if (!is_void)
 335         fprintf (cfile, "\treturn (%s) 0;\n", sym->return_text);
 336     fputs ("}\n", cfile);
 337     return;
 338   }
 339
 340   /* Tracing, maybe forwarding as well */
 341   if (globals.forward_dll)
 342   {
 343     /* Write variables for calling */
 344     if (sym->varargs)
 345       fputs("\tva_list valist;\n", cfile);
 346
 347     fprintf (cfile, "\t%s (__%s *pFunc)(", sym->return_text,
 348              symbol_get_call_convention(sym));
 349
 350     for (i = start; i < sym->argc; i++)
 351       fprintf (cfile, "%s%s", i > start ? ", " : "", sym->arg_text [i]);
 352
 353     fprintf (cfile, "%s);\n", sym->varargs ? ",..." : sym->argc == 1 &&
 354              sym->flags & SYM_THISCALL ? "" : sym->argc ? "" : "void");
 355
 356     if (!is_void)
 357       fprintf (cfile, "\t%s retVal;\n", sym->return_text);
 358
 359     fprintf (cfile, "\tpFunc=(void*)GetProcAddress(hDLL,\"%s\");\n",
 360              sym->symbol);
 361   }
 362
 363   /* TRACE input arguments */
 364   fprintf (cfile, "\tTRACE(\"(%s", !sym->argc ? "void" : "");
 365
 366   for (i = 0; i < sym->argc; i++)
 367     fprintf (cfile, "%s(%s)%s", i ? "," : "", sym->arg_text [i],
 368              get_format_str (sym->arg_type [i]));
 369
 370   fprintf (cfile, "%s): %s\\n\"", sym->varargs ? ",..." : "",
 371            globals.forward_dll ? "forward" : "stub");
 372
 373   for (i = 0; i < sym->argc; i++)
 374     if (sym->arg_type[i] != ARG_STRUCT)
 375       fprintf(cfile, ",%s%s%s%s", sym->arg_type[i] == ARG_LONG ? "(LONG)" : "",
 376               sym->arg_type[i] == ARG_WIDE_STRING ? "debugstr_w(" : "",
 377               sym->arg_name[i],
 378               sym->arg_type[i] == ARG_WIDE_STRING ? ")" : "");
 379
 380   fputs (");\n", cfile);
 381
 382   if (!globals.forward_dll)
 383   {
 384     if (!is_void)
 385       fprintf (cfile, "\treturn (%s) 0;\n", sym->return_text);
 386     fputs ("}\n", cfile);
 387     return;
 388   }
 389
 390   /* Call the DLL */
 391   if (sym->varargs)
 392     fprintf (cfile, "\tva_start(valist,%s);\n", sym->arg_name[sym->argc-1]);
 393
 394   fprintf (cfile, "\t%spFunc(", !is_void ? "retVal = " : "");
 395
 396   for (i = 0; i < sym->argc; i++)
 397     fprintf (cfile, "%s%s", i ? "," : "", sym->arg_name [i]);
 398
 399   fputs (sym->varargs ? ",valist);\n\tva_end(valist);" : ");", cfile);
 400
 401   /* TRACE return value */
 402   fprintf (cfile, "\n\tTRACE(\"Returned (%s)\\n\"",
 403            get_format_str (sym->return_type));
 404
 405   if (!is_void)
 406   {
 407     if (sym->return_type == ARG_WIDE_STRING)
 408       fputs (",debugstr_w(retVal)", cfile);
 409     else
 410       fprintf (cfile, ",%s%s", sym->return_type == ARG_LONG ? "(LONG)" : "",
 411                sym->return_type == ARG_STRUCT ? "" : "retVal");
 412     fputs (");\n\treturn retVal;\n", cfile);
 413   }
 414   else
 415     fputs (");\n", cfile);
 416
 417   fputs ("}\n", cfile);
 418 }
 419
 420
 421 /*******************************************************************
 422  *         output_c_postamble
 423  *
 424  * Write the last part of the .c file
 425  */
 426 static void output_c_postamble (void)
 427 {
 428   if (cfile)
 429     fclose (cfile);
 430   cfile = NULL;
 431 }
 432
 433
 434 /*******************************************************************
 435  *         output_makefile
 436  *
 437  * Write a Wine compatible makefile.in
 438  */
 439 void  output_makefile (void)
 440 {
 441   FILE *makefile = open_file ("Makefile", ".in", "w");
 442
 443   if (VERBOSE)
 444     puts ("Creating makefile");
 445
 446   fprintf (makefile,
 447            "# Generated from %s by winedump.\nTOPSRCDIR = @top_srcdir@\n"
 448            "TOPOBJDIR = ../..\nSRCDIR    = @srcdir@\nVPATH     = @srcdir@\n"
 449            "MODULE    = %s.dll\n", globals.input_name, OUTPUT_DLL_NAME);
 450
 451   fprintf (makefile, "IMPORTS   = kernel32");
 452   if (globals.forward_dll)
 453     fprintf (makefile, " %s", globals.forward_dll);
 454
 455   fprintf (makefile,
 456            "\n\nC_SRCS = \\\n\t%s_main.c\n\n@MAKE_DLL_RULES@\n\n"
 457            "@DEPENDENCIES@  # everything below this line is overwritten by make depend",
 458            OUTPUT_DLL_NAME);
 459
 460   if (globals.forward_dll)
 461     fprintf (specfile,"#import %s.dll\n", globals.forward_dll);
 462
 463   fclose (makefile);
 464 }
 465
 466
 467 /*******************************************************************
 468  *         output_prototype
 469  *
 470  * Write a C prototype for a parsed symbol
 471  */
 472 void  output_prototype (FILE *file, const parsed_symbol *sym)
 473 {
 474   unsigned int i, start = sym->flags & SYM_THISCALL ? 1 : 0;
 475
 476   fprintf (file, "%s __%s %s_%s(", sym->return_text, symbol_get_call_convention(sym),
 477            OUTPUT_UC_DLL_NAME, sym->function_name);
 478
 479   if (!sym->argc || (sym->argc == 1 && sym->flags & SYM_THISCALL))
 480     fputs ("void", file);
 481   else
 482     for (i = start; i < sym->argc; i++)
 483       fprintf (file, "%s%s %s", i > start ? ", " : "", sym->arg_text [i],
 484                sym->arg_name [i]);
 485   if (sym->varargs)
 486     fputs (", ...", file);
 487   fputc (')', file);
 488 }
 489
 490
 491 /*******************************************************************
 492  *         output_c_banner
 493  *
 494  * Write a function banner to the .c file
 495  */
 496 void  output_c_banner (const parsed_symbol *sym)
 497 {
 498   char ord_spec[16];
 499   size_t i;
 500
 501   if (sym->ordinal >= 0)
 502     snprintf(ord_spec, sizeof (ord_spec), "%d", sym->ordinal);
 503   else
 504   {
 505     ord_spec[0] = '@';
 506     ord_spec[1] = '\0';
 507   }
 508
 509   fprintf (cfile, "/*********************************************************"
 510            "*********\n *\t\t%s (%s.%s)\n *\n", sym->symbol,
 511            OUTPUT_UC_DLL_NAME, ord_spec);
 512
 513   if (globals.do_documentation && sym->function_name)
 514   {
 515     fputs (" *\n * PARAMS\n *\n", cfile);
 516
 517     if (!sym->argc)
 518       fputs (" *  None.\n *\n", cfile);
 519     else
 520     {
 521       for (i = 0; i < sym->argc; i++)
 522         fprintf (cfile, " *  %s [%s]%s\n", sym->arg_name [i],
 523                  get_in_or_out(sym, i),
 524                  strcmp (sym->arg_name [i], "_this") ? "" :
 525                  "     Pointer to the class object (in ECX)");
 526
 527       if (sym->varargs)
 528         fputs (" *  ...[I]\n", cfile);
 529       fputs (" *\n", cfile);
 530     }
 531
 532     fputs (" * RETURNS\n *\n", cfile);
 533
 534     if (sym->return_text && !strcmp (sym->return_text, "void"))
 535       fputs (" *  Nothing.\n", cfile);
 536     else
 537       fprintf (cfile, " *  %s\n", sym->return_text);
 538   }
 539   fputs (" *\n */\n", cfile);
 540 }
 541
 542
 543 /*******************************************************************
 544  *         get_format_str
 545  *
 546  * Get a string containing the correct format string for a type
 547  */
 548 static const char *get_format_str (int type)
 549 {
 550   switch (type)
 551   {
 552   case ARG_VOID:        return "void";
 553   case ARG_FLOAT:       return "%f";
 554   case ARG_DOUBLE:      return "%g";
 555   case ARG_POINTER:     return "%p";
 556   case ARG_WIDE_STRING:
 557   case ARG_STRING:      return "%s";
 558   case ARG_LONG:        return "%ld";
 559   case ARG_STRUCT:      return "struct";
 560   }
 561   assert (0);
 562   return "";
 563 }
 564
 565
 566 /*******************************************************************
 567  *         get_in_or_out
 568  *
 569  * Determine if a parameter is In or In/Out
 570  */
 571 static const char *get_in_or_out (const parsed_symbol *sym, size_t arg)
 572 {
 573   assert (sym && arg < sym->argc);
 574   assert (globals.do_documentation);
 575
 576   if (sym->arg_flag [arg] & CT_CONST)
 577     return "In";
 578
 579   switch (sym->arg_type [arg])
 580   {
 581   case ARG_FLOAT:
 582   case ARG_DOUBLE:
 583   case ARG_LONG:
 584   case ARG_STRUCT:      return "In";
 585   case ARG_POINTER:
 586   case ARG_WIDE_STRING:
 587   case ARG_STRING:      return "In/Out";
 588   }
 589   assert (0);
 590   return "";
 591 }