/*
 *  ======== package/cfg/EVM_C6674_configuration_pe66.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/git/phoenix_hello/C6674_EvmPlat/EVM_C6674_configuration.cfg",
        cfgHome: "xconfig_EVM_C6674_configuration",
        cfgArgs: "null",
        cfgArgsEncoded: true,
        releases: {
            0: {
                name: "xconfig_EVM_C6674_configuration",
                attrs: {
                    prefix: "",
                    label: "default"
                },
                otherFiles: {},
                excludeDirs: {}
            }
        },
        prelink: false
    };
    _runescape(build);
    build.cfgArgs = null;
    build.target = xdc.module("ti.targets.elf.C66");
    var targChange = {
        platforms: [
            "ti.platforms.simTCI6616"
        ],
        version: "ti.targets.elf.C66%7B1%2C0%2C7.4%2C21",
        extensions: {
            ".se66": {
                suf: ".se66",
                typ: "asm"
            },
            ".s66": {
                suf: ".s66",
                typ: "asm"
            },
            ".s674": {
                suf: ".s674",
                typ: "asm"
            },
            ".s64P": {
                suf: ".s64P",
                typ: "asm"
            },
            ".s64": {
                suf: ".s64",
                typ: "asm"
            },
            ".s62": {
                suf: ".s62",
                typ: "asm"
            }
        },
        rootDir: "C%3A/ti/c6000_7.4.21",
        rawVersion: "7.4.21"
    };
    _runescape(targChange);
    _applyChanges(build.target, targChange);

    prog.build = build;

    prog.name = "EVM_C6674_configuration.xe66";
    prog.cfgBase = "package/cfg/EVM_C6674_configuration_pe66";

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

    /* use the platform package's Platform module */
    var Platform = xdc.useModule("EVM_C6678.Platform");
    var platParams = _getPlatCfg();
    var invalidParams = [];
    for (var prop in platParams) {
        if (!(prop in Platform.PARAMS)) {
            delete platParams[prop];
            invalidParams.push(prop);
        }
    }
    prog.platformName = "EVM_C6678";
    prog.platform = Platform.create("", 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, "");
    }

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

    /* 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.rts6000");
}

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

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

    var cfgScript = "C:/git/phoenix_hello/C6674_EvmPlat/EVM_C6674_configuration.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["EVM_C6678"].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/EVM_C6674_configuration_pe66", "EVM_C6674_configuration.pe66");

    utils.genDep("package/cfg/EVM_C6674_configuration_pe66", "xconfig_EVM_C6674_configuration", 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;
    }
}
