iface/dll/defedf.c

   1 /* $Id$
   2  *
   3  * reactos/iface/dll/defedf.c
   4  *
   5  * ReactOS Operating System
   6  *
   7  * Convert a *.def file for a PE image into an *.edf file,
   8  * to build the PE image with a clean exports table.
   9  *
  10  * Written by EA (19990703)
  11  *
  12  */
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <limits.h>
  16 #ifndef MAX_PATH
  17 # ifdef PATH_MAX
  18 #  define MAX_PATH PATH_MAX
  19 # else
  20 #  define MAX_PATH _MAX_PATH
  21 # endif
  22 #endif
  23 #include <string.h>
  24
  25 #define INPUT_BUFFER_SIZE 1024
  26
  27 //#define DEBUG
  28
  29 static const char * SUFFIX_DEF = ".def";
  30 static const char * SUFFIX_EDF = ".edf";
  31
  32
  33 int
  34 Usage ( const char * ImageName )
  35 {
  36         fprintf(
  37                 stderr,
  38                 "Usage: %s def_file [edf_file]\n",
  39                 ImageName
  40                 );
  41         return EXIT_SUCCESS;
  42 }
  43
  44
  45 char *
  46 AddSuffix (
  47         const char      * Prototype,
  48         const char      * Suffix
  49         )
  50 {
  51         char    NewName [MAX_PATH];
  52         char    * SuffixStart;
  53
  54         if (!Prototype) return NULL;
  55         strcpy( NewName, Prototype );
  56         SuffixStart =
  57                 NewName
  58                 + strlen(NewName)
  59                 - strlen(Suffix);
  60         if (strcmp(SuffixStart,Suffix))
  61         {
  62                 strcat(NewName, Suffix);
  63         }
  64         return strdup(NewName);
  65 }
  66
  67
  68 char *
  69 MakeEdfName (
  70         const char      * NameDef,
  71         const char      * NameEdf
  72         )
  73 {
  74         if (NULL == NameEdf)
  75         {
  76                 char    NewName [MAX_PATH];
  77                 char    * Dot;
  78
  79                 strcpy( NewName, NameDef );
  80                 Dot = strrchr( NewName, '.');
  81                 if (0 == strcmp(Dot, SUFFIX_DEF))
  82                 {
  83                         *Dot = '\0';
  84                 }
  85                 return AddSuffix( NewName, SUFFIX_EDF );
  86         }
  87         return AddSuffix( NameEdf, SUFFIX_EDF );
  88 }
  89
  90
  91 typedef
  92 enum
  93 {
  94         LineLibrary,
  95         LineExports,
  96         LineImports,
  97         LineSymbol,
  98 //      LineSymbolCdecl,
  99 //      LineSymbolStdcall,
 100 //      LineSymbolFastcall,
 101 //      LineSymbolData,
 102         LineComment,
 103         LineEmpty
 104
 105 } PARSING_EXIT_CODE;
 106
 107
 108 PARSING_EXIT_CODE
 109 ParseInput (
 110         char * InputBuffer,
 111         char * CleanName
 112         )
 113 {
 114         char    * r;
 115
 116         r = strrchr( InputBuffer, '\n' );
 117         if (r) *r = '\0';
 118 #ifdef DEBUG
 119 printf("ParseInput(%s)\n",InputBuffer);
 120 #endif
 121         if (0 == strlen(InputBuffer))
 122         {
 123 #ifdef DEBUG
 124 printf("LineEmpty\n");
 125 #endif
 126                 return LineEmpty;
 127         }
 128         /*
 129          * Skip blanks and tabs.
 130          */
 131         for (   InputBuffer;
 132                 (
 133                         (*InputBuffer)
 134                         && (*InputBuffer == ' ')
 135                         && (*InputBuffer == '\t')
 136                         );
 137                 InputBuffer++
 138                 );
 139 #ifdef DEBUG
 140 printf("1st=\"%c\" (%d)\n", *InputBuffer, (int) *InputBuffer );
 141 #endif
 142         r = InputBuffer;
 143         if (*r == ';')
 144         {
 145                 strcpy( InputBuffer, r );
 146 #ifdef DEBUG
 147 printf("LineComment\n");
 148 #endif
 149                 return LineComment;
 150         }
 151         r = strchr( InputBuffer, '=' );
 152         if (r)
 153         {
 154                 printf( "Fatal error: can not process DEF files with aliases!\n");
 155                 exit(EXIT_FAILURE);
 156         }
 157         r = strchr( InputBuffer, '@' );
 158         if (r)
 159         {
 160                 strcpy( CleanName, InputBuffer );
 161                 r = strchr( CleanName, '@' );
 162                 *r = '\0';
 163 #ifdef DEBUG
 164 printf("LineSymbol: \"%s\"=\"%s\"\n",InputBuffer,CleanName);
 165 #endif
 166                 return LineSymbol;
 167         }
 168         /* can not recognize it; copy it verbatim */
 169 #ifdef DEBUG
 170 printf("LineComment\n");
 171 #endif
 172         return LineComment;
 173 }
 174
 175
 176 int
 177 DefEdf (
 178         const char      * ImageName,
 179         const char      * Def,
 180         const char      * Edf
 181         )
 182 {
 183         FILE    * fDef;
 184         FILE    * fEdf;
 185         char    InputBuffer [INPUT_BUFFER_SIZE];
 186
 187         printf(
 188                 "%s --> %s\n",
 189                 Def,
 190                 Edf
 191                 );
 192         fDef = fopen( Def, "r" );
 193         if (!fDef)
 194         {
 195                 fprintf(
 196                         stderr,
 197                         "%s: could not open \"%s\"\n",
 198                         ImageName,
 199                         Def
 200                         );
 201                 return EXIT_FAILURE;
 202         }
 203         fEdf = fopen( Edf, "w" );
 204         if (!fEdf)
 205         {
 206                 fprintf(
 207                         stderr,
 208                         "%s: could not create \"%s\"\n",
 209                         ImageName,
 210                         Edf
 211                         );
 212                 return EXIT_FAILURE;
 213         }
 214         while ( fgets( InputBuffer, sizeof InputBuffer, fDef ) )
 215         {
 216                 char CleanName [MAX_PATH];
 217
 218                 switch (ParseInput(InputBuffer,CleanName))
 219                 {
 220                 case LineLibrary:
 221                         fprintf(fEdf,"%s\n",InputBuffer);
 222                         break;
 223
 224                 case LineExports:
 225                         fprintf(fEdf,"EXPORTS\n");
 226                         break;
 227
 228                 case LineImports:
 229                         fprintf(fEdf,"IMPORTS\n");
 230                         break;
 231
 232                 case LineSymbol:
 233                         fprintf(
 234                                 fEdf,
 235                                 "%s=%s\n",
 236                                 CleanName,
 237                                 InputBuffer
 238                                 );
 239                         break;
 240
 241                 case LineComment:
 242                         fprintf(
 243                                 fEdf,
 244                                 "%s\n",
 245                                 InputBuffer
 246                                 );
 247                         break;
 248
 249                 case LineEmpty:
 250                         fprintf(
 251                                 fEdf,
 252                                 "\n"
 253                                 );
 254                         break;
 255                 }
 256         }
 257         fclose(fDef);
 258         fclose(fEdf);
 259         return EXIT_SUCCESS;
 260 }
 261
 262
 263 int
 264 main(
 265         int     argc,
 266         char    * argv []
 267         )
 268 {
 269         char    * NameDef;
 270         char    * NameEdf;
 271         int     rv;
 272
 273
 274         if ((argc != 2) && (argc != 3))
 275         {
 276                 return Usage(argv[0]);
 277         }
 278         NameDef = AddSuffix(
 279                         argv [1],
 280                         SUFFIX_DEF
 281                         );
 282         if (!NameDef)
 283         {
 284                 fprintf(
 285                         stderr,
 286                         "%s: can not build the def_file name\n",
 287                         argv [0]
 288                         );
 289                 return EXIT_FAILURE;
 290         }
 291         NameEdf = MakeEdfName(
 292                         NameDef,
 293                         argv [2]
 294                         );
 295         if (!NameEdf)
 296         {
 297                 fprintf(
 298                         stderr,
 299                         "%s: can not build the edf_file name\n",
 300                         argv [0]
 301                         );
 302                 free(NameDef);
 303                 return EXIT_FAILURE;
 304         }
 305         rv = DefEdf(
 306                 argv [0],
 307                 NameDef,
 308                 NameEdf
 309                 );
 310         free(NameDef);
 311         free(NameEdf);
 312         return rv;
 313 }
 314
 315 /* EOF */