Shared Source JScript 8.0 Compiler

The @ option lets you specify a file that contains compiler options and source code files to compile. These compiler options and source code files will be processed by the compiler just as if set out on the command line.

To specify more than one response file in a compilation, specify multiple response file options. For example:

@file1.rsp @file2.rsp

In a response file, multiple compiler options and source code files can appear on one line. A single compiler option specification must appear on one line (it cannot span multiple lines).

Response files can have comments that begin with the # symbol.

Specifying compiler options from within a response file is just like making those commands on the command line.

The compiler processes command options as they are encountered. Therefore, the options in one response file might be incompatible with the options in another response file or the command line options. This can generate errors.

Response files cannot be nested. You cannot place @response_file inside a response file. The JScript compiler reports an error for such cases. 

For example, the following are a few lines from a sample response file:

# build the first output file
/target:exe /out:MyExe.exe source1.js source2.js

This option causes the compiler to display a list of compiler options along with a brief description of each option.

Option Values

+ | -

/autoref is on by default, unless /nostdlib+ is specified. Specifying /autoref+, or just /autoref, causes the compiler to automatically reference assemblies based on imported namespaces and fully qualified names.

The /autoref option instructs the compiler to reference assemblies without having to pass the assembly to /reference. When you use import to import a namespace, or you use a fully qualified type name in your code, the JScript compiler searches for an assembly that contains the type. See /lib for a discussion of how the JScript compiler searches for assemblies.

The compiler does not try to reference an assembly if it has the same name as the output file of the program you are building.

The following program will compile and run when /autoref+ is in effect; the compiler will reference System.dll as a result of the type annotation when declaring a variable.

var s: System.Collections.Specialized.StringCollection = 
                   new System.Collections.Specialized.StringCollection();
print(s);

The following program will compile and run when /autoref+ is in effect; the compiler will reference System.dll as a result of the import statement.

import System;
var s = new System.Collections.Specialized.StringCollection();
print(s);

These examples also show how the compiler looks for assembly names based on type annotation or import statements. When the compiler did not find an assembly called System.Collections.Specialized.dll that contained StringCollection, it looked for System.Collections.dll. Failing to find that file, it looked for System.dll, which it did find to contain StringCollection.

If you compile one or more source code files that when created did not designate use of the default code page on your computer, you can use the /codepage option to specify which code page should be used. /codepage applies to all source code files in your compilation.

If the source code files were created with the same codepage that is in effect on your computer or if the source code files were created with UNICODE or UTF-8, you need not use /codepage.

The /define option defines names as symbols in your program.

You can define multiple symbols with /define by using a comma to separate symbol names. For example:

/define:DEBUG,trace=true,max_Num=100

/d is the short form of /define.

Compile with /define:.

print("testing")
/*@cc_on @*/
/*@if (@xx)
print("xx defined")
@else @*/
print("xx not defined")
/*@end @*/

Option values:

+ | -

/fast is on by default. /fast or /fast+ causes the compiler to generate an output file that is speed-optimized; however, if this option is used certain language features from previous versions will not be supported. Specifying /fast-, on the other hand, will provide for backward language compatibility, but the compiler will produce an output file that is not optimized for speed.

When /fast is in effect:

• All variables must be declared.
• Functions become constants and you cannot assign to them or redefine them.
• Predefined properties of built-in objects are marked DontEnum, DontDelete, and ReadOnly.
• Properties on the built-in objects cannot be expanded, other than the Global object (which is also the global scope).
• The arguments variable is not available within function calls.
• Assignments to read-only variables, fields, or methods generate errors.

This option causes the compiler to display a list of compiler options along with a brief description of each option.

Option values:

dir1

A directory for the compiler to look in if a referenced assembly is not found in the current working directory (the directory from which the compiler is invoked) or in the CLI implementation assembly directory.

dir2

One or more additional directories for searching for assembly references. Separate additional directory names with a comma or semicolon.

The /lib option specifies the location of assemblies referenced through the /reference option.

The compiler searches for assembly references that are not fully qualified in the following order:

1. The current working directory. This is the directory from which the compiler is invoked.
2. The common language runtime system directory.
3. Directories specified by /lib.
4. Directories specified by the LIB environment variable.

Use /reference to specify an assembly reference.

/lib is additive; specifying it more than once appends to any prior values.

For example, compile t2.js to create an .exe. The compiler will look in the working directory and in the root directory of the C drive for assembly references.

jsc /lib:c:\ /reference:t2.dll t2.js

Option values:

filename

The resource file to link to the assembly.

name[,public|private](optional)

The logical name for the resource; the name used to load the resource. The default is the name of the file. Optionally, you can specify whether the file is public or private in the assembly manifest. For example, /linkres:filename.res,myname.res,public. By default, filename is public in the assembly.

The /linkresource option does not embed the resource file in the output file. Use the /resource option to embed a resource file in the output file.

If filename is a managed resource created by the Resource File Generator, for example, it can be accessed with members in the System.Resources namespace.

/linkres is the short form of /linkresource.

For example, compile in.js and link to resource file rf.resource:

jsc /linkresource:rf.resource in.js

The /nologo option suppresses display of the banner when the compiler starts.

Option values:

+ | -

The /nostdlib or /nostdlib+ option causes the compiler to not import mscorlib.dll. Use this option if you want to define or create your own System namespace and objects. If you do not specify /nostdlib, mscorlib.dll will be imported into your program (as when you specify /nostdlib-).

Specifying /nostdlib+ also specifies /autoref-.

For example, if you have a component called System.String (or any other name in mscorlib) could only access your component using

/nostdlib /r:your_library,mscorlib 

to search your library before mscorlib. Typically, you would not define a namespace in your application called System.

The /out option specifies the name of the output file. The compiler expects to find one or more source code files following the /out option.

If you do not specify the name of the output file:

• An .exe file will take its name from the first source code file used to build the output file.
• A .dll file will take its name from the first source code file used to build the output file.

On the command line, it is possible to specify multiple output files for a compilation. All source code files specified after an /out option will be compiled into the output file specified by that /out option.

Specify the full name and extension of the file you want to create. The extension must be either .exe or .dll. It is possible to specify a .dll extension for /t:exe projects.

For example, compile t2.js, create output filet2.exe, and build t3.js and create output file t3.exe:

jsc t2.js /out:t3.exe t3.js

Option values:

+ | -

By default, /print or /print+ causes the compiler to enable the use of the print statement. An example of a print statement is,

print("hello world"); 

Specifying /print- will disable the print command.

You should use /print- if your DLL will be loaded into an environment that does not have a console.

You can set Microsoft.JScript.ScriptStream.Out to be an instance of a TextWriter object to enable print to send output elsewhere.

The /reference option directs the compiler to make public type information in the specified files available to the project you are currently compiling.

The file or files you reference must be assemblies.

/reference cannot take a module as input.

Although executable files can be referenced as assemblies it is not recommended that shared, referenced code be stored in executable assemblies.  Instead, place the shared code in an assembly library.

If you reference an assembly (Assembly A), which itself references another assembly (Assembly B), you will need to reference Assembly B if:

• A type you use from Assembly A inherits from a type or implements an interface from Assembly B.
• You invoke a field, property, event, or method that has a return type or parameter type from Assembly B.

Use /lib to specify the directory in which one or more of your assembly references is located.

/r is the short form of /reference.

For example, compile source file input.js and import metadata from metad1.dll and metad2.dll to produce out.exe:

jsc /reference:metad1.dll;metad2.dll /out:out.exe input.js

Option values:

filename

The resource file you want to embed in the output file.

name[,public|private](optional)

The logical name for the resource; the name used to load the resource. The default is the name of the file.

Optionally, you can specify whether the file is public or private in the assembly manifest. For example, /res:filename.res,myname.res,public. By default, filename is public in the assembly.

Use the /resource option to link a resource to an assembly and not place the resource file in the output file.

If filename is a managed resource file created, for example, by Resgen, it can be accessed with members in the System.Resources namespace.  For more information, see System.Resources.ResourceManager.

/res is the short form of /resource.

For example, compile in.js and attach resource file rf.resource:

jsc /res:rf.resource in.js

Causes a .NET Framework assembly manifest to be placed in a specified type of binary output file.

If you create an assembly, you can indicate that all or part of your code is CLS-compliant with the CLSCompliantAttribute class attribute.

import System;
[assembly:System.CLSCompliant(true)]   // Specify assembly compliance.

System.CLSCompliant(true) class TestClass   // Specify compliance for element.
{
   var i: int;
}

The /target:exe option causes the compiler to create an executable (EXE), console application. The /target:exe option is in effect by default. The executable file will be created with the .exe extension.

Unless otherwise specified with the /out option, the output file name takes the name of the first source code file in the compilation for each output file.

When specified at the command line, all files up to the next /out or /target:library option are used to create the .exe. The /target:exe option is in effect for all files following the previous /out or /target:library option.

The /target:library option causes the compiler to create a DLL rather than an EXE. The DLL will be created with the .dll extension.

Unless otherwise specified with the /out option, the output file name takes the name of the first input file.

When specified at the command line, all source files up to the next /out or /target:exe option are used to create the DLL.

This information is ignored by the Shared Source implementation of the CLI.  However, if the application is executed under the .NET Framework, this option will have an effect on the Windows loader. 

For more information on the console or Windows subsystem setting see msdn.microsoft.com and search for "console subsystem".

Use /target:exe to create a console application.

Option values:

+ | -

By default /utf8output- displays output directly to the console. Specifying /utf8output or /utf8output+ redirects compiler output to a file.

In some international configurations, compiler output cannot correctly be displayed to the console. In these configurations, use /utf8output and redirect compiler output to a file.

The default for this option is /utf8output-.

Specifying /utf8output is equivalent to specifying /utf8output+.

Option values:

+ | -

By default, /versionsafe- is in effect and the compiler will not generate an error if it finds an implicit method override. /versionsafe+, which is equivalent to /versionsafe, causes the compiler to generate errors for implicit method overrides.

Use the hide or override keywords to explicitly indicate the override status of a method. For example, the following code will generate an error when compiled with /versionsafe:

class c
{
function f()
{
}
}
class d extends c 
{
function f()
{
}
}

The /warn option specifies the warning level for the compiler to display.
Use /warnaserror to treat all warnings as errors up to the warning level specified. Higher-level warnings are ignored. 

The compiler always displays errors. 

/w is the short form of /warn.

Valid values are 0-4.

Any messages that would ordinarily be reported as warnings are instead reported as errors. No output files are created. The build continues in order to identify as many errors and warnings as possible.

By default, /warnaserror- is in effect, which causes warnings to not prevent the generation of an output file. /warnaserror, which is equivalent to /warnaserror+, causes warnings to be treated as errors.

Use /warn to specify the level of warnings that you want the compiler to display.