Man Linux: Main Page and Category List


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


       mcs [option] [source-files]


       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
       implements C# 1.0 and parts of C# 2.0 and C# 3.0 specification which do
       not depend on generics.

       The  gmcs  compiler  is  used  to  compile  against the 2.0 profile and
       implements the complete C# 3.0 specification.

       The smcs compiler is used to compile against the  Silverlight/Moonlight
       profile.    This   profile   is   designed  to  be  used  for  creating
       Silverlight/Moonlight applications that will  run  on  a  web  browser.
       The  API exposed by this profile is a small subset of the 3.5 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).

       See the section on packages for more information.

       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
       reference 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
       runtime 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.


              Displays information about the Mono C# compiler

              Includes  the  specified  modules  in  the  resulting  assembly.
              Modules   are   created   by   calling  the  compiler  with  the
              -target:module option

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

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

       -clscheck-, -clscheck+
              Disables or enables  the  Common  Language  Specification  (CLS)
              checks (it is enabled by default).

              The Common Language Specification (CLS) defines an interoperable
              subset of types as  well  as  conventions  that  compilers  (CLS
              producers)  and  developers  must follow to expose code to other
              programming languages (CLS consumers).

              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
              SYMLIST  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+
              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.

              Do not generate debugging information.

              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
              including  [assembly:  AssemblyDelaySign  (true)] in your source
              code. Compiler option takes precedence over the attributes.

              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.
              Compiler option takes precedence over the attributes.

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

              This flag is ignored by Mono's C# compiler and is  present  only
              to allow MCS to be used as a CSC replacement for msbuild/xbuild.

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

              This flag is ignored by Mono's C# compiler and is  present  only
              to allow MCS to be used as a CSC replacement for msbuild/xbuild.

              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
              precedence over the attributes.

              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.

              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
              features.  The possible values are:

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

              ISO-1  Restrict  compiler  to  use  only  first ISO standardized
                     features.  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.

              3      Restrict  the compiler to use only the features available
                     in C# 3.0 (a superset of ISO-1 and ISO-2).

              future Enables features from upcoming versions of the  language.
                     As of May 2009 this includes support for C# 4 as released
                     in Visual Studio 2010 beta 1.

              Notice that  this  flag  only  controls  the  language  features
              available  to  the  programmer,  it does not control the kind of
              assemblies produced.  Programs compiled with mcs will  reference
              the  1.1  APIs,  Programs  compiled  with gmcs reference the 2.0

              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
              multiple times.

              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.

              Makes  the  compiler  ignore  warnings  specified  in the comma-
              separated list WARNLIST>

       -optimize, -optimize+, -optimize-
              Controls  whether  to  perform  optimizations   on   the   code.
              -optimize  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.

              Used for benchmarking.  The compiler will only parse  its  input

              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

                     This will instruct the compiler to reference the System.*
                     libraries  available  on  a  typical   dotnet   framework
                     installation,  notice  that  this does not include all of
                     the Mono libraries, only the System.* ones.   This  is  a
                     convenient shortcut for those porting code.

                     Use  this to reference the "Olive" libraries (the 3.0 and
                     3.5 extended libraries).

                     References     the      assemblies      for      creating
                     Moonlight/Silverlight      applications.      This     is
                     automatically used when using the smcs compiler,  but  it
                     is  here  when  developers  want  to use it with the gmcs

                     Use   this   option   to   create   Moonlight/Silverlight
                     applications  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  silverdesktop  will  not  run   on   the   browser.
                     Typically  these  applications  will be launched with the
                     mopen command line tool.

              For more details see the PACKAGE section in this document

              Used to specify the target platform. The  possible  values  are:
              anycpu,  x86,  x64 or itanium. As of June 2009, the Mono runtime
              only have support to emit anycpu and x86 assemblies.

              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.

              Links to the specified RESOURCE.  The optional ID can be used to
              give a name to the linked resource.

       -r:ASSEMBLY1[,ASSEMBLY2], -reference 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.

              Extern alias reference support for C#.

              If  you  have  different assemblies that provide the same types,
              the extern alias support allows you to provide names  that  your
              software  can  use  to  tell  those  appart.     The  types from
              ASSEMBLY will be exposed as ALIAS, then on the C#  source  code,
              you need to do:

                   extern alias ALIAS;
              To bring it into your namespace.   For example, to cope with two
              graphics  libraries  that  define   "Graphics.Point",   one   in
              "OpenGL.dll"  and  one in "Postscript.dll", you would invoke the
              compiler like this:

                   mcs -r:Postscript=Postscript.dll -r:OpenGL=OpenGL.dll

              And in your source code, you would write:

                   extern alias Postscript;
                   extern alias OpenGL;

                   class X {
                        // This is a Graphics.Point from Postscrip.dll
                        Postscript.Point p = new Postscript.Point ();

                        // This is a Graphics.Point from OpenGL.dll
                        OpenGL.Point p = new OpenGL.Point ();

       -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'

              Starts up the compiler in interactive mode, providing a C# shell
              for  statements  and  expressions.    A  shortcut  is to use the
              csharp command directly.

              Generates a stack trace at  the  time  the  error  is  reported,
              useful 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).

              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.

              Shows the compiler version.

       -warnaserror, -warnaserror+
              All compilers warnings will be reported as errors.

       -warnaserror:W1,[Wn], -warnaserror+:W1,[Wn]
              Treats one or more compiler warnings as errors.

              Sets one or more compiler warnings  to  be  always  threated  as
              warnings.   Becomes useful when used together with -warnaserror.

              Sets the warning level.  0 is the lowest warning level, and 4 is
              the highest.  The default is 4.

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

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

       --     Use  this  to  stop  option  parsing,  and  allow option-looking
              parameters to be passed on the command line.


       When referencing an assembly, if the name of the assembly  is  a  path,
       the  compiler will try to load the assembly specified in the path.   If
       it does not, then the compiler will try loading the assembly  from  the
       current  directory,  the compiler base directory and if the assembly is
       not found in any of  those  places  in  the  directories  specified  as
       arguments to the -lib: command argument.

       Depending  on  the  invocation for the C# compiler (mcs, gmcs, or smcs)
       you will get a default set of libraries and versions of those libraries
       that are referenced.

       The  compiler uses the library path to locate libraries, and is able to
       reference libraries from a particular  package  if  that  directory  is
       used.   To  simplify  the use of packages, the C# compiler includes the
       -pkg: command line option that is used to load specific collections  of

       Libraries   visible   to  the  compiler  are  stored  relative  to  the
       installation prefix under PREFIX/lib/mono/ called the  PACKAGEBASE  and
       the defaults for mcs, gmcs and smcs are as follows:

       mcs    References the PACKAGEBASE/1.0 directory

       gmcs   References the PACKAGEBASE/2.0 directory

       smcs   References the PACKAGEBASE/2.1 directory

       Those  are  the  only  runtime  profiles  that  exist.   Although other
       directories exist (like 3.0 and  3.5)  those  are  not  really  runtime
       profiles,  they  are merely placeholders for extra libraries that build
       on the 2.0 foundation.

       Software providers will distribute software that is installed  relative
       to the PACKAGEBASE directory.  This is integrated into the gacutil tool
       that not only installs public assemblies into the Global Assembly Cache
       (GAC)  but also installs them into the PACKAGEBASE/PKG directory (where
       PKG is the name passed to the -package flag to gacutil).

       As a developer, if you want to consume the Gtk#  libraries,  you  would
       invoke the compiler like this:

            $ mcs -pkg:gtk-sharp-2.0 main.cs

       The  -pkg:  option  instructs the compiler to fetch the definitions for
       gtk-sharp-2.0 from pkg-config, this is equivalent to passing to the  C#
       compiler the output of:

            $ pkg-config --libs gtk-sharp-2.0

       Usually this merely references the libraries from PACKAGEBASE/PKG.

       Although  there are directory names for 3.0 and 3.5, that does not mean
       that there are 3.0 and 3.5 compiler editions or profiles.    Those  are
       merely  new  libraries that must be manually referenced either with the
       proper -pkg: invocation, or by referencing the libraries directly.


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

       By   default   calls    to    methods    and    properties    in    the
       System.Diagnostics.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.Diagnostics.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.


       When  using  the  "-debug"  flag,  MCS  will  generate  a file with the
       extension  .mdb  that  contains  the  debugging  information  for   the
       generated  assembly.  This file is consumed by the Mono debugger (mdb).


              If this variable is set,  it  contains  a  string  in  the  form
              "foreground,background"  that  specifies  which  color to use to
              display errors on some terminals.

              The background is optional and defaults to your terminal current
              background.    The  possible  colors  for foreground are: black,
              red, brightred, green, brightgreen, yellow, brightyellow,  blue,
              brightblue,  magenta,  brightmagenta,  cyan,  brightcyan,  grey,
              white and brightwhite.

              The possible colors  for  background  are:  black,  red,  green,
              yellow, blue, magenta, cyan, grey and white.

              For example, you could set these variable from your shell:
                   export MCS_COLORS

              You  can  disable  the  built-in  color  scheme  by setting this
              variable to "disable".


       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


       The Mono C# Compiler was written  by  Miguel  de  Icaza,  Ravi  Pratap,
       Martin  Baulig,  Marek  Safar  and  Raja Harinath.  The development was
       funded by Ximian, Novell and Marek Safar.


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


       csharp(1), mdb(1), mono(1), mopen(1), mint(1), pkg-config(1),sn(1)


       To report bugs in the compiler, you must file them on our bug  tracking
       system, at:


       The    Mono    Mailing    lists    are   listed   at   http://www.mono-


       The   Mono   C#    compiler    was    developed    by    Novell,    Inc
       (,  http)  and  is  based  on the ECMA C# language
       standard available here:

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

                                6 January 2001                          mcs(1)