Notas de Aula - MAC 211 - Laboratório de Programação

Aula 18 - 29/4/2010

Sobre Estilo de codificação para o Projeto - boas práticas

• Invista sempre alguma energia para escolher o melhor nome possível para suas variáveis, funções e arquivos. Não adote simplesmente a primeira coisa que lhe vier à cabeça. Os nomes tem que ser reveladores da intenção (intention revealing names).
  
• Sempre evite escrever linhas de código maiores que 100 caracteres. É uma péssima prática.
  
  
• Seu grupo deve adotar um estilo único de codificação. Faça uma pequena reunião para decidir os padrões do grupo para:
• localização dos { }
• escolha de padrão de maiúsculas e minúsculas e _ para nomes de variáveis, funções, etc.
• estilo dos comentários
• indentação
• etc.
  
• Dependendo do contexto, pode ser interessante evitar o uso de TABs no seu código, é muito provável que alguém vá lê-lo em um ambiente ondes os TABs estão definidos de uma forma diferente e o seu programa vai aparecer com uma indentação toda maluca. Se você inserir a seguinte linha no seu arquivo .emacs, o emacs vai automaticamente colocar um certo número de espaços quando você digitar a tecla TAB.
• ;use spaces instead of tabs for indenting
(setq-default indent-tabs-mode nil)

• Modularização: procure dividir o seu programa em funções que tratam de um mesmo aspecto e colocar cada um destes aspectos em um arquivo diferente.
  Da mesma forma, evite arquivos muito grandes, o máxima aceitável são algumas poucas centenas de linhas.
  
• Minimize o número de variáveis globais e evite ao máximo que funções de um arquivo tenham que conhecer detalhes das funções de outro arquivo.
  
• Crie um bom makefile para gerenciar o seu processo de compilação.
  
  
• Crie um arquivo LEIAME que forneça informações relevantes sobre a estruturação do seu código, sobre como compilá-lo e como executá-lo.

GNU FLEX

• A ferramenta GNU Flex é um gerador de analisadores léxicos, ou seja, a sua saída é um programa que, depois de ser compilado, se torna um analisador de itens léxicos. Chique, né? Em computação é relativamente comum usarmos programas para gerar outros programas.
  
• O formato da entrada do Flex é
  
• definitions
%%
rules
%%
user code

• Na primeira parte, você pode colocar qualquer definição inicial que o seu analisador precise.
• Na parte final, você pode colocar a função main() do seu programa ou outras funções que você escrever.
• Na parte do meio, "rules", você coloca uma série de regras que definem os tipos léxicos entendidos pelo seu analisador e que são utilizadas pelo flex para gerar o código do analisador.
• Se duas regras casam com o texto da entrada, o flex considera a regra que casa com o texto mais longo. Se o comprimento do texto é igual, a regra que é definida antes é utilizada.
  
  
• yylex() é a função que deve ser chamada para executar o analisador léxico.
• yytext é um apontador para uma cadeia de caracteres contendo o último item léxico reconhecido.
• yyin é o descritor do arquivo de entrada que será processado.
  
  
• Exemplo1: um contador de caracteres e linhas.
• Exemplo2: um analisador léxico para uma linguagem similar a Pascal.
  
• Para compilar os exemplos, use gcc lex.yy.c -lfl



• Expressões regulares aceitas pelo Flex em suas regras:
 
• `x' match the character `x'

`.' any character (byte) except newline
`[xyz]'
    a "character class"; in this case, the pattern matches either an `x', a `y', or a `z'
`[abj-oZ]'
    a "character class" with a range in it; matches an `a', a `b', any letter from `j' through `o', or a `Z'
`[^A-Z]'
    a "negated character class", i.e., any character but those in the class. In this case, any character EXCEPT an uppercase letter.
`[^A-Z\n]'
    any character EXCEPT an uppercase letter or a newline
`r*'
    zero or more r's, where r is any regular expression
`r+'
    one or more r's
`r?'
    zero or one r's (that is, "an optional r")
`r{2,5}'
    anywhere from two to five r's
`r{2,}'
    two or more r's
`r{4}'
    exactly 4 r's
`{name}'
    the expansion of the "name" definition (see above)
`"[xyz]\"foo"'
    the literal string: `[xyz]"foo'
`\x'
    if x is an `a', `b', `f', `n', `r', `t', or `v', then the ANSI-C interpretation of \x. Otherwise, a literal `x' (used to escape operators such as `*')
`\0'
    a NULL character (ASCII code 0)
`\123'
    the character with octal value 123
`\x2a'
    the character with hexadecimal value 2a
`(r)'
    match an r; parentheses are used to override precedence (see below)
`rs'
    the regular expression r followed by the regular expression s; called "concatenation"
`r|s'
    either an r or an s
`r/s'
    an r but only if it is followed by an s. The text matched by s is included when determining whether this rule is the longest match, but is then returned to the input before the action is executed. So the action only sees the text matched by r. This type of pattern is called trailing context. (There are some combinations of `r/s' that flex cannot match correctly; see notes in the Deficiencies/Bugs section of the manual regarding "dangerous trailing context".)
`^r'
    an r, but only at the beginning of a line (i.e., which just starting to scan, or right after a newline has been scanned).
`r$'
    an r, but only at the end of a line (i.e., just before a newline). Equivalent to "r/\n". Note that flex's notion of "newline" is exactly whatever the C compiler used to compile flex interprets '\n' as; in particular, on some DOS systems you must either filter out \r's in the input yourself, or explicitly use r/\r\n for "r$".
`<s>r'
    an r, but only in start condition s (see below for discussion of start conditions) <s1,s2,s3>r same, but in any of start conditions s1, s2, or s3
`<*>r'
    an r in any start condition, even an exclusive one.
`<<EOF>>'
    an end-of-file
`<s1,s2><<EOF>>'
    an end-of-file when in start condition s1 or s2

• Regras válidas por um período limitado.
• É possível declarar um conjunto de regras que só são válidas temporariamente, com condição incial (start condition).  Para ativá-las, usa-se a macro

BEGIN(nome), onde nome é o nome do conjunto de regras.  Estas regras são identificadas por conterem a cadeia <nome> no início da condição.

• Para cancelar as regras extras, usa-se BEGIN(0).  Mais de um conjunto pode ser ativado a qualquer momento.
  
• Os nomes das regras extras devem ser declarados de uma das seguintes formas, na primeira seção da especificação:
• Com %s nome declara-se regras adicionais.  Quando ativadas, elas se somam às regras sem qualificação especial.
• Com %x nome declara-se regras exclusivas.  Isto é, quando ativadas, apenas estas regras valem.
  
• In addition to characters and ranges of characters, character classes can also contain character class "expressions". These are expressions enclosed inside `[': and `:'] delimiters (which themselves must appear between the '[' and ']' of the character class; other elements may occur inside the character class, too). The valid expressions are:
  
  [:alnum:] [:alpha:] [:blank:]
  [:cntrl:] [:digit:] [:graph:]
  [:lower:] [:print:] [:punct:]
  [:space:] [:upper:] [:xdigit:]
  
  These expressions all designate a set of characters equivalent to the corresponding standard C `isXXX' function. For example, `[:alnum:]' designates those characters for which `isalnum()' returns true - i.e., any alphabetic or numeric. Some systems don't provide `isblank()', so flex defines `[:blank:]' as a blank or a tab. For example, the following character classes are all equivalent:
  
  [[:alnum:]]
  [[:alpha:][:digit:]
  [[:alpha:]0-9]
  [a-zA-Z0-9]
  
  
• No exemplo a seguir, isso ficará mais claro.
  
• Um exemplo mais complicadinho usando Flex: um conversor de real para dólar.
  
• O Exemplo usa a seguinte função:
•  SYNOPSIS

     #include <monetary.h>

     ssize_t strfmon(char *s, size_t maxsize, const char *format, ...);

 DESCRIPTION
     The strfmon() function  places  characters  into  the  array
     pointed  to  by  s as controlled by the string pointed to by
     format. No more than  maxsize  bytes  are  placed  into  the
     array.

• /* Conversor de real para dolar */
  /* O primeiro argumento do programa é a taxa de conversão */
  /* O programa converte valores monetários com prefixo R$ para US$.  Os
   * milhares devem estar separados por '.' e os centavos por ',', uma vez
   * que o "locale" foi definido para o Brasil.  Isto não vale para o
   * argumento do programa.
   */

  %{
  #include <math.h>
  #include <locale.h>

  double taxa = 2.1;

  void converte(double d) {
    char b[2048];
    strfmon(b,2048,"%!n", d/taxa);
    printf("US$%s", b);
  }
  %}

  MILHAR   [[:digit:]]{3}
  VAL      -?[[:digit:]][[:digit:]]?[[:digit:]]?
  CENT     [[:digit:]]{2}

  SEP [[:space:]]*

  double valor=0.;
  %s VALOR  MEIO

  %%

  R[$]{SEP} BEGIN(VALOR);

  <VALOR>{VAL} {
                 valor = atof(yytext);
                 BEGIN(MEIO);
               }
  <MEIO>[.]{MILHAR} {
                      valor *=1000;
                      valor += atof(++yytext);
                    }
  <MEIO,VALOR>[,]{CENT} {
                          valor += atof(++yytext)/100;
                          converte(valor);
                          valor = 0.;
                          BEGIN(0);
                        }

  <VALOR,MEIO>. {
                       converte(valor);
                       valor = 0.;
                       BEGIN(0);
                }
   

  . ECHO;

  %%

  int main(int ac, char **av)
  {
    ac--, av++;
    if (ac)
      {
          taxa = atof(*av);
          ac--, av++;
      }
   
   

    if (!taxa)
      {
          fprintf(stderr,"Taxa inaceitável\n");
          exit(1);
      }

    setlocale(LC_ALL,"pt_BR");

    if (ac) yyin = fopen(*av,"r");
    yylex();
  }

• Um artigo bem interessante sobre a escrita de expressões regulares: Five Habits for Successful Regular Expressions.