Início  |  Mapa  |  Índice  |  Procura

Convert to GutenPalm or to PalmDoc por Lorne Bailey <sherm_pbody(at)yahoo.com> Sobre o autor: O Lorne vive em Chicago e trabalha como consultor informático, especializado em obter dados de e para bases de dados Oracle. Desde que se mudou para um ambiente de programação *nix, evitou por completo a 'DLL Hell'. Está, presentemente a trabalhar no mestrado sobre Ciência de Computação. Traduzido para Português por: Bruno Sousa <bruno(at)linuxfocus.org> Conteúdo: Regras do GCC No Princípio... Pré-compilação Compilação Assemblagem Mais duas Opç�es Importantes Depuração Resumo Ligaç�es Forma de respostas para este artigo

GCC - a raiz para tudo

Abstrato:

Este artigo assume que sabe as bases da linguagem C e introduzir-lhe-á o gcc como um compilador. Certificarnos-emos que consegue invocar o compilador a partir da linha de comandos utilizando código fonte C simples. Depois veremos muito rapidamente o que está a acontecer agora e como pode controlar a compilação dos seus programas. Daremos uma pequena entrada em como utilizar um depurador.

Regras do GCC

Consegue-se imaginar a compilar software livre com um compilador proprietário e fechado? Como é que sabe o que vai no seu executável? Pode haver qualquer tipo de "back door" ou cavalo de Tróia. O Ken Thompson, numa das piratarias de todos os tempos, escreveu um compilador que deixava uma "back door" no programa de 'login' e perpetuava o cavalo de Tróia quando o compilador se apercebia que estava a compilar a si mesmo. Leia a descrição dele para todos clássicos de todos os tempos aqui. Felizmente, temos o gcc. Sempre que faz um configure; make; make install o gcc faz um trabalho pesado que não se vê. Como é que fazemos o gcc trabalhar para nós? Começaremos por escrever um jogo de cartas, mas só escreveremos o necessário para demonstrar a funcionalidade do compilador. Visto que estamos a começar do zero, é preciso compreender o processo de compilação para saber o que deve ser feiro para se ter um executável e em que ordem. Daremos uma visto de olhos geral como um programa C é compilado e as opç�es que o gcc tem para fazer o que queremos. Os passos (e os utilitários que os fazem) são Pré-compilação (gcc -E), Compilação (gcc), Assemblagem (as), e Linkagem (ld) - Ligação.

No Princípio...

Primeiro pensamento, devíamos saber como invocar o compilador em primeiro lugar. É realmente simples. Começaremos com o clássico de todos os tempos, o primeiro programa C. (Os de velhos tempos que me perdoem).

#include <stdio.h>

int main()

{
  printf("Hello World!\n");
}

Guarde este ficheiro como game.c. Pode compilá-lo na linha de comandos, correndo:

gcc game.c

a.out
Hello World

gcc -o game game.c

game
Hello World

Até este ponto, ainda estamos longe de um programa útil. Se pensa que isto é uma coisa má, deve reconsiderar o facto que temos um programa que compila e corre. À medida que adicionarmos funcionalidade, a pouco e pouco, queremos certificar-nos que o mantemos capaz de correr. Parece que todos os programadores iniciantes querem escrever 1,000 linhas de código e depois corrigi-las de uma vez só. Ninguém, mas mesmo ninguém pode fazer isto. Você faz um programa pequeno que correm faz as alteraç�es e torna-o executável novamente. Isto limita os erros que tem de corrigir de uma só vez. E ainda por cima, você sabe exactamente o que fez e que não trabalha, então sabe onde concentrar-se. Isto evita-lhe criar algo que você pensa que trabalha e até compile mas nunca se torna num executável. Lembre-se que só por ter compilado não quer dizer que esteja correcto.

O nosso próximo passo é criar um ficheiro cabeçalho para o nosso jogo. Um ficheiro cabeçalho concentra os tipos de dados e a declaração de funç�es num só sítio. Isto assegura que as estruturas de dados estão definidas consistentemente, assim qualquer parte do nosso programa vê tudo, exactamente do mesmo modo.

#ifndef DECK_H
#define DECK_H

#define DECKSIZE 52

typedef struct deck_t
{
  int card[DECKSIZE];
  /* number of cards used */
  int dealt;
}deck_t;

#endif /* DECK_H */

Guarde este ficheiro como deck.h. Só o ficheiro .c é que é compilado, assim temos de alterar o nosso game.c. Na linha 2 do game.c, escreva #include "deck.h". Na linha 5, escreva deck_t deck; para ter a certeza que não falhámos nada, compile-o novamente.

gcc -o game game.c

Se não houver erros, não há problema. Se não compilar resolva-o até compilar.

Pré-compilação

Como é que o compilador sabe que tipo é o deck_t ? Porque durante a pré-compilação, ele, na verdade copia o ficheiro "deck.h" para dentro do ficheiro "game.c". As directivas do pré-compilador no código fonte começam por um "#". Pode invocar o pré-compilador através do frontend do gcc com a opção -E.

gcc -E -o game_precompile.txt game.c
wc -l game_precompile.txt
  3199 game_precompile.txt

1. Copia os ficheiros "#included" no código fonte para serem compilados.
2. Substirui o texto "#define" pelo seu valor actual.
3. Substitui as macros nas linhas onde são chamadas.

Compilação

Como um passo intermediário, o gcc traduz o seu código em linguagem Assembler. Para fazer isto, ele deve descobrir o que é que tinha intenção de fazer ao passar por todo o seu código. Se cometer um erro de sintaxe ele dir-lhe-à e a compilação falhará. Muitas vezes as pessoas confundem este passo com todo o processo inteiro. Mas ainda há mais trabalho para o gcc fazer.

Assemblagem

O as transforma o código Assembler em código objecto. O código objecto não pode ainda correr no CPU, as está muito perto. A opção do compilador -c transforma um ficheiro .c num ficheiro objecto com a extensão .o. Se corrermos:

gcc -c game.c

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "deck.h"

static time_t seed = 0;

void shuffle(deck_t *pdeck)
{
  /* Keeps track of what numbers have been used */
  int drawn[DECKSIZE] = {0};
  int i;

  /* One time initialization of rand */
  if(0 == seed)
  {
    seed = time(NULL);
    srand(seed);
  }
  for(i = 0; i < DECKSIZE; i++)
  {
    int value = -1;
    do
    {
      value = rand() % DECKSIZE;
    }
    while(drawn[value] != 0);

    /* mark value as used */
    drawn[value] = 1;

    /* debug statement */
    printf("%i\n", value);
    pdeck->card[i] = value;
  }
  pdeck->dealt = 0;
  return;
}

Guarde este ficheiro como shuffle.c. Pusemos uma frase de depuração no código para quando correr, escrever o número das cartas que gera. Isto não adiciona nenhuma funcionalidade ao programa, mas agora, é crucial para vermos o que se passa. Visto estarmos somente a começar o nosso jogo, não temos outro modo senão que termos a certeza que a nossa função está a fazer o que pretendemos. Com a frase printf, podemos ver exactamente o que está acontecer e assim quando passarmos para a próxima fase sabemos que o baralho esta bem baralhado. Depois de estarmos satisfeitos com o seu funcionamento podemos remover esta linha do nosso código. Esta técnica de fazer depuração aos programas parece arcaica mas fá-lo com um mínimo de trabalho irrelevante. Discutiremos mais tardes depuradores mais sofisticados.

1. Passamos por parâmetro o seu endereço, pode dizer isto pelo '&' (endereço de) operador. Isto passa o endereço de máquina da variável para a função, assim a função pode alterar a própria variável. É possível programar com variáveis globais, mas deviam ser utilizadas raramente. Os ponteiros são uma parte importante do C e devia entende-los também.
2. Estamos a utilizar uma chamada de função a partir do novo ficheiro .c. O sistema operativo procura sempre por uma função chamada 'main' e começa a sua execução aí. O shuffle.c não tem uma função 'main' por conseguinte não pode ser um executável por si só. Devemos combiná-lo com outro programa que tenha uma função 'main' e que chame a função shuffle.

Corra o comando

gcc -c shuffle.c

shuffle(&deck);

gcc -o game game.c

/tmp/ccmiHnJX.o: In function `main':
/tmp/ccmiHnJX.o(.text+0xf): undefined reference to `shuffle'
collect2: ld returned 1 exit status

O linker, ld, pega no código objecto previamente criado com as e transforma-o num executável através do comando

gcc -o game game.o shuffle.o

O linker encontra a função shuffle a partir do objecto shuffle.o e inclui-o no executável. A verdadeira beleza dos ficheiros objecto vem do facto se quisermos utilizarmos esta função novamente, só temos de incluir o ficheiro "deck.h" e ligar ao código do novo executável o ficheiro objecto shuffle.o.

O aproveitamento do código está sempre a acontecer. Não escrevemos o código da função printf quando a chamámos em cima como uma declaração de depuração, O linker encontra a sua definição no ficheiro que incluímos #include <stdlib.h> e liga-o ao código objecto armazenada na biblioteca C (/lib/libc.so.6). Deste modo podemos utilizar a função de alguém que sabemos trabalhar correctamente e preocuparmo-nos em resolver os nossos problemas. É por este motivo que os ficheiros de cabeçalho só contêm as definiç�es de dados e de funç�es e não o corpo das funç�es. Normalmente você cria os ficheiros objecto ou bibliotecas para o linker por no executável. Um problema podia ocorrer com o nosso código visto que não pusemos nenhum definição no nosso ficheiro cabeçalho. O que é que podemos fazer para ter a certeza que tudo corre sem problemas?

Mais duas Opç�es Importantes

A opção -Wall activa todo o tipo de avisos relativamente à sintaxe da linguagem para nos ajudar a ter a certeza que o nosso código está correcto e portável tanto quanto possível. Quando utilizamos esta opção e compilamos o nosso código podemos ver algo como:

game.c:9: warning: implicit declaration of function `shuffle'

void shuffle(deck_t *pdeck);

Uma outra opção comum do compilador é a optimização -O# (ou seja -O2). Isto diz ao compilador o nível de optimização que quer. O compilador tem um saco cheio de truques para tornar o seu código mais rápido. Para um pequeno programa como o nosso não notaremos qualquer diferença, mas para programas grandes pode melhorar um pouco a rapidez. Você vê esta opção em todo o lado por isso devia saber o que significa.

Depuração

Como todos sabemos, só porque o nosso código compilou não quer dizer que vai trabalhar do modo que queremos. Pode verificar que são utilizados todos os números de uma só vez correndo

game | sort - n | less

gcc -g -c shuffle.c game.c
gcc -g -o game game.o shuffle.o

Resumo

Esta artigo apresentou uma visita clara à compilação e depuração aos programas C. Discutimos os passos que o compilador faz e as opç�es que devemos passar ao gcc para ele fazer esses passos. Introduzimos a ligação a bibliotecas partilhadas e terminámos com uma introdução aos depuradores. Requer bastante trabalho para saber realmente, o que está a fazer, mas espero que isto o ajude a começar com o pé direito. Pode encontrar mais informação nas páginas man e info acerca do gcc, as e do ld.

Escrever código por si mesmo ensina-lhe o mais importante. Para praticar, podia utilizar estas bases simples do programa de jogo de cartas utilizado neste artigo e escrever um jogo de blackjack. Aproveite o tempo para aprender a utilizar um depurador. É muito mais fácil começar com um GUI como o KDbg. Se adicionar funcionalidade aos poucos, saberá as coisas sem se dar por isso. Lembre-se mantenha-o a correr!

Aqui estão algumas coisas que poderá precisas para criar um jogo completo.

• Uma definição do jogador de cartas (por exemplo podia definir o deck_t como definiu o player_t).
• Uma função que distribui um dado número de cartas a um dado jogador. Lembre-se de incrementar o número de 'distribuídas' do baralho para saber de onde deve tirar a próxima carta. Lembre-se de saber o número de cartas que cada jogador tem na mão.
• Alguma interacção dos utilizadores, para pedir se o utilizador quer outra carta.
• Uma função para apresentar as cartas de um jogador. A carta tem um valor de % 13 (a começar em 0 até 12), o naipe tem um valor de / 13 (a começar em 0 até 3).
• Uma função para determinar o valor das cartas que um utilizador tem na mão. Os ases são cartas com um valor de zero e podem valer 1 ou 11. Os reis têm valor 10 e no mínimo 10.

Ligaç�es

• gcc Colecção do compilador GCC da GNU
• gdb O Debugger da GNU
• KDbg Debugger GUI do KDE
• Compilador pirata Grande compilador pirata de Ken Thompson

Forma de respostas para este artigo

2002-03-16, generated by lfparser version 2.26