root/trunk/bintod/bintod.d

/*
 *  Copyright (C) 2006/2007 Frank Benoit <benoit@tionex.de>
 *
 *  This software is provided 'as-is', without any express or implied
 *  warranty.  In no event will the authors be held liable for any damages
 *  arising from the use of this software.
 *
 *  Permission is granted to anyone to use this software for any purpose,
 *  including commercial applications, and to alter it and redistribute it
 *  freely, subject to the following restrictions:
 *
 *  1. The origin of this software must not be misrepresented; you must not
 *     claim that you wrote the original software. If you use this software
 *     in a product, an acknowledgment in the product documentation would be
 *     appreciated but is not required.
 *  2. Altered source versions must be plainly marked as such, and must not be
 *     misrepresented as being the original software.
 *  3. This notice may not be removed or altered from any source distribution.
 */
module bintod;

import             tango.io.Stdout;
import             tango.io.FileConduit;
import             tango.io.Buffer;
import             tango.io.Print;
import             tango.text.convert.Layout;
import             tango.text.convert.Utf;
import             tango.text.convert.UnicodeBom;
import             tango.text.Util : replace, containsPattern;
import             tango.text.stream.LineIterator;

import             mango.xml.sax.Exceptions;
import             mango.xml.sax.DefaultSAXHandler;
import             mango.xml.sax.model.ISAXParser;
import             mango.xml.sax.parser.teqXML;

public Layout!(char) Layouter;

static this(){
    Layouter  = new Layout!(char);
}

public bool isDigit( dchar c ){
    return ( c >= '0' && c <= '9' );
}

public bool isAlpha( dchar c ){
    return ( c >= 'a' && c <= 'z' ) || ( c >= 'A' && c <= 'Z' );
}

public bool isAlphaNumeric( dchar c ){
    return isAlpha(c) || isDigit(c);
}
void usage() {
    Stdout.formatln("usage: configfile.xml");
}

class ResourceData {
    char[]       mFile;
    char[]       mId;
    char[]       mVarName;
    char[]       mVersion;
}

class Config {
    char[]         mTargetFile;
    char[]         mTargetModule;
    ResourceData[] mResources;
}


const char[] idResource       = "resource";
const char[]       idPath     = "path";
const char[]       idId       = "id";
const char[]       idVersion  = "version";
const char[]       idVariable = "variable";

const char[]       idTarget = "target";
const char[]       idFile   = "file";
const char[]       idModule = "module";

Config parserConfig(char[] aConfigPath) {
    Config config;
    FileConduit conduit = new FileConduit(aConfigPath);

    auto parser = new XMLReader!(char)();
    parser.parse( conduit, new class DefaultSAXHandler!(char){
            char[][char[]] attribs;
            void startDocument() {
            }
            void endDocument() {
            }
            void startElement(char[] name) {
                attribs = null;
            }
            void addAttribute(char[] key, char[] value) {
                attribs[key.dup] = value.dup;
            }
            void endElement(char[] name) {
                if (name == idTarget) {
                    config               = new Config;
                    config.mTargetFile   = attribs[idFile];
                    config.mTargetModule = attribs[idModule];
                }
                else if (name == idResource) {
                    ResourceData res = new ResourceData;
                    res.mFile    = attribs[idPath];
                    res.mId      = attribs[idId];
                    res.mVarName = attribs[idVariable];
                    if (idVersion in attribs) {
                        res.mVersion = attribs[idVersion];
                    }
                    else {
                        res.mVersion = "all";
                    }
                    config.mResources ~= res;
                }
            }
            } );

    conduit.close();
    return(config);
}

int main(char[][] args) {
    if (args.length != 2) {
        usage();
        return(1);
    }
    Config      config  = parserConfig(args[1]);
    auto        config_src = new FileConduit(args[1], FileConduit.ReadExisting );
    auto        cfgIter = new LineIterator!(char) ( config_src );

    FileConduit file = new FileConduit(config.mTargetFile, FileConduit.ReadWriteCreate);
    file.truncate();
    auto        mWriter = new Print!(char) (Layouter, new Buffer(file));

    mWriter.formatln("//");
    mWriter.formatln("// This file was generated with bintod");
    mWriter.formatln("//");
    mWriter.formatln("// The content of the config was:"c);
    while (cfgIter.next) {
        mWriter.format("//:");
        mWriter.formatln(cfgIter.get);
    }
    config_src.close();
    mWriter.formatln("module {0};", config.mTargetModule);
    mWriter.formatln("");
    mWriter.formatln("");

    // Write id to variable mapper
    mWriter.formatln("extern(C) ubyte[] resources_getDataById( char[] aId ){{");
    foreach (ResourceData res; config.mResources) {
        mWriter.formatln("    version( {0} ){{", res.mVersion);
        mWriter.formatln("        if( aId == \"{0}\" ) return {1};", res.mId, res.mVarName);
        mWriter.formatln("    }");
    }
    mWriter.formatln("    return null;");
    mWriter.formatln("}");
    mWriter.formatln("");

    // Write the data
    foreach (ResourceData res; config.mResources) {
        mWriter.formatln("version( {0} ){{", res.mVersion);

        version( Windows ){
            char[] fn = replace( res.mFile, '/', '\\' );
        }
        else version( linux ){
            char[] fn = replace( res.mFile, '\\', '/' );
        }
        auto path = new FilePath( fn );
        if( path.exists() ){
            Stdout.formatln( "processing file {}", fn );
        }
        else{
            Stdout.formatln( "BINTOD Error: file {} does not exist.", fn );
        }
        FileConduit dataFc = new FileConduit( fn, FileConduit.ReadExisting );
        ubyte[]     data   = new ubyte[] (dataFc.length);
        dataFc.read(data);
        dataFc.close();
        char[]      showLine;
        const       LINE_ITEMCOUNT = 16;
        uint        lastIdx;
        if( data.length == 0 ){
            mWriter.formatln("    ubyte[] {0};", res.mVarName);
        }
        else{
            mWriter.formatln("    ubyte[] {0} = [ cast(ubyte)", res.mVarName);
            foreach (uint idx, ubyte d; data) {
                lastIdx = idx;
                if ((idx % LINE_ITEMCOUNT) == 0) {
                    mWriter("        ");
                }
                mWriter.format("0x{0:X2}, ", d);
                if (isAlphaNumeric(d) || .containsPattern(" []{};:'\"~`!@#$%^&*()_+=-/?.>,<\\|", [cast(char)d])) {
                    showLine ~= d;
                }
                else {
                    switch (d) {
                    case '\n':
                        showLine ~= "\u00b6";
                        break;

                    case '\t':
                        showLine ~= "\u00bb";
                        break;

                    default:
                        showLine ~= '.';
                        break;
                    }
                }
                if ((idx % LINE_ITEMCOUNT) == LINE_ITEMCOUNT - 1) {
                    mWriter.format(" // [0x{:X6}] {}", idx - (LINE_ITEMCOUNT - 1), showLine);
                    showLine = null;
                    mWriter.newline();
                }
            }
            mWriter.format("];");
            bool        printLastShowLine = false;
            bool        firstFill         = true;
            while ((lastIdx % LINE_ITEMCOUNT) != LINE_ITEMCOUNT - 1) {
                if (!firstFill) {
                    mWriter(" ");
                }
                mWriter("     ");
                firstFill = false;
                lastIdx++;
                printLastShowLine = true;
            }
            if (printLastShowLine) {
                mWriter.format("// [0x{:X6}] {}", lastIdx - (LINE_ITEMCOUNT - 1), showLine);
                mWriter.newline();
            }
        }
        mWriter.formatln("}"c);
        mWriter.formatln(""c);
        mWriter.formatln(""c);
    }
    mWriter.flush;
    return(0);
}