********************************** ********** COM - Resumo ********** ********************************** Data : 14/11/2003 a 03/12/2003 Versão : 04/07/2007 Professor: Fabrício Jailson Barth Autor : Leandro Salvador ( leandrosalvador.com.br ) * Verificações - tipos - regras de operação - se existir um float seguido de um operador + seguido de um int, o resultado será float - hierarquia de tipos - coersão --> colocar um int num float - se uma variável tipo X pode receber um valor Y (mesmo tipo) - unicidade - cada variável definida apenas uma vez - declaração - todas as variáveis usadas já foram declaradas antecipadamente - escopo - área de atuação * Tabela de Símbolos - nome variável | tipo variável | escopo variável * Fluxo - fonte --> léxica --> sintática --> semântica* --> código intermediário --> interpretador --> código objeto - fonte --> léxica --> sintática --> semântica* --> código intermediário --> código máquina --> código objeto máquina - *semântica - tipos - unicidade - declaração - escopo - tabela de símbolos * Geração de Código - substitui sistema de nós e subárvores por segmento de código de destino, preservando a semântica - exemplo 1) - código origem x = (a + b) * (c - d); - comandos assembly - load - add - sub - mult - store - S --> V = T E --> V + V E --> V - V T --> E * E - árvore S /|\ .---´ | `---. / | \ / | \ V = T | /|\ x .---´ | `---. / | \ / | \ E * E /|\ /|\ .--´ | `--. .--´ | `--. / | \ / | \ / | \ / | \ V + V V - V | | | | a b c d - código destino E --> V + V load a t1 = a + b add b store t1 E --> V - V load c t2 = c - d sub d store t2 T --> E * E load t1 t3 = t1 * t2 mult t2 store t3 S --> V = T load t3 x = t3 store x - código destino otimizado load a load a load a load a add b add b add b add b store t1 store t1 store t1 store t1 load c load c load c load c sub d sub d sub d sub d store t2 store t2 store t2 load t1 load t1 ¯\/¯ load t2 mult t2 mult t2 _/\_ mult t1 mult t1 store t3 ¯¯\_ store x store x store x load t3 __/¯ store x - dicas otimização código --------------------- | store t3 | store x | | load t3 | | | store x | | --------------------- | store t2 | mult t1 | | load t2 | | | mult t1 | | --------------------- | load t1 | load t2 | | mult t2 | mult t1 | --------------------- * BNF com Recursão Esquerda ::= | ::= | ::= IDENTIFICADOR | NUM | * Fórmula A ::= Aa1 | Aa2 | ... | Aan | B1 | B2 | ... | Bn A ::= B1A' | B2A' | ... | BnA' A' ::= a1A' | a2A' | ... | anA' | T * Eliminação Recursão Esquerda - BNF ::= | - atribuições A = A' = a1 = B1 = - aplicação da fórmula -----A----- ::= -----A----- ------a1------ | --B1--- ::= | -----A----- ::= --B1--- -----A'----- ::= -----A'----- ::= ------a1------ -----A'----- ::= | NADA - recursão esquerda eliminada ::= | ::= ::= | NADA * Eliminação Recursão Esquerda - BNF ::= | - atribuições A = A' = a1 = B1 = - aplicação da fórmula ---A--- ::= ---A--- ------a1------ | --B2--- ::= | ---A--- ::= --B1--- ---A1--- ::= ---A'--- ::= ------a1------ --A1--- | NADA ::= TERMO2> | NADA - recursão esquerda eliminada ::= | ::= ::= | NADA * BNF sem Recursão Esquerda ::= ::= | NADA ::= ::= | NADA ::= IDENTIFICADOR | NUM | * Dica BNF - ::= ... | NADA - quando uma da BNF permite ser chamada por ela própria de maneira recursiva, é importante que exista a opção | NADA, pois caso contrário entrará em loop infinito, devido à recursividade - na codificação da , a eliminação da recursividade pode ser feita colocando-se um if no início do método, de forma que quando o método se chamar recursivamente, só entrará novamente no if caso o átomo atual seja compatível com aquele método, caso contrário, devolvará o controle do programa ao método que o chamou anteriormente * Expressões Regulares em Java - a classe String possui um método booleano chamado matches, o qual diz se uma String corresponde ou não a uma dada expressão regular - esse método recebe como parâmetro a String correspondente à expressão regular que deverá ser comparada com a String - exemplos true - "1".matches("[0-9]") - "a".matches("[a-z]") - "A".matches("[A-Z]") - "b".matches("[a-zA-Z]") - "B".matches("[a-zA-Z]") - "2".matches("[a-zA-Z_0-9]") - "c".matches("[a-zA-Z_0-9]") - "C".matches("[a-zA-Z_0-9]") - ".".matches("[.]") - muitas outras expressões regulares podem ser construídas, basta consultar o JavaDOC para maiores informações (regular expressions) - as expressões regulares facilitam muito as comparações que, sem elas, teriam que ser feitas varrendo um array com os caracteres desejados, o que seria muito mais trabalhoso e, provavelmente, menos robusto - link - C:/j2sdk1.4.2_02/docs/api/java/util/regex/Pattern.html#sum - http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/Pattern.html * Utilização de Matriz Bidimensional String[][] bidimensao = {{"a","b","c"},{"d","e","f","g"}}; System.out.println("length = " + bidimensao[1].length); ----------//----------