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

Aula 21 - 4/6/2002

Comentários sobre a Fase 3 do projeto: Dinâmica

• Para ler a entrada do teclado (o usuário vai usar o teclado para controlar o jogo) use as seguintes funções do xwc.
• /* Inicializa a captura de eventos de teclado */

void InitKBD(WINDOW *w);

/* Verifica se existe alguma tecla disponível */
int WCheckKBD(WINDOW *w);

/* Pega a próxima tecla e devolve o código X.
 * Veja em $INC/X11/keysymdef.h */
KeyCoDe WGetKey(WINDOW *w);

/* Devolve o KeySym da última tecla lida */
KeySym WLastKeySym();
 

• IMPORTANTE: note que há uma imprecisão no comentário que antecede a função WGetKey, o arquivo X11/keysymdef.h define o KeySym de cada tecla que é diferente do KeyCode (o KeySym é portável de uma arquitetura para outra mas o KeyCode não é). Assim, se você quiser o KeySym terá que primeiro chamar a função WGetKey() e depois obter o  KeySym  através da função WLastKeySym().

 
• No meu sistema, o arquivo /usr/X11R6/include/X11/keysymdef.h define o seguinte:

 

#define XK_Left   0xFF51 /* Move left, left arrow */
#define XK_Up     0xFF52 /* Move up, up arrow */
#define XK_Right  0xFF53 /* Move right, right arrow */
#define XK_Down   0xFF54 /* Move down, down arrow */
#define XK_j      0x06a
#define XK_k      0x06b

Pode ser uma boa dar duas opções para o usuário, e.g., além de usar as flechas, ele poderia também usar as teclas 'i', 'j', 'k' e 'k' para jogar.
 

• Se por algum motivo o método acima não funcionar na sua máquina, execute o programa xev. O xev  é um programa que abre uma janela do X e mostra todos os eventos que aquela janela recebe. Se você apertar uma tecla com a janela selecionada, o xev mostra uma série de informações incluindo o KeyCode e o KeySym.
• Em último caso (desespero total :-) você pode escrever um programinha que entra num laço que tudo o que ele faz é pegar caracteres do teclado e imprimir o seu código. Mas acho que não precisaremos chegar a este ponto :-).

Comentários Gerais

• Sempre evite escrever linhas de código maiores que 100 caracteres. É uma péssima prática.
• Evite usar 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 endentaçã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)

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.
• 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.
• 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

• Um artigo bem interessante sobre a escrita de expressões regulares: Five Habits for Successful Regular Expressions.
• Veja maiores detalhes sobre as ferramentas das últimas aulas na página de ponteiros.

Diferenças entre Linguagens Interpretadas e Linguagens Compiladas

• Compiladores vs. interpretadores
• Java: compilador (javac) + interpretador (JVM).
• JIT compilation.