| /* --COPYRIGHT--,EPL |
| * Copyright (c) 2008-2019 Texas Instruments Incorporated |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Texas Instruments - initial implementation |
| * |
| * --/COPYRIGHT--*/ |
| var bldPkg = xdc.om["xdc.bld"]; |
| |
| var _Clock = xdc.module("xdc.services.global.Clock"); |
| |
| /* |
| * ======== initializeModel ======== |
| */ |
| function initializeModel(args) |
| { |
| xdc.$$make_om('bld'); /* create and name this object model */ |
| |
| /* load build model's modules and interfaces */ |
| xdc.loadPackage('xdc.bld'); |
| |
| /* init global objects */ |
| xdc.global.Pkg = xdc.om['xdc.bld.PackageContents']; |
| xdc.global.Build = xdc.om['xdc.bld.BuildEnvironment']; |
| |
| /* bind the root object for this model in the generic "OM" */ |
| xdc.om.$$bind('$root', Pkg); |
| |
| /* scan the package's modules and interfaces */ |
| Build.$private.scanPkg(Pkg); |
| |
| /* run the config.bld script */ |
| var $save = xdc.global.arguments; |
| xdc.global.arguments = args; |
| Build.$private.sourceCfg(args[0]); |
| xdc.global.arguments = $save; |
| } |
| |
| /* |
| * ======== BuildEnvironment.onInit ======== |
| * Called when the singleton Build Module Value is first |
| * created. |
| * |
| * Context: |
| * this the Build Module Value |
| * Params: |
| * Returns: |
| * void |
| */ |
| function onInit() { |
| |
| /* |
| * ======== scanPkg ======== |
| * Read package.xdc and populate the pkg object with the |
| * information declared there: |
| * pkg.name string name of package |
| * pkg.modules array of modules in this package |
| * pkg.interfaces array of interface in this package |
| * |
| * Params: |
| * pkg xdc.bld.PackageContents module |
| * |
| * Returns |
| * void |
| * |
| * Throws |
| * exceptions thrown are for fatal errors |
| */ |
| function scanPkg(pkg) |
| { |
| var file = new java.io.File("package.xdc"); |
| if (file.exists()) { |
| var scan = new Packages.xdc.services.intern.cmd.Scan( |
| xdc.$$private.Env |
| ); |
| |
| pkg.name = "" + scan.read("package.xdc", false); |
| pkg.$seal("name"); |
| |
| pkg.version = "" + scan.getKey(); |
| pkg.$seal("version"); |
| |
| var a = scan.getModules(); |
| for (var i = 0; i < a.length; i++) { |
| pkg.modules[pkg.modules.length++] = "" + a[i]; |
| } |
| pkg.modules.$seal(); |
| |
| var a = scan.getInterfaces(); |
| for (var i = 0; i < a.length; i++) { |
| pkg.interfaces[pkg.interfaces.length++] = "" + a[i]; |
| } |
| pkg.interfaces.$seal(); |
| |
| var a = scan.getImports(); |
| for (var i = 0; i < a.length; i++) { |
| pkg.imports[pkg.imports.length++] = "" + a[i]; |
| } |
| pkg.imports.$seal(); |
| } |
| } |
| |
| /* |
| * ======== sourceCfg ======== |
| * Source global build configuration file and do light semantic |
| * processing prior to running package specific build script. |
| * This script typically loads packages of targets and configures |
| * the targets for the build environment. |
| * |
| * The sourced file may set useTargets and excludeTargets and |
| * configure various targets. sourceCfg checks that all targets |
| * included have their rootDir set and propagates the rootDir |
| * setting to any target that declares another as its base (see |
| * ITarget). |
| * |
| * Params: |
| * file string naming the file to load and execute. |
| * This file is searched for along the import path |
| * (which includes the package path) |
| * Returns |
| * void |
| * Throws |
| * exceptions thrown are for fatal errors |
| */ |
| function sourceCfg(cfgFile) |
| { |
| /* import the user's "global" configuration of the target tools */ |
| |
| /* we expand to an absolute file name to ensure that importFile() |
| * doesn't find the file in the current script directory (which in |
| * this case is the bld package directory); e.g., "./config.bld" |
| * should be found along the import path rather than in bld/. |
| */ |
| cfgFile = (new java.io.File(cfgFile)).getAbsolutePath() + ""; |
| xdc.$$trace("xdc.bld loading " + cfgFile, 1, ["xdccore"]); |
| utils.importFile(cfgFile); |
| |
| /* This case, where config.bld caused an error but there is no |
| * exception can't be reproduced. This is most likely a leftover from |
| * an older error handling architecture. |
| */ |
| if (utils.hasReportedError()) { |
| throw xdc.$$XDCException("xdc.bld.TARGET_CONFIG_ERROR", |
| "Error in configuration. Check '" + cfgFile + "'"); |
| } |
| |
| _Clock.print("bld: config.bld loaded."); |
| |
| /* initialize build model's native target (if necessary) */ |
| var nativeName; |
| if (this.bld.nativeTarget == null) { |
| if (this.bld.hostOSName == "Windows") { |
| nativeName = "microsoft.targets.Win64"; |
| } |
| else if (this.bld.hostOSName == "Linux") { |
| nativeName = "gnu.targets.Linux86_64"; |
| } |
| else if (this.bld.hostOSName == "MacOS") { |
| nativeName = "gnu.targets.Mac86_64"; |
| } |
| if (nativeName != null && (nativeName in xdc.om)) { |
| this.bld.nativeTarget = xdc.om[nativeName]; |
| } |
| } |
| |
| /* initialize build model's targets array (if necessary) */ |
| if (this.bld.targets.length == 0) { |
| var inc, xcl; |
| if ((inc = this.bld.useTargets) === undefined) { |
| if ((inc = environment["xdc.bld.targets"]) == null) { |
| inc = ""; |
| } |
| } |
| if (inc == "") { |
| inc = "native"; |
| } |
| if (inc != null) { |
| if (this.bld.excludeTargets != null) { |
| xcl = this.bld.excludeTargets; |
| } |
| _exportTargets(this.bld.targets, inc, xcl, true); |
| } |
| } |
| |
| _Clock.print("bld: exported targets."); |
| |
| /* initialize all targets */ |
| for (var i = 0; i < this.bld.targets.length; i++) { |
| var targ = this.bld.targets[i]; |
| if (targ == undefined) { |
| throw xdc.$$XDCException("xdc.bld.TARGET_CONFIG_ERROR", |
| "Undefined target found in Build.targets (at index = " |
| + i + "). " |
| + this.bld.printBuildTargets()); |
| } |
| |
| if (targ instanceof this.bld.$package.ITarget.Module) { |
| var index = this.targsTab[targ.suffix]; |
| /* check for duplicate suffixes in the target array */ |
| if (index != null) { |
| var otarg = this.bld.targets[index]; |
| var msg; |
| if (otarg.$name != targ.$name) { |
| msg = "The target '" + targ.$name |
| + "' has the same suffix as the target '" |
| + otarg.$name + "'"; |
| } |
| else { |
| msg = "The target '" + targ.$name |
| + "' appears more than once in the Build.targets array"; |
| } |
| throw xdc.$$XDCException("xdc.bld.DUPLICATE_TARGET_ERROR", |
| msg); |
| } |
| |
| this.targsTab[targ.suffix] = i; /* fill in targsTab hash */ |
| |
| /* white space support for Windows (CQ18010) */ |
| if (targ.rootDir != null && targ.rootDir.match(/\s+/) && |
| this.bld.hostOSName == "Windows") { |
| var file = xdc.module('xdc.services.io.File'); |
| targ.rootDir = file.getDOSPath(targ.rootDir); |
| } |
| |
| /* patch targets that fail to initialize t_Size */ |
| var t = targ.stdTypes["t_Size"]; |
| if (t == null || t.align == null || t.size == null) { |
| // print("patching target " + targ.name + "'s t_Size ..."); |
| targ.stdTypes.$unseal(); |
| targ.stdTypes["t_Size"] = targ.stdTypes["t_Int"]; |
| targ.stdTypes.$seal(); |
| } |
| |
| /* propagate rootDir to targets that don't have it defined */ |
| if (targ.rootDir == null && targ.base != null) { |
| targ.rootDir = targ.base.rootDir; |
| } |
| if (targ.rootDir == null) { |
| throw xdc.$$XDCException("xdc.bld.ROOTDIR_NOT_SET", |
| "'rootDir' has not been set for the target " |
| + targ.$name + "; define 'rootDir' in " |
| + java.lang.System.getenv("XDCBUILDCFG")); |
| } |
| |
| /* initialize target's and platforms array and default plat */ |
| if (targ.platforms == null) { |
| targ.platforms = []; |
| } |
| if (targ.platform == null) { |
| if (targ.platforms.length > 0) { |
| targ.platform = targ.platforms[0]; |
| } |
| } |
| if (targ.platforms.length == 0) { |
| if (targ.platform != null) { |
| targ.platforms.length = 1; |
| targ.platforms[0] = targ.platform; |
| } |
| } |
| } |
| } |
| _Clock.print("bld: initialized targets defaults."); |
| |
| /* seal target to prevent user from changing in package.bld */ |
| for (var i = 0; i < this.bld.targets.length; i++) { |
| var targ = this.bld.targets[i]; |
| targ.$seal(); /* must do this in a separate loop from above |
| * because seal follows references. A seal of |
| * targ will also seal targ.base; e.g., sealing |
| * C64 will seal the C62 before the C62 is |
| * initialized! |
| */ |
| } |
| |
| _Clock.print("bld: targets sealed."); |
| /* BUG?: should we fail if bld.targets is empty? */ |
| |
| /* seal (make readonly) the fields that should not be modified |
| * by package.bld scripts |
| */ |
| this.bld.targets.$seal(); |
| this.bld.$seal("useTargets"); |
| this.bld.$seal("platformTable"); |
| this.bld.$seal("excludeTargets"); |
| this.bld.$seal("nativeTarget"); |
| } |
| |
| /* initialize private state */ |
| var priv = this.$private; /* private Build Module state */ |
| |
| /* private methods/data that we don't want scripts to see */ |
| priv.scanPkg = scanPkg; |
| priv.sourceCfg = sourceCfg; |
| priv.bld = this; |
| priv.targsTab = {}; |
| } |
| |
| /* |
| * ======== BuildEnvironment.usePlatform ======== |
| */ |
| function usePlatform(platformName) |
| { |
| if (!(typeof platformName == "string")) { |
| throw xdc.$$XDCException("xdc.bld.PARAMETER_MISMATCH", |
| "Parameter must be a string: was passed " + platformName); |
| } |
| |
| var plat = this.platforms[platformName]; |
| |
| if (plat == null) { |
| var pa = platformName.split(':'); |
| |
| /* load platform package */ |
| var pkg = xdc.loadPackage(pa[0]); |
| |
| /* create platform instance */ |
| var args = this.platformTable[platformName]; |
| plat = pkg.Platform.create( |
| platformName.substring(pa[0].length + 1), |
| args == null ? {} : args); |
| |
| this.platforms[platformName] = plat; |
| } |
| |
| return (plat); |
| } |
| |
| /* |
| * ======== BuildEnvironment.printBuildTargets ======== |
| */ |
| function printBuildTargets() |
| { |
| if (this.targets.length == 0) { |
| return ("No target modules were loaded.\n"); |
| } |
| var str = "Valid Build Targets:\n"; |
| for (var i = 0; i < this.targets.length; i++) { |
| if (this.targets[i] != undefined) { |
| str = str + this.targets[i].$name + "\n"; |
| } |
| } |
| |
| return str; |
| } |
| |
| |
| /* |
| * ======== BuildEnvironment.isInTargetsArray ======== |
| */ |
| function isInTargetsArray(targ) |
| { |
| return (this.$private.targsTab[targ.suffix] == null ? false : true); |
| } |
| |
| /* |
| * ======== BuildEnvironment.getReleaseDescs ======== |
| */ |
| function getReleaseDescs(pname) |
| { |
| var result = []; |
| |
| /* locate the package.bld.xml file (which describes a package's releases */ |
| var xname = xdc.getPackageBase(pname) + "/package/package.bld.xml"; |
| var xfile = new java.io.File(xname); |
| if (!xfile.exists()) { |
| throw xdc.$$XDCException("xdc.bld.PACKAGE_NOT_BUILT", "The package '" |
| + pname + "' has not been built. Try re-building the package."); |
| } |
| |
| /* parse the XML file */ |
| var doc = Packages.xdc.services.global.XML.parse(xname); |
| if (doc == null) { |
| throw xdc.$$XDCException("xdc.bld.INVALID_PACKAGE", "The package '" |
| + pname + "' has an invalid package.bld.xml file (" + xname |
| + "). Try re-building the package."); |
| } |
| |
| /* extract from this file the release information */ |
| var rels = Packages.xdc.services.global.XML.getHMaps(doc, "releases", |
| ["name", "label", "pname"]); /* pname stands for "physical name" */ |
| |
| /* create the release description objects */ |
| for (var i = 0; i < rels.length; i++) { |
| var obj = rels[i]; |
| var desc = new xdc.om['xdc.bld.Release'].Desc({ |
| name: obj.get("name"), |
| aname: obj.get("pname"), |
| label: obj.get("label") |
| }); |
| result.push(desc); |
| } |
| |
| return (result); |
| } |
| |
| /* |
| * ======== _exportTargets ======== |
| * Given the names (or patterns) of modules that implement ITarget, add |
| * each to the array of targets in build. |
| */ |
| function _exportTargets(targArray, list, exclude, warnings) |
| { |
| var ta = list.split(/[,;:\s]+/); |
| var ma = xdc.om.$modules; |
| var targets = []; |
| var ep = exclude == null ? null : new RegExp(exclude); |
| |
| /* put all matching targets into local targets array */ |
| for (var j = 0; j < ta.length; j++) { |
| |
| /* check for "native" target */ |
| if (ta[j] == "native" && bldPkg.BuildEnvironment.nativeTarget != null) { |
| targArray[targArray.length++] = bldPkg.BuildEnvironment.nativeTarget; |
| continue; |
| } |
| |
| /* match name against target module names */ |
| var pattern = new RegExp(ta[j]); |
| var found = false; |
| var tmp; |
| for (var i = 0; i < ma.length; i++) { |
| var sname = ma[i].$name; |
| if ((tmp = sname.match(pattern)) != null && tmp[0] == sname) { |
| if (ep != null |
| && (tmp = sname.match(ep)) != null && tmp[0] == sname) { |
| continue; |
| } |
| if (ma[i] instanceof bldPkg.ITarget.Module) { |
| targArray[targArray.length++] = ma[i]; |
| found = true; |
| } |
| } |
| } |
| |
| /* try appending the TI package prefix to the target specification */ |
| if (found == false) { |
| for (var i = 0; i < ma.length; i++) { |
| var sname = ma[i].$name; |
| if (("ti.targets." + ta[j]) == sname |
| && ma[i] instanceof bldPkg.ITarget.Module) { |
| if (ep != null |
| && (tmp = sname.match(ep)) != null && tmp[0] == sname){ |
| continue; |
| } |
| targArray[targArray.length++] = ma[i]; |
| found = true; |
| break; |
| } |
| } |
| } |
| |
| /* if no match is found for a pattern, print a warning */ |
| if (found == false && warnings == true) { |
| print("Warning: Target specification '" + ta[j] + |
| "' does not match any loaded target module.\n" + |
| xdc.module('xdc.bld.BuildEnvironment').printBuildTargets()); |
| } |
| } |
| } |
