Man mcs

Added: 02.2008

mcs(1)                                                                 mcs(1)

NAME mcs, gmcs, smcs - Mono C# Compiler (1.0, 2.0, Moonlight)

SYNOPSIS mcs [option] [source-files]

DESCRIPTION mcs is the Mono C# compiler, an implementation of the ECMA-334 language specification. You can pass one or more options to drive the compiler, and a set of source files. Extra options or arguments can be provided in a response file. Response files are referenced by prepending the @ symbol to the response file name.

The mcs compiler is used to compile against the 1.x profile and imple&#8208; ments C# 1.0 and 2.0 with the exception of generics and nullable types.

The gmcs compiler is used to compile against the 2.0 profile and imple&#8208; ments the complete C# 2.0 specification including generics.

The smcs compiler is used to compile against the Silverlight/Moonlight profile. This profile  is  designed  to  be  used  for creating Sil&#8208; verlight/Moonlight applications that will run on a web browser. The API exposed  by this profile is a small subset of the 2.0 API (even if       it is commonly referred as the 2.1 API, this API is a small  subset  of       2.0  with  a  few extensions), in addition this profile by default runs with -langversion:linq which turns on the C# 3.0 language by default.

The Mono C# compiler accepts the same command line  options  that  the Microsoft C# compiler does. Those options can start with a slash or a      dash (/checked is the same as -checked). Additionally some  GNU-like options are  supported, those begin with "--". All MCS-specific flags which are not available in the Microsoft C# compiler are available only with the GNU-style options.

C# source  files  must  end with a ".cs" extension. Compilation of C#      source code requires all the files that make up a  library,  module  or       executable to be provided on the command line. There is no support for partial compilation. To achieve the benefits of partial  compilation, you should compile programs into their own assemblies, and later refer&#8208; ence them with the "-r" flag.

The Mono C# compiler generates images (.exe files)  that  contain  CIL byte code  that can be executed by any system that implements a Common Language Infrastructure virtual machine such as the Microsoft .NET run&#8208; time engine  on  Windows  or  the Mono runtime engine on Unix systems. Executables are not bound to a specific CPU or operating system.

The Mono C# compiler by  default  only  references  three  assemblies: mscorlib.dll, System.dll and System.Xml.dll. If you want to reference extra libraries you must manually specify them using the -pkg: command line option or the -r: command line option. Alternatively if you want to get all of the System libraries, you can use the -pkg:dotnet command line option.

OPTIONS --about Displays information about the Mono C# compiler

--addmodule:MODULE1[,MODULE2] Includes the specified modules in the resulting assembly.

-checked, -checked+ Sets the default compilation mode to `checked'. This makes all the math operations checked (the default is unchecked).

-checked- Sets the default compilation mode to `unchecked'. This makes all the math operations unchecked (this is the default).

-codepage:ID Specifies the code page used to process the input files from the point it is specified on. By default files will be processed in             the  environment-dependent  native code page. The compiler will also automatically detect Unicode files that have  an  embedded byte mark  at the beginning. Other popular encodings are 28591 (Latin1), 1252 (iso-8859-1) and 65001 (UTF-8). MCS supports  a              couple  of  shorthands:  "utf8"  can  be  used  to specify utf-8 instead of using the cryptic 65001  and  "reset"  restores  the automatic handling  of  code  pages. These shorthands are not available on the Microsoft compiler.

-define:SYMLIST, -d:SYMLIST Defines the symbol listed by the semi-colon separated list SYM&#8208; LIST SYMBOL. This can be tested in the source code by the pre- processor, or can be used by methods that have been tagged with the Conditional attribute.

-debug, -debug+, -g Generate debugging  information. To obtain stack traces with debugging information, you need to invoke the mono runtime with the `--debug' flag. This debugging information is stored inside the assembly as a resource.

-debug- Do not generate debugging information.

-delaysign+ Only embed the strongname public key  into  the  assembly. The actual signing must be done in a later stage using the SN tool. This is useful to protect the private key  during  development. Note that delay signing can only be done using a strongname key file (not a key container). The option is equivalent to includ&#8208; ing [assembly:  AssemblyDelaySign  (true)] in your source code. Compiler option takes precedence over the attributes.

-delaysign- Default. Strongname (sign) the assembly using the  strong  name key file  (or container). The option is equivalent to including [assembly: AssemblyDelaySign (false)] in your source code. Com&#8208; piler option takes precedence over the attributes.

-doc:FILE Extracts the  C#/XML  documentation  from  the  source code and stores in in the given FILE.

--expect-error X L             The compiler will expect the code to generate an error named `X' in line `L'. This is only used by the test suite.

--fatal This is  used for debugging the compiler. This makes the error emission generate an exception that can be caught by a debugger.

-keyfile:KEYFILE Strongname (sign) the output assembly using the key pair present in the specified strong name key file (snk). A full key pair is              required   by   default  (or  when  using  delaysign-). A file containing only the public key can be used with delaysign+. The option is  equivalent  to  including [assembly: AssemblyKeyFile ("KEYFILE")] in your source code. Compiler option takes prece&#8208; dence over the attributes.

-keycontainer:CONTAINER Strongname (sign) the output assembly using the key pair present in the specified container. Note that delaysign+ is ignored when using key  containers. The option  is equivalent to including [assembly: AssemblyKeyName ("CONTAINER")] in your source  code. Compiler option takes precedence over the attributes.

-langversion:TEXT The option  specifies  the  version of the language to use. The feature set is different in each C# version. This switch can be              used  to  force  the compiler to allow only a subset of the fea&#8208; tures. The possible values are:

Default Instruct compiler to use the latest version. Equivalent is to omit the switch (this currently defaults to the C#                     2.0 language specification).

ISO-1 Restrict compiler to use only first ISO standardized fea&#8208; tures. The usage  of features such as generics, static classes, anonymous methods will lead to error.

ISO-2 Restrict compiler to use only the second ISO standardized features. This allows  the  use  of  generics,  static classes, iterators and anonymous methods for example.

linq  This enables the C# 3.0 support. Only a few features of                    C#  3.0 have been implemented in the Mono C# compiler, so                     not everything is available.

Notice that this flag only controls the language features avail&#8208; able to  the programmer, it does not control the kind of assem&#8208; blies produced. Programs compiled with mcs will reference  the 1.1 APIs, Programs compiled with gmcs reference the 2.0 APIs.

-lib:PATHLIST Each path specified in the comma-separated list will direct the compiler to look for libraries in that specified path.

-L PATH Directs the compiler to look for  libraries  in  the  specified path. Multiple paths can be provided by using the option multi&#8208; ple times.

-main:CLASS Tells the compiler which CLASS contains the entry point. Useful when you are compiling several classes with a Main method.

-nostdlib, -nostdlib+ Use this  flag  if  you want to compile the core library. This makes the compiler load its internal types  from  the  assembly being compiled.

-noconfig, -noconfig+ Disables the  default compiler configuration to be loaded. The compiler by default has references to the system assemblies.

-nowarn:WARNLIST Makes the compiler ignore warnings specified in the comma-sepa&#8208; rated list WARNLIST>

-optimize, -optimize+, -optimize- Controls whether to perform optimizations on the code. -opti&#8208; mize and -optimize+ will turn on optimizations, -optimize- will turn it off. The default in mcs is to optimize+.

-out:FNAME, -o FNAME Names the output file to be generated.

--parse Used for  benchmarking. The compiler will only parse its input files.

-pkg:package1[,packageN] Reference assemblies for the given packages. The compiler will invoke pkg-config --libs on the set of packages specified on the command line to obtain libraries and directories to compile the code. This is typically used with third party components, like this:

$ mcs -pkg:gtk-sharp demo.cs

-pkg:dotnet This will instruct the compiler to reference the System.* libraries available on a typical dotnet framework instal&#8208; lation, notice that this does not include all of the Mono libraries, only the System.* ones. This is a convenient shortcut for those porting code.

-pkg:olive Use this to reference the "Olive" libraries (the 3.0 and                     3.5 extended libraries).

-pkg:silver References the  assemblies  for  creating Moonlight/Sil&#8208; verlight applications. This is automatically used  when using the  smcs compiler, but it is here when developers want to use it with the gmcs compiler.

-pkg:silverdesktop Use this option to create Moonlight/Silverlight applica&#8208; tions that  target  the  desktop. This option allows developers to consume the Silverlight APIs with the full 2.0 profile  API available to them, unlike smcs it gives full access to all the APIs that are part of Mono. The only downside  is  that  applications  created with sil&#8208; verdesktop will not run on the browser. Typically these applications will be launched with the mopen command line tool.

-resource:RESOURCE[,ID] Embeds to the given resource file. The optional ID can be used to give a different name to the resource. If not specified, the resource name will be the file name.

-linkresource:RESOURCE[,ID] Links to the specified RESOURCE. The optional ID can be used to             give a name to the linked resource.

-r:ASSEMBLY1[,ASSEMBLY2], -r ASSEMBLY1[,ASSEMBLY2] Reference the  named  assemblies. Use this to use classes from the named assembly in your program. The assembly will be loaded from either the system directory where all the assemblies live, or from the path explicitly given with the -L option.

You can also use a semicolon to separate the assemblies instead  of  a       comma.

-recurse:PATTERN, --recurse PATTERN Does recursive compilation using the specified pattern. In Unix the shell will perform globbing, so you might want  to  use  it              like this:

$ mcs -recurse:'*.cs'

--stacktrace Generates a stack trace at the time the error is reported, use&#8208; ful for debugging the compiler.

-target:KIND, -t:KIND Used to specify the desired target. The possible  values  are: exe  (plain  executable),  winexe  (Windows.Forms  executable), library (component libraries) and module (partial library).

--timestamp Another debugging flag. Used to display the times  at  various points in the compilation process.

-unsafe, -unsafe+ Enables compilation of unsafe code.

-v    Debugging. Turns on verbose yacc parsing.

-v2   Turns on C# 2.0 language features.

--version Shows the compiler version.

-warnaserror, -warnaserror+ Treat warnings as errors.

-warn:LEVEL Sets the warning level. 0 is the lowest warning level, and 4 is             the highest. The default is 2.

-win32res:FILE Specifies a Win32 resource file (.res) to be bundled  into  the resulting assembly.

-win32icon:FILE Attaches the  icon  specified  in  FILE  on the output into the resulting assembly.

--    Use this to stop option parsing, and allow option-looking param&#8208; eters to be passed on the command line.

SPECIAL DEFINES The TRACE and DEBUG defines have a special meaning to the compiler.

By default  calls  to  methods  and  properties in the System.Diagnos&#8208; tics.Trace class are not generated unless the TRACE symbol is  defined (either through a "#define TRACE") in your source code, or by using the --define TRACE in the command line.

By default calls to methods  and  properties  in  the  System.Diagnos&#8208; tics.Debug class  are not generated unless the DEBUG symbol is defined (either through a "#define DEBUG") in your source code, or by using the --define DEBUG in the command line.

Note that  the effect of defining TRACE and DEBUG is a global setting, even if they are only defined in a single file.

DEBUGGING SUPPORT When using the "-debug" flag, MCS will generate a file with the exten&#8208; sion .mdb  that  contains  the debugging information for the generated assembly. This file is consumed by the Mono debugger (mdb).

NOTES During compilation the MCS compiler defines the __MonoCS__ symbol, this can be  used by pre-processor instructions to compile Mono C# compiler specific code. Please note that this symbol is only to test for  the compiler, and  is  not useful to distinguish compilation or deployment platforms.

AUTHORS The Mono C# Compiler was written by Miguel de Icaza, Ravi Pratap, Mar&#8208; tin Baulig, Marek Safar and Raja Harinath. The development was funded by Ximian, Novell and Marek Safar.

LICENSE The Mono Compiler Suite is released under the terms of  the  GNU  GPL. Please read  the accompanying `COPYING' file for details. Alternative licensing for the compiler is available from Novell.

SEE ALSO mdb(1), mono(1), mopen(1), mint(1), sn(1)

BUGS To report bugs in the compiler, you must file them on our bug tracking system, at: http://www.mono-project.com/Bugs

MAILING LIST The Mono Mailing lists are listed at http://www.mono-project.com/Mail&#8208; ing_Lists

MORE INFORMATION The Mono C# compiler was developed  by  Novell,  Inc  (http://www.nov&#8208;       ell.com,  http) and is based on the ECMA C# language standard available here: http://www.ecma.ch/ecma1/STAND/ecma-334.htm

The home  page  for  the  Mono  C#  compiler  is  at  http://www.mono- project.com/CSharp_Compiler

6 January 2001                         mcs(1)