/*
 * Copyright (c) 2003 Matthijs Hollemans
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */


#include <AppFileInfo.h>
#include <Mime.h>
#include <Resources.h>
#include <Roster.h>
#include <TypeConstants.h>

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "rdef.h"
#include "private.h"

// What we add to the front of enum symbols.
#define PREFIX  "R_"


static FILE *sOutputFile;
static FILE *sHeaderFile;

// Level of indentation (how many tabs).
static int32 sTabs;
static bool sBraceOnNextLine = false;


static void write_generic_data(const char *name, type_code type,
        const void *data, size_t length);


static void
indent()
{
        for (int32 t = 0; t < sTabs; ++t) {
                fprintf(sOutputFile, "\t");
        }
}


void
open_brace()
{
        if (sBraceOnNextLine) {
                fprintf(sOutputFile, "\n");
                indent();
                fprintf(sOutputFile, "{\n");
        } else
                fprintf(sOutputFile, " {\n");

        ++sTabs;
}


void
close_brace()
{
        --sTabs;

        fprintf(sOutputFile, "\n");
        indent();
        fprintf(sOutputFile, "}");
}


static bool
make_code(uint32 value, char *code)
{
        code[0] = (value >> 24) & 0xFF;
        if (isprint(code[0])) {
                code[1] = (value >> 16) & 0xFF;
                if (isprint(code[1])) {
                        code[2] = (value >> 8) & 0xFF;
                        if (isprint(code[2])) {
                                code[3] = value & 0xFF;
                                if (isprint(code[3])) {
                                        code[4] = '\0';
                                        return true;
                                }
                        }
                }
        }

        return false;
}


static void
write_code(uint32 value)
{
        char code[5];
        if (make_code(value, code))
                fprintf(sOutputFile, "'%s'", code);
        else
                fprintf(sOutputFile, "%" B_PRIu32, value);
}


static void
write_field_name(const char *name)
{
        // We call this from the write_xxx() functions to properly align a
        // field's type code (which goes to the left of the field name) and
        // the field's data (to right of the name). If we are not currently
        // writing a field (but the entire resource), name is NULL.

        if (name != NULL)
                fprintf(sOutputFile, "\"%s\" = ", name);
}


static bool
is_ident(const char *name)
{
        if (name[0] != '_' && !isalpha(name[0]))
                return false;

        for (size_t t = 1; t < strlen(name); ++t) {
                if (name[t] != '_' && !isalnum(name[t]))
                        return false;
        }

        return true;
}


static bool
has_prefix(const char *name)
{
        size_t name_len = strlen(name);
        size_t prefix_len = strlen(PREFIX);

        if (name_len > prefix_len) {
                if (strncmp(name, PREFIX, prefix_len) == 0)
                        return true;
        }

        return false;
}


static bool
is_string(const void *data, size_t length)
{
        // We consider the buffer a string if it contains only human readable
        // characters. The buffer should also end with a '\0'. Although the
        // compiler allows string literals to contain embedded '\0' chars as
        // well, we don't allow them here (because they may cause false hits).

        if (length == 0)
                return false;

        char *ptr = (char *)data;

        for (size_t t = 0; t < length - 1; ++t) {
                if (!isprint(*ptr++))
                        return false;
        }

        return (*ptr == '\0');
}


static void
write_rsrc(type_code type, int32 id, const char *name)
{
        if (name[0] == '\0') {
                fprintf(sOutputFile, "resource(%" B_PRId32 ") ", id);
        } else if ((flags & RDEF_AUTO_NAMES) != 0&& is_ident(name)) {
                char code[5];
                if (has_prefix(name)) {
                        fprintf(sOutputFile, "resource(%s) ", name);
                        fprintf(sHeaderFile, "\t%s = %" B_PRId32 ",\n", name, id);
                } else if (make_code(type, code)) {
                        fprintf(sOutputFile, "resource(%s%s_%s) ", PREFIX, code, name);
                        fprintf(sHeaderFile, "\t%s%s_%s = %" B_PRId32 ",\n", PREFIX, code,
                                name, id);
                } else {
                        fprintf(sOutputFile, "resource(%s%" B_PRIu32 "_%s) ", PREFIX,
                                (uint32)type, name);
                        fprintf(sHeaderFile, "\t%s%" B_PRIu32 "_%s = %" B_PRId32 ",\n",
                                PREFIX, (uint32)type, name, id);
                }
        } else {
                fprintf(sOutputFile, "resource(%" B_PRId32 ", \"%s\") ", id, name);
        }
}


//      #pragma mark - generic types


static uint8 *
write_raw_line(uint8 *ptr, uint8 *end, size_t bytesPerLine)
{
        uint32 count = 0;

        fprintf(sOutputFile, "$\"");

        while (ptr < end && count < bytesPerLine) {
                fprintf(sOutputFile, "%02X", *ptr++);
                ++count;
        }

        fprintf(sOutputFile, "\"");

        return ptr;
}


static void
write_raw(const char *name, type_code type, const void *data,
        size_t length, size_t bytesPerLine = 32)
{
        uint8 *ptr = (uint8 *)data;
        uint8 *end = ptr + length;

        if (length > bytesPerLine) {
                if (type != B_RAW_TYPE) {
                        fprintf(sOutputFile, "#");
                        write_code(type);
                        fprintf(sOutputFile, " ");
                }

                write_field_name(name);
                fprintf(sOutputFile, "array");

                open_brace();

                int32 item = 0;
                while (ptr < end) {
                        if (item++ > 0)
                                fprintf(sOutputFile, "\n");

                        indent();
                        ptr = write_raw_line(ptr, end, bytesPerLine);
                }

                close_brace();
        } else {
                if (type != B_RAW_TYPE) {
                        fprintf(sOutputFile, "#");
                        write_code(type);
                        fprintf(sOutputFile, " ");
                }

                write_field_name(name);
                write_raw_line(ptr, end, bytesPerLine);
        }
}


static void
write_bool(const char *name, const void *data, size_t length)
{
        if (length != sizeof(bool)) {
                write_raw(name, B_BOOL_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "%s", *(bool *)data ? "true" : "false");
        }
}


static void
write_int8(const char *name, const void *data, size_t length)
{
        if (length != sizeof(int8)) {
                write_raw(name, B_INT8_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(int8)%d", *(int8 *)data);
        }
}


static void
write_int16(const char *name, const void *data, size_t length)
{
        if (length != sizeof(int16)) {
                write_raw(name, B_INT16_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(int16)%d", *(int16 *)data);
        }
}


static void
write_int32(const char *name, const void *data, size_t length)
{
        if (length != sizeof(int32)) {
                write_raw(name, B_INT32_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "%" B_PRId32, *(int32 *)data);
        }
}


static void
write_int64(const char *name, const void *data, size_t length)
{
        if (length != sizeof(int64)) {
                write_raw(name, B_INT64_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(int64)%" B_PRId64, *(int64 *)data);
        }
}


static void
write_uint8(const char *name, const void *data, size_t length)
{
        if (length != sizeof(uint8)) {
                write_raw(name, B_UINT8_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(uint8)%u", *(uint8 *)data);
        }
}


static void
write_uint16(const char *name, const void *data, size_t length)
{
        if (length != sizeof(uint16)) {
                write_raw(name, B_UINT16_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(uint16)%u", *(uint16 *)data);
        }
}


static void
write_uint32(const char *name, const void *data, size_t length)
{
        if (length != sizeof(uint32)) {
                write_raw(name, B_UINT32_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(uint32)%" B_PRIu32, *(uint32 *)data);
        }
}


static void
write_uint64(const char *name, const void *data, size_t length)
{
        if (length != sizeof(uint64)) {
                write_raw(name, B_UINT64_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(uint64)%" B_PRIu64, *(uint64 *)data);
        }
}


static void
write_float(const char *name, const void *data, size_t length)
{
        if (length != sizeof(float)) {
                write_raw(name, B_FLOAT_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "%#g", *(float *)data);
        }
}


static void
write_double(const char *name, const void *data, size_t length)
{
        if (length != sizeof(double)) {
                write_raw(name, B_DOUBLE_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(double)%#g", *(double *)data);
        }
}


static void
write_size(const char *name, const void *data, size_t length)
{
        if (length != sizeof(size_t)) {
                write_raw(name, B_SIZE_T_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(size_t)%lu", (unsigned long)*(size_t *)data);
        }
}


static void
write_ssize(const char *name, const void *data, size_t length)
{
        if (length != sizeof(ssize_t)) {
                write_raw(name, B_SSIZE_T_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(ssize_t)%ld", (long)*(ssize_t *)data);
        }
}


static void
write_off(const char *name, const void *data, size_t length)
{
        if (length != sizeof(off_t)) {
                write_raw(name, B_OFF_T_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(off_t)%" B_PRIdOFF, *(off_t *)data);
        }
}


static void
write_time(const char *name, const void *data, size_t length)
{
        if (length != sizeof(time_t)) {
                write_raw(name, B_TIME_TYPE, data, length);
        } else {
                write_field_name(name);
                fprintf(sOutputFile, "(time_t)%ld", (long)*(time_t *)data);
        }
}


static void
write_point(const char *name, const void *data)
{
        ///TODO: using built-in type table

        write_field_name(name);
        float *f = (float *)data;
        fprintf(sOutputFile, "point { %#g, %#g }", f[0], f[1]);
}


static void
write_rect(const char *name, const void *data)
{
        ///TODO: using built-in type table

        write_field_name(name);
        float *f = (float *)data;
        fprintf(sOutputFile, "rect { %#g, %#g, %#g, %#g }", f[0], f[1], f[2], f[3]);
}


static void
write_rgb(const char *name, const void *data)
{
        ///TODO: using built-in type table

        write_field_name(name);
        uint8 *b = (uint8 *)data;

        fprintf(sOutputFile, "rgb_color { 0x%02X, 0x%02X, 0x%02X, 0x%02X }",
                b[0], b[1], b[2], b[3]);
}


static const char *
write_string_line(const char *ptr, const char *end, size_t charsPerLine)
{
        uint32 count = 0;
        bool end_of_item = false;

        fprintf(sOutputFile, "\"");

        while (ptr < end && count < charsPerLine && !end_of_item) {
                char c = *ptr++;

                switch (c) {
                        case '\b': fprintf(sOutputFile, "\\b");  count += 2; break;
                        case '\f': fprintf(sOutputFile, "\\f");  count += 2; break;
                        case '\n': fprintf(sOutputFile, "\\n");  count += 2; break;
                        case '\r': fprintf(sOutputFile, "\\r");  count += 2; break;
                        case '\t': fprintf(sOutputFile, "\\t");  count += 2; break;
                        case '\v': fprintf(sOutputFile, "\\v");  count += 2; break;
                        case '\"': fprintf(sOutputFile, "\\\""); count += 2; break;
                        case '\\': fprintf(sOutputFile, "\\\\"); count += 2; break;

                        case '\0': end_of_item = true; break;

                        default:
                        {
                                if ((uint8)c < 128 && !isprint(c)) {
                                        fprintf(sOutputFile, "\\0x%02X", (uint8)c); count += 5;
                                } else {
                                        fprintf(sOutputFile, "%c", c); ++count;
                                }
                        }
                }
        }

        fprintf(sOutputFile, "\"");

        if (end_of_item && ptr < end)
                fprintf(sOutputFile, ",");

        return ptr;
}


static void
write_string(const char *name, type_code type,
        const void *data, size_t length)
{
        const char *ptr = (const char *)data;
        const char *end = ptr + length;
        size_t charsPerLine = 64;

        // We write an "array" resource if the string has more than 64
        // characters. A string resource may also be comprised of multiple
        // substrings, each terminated by a '\0' char. In that case, we
        // must write an "array" resource as well. Sneaky as we are, we use
        // strlen() to check for that, because it also looks for a '\0'.

        if (length > charsPerLine || strlen(ptr) < length - 1) {
                fprintf(sOutputFile, "#");
                write_code(type);
                fprintf(sOutputFile, " array");

                if (name != NULL) {
                        fprintf(sOutputFile, " ");
                        write_field_name(name);
                        fprintf(sOutputFile, " array");
                }

                open_brace();

                int32 item = 0;
                while (ptr < end) {
                        if (item++ > 0)
                                fprintf(sOutputFile, "\n");

                        indent();
                        ptr = write_string_line(ptr, end, charsPerLine);
                }

                close_brace();
        } else {
                if (type != B_STRING_TYPE) {
                        fprintf(sOutputFile, "#");
                        write_code(type);
                        fprintf(sOutputFile, " ");
                }

                write_field_name(name);
                write_string_line(ptr, end, charsPerLine);
        }
}


static void
write_fields(BMessage &msg)
{
        int32 t = 0;
        int32 item = 0;

#ifdef B_BEOS_VERSION_DANO
        const char *name;
#else
        char *name;
#endif
        type_code type;
        int32 count;
        const void *data;
        size_t length;

        open_brace();

        while (msg.GetInfo(B_ANY_TYPE, t, &name, &type, &count) == B_OK) {
                for (int32 k = 0; k < count; ++k) {
                        if (msg.FindData(name, type, k, &data, (ssize_t*) &length) == B_OK) {
                                if (item++ > 0)
                                        fprintf(sOutputFile, ",\n");

                                indent();
                                write_generic_data(name, type, data, length);
                        }
                }

                ++t;
        }

        close_brace();
}


static void
write_message(const char *name, BMessage &msg, type_code type)
{
        if (type != B_MESSAGE_TYPE) {
                fprintf(sOutputFile, "#");
                write_code(type);
                fprintf(sOutputFile, " ");
        }

        write_field_name(name);

        const char *class_;
        if (msg.FindString("class", &class_) == B_OK) {
                fprintf(sOutputFile, "archive");

                const char *add_on;
                if (msg.FindString("add_on", &add_on) == B_OK) {
                        fprintf(sOutputFile, "(\"%s\"", add_on);
                        if (msg.what != 0) {
                                fprintf(sOutputFile, ", ");
                                write_code(msg.what);
                        }
                        fprintf(sOutputFile, ")");

                        msg.RemoveName("add_on");
                } else if (msg.what != 0) {
                        fprintf(sOutputFile, "(, ");
                        write_code(msg.what);
                        fprintf(sOutputFile, ")");
                }

                fprintf(sOutputFile, " %s", class_);
                msg.RemoveName("class");
        } else if (msg.what == 0) {
                fprintf(sOutputFile, "message");
        } else {
                fprintf(sOutputFile, "message(");
                write_code(msg.what);
                fprintf(sOutputFile, ")");
        }

        if (msg.CountNames(B_ANY_TYPE) > 0)
                write_fields(msg);
}


static void
write_other(const char *name, type_code type,
        const void *data, size_t length)
{
        BMessage msg;
        if (msg.Unflatten((const char *)data) == B_OK)
                write_message(name, msg, type);
        else if (is_string(data, length))
                write_string(name, type, data, length);
        else
                write_raw(name, type, data, length);
}


//      #pragma mark - special types


static void
write_app_signature(const void *data, size_t length)
{
        fprintf(sOutputFile, "resource app_signature ");
        write_string_line((const char *)data, (const char *)data + length, length * 2);
}


static void
write_app_flags(const void *data, size_t length)
{
        fprintf(sOutputFile, "resource app_flags ");

        uint32 flags = *(uint32 *)data;
        switch (flags & B_LAUNCH_MASK) {
                case B_SINGLE_LAUNCH:
                        fputs("B_SINGLE_LAUNCH", sOutputFile);
                        break;
                case B_MULTIPLE_LAUNCH:
                        fputs("B_MULTIPLE_LAUNCH", sOutputFile);
                        break;
                case B_EXCLUSIVE_LAUNCH:
                        fputs("B_EXCLUSIVE_LAUNCH", sOutputFile);
                        break;
        }

        if (flags & B_BACKGROUND_APP)
                fputs(" | B_BACKGROUND_APP", sOutputFile);
        if (flags & B_ARGV_ONLY)
                fputs(" | B_ARGV_ONLY", sOutputFile);
}


static void
write_app_icon(uint32 which, const void *data, size_t length)
{
        int32 lineWidth = 32;
        const char* type = "";
        switch (which) {
                case B_MINI_ICON:
                        type = "mini";
                        lineWidth = 16;
                        break;
                case B_LARGE_ICON:
                        type = "large";
                        break;
                case 'VICN':
                        type = "vector";
                        break;
                case 'PNG ':
                        type = "png";
                        break;
                default:
                        fprintf(stderr, "write_app_icon() called with invalid type!\n");
                        break;
        }
        fprintf(sOutputFile, "resource %s_icon ", type);
        write_raw(NULL, B_RAW_TYPE, data, length, lineWidth);
}


static void
write_app_file_types(const void *data, size_t length)
{
        fputs("resource file_types ", sOutputFile);
        write_other(NULL, B_MESSAGE_TYPE, data, length);
}


static void
write_app_version(const void *data, size_t length)
{
        const version_info *version = (const version_info *)data;
        //const version_info *systemVersion = version + 1;

        fputs("resource app_version", sOutputFile);
        open_brace();

        fprintf(sOutputFile, "\tmajor  = %" B_PRIu32 ",\n"
                "\tmiddle = %" B_PRIu32 ",\n"
                "\tminor  = %" B_PRIu32 ",\n\n", version->major, version->middle,
                version->minor);

        const char *variety = "B_APPV_DEVELOPMENT";
        switch (version->variety) {
                case 1:
                        variety = "B_APPV_ALPHA";
                        break;
                case 2:
                        variety = "B_APPV_BETA";
                        break;
                case 3:
                        variety = "B_APPV_GAMMA";
                        break;
                case 4:
                        variety = "B_APPV_GOLDEN_MASTER";
                        break;
                case 5:
                        variety = "B_APPV_FINAL";
                        break;
        }
        fprintf(sOutputFile, "\tvariety = %s,\n"
                "\tinternal = %" B_PRIu32 ",\n\n", variety, version->internal);

        fprintf(sOutputFile, "\tshort_info = ");
        write_string(NULL, B_STRING_TYPE, version->short_info, strlen(version->short_info));

        fprintf(sOutputFile, ",\n\tlong_info = ");
        write_string(NULL, B_STRING_TYPE, version->long_info, strlen(version->long_info));

        close_brace();
}


//      #pragma mark - file examination


static void
write_generic_data(const char *name, type_code type,
        const void *data, size_t length)
{
        switch (type) {
                case B_BOOL_TYPE:    write_bool(name, data, length);   break;
                case B_INT8_TYPE:    write_int8(name, data, length);   break;
                case B_INT16_TYPE:   write_int16(name, data, length);  break;
                case B_INT32_TYPE:   write_int32(name, data, length);  break;
                case B_INT64_TYPE:   write_int64(name, data, length);  break;
                case B_UINT8_TYPE:   write_uint8(name, data, length);  break;
                case B_UINT16_TYPE:  write_uint16(name, data, length); break;
                case B_UINT32_TYPE:  write_uint32(name, data, length); break;
                case B_UINT64_TYPE:  write_uint64(name, data, length); break;
                case B_FLOAT_TYPE:   write_float(name, data, length);  break;
                case B_DOUBLE_TYPE:  write_double(name, data, length); break;
                case B_SIZE_T_TYPE:  write_size(name, data, length);   break;
                case B_SSIZE_T_TYPE: write_ssize(name, data, length);  break;
                case B_OFF_T_TYPE:   write_off(name, data, length);    break;
                case B_TIME_TYPE:    write_time(name, data, length);   break;

                case B_POINT_TYPE:     write_point(name, data);  break;
                case B_RECT_TYPE:      write_rect(name, data);   break;
                case B_RGB_COLOR_TYPE: write_rgb(name, data);    break;

                case B_MIME_STRING_TYPE:
                case B_STRING_TYPE:
                        write_string(name, type, data, length);
                        break;

                case 'MICN':
                        write_raw(name, type, data, length, 16);
                        break;
                case B_POINTER_TYPE:
                case 'ICON':
                case 'VICN':
                        write_raw(name, type, data, length);
                        break;

                default:
                        write_other(name, type, data, length);
                        break;
        }
}


static void
write_data(int32 id, const char *name, type_code type,
        const void *data, size_t length)
{
        // check for special types

        switch (type) {
                case B_MIME_STRING_TYPE:
                        if (!strcmp(name, "BEOS:APP_SIG")) {
                                write_app_signature(data, length);
                                return;
                        }
                        break;

                case 'VICN':
                        if (!strcmp(name, "BEOS:ICON")) {
                                write_app_icon('VICN', data, length);
                                return;
                        }
                        break;

                case 'PNG ':
                        if (!strcmp(name, "BEOS:ICON")) {
                                write_app_icon('PNG ', data, length);
                                return;
                        }
                        break;

                case 'MICN':
                        if (!strcmp(name, "BEOS:M:STD_ICON")) {
                                write_app_icon(B_MINI_ICON, data, length);
                                return;
                        }
                        break;

                case 'ICON':
                        if (!strcmp(name, "BEOS:L:STD_ICON")) {
                                write_app_icon(B_LARGE_ICON, data, length);
                                return;
                        }
                        break;

                case B_MESSAGE_TYPE:
                        if (!strcmp(name, "BEOS:FILE_TYPES")) {
                                write_app_file_types(data, length);
                                return;
                        }
                        break;

                case 'APPF':
                        if (!strcmp(name, "BEOS:APP_FLAGS") && length == 4) {
                                write_app_flags(data, length);
                                return;
                        }
                        break;

                case 'APPV':
                        if (!strcmp(name, "BEOS:APP_VERSION")
                                && (length == sizeof(version_info)
                                        // length can be twice the size for the old BeOS resource
                                        || length == sizeof(version_info) * 2)) {
                                write_app_version(data, length);
                                return;
                        }
                        break;
        }

        // write generic types

        write_rsrc(type, id, name);
        write_generic_data(NULL, type, data, length);
}


static void
examine_file(char *fileName)
{
        BFile file(fileName, B_READ_ONLY);
        if (file.InitCheck() != B_OK) {
                strcpy(rdef_err_file, fileName);
                rdef_err = RDEF_FILE_NOT_FOUND;
                return;
        }

        BResources res;
        if (res.SetTo(&file) != B_OK) {
                strcpy(rdef_err_file, fileName);
                rdef_err = RDEF_NO_RESOURCES;
                return;
        }

        int32 t = 0;
        type_code type;
        int32 id;
        const char *name;
        size_t length;
        const void *data;

        while (res.GetResourceInfo(t, &type, &id, &name, &length)) {
                sTabs = 0;

                data = res.LoadResource(type, id, NULL);
                if (data != NULL) {
                        fprintf(sOutputFile, "\n");
                        write_data(id, name, type, data, length);
                        fprintf(sOutputFile, ";\n");
                }

                ++t;
        }
}


static status_t
open_output_files(const char *fileName, const char *headerName)
{
        sOutputFile = fopen(fileName, "w");
        if (sOutputFile == NULL) {
                strcpy(rdef_err_msg, strerror(errno));
                strcpy(rdef_err_file, fileName);
                return RDEF_WRITE_ERR;
        }

        if (flags & RDEF_AUTO_NAMES) {
                sHeaderFile = fopen(headerName, "w");
                if (sHeaderFile == NULL) {
                        strcpy(rdef_err_msg, strerror(errno));
                        strcpy(rdef_err_file, headerName);
                        fclose(sOutputFile);
                        return RDEF_WRITE_ERR;
                }

                fprintf(sOutputFile, "\n#include \"%s\"\n", headerName);

                if (sBraceOnNextLine)
                        fprintf(sHeaderFile, "\nenum\n{\n");
                else
                        fprintf(sHeaderFile, "\nenum {\n");
        }

        return B_OK;
}


static void
close_output_files(const char *fileName, const char *headerName)
{
        if (flags & RDEF_AUTO_NAMES) {
                fprintf(sHeaderFile, "};\n");
                fclose(sHeaderFile);

                if (rdef_err != B_OK)
                        unlink(headerName);
        }

        fclose(sOutputFile);

        if (rdef_err != B_OK)
                unlink(fileName);
}


status_t
rdef_decompile(const char *fileName)
{
        clear_error();

        if (fileName == NULL || fileName[0] == '\0') {
                rdef_err = B_BAD_VALUE;
                return rdef_err;
        }

        char headerName[B_PATH_NAME_LENGTH + 1];
        if ((flags & RDEF_AUTO_NAMES) != 0)
                sprintf(headerName, "%s.h", fileName);

        rdef_err = open_output_files(fileName, headerName);
        if (rdef_err != B_OK)
                return rdef_err;

        for (ptr_iter_t i = input_files.begin();
                        (i != input_files.end()) && (rdef_err == B_OK); ++i) {
                examine_file((char *)*i);
        }

        close_output_files(fileName, headerName);
        return rdef_err;
}