Suporte à compilação, execução e depuração integradas Compilar os arquivos do projeto Executar o código Depurar o código Alterar um executor integrado Criar uma configuração de execução Criar um compilador ou executor Definir um compilador ou executor

Trabalhar com compiladores, executores e depuradores no Ambiente de desenvolvimento integrado (IDE) do AWS Cloud9

Um compilador instrui o IDE do AWS Cloud9 sobre como compilar os arquivos de um projeto. Um executor instrui o AWS Cloud9 sobre como executar arquivos de um tipo específico. Um executor pode usar um depurador para ajudar a encontrar problemas no código-fonte dos arquivos.

Use o IDE do AWS Cloud9 para compilar, executar e depurar o código das seguintes formas:

Use um compilador para compilar os arquivos do projeto. Consulte Compilar os arquivos do projeto.
Use um executor para executar (e, opcionalmente, para depurar) o código. Consulte Suporte à compilação, execução e depuração integradas e Executar o código.
Altere um executor integrado para executar (e, opcionalmente, para depurar) o código de forma diferente daquela definida originalmente. Consulte Alterar um executor integrado.
Use um executor para executar (e, opcionalmente, para depurar) o código com um combinação personalizada de nome de arquivo, opções da linha de comando, modo de depuração, diretório de trabalho atual e variáveis de ambiente. Consulte Criar uma configuração de execução.
Crie o seu próprio compilador ou executor. Consulte Criar um compilador ou executor.

Suporte à compilação, execução e depuração integradas

O IDE do AWS Cloud9 oferece suporte à compilação, execução e depuração integradas de código em diversas linguagens. Para obter uma lista completa, consulte Suporte às linguagens.

O suporte à compilação integrada está disponível na barra de menu nos comandos Run (Executar), Build System (Compilar sistema) e Run (Executar), Build (Compilar). Para adicionar suporte a uma linguagem de programação ou ferramenta que não está listada, consulte Criar um compilador ou executor.

O suporte à execução integrada está disponível no botão Run (Executar) e na barra de menu nos comandos Run (Executar), Run With (Executar com) e Run (Executar), Run Configurations (Configurações de execução). Para adicionar suporte a uma linguagem de programação ou ferramenta que não está listada, consulte Criar um compilador ou executor e Criar uma configuração de execução.

O suporte à depuração integrada está disponível por meio da janela Debugger (Depurador). Para exibir a janela Debugger (Depurador), selecione o botão Debugger (Depurador). Se o botão Debugger (Depurador) não estiver visível, selecione Window (Janela), Debugger (Depurador) na barra de menus.

Compilar os arquivos do projeto

Abra um arquivo correspondente ao código que deseja compilar.
Na barra de menus, selecione Run, Build System (Executar, Sistema de compilação) e, em seguida, escolha o nome do compilador para usar, caso ainda não tenha sido escolhido. Se o compilador que deseja usar não estiver listado, interrompa esse procedimento, conclua as etapas em Criar um compilador ou executor e, em seguida, retorne para esse procedimento.
Selecione Run, Build (Executar, Compilar).

Executar o código

Abra um arquivo correspondente ao código que deseja executar, caso ainda não esteja aberto e selecionado.
Na barra de menus, selecione um dos seguintes:
- Para executar o código com o executor integrado correspondente mais próximo, selecione Run, Run (Executar, Executar). Se o AWS Cloud9 não conseguir encontrar um, esse comando é desabilitado.
- Para executar o código com a configuração de execução que o AWS Cloud9 usou pela última vez, selecione Run, Run Last (Executar, Executar o último).
- Para executar o código com um executor específico, selecione Run, Run With (Executar, Executar com) e, em seguida, escolha o nome do executor. Se o executor que deseja usar não estiver listado, interrompa esse procedimento, conclua as etapas em Criar um compilador ou executor e, em seguida, retorne para esse procedimento.
- Para executar o código com um executor específico com uma combinação personalizada de nome de arquivo, opções da linha de comando, modo de depuração, diretório de trabalho atual e variáveis de ambiente, selecione Run, Run Configurations (Executar, Configurações de execução) e, em seguida, escolha o nome da configuração de execução. Na guia da configuração de execução exibida, selecione Runner: Auto (Executor: automático), escolha o executor que deseja usar e, em seguida, selecione Run (Executar). Se o executor que deseja usar não estiver listado, interrompa esse procedimento, conclua as etapas em Criar um compilador ou executor e, em seguida, retorne para esse procedimento.

Depurar o código

Na guia da configuração de execução do código, selecione Run in Debug Mode (Executar no modo de depuração). O ícone de bug muda para verde em um fundo branco. Para obter mais informações, consulte Executar o código e Criar uma configuração de execução.
Defina os pontos de interrupção no código onde deseja pausar durante a execução, da seguinte forma:
1. Abra cada arquivo nos quais deseja definir um ponto de interrupção.
2. Em cada ponto em um arquivo onde deseja definir um ponto de interrupção, selecione a área em branco no gutter à esquerda do número de linha. Um círculo vermelho é exibido.
  
  Para remover um ponto de interrupção, selecione o ponto existente no gutter.
  
  Para desativar um ponto de interrupção em vez de removê-lo, na janela Debugger (Depurador), em Breakpoints (Pontos de interrupção), desmarque a caixa correspondente ao ponto de interrupção que deseja desativar. Para ativar o ponto de interrupção novamente, selecione a caixa que foi desmarcada.
  
  Para desativar todos os pontos de interrupção de uma só vez, na janela Debugger (Depurador), selecione Deactivate All Breakpoints (Desativar todos os pontos de interrupção). Para ativar todos os pontos de interrupção novamente, selecione Activate All Breakpoints (Ativar todos os pontos de interrupção).
  
  Se a janela Debugger (Depurador) não estiver visível, selecione o botão Debugger (Depurador). Se o botão Debugger (Depurador) não estiver visível, selecione Window (Janela), Debugger (Depurador) na barra de menus.
Defina quaisquer expressões de observação para as quais deseje obter o valor no momento em que a execução pausar, da seguinte forma:
1. Na janela Debugger (Depurador), em Watch Expressions (Expressões de observação), selecione Type an expression here (Digite uma expressão aqui).
2. Digite a expressão que deseja observar e, em seguida, pressione Enter.
  
  Para alterar uma expressão de observação existente, clique com o botão direito do mouse na expressão e, em seguida, selecione Edit Watch Expression (Editar expressão de observação). Digite a alteração e, em seguida, pressione Enter.
  
  Para remover uma expressão de observação existente, clique com o botão direito do mouse na expressão e, em seguida, selecione Remove Watch Expression (Remover expressão de observação).
Execute o código conforme descrito em Executar o código.

Sempre que uma execução pausar, também é possível pausar o ponteiro do mouse em qualquer trecho de código exibido (por exemplo, uma variável) para mostrar as informações disponíveis sobre ele em uma dica da ferramenta.

Alterar um executor integrado

Na barra de menus, selecione Run, Run With (Executar, Executar com) e, em seguida, selecione o executor integrado que deseja alterar.
Interrompa o executor de tentar executar o código ao escolher Stop (Encerrar) na guia da configuração de execução exibida.
Selecione Runner: My Runner (Executor: My Runner), onde My Runner é o nome do executor que deseja alterar e, em seguida, escolha Edit Runner (Editar executor).
Na guia My Runner.run exibida, altere a definição atual do executor. Consulte Definir um compilador ou executor.
Selecione File, Save As (Arquivo, Salvar como). Salve o arquivo com o mesmo nome (My Runner.run) no diretório my-environment/.c9/runners, onde my-environment é o nome do ambiente de desenvolvimento do AWS Cloud9.

nota

Todas as alterações feitas em um executor integrado se aplicam somente ao ambiente em que elas foram feitas. Para aplicar as alterações em um ambiente separado, abra o outro ambiente e siga as etapas anteriores para abrir, editar e salvar as mesmas alterações nesse executor integrado.

Criar uma configuração de execução

Na barra de menus, selecione Run, Run Configurations, New Run Configuration (Executar, Configurações de execução, Nova configuração de execução). Na guia da configuração de execução exibida, faça o seguinte:

Na caixa ao lado de Run (Executar) e Restart (Reiniciar), digite o nome que será exibido no menu Run, Run Configurations (Executar, Configurações de execução) para essa configuração de execução.
Na caixa Command (Comando), digite qualquer opção da linha de comando personalizada que deseje usar.
Para que essa configuração de execução use as configurações de depuração predefinidas do executor, selecione Run in Debug Mode (Executar no modo de depuração). O ícone de bug mudará para verde em um fundo branco.
Para que essa configuração de execução use um diretório de trabalho específico, selecione CWD, escolha o diretório para usar e, em seguida, selecione Select (Selecionar).
Para que essa configuração de execução use variáveis de ambiente específicas, selecione ENV e, em seguida, digite o nome e o valor de cada variável de ambiente.

Para usar essa configuração de execução, abra o arquivo correspondente ao código que deseja executar. Selecione Run, Run Configurations (Executar, Configurações de execução) na barra de menus e, em seguida, escolha o nome dessa configuração de execução. Na guia da configuração de execução exibida, selecione Runner: Auto (Executor: automático), escolha o executor que deseja usar e, em seguida, selecione Run (Executar).

nota

Qualquer configuração de execução criada se aplica somente ao ambiente em que ela foi criada. Para adicionar uma configuração de execução em um ambiente separado, abra o outro ambiente e siga as etapas anteriores para criar a mesma configuração de execução nesse ambiente

Criar um compilador ou executor

Para criar um compilador, na barra de menus, selecione Run, Build System, New Build System (Executar, Sistema de compilação, Novo sistema de compilação). Para criar um executor, na barra de menus, selecione Run, Run With, New Runner (Executar, Executar com, Novo executor).
Na guia do compilador (identificado como My Builder.build) ou na guia do executor (identificado como My Runner.run) exibida, defina o compilador ou o executor. Consulte Definir um compilador ou executor.
Depois de definir o compilador ou executor, selecione File, Save As (Arquivo, Salvar como). Para um compilador, salve o arquivo com a extensão .build no diretório my-environment/.c9/builders, onde my-environment é o nome do ambiente. Para um executor, salve o arquivo com a extensão .run no diretório my-environment/.c9/runners, onde my-environment é o nome do ambiente. O nome de arquivo especificado será o nome exibido no menu Run, Build System (Executar, Sistema de compilação) (para um compilador) ou no menu Run, Run With (Executar, Executar com) (para um executor). Portanto, a menos que você especifique um nome de arquivo diferente, por padrão, o nome exibido será My Builder (para um compilador) ou My Runner (para um executor).

Para usar esse compilador ou executor, consulte Compilar os arquivos projeto ou Executar o código.

nota

Qualquer compilador ou executor criado se aplica somente ao ambiente em que foi criado. Para adicionar o compilador ou executor em um ambiente separado, abra o outro ambiente e siga as etapas anteriores para criar o mesmo compilador ou executor nesse ambiente.

Definir um compilador ou executor

Este procedimento assume que você já começou a criar um compilador ou executor ao escolher Run, Build System, New Build System (Executar, Sistema de compilação, Novo sistema de compilação) (para um compilador) ou Run, Run With, New Runner (Executar, Executar com, Novo executor).

Na guia do compilador ou executor exibida, use o JSON para definir o executor ou compilador. Comece com o seguinte código como um modelo.

Para um compilador, comece com esse código.


{
  "cmd": [],
  "info": "",
  "env": {},
  "selector": ""
}

Para um executor, comece com esse código.


{
  "cmd": [],
  "script": "",
  "working_dir": "",
  "info": "",
  "env": {},
  "selector": "",
  "debugger": "",
  "debugport": ""
}

No código anterior:

cmd: representa uma lista de strings separadas por vírgulas para que o AWS Cloud9 execute como um único comando.

Quando o AWS Cloud9 executa esse comando, cada string na lista será separada por um único espaço. Por exemplo, o AWS Cloud9 executará "cmd": [ "ls", "$file", "$args"] como ls $file $args, onde o AWS Cloud9 substituirá $file pelo caminho completo para o arquivo atual e $args pelos argumentos inseridos após o nome do arquivo. Para obter mais informações, consulte a lista de variáveis compatíveis posteriormente nesta seção.
script: representa um script bash (que também pode ser especificado como uma matriz de linhas conforme necessário para legibilidade) executado pelo executor no terminal.
working_dir: representa o diretório onde o executor será executado.
info: representa qualquer string de texto que deseje exibir ao usuário no início da execução. Essa string pode conter variáveis, por exemplo Running $project_path$file_name..., onde o AWS Cloud9 substituirá $project_path pelo caminho do diretório do arquivo atual e $file_name pela parte do nome do arquivo atual. Consulte a lista de variáveis compatíveis posteriormente nesta seção.
env: representa qualquer conjunto de argumentos da linha de comando para uso do AWS Cloud9, por exemplo:
```
"env": {
  "LANG": "en_US.UTF-8",
  "SHLVL": "1"
}
```
selector: representa qualquer expressão regular que deseje que o AWS Cloud9 use para identificar os nomes de arquivos que se aplicam a esse executor. Por exemplo, especifique source.py para arquivos Python.
debugger: representa o nome de qualquer depurador disponível que deseja que o AWS Cloud9 use e que é compatível com esse executor. Por exemplo, especifique v8 para o depurador V8.
debugport: representa o número da porta que deseja que o AWS Cloud9 use durante a depuração. Por exemplo, especifique 15454 para o número da porta a ser usada.

A tabela a seguir mostra as variáveis que podem ser utilizadas.

Variável	Descrição
`$file_path`	O diretório do arquivo atual, por exemplo, `/home/ec2-user/environment` ou `/home/ubuntu/environment`.
`$file`	O caminho completo para o arquivo atual, por exemplo, `/home/ec2-user/environment/hello.py` ou `/home/ubuntu/environment/hello.py`.
`$args`	Todos os argumentos inseridos após o nome do arquivo, por exemplo, `"5" "9"`.
`$file_name`	A parte do nome do arquivo atual, por exemplo, `hello.py`.
`$file_extension`	A extensão do arquivo atual, por exemplo, `py`.
`$file_base_name`	O nome do arquivo atual sem a extensão de arquivo, por exemplo, `hello`.
`$packages`	O caminho completo para a pasta de pacotes.
`$project`	O caminho completo para a pasta do projeto atual.
`$project_path`	O diretório do arquivo de projeto atual, por exemplo, `/home/ec2-user/environment/` ou `/home/ubuntu/environment/`.
`$project_name`	O nome do arquivo de projeto atual sem a extensão de arquivo, por exemplo, `my-demo-environment`.
`$project_extension`	A extensão do arquivo de projeto atual.
`$project_base_name`	O nome do arquivo de projeto atual sem a extensão.
`$hostname`	O nome de host do ambiente, por exemplo, `192.0.2.0`.
`$hostname_path`	O nome de host do ambiente com o caminho relativo para o arquivo de projeto, por exemplo, `https://192.0.2.0/hello.js`.
`$url`	O URL completo para acessar o ambiente, por exemplo, `https://192.0.2.0.`.
`$port`	A porta atribuída ao ambiente, por exemplo, `8080`.
`$ip`	Os endereços IP para executar um processo no ambiente, por exemplo, `0.0.0.0`.

Como exemplo, o arquivo de compilador chamado G++.build define um compilador para GCC que executa o comando g++ com a opção -o para compilar o arquivo atual (por exemplo, hello.cpp) em um módulo de objeto. Em seguida, ele vincula o módulo de objeto em um programa com o mesmo nome que o arquivo atual (por exemplo, hello). Aqui o comando equivalente é g++ -o hello hello.cpp.


{
  "cmd": [ "g++", "-o", "$file_base_name", "$file_name" ],
  "info": "Compiling $file_name and linking to $file_base_name...",
  "selector": "source.cpp"
}

Como outro exemplo, o arquivo de executor a seguir chamado Python.run define um executor que usa Python para executar o arquivo atual com todos os argumentos fornecidos. Por exemplo, se o arquivo atual se chama hello.py e os argumentos 5 e 9 foram fornecidos, o comando equivalente é python hello.py 5 9.


{
  "cmd": [ "python", "$file_name", "$args" ],
  "info": "Running $file_name...",
  "selector": "source.py"
}

Finalmente, o arquivo de executor a seguir chamado Print Run Variables.run define um executor simplesmente gera o valor de cada variável disponível e, em seguida, é encerrado.


{
  "info": "file_path = $file_path, file = $file, args = $args, file_name = $file_name, file_extension = $file_extension, file_base_name = $file_base_name, packages = $packages, project = $project, project_path = $project_path, project_name = $project_name, project_extension = $project_extension, project_base_name = $project_base_name, hostname = $hostname, hostname_path = $hostname_path, url = $url, port = $port, ip = $ip"
}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Trabalhar com arquivos de imagem

Trabalhar com variáveis de ambiente personalizadas