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

Aula 20- 29/5/2001

Busca e especificação de padrões

• No shell (e.g., bash)
• * qualquer cadeia de caracteres
• ? qualquer caractere
• [abcd] qualquer caractere no conjunto dado
• [a-zA-Z] qualquer caractere nos intervalos dados
• {nome1,nome2,nome3} qualquer um dos nomes dados
• Existem outras formas de especificar padrões usando Expressões Regulares.  Veja no final desta página todos os tipos de expressões regulares aceitas pela ferramenta Flex.

AWK

• O awk é uma ferramenta para tratamento de textos baseada em expressões regulares.
• O awk lê um script e o aplica na sua entrada.
• Um script awk é formado basicamente por pares do tipo
• PADRÃO  AÇÃO
• A entrada é quebrada em registros (normalmente linhas)
• Os registros são quebrados em campos (normalmente nos espaços em branco) que podem ser referenciados por $1, $2, ..., $n. $0 se refere ao registro todo.
• As variáveis não são declaradas. Elas passam a existir na primeira vez em que são usadas.
• Não existe tipo de variável. Cada variável pode conter qualquer tipo.
• Além das variáveis normais, podem ser utilizados vetores.  Os vetores no

entanto têm uma característica interessante: seus índices são cadeias de
caracteres (vetores associativos).  Veja o exemplo abaixo.
• Exemplo: Um contador de ocorrências de palavras, um dos exemplos mais comuns em

  AWK.  A variável especial NF contém o número de campos no registro corrente:

# freqüência de palavras
     {
         for (i = 1; i <= NF; i++)
             freq[$i]++
     }

END  {
         for (word in freq)
             printf "%s\t%d\n", word, freq[word]
     }

• Vejamos alguns exemplos mais (o script pode ser passado como primeiro argumento entre ' '):
• awk '/^[AEIOUaeiou]/'  imprime todas as linhas que começam com uma vogal.
• awk '$2 > $1' linhas cuja segunda palavra é maior   (numérica ou lexicograficamente) do que a primeira.  A comparação será   numérica se ambas palavras tiverem representação numérica.
• awk '/^[a-zA-Z]+ +[0-9]+ +x +[0-9]+ +[a-zA-Z]+/ && $2>$4':
  Resultados de jogos onde o primeiro time venceu (o nome do time não pode ter espaços).
• awk '/^[0-9]/ || $2 > 3$'  começando com dígito ou com o segundo campo maior do que o terceiro.
• awk '$1 ~ /Janeiro/' linhas cujo primeiro campo contém a expressão regular Janeiro.
• awk '$1 !~ /Janeiro/' linhas cujo primeiro campo não contém a expressão regular Janeiro.
• O operador ~ é chamado de "match" e diz se uma expressão casa com um determinado padrão especificado através de uma expressão regular. Os operadores ~ e !~ podem ser utilizados como no exemplo acima ou dentro de comandos if, while, e for.
• Mais um exemplo interessante:
•  ls -lg | awk '$6 == "Nov" { sum += $5 }

                  END { print sum }'
• Onde a saída do comando ls -lg é algo como:

     -rw-r--r--  1 arnold   user   1933 Nov  7 13:05 Makefile
     -rw-r--r--  1 arnold   user  10809 Nov  7 13:03 gawk.h
     -rw-r--r--  1 arnold   user    983 Apr 13 12:14 gawk.tab.h
     -rw-r--r--  1 arnold   user  31869 Jun 15 12:20 gawk.y
     -rw-r--r--  1 arnold   user  22414 Nov  7 13:03 gawk1.c
     -rw-r--r--  1 arnold   user  37455 Nov  7 13:03 gawk2.c
     -rw-r--r--  1 arnold   user  27511 Dec  9 13:07 gawk3.c
     -rw-r--r--  1 arnold   user   7989 Nov  7 13:03 gawk4.c

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 se 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.
• Exemplo1: um contador de caracteres e linhas.
• Exemplo2: um analisador léxico para uma linguagem similar a Pascal.
• Expressões regulares aceitar 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 NUL 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 below 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

• Veja maiores detalhes sobre as ferramentas das últimas aulas na página de ponteiros.