dmcs - Online na nuvem

PROGRAMA:

NOME

mcs - Compilador Mono C #

SINOPSE

mcs [opção] [arquivos-fonte]

DESCRIÇÃO

mcs é o compilador Mono C #, uma implementação da especificação da linguagem ECMA-334.
Você pode passar uma ou mais opções para conduzir o compilador e um conjunto de arquivos de origem. Extra
opções ou argumentos podem ser fornecidos em um arquivo de resposta. Os arquivos de resposta são referenciados por
acrescentando o símbolo @ ao nome do arquivo de resposta.

A mcs compilador é usado para compilar com a versão mais recente da Mono Base Class Library e
implementa totalmente as especificações C # 1.0, 2.0, 3.0 e 4.0.

Veja a seção sobre pacotes para mais informações.

O compilador Mono C # aceita as mesmas opções de linha de comando que o compilador Microsoft C #
faz. Essas opções podem começar com uma barra ou hífen (/ checked é o mesmo que -checked).
Além disso, algumas opções do tipo GNU são suportadas, aquelas começam com "-". Todos específicos de MCS
sinalizadores que não estão disponíveis no compilador Microsoft C # estão disponíveis apenas com o
Opções de estilo GNU.

Os arquivos de origem C # devem terminar com uma extensão ".cs". A compilação do código-fonte C # requer
todos os arquivos que compõem uma biblioteca, módulo ou executável a ser disponibilizado no comando
linha. Não há suporte para compilação parcial. Para alcançar os benefícios da parcial
compilação, você deve compilar programas em seus próprios assemblies, e referência posterior
-los com o sinalizador "-r".

O compilador Mono C # gera imagens (arquivos .exe) que contêm código de byte CIL que pode ser
executado por qualquer sistema que implemente uma máquina virtual de infraestrutura de linguagem comum
como o mecanismo de tempo de execução Microsoft .NET no Windows ou o mecanismo de tempo de execução Mono no Unix
sistemas. Os executáveis ​​não estão vinculados a uma CPU ou sistema operacional específico.

O compilador Mono C # por padrão faz referência apenas a três assemblies: mscorlib.dll, System.dll
e System.Xml.dll. Se você quiser fazer referência a bibliotecas extras, você deve especificar manualmente
-pkg: opção de linha de comando ou -r: opção de linha de comando. Alternativamente se
você deseja obter todas as bibliotecas do sistema, você pode usar a linha de comando -pkg: dotnet
opção.

OPÇÕES

--sobre
Exibe informações sobre o compilador Mono C #

--addmodule: MODULE1 [, MODULE2]
Inclui os módulos especificados na montagem resultante. Módulos são criados por
chamando o compilador com a opção -target: module

-verificado, -marcado +
Define o modo de compilação padrão para "verificado". Isso torna todas as operações matemáticas
marcada (o padrão é desmarcado).

-verificado-
Define o modo de compilação padrão como `desmarcado '. Isso torna toda a matemática
operações desmarcadas (este é o padrão).

-clscheck-, -clscheck +
Desativa ou ativa as verificações de Common Language Specification (CLS) (está ativado
por padrão).

A Common Language Specification (CLS) define um subconjunto interoperável de tipos como
bem como as convenções que compiladores (produtores CLS) e desenvolvedores devem seguir para
expor o código a outras linguagens de programação (consumidores CLS).

-codepage: ID
Especifica a página de código usada para processar os arquivos de entrada do ponto em que é
especificado em. Por padrão, os arquivos serão processados ​​no ambiente dependente
página de código nativa. O compilador também detectará automaticamente os arquivos Unicode que
tem uma marca de byte incorporada no início.

Outras codificações populares são 28591 (Latin1), 1252 (iso-8859-1) e 65001 (UTF-8).

MCS suporta alguns atalhos: "utf8" pode ser usado para especificar utf-8 em vez de
usando o cryptic 65001 e "reset" restaura a manipulação automática de páginas de código.
Essas abreviações não estão disponíveis no compilador da Microsoft.

-define: SYMLIST, -d: SYMLIST
Define o símbolo listado pela lista separada por ponto e vírgula SYMLIST SYMBOL. Esse
pode ser testado no código-fonte pelo pré-processador ou pode ser usado por métodos
que foram marcados com o atributo Condicional.

-depurar, -debug +
Gere informações de depuração. Para obter rastreamentos de pilha com informações de depuração,
você precisa invocar o tempo de execução mono com o sinalizador `--debug '. A depuração
as informações são armazenadas em um arquivo MDB localizado na mesma pasta de saída produzida
montagem.

-depurar-
Não gere informações de depuração.

-delaysign +
Incorpore apenas a chave pública de nome forte no assembly. A assinatura real deve ser
feito em um estágio posterior usando a ferramenta SN. Isso é útil para proteger a chave privada
durante o desenvolvimento. Observe que a assinatura atrasada só pode ser feita usando uma chave de nome forte
arquivo (não um contêiner de chave). A opção é equivalente a incluir [assembly:
AssemblyDelaySign (true)] em seu código-fonte. A opção do compilador tem precedência
sobre os atributos.

-sinal de atraso-
Predefinição. Nome forte (assinar) o conjunto usando o arquivo de chave de nome forte (ou
recipiente). A opção é equivalente a incluir [assembly: AssemblyDelaySign
(false)] em seu código-fonte. A opção do compilador tem precedência sobre os atributos.

-doc: FILE
Extrai a documentação C # / XML do código-fonte e armazena no
ARQUIVO.

-errorreportar
Este sinalizador é ignorado pelo compilador C # do Mono e está presente apenas para permitir que o MCS seja
usado como um substituto do CSC para msbuild / xbuild.

--fatal
Isso é usado para depurar o compilador. Isso faz com que a emissão de erro gere um
exceção que pode ser detectada por um depurador.

-filealign
Este sinalizador é ignorado pelo compilador C # do Mono e está presente apenas para permitir que o MCS seja
usado como um substituto do CSC para msbuild / xbuild.

-caminhos completos
Qualquer erro de código-fonte ou aviso emitido pelo compilador inclui o nome do arquivo apenas por
predefinição. Esta opção faz com que o compilador emita o caminho do arquivo absoluto.

-keyfile: KEYFILE
Nome forte (sinal) o conjunto de saída usando o par de chaves presente no especificado
arquivo de chave de nome forte (snk). Um par de chaves completo é necessário por padrão (ou ao usar
delaysign-). Um arquivo contendo apenas a chave pública pode ser usado com delaysign +. o
opção é equivalente a incluir [assembly: AssemblyKeyFile ("KEYFILE")] em seu
Código fonte. A opção do compilador tem precedência sobre os atributos.

-keycontainer: CONTAINER
Nome forte (sinal) o conjunto de saída usando o par de chaves presente no especificado
recipiente. Observe que delaysign + é ignorado ao usar recipientes de chave. A opção é
equivalente a incluir [assembly: AssemblyKeyName ("CONTAINER")] em sua fonte
código. A opção do compilador tem precedência sobre os atributos.

-langversion: TEXT
A opção especifica a versão do idioma a ser usado. O conjunto de recursos é
diferente em cada versão C #. Esta opção pode ser usada para forçar o compilador a
permitir apenas um subconjunto dos recursos. Os valores possíveis são:

Padrão
Instrua o compilador a usar a versão mais recente. Equivalente é omitir o
switch (atualmente, o padrão é a especificação da linguagem C # 4.0).

ISO-1 Restrinja o compilador para usar apenas os primeiros recursos padronizados ISO. O uso de
recursos como genéricos, classes estáticas, métodos anônimos levarão a
erro.

ISO-2 Restrinja o compilador para usar apenas os segundos recursos padronizados ISO. Esse
permite o uso de genéricos, classes estáticas, iteradores e métodos anônimos
por exemplo.

3 Restrinja o compilador para usar apenas os recursos disponíveis em C # 3.0 (a
superconjunto de ISO-1 e ISO-2).

4 Restrinja o compilador para usar apenas os recursos disponíveis em C # 4.0
especificação.

experimental
Ativa recursos instáveis ​​de versões futuras do idioma.

Observe que este sinalizador restringe apenas os recursos de idioma disponíveis para o
programador. Uma versão dos conjuntos produzidos pode ser controlada usando SDK opção.

-lib: PATHLIST
Cada caminho especificado na lista separada por vírgulas direcionará o compilador para olhar
para bibliotecas nesse caminho especificado.

-L PATH
Direciona o compilador para procurar bibliotecas no caminho especificado. Caminhos múltiplos
pode ser fornecido usando a opção várias vezes.

-main: CLASS
Diz ao compilador qual CLASSE contém o ponto de entrada. Útil quando você está
compilar várias classes com um método Main.

-nostdlib, -nostdlib +
Use este sinalizador se desejar compilar a biblioteca principal. Isso torna o compilador
carregue seus tipos internos do assembly que está sendo compilado.

-noconfig, -noconfig +
Desativa a configuração do compilador padrão a ser carregada. O compilador por padrão
tem referências aos assemblies do sistema.

-nowarn: WARNLIST
Faz com que o compilador ignore os avisos especificados na lista separada por vírgulas WARNLIST>

-otimizar, -optimize +, -otimizar-
Controla as otimizações de geração de código do compilador no código. Usando -optimize ou
-optimize + ativará as otimizações, -optimize- desativará. O padrão em
mcs é otimizar-. A opção pode ser misturada com -debug, mas para a melhor depuração
experiência, é recomendável deixar as opções desativadas.

-out: FNAME, -o NOME
Nomeia o arquivo de saída a ser gerado.

--analisar
Usado para benchmarking. O compilador analisará apenas seus arquivos de entrada.

-pkg: package1 [, packageN]
Assemblies de referência para os pacotes fornecidos.

O compilador irá invocar pkg-config --libs no conjunto de pacotes especificado no
linha de comando para obter bibliotecas e diretórios para compilar o código.

Isso normalmente é usado com componentes de terceiros, como este:

$ mcs -pkg: gtk-sharp demo.cs

-pkg: dotnet
Isso instruirá o compilador a fazer referência às bibliotecas System. *
disponível em uma instalação típica de estrutura dotnet, observe que isso
não inclui todas as bibliotecas Mono, apenas as System. *. Isto é um
atalho conveniente para o código de portabilidade.

-plataforma: ARCH
Usado para especificar a plataforma de destino. Os valores possíveis são: anycpu,
anycpu32bitpreferred, arm, x86, x64 ou itanium. A opção padrão é anycpu.

-recurso: RECURSO [, ID]
Incorpora no arquivo de recurso fornecido. O ID opcional pode ser usado para dar um diferente
nome para o recurso. Se não for especificado, o nome do recurso será o nome do arquivo.

-linkresource: RESOURCE [, ID]
Links para o RECURSO especificado. O ID opcional pode ser usado para dar um nome ao
recurso vinculado.

-r: ASSEMBLY1 [, ASSEMBLY2], -referência ASSEMBLY1 [, ASSEMBLY2]
Faça referência aos assemblies nomeados. Use isto para usar classes do assembly nomeado em
seu programa. O conjunto será carregado a partir do diretório do sistema onde
todos os assemblies ao vivo, ou do caminho explicitamente fornecido com a opção -L.

Você também pode usar um ponto-e-vírgula para separar as montagens em vez de uma vírgula.

-referência: ALIAS = MONTAGEM
Suporte de referência de alias externo para C #.

Se você tiver diferentes assemblies que fornecem os mesmos tipos, o alias externo
o suporte permite que você forneça nomes que seu software pode usar para informar aqueles
appart. Os tipos de ASSEMBLY serão expostos como ALIAS e, em seguida, na fonte C #
código, você precisa fazer:

alias externo ALIAS;
Para trazê-lo para o seu namespace. Por exemplo, para lidar com duas bibliotecas gráficas
que define "Graphics.Point", um em "OpenGL.dll" e um em "Postscript.dll", você
iria invocar o compilador assim:

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

E em seu código-fonte, você escreveria:

alias externo Postscript;
alias externo OpenGL;

classe X {
// Este é um Graphics.Point de Postscrip.dll
Postscript.Point p = novo Postscript.Point ();

// Este é um Graphics.Point de OpenGL.dll
OpenGL.Point p = novo OpenGL.Point ();
}

-recurso: PATTERN, --recurso PADRONIZAR
Faz compilação recursiva usando o padrão especificado. No Unix, o shell irá
realizar globbing, então você pode querer usá-lo assim:

$ mcs -recurse: '*. cs'

-sdk: VERSION
Usado para especificar a versão dos assemblies da Base Class Library usados ​​para compilação.
Os seguintes valores predefinidos são válidos: 2, 4 (padrão), bem como qualquer valor personalizado.
O número da versão predefinida significa qual valor personalizado é especificado. O mcs tentará
encontre Bibliotecas de classes básicas no local de instalação mono PREFIX / lib / mono / .

- concha
Inicia o compilador no modo interativo, fornecendo um shell C # para instruções e
expressões. Um atalho é usar o csharp comando diretamente.

--stacktrace
Gera um rastreamento de pilha no momento em que o erro é relatado, útil para depurar o
compilador

-alvo: KIND, -t: TIPO
Usado para especificar o destino desejado. Os valores possíveis são: exe (simples
executável), winexe (executável Windows.Forms), biblioteca (bibliotecas de componentes) e
módulo (biblioteca parcial).

--timestamp
Outro sinalizador de depuração. Usado para exibir os horários em vários pontos do
processo de compilação.

-inseguro, -unsafe +
Permite a compilação de código não seguro.

-v Depurando. Ativa a análise detalhada do yacc.

--versão
Mostra a versão do compilador.

-warnaserror, -warnaserror +
Todos os avisos do compilador serão relatados como erros.

-warnaserror: W1, [Wn], -warnaserror +: W1, [Wn]
Trata um ou mais avisos do compilador como erros.

-warnaserror-: W1, [Wn]
Define um ou mais avisos do compilador para serem sempre ameaçados como avisos. Torna-se
útil quando usado junto com -warnaserror.

-aviso: LEVEL
Define o nível de aviso. 0 é o nível de aviso mais baixo e 4 é o mais alto. o
o padrão é 4.

-win32res: FILE
Especifica um arquivo de recurso Win32 (.res) a ser agrupado no assembly resultante.

-win32icon: FILE
Anexa o ícone especificado em FILE na saída para a montagem resultante.

-- Use isto para interromper a análise de opções e permitir que parâmetros de procura de opções sejam passados
na linha de comando.

KITS E BIBLIOTECAS

Ao fazer referência a um assembly, se o nome do assembly for um caminho, o compilador tentará
para carregar o assembly especificado no caminho. Caso contrário, o compilador tentará
carregar o assembly do diretório atual, o diretório base do compilador e se o
assembly não é encontrado em nenhum desses lugares nos diretórios especificados como argumentos para
o argumento -lib: comando.

O compilador usa o caminho da biblioteca para localizar bibliotecas e é capaz de referenciar bibliotecas
de um pacote específico se esse diretório for usado. Para simplificar o uso de pacotes, o
O compilador C # inclui a opção de linha de comando -pkg: que é usada para carregar
coleções de bibliotecas.

Bibliotecas visíveis para o compilador são armazenadas em relação ao prefixo de instalação em
PREFIXO / lib / mono / chamado PACKAGEBASE e os padrões para mcs, gmcs e smcs são como
segue:

mcs Referencia o diretório PACKAGEBASE / 1.0

gmcs Referencia o diretório PACKAGEBASE / 2.0

sms Referencia o diretório PACKAGEBASE / 2.1

Esses são os únicos perfis de tempo de execução que existem. Embora existam outros diretórios (como
3.0 e 3.5) esses não são realmente perfis de tempo de execução, são apenas marcadores de lugar para
bibliotecas que se baseiam na base 2.0.

Os fornecedores de software distribuirão o software instalado em relação ao PACKAGEBASE
diretório. Isso é integrado ao gacutil ferramenta que não instala apenas o público
assemblies no Global Assembly Cache (GAC), mas também os instala no
Diretório PACKAGEBASE / PKG (em que PKG é o nome passado para o sinalizador -package para gacutil).

Como um desenvolvedor, se você deseja consumir as bibliotecas Gtk #, você deve invocar o compilador
como isso:

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

A opção -pkg: instrui o compilador a buscar as definições para gtk-sharp-2.0 de
pkg-config, isso é equivalente a passar para o compilador C # a saída de:

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

Normalmente, isso apenas faz referência às bibliotecas de PACKAGEBASE / PKG.

Embora existam nomes de diretório para 3.0 e 3.5, isso não significa que existam 3.0
e 3.5 edições ou perfis do compilador. Essas são apenas novas bibliotecas que devem ser
referenciado manualmente com o -pkg: invocação adequado ou referenciando o
bibliotecas diretamente.

SPECIAL DEFINA

A TRACE e DEBUG define tem um significado especial para o compilador.

Por padrão, as chamadas para métodos e propriedades na classe System.Diagnostics.Trace não são
gerado a menos que o símbolo TRACE seja definido (por meio de um "#define TRACE") em seu
código-fonte, ou usando o --definir TRACE na linha de comando.

Por padrão, as chamadas para métodos e propriedades na classe System.Diagnostics.Debug não são
gerado a menos que o símbolo DEBUG seja definido (através de um "#define DEBUG") em seu
código-fonte, ou usando o --definir DEBUG na linha de comando.

Observe que o efeito de definir TRACE e DEBUG é uma configuração global, mesmo que sejam
definido apenas em um único arquivo.

DEPURAÇÃO SUPPORT

Ao usar o sinalizador "-debug", o MCS irá gerar um arquivo com a extensão .mdb que
contém as informações de depuração para o assembly gerado. Este arquivo é consumido por
o depurador Mono (mdb).

MEIO AMBIENTE VARIÁVEIS

MCS_COLORS
Se esta variável for definida, ela contém uma string na forma "foreground, background"
que especifica qual cor usar para exibir erros em alguns terminais.

O plano de fundo é opcional e o padrão é o plano de fundo atual do terminal. o
as cores possíveis para o primeiro plano são: Preto, vermelho, vermelho brilhante, verde verde claro,
amarelo, amarelo brilhante, azul, azul-claro, magenta, magenta-claro, ciano, ciano-claro,
cinza, branco e branco brilhante.

As cores possíveis para o fundo são: preto, vermelho, verde, amarelo, azul, magenta,
ciano, cinza e branco.

Por exemplo, você pode definir essas variáveis ​​em seu shell:
exportar MCS_COLORS
MCS_COLORS = erros = branco brilhante, vermelho

Você pode desabilitar o esquema de cores embutido definindo esta variável para "desabilitar".

NOTAS

Durante a compilação, o compilador MCS define o símbolo __MonoCS__, que pode ser usado por
instruções do pré-processador para compilar o código específico do compilador Mono C #. Por favor, note que
este símbolo serve apenas para testar o compilador e não é útil para distinguir a compilação
ou plataformas de implantação.

AUTORES

O compilador Mono C # foi escrito por Miguel de Icaza, Ravi Pratap, Martin Baulig, Marek
Safar e Raja Harinath. O desenvolvimento foi financiado pela Ximian, Novell e Marek Safar.

Use dmcs online usando serviços onworks.net