make_xftmpl.c 15.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 * Binary encode X templates from text format.
 *
 * Copyright 2011 Dylan Smith
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#include "config.h"
#include "wine/port.h"

#include <signal.h>
25
#include <stdarg.h>
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
#include <stdio.h>
#include <stdlib.h>
#ifdef HAVE_GETOPT_H
# include <getopt.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#include "windef.h"
#include "guiddef.h"

#define ARRAY_SIZE(array) (sizeof(array)/sizeof(array[0]))

#define TOKEN_NAME         1
#define TOKEN_STRING       2
#define TOKEN_INTEGER      3
#define TOKEN_GUID         5
#define TOKEN_INTEGER_LIST 6
#define TOKEN_FLOAT_LIST   7
#define TOKEN_OBRACE      10
#define TOKEN_CBRACE      11
#define TOKEN_OPAREN      12
#define TOKEN_CPAREN      13
#define TOKEN_OBRACKET    14
#define TOKEN_CBRACKET    15
#define TOKEN_OANGLE      16
#define TOKEN_CANGLE      17
#define TOKEN_DOT         18
#define TOKEN_COMMA       19
#define TOKEN_SEMICOLON   20
#define TOKEN_TEMPLATE    31
#define TOKEN_WORD        40
#define TOKEN_DWORD       41
#define TOKEN_FLOAT       42
#define TOKEN_DOUBLE      43
#define TOKEN_CHAR        44
#define TOKEN_UCHAR       45
#define TOKEN_SWORD       46
#define TOKEN_SDWORD      47
#define TOKEN_VOID        48
#define TOKEN_LPSTR       49
#define TOKEN_UNICODE     50
#define TOKEN_CSTRING     51
#define TOKEN_ARRAY       52

struct keyword
{
    const char *word;
    WORD token;
};

static const struct keyword reserved_words[] = {
    {"ARRAY", TOKEN_ARRAY},
    {"CHAR", TOKEN_CHAR},
    {"CSTRING", TOKEN_CSTRING},
    {"DOUBLE", TOKEN_DOUBLE},
    {"DWORD", TOKEN_DWORD},
    {"FLOAT", TOKEN_FLOAT},
    {"SDWORD", TOKEN_SDWORD},
    {"STRING", TOKEN_LPSTR},
    {"SWORD", TOKEN_SWORD},
    {"TEMPLATE", TOKEN_TEMPLATE},
    {"UCHAR", TOKEN_UCHAR},
    {"UNICODE", TOKEN_UNICODE},
    {"VOID", TOKEN_VOID},
    {"WORD", TOKEN_WORD}
};

95 96
extern int getopt(int argc, char *const *argv, const char *optstring);

97 98 99 100
static BOOL option_header;
static char *option_inc_var_name = NULL;
static char *option_inc_size_name = NULL;
static const char *option_outfile_name = "-";
101
static char *program_name;
102 103
static FILE *infile;
static int line_no;
104
static const char *infile_name;
105
static FILE *outfile;
106 107
static BYTE *output_data;
static UINT output_pos, output_size;
108 109 110 111 112

#ifndef __GNUC__
#define __attribute__(x)
#endif

113
static void fatal_error( const char *msg, ... ) __attribute__ ((__format__ (__printf__, 1, 2)));
114

115
static void fatal_error( const char *msg, ... )
116 117 118 119 120
{
    va_list valist;
    va_start( valist, msg );
    if (infile_name)
    {
121
        fprintf( stderr, "%s:%d:", infile_name, line_no );
122 123 124 125 126 127 128 129
        fprintf( stderr, " error: " );
    }
    else fprintf( stderr, "%s: error: ", program_name );
    vfprintf( stderr, msg, valist );
    va_end( valist );
    exit( 1 );
}

130

131
static inline BOOL read_byte( char *byte )
132
{
133
    int c = fgetc(infile);
134
    *byte = c;
135
    if (c == '\n') line_no++;
136 137 138
    return c != EOF;
}

139
static inline BOOL unread_byte( char last_byte )
140
{
141 142
    if (last_byte == '\n') line_no--;
    return ungetc(last_byte, infile) != EOF;
143 144
}

145
static inline BOOL read_bytes( void *data, DWORD size )
146
{
147
    return fread(data, size, 1, infile) > 0;
148 149
}

150
static BOOL write_c_hex_bytes(void)
151
{
152 153
    UINT i;
    for (i = 0; i < output_pos; i++)
154
    {
155
        if (i % 12 == 0)
156 157
            fprintf(outfile, "\n ");
        fprintf(outfile, " 0x%02x,", output_data[i]);
158 159 160 161
    }
    return TRUE;
}

162
static BOOL write_raw_bytes(void)
163
{
164
    return fwrite(output_data, output_pos, 1, outfile) > 0;
165 166
}

167
static inline BOOL write_bytes(const void *data, DWORD size)
168
{
169 170 171 172 173 174 175 176 177
    if (output_pos + size > output_size)
    {
        output_size = max( output_size * 2, size );
        output_data = realloc( output_data, output_size );
        if (!output_data) return FALSE;
    }
    memcpy( output_data + output_pos, data, size );
    output_pos += size;
    return TRUE;
178 179
}

180
static inline BOOL write_byte(BYTE value)
181
{
182
    return write_bytes( &value, sizeof(value) );
183 184
}

185
static inline BOOL write_word(WORD value)
186
{
187 188
    return write_byte( value ) &&
           write_byte( value >> 8 );
189 190
}

191
static inline BOOL write_dword(DWORD value)
192
{
193 194
    return write_word( value ) &&
           write_word( value >> 16 );
195 196
}

197
static inline BOOL write_float(float value)
198 199 200
{
    DWORD val;
    memcpy( &val, &value, sizeof(value) );
201
    return write_dword( val );
202 203
}

204
static inline BOOL write_guid(const GUID *guid)
205
{
206 207 208 209
    return write_dword( guid->Data1 ) &&
           write_word( guid->Data2 ) &&
           write_word( guid->Data3 ) &&
           write_bytes( guid->Data4, sizeof(guid->Data4) );
210 211 212 213 214 215 216
}

static int compare_names(const void *a, const void *b)
{
    return strcasecmp(*(const char **)a, *(const char **)b);
}

217
static BOOL parse_keyword( const char *name )
218 219 220 221 222 223 224 225
{
    const struct keyword *keyword;

    keyword = bsearch(&name, reserved_words, ARRAY_SIZE(reserved_words),
                      sizeof(reserved_words[0]), compare_names);
    if (!keyword)
        return FALSE;

226
    return write_word(keyword->token);
227 228
}

229
static BOOL parse_guid(void)
230 231 232 233 234 235 236 237
{
    char buf[39];
    GUID guid;
    DWORD tab[10];
    BOOL ret;
    static const char *guidfmt = "<%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X>";

    buf[0] = '<';
238
    if (!read_bytes(buf + 1, 37)) fatal_error( "truncated GUID\n" );
239 240 241
    buf[38] = 0;

    ret = sscanf(buf, guidfmt, &guid.Data1, tab, tab+1, tab+2, tab+3, tab+4, tab+5, tab+6, tab+7, tab+8, tab+9);
242
    if (ret != 11) fatal_error( "invalid GUID '%s'\n", buf );
243 244 245 246 247 248 249 250 251 252 253 254

    guid.Data2 = tab[0];
    guid.Data3 = tab[1];
    guid.Data4[0] = tab[2];
    guid.Data4[1] = tab[3];
    guid.Data4[2] = tab[4];
    guid.Data4[3] = tab[5];
    guid.Data4[4] = tab[6];
    guid.Data4[5] = tab[7];
    guid.Data4[6] = tab[8];
    guid.Data4[7] = tab[9];

255 256
    return write_word(TOKEN_GUID) &&
           write_guid(&guid);
257 258
}

259
static BOOL parse_name(void)
260 261 262 263 264
{
    char c;
    int len = 0;
    char name[512];

265
    while (read_byte(&c) && len < sizeof(name) &&
266 267 268 269 270
           (isalnum(c) || c == '_' || c == '-'))
    {
        if (len + 1 < sizeof(name))
            name[len++] = c;
    }
271
    unread_byte(c);
272 273
    name[len] = 0;

274
    if (parse_keyword(name)) {
275 276
        return TRUE;
    } else {
277 278 279
        return write_word(TOKEN_NAME) &&
               write_dword(len) &&
               write_bytes(name, len);
280 281 282
    }
}

283
static BOOL parse_number(void)
284 285 286 287 288 289 290
{
    int len = 0;
    char c;
    char buffer[512];
    BOOL dot = FALSE;
    BOOL ret;

291
    while (read_byte(&c) &&
292 293 294 295 296 297 298
           ((!len && c == '-') || (!dot && c == '.') || isdigit(c)))
    {
        if (len + 1 < sizeof(buffer))
            buffer[len++] = c;
        if (c == '.')
            dot = TRUE;
    }
299
    unread_byte(c);
300 301 302 303 304
    buffer[len] = 0;

    if (dot) {
        float value;
        ret = sscanf(buffer, "%f", &value);
305 306 307
        if (!ret) fatal_error( "invalid float token\n" );
        ret = write_word(TOKEN_FLOAT) &&
              write_float(value);
308 309 310
    } else {
        int value;
        ret = sscanf(buffer, "%d", &value);
311 312 313
        if (!ret) fatal_error( "invalid integer token\n" );
        ret = write_word(TOKEN_INTEGER) &&
              write_dword(value);
314 315 316 317 318
    }

    return ret;
}

319
static BOOL parse_token(void)
320 321
{
    char c;
322 323
    int len;
    char *tok, buffer[512];
324

325
    if (!read_byte(&c))
326 327 328 329 330 331 332 333 334 335
        return FALSE;

    switch (c)
    {
        case '\n':
        case '\r':
        case ' ':
        case '\t':
            return TRUE;

336 337 338 339 340 341 342 343 344
        case '{': return write_word(TOKEN_OBRACE);
        case '}': return write_word(TOKEN_CBRACE);
        case '[': return write_word(TOKEN_OBRACKET);
        case ']': return write_word(TOKEN_CBRACKET);
        case '(': return write_word(TOKEN_OPAREN);
        case ')': return write_word(TOKEN_CPAREN);
        case ',': return write_word(TOKEN_COMMA);
        case ';': return write_word(TOKEN_SEMICOLON);
        case '.': return write_word(TOKEN_DOT);
345 346

        case '/':
347 348 349
            if (!read_byte(&c) || c != '/')
                fatal_error( "invalid single '/' comment token\n" );
            while (read_byte(&c) && c != '\n');
350 351
            return c == '\n';

352 353
        case '#':
            len = 0;
354
            while (read_byte(&c) && c != '\n')
355
                if (len + 1 < sizeof(buffer)) buffer[len++] = c;
356
            if (c != '\n') fatal_error( "line too long\n" );
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
            buffer[len] = 0;
            tok = strtok( buffer, " \t" );
            if (!tok || strcmp( tok, "pragma" )) return TRUE;
            tok = strtok( NULL, " \t" );
            if (!tok || strcmp( tok, "xftmpl" )) return TRUE;
            tok = strtok( NULL, " \t" );
            if (!tok) return TRUE;
            if (!strcmp( tok, "name" ))
            {
                tok = strtok( NULL, " \t" );
                if (tok && !option_inc_var_name) option_inc_var_name = strdup( tok );
            }
            else if (!strcmp( tok, "size" ))
            {
                tok = strtok( NULL, " \t" );
                if (tok && !option_inc_size_name) option_inc_size_name = strdup( tok );
            }
            return TRUE;

376
        case '<':
377
            return parse_guid();
378 379

        case '"':
380
            len = 0;
381 382

            /* FIXME: Handle '\' (e.g. "valid\"string") */
383
            while (read_byte(&c) && c != '"') {
384 385 386
                if (len + 1 < sizeof(buffer))
                    buffer[len++] = c;
            }
387 388 389 390
            if (c != '"') fatal_error( "unterminated string\n" );
            return write_word(TOKEN_STRING) &&
                   write_dword(len) &&
                   write_bytes(buffer, len);
391 392

        default:
393
            unread_byte(c);
394
            if (isdigit(c) || c == '-')
395
                return parse_number();
396
            if (isalpha(c) || c == '_')
397 398
                return parse_name();
            fatal_error( "invalid character '%c' to start token\n", c );
399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
    }

    return TRUE;
}

static const char *output_file;

static void cleanup_files(void)
{
    if (output_file) unlink(output_file);
}

static void exit_on_signal( int sig )
{
    exit(1);  /* this will call the atexit functions */
}

static void usage(void)
{
    fprintf(stderr, "Usage: %s [OPTIONS] INFILE\n"
                    "Options:\n"
420
                    "  -H        Output to a c header file instead of a binary file\n"
421 422 423 424 425 426 427 428 429 430
                    "  -i NAME   Output to a c header file, data in variable NAME\n"
                    "  -s NAME   In a c header file, define NAME to be the data size\n"
                    "  -o FILE   Write output to FILE\n",
                    program_name);
}

static char **parse_options(int argc, char **argv)
{
    int optc;

431
    while ((optc = getopt(argc, argv, "hHi:o:s:")) != -1)
432 433 434 435 436 437
    {
        switch (optc)
        {
            case 'h':
                usage();
                exit(0);
438 439 440
            case 'H':
                option_header = TRUE;
                break;
441
            case 'i':
442
                option_header = TRUE;
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
                option_inc_var_name = strdup(optarg);
                break;
            case 'o':
                option_outfile_name = strdup(optarg);
                break;
            case 's':
                option_inc_size_name = strdup(optarg);
                break;
        }
    }
    return &argv[optind];
}

int main(int argc, char **argv)
{
    char header[16];
    char **args;
    char *header_name = NULL;

    program_name = argv[0];

    args = parse_options(argc, argv);
    infile_name = *args++;
    if (!infile_name || *args)
    {
        usage();
        return 1;
    }

472 473
    infile = stdin;
    outfile = NULL;
474 475 476

    if (!strcmp(infile_name, "-")) {
        infile_name = "stdin";
477
    } else if (!(infile = fopen(infile_name, "rb"))) {
478 479 480 481
        perror(infile_name);
        goto error;
    }

482
    if (!read_bytes(header, sizeof(header))) {
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510
        fprintf(stderr, "%s: Failed to read file header\n", program_name);
        goto error;
    }
    if (strncmp(header, "xof ", 4))
    {
        fprintf(stderr, "%s: Invalid magic value '%.4s'\n", program_name, header);
        goto error;
    }
    if (strncmp(header + 4, "0302", 4) && strncmp(header + 4, "0303", 4))
    {
        fprintf(stderr, "%s: Unsupported version '%.4s'\n", program_name, header + 4);
        goto error;
    }
    if (strncmp(header + 8, "txt ", 4))
    {
        fprintf(stderr, "%s: Only support conversion from text encoded X files.",
                program_name);
        goto error;
    }
    if (strncmp(header + 12, "0032", 4) && strncmp(header + 12, "0064", 4))
    {
        fprintf(stderr, "%s: Only 32-bit or 64-bit float format supported, not '%.4s'.\n",
                program_name, header + 12);
        goto error;
    }

    if (!strcmp(option_outfile_name, "-")) {
        option_outfile_name = "stdout";
511
        outfile = stdout;
512 513 514 515 516 517 518 519
    } else {
        output_file = option_outfile_name;
        atexit(cleanup_files);
        signal(SIGTERM, exit_on_signal);
        signal(SIGINT, exit_on_signal);
#ifdef SIGHUP
        signal(SIGHUP, exit_on_signal);
#endif
520
        if (!(outfile = fopen(output_file, "wb"))) {
521 522 523 524 525
            perror(option_outfile_name);
            goto error;
        }
    }

526
    if (!write_bytes("xof 0302bin 0064", 16))
527 528
        goto error;

529 530
    line_no = 1;
    while (parse_token());
531

532
    if (ferror(outfile) || ferror(infile))
533 534 535
        goto error;

    if (option_header)
536 537 538
    {
        char *str_ptr;

539
        if (!option_inc_var_name)
540
            fatal_error( "variable name must be specified with -i or #pragma name\n" );
541

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
        header_name = strrchr(option_outfile_name, '/');
        if (header_name)
            header_name = strdup(header_name + 1);
        else
            header_name = strdup(option_outfile_name);
        if (!header_name) {
            fprintf(stderr, "Out of memory\n");
            goto error;
        }

        str_ptr = header_name;
        while (*str_ptr) {
            if (*str_ptr == '.')
                *str_ptr = '_';
            else
                *str_ptr = toupper(*str_ptr);
            str_ptr++;
        }

561
        fprintf(outfile,
562 563 564 565 566 567 568
            "/* File generated automatically from %s; do not edit */\n"
            "\n"
            "#ifndef __WINE_%s\n"
            "#define __WINE_%s\n"
            "\n"
            "unsigned char %s[] = {",
            infile_name, header_name, header_name, option_inc_var_name);
569 570
        write_c_hex_bytes();
        fprintf(outfile, "\n};\n\n");
571
        if (option_inc_size_name)
572 573 574
            fprintf(outfile, "#define %s %u\n\n", option_inc_size_name, output_pos);
        fprintf(outfile, "#endif /* __WINE_%s */\n", header_name);
        if (ferror(outfile))
575 576
            goto error;
    }
577
    else write_raw_bytes();
578

579 580
    fclose(infile);
    fclose(outfile);
581 582 583 584
    output_file = NULL;

    return 0;
error:
585 586
    if (infile) {
        if (ferror(infile))
587
            perror(infile_name);
588
        fclose(infile);
589
    }
590 591
    if (outfile) {
        if (ferror(outfile))
592
            perror(option_outfile_name);
593
        fclose(outfile);
594 595 596
    }
    return 1;
}