/*
 *  ======== package/cfg/wolfsslTest_pem4f.cfg ========
 *  This generated configuration script runs the user's configuration script
 *  the context of a specific target and platform in order to generate
 *  all the files necessary to create an executable; e.g., linker command
 *  files, static C/C++ data structures, etc.
 */

/*
 *  ======== _applyChanges ========
 *  Changes that bring the build target to the state at the end of the build
 *  model
 */
function _applyChanges(obj, chgObj) {
    var wasSealed = false;
    if (obj.$sealed) {
        wasSealed = true;
        obj.$unseal();
    }
    for (var prop in chgObj) {
        if (typeof obj[prop] == 'object' && obj[prop] != undefined) {
            if ("$category" in obj[prop] && obj[prop].$category == "Vector") {
               obj[prop].length = chgObj[prop].length;
               for (var i = 0; i < chgObj[prop].length; i++) {
                   if (obj[prop].length < i + 1) {
                       obj[prop].length++;
                   }
                   obj[prop][i] = chgObj[prop][i];
               }
            }
            else {
        	_applyChanges(obj[prop], chgObj[prop]);
            }
	}
	else {
            obj[prop] = chgObj[prop];
	}
    }
    if (wasSealed) {
        obj.$seal();
    }
}

/*
 *  ======== _runescape ========
 *  Recursive unescape to decode serialized strings
 */
function _runescape(obj) {
    for (var i in obj) {
	if (obj[i] != null) {
	    if (typeof obj[i] == 'string') {
		obj[i] = unescape(obj[i]);
	    }
	    else if (typeof obj[i] == 'object') {
		_runescape(obj[i]);
	    }
	}
    }
}

/*
 *  ======== _getPlatCfg ========
 */
function _getPlatCfg() {
    var tmp = {};
    _runescape(tmp);
    return (tmp);
}
/*
 *  ======== _cfginit ========
 */
function _cfginit() {
    xdc.loadPackage('xdc.services.intern.cmd');
    var prog = xdc.om['xdc.cfg.Program'];

    /* initialize prog attrs from build model */
    var build = {
        profile: "release",
        cfgScript: "C%3A/Users/khimes/workspace_v6_0/wolfsslTest/wolfsslTest.cfg",
        cfgHome: "xconfig_wolfsslTest",
        cfgArgs: "null",
        cfgArgsEncoded: true,
        releases: {
            0: {
                name: "xconfig_wolfsslTest",
                attrs: {
                    prefix: "",
                    label: "default"
                },
                otherFiles: {},
                excludeDirs: {}
            }
        },
        prelink: false
    };
    _runescape(build);
    build.cfgArgs = null;
    build.target = xdc.module("ti.targets.arm.elf.M4F");
    var targChange = {
        platforms: [
            "ti.platforms.stellaris%3ALM4FSXLH5BB%3A1"
        ],
        version: "ti.targets.arm.elf.M4F%7B1%2C0%2C5.1%2C6",
        extensions: {
            ".sem4fe": {
                suf: ".sem4fe",
                typ: "asm"
            },
            ".sem4f": {
                suf: ".sem4f",
                typ: "asm"
            },
            ".sv7M4": {
                suf: ".sv7M4",
                typ: "asm"
            },
            ".sv7M": {
                suf: ".sv7M",
                typ: "asm"
            }
        },
        rootDir: "c%3A/ti/ccsv6/tools/compiler/arm_5.1.6",
        rawVersion: "5.1.6"
    };
    _runescape(targChange);
    _applyChanges(build.target, targChange);

    prog.build = build;

    prog.name = "wolfsslTest.xem4f";
    prog.cfgBase = "package/cfg/wolfsslTest_pem4f";

    prog.endian = prog.build.target.model.endian;
    prog.codeModel = prog.build.target.model.codeModel;

    /* use the platform package's Platform module */
    var Platform = xdc.useModule("ti.platforms.tiva.Platform");
    var platParams = _getPlatCfg();
    var invalidParams = [];
    for (var prop in platParams) {
        if (!(prop in Platform.PARAMS)) {
            delete platParams[prop];
            invalidParams.push(prop);
        }
    }
    prog.platformName = "ti.platforms.tiva:TM4C1294NCPDT";
    prog.platform = Platform.create("TM4C1294NCPDT", platParams);
    for (var i = 0; i < invalidParams.length; i++) {
        Platform.$logWarning("The parameter '" + invalidParams[i] + "' is " +
            "passed to this platform instance through Build.platformTable, " +
            "but the instance does not have a configuration parameter with " +
            "that name.", prog.platform, "TM4C1294NCPDT");
    }

    /* record the executable's package name */
    prog.buildPackage = "xconfig_wolfsslTest";

    /* record build-model information required during config generation */
    prog.$$bind("$$isasm", 0);
    prog.$$bind("$$isrom", 0);
    prog.$$bind("$$gentab", [
    ]);

    /* bind prog to an appropriate execution context */
    prog.cpu = prog.platform.getExeContext(prog);

    /* import the target's run-time support pkg */
    xdc.loadPackage("ti.targets.arm.rtsarm");
}

/* function to import the cfg script's package */
function _userscript(script) {
    var home;
    var spath;
    home = xdc.loadPackage("xconfig_wolfsslTest");

    xdc.om.$$bind('$homepkg', home);

    var cfgScript = "C:/Users/khimes/workspace_v6_0/wolfsslTest/wolfsslTest.cfg";
    if (!script) {
        utils.loadCapsule(cfgScript, false, spath);
    }
    else {
        /* set up the same environment that loadCapsule would */
        var $saveCsd = utils.csd;
        var $cfgFile = utils.findFile(cfgScript, spath);
        var cname = cfgScript;
        if ($cfgFile) {
            $cfgFile = java.io.File($cfgFile);
            utils.csd = $cfgFile.getParentFile().getCanonicalPath();
            cname = "" + $cfgFile.getCanonicalPath();
        }

        /* create the capsule object */
        var cap = {
            prototype:  utils.global,
            $path:      cname,
            $private:   {path: cname},
            $capsule:   undefined,      /* set to cap below */
        };

        /* 'this.$capsule' is always cap object */
        cap.$capsule = cap;

        /* save the capsule object */
        utils.$$capmap[cname] = cap;

        try {
            var cx =
                Packages.org.mozilla.javascript.Context.getCurrentContext();
            var rdr = new
                java.io.BufferedReader(new java.io.StringReader(script));
            Packages.config.Shell.evaluateLoad(cx, cap, rdr, cname, 1);
        }
        finally {
            rdr.close();
            utils.csd = $saveCsd;
        }
    }
}

function _postinit() {
    var cout = null;

    var Program = xdc.om['xdc.cfg.Program'];
    /* get the exec command for this executable */
    if (Program.execCmd == null) {
        Program.execCmd = Program.platform.getExecCmd(Program,
            xdc.om["ti.platforms.tiva"].packageBase);
    }
    cout = "define EXEC." + Program.name + '\n\n';
    cout += Program.execCmd;
    cout += "\nendef\n\n";

    /* if SourceDir generates a makefile, we need to run it */
    _genSourceDirMak("package/cfg/wolfsslTest_pem4f", "wolfsslTest.pem4f");

    utils.genDep("package/cfg/wolfsslTest_pem4f", "xconfig_wolfsslTest", utils.loadedFiles, cout, null);
}

function _genSourceDirMak(cfgBase, cfgName)
{
    var SourceDir = xdc.om['xdc.cfg.SourceDir'];

    if (SourceDir && SourceDir.$instances.length > 0) {
        /* construct rule to run SourceDir generated makefile */
        var make = "\t$(MAKE) -f "
            + SourceDir.outputDir + "/" + SourceDir.makefileName;

        /* this file is included by package.mak (if it exists) */
        var file = new java.io.File(cfgBase + ".cfg.mak");
        file["delete"]();
        var out = new java.io.BufferedWriter(new java.io.FileWriter(file));

        /* add rules to run SourceDir generated makefile */
        out.write("# invoke SourceDir generated makefile for " + cfgName
            + "\n" + cfgName + ": .libraries," + cfgName
            + "\n.libraries," + cfgName + ": " + cfgBase + ".xdl\n"
            + make + "\n\n"
            + "clean::\n" + make + " clean\n\n"
        );
        out.close();
        out = null;
    }
}
