tools/bin2res.c

   1 /************************************************
   2  *
   3  * Converting binary resources from/to *.rc files
   4  *
   5  * Copyright 1999 Juergen Schmied
   6  *
   7  * 11/99 first release
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #include "config.h"
  25
  26 #ifdef HAVE_SYS_PARAM_H
  27 # include <sys/param.h>
  28 #endif
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31
  32 #include <ctype.h>
  33 #include <string.h>
  34
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37
  38 #include <fcntl.h>
  39 #ifdef HAVE_UNISTD_H
  40 # include <unistd.h>
  41 #endif
  42 #ifdef HAVE_SYS_MMAN_H
  43 # include <sys/mman.h>
  44 #endif
  45
  46 #include "windef.h"
  47 #include "winbase.h"
  48 #include "wingdi.h"
  49 #include "winuser.h"
  50
  51 extern char*   g_lpstrFileName;
  52
  53 /* global options */
  54
  55 char*   g_lpstrFileName = NULL;
  56 char*   g_lpstrInputFile = NULL;
  57 int     b_to_binary = 0;
  58 int     b_force_overwrite = 0;
  59
  60 static char*    errorOpenFile = "Unable to open file.\n";
  61 static char*    errorRCFormat = "Unexpexted syntax in rc file line %i\n";
  62
  63 void usage(void)
  64 {
  65     printf("Usage: bin2res [-d bin] [input file]\n");
  66     printf("  -d bin convert a *.res back to a binary\n");
  67     printf("  -f force overwriting newer files\n");
  68     exit(-1);
  69 }
  70
  71 void parse_options(int argc, char **argv)
  72 {
  73   int i;
  74
  75   switch( argc )
  76   {
  77     case 2:
  78          g_lpstrInputFile = argv[1];
  79          break;
  80
  81     case 3:
  82     case 4:
  83     case 5:
  84          for( i = 1; i < argc - 1; i++ )
  85          {
  86            if( argv[i][0] != '-' ||
  87                strlen(argv[i]) != 2 ) break;
  88
  89            if( argv[i][1] == 'd')
  90            {
  91              if (strcmp ("bin", argv[i+1])==0)
  92              {
  93                b_to_binary =1;
  94                i++;
  95              }
  96              else
  97              {
  98                usage();
  99              }
 100
 101            }
 102            else if ( argv[i][1] == 'f')
 103            {
 104              b_force_overwrite = 1;
 105            }
 106            else
 107            {
 108              usage();
 109            }
 110          }
 111          if( i == argc - 1 )
 112          {
 113            g_lpstrInputFile = argv[i];
 114            break;
 115          }
 116     default: usage();
 117   }
 118 }
 119
 120 int insert_hex (char * infile, FILE * outfile)
 121 {
 122 #ifdef  HAVE_MMAP
 123         unsigned int i;
 124         int             fd;
 125         struct stat     st;
 126         LPBYTE p_in_file = NULL;
 127
 128         if( (fd = open( infile, O_RDONLY))==-1 )
 129         {
 130           fprintf(stderr, errorOpenFile );
 131           exit(1);
 132         }
 133         if ((fstat(fd, &st) == -1) || (p_in_file = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) == (void *)-1)
 134         {
 135           fprintf(stderr, errorOpenFile );
 136           close(fd);
 137           exit(1);
 138         }
 139
 140         fprintf (outfile, "{\n '");
 141         i = 0;
 142         while (1)
 143         {
 144           fprintf(outfile, "%02X", p_in_file[i]);
 145           if (++i >= st.st_size) break;
 146           fprintf(outfile, "%s", (i == (i & 0xfffffff0)) ? "'\n '" :" ");
 147         }
 148         fprintf (outfile, "'\n}");
 149         munmap(p_in_file, st.st_size);
 150         close(fd);
 151         return 1;
 152 #else   /* HAVE_MMAP */
 153         FILE*   fp;
 154         struct stat     st;
 155         unsigned int    i;
 156         int             c;
 157
 158         fp = fopen( infile, "r" );
 159         if ( fp == NULL )
 160         {
 161           fprintf(stderr, errorOpenFile );
 162           exit(1);
 163         }
 164         if (fstat(fileno(fp), &st) == -1)
 165         {
 166           fprintf(stderr, errorOpenFile );
 167           fclose(fp);
 168           exit(1);
 169         }
 170
 171         fprintf (outfile, "{\n '");
 172         i = 0;
 173         while (1)
 174         {
 175           c = fgetc(fp);
 176           if ( c == EOF )
 177           {
 178             fprintf(stderr, errorOpenFile );
 179             fclose(fp);
 180             exit(1);
 181           }
 182           fprintf(outfile, "%02X", c);
 183           if (++i >= st.st_size) break;
 184           fprintf(outfile, "%s", (i == (i & 0xfffffff0)) ? "'\n '" :" ");
 185         }
 186         fprintf (outfile, "'\n}");
 187
 188         fclose(fp);
 189         return 1;
 190 #endif  /* HAVE_MMAP */
 191 }
 192
 193 int convert_to_res ()
 194 {
 195         FILE    *fin, *ftemp;
 196         char    buffer[255];
 197         char    infile[255];
 198         char    tmpfile[255];
 199         char    *pos;
 200         int     c, len;
 201         struct stat     st;
 202         int line = 0;
 203         time_t  tinput;
 204         long startpos, endpos;
 205
 206         strcpy( tmpfile, g_lpstrInputFile );
 207         strcat( tmpfile, "-tmp" );
 208         /* FIXME: should use better tmp name and create with O_EXCL */
 209         if( (ftemp = fopen( tmpfile, "w")) == NULL ) goto error_open_file;
 210
 211         if( (fin = fopen( g_lpstrInputFile, "r")) == NULL || stat(g_lpstrInputFile, &st)) goto error_open_file;
 212         tinput = st.st_ctime;
 213
 214         while ( NULL != fgets(buffer, 255, fin))
 215         {
 216           fputs(buffer, ftemp);
 217           line++;
 218           if ( (pos = strstr(buffer, "BINRES")) != NULL)
 219           {
 220             /* get the out-file name */
 221             len = 0; pos += 6; startpos=0; endpos=0;
 222             while ( *pos == ' ') pos++;
 223             while ( pos[len] != ' ') len++;
 224             strncpy(infile, pos, len);
 225             infile[len]=0;
 226
 227             if ( (!stat(infile, &st) && st.st_ctime > tinput) || b_force_overwrite)
 228             {
 229               /* write a output file */
 230               printf("[%s:c]", infile);
 231               while((c = fgetc(fin))!='{' && c != EOF) fputc(c, ftemp);
 232               if (c == EOF ) goto error_rc_format;
 233               while((c = fgetc(fin))!='}' && c != EOF);
 234               if (c == EOF ) goto error_rc_format;
 235
 236               insert_hex(infile, ftemp);
 237             }
 238             else
 239             {
 240               printf("[%s:s]", infile);
 241             }
 242           }
 243         }
 244
 245         fclose(fin);
 246         fclose(ftemp);
 247
 248         if (unlink(g_lpstrInputFile) == -1)
 249         {
 250             perror("unlink");
 251             unlink(tmpfile);
 252             return 0;
 253         }
 254         if (rename(tmpfile, g_lpstrInputFile) == -1)
 255         {
 256             perror("rename");
 257             unlink(tmpfile);
 258             return 0;
 259         }
 260         return 1;
 261
 262 error_open_file:
 263         fprintf(stderr, errorOpenFile );
 264         return 0;
 265
 266 error_rc_format:
 267         fprintf(stderr, errorRCFormat, line);
 268         return 0;
 269 }
 270
 271 int convert_to_bin()
 272 {
 273         FILE    *fin, *fout;
 274         char    buffer[255];
 275         char    outfile[255];
 276         char    *pos;
 277         int     len, index, in_resource;
 278         unsigned int    byte;
 279         struct stat     st;
 280         int line = 0;
 281         time_t  tinput;
 282
 283         if( (fin = fopen( g_lpstrInputFile, "r")) == NULL || stat(g_lpstrInputFile, &st)) goto error_open_file;
 284         tinput = st.st_ctime;
 285
 286         while ( NULL != fgets(buffer, 255, fin))
 287         {
 288           line++;
 289           if ( (pos = strstr(buffer, "BINRES")) != NULL)
 290           {
 291             /* get the out-file name */
 292             len = 0; pos += 6;
 293             while ( *pos == ' ') pos++;
 294             while ( pos[len] != ' ') len++;
 295             strncpy(outfile, pos, len);
 296             outfile[len]=0;
 297
 298             if ( stat(outfile, &st) || st.st_ctime < tinput || b_force_overwrite)
 299             {
 300               /* write a output file */
 301               printf("[%s:c]", outfile);
 302               if ( (fout = fopen( outfile, "w")) == NULL) goto error_open_file;
 303
 304               in_resource = 0;
 305               while (1)
 306               {
 307                 if ( NULL == fgets(buffer, 255, fin)) goto error_rc_format;
 308                 line++;
 309
 310                 /* parse a line */
 311                 for ( index = 0; buffer[index] != 0; index++ )
 312                 {
 313                   if ( ! in_resource )
 314                   {
 315                     if ( buffer[index] == '{' ) in_resource = 1;
 316                     continue;
 317                   }
 318
 319                   if ( buffer[index] == ' ' || buffer[index] == '\''|| buffer[index] == '\n' ) continue;
 320                   if ( buffer[index] == '}' ) goto end_of_resource;
 321                   if ( ! isxdigit(buffer[index])) goto error_rc_format;
 322                   index += sscanf(&buffer[index], "%02x", &byte);
 323                   fputc(byte, fout);
 324                 }
 325               }
 326               fclose(fout);
 327             }
 328             else
 329             {
 330               printf("[%s:s]", outfile);
 331             }
 332 end_of_resource: ;
 333           }
 334         }
 335
 336         fclose(fin);
 337         return 1;
 338
 339 error_open_file:
 340         fprintf(stderr, errorOpenFile );
 341         return 0;
 342
 343 error_rc_format:
 344         fprintf(stderr, errorRCFormat, line);
 345         return 0;
 346 }
 347
 348 int main(int argc, char **argv)
 349 {
 350         parse_options( argc, argv);
 351
 352         if (b_to_binary == 0)
 353         {
 354           convert_to_res();
 355         }
 356         else
 357         {
 358           convert_to_bin();
 359         }
 360         printf("\n");
 361         return 0;
 362 }