metaonly module microsoft.targets.Win32

Microsoft Windows 32-bit target using the Visual C/C++ compiler

This target can be configured to be used with different versions of Microsoft Visual C/C++ and different installations of Platform SDK (or a newer equivalent Windows SDK). The optional Platform SDK is needed only for building applications that use Windows API. The target Win32 contains default configurations for Visual C/C++ versions 6.0, 7.0 and 8.0, but in order to support future versions of Visual C/C++ and different Platform SDK installations, there is a parameter vcPath, which users can set in their config.bld files to enable usage of this target with their installations. [ more ... ]
XDCscript usage meta-domain sourced in microsoft/targets/Win32.xdc
var Win32 = xdc.useModule('microsoft.targets.Win32');
module-wide constants & types
        obj.base// base name of the source and destination = String  ...
        obj.dstPrefix// directory prefix of destination file = String  ...
        obj.dstSuffix// suffix of destination file; e.g., ".a62" = String  ...
        obj.files// String of files to archive = String  ...
        obj.profile// index into profiles map = String  ...
        obj.opts// goal specific archiver options = String  ...
        obj.cmd// the command to run = String  ...
        obj.opts// required options for the command = String  ...
        obj.msg// brief message describing subsequent commands = String  ...
        obj.cmds// commands necessary to generate goal = String  ...
        obj.path// host-independent representation of PATH = String[]  ...
        obj.envs// environment variable settings for the cmds = String[]  ...
        obj.base// base name of the source and destination = String  ...
        obj.dstPrefix// directory prefix of destination file = String  ...
        obj.dstSuffix// suffix of destination file; e.g., ".o62" = String  ...
        obj.srcSuffix// optional suffix of source file; e.g., ".c" = String  ...
        obj.srcPrefix// optional directory prefix of source file = String  ...
        obj.profile// index into profiles map = String  ...
        obj.aopts// goal specific ASM options = String  ...
        obj.copts// goal specific C compiler options = String  ...
        obj.cfgcopts// goal specific C config file options = String  ...
        obj.defs// goal specific C/ASM definition options = String  ...
        obj.incs// goal specific C/ASM include options = String  ...
        obj.execTemplate// debugger template for executable = String  ...
        obj.execPattern// exec file name pattern = String  ...
        obj.packageTemplate// debugger template for package = String  ...
        obj.packagePattern// package file name pattern = String  ...
        obj.suf// file extension (including any '.') = String  ...
        obj.typ// type of this file; e.g., "c", "asm", .. = String  ...
        obj.base// base name of the source and destination = String  ...
        obj.dstPrefix// directory prefix of destination file = String  ...
        obj.dstSuffix// suffix of destination file; e.g., ".x62" = String  ...
        obj.files// string of files to link with = String  ...
        obj.profile// index into profiles map = String  ...
        obj.opts// goal specific linker options = String  ...
        obj.dllMode// true if we're linking an assembly = Bool  ...
        obj.isRom// reflects the isRom attribute = Bool  ...
    var obj = new Win32.Model// Target runtime model;
        obj.endian// endian-ness of this target = String  ...
        obj.codeModel// target-specific code model = String  ...
        obj.dataModel// target-specific data model = String  ...
        obj.linkOpts// profile-specific linker opts = String  ...
        obj.archiveOpts// profile-specific archiver opts = String  ...
        obj.prefix// options that appear before Command.opts = String  ...
        obj.suffix// options that appear after Command.opts = String  ...
        obj.t_IArg = ITarget.TypeInfo  ...
        obj.t_Char = ITarget.TypeInfo  ...
        obj.t_Double = ITarget.TypeInfo  ...
        obj.t_Float = ITarget.TypeInfo  ...
        obj.t_Fxn = ITarget.TypeInfo  ...
        obj.t_Int = ITarget.TypeInfo  ...
        obj.t_Int8 = ITarget.TypeInfo  ...
        obj.t_Int16 = ITarget.TypeInfo  ...
        obj.t_Int32 = ITarget.TypeInfo  ...
        obj.t_Int40 = ITarget.TypeInfo  ...
        obj.t_Int64 = ITarget.TypeInfo  ...
        obj.t_Long = ITarget.TypeInfo  ...
        obj.t_LDouble = ITarget.TypeInfo  ...
        obj.t_LLong = ITarget.TypeInfo  ...
        obj.t_Ptr = ITarget.TypeInfo  ...
        obj.t_Short = ITarget.TypeInfo  ...
        obj.t_Size = ITarget.TypeInfo  ...
        obj.compilerDir = String  ...
        obj.dllPath = String  ...
        obj.sdkPath = String  ...
        obj.libs = String  ...
module-wide config parameters
        cmd: "$(rootDir)/$(compilerDir)/bin/lib.exe -nologo",
        opts: ""
    };
        cmd: "$(rootDir)/$(compilerDir)/bin/ml -c",
        opts: "-nologo"
    };
        cmd: "$(rootDir)/$(compilerDir)/bin/cl.exe -nologo -c",
        opts: '-Zp1 -W3 -DWIN32 -D_DLL -D_AFXDLL -DEXPORT=""'
    };
        cmd: "$(rootDir)/$(compilerDir)/bin/link",
        opts: "-nologo"
    };
        endian: "little"
    };
    const Win32.name// Nickname for this target = String "Win32";
    const Win32.rts// Name of a run-time support package to include = String "microsoft.targets.rts";
    const Win32.sectMap// Output section name to segment type mapping = String[string] computed value;
    const Win32.stdInclude// Standard C/C++ types header = String "microsoft/targets/std.h";
        prefix: "",
        suffix: ""
    };
        prefix: "",
        suffix: ""
    };
        prefix: "$(ccOpts.prefix)",
        suffix: "$(ccOpts.suffix)"
    };
        prefix: "-Ob1 -Gs",
        suffix: "-Dfar= "
    };
        execTemplate: "microsoft/targets/vc_exec.xdt",
        execPattern: "$(cfgName).vcproj"
    };
        [
            ".asm",
            {
                suf: ".asm",
                typ: "asm"
            }
        ],
        [
            ".c",
            {
                suf: ".c",
                typ: "c"
            }
        ],
        [
            ".cpp",
            {
                suf: ".cpp",
                typ: "cpp"
            }
        ],
        [
            ".cxx",
            {
                suf: ".cxx",
                typ: "cpp"
            }
        ],
        [
            ".C",
            {
                suf: ".C",
                typ: "cpp"
            }
        ],
        [
            ".cc",
            {
                suf: ".cc",
                typ: "cpp"
            }
        ]
    ];
    Win32.includeOpts// User modifiable include paths = String "-I$(rootDir)/$(compilerDir)/include -I$(rootDir)/$(compilerDir)/atlmfc/include -I$(rootDir)/$(compilerDir)/mfc/include -I$(rootDir)/$(compilerDir)/atl/include -I$(sdkPath)/include";
        prefix: "-libpath:$(rootDir)/$(compilerDir)/lib -libpath:$(rootDir)/$(compilerDir)/atlmfc/lib -libpath:$(rootDir)/$(compilerDir)/mfc/lib -libpath:$(sdkPath)/lib",
        suffix: "-map:$(XDCCFGDIR)/$@.map -pdb:$(XDCCFGDIR)/$@.pdb -machine:ix86 -nodefaultlib -incremental:no"
    };
    Win32.platform// The default platform name for this target = String "host.platforms.PC";
        [
            "debug",
            {
                compileOpts: {
                    copts: "-Z7 -Odi -MT",
                    defs: ""
                },
                linkOpts: "-debug "
            }
        ],
        [
            "release",
            {
                compileOpts: {
                    copts: "-O2 -MT",
                    defs: ""
                },
                linkOpts: ""
            }
        ]
    ];
        [
            "VC6",
            {
                compilerDir: "vc98",
                dllPath: "common/msdev98/bin",
                sdkPath: "",
                libs: " msvcrt.lib setargv.obj oldnames.lib ole32.lib oleaut32.lib olepro32.lib uuid.lib kernel32.lib user32.lib gdi32.lib advapi32.lib shell32.lib comctl32.lib mfc42.lib msvcirt.lib"
            }
        ],
        [
            "VC7",
            {
                compilerDir: "Vc7",
                dllPath: "Common7/IDE;VisualStudio.NETProfessional-English",
                sdkPath: "Vc7/PlatformSDK",
                libs: " msvcrt.lib setargv.obj oldnames.lib ole32.lib oleaut32.lib olepro32.lib uuid.lib kernel32.lib user32.lib gdi32.lib advapi32.lib shell32.lib comctl32.lib mfc70.lib msvcirt.lib"
            }
        ],
        [
            "VC8",
            {
                compilerDir: "VC",
                dllPath: "Common7/IDE",
                sdkPath: "VC/PlatformSDK",
                libs: " msvcrt.lib setargv.obj oldnames.lib ole32.lib oleaut32.lib olepro32.lib uuid.lib kernel32.lib user32.lib gdi32.lib advapi32.lib shell32.lib comctl32.lib"
            }
        ]
    ];
module-wide functions
 
DETAILS
This target can be configured to be used with different versions of Microsoft Visual C/C++ and different installations of Platform SDK (or a newer equivalent Windows SDK). The optional Platform SDK is needed only for building applications that use Windows API. The target Win32 contains default configurations for Visual C/C++ versions 6.0, 7.0 and 8.0, but in order to support future versions of Visual C/C++ and different Platform SDK installations, there is a parameter vcPath, which users can set in their config.bld files to enable usage of this target with their installations.
Unlike the Visual C/C++ 6.x tool chain, this compiler complies very closely with the C/C++ language specification. This target may be necessary in situations that take full advantage of the C++ language.
struct Win32.ArchiveGoal

The goal specification passed to the archive function

XDCscript usage meta-domain
var obj = new Win32.ArchiveGoal;
 
    obj.base = String  ...
    // base name of the source and destination
    obj.dstPrefix = String  ...
    // directory prefix of destination file
    obj.dstSuffix = String  ...
    // suffix of destination file; e.g., ".a62"
    obj.files = String  ...
    // String of files to archive
    obj.profile = String  ...
    // index into profiles map
    obj.opts = String  ...
    // goal specific archiver options
SEE
struct Win32.Command

Required command and options

XDCscript usage meta-domain
var obj = new Win32.Command;
 
    obj.cmd = String  ...
    // the command to run
    obj.opts = String  ...
    // required options for the command
FIELDS
cmd — name of a tool-chain executable without any path information. The location of this executable is specified by the binDir (or pathPrefix) configuration parameter.
opts — required options passed to the command; these options can not be changed or eliminated by user's configuration script.
DETAILS
The compile, link, and archive functions in this interface are implemented by expanding the strings specified in this structure and inserting strings from the Options structure to form a single command. The strings in this structure can not be changed by the user (they are fixed by the target), but the string in the Options structure may be changed by the user.
The final command is: Command.cmd Options.prefix Command.opts Options.suffix
struct Win32.CommandSet

The commands necessary to create a specified goal

XDCscript usage meta-domain
var obj = new Win32.CommandSet;
 
    obj.msg = String  ...
    // brief message describing subsequent commands
    obj.cmds = String  ...
    // commands necessary to generate goal
    obj.path = String[]  ...
    // host-independent representation of PATH
    obj.envs = String[]  ...
    // environment variable settings for the cmds
FIELDS
msg — a brief synopsis of the commands specified by cmds; this string is output in lieu of cmds when building in "non-verbose" mode.
cmds — a single string of commands that must be executed to complete the specified operation. Multiple commands may be specified by separating each command with the '\n' character.
To facilitate the creation of "portable" makefiles and to simplify the implementation of targets, certain distinguished "macros" may be embedded in this string. The build engine replaces these macros with the values described below.
$(rootDir)
the target's rootDir configuration parameter
$(packageBase)
the target package's xdc.IPackage.packageBase property
$(XDCINCS)
a set of "-I" options that names each repository in the package path
envs — an array of "name=value" strings that represent environment variables that are defined prior to the execution of the commands specified by cmds
path — an array of directory names that are used to compose the PATH environment variable that is in effect when the commands specified by cmds are run.
DETAILS
This structure is the return value of the compile, link and archive functions. This value is then used to generate a makefile or any other files necessary to generate a specified goal.
SEE
struct Win32.CompileGoal

The goal specification passed to the compile function

XDCscript usage meta-domain
var obj = new Win32.CompileGoal;
 
    obj.base = String  ...
    // base name of the source and destination
    obj.dstPrefix = String  ...
    // directory prefix of destination file
    obj.dstSuffix = String  ...
    // suffix of destination file; e.g., ".o62"
    obj.srcSuffix = String  ...
    // optional suffix of source file; e.g., ".c"
    obj.srcPrefix = String  ...
    // optional directory prefix of source file
    obj.profile = String  ...
    // index into profiles map
    obj.opts = ITarget.CompileOptions  ...
    // goal specific compiler options
    obj.configOpts = Bool  ...
    // true if compiling the generated C config file
SEE
struct Win32.CompileOptions

Options passed to the compiler/assembler

XDCscript usage meta-domain
var obj = new Win32.CompileOptions;
 
    obj.aopts = String  ...
    // goal specific ASM options
    obj.copts = String  ...
    // goal specific C compiler options
    obj.cfgcopts = String  ...
    // goal specific C config file options
    obj.defs = String  ...
    // goal specific C/ASM definition options
    obj.incs = String  ...
    // goal specific C/ASM include options
FIELDS
aopts — a string of target-specific assembler options
copts — a string of target-specific C/C++ compiler options
cfgcopts — a string of C/C++ compiler options for C config file
defs — a string of macro definitions each of the form "-Dname=value" separated by white space
incs — a string of include directories each of the form "-Idir" separated by white space
PREDEFINED MACROS
The XDC Build Engine automatically adds several predefined macros via -D definitions that enable conditional compilation of source files based on build-specific attributes.
xdc_bld__profile_{profile_name}
this symbol is always defined and {profile_name} is the compile goal's (see CompileGoal) profile name.
In addition, each target defines a set of macros that enable clients to portably support big/little endian targets, for example. These macros are indirectly included by sources that include xdc/std.h; see xdc.
SEE
struct Win32.DebugGen

Debugger integration support

XDCscript usage meta-domain
var obj = new Win32.DebugGen;
 
    obj.execTemplate = String  ...
    // debugger template for executable
    obj.execPattern = String  ...
    // exec file name pattern
    obj.packageTemplate = String  ...
    // debugger template for package
    obj.packagePattern = String  ...
    // package file name pattern
DETAILS
This structure specifies additional files that are generated in order to support integration with a debugger. For example, the default setting for TI targets specifies the generation of CCS project files that allow one to easily debug executables that have been constructed from multiple packages.
There are two "types" of debug support files that are generated; one for the package as a whole, and one for each executable. Since packages may contain portable sources that are built for more than one target, a "package-level" file is generated for each target used in the package. A separate file is generated for each executable built within the package.
The execTemplate and packageTemplate fields name a template that is expanded in the context of the config model and the build model, respectively. These fields should be set to a file name string which is relative to the package path; e.g., the string "ti/targets/cc_exec.xdt" refers to the file "cc_exec.xdt" in the ti.targets package located along the package path.
Preconditions for the execTemplate:
this
the configured program object (xdc.cfg.Program); i.e., the program object *after* the program's configuration script completes.
$args
array of arguments passed to the template
$args[1]
the name of the executable being produced for this configuration.
environment
hash table of XDC global parameters; e.g., "xdc.path", "xdc.root", ...
Preconditions for the packageTemplate:
this
the "package contents" object (i.e., xdc.bld.PackageContents) *after* the package's build script (package.bld) completes.
$args
array of arguments passed to the template
$args[0]
the target (a module implementing the xdc.bld.ITarget interface)
$args[1]
hash-table of all package sources
environment
hash table of XDC global parameters; e.g., "xdc.path", "xdc.root", ...
The execPattern and packagePattern fields are expressions that are expanded prior to template expansion to determine the name of the output file. Expressions of the form "$(name)" within the pattern string are expanded if "name" is one of the built-in variables listed below.
Built-in variables for execPattern:
cfgName
the name of the generated configuration file (without any directory prefix);
cfgDir
the name of the directory containing the config file;
exeName
the name of the executable file (without any directory prefix);
exeDir
the directory containing the executable file.
Both the exeDir and cfgDir are relative to the directory containing the package.bld script.
Built-in variables for packagePattern:
pkgName
the package's name (e.g., "ti.targets");
trgName
the target's name property;
trgSuffix
the target's suffix property.
SEE
struct Win32.Extension

File extension to file type association

XDCscript usage meta-domain
var obj = new Win32.Extension;
 
    obj.suf = String  ...
    // file extension (including any '.')
    obj.typ = String  ...
    // type of this file; e.g., "c", "asm", ..
FIELDS
suf — the file extension including any '.' characters
typ — the type of the file having this extension. Allowable file type identifiers include:
"c"
C language source file
"asm"
assembly language source file
"cpp"
C++ language source file
DETAILS
This structure is used by the Build Engine to determine whether a file should be treated as C++, C, or assembly language source.
SEE
struct Win32.LinkGoal

The goal specification passed to the link function

XDCscript usage meta-domain
var obj = new Win32.LinkGoal;
 
    obj.base = String  ...
    // base name of the source and destination
    obj.dstPrefix = String  ...
    // directory prefix of destination file
    obj.dstSuffix = String  ...
    // suffix of destination file; e.g., ".x62"
    obj.files = String  ...
    // string of files to link with
    obj.profile = String  ...
    // index into profiles map
    obj.opts = String  ...
    // goal specific linker options
    obj.dllMode = Bool  ...
    // true if we're linking an assembly
    obj.isRom = Bool  ...
    // reflects the isRom attribute
SEE
struct Win32.Model

Target runtime model

XDCscript usage meta-domain
var obj = new Win32.Model;
 
    obj.endian = String  ...
    // endian-ness of this target
    obj.codeModel = String  ...
    // target-specific code model
    obj.dataModel = String  ...
    // target-specific data model
    obj.shortEnums = Bool  ...
    // if true, enums are packed into smallest integral type
FIELDS
— (endian) this string specifies the endianess of the generated code. Valid values include:
"big"
big endian
"little"
little endian
null
unspecified
(codeModel) this string specifies a target-specific code size model. Valid values include:
"near"
C54 near mode
"far"
C54 far mode
undefined
unspecified
(dataModel) this string specifies a target-specific data size model. Valid values include:
"large"
C55, C28 large model
undefined
unspecified
(shortEnums) this flag specifies if a target fits the values of an enumeration into the smallest integer type that can accept all values. If that is the case, this flag must be set to true. If all values are the size of an Int, this flag can be either set to false or left unspecified.
SEE
struct Win32.OptionSet

Collection of tool-chain options

XDCscript usage meta-domain
var obj = new Win32.OptionSet;
 
    obj.compileOpts = ITarget.CompileOptions  ...
    // profile-specific compiler opts
    obj.linkOpts = String  ...
    // profile-specific linker opts
    obj.archiveOpts = String  ...
    // profile-specific archiver opts
    obj.filters = ITargetFilter.InstDesc[]  ...
    // ITargetFilter instance descs
FIELDS
compilerOptions — a set of compiler/assembler options
linkOpts — a string of target-specific linker options
archiveOpts — a string of target-specific archiver options
filters — an array of filters applied (in order) to tool-chain commands
DETAILS
This structure is used to define a collection of tool-chain options that are used as a group to achieve some effect supported by the tool-chain. For example, some compilers require that specific options be passed to the compiler *and* linker in order to generate execution profile information or code coverage statistics.
SEE
struct Win32.Options

User configurable command options

XDCscript usage meta-domain
var obj = new Win32.Options;
 
    obj.prefix = String  ...
    // options that appear before Command.opts
    obj.suffix = String  ...
    // options that appear after Command.opts
DETAILS
The option strings allow the user to pass additional parameters to the executable that is responsible for compiling, linker, or archiving. See xdc.bld.ITarget2.Command.
struct Win32.StdTypes

Standard base types supported by all targets

XDCscript usage meta-domain
var obj = new Win32.StdTypes;
 
    obj.t_IArg = ITarget.TypeInfo  ...
    obj.t_Char = ITarget.TypeInfo  ...
    obj.t_Double = ITarget.TypeInfo  ...
    obj.t_Float = ITarget.TypeInfo  ...
    obj.t_Fxn = ITarget.TypeInfo  ...
    obj.t_Int = ITarget.TypeInfo  ...
    obj.t_Int8 = ITarget.TypeInfo  ...
    obj.t_Int16 = ITarget.TypeInfo  ...
    obj.t_Int32 = ITarget.TypeInfo  ...
    obj.t_Int40 = ITarget.TypeInfo  ...
    obj.t_Int64 = ITarget.TypeInfo  ...
    obj.t_Long = ITarget.TypeInfo  ...
    obj.t_LDouble = ITarget.TypeInfo  ...
    obj.t_LLong = ITarget.TypeInfo  ...
    obj.t_Ptr = ITarget.TypeInfo  ...
    obj.t_Short = ITarget.TypeInfo  ...
    obj.t_Size = ITarget.TypeInfo  ...
SEE
struct Win32.VCPath

Object that defines various paths in a particular Visual Studio installation

XDCscript usage meta-domain
var obj = new Win32.VCPath;
 
    obj.compilerDir = String  ...
    obj.dllPath = String  ...
    obj.sdkPath = String  ...
    obj.libs = String  ...
FIELDS
compilerDir — Relative path from this target's rootDir to the directory that contains the compiler.
dllPath — Relative path from this target's rootDir to the directory that contains mspdb.dll, mspdbcore.dll, etc.
sdkPath — Relative path from this target's rootDir to a Platform SDK installation or an absolute path to a Platform SDK installation. Platform SDK is required if the target is used to build executables that use Windows API.
libs — List of libraries to be added to the linker command line. If Platform SDK is used, the list should contain required libraries from sdkPath/lib. Otherwise, only the libraries from compilerDir/lib can be added to 'libs'.
DETAILS
Different Visual Studio installations keep the actual compiler and additional required DLLs in separate directories. Also, a Platform SDK installation is needed for building programs that use Windows API.
config Win32.alignDirectiveSupported  // module-wide

The compiler supports an align directive

XDCscript usage meta-domain
const Win32.alignDirectiveSupported = Bool false;
config Win32.ar  // module-wide

The archiver command and all required options

XDCscript usage meta-domain
const Win32.ar = ITarget2.Command {
    cmd: "$(rootDir)/$(compilerDir)/bin/lib.exe -nologo",
    opts: ""
};
DETAILS
-nologo
don't display archiver copyright
config Win32.asm  // module-wide

The assemble command and all required options

XDCscript usage meta-domain
const Win32.asm = ITarget2.Command {
    cmd: "$(rootDir)/$(compilerDir)/bin/ml -c",
    opts: "-nologo"
};
DETAILS
-c
don't link
-nologo
don't display macro assembler copyright
config Win32.base  // module-wide

A target that this target is based upon

XDCscript usage meta-domain
const Win32.base = ITarget.Module computed value;
DETAILS
If non-null, this target shares the same tool-chain of the specified base target. This parameter is used to determine various default values for target configuration parameters. For example, the default setting of rootDir is the value of the base's rootDir setting.
config Win32.bitsPerChar  // module-wide

The number of bits in a variable of type char

XDCscript usage meta-domain
const Win32.bitsPerChar = Int 8;
DETAILS
This constant allows one to determine the precise number of bits in each of the types specified in the stdTypes map. For example, the number of bits in the target t's int type is
      t.stdTypes.t_Int.size * t.bitsPerChar
config Win32.cc  // module-wide

The compile command and all required options

XDCscript usage meta-domain
const Win32.cc = ITarget2.Command {
    cmd: "$(rootDir)/$(compilerDir)/bin/cl.exe -nologo -c",
    opts: '-Zp1 -W3 -DWIN32 -D_DLL -D_AFXDLL -DEXPORT=""'
};
DETAILS
-W3
enable all warnings recommended for production purposes.
-c
don't link
-nologo
don't display compiler copyright
-Zp1
Packs structure members on 1-byte boundry
config Win32.isa  // module-wide

CPU Instruction Set Architecture (ISA)

XDCscript usage meta-domain
const Win32.isa = String "x86";
DETAILS
This parameter is used to identify a set of targets that produce code for a common ISA. This is used by build scripts that need to build for all targets that support a particular device.
For example, the build script for a package that is designed for the TMS32064xx (and no other CPU) can easily specify that it should be built for all targets that generate code for the TMS320C64xx without having to specify a specific target. This allows the user to add new targets (big endian, little endian, different compilers, etc.) that build for the TMS320C64xx without having to modify the package's build script.
Note that this field should not be confused with platform ISA names; this field is defined by target tool-chains and may differ from the names given by a CPU device.
SEE
config Win32.lnk  // module-wide

The linker command and all required options

XDCscript usage meta-domain
const Win32.lnk = ITarget2.Command {
    cmd: "$(rootDir)/$(compilerDir)/bin/link",
    opts: "-nologo"
};
DETAILS
-nologo
Don't display linker copyright
config Win32.model  // module-wide

Run-time model

XDCscript usage meta-domain
const Win32.model = ITarget.Model {
    endian: "little"
};
DETAILS
This structure identifies a particular run-time model used by the compiler to generate instructions.
config Win32.name  // module-wide

Nickname for this target

XDCscript usage meta-domain
const Win32.name = String "Win32";
DETAILS
This name is typically the name of the module without the package name prefix. Thus, it is not necessarily globally unique.
Use the $name property of the module to get a globally unique name for the target.
config Win32.os  // module-wide

Name of OS required to run programs built for this target

XDCscript usage meta-domain
const Win32.os = String "Windows";
DETAILS
Native executables are run by the host OS. This OS often defines runtime interfaces that all executables (implicitly or explicitly) use.
If os is undefined, then no OS is required.
config Win32.rts  // module-wide

Name of a run-time support package to include

XDCscript usage meta-domain
const Win32.rts = String "microsoft.targets.rts";
DETAILS
Development environments often provide a set of common run-time support functions that all other code can easily utilize; e.g., some means for performing a "printf", normal program termination with "exit status", etc. If the rts parameter is non-null, it is the name of a package that is implicitly imported when building any executable that is built using this target. If rts is undefined, no rts package is imported.
This parameter makes it possible for the target producer to name a package that provides a target-specific implementation of a runtime support interface. Clients of a target do not need to explicitly name a target specific rts implementation; thus, it is not possible for the client to inadvertently name the wrong (or an incompatible) rts implementation.
Note: this package is *NOT* included if the executable's xdc.bld.Executable.attrs.rtsName attribute is set to null; see xdc.bld.Executable.Attrs. It is also not included if the executable is a legacy DSP/BIOS program.
config Win32.sectMap  // module-wide

Output section name to segment type mapping

XDCscript usage meta-domain
const Win32.sectMap = String[string] computed value;
DETAILS
This hash table is used to determine whether a particular object file output section (".text", ".stack", etc.) requires 'data', 'code' or 'stack' memory segment.
This sectMap is referenced by linker command file templates during generation to create linker command files. The Platform defines the default memory segments for code and data, and based on this map and the default segments, the linker command file template places an output section into a physical memory segment.
Note that the xdc.cfg.Program object and the xdc.platform.IPlatform instance have a sectMap parameter. Both the Program's and IPlatform's sectMap can augment and/or override the placement for a section, but xdc.cfg.Program.sectMap takes precedence. Therefore, this sectMap and the default segments from the platform define an initial section map which is then augmented by the Program's and IPlatform's section map.
config Win32.stdInclude  // module-wide

Standard C/C++ types header

XDCscript usage meta-domain
const Win32.stdInclude = String "microsoft/targets/std.h";
DETAILS
This string identifies a header containing the C/C++ definitions required to enable use of xdc/std.h in C/C++ sources; see xdc.
The value of this string is used by xdc/std.h to include target-specific definitions of the types Int8, Int16, etc. In addition, this header supplies target-specific definitions of the predefined xdc_target__* macros required by xdc/std.h.
Since this header must supply target-specific values for target-independent names the structure of this header is usually of the form:
      // if target macros are not already defined, 
      #if !defined(xdc_target_macros_include__)
          // include target-specific definitions
          #if defined(TARGET1)
              #include "target1.h"
          #elif defined(TARGET2)
              #include "target2.h"
          #elif ...
              :
          #else
              #error unsupported target
          #endif
      #endif
      // include common definitions
          :
The check of the symbol xdc_target_macros_include__ exists to allow others that define new targets to include this header to get common definitions for a family of related targets.
To simplify the creation of the target-specific header files, the template file stddefs.xdt in this package can be used to automatically generate the required definitions from each target's .xdc specification.
config Win32.suffix  // module-wide

Suffix appended to all objs, libraries, and executable

XDCscript usage meta-domain
const Win32.suffix = String "86W";
DETAILS
All files generated by this target (object files, archives, executables, etc.) have file names whose extensions end with suffix. In particular, targets create files with the following extensions:
".a<suffix>"
archive files (i.e., libraries)
".o<suffix>"
object files
".s<suffix>"
assembly language source (see scompile())
".x<suffix>"
executable files This suffix should be chosen to globally and uniquely identify the EABI (Embedded Application Binary Interface) of the objects produced by this target. Targets with the same suffix should should produce 100% EABI compatible objects and, targets with different suffixes should produce objects with incompatible EABIs.
SEE
config Win32.arOpts  // module-wide

User configurable archiver options

XDCscript usage meta-domain
Win32.arOpts = ITarget2.Options {
    prefix: "",
    suffix: ""
};
config Win32.asmOpts  // module-wide

User configurable assembler options

XDCscript usage meta-domain
Win32.asmOpts = ITarget2.Options {
    prefix: "",
    suffix: ""
};
config Win32.ccConfigOpts  // module-wide

User configurable compiler options for the generated config C file

XDCscript usage meta-domain
Win32.ccConfigOpts = ITarget2.Options {
    prefix: "$(ccOpts.prefix)",
    suffix: "$(ccOpts.suffix)"
};
DETAILS
By default, this parameter inherits values specified in ccOpts. The strings "$(ccOpts.prefix)" and "$(ccOpts.suffix)" are expanded into the values specified by ccOpts for this target.
config Win32.ccOpts  // module-wide

User modifiable default options

XDCscript usage meta-domain
Win32.ccOpts = ITarget2.Options {
    prefix: "-Ob1 -Gs",
    suffix: "-Dfar= "
};
DETAILS
-G5 (removed because it is incompatible with VC8.0)
Optimizes code to favor the Pentium processor
-Ob1
Expand only functions marked as inline or, in a C++ member function, defined within a class declaration
-Gs
Probe stack to automatically grow stack as necessary
-GX (removed because it is incompatible with VC8.0)
Enables synchronous exception handling
-WL
Write errors/warnings on a single output line
config Win32.cmdPrefix  // module-wide

Prefix to put in front of each command

XDCscript usage meta-domain
Win32.cmdPrefix = String "";
DETAILS
This string is put in front of every Command before being passed to the shell for execution. This string can be used to run the compiler in emulation environments.
config Win32.compatibleSuffixes  // module-wide

Array of suffixes used by targets compatible with this target

XDCscript usage meta-domain
Win32.compatibleSuffixes = String[] undefined;
DETAILS
This array is used to identify a set of targets that produce code that can be linked with code produced by this target, where the order of suffixes defines the order of preferrence. This parameter is used by findSuffixes().
For example, an Arm target which builds for v6 architecture might have the following values in its compatibleSuffix: ["v5T", "MV470"]. This means that code produced by targets with suffixes "v5T' and "MV470" can be linked with code produced by that target, and that "v5T" code is more preferred than "MV470" code.
config Win32.debugGen  // module-wide

Debugger/IDE project file generation support

XDCscript usage meta-domain
Win32.debugGen = ITarget.DebugGen {
    execTemplate: "microsoft/targets/vc_exec.xdt",
    execPattern: "$(cfgName).vcproj"
};
DETAILS
This parameter allows one to automatically generate files that can be used by an IDE to more easily debug (and possibly rebuild) specified goals.
To avoid unnecessary build time overhead, these files are not always generated; by default, they are only generated for "debug" profiles. The generation of these files is controlled by the xdc.cfg.Program.gen configuration parameter. To force these files to be generated for a particular executable, add the following line to the executable's program configuration script:
	    Program.gen.debuggerFiles = true;
It is also possible to disable the generation of selected files by setting the appropriate fields of DebugGen to null in your config.bld script.
The settings below generate VC project files that enable one to debug (and even rebuild) Executables from within the VC GUI.
To avoid unnecessary build time overhead, these files are not always generated; by default, they are only generated for "debug" profiles. The generation of these files is controlled by the xdc.cfg.Program.gen configuration parameter. To force these files to be generated for a particular executable, add the following line to the executable's program configuration script:
	    Program.gen.debuggerFiles = true;
It is also possible to control the generation via build options; see xdc.bld.ITarget.DebugGen.
To debug an executable: double click on the generated *.vcproj file, when the debugger comes up, type F11 (step into).
The first time you debug an executable, the VC debugger may prompt you for a "solution file" to save. Click OK (accepting the solution file name), and you will be at the first statement of your executable.
To set command line arguments prior to debugging: open the executable's "Project Properties" dialog (select the executable in the "Solution Explorer" window and pull-down View->"Property Pages" or type shift-F4), select "Debugging" in the left-most pane of the executable's "Property Pages", and enter command line arguments in the "Command Arguments" text box.
SEE
config Win32.execExt  // module-wide

Extension for executables

XDCscript usage meta-domain
Win32.execExt = String ".exe";
DETAILS
Operating systems and tools often have a strong preference for a specific extension for executables; e.g., Windows expects executables to have the extension ".exe". If this parameter is set, executables will be given the specified extension instead of the default ".x<suffix>", where <suffix> is the target's suffix parameter.
The execExt is an expression that is expanded prior to use. Expressions of the form "$(name)" within the pattern string are expanded if "name" is one of the built-in variables listed below.
Built-in variables for execExt:
trgName
the target's name property
trgSuffix
the target's suffix property
platPName
the executable's platform package name
platIName
the executable's platform instance name
EXAMPLE
If you want to build a portable executable for multiple targets side-by-side and you want (or need) to use a fixed extension such as ".out" for all executables, setting execExt to "_$(trgSuffix).out" for all targets ensures that all generated executables will have unique names and yet share a common extension of ".out".
config Win32.extensions  // module-wide

File extensions recognized by this target

XDCscript usage meta-domain
Win32.extensions = ITarget.Extension[string] [
    [
        ".asm",
        {
            suf: ".asm",
            typ: "asm"
        }
    ],
    [
        ".c",
        {
            suf: ".c",
            typ: "c"
        }
    ],
    [
        ".cpp",
        {
            suf: ".cpp",
            typ: "cpp"
        }
    ],
    [
        ".cxx",
        {
            suf: ".cxx",
            typ: "cpp"
        }
    ],
    [
        ".C",
        {
            suf: ".C",
            typ: "cpp"
        }
    ],
    [
        ".cc",
        {
            suf: ".cc",
            typ: "cpp"
        }
    ]
];
DETAILS
This is a user modifiable table used to customize file extensions recognized by each target.
For example, to add a new assembly language extension, say ".s64", to the target ti.targets.C64P, add the following lines to the build model startup script:
      var C64P = xdc.module('ti.targets.C64P');
      C64P.extensions[".s64"] = {
          suf: ".s64", typ: "asm"
      };

  Note that individual targets may add additional language types.

  It is also possible to remove default extensions.  For example, to
  remove the "`.asm`" extension from the target `ti.targets.C64P`, add
  the following lines to the build model startup script:
      var C64P = xdc.module('ti.targets.C64P');
      delete C64P.extensions[".asm"];
config Win32.includeOpts  // module-wide

User modifiable include paths

XDCscript usage meta-domain
Win32.includeOpts = String "-I$(rootDir)/$(compilerDir)/include -I$(rootDir)/$(compilerDir)/atlmfc/include -I$(rootDir)/$(compilerDir)/mfc/include -I$(rootDir)/$(compilerDir)/atl/include -I$(sdkPath)/include";
DETAILS
-I$(rootDir)/$(compilerDir)/include
include compiler specific headers
config Win32.lnkOpts  // module-wide

User modifiable linker options

XDCscript usage meta-domain
Win32.lnkOpts = ITarget2.Options {
    prefix: "-libpath:$(rootDir)/$(compilerDir)/lib -libpath:$(rootDir)/$(compilerDir)/atlmfc/lib -libpath:$(rootDir)/$(compilerDir)/mfc/lib -libpath:$(sdkPath)/lib",
    suffix: "-map:$(XDCCFGDIR)/$@.map -pdb:$(XDCCFGDIR)/$@.pdb -machine:ix86 -nodefaultlib -incremental:no"
};
DETAILS
-libpath...
directories to search for toolchain specific libraries
-nodefaultlib
don't search for default libraries when linking; all libraries used must be explicitly named
-incremental:no
link for execution (no subsequent link will occur)
-machine:ix86
link for the Intel x86 architecture
-map:$(XDCCFGDIR)/$@.map
output any link map information to the specified file ($(XDCCFGDIR) is usually package/cfg)
-pdb:$(XDCCFGDIR)/$@.pdb
output any program debug information to the specified file ($(XDCCFGDIR) is usually package/cfg)
config Win32.platform  // module-wide

The default platform name for this target

XDCscript usage meta-domain
Win32.platform = String "host.platforms.PC";
DETAILS
Build scripts often build for just one platform per target. This parameter allows one to establish a default platform for each target in a build.
If this parameter is null or undefined and platforms array is non-empty, it is initialized to be the first element of the platforms array (i.e., platforms[0]).
config Win32.platforms  // module-wide

A set of platforms that can support this target

XDCscript usage meta-domain
Win32.platforms = String[] [ ];
DETAILS
Some build scripts build executables for "all" platforms; e.g., regression test suites. This parameter allows one to establish a set of platforms that build scripts can legitimately use to create executables, for example.
If this array is empty (i.e., has length 0) and platform is non-null, platforms is initialized to an array of one element equal to platform.
config Win32.profiles  // module-wide

Standard options profiles are overwritten because we can't use 'MTs' and -D_DEBUG=1. Both of them added the debug version of the C runtime library to the manifest

XDCscript usage meta-domain
Win32.profiles = ITarget.OptionSet[string] [
    [
        "debug",
        {
            compileOpts: {
                copts: "-Z7 -Odi -MT",
                defs: ""
            },
            linkOpts: "-debug "
        }
    ],
    [
        "release",
        {
            compileOpts: {
                copts: "-O2 -MT",
                defs: ""
            },
            linkOpts: ""
        }
    ]
];
DETAILS
A profile is a collection of tool options used to create a library or executable that supports a certain "flavor" of library or executable; e.g., "debug" or "release".
Some profile names are supported by all targets even though the targets use different compilers (and therefore different options). These profile names makes it possible for a package to build libraries or executables in a "debug" (or "release") profile independent of the target, for example.
All targets are required to support "debug" and "release" profile names.
Profile options are added to beginning of any goal specific options specified by the user before being passed to the target.
config Win32.rootDir  // module-wide

Installation directory for this target's code generation tools

XDCscript usage meta-domain
Win32.rootDir = String undefined;
DETAILS
Since each target potentially "wraps" a different compiler tool-chain and each tool-chain will, in general, assume a different physical design for the installation of the compiler and its associated libraries and headers, one must consult each specific target to know how to set this parameter.
If the base parameter is null, this parameter *must* be set by the user; otherwise, rootDir defaults to the value base.rootDir.
config Win32.strictANSI  // module-wide

Disable Microsoft C/C++ language extensions

XDCscript usage meta-domain
Win32.strictANSI = Bool true;
DETAILS
Set to true if you plan to port your program to other environments. The compiler treats extended keywords as simple identifiers, disables the other Microsoft extensions, and automatically defines the __STDC__ predefined macro for C programs. This option shows up as "-Za" on the command line when strictANSI is set to true.
config Win32.vcPath  // module-wide

Location of the compiler, additional DLLs, and Platform SDK installation

XDCscript usage meta-domain
Win32.vcPath = Win32.VCPath[string] [
    [
        "VC6",
        {
            compilerDir: "vc98",
            dllPath: "common/msdev98/bin",
            sdkPath: "",
            libs: " msvcrt.lib setargv.obj oldnames.lib ole32.lib oleaut32.lib olepro32.lib uuid.lib kernel32.lib user32.lib gdi32.lib advapi32.lib shell32.lib comctl32.lib mfc42.lib msvcirt.lib"
        }
    ],
    [
        "VC7",
        {
            compilerDir: "Vc7",
            dllPath: "Common7/IDE;VisualStudio.NETProfessional-English",
            sdkPath: "Vc7/PlatformSDK",
            libs: " msvcrt.lib setargv.obj oldnames.lib ole32.lib oleaut32.lib olepro32.lib uuid.lib kernel32.lib user32.lib gdi32.lib advapi32.lib shell32.lib comctl32.lib mfc70.lib msvcirt.lib"
        }
    ],
    [
        "VC8",
        {
            compilerDir: "VC",
            dllPath: "Common7/IDE",
            sdkPath: "VC/PlatformSDK",
            libs: " msvcrt.lib setargv.obj oldnames.lib ole32.lib oleaut32.lib olepro32.lib uuid.lib kernel32.lib user32.lib gdi32.lib advapi32.lib shell32.lib comctl32.lib"
        }
    ]
];
DETAILS
This parameter is a map that contains information about paths to DLLs needed for building applications, and paths to the optional Platform SDK. Keys in the map are user-selected aliases for different Visual C/C++ releases. The values are VCPath objects. This parameter can be set only in config.bld, together with rootDir. If vcPath is not set in rootDir, the default values specified below are used. After a user sets this target's rootDir, XDCtools search through the values in vcPath, looking for a field compilerDir whose content matches a name of a subdirectory in rootDir. Once a match is found, the content of that element of the map is used to find a path to required DLLs, a path to Platform SDK and a list of libraries.
EXAMPLES
If the content of vcPath, set in config.bld is
      Win32.vcPath = [ 
          ["Visual Studio 7", 
              { 
                  compilerDir: "Vc7", 
                  dllPath: "Common7/IDE;VisualStudio.NETProfessional-English", 
                  sdkPath: "C:/PlatformSDK", 
                  libs: " msvcrt.lib setargv.obj oldnames.lib ole32.lib oleaut32.lib olepro32.lib uuid.lib kernel32.lib user32.lib gdi32.lib advapi32.lib shell32.lib comctl32.lib mfc70.lib msvcirt.lib" 
              } 
          ], 
          ["Visual Studio C++ 2005", 
              { 
                  compilerDir: "VC", 
                  dllPath: "Common7/IDE", 
                  sdkPath: "VC/PlatformSDK", 
                  libs: " msvcrt.lib setargv.obj oldnames.lib ole32.lib oleaut32.lib olepro32.lib uuid.lib kernel32.lib user32.lib gdi32.lib advapi32.lib shell32.lib comctl32.lib" 
              } 
          ] 
      ]; 
and the rootDir for the target Win32 is set to "C:/Program Files/Microsoft Visual Studio 8", XDCtools will first check if there is a directory "Vc7" under rootDir. If the directory is not found, the next element in the map and its compilerDir field are queried. In this case, the next element's compilerDir is "VC". If that directory is found under rootDir, the other fields in that element are used as follows: compilerDir and dllPath are added to the environment variable PATH. The contents of sdkPath and libs are added to appropriate command lines.
If none of the elements in the map has compilerDir that corresponds to a subdirectory in rootDir, the configuration fails.
Once a user sets up vcPath with all available installations of Visual Studio, simply by switching rootDir for this target, the right component of vcPath will be selected.
The default version of this parameter contains settings for several Visual Studio releases. Therefore, a user does not have to completely redefine vcPath. Only the fields that corresponds to settings that differ between user's configuration and the default configuration need to be changes. For example, if the only difference between the default configuration and a user's environment is that the user installed Platform SDK to be used with Visual C/C++ 8 in a different directory, only that field needs to be changed.
      var Win32 = xdc.module('microsoft.targets.Win32'); 
      Win32.vcPath["VC8"].sdkPath = "C:/WindowsSDK"; 
If Platform SDK is not installed, sdkPath should be empty and the libraries from Platform SDK should be removed from 'libs':
      var Win32 = xdc.module('microsoft.targets.Win32'); 
      Win32.vcPath = [ 
          ["VC8", 
              { 
                  compilerDir: "VC", 
                  dllPath: "Common7/IDE", 
                  sdkPath: "", 
                  libs: " msvcrt.lib setargv.obj oldnames.lib" 
              } 
          ], 
      ]; 
config Win32.version  // module-wide

The Compatibility Key associated with this target

XDCscript usage meta-domain
Win32.version = String undefined;
DETAILS
The first two components of this target Compatibility Key are '1,0'. The rest of the Key represents the compiler version. The third component combines the major and the minor version number in the format Major.Minor. The fourth component is the build number.
READONLY
This value is automatically computed by the XDC Build Engine by executing the getVersion() function after package.bld completes but prior to generating package.mak.
EXAMPLE
If this target's rootDir points to the Visual C++ 2005 Express Edition, the output of the command cl may contains the compiler version string 14.00.50727.42. The Compatibility Key is [1,0,14.00,50727].
config Win32.versionMap  // module-wide

Map of compiler version numbers to compatibility keys

XDCscript usage meta-domain
Win32.versionMap = String[string] [ ];
DETAILS
versionMap is a user modifiable table used to map tool-chain version numbers to Compatibility Keys.
Each target defines the format of the tool-chain version obtained from the tool-chain. The user can then map new tool-chain version strings to an appropriate compatibility key.
Each target must respect the mapping defined by this table; i.e., if the user supplies a compatibility key in this map, it must be returned when getVersion() is called.
Thus, it is possible for the user to assert that any two compiler tool chains should be treated as equivalent (or incompatible) by mapping their version numbers to identical (incompatible) compatibility keys.
SEE
Win32.archive()  // module-wide

Create an archive

XDCscript usage meta-domain
Win32.archive(ITarget.ArchiveGoal* goal) returns ITarget.CommandSet*
ARGUMENTS
goal — the ArchiveGoal defining the archive to build.
DETAILS
This function is called during makefile generation to convert build goals into specific commands that generate the specified goal.
RETURNS
This function returns a CommandSet. If non-null, this object defines the commands that must be executed to create the specified object file. If null, then goal can not be achieved.
THROWS
Error exceptions are thrown for fatal errors.
Win32.compile()  // module-wide

Compile a source file into an object file

XDCscript usage meta-domain
Win32.compile(ITarget.CompileGoal* goal) returns ITarget.CommandSet*
ARGUMENTS
goal — a CompileGoal that specifies what file to compile, the output file name, and any goal-specific options to use
DETAILS
This function is called during makefile generation to convert build goals into specific commands that generate the specified object file goal.
RETURNS
This function retuns a CommandSet. If non-null, this object defines the commands that must be executed to create the specified object file. If null, then goal can not be achieved.
THROWS
Error exceptions are thrown for fatal errors.
Win32.findSuffix()  // module-wide

Find the suffix that is compatible with this target

XDCscript usage meta-domain
Win32.findSuffix(Any pkg) returns Any
ARGUMENTS
pkg — a package object or an array of target suffix strings (see suffix).
DETAILS
This function determines the list of targets supported by the package given as the argument. From that list, this function returns the suffix of a target that is compatible with this target. Compatibility in this case means that object files created by a target having the suffix returned by this function can be linked into an executable produced using this target. In the case where more than one suffix is compatible, this function returns a suffix in the following order of preference:
  1. if this target's suffix is in the list, that suffix is returned.
  2. suffixes from compatibleSuffixes are matched against the list from the first to the last, and the first one with the match is returned.
RETURNS
This function returns the suffix string of a target compatible with this target or null if pkg does not support any target compatible with this target.
Win32.getISAChain()  // module-wide

Get this target's ISA "is compatible with" relation

XDCscript usage meta-domain
Win32.getISAChain(Any isa) returns Any
ARGUMENTS
isa — the ISA identifier string for the ISA to lookup; if null then the target's ISA is used (ITarget.isa).
DETAILS
Returns an array of ISA names (including this target's ISA) that represents the "is a" relation between ISA's. The array starts with the most general ISA and ends with this target's ISA or with the optionally specified argument. This relation is used to:
  1. pre-define macro definitions that enable code to be conditionally compiled based on compatible versions of a target's ISA.
  2. locate appropriate source files during makefile generation; each ISA named in a chain causes the extensions ".s"isa to be added to the ITarget.extensions table (in the reverse order that they appear in the chain). For example, if a target's ISA is "64P" and the returned chain is ["62", "64", "64P"], the following assembly language suffixes are added to the target's extensions table: ".s64P", ".s64", ".s62".
  3. determine the assembly language suffix used during legacy BIOS configuration; the first element of the target's ISA chain defines the suffix. For example, if a target's ISA is "64P" and the returned chain is ["62", "64", "64P"], the assembly suffix is ".s62".
This relation may also be used in the future to help validate combinations of targets and platforms; a target's CPU ISA must appear on the chain specified by the platform's CPU ISA.
RETURNS
This function returns an array of ISA strings where the last string is the optionally specified ISA string or this target's ISA, and the first string is the "base" ISA in the is source compatible" relationship. If the specified ISA string is not in this target's chain of compatible targets, null is returned.
THROWS
Error exceptions are thrown for fatal errors.
Win32.getVersion()  // module-wide

Get a target-specific Compatibility Key string

XDCscript usage meta-domain
Win32.getVersion() returns String
DETAILS
This function is called during makefile generation to obtain a target-specific Compatibility Key string. This string is of the form:
      "<pkg>.<mod>{<d0>,<d1>,<d2>,<d3>"
where, <pkg>.<mod> is the name of the target, and <d0>, <d1>, etc. forms a Compatibility Key.
RETURNS
This function returns a string that encodes the name of the target and its Compatibility Key.
THROWS
Error exceptions are thrown for fatal errors.
Win32.link()  // module-wide

Link object files to produce an executable

XDCscript usage meta-domain
Win32.link(ITarget.LinkGoal* goal) returns ITarget.CommandSet*
ARGUMENTS
goal — a LinkGoal that specifies the output file name, a list of files to link with, and any goal-specific options to use
DETAILS
This function is called during makefile generation to convert build goals into specific commands that generate the specified goal.
RETURNS
This function returns a CommandSet. If non-null, this object defines the commands that must be executed to create the specified object file. If null, then goal can not be achieved.
THROWS
Error exceptions are thrown for fatal errors.
Win32.scompile()  // module-wide

Compile a source file into an assembly language file

XDCscript usage meta-domain
Win32.scompile(ITarget.CompileGoal* goal) returns ITarget.CommandSet*
ARGUMENTS
goal — a CompileGoal that specifies what file to compile, the output file name, and any goal-specific options to use
DETAILS
This function is called during makefile generation to convert build goals into specific commands that generate the specified assembly language source goal.
RETURNS
This function returns a CommandSet. If non-null, this object defines the commands that must be executed to create the specified assembly language file. If null, then goal can not be achieved or is unnecessary (e.g., because the source file is already an asm file).
THROWS
Error exceptions are thrown for fatal errors.
Win32.selectSuffix()  // module-wide

Select the suffix that is compatible with this target

XDCscript usage meta-domain
Win32.selectSuffix(String[] suffixList) returns String
ARGUMENTS
suffixList — an array of target suffix strings (see suffix).
DETAILS
From a list of suffixes supplied as an argument, this function returns the suffix compatible with this target. Compatibility in this case means that object files created by a target having the suffix returned by this function can be linked into an executable produced using this target. In the case where more than one suffix is compatible, this function returns a suffix in the following order of preference:
  1. if this target's suffix is in the list, that suffix is returned.
  2. suffixes from compatibleSuffixes are matched against the list from the first to the last, and the first one with the match is returned.
RETURNS
This function returns the suffix string of a target compatible with this target or null if no such suffix is found in the list of suffixes specified by the first argument.
Win32.setPath()  // module-wide

Return path needed to find necessary DLLS

XDCscript usage meta-domain
Win32.setPath() returns Any
DETAILS
The microsoft compilers often require one or more directories to be in the PATH; this allows the compiler to find necessary DLLs. A target implementing this function returns a string with path components separated by ";".
generated on Tue, 24 Aug 2010 15:39:50 GMT