Passo 4: Criar a tarefa para compilar programas

O VSCode nos permite trabalhar com compiladores diversos porque oferece recursos para customização das tarefas de compilação, debug e execução. Em linhas gerais, para compilar programas o que temos que fazer é criar tarefas aproveitando os recursos disponíveis nas extensões que instalamos para cada linguagem.

4.1. Crie um script de compilação

O utilitário de compilação do GnuCOBOL (cobc) precisa ser chamado com parâmetros diferentes para gerar binários (programas executáveis que podem ser chamados diretamente na linha de comando) ou libraries (programas called com extensão .so ou .dylib que só podem ser chamados por outros programas). Os parâmetros também são diferentes para compilar um programa em fixed format ou em free format. E além disso, se o programa tiver comandos SQL (“EXEC SQL”) será preciso criar um step de pré-compilação antes de chamar o cobc.

Teríamos então que criar uma tarefa de compilação no VSCode para cada uma dessas combinações: fixed format binário sem SQL, free format called com SQL e assim por diante… dá para imaginar a possível confusão na hora de selecionar a tarefa certa para o tipo de programa certo.

Por esse motivo optamos por fazer a compilação num bash script. Desta forma, o próprio script fica responsável por avaliar o programa fonte e decidir com que parâmetros deve chamar o utilitário cobc. No VSCode, precisaremos apenas criar uma tarefa que chame esse script, como veremos nas próximas sessões.

O script que vamos usar é esse aqui:

#!/bin/bash
#--------------------------------------------------------------------#
 # Nome:         cobol.sh
 # Objetivo:     Script usado para compilacao COBOL no VSCODE
 # Data:         Janeiro/2021
 # Descrição:    Seleciona os argumentos correspondentes do GnuCOBOL (cobc)
 #               em funcao das caracteristicas do fonte cujo nome foi 
 #               informado via argumento. Com isso apenas uma tarefa de 
 #               compilacao precisa ser configurada no VSCode
#--------------------------------------------------------------------#
PROGRAMA=$1
COBLAB=/Users/{seuNome}/cobolws
FONTE=$COBLAB/cbl/$PROGRAMA.cbl
 
MAIN=true
FREE=true
ESQL=false
 
# Se programa tem USING na PROCEDURE e' "called", senao é "main"
FOUND=$(grep -i "PROCEDURE" $FONTE | grep -i "USING")
if [ ! -z "$FOUND" ]; then
    MAIN=false
else
    FOUND=$(grep -i "PROCEDURE" $FONTE)
    if [ -z "$FOUND" ]; then
        echo "cobol.sh (Error): Programa nao tem procedure division";
        exit 1;
    fi
fi
 
# Se o PROGRAM-ID tiver sete espacos 'a esquerda é "fixed", senao e' free
FOUND=$(grep -i "^[[:space:]]\{7\}PROGRAM-ID" $FONTE)
if [ ! -z "$FOUND" ]; then
    FREE=false
else    
    FOUND=$(grep -i "PROGRAM-ID" $FONTE)
    if [ -z "$FOUND" ]; then
        echo "cobol.sh (Error): Programa nao tem program-id";
        exit 1;
    fi    
fi
 
# Se houver um EXEC SQL o programa precisa ser pre-compilado
 FOUND=$(grep -i "EXEC SQL" $FONTE)
 if [ ! -z "$FOUND" ]; then
     ESQL=true
 fi
 
# Monta os parametros de compilacao em funcao do que encontrou nos fontes
echo "cobol.sh (INFO): MAIN=$MAIN FREE=$FREE ESQL=$ESQL"
if [[ $MAIN == true ]]; then 
    OBJETO=$COBLAB/bin/$PROGRAMA
    if [[ $FREE == true ]]; then 
        if [[ $ESQL == true ]]; then     
            cobc -x -free -locsql $FONTE -I $COBCPY -o $OBJETO
        else
            cobc -x -free $FONTE -I $COBCPY -o $OBJETO
        fi
    else    
        if [[ $ESQL == true ]]; then     
            cobc -x -locsql $FONTE -I $COBCPY -o $OBJETO
        else
            cobc -x $FONTE -I $COBCPY -o $OBJETO
        fi
    fi
else
    OBJETO=$COBLAB/lib
    if [[ $FREE == true ]]; then 
        if [[ $ESQL == true ]]; then     
            cobc -free -locsql $FONTE -I $COBCPY -o $OBJETO
        else
            cobc -free $FONTE -I $COBCPY -o $OBJETO
        fi
    else    
        if [[ $ESQL == true ]]; then     
            cobc -locsql $FONTE -I $COBCPY -o $OBJETO
        else
            cobc $FONTE -I $COBCPY -o $OBJETO
        fi
    fi
fi
RC=$?
 
if [ $RC == 0 ]; then
    echo "cobol.sh (INFO): O programa $PROGRAMA foi gerado em $OBJETO"
else
    echo "cobol.sh (ERRO): O programa $PROGRAMA nao foi compilado"
fi

exit RC
 

Alguns comentários sobre o script:

1. A primeira linha (PROGRAMA=$1) é onde recebemos o nome do programa a ser compilado. Ele chegará como o primeiro argumento informado logo após o nome do script e será armazenado numa variável interna chamada PROGRAMA;
2. A segunda linha define o valor de uma variável interna chamada COBLAB. Nesta variável vamos guardar o nome do workspace que criamos para o VSCode nos passos anteriores: /Users/{SeuNome}/cobolws. Substitua pelo caminho do seu workspace, por exemplo, /Users/JoaoSilva/cobolws;
3. A terceira linha também define o valor de uma variável interna chamada FONTE e que deve conter o caminho completo do programa que o script vai compilar. Repare que para montar esse caminho completo eu usei o conteúdo das duas variáveis anteriores, PROGRAMA e COBLAB;
4. Em seguida o script faz três buscas dentro no programa fonte para determinar de que tipo ele é. Os comentários de cada bloco explicam o que o script está procurando;
5. Três variáveis (MAIN, FREE e ESQL) são atualizadas nessas buscas, e elas são usadas mais adiante para que o script decida com que argumentos o compilador deve ser chamado.

Para que o VSCode possa chamar esse script de qualquer lugar, você precisa copiá-lo para um diretório do seu equipamento que faça parte da variável de ambiente PATH. Você pode executar o comando abaixo no terminal para ver quais são os diretórios conhecidos pelo PATH e escolher um deles para salvar o script. No meu equipamento a variável PATH está assim…

ECHO $PATH 
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Users/pauloandre/bin:/Users/pauloandre/lib:/Users/pauloandre/br/com/gotocobol/bin:/Users/pauloandre/br/com/gotocobol/lib:/Users/pauloandre/br/com/gotocobol/coblab/bin:/Users/pauloandre/br/com/gotocobol/coblab/lib:/Users/pauloandre/br/com/gotocobol/coblab/bin:/Users/pauloandre/br/com/gotocobol/coblab/lib:/Users/pauloandre/br/com/gotocobol/coblab/bin:/Users/pauloandre/br/com/gotocobol/coblab/lib:/Users/pauloandre/br/com/gotocobol/coblab/shs:/Users/pauloandre/br/com/gotocobol/coblab/bin:/Users/pauloandre/br/com/gotocobol/coblab/lib:/Users/pauloandre/br/com/gotocobol/coblab/shs

Ou pode também escolher um diretório diferente e alterar o arquivo /Users/{SeuNome}/.bash_profile para que esse novo diretório faça parte do PATH. No passo 5 deste tutorial eu mostro como se altera a .bash_profile no Mac.

4.2. Teste o script de compilação

Com o script já instalado no diretório escolhido, vamos codificar um pequeno programa para testá-lo. Copie (ou digite no VSCode) o código abaixo e salve-o como teste.cbl no diretório /Users/{SeuNome}/cobolws/cbl:

identification division.
program-id. teste.
procedure division.
main.
   display "Hello Mac"
   stop run.
       

Agora vá para o terminal do Mac e digite…

cobol.sh gtc000

Se você instalou o script num diretório reconhecido pela variável PATH você deve ver duas mensagens assim:

cobol.sh (INFO): MAIN=true FREE=true ESQL=false
cobol.sh (INFO): O programa gtc000 foi gerado em /Users/{seuNome}/cobolws/bin/gtc000

A primeira mostra como o que o script encontrou no programa fonte: é um programa principal, em free format e sem comandos SQL. A segunda mensagem informa que o programa gtc000 foi compilado e seu binário (executável) foi gerado no diretório bin do nosso workspace.

Se tudo parecer mal, algumas coisas podem estar acontecendo:

1. Verifique se você salvou o programa com o nome certo e a extensão correta;
2. Verifique se você informou o nome certo (sem a extensão) ao lado do nome do script na linha de comando;
3. Verifique se o script está num diretório reconhecido pelo PATH;
4. Verifique se não houve um erro de digitação que impediu o programa de ser compilado.

Para testar o programa, basta ir ao diretório bin do workspace e informar seu nome na linha de comando:

cd /Users/pauloandre/cobolws/bin
./gtc000
Hello Mac

4.3. Crie a tarefa de compilação

Acesse o menu Terminal do VSCode e selecione a opção “Configure Task”:

O VSCode abrirá um campo para que você selecione um template para a tarefa quer criar. Digite “gnucobol” nesse campo…

Repare na tela anterior que existem vários tipos de tarefa disponíveis na extensão que instalamos para trabalhar com o GnuCOBOL (bitlang.gnucobol). A primeira delas é justamente um template para compilação de programas. Selecione esse template.

O VSCode vai abrir um arquivo chamado tasks.json, semelhante ao que aparece na imagem abaixo:

Este template, porém, pretende usar o npm, um gerenciador de pacotes do node.js, muito usado pelo VSCode. Nós não precisamos do npm em nosso ambiente e por isso vamos modificar essa tarefa para chamar nosso próprio script. Copie o conteúdo abaixo e copie por cima do arquivo tasks.json, que está aberto no VSCode:

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "gnucobol (compile)",
            "type": "shell",
            "command": "cobol.sh",
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "args": [
                "${fileBasenameNoExtension}"
            ],
            "problemMatcher": [
                "$gnucobol3-cobc",
                "$gnucobol3-error-cobc",
                "$gnucobol3-note-cobc",
                "$gnucobol3-warning-cobc"
            ],
            "detail": "tsc -p ./"
        }
    ]
}

4.4. Entenda como a tarefa está configurada:

• O nome da tarefa aperece no campo “label”, e nós a chamamos de “gnucobol (compile)”.
• Ela é do tipo “shell”, porque o que ela faz é executar comandos ou scripts como se os estivéssemos digitando esses comandos no terminal;
• O comando que vai ser executado se chama “cobol.sh“, o nome do script que criamos;
• Ela é do tipo “build” e o parâmetro “isDefault” está configurado com “true”, porque queremos que ela seja a tarefa default de compilação de programas em nosso ambiente. Com isso, para compilar o programa que estamos editando só precisaremos pressionar as teclas command+shift+B.
• Repare que no campo “argumento” estamos dizendo para o VSCode que ele deve enviar o conteúdo de uma variável do próprio VSCode chamada “${fileBasenameNoExtension}“. Essa variável (como o nome diz) contém o nome do programa que está sendo editado, sem extensão, que é exatamente o que nosso script espera receber.
• O VSCode possui recursos muito interessantes para navegar na lista de erros de compilação e localizar rapidamente a linha causadora do erro dentro do programa. Nós veremos um pouco desses recursos mais adiante nesse tutorial. No campo “problemMatcher” estamos informando o nome de três módulos disponíveis na extensão bitlang.gnucobol e que fazem o trabalho de traduzir a lista de erros de compilação do GnuCOBOL para um formato que o VSCode possa usar em suas janelas.

4.5. Próximo passo

No próximo vamos criar uma tarefa para execução do programa e estaremos chegando ao final da configuração.

---

Anterior

Conteúdo

Próximo