diff options
Diffstat (limited to 'bin2c.c')
| -rw-r--r-- | bin2c.c | 615 |
1 files changed, 615 insertions, 0 deletions
@@ -0,0 +1,615 @@ + +#include <stdlib.h> +#include <stdio.h> +#include <stdarg.h> +#include <errno.h> +#include <string.h> +#include <sys/stat.h> +#include <assert.h> + +/* Version information */ +const char *versionInfo = + "bin2c version 1.0 by Fatih Aygun\n" + "\n" + "Visit sourceforge.net/projects/bin2c to for new versions.\n" + "This program is public domain, do whatever you want with it.\n" +; + +/* Command line help */ +const char *commandLineHelp = + "Usage: bin2c [OPTION...] FILE [FILE...]\n" + "bin2c creates a C soures and headers from binary files.\n" + "\n" + "Examples:\n" + " bin2c -o foo.h bar.bin # Create 'foo.h' from the contents of\n" + " 'bar.bin'\n" + " bin2c -o foo.h file1 file2 # Create 'foo.h' from the contents of 'file1'\n" + " and 'file2'\n" + " bin2c -d foo.h -o foo.c bar.bin # Create 'foo.c' and 'foo.h' from the\n" + " contents of 'bar.bin'\n" + "\n" + "Options:\n" + " -d, --header <file name> Name a header file (A header file will not be\n" + " created unless explicitly named)\n" + " -h, --help Print this command line help and exit immediately\n" + " -o, --output <file name> Name an output file\n" + " -m, --macro Create the size definition as a macro instead of\n" + " a const\n" + " -n, --name <symbol name> Name the symbol to be defined\n" + " -v, --version Print version information and exit immediately\n" + "\n" + "Visit sourceforge.net/projects/bin2c to for new versions.\n" + "This program is public domain, do whatever you want with it.\n" + ; + +/* Output formatting macros */ +#define bytesPerLine 16 +#define indentString " " +#define outputFormatBase "0x%.2X" +#define outputFormat outputFormatBase", " +#define outputFormatEOL outputFormatBase",\n" +#define outputFormatEOF outputFormatBase"\n" +#define sizeDefinition "const long int bin2c_%s_size = %d;\n" +#define sizeMacroDefinition "#define bin2c_%s_size %d\n" +#define typeName "const unsigned char" + +/* Define bool */ +#define bool int +#define false 0 +#define true 1 + +/* Global variables */ +FILE *outputFile=0; /* Current output file stream */ +const char *outputFileName=0; /* Current output file name */ +FILE *headerFile=0; /* Current header file */ +const char *headerFileName=0; /* Current header file name */ +FILE *tmpFuncFile=0; /* File to write final function that search for files */ +const char *tmpFuncFileName=0; /* Current tmpFunc file name */ +char *symbolName=0; /* Current symbol name */ +char *headerSymbol=0; /* Symbol for multiple inclusion protection */ +bool createMacro = false; /* Should we create a define instead of a const? */ + +/* Error messages */ +const char* cantOpen = "Can't open file '%s'"; +const char* cantClose = "Can't close file '%s'"; +const char* cantRemove = "Can't remove file '%s'"; +const char* cantWrite = "Can't write to file '%s'"; +const char* noOutputFilesAreNamed = "No output files are named"; +const char* noHeaderFilesAreNamed = "No header files are named"; +const char* cantMalloc = "Can't allocate memory for '%s'"; +const char* cantSeek = "Can't seek in the file '%s'"; +const char* cantDetermine = "Can't determine the file size of '%s'"; +const char* cantRead = "Can't read from file %s"; +const char* unknownOption = "Unknown option '%s'"; +const char* tryHelp = "Try 'bin2c --help' for more information.\n"; +const char* noSymbolName = "No symbol name is given"; +const char* notValidId = "'%s' is not a valid identifier"; +const char* symbolNameGiven = "Symbol name is given twice"; + +/* Print a formatted error message */ +static void vprintfError(const char *format, va_list args) +{ + fprintf(stderr, "bin2c: "); + vfprintf(stderr, format, args); + if (errno) { + fprintf(stderr, ": "); + perror(""); + errno = 0; + } else { + fprintf(stderr, "\n"); + } +} + +static void printfError(const char *format, ...) +{ + va_list args; + + va_start(args, format); + vprintfError(format, args); + va_end(args); +} + +/* Panic */ +static void panic() +{ + /* Close and remove the output file if it's open */ + if (outputFile) { + if (fclose(outputFile)) { + printfError(cantClose, outputFileName); + } + + if (remove(outputFileName)) { + printfError(cantRemove, outputFileName); + } + } + + /* Close and remove the header file if it's open */ + if (headerFile) { + if (fclose(headerFile)) { + printfError(cantClose, headerFileName); + } + + if (remove(headerFileName)) { + printfError(cantRemove, headerFileName); + } + } + + /* Close and remove the header file if it's open */ + if (tmpFuncFile) { + if (fclose(tmpFuncFile)) { + printfError(cantClose, tmpFuncFileName); + } + + if (remove(tmpFuncFileName)) { + printfError(cantRemove, tmpFuncFileName); + } + } + + /* Exit with an error code */ + exit(EXIT_FAILURE); +} + +/* Check a contidion and panic if it's false */ +static void check(bool condition, const char *format, ...) +{ + va_list args; + + if (!condition) { + va_start(args, format); + vprintfError(format, args); + va_end(args); + panic(); + } +} + +/* Write a formatted string to the output file and check for errors */ +static void output(const char *format, ...) +{ + va_list args; + + /* Try to write to the file */ + va_start(args, format); + vfprintf(outputFile, format, args); + va_end(args); + + /* Check for errors */ + check(!ferror(outputFile), cantWrite, outputFileName); +} + +/* Write a formatted string to the header file and check for errors */ +static void header(const char *format, ...) +{ + va_list args; + + /* Try to write to the file */ + va_start(args, format); + vfprintf(headerFile, format, args); + va_end(args); + + /* Check for errors */ + check(!ferror(headerFile), cantWrite, headerFileName); +} + +/* Write a formatted string to the tmp file and check for errors */ +static void tmpFunc(const char *format, ...) +{ + va_list args; + + /* Try to write to the file */ + va_start(args, format); + vfprintf(tmpFuncFile, format, args); + va_end(args); + + /* Check for errors */ + check(!ferror(tmpFuncFile), cantWrite, tmpFuncFileName); +} + +/* Allocate a valid C identifier from a file name */ +static char *fileNameToSymbol(const char *fileName) +{ + char *name; + int i; + + name = malloc(strlen(fileName) + 1); + check(name != 0, cantMalloc, "the symbol name"); + + /* Copy the file name to symbolName */ + strcpy(name, fileName); + + /* Replace every non alphanumerical character with '_' */ + for (i = 0; name[i]; ++i) { + if (!((name[i] >= 'a' && name[i] <= 'z') || + (name[i] >= 'A' && name[i] <= 'Z') || + (name[i] >= '0' && name[i] <= '9'))) { + name[i] = '_'; + } + } + + /* Replace the first character with '_' if it's a digit */ + if (name[0] >= '0' && name[0] <= '9') { + name[0] = '_'; + } + + return name; +} + + int isdir(const char * path) +{ + int bOK = 0; + #ifndef _MSC_VER + struct stat buf; + if (path == NULL) return 0; + if (stat(path, &buf) == 0 && S_ISDIR(buf.st_mode)) bOK=1; + #else + wchar_t *wcpath = to_wide_string((char*)path); + if (wcpath == NULL) return FALSE; + bOK = isdirW(wcpath); + FREE(wcpath); + #endif + return bOK; + } + +/* Process an input file */ +static int processFile(const char *fileName, long int from, long int to) +{ + bool symbolNameAllocated = false; /* Did we allocate the symbolName? */ + long int i, j; /* Indexes for various purposes */ + FILE *inputFile; /* Input file stream */ + int byte; /* Byte read from the input */ + long int fsize=0; + + if(isdir(fileName)) return 0; + + /* Be sure that the output file is open */ + check(outputFile != 0, noOutputFilesAreNamed); + + /* Write the comment */ + output("\n/* Contents of file %s */\n", fileName); + if (headerFile) { + header("\n/* Contents of file %s */\n", fileName); + } + + /* Make up a suitable symbolName if we don't have one */ + if (!symbolName) { + symbolName = fileNameToSymbol(fileName); + symbolNameAllocated = true; + } + + /* Open the input file */ + inputFile = fopen(fileName, "rb"); + check(inputFile != 0, cantOpen, fileName); + + /* If to == -1, set it to the last byte of the file */ + if (to == -1) { + check(!fseek(inputFile, 0, SEEK_END), cantSeek, fileName); + to = ftell(inputFile); + check(to >= 0, cantDetermine, fileName); + --to; + } + + assert(from <= to - 1); + + /* Position the file to "from" */ + check(!fseek(inputFile, from, SEEK_SET), cantSeek, fileName); + + fsize = to - from + 1; + + /* Output the size definition */ + if (headerFile) { + if (createMacro) { + header(sizeMacroDefinition, symbolName, fsize); + } else { + header("extern "sizeDefinition, symbolName, fsize); + output(sizeDefinition, symbolName, fsize); + } + } else { + if (createMacro) { + output(sizeMacroDefinition, symbolName, fsize); + } else { + output(sizeDefinition, symbolName, fsize); + } + } + + if (tmpFuncFile) { + tmpFunc("\t{\"/_attach_/%s\", bin2c_%s, %d},\n", fileName, symbolName, fsize); + } + /* Output the definition */ + output("%s bin2c_%s[%d] = {\n", typeName, symbolName, fsize); + if (headerFile) { + header("extern %s *bin2c_%s;\n", typeName, symbolName, fsize); + } + + /* Output the contents */ + j = 1; + for (i = from; i <= to; ++i) { + /* Read a byte from the input file */ + byte = fgetc(inputFile); + check(byte != EOF, cantRead, fileName); + + /* Output the indentation if it's the first byte of a line */ + if (j == 1) { + output(indentString); + } + + /* Output the actual byte */ + if (i == to) { + /* Output the last byte */ + output(outputFormatEOF, byte); + } else if (j == bytesPerLine) { + /* Output the last byte of a line */ + output(outputFormatEOL, byte); + } else { + /* Output a normal byte */ + output(outputFormat, byte); + } + + /* Next byte */ + ++j; + if (j > bytesPerLine) { + j = 1; + } + } + + /* Output the end of definition */ + output("};\n"); + + /* Free the symbol name if it was allocated by us */ + if (symbolNameAllocated) { + free(symbolName); + } + + /* Clear the symbol name */ + symbolName = 0; + return 1; +} + +/* Unknown option error */ +static void handleUnknownOption(const char *s) +{ + printfError(unknownOption, s); + fprintf(stderr, tryHelp); + panic(); +} + +/* Open an output file */ +static void openOutputFile(const char *fileName) +{ + /* Be sure that a file name is given */ + if (!fileName) { + printfError(noOutputFilesAreNamed); + fprintf(stderr, tryHelp); + panic(); + } + + /* Close previous output file if any */ + if (outputFile) { + check(!fclose(outputFile), cantClose, outputFileName); + } + + /* Open the new output file */ + outputFile = fopen(fileName, "w"); + check(outputFile != 0, cantOpen, outputFileName); + outputFileName = fileName; + + output("/* Generated by bin2c, do not edit manually */\n"); +} + +/* Open a header file */ +static void openHeaderFile(const char *fileName) +{ + /* Be sure that a file name is given */ + if (!fileName) { + printfError(noHeaderFilesAreNamed); + fprintf(stderr, tryHelp); + panic(); + } + + /* Close previous header file if any */ + if (headerFile) { + header("\n#endif /* __%s_included */\n", headerSymbol); + free(headerSymbol); + headerSymbol = 0; + check(!fclose(headerFile), cantClose, headerFileName); + } + + /* Open the new header file */ + headerFile = fopen(fileName, "w"); + check(headerFile != 0, cantOpen, headerFileName); + headerFileName = fileName; + headerSymbol = fileNameToSymbol(fileName); + + header("/* Generated by bin2c, do not edit manually */\n"); + header("#ifndef __%s_included\n", headerSymbol); + header("#define __%s_included\n", headerSymbol); +} + + typedef void writeFileFunc(const char *format, ...); + + void writeAttchmentStruct(writeFileFunc *writeFunc){ + (*writeFunc)("\ntypedef struct {\n"); + (*writeFunc)("\tconst char *file_name;\n"); + (*writeFunc)("\tconst unsigned char *sym_name;\n"); + (*writeFunc)("\tlong size;\n"); + (*writeFunc)("} bin2c_filesAttached_st;\n"); +} + +/* Open a header file */ +static void openFuncFile(const char *fileName) +{ + static char fnBuf[1024]; + /* Be sure that a file name is given */ + if (!fileName) { + printfError(noHeaderFilesAreNamed); + fprintf(stderr, tryHelp); + panic(); + } + + /* Close previous header file if any */ + if (tmpFuncFile) { + tmpFunc("\n};\n"); + check(!fclose(tmpFuncFile), cantClose, tmpFuncFileName); + } + + snprintf(fnBuf, sizeof(fnBuf), "%s.tmp", fileName); + + /* Open the new header file */ + tmpFuncFile = fopen(fnBuf, "w"); + check(tmpFuncFile != 0, cantOpen, fnBuf); + tmpFuncFileName = fnBuf; + + tmpFunc("\n/* Generated by bin2c, do not edit manually */\n"); + writeAttchmentStruct(&tmpFunc); + tmpFunc("const bin2c_filesAttached_st bin2c_filesAttached[] = {\n"); +} + +/* Set the symbol name for next file */ +static void setSymbolName(char *name) +{ + int i; + + if (symbolName) { + printfError(symbolNameGiven); + fprintf(stderr, tryHelp); + panic(); + } + + /* Be sure that a symbol name is given */ + if (!name) { + printfError(noSymbolName); + fprintf(stderr, tryHelp); + panic(); + } + + /* Check if the symbol is a valid C identifier */ + check((name[0] >= 'a' && name[0] <='z') || + (name[0] >= 'A' && name[0] <='Z') || + (name[0] == '_'), notValidId, name); + + for (i = 1; name[i]; ++i) { + check((name[i] >= 'a' && name[i] <='z') || + (name[i] >= 'A' && name[i] <='Z') || + (name[i] >= '0' && name[i] <='9') || + (name[i] == '_'), notValidId, name); + } + + /* Set the symbol name */ + symbolName = name; + } + + void concatenate(const char *dest, const char *src){ + int i,ch; + FILE *fpdest=fopen(dest,"a"); + FILE *fpsrc=fopen(src,"r"); + while((ch=getc(fpsrc))!=EOF) putc(ch,fpdest); + } + +/* Main function */ +int main(int argc, char **argv) +{ + int i; /* Index to process commandline arguments */ + int ipf = 0; /*total files processed*/ + + /* Scan for a -h or --help option */ + for (i = 1; i < argc; ++i) { + if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) { + /* Print command line arguments help and exit immediately */ + printf("%s", commandLineHelp); + return EXIT_SUCCESS; + } + } + + /* Scan for a -v or --version option */ + for (i = 1; i < argc; ++i) { + if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) { + /* Print version information and exit immediately */ + printf("%s", versionInfo); + return EXIT_SUCCESS; + } + } + + /* Process command line arguments */ + for (i = 1; i < argc; ++i) { + /* Check if it's an option or file name */ + if (argv[i][0] == '-') { + /* Process the option */ + switch (argv[i][1]) { + case '-': + /* Long options */ + if (!strcmp(argv[i], "--output")) { + /* Name an output file */ + openOutputFile(argv[i+1]); + openFuncFile(argv[i+1]); + ++i; + } else if (!strcmp(argv[i], "--header")) { + /* Name a header file */ + openHeaderFile(argv[i+1]); + ++i; + } else if (!strcmp(argv[i], "--macro")) { + /* Create a macro for the size definition */ + createMacro = true; + } else if (!strcmp(argv[i], "--name")) { + /* Name the symbol */ + setSymbolName(argv[i+1]); + ++i; + } else { + /* Unknown option */ + handleUnknownOption(argv[i]); + } + break; + case 'o': + /* Name an output file */ + openOutputFile(argv[i+1]); + openFuncFile(argv[i+1]); + ++i; + break; + case 'd': + /* Name a header file */ + openHeaderFile(argv[i+1]); + ++i; + break; + case 'm': + /* Create a macro for the size definition */ + createMacro = true; + break; + case 'n': + /* Name the symbol */ + setSymbolName(argv[i+1]); + ++i; + break; + default: + /* Unknown option */ + handleUnknownOption(argv[i]); + } + } else { + /* Process the file */ + if(processFile(argv[i], 0, -1)) ipf++; + } + } + + /* Close any remaining output files */ + if (headerFile) { + writeAttchmentStruct(&header); + header("extern const bin2c_filesAttached_st bin2c_filesAttached[%d];\n", ipf); + + header("\n#endif /* __%s_included */\n", headerSymbol); + free(headerSymbol); + headerSymbol = 0; + check(!fclose(headerFile), cantClose, headerFileName); + } + + if (tmpFuncFile) { + tmpFunc("};\n"); + check(!fclose(tmpFuncFile), cantClose, tmpFuncFileName); + } + + if (outputFile) { + check(!fclose(outputFile), cantClose, outputFileName); + } + + if (tmpFuncFile && outputFile) { + concatenate(outputFileName, tmpFuncFileName); + remove(tmpFuncFileName); + } + + return EXIT_SUCCESS; +} |