API tools faq
paste
Advertisement
jacknpoe

Separador logradouro/numero/complemento (1.1.1)

jacknpoe
Feb 28th, 2016
460
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
PHP 22.32 KB | None | 0 0
raw download clone embed print report
  1. <?php
  2.     //***********************************************************************************************
  3.     // AUTOR: Ricardo Erick Rebêlo
  4.     // Objetivo: separar um endereço em logradouro / número / complemento
  5.     // Obs.: tudo o que aparece após o número é considerado complemento
  6.     // Versão Original: 01/10/2009 - Ricardo Erick Rebêlo
  7.     // Alterações:
  8.     // 1.0   27/06/2010 - Versão final da primeira conversão
  9.     // 1.01  26/02/2016 - Recuperada versão mais recente de http://pastebin.com/5cqxEsAU de 15/10/2013
  10.     //                   após perda da versão de trabalho na desinstalação do XAMPP
  11.     // 1.1   26/02/2016 - alteração para uso em php 5.3.0 com namespace jacknpoe
  12.     // 1.1.1 16/03/2016 - correção menor e inclusão de outros caracteres latin1 na tabela_conversao
  13.  
  14.  
  15.     namespace jacknpoe;
  16.  
  17.     //***********************************************************************************************
  18.     // constante indefinida para todas as classes de constantes - NÃO REDEFINIR
  19.     define( "INDEFINIDO", 0);
  20.  
  21.     // informações sobre os TOKENs
  22.     define( "TOKEN_INF_TIPO", 1);
  23.     define( "TOKEN_INF_VALOR", 2);
  24.     define( "TOKEN_INF_FORMATADO", 3);
  25.     define( "TOKEN_INF_INICIO", 4);
  26.     define( "TOKEN_INF_TAMANHO", 5);
  27.  
  28.  
  29.     //***********************************************************************************************
  30.     // Classe Parser
  31.  
  32.     class ParserEndereco
  33.     {
  34.  
  35.         // CONSTANTES
  36.  
  37.         // versão atual da classe
  38.         const VERSAO = '1.1.1';
  39.  
  40.         // tipos de tokens
  41.         const TOKEN_NOME = 1;
  42.         const TOKEN_NUMERO = 2;
  43.         const TOKEN_N_NUMERO = 3;
  44.         const TOKEN_DIVISOR = 25;
  45.         const TOKEN_IND_LOG = 51;
  46.         const TOKEN_IND_NUM = 52;
  47.         const TOKEN_IND_COM = 53;
  48.         const TOKEN_IND_LOC = 54;
  49.         const TOKEN_IND_ANT = 55;
  50.  
  51.         // estados do autômato (AFD)
  52.         const ESTADO_INICIAL = 1;
  53.         const ESTADO_DIVISOR = 2;
  54.         const ESTADO_N = 3;
  55.         const ESTADO_HIFEN = 4;
  56.         const ESTADO_NUMERO = 5;
  57.         const ESTADO_NUMERO2 = 6;
  58.         const ESTADO_CARACTER = 7;
  59.         const ESTADO_NUMERO3 = 8;
  60.         const ESTADO_CARACTER2 = 9;
  61.  
  62.         // tipos de caracteres
  63.         const CHAR_NULO = 1;
  64.         const CHAR_LETRA = 2;
  65.         const CHAR_NUMERO = 3;
  66.         const CHAR_VELHA = 4;
  67.         const CHAR_N = 5;
  68.         const CHAR_HIFEN = 6;
  69.         const CHAR_DIVISOR = 7;
  70.         const CHAR_VIRGULA = 8;
  71.  
  72.  
  73.         // ATRIBUTOS
  74.  
  75.         private $_tokens;
  76.         private $_nomes_tokens = array(
  77.             INDEFINIDO => '?',
  78.             self::TOKEN_NOME => 'nome',
  79.             self::TOKEN_NUMERO => 'número',
  80.             self::TOKEN_N_NUMERO => 'NNúmero',
  81.             self::TOKEN_DIVISOR => 'divisor',
  82.             self::TOKEN_IND_LOG => 'IndLog',
  83.             self::TOKEN_IND_NUM => 'IndNum',
  84.             self::TOKEN_IND_COM => 'IndCom',
  85.             self::TOKEN_IND_LOC => 'IndLoc',
  86.             self::TOKEN_IND_ANT => 'IndAnt' );      // utilizar em registros para depuração
  87.  
  88.         public $logradouro = '';
  89.         public $numero = '';
  90.         public $complemento = '';
  91.  
  92.  
  93.         // MÉTODOS
  94.  
  95.         function __construct()
  96.         {
  97.             $this->_tokens = new TokenEndereco();
  98.         }
  99.  
  100.  
  101.         function getNomeToken( $tipo)       // recupera o nome de um token para registros de depuração
  102.         {
  103.             return $this->_nomes_tokens[ $tipo];
  104.         }
  105.  
  106.         function reconhecerEndereco( $endereco)     // reconhece logradouro, número e complemento
  107.         {
  108.             $inicio = ( $tamanho = ( $token_numero = ( $fim_logradouro = 0)));
  109.  
  110.             $endereco = trim( $endereco);
  111.  
  112.             $this->reconhecerTokens( $endereco);        // reconhece os tokens (preenche $this->_tokens)
  113.  
  114.             $n_tokens = $this->_tokens->getNumeroTokens();
  115.  
  116.             // SINTAXE / Construções Gramaticais (regras de alteração)
  117.  
  118.             for( $contador = 1; $contador <= $n_tokens; $contador ++ )      // devemos fazer as regras em todos os tokens
  119.             {
  120.                 if( $this->_tokens->getTokenInfo( $contador, TOKEN_INF_TIPO) === self::TOKEN_NUMERO )       // coincidentemente, todas contém <num>
  121.                 {
  122.                     // regra 1   ( <num><Iant> -> <nome><nome> )
  123.                     if( $this->_tokens->getTokenInfo( $contador+1, TOKEN_INF_TIPO) === self::TOKEN_IND_ANT )
  124.                     {
  125.                         $this->_tokens->setTokenInfo( $contador, TOKEN_INF_TIPO, self::TOKEN_NOME);
  126.                         $this->_tokens->setTokenInfo( $contador+1, TOKEN_INF_TIPO, self::TOKEN_NOME);
  127.                     }
  128.  
  129.                     // regras 2 e 3   (  <Iloc><num> -> <Iloc><nome>,   <Icom><num> -> <Icom><nome> )
  130.                     if( in_array( $this->_tokens->getTokenInfo( $contador-1, TOKEN_INF_TIPO), array( self::TOKEN_IND_COM, self::TOKEN_IND_LOC ), TRUE ) )
  131.                         $this->_tokens->setTokenInfo( $contador, TOKEN_INF_TIPO, self::TOKEN_NOME);
  132.  
  133.                     // regra 4   ( <Inum><num> -> <Inum><Nnum> )
  134.                     if( $this->_tokens->getTokenInfo( $contador-1, TOKEN_INF_TIPO) === self::TOKEN_IND_NUM )
  135.                         $this->_tokens->setTokenInfo( $contador, TOKEN_INF_TIPO, self::TOKEN_N_NUMERO);
  136.                        
  137.                     // regra 5   ( <num><Ilog><num> -> <num><Ilog><Nnum> )
  138.                     if( $this->_tokens->getTokenInfo( $contador-1, TOKEN_INF_TIPO) === self::TOKEN_IND_LOG )
  139.                     {
  140.                         if( $this->_tokens->getTokenInfo( $contador-2, TOKEN_INF_TIPO) === self::TOKEN_NUMERO )
  141.                         {
  142.                             $this->_tokens->setTokenInfo( $contador, TOKEN_INF_TIPO, self::TOKEN_N_NUMERO);
  143.                         }
  144.                     // regra 6   ( <Ilog><num> -> <Ilog><nome> )
  145.                         else
  146.                         {
  147.                             $this->_tokens->setTokenInfo( $contador, TOKEN_INF_TIPO, self::TOKEN_NOME);
  148.                         }
  149.                     }
  150.                 }
  151.             }
  152.  
  153.             // UMA DAS REGRAS DA SEMÂNTICA
  154.  
  155.             // primeira regra (especial: se existir TOKEN_N_NUMERO, esse é o número no endereço)
  156.             for( $contador = 1; $contador <= $n_tokens; $contador ++ )
  157.             {
  158.                 if( $this->_tokens->getTokenInfo( $contador, TOKEN_INF_TIPO) === self::TOKEN_N_NUMERO )
  159.                 {
  160.                     $token_numero = $contador;
  161.                     break;
  162.                 }
  163.             }
  164.    
  165.             // ÚLTIMA REGRA DA SINTAXE (apenas se a primeira semântica falhar)
  166.  
  167.             if( $token_numero == 0)
  168.             {
  169.                 for( $contador = 1; $contador <= $n_tokens; $contador ++ )
  170.                 {
  171.                     // regra 7   ( <nome><num> -> <nome><Nnum> )
  172.                     if( $this->_tokens->getTokenInfo( $contador, TOKEN_INF_TIPO) === self::TOKEN_NUMERO )
  173.                     {
  174.                         if( $this->_tokens->getTokenInfo( $contador-1, TOKEN_INF_TIPO) === self::TOKEN_NOME )
  175.                             $this->_tokens->setTokenInfo( $contador, TOKEN_INF_TIPO, self::TOKEN_N_NUMERO);
  176.                     }
  177.                 }
  178.  
  179.             // SEMÂNTICA (excetuando a primeira regra especial; principalmente exceções)
  180.  
  181.                 for( $contador = $n_tokens; $contador >= 1; $contador -- )
  182.                 {
  183.                     // procuramos por um <Nnum> convertido na última regra sintática, mas da direita para a esquerda
  184.                     if( $this->_tokens->getTokenInfo( $contador, TOKEN_INF_TIPO) === self::TOKEN_N_NUMERO )
  185.                     {
  186.                         $token_numero = $contador;
  187.                         break;
  188.                     }
  189.                 }
  190.             }
  191.  
  192.             // neste ponto, se $token_numero == 0, não existe número e apenas procuramos pelo S/N
  193.  
  194.             if( $token_numero == 0)
  195.             {
  196.                 for( $contador = 1; $contador <= $n_tokens; $contador ++ )
  197.                 {
  198.                     if( strpos( '|SN|SNO|SNRO|', $this->_tokens->getTokenInfo( $contador, TOKEN_INF_FORMATADO)) !== FALSE )
  199.                     {
  200.                         $inicio = $this->_tokens->getTokenInfo( $contador, TOKEN_INF_INICIO);
  201.                         $tamanho = $this->_tokens->getTokenInfo( $contador, TOKEN_INF_TAMANHO);
  202.                         $fim_logradouro = ( $this->_tokens->getTokenInfo( $contador-1, TOKEN_INF_TIPO) === self::TOKEN_IND_NUM
  203.                                             ? $this->_tokens->getTokenInfo( $contador-1, TOKEN_INF_INICIO) : $inicio ) - 1 ;
  204.                         $token_numero = $contador;
  205.                         break;
  206.                     }
  207.  
  208.                     if( strpos( '|SN|SNO|SNRO|', $this->_tokens->getTokenInfo( $contador, TOKEN_INF_FORMATADO) .
  209.                                                  $this->_tokens->getTokenInfo( $contador+1, TOKEN_INF_FORMATADO)) !== FALSE )
  210.                     {
  211.                         $inicio = $this->_tokens->getTokenInfo( $contador, TOKEN_INF_INICIO);
  212.                         $tamanho = $this->_tokens->getTokenInfo( $contador,  TOKEN_INF_INICIO)
  213.                                  + $this->_tokens->getTokenInfo( $contador+1, TOKEN_INF_TAMANHO)
  214.                                  - $this->_tokens->getTokenInfo( $contador, TOKEN_INF_INICIO);
  215.                         $fim_logradouro = ( $this->_tokens->getTokenInfo( $contador-1, TOKEN_INF_TIPO) === self::TOKEN_IND_NUM
  216.                                             ? $this->_tokens->getTokenInfo( $contador-1, TOKEN_INF_INICIO) : $inicio ) - 1 ;
  217.                         $token_numero = $contador;
  218.                         break;
  219.                     }
  220.                 }
  221.  
  222.             // neste ponto, se $token_numero == 0, não existe número nem S/N
  223.  
  224.                 if( $token_numero == 0)
  225.                 {
  226.                     $this->logradouro = $this->retornarSemSimbolos( $endereco);
  227.                     $this->numero = '-';
  228.                     $this->complemento = '';
  229.                     return FALSE ;
  230.                 }
  231.             }
  232.             else
  233.             {
  234.                 $inicio = $this->_tokens->getTokenInfo( $token_numero, TOKEN_INF_INICIO);
  235.                 $tamanho = $this->_tokens->getTokenInfo( $token_numero, TOKEN_INF_TAMANHO);
  236.                 $fim_logradouro = ( $this->_tokens->getTokenInfo( $token_numero-1, TOKEN_INF_TIPO) === self::TOKEN_IND_NUM
  237.                                     ? $this->_tokens->getTokenInfo( $token_numero-1, TOKEN_INF_INICIO) : $inicio ) - 1 ;
  238.             }
  239.  
  240.             $this->logradouro = $this->retornarSemSimbolos( substr( $endereco, 0, $fim_logradouro));
  241.             $this->numero = $this->retornarSemSimbolos( substr( $endereco, $inicio-1, $tamanho));
  242.             $this->complemento = $this->retornarSemSimbolos( substr( $endereco, $inicio + $tamanho-1));
  243.    
  244.             return TRUE;
  245.         }
  246.  
  247.         private function retornarSemSimbolos( $texto)       // retira espaços e símbolos (ver abaixo) do início e do final de um texto
  248.         {
  249.             $antiga = '';
  250.             $texto = trim( $texto);
  251.  
  252.             while( $antiga != $texto)
  253.             {
  254.                 $antiga = $texto;
  255.  
  256. //              strpos( '|SN|SNO|SNRO|', $this->_tokens->getTokenInfo( $contador, TOKEN_INF_FORMATADO)) !== FALSE
  257.                 if( strpos( '!@"#$%-=*&,.;:/?´^~_§°', $texto[0]) !== FALSE)
  258.                     $texto = substr( $texto, 1);
  259.  
  260.                 if( strpos( '!@"#$%-=*&,.;:/?´^~_§°', $texto[ strlen( $texto)-1 ]) !== FALSE)
  261.                     $texto = substr( $texto, 0, -1);    //  $texto = substr( $texto, 0, strlen( $texto)-1);
  262.  
  263.                 $texto = trim( $texto);
  264.             }
  265.  
  266.             return $texto;
  267.         }
  268.  
  269.         private function reconhecerTokens( $endereco)
  270.         {
  271.             $this->_tokens->excluirTodos();
  272.  
  273.             if( $endereco === '' or ! is_string( $endereco)) return;
  274.  
  275.             $inicio = 1;
  276.  
  277.             while( $endereco != '')
  278.             {
  279.                 $posicao = 1;
  280.                 $estado = self::ESTADO_INICIAL;
  281.                 $tamanho = strlen( $endereco);
  282.                 $token_encontrado = FALSE;
  283.  
  284.                 while( ! $token_encontrado)
  285.                 {
  286.                     $caracter = $this->avaliarCaracter( $endereco[ $posicao - 1]);
  287.  
  288.                     if( $caracter !== self::CHAR_NULO )
  289.                     {
  290.                         switch( $estado)
  291.                         {
  292.                             case self::ESTADO_INICIAL:
  293.                                 switch( $caracter)
  294.                                 {
  295.                                     case self::CHAR_DIVISOR :
  296.                                     case self::CHAR_VELHA :
  297.                                     case self::CHAR_VIRGULA :
  298.                                         $estado = self::ESTADO_DIVISOR ;
  299.                                         break;
  300.                                     case self::CHAR_N :
  301.                                         $estado = self::ESTADO_N ;
  302.                                         break;
  303.                                     case self::CHAR_HIFEN :
  304.                                         $estado = self::ESTADO_HIFEN ;
  305.                                         break;
  306.                                     case self::CHAR_NUMERO :
  307.                                         $estado = self::ESTADO_NUMERO ;
  308.                                         break;
  309.                                     default:
  310.                                         $estado = self::ESTADO_CARACTER ;
  311.                                 }
  312.                                 break;
  313.  
  314.                             case self::ESTADO_DIVISOR:
  315.                                 if ( in_array( $caracter, array( self::CHAR_LETRA, self::CHAR_NUMERO, self::CHAR_N )))
  316.                                 {
  317.                                     $posicao --;
  318.                                     $token_encontrado = TRUE;
  319.                                 }
  320.                                 break;
  321.  
  322.                             case self::ESTADO_N:
  323.                             case self::ESTADO_CARACTER2:
  324.                                 if ( in_array( $caracter, array( self::CHAR_LETRA, self::CHAR_N )))
  325.                                 {
  326.                                     $estado = self::ESTADO_CARACTER ;
  327.                                 }
  328.                                 else
  329.                                 {
  330.                                     $posicao --;
  331.                                     $token_encontrado = TRUE;
  332.                                 }
  333.                                 break;
  334.  
  335.                             case self::ESTADO_HIFEN:
  336.                                 if ( in_array( $caracter, array( self::CHAR_DIVISOR, self::CHAR_HIFEN, self::CHAR_VIRGULA )))
  337.                                 {
  338.                                     if ( $caracter != self::CHAR_HIFEN) $estado = self::CHAR_DIVISOR ;
  339.                                 }
  340.                                 else
  341.                                 {
  342.                                     $posicao --;
  343.                                     $token_encontrado = TRUE;
  344.                                 }
  345.                                 break;
  346.  
  347.                             case self::ESTADO_CARACTER:
  348.                                 if ( $caracter == self::CHAR_HIFEN ) $estado = self::ESTADO_CARACTER2 ;
  349.  
  350.                                 if ( in_array( $caracter, array( self::CHAR_DIVISOR, self::CHAR_VELHA, self::CHAR_VIRGULA )))
  351.                                 {
  352.                                     $posicao --;
  353.                                     $token_encontrado = TRUE;
  354.                                 }
  355.                                 break;
  356.  
  357.                             case self::ESTADO_NUMERO:
  358.                                 if ( in_array( $caracter, array( self::CHAR_DIVISOR, self::CHAR_HIFEN, self::CHAR_VELHA )))
  359.                                 {
  360.                                     $posicao --;
  361.                                     $token_encontrado = TRUE;
  362.                                 }
  363.                                 elseif ( $caracter != self::CHAR_NUMERO )
  364.                                 {
  365.                                     $estado = ( $caracter == self::CHAR_LETRA ? self::ESTADO_NUMERO3 : self::ESTADO_NUMERO2);
  366.                                 }
  367.                                 break;
  368.  
  369.                             case self::ESTADO_NUMERO2:
  370.                                 if ( in_array( $caracter, array( self::CHAR_DIVISOR, self::CHAR_HIFEN, self::CHAR_VELHA, self::CHAR_VIRGULA, self::CHAR_LETRA )))
  371.                                 {
  372.                                     $posicao --;
  373.                                     $token_encontrado = TRUE;
  374.                                 }
  375.                                 else
  376.                                 {
  377.                                     $estado = ( $caracter == self::CHAR_NUMERO ? self::ESTADO_NUMERO : self::ESTADO_CARACTER);
  378.                                 }
  379.                                 break;
  380.  
  381.                             case self::ESTADO_NUMERO3:
  382.                                 if ( in_array( $caracter, array( self::CHAR_DIVISOR, self::CHAR_HIFEN, self::CHAR_VELHA, self::CHAR_VIRGULA)))
  383.                                 {
  384.                                     $posicao --;
  385.                                     $token_encontrado = TRUE;
  386.                                 }
  387.                                 else
  388.                                 {
  389.                                     $estado = ( $caracter == self::CHAR_NUMERO ? self::ESTADO_NUMERO : self::ESTADO_CARACTER);
  390.                                 }
  391.                                 break;
  392.  
  393.                             default:
  394.                                 // erro (futura implementação?)
  395.                         }   // switch $estado
  396.                     }   // if $caracter nulo
  397.  
  398.                     if ( ! $token_encontrado)
  399.                     {
  400.                         if ( $posicao < $tamanho)
  401.                         {
  402.                             $posicao ++;
  403.                         }
  404.                         else
  405.                         {
  406.                             $token_encontrado = TRUE;
  407.                         }
  408.                     }
  409.                 }   // while !$token_encontrado
  410.  
  411.                 switch ( $estado)
  412.                 {
  413.                     case self::ESTADO_INICIAL:
  414.                     case self::ESTADO_DIVISOR:
  415.                     case self::ESTADO_HIFEN:
  416.                         $token = self::TOKEN_DIVISOR;
  417.                         break;
  418.                     case self::ESTADO_N:
  419.                     case self::ESTADO_CARACTER:
  420.                     case self::ESTADO_CARACTER2:
  421.                         $token = self::TOKEN_NOME;
  422.                         break;
  423.                     case self::ESTADO_NUMERO:
  424.                     case self::ESTADO_NUMERO2:
  425.                     case self::ESTADO_NUMERO3:
  426.                         $token = self::TOKEN_NUMERO;
  427.                         break;
  428.                     default:
  429.                         // erro (futura implementação?)
  430.                 }
  431.  
  432.                 $valor = substr( $endereco, 0, $posicao);
  433.                 $formatado = $this->formatar( $valor);
  434.                 $token = $this->retornarPalavraChave( $formatado, $token);
  435.  
  436.                 if ( $token != self::TOKEN_DIVISOR )
  437.                 {
  438.                     $this->_tokens->incluirToken( $token, $valor, $formatado, $inicio, $posicao);
  439.                 }
  440.  
  441.                 $inicio += $posicao;
  442.                 $endereco = substr( $endereco, $posicao);
  443.             }   // while $endereco
  444.         }   // function
  445.        
  446.         private $_tabela_conversao = array(
  447.             // C0 a FF (todas, em ordem)
  448.             'À'=>'A', 'Á'=>'A', 'Â'=>'A', 'Ã'=>'A', 'Ä'=>'A', 'Å'=>'A', 'Æ'=>'AE', 'Ç'=>'C',
  449.             'È'=>'E', 'É'=>'E', 'Ê'=>'E', 'Ë'=>'E', 'Ì'=>'I', 'Í'=>'I', 'Î'=>'I',  'Ï'=>'I',
  450.             'Ð'=>'D', 'Ñ'=>'N', 'Ò'=>'O', 'Ó'=>'O', 'Ô'=>'O', 'Õ'=>'O', 'Ö'=>'O',  '×'=>'x',
  451.             'Ø'=>'O', 'Ù'=>'U', 'Ú'=>'U', 'Û'=>'U', 'Ü'=>'U', 'Ý'=>'Y', 'Þ'=>'B', 'ß'=>'Ss',
  452.             'à'=>'a', 'á'=>'a', 'â'=>'a', 'ã'=>'a', 'ä'=>'a', 'å'=>'a', 'æ'=>'ae', 'ç'=>'c',
  453.             'è'=>'e', 'é'=>'e', 'ê'=>'e', 'ë'=>'e', 'ì'=>'i', 'í'=>'i', 'î'=>'i',  'ï'=>'i',
  454.             'ð'=>'o', 'ñ'=>'n', 'ò'=>'o', 'ó'=>'o', 'ô'=>'o', 'õ'=>'o', 'ö'=>'o',  '÷'=>'/',
  455.             'ø'=>'o', 'ù'=>'u', 'ú'=>'u', 'û'=>'u', 'ü'=>'u', 'ý'=>'y', 'þ'=>'b',  'ÿ'=>'y',
  456.             // A0 a BF (algumas, fora de ordem)
  457.             '°'=>'o', 'º'=>'o', 'ª'=>'a', '¢'=>'c', '¹'=>'1', '²'=>'2', '³'=>'3',  '£'=>'L',
  458.             '¥'=>'Y', '¦'=>'|', '§'=>'S', '©'=>'C', '­'=>'-', '®'=>'R', 'µ'=>'u'
  459.             ); // retirado do manual do PHP (allixsenos at gmail dot com)
  460.                // alterada ordem e acrescentados alguns caracteres para compatibilizar melhor
  461.  
  462.         private function retirarAcentosEEspeciais( $texto)
  463.         {
  464.             return strtr( $texto, $this->_tabela_conversao);    // retirado do manual do PHP (allixsenos at gmail dot com)
  465.         }
  466.  
  467.         private function apenasLetrasENumeros( $texto)
  468.         {
  469.             $texto = $this->retirarAcentosEEspeciais( $texto);
  470.  
  471.             $texto_temp = '';
  472.  
  473.             for ( $contador = 0; $contador < strlen( $texto); $contador++ )
  474.             {
  475.                 $ascii = ord( $texto[$contador]);
  476.  
  477.                 if (    ( $ascii >= 97 and $ascii <= 122 )
  478.                      or ( $ascii >= 65 and $ascii <= 90 )
  479.                      or ( $ascii >= 48 and $ascii <= 57 ) )
  480.                 {
  481.                     $texto_temp .= $texto[$contador];
  482.                 }
  483.             }
  484.  
  485.             return $texto_temp;
  486.         }
  487.  
  488.         private function apenasLetras( $texto)
  489.         {
  490.             $texto = $this->retirarAcentosEEspeciais( $texto);
  491.  
  492.             $texto_temp = '';
  493.  
  494.             for ( $contador = 0; $contador < strlen( $texto); $contador++ )
  495.             {
  496.                 $ascii = ord( $texto[$contador]);
  497.  
  498.                 if (    ( $ascii >= 97 and $ascii <= 122 )
  499.                      or ( $ascii >= 65 and $ascii <= 90 ) )
  500.                 {
  501.                     $texto_temp .= $texto[$contador];
  502.                 }
  503.             }
  504.  
  505.             return $texto_temp;
  506.         }
  507.  
  508.         private function apenasNumeros( $texto)
  509.         {
  510.             $texto_temp = '';
  511.  
  512.             for ( $contador = 0; $contador < strlen( $texto); $contador++ )
  513.             {
  514.                 $ascii = ord( $texto[$contador]);
  515.  
  516.                 if (  $ascii >= 48 and $ascii <= 57 )
  517.                 {
  518.                     $texto_temp .= $texto[$contador];
  519.                 }
  520.             }
  521.  
  522.             return $texto_temp;
  523.         }
  524.        
  525.         private $_estados = array( 'AC', 'AL', 'AP', 'AM', 'BA', 'CE', 'DF', 'ES', 'GO', 'MA', 'MT', 'MS', 'MG', 'PA',
  526.                                    'PB', 'PR', 'PE', 'PI', 'RR', 'RO', 'RJ', 'RN', 'RS', 'SC', 'SP', 'SE', 'TO' );
  527.         private $_numeros = array( 'PRIMEIRA', 'SEGUNDA', 'TERCEIRA', 'QUARTA', 'QUINTA', 'SEXTA', 'SETIMA', 'OITAVA', 'NONA', 'DECIMA',
  528.                                    'PRIMEIRO', 'SEGUNDO', 'TERCEIRO', 'QUARTO', 'QUINTO', 'SEXTO', 'SETIMO', 'OITAVO', 'NONO', 'DECIMO' );
  529.         private $_ind_nums = array( 'N', 'NR', 'NRO', 'NO', 'NMRO', 'NUMERO', 'NUME', 'O', 'NUM', 'NMER', 'NMERU', 'NME' );
  530.         private $_ind_coml = array( 'S', 'SL', 'SALA', 'SLA', 'ESQ', 'ESQUINA', 'AP', 'APTO', 'APT', 'CXP',
  531.                                     'CXA', 'CAIXA', 'POSTAL', 'CX', 'CP', 'PERTO', 'PROXIMO', 'PROX', 'APAR', 'ESQU',
  532.                                     'LOJA', 'LJ', 'L' );
  533.         private $_ind_ante = array( 'ANDAR', 'PISO' );
  534.         private $_ind_loca = array( 'ED', 'KM', 'EDIFICIO', 'EDIF', 'EDF', 'QUADRA', 'LOTE', 'LT', 'QD', 'BOX', 'CASA', 'GALPAO' );
  535.         private $_ind_logr = array( 'RUA', 'R', 'BR', 'ROD', 'AVENIDA', 'AV', 'AVEN', 'EST', 'ESTRADA', 'RODOVIA',
  536.                                     'AL', 'ALAMEDA', 'TRAV', 'TRV', 'TRAVESSA', 'PR', 'PRC', 'PRACA', 'PATIO',
  537.                                     'ALMD', 'PRAA', 'LINHA', 'TV', 'AVDA', 'RD', 'PCA', 'PC', 'ESTADUAL', 'FEDERAL' );
  538.         private $_ind_com5 = array( 'APART', 'ESQUI', 'PROXI' );
  539.         private $_ind_log4 = array( 'AVEN', 'ESTR', 'TRAV', 'RODO' );
  540.  
  541.         private function retornarPalavraChave( $valor, $token_origem)
  542.         {
  543.             if( $token_origem == self::TOKEN_NUMERO and $valor[0] == 'N') return self::TOKEN_N_NUMERO;
  544.  
  545.             if( in_array( $valor, $this->_numeros) ) return self::TOKEN_NUMERO;
  546.            
  547.             if( in_array( $valor, $this->_ind_nums) ) return self::TOKEN_IND_NUM;
  548.  
  549.             if( in_array( $this->apenasLetras( $valor), $this->_ind_nums)
  550.                 and $this->apenasNumeros( substr( $this->apenasLetrasENumeros( $valor), 0, 1)) == '' )
  551.                 return self::TOKEN_N_NUMERO;
  552.  
  553.             if( in_array( $valor, $this->_ind_coml) ) return self::TOKEN_IND_COM;
  554.  
  555.             if( in_array( $valor, $this->_ind_ante) ) return self::TOKEN_IND_ANT;
  556.  
  557.             if( in_array( $valor, $this->_ind_loca) ) return self::TOKEN_IND_LOC;
  558.  
  559.             if( in_array( $valor, $this->_ind_logr) or in_array( $valor, $this->_estados) ) return self::TOKEN_IND_LOG;
  560.  
  561.             if( in_array( substr( $valor, 0, 5), $this->_ind_com5) ) return self::TOKEN_IND_COM;
  562.  
  563.             if( in_array( substr( $valor, 0, 4), $this->_ind_log4) ) return self::TOKEN_IND_LOG;
  564.  
  565.             if( substr( $valor, 0, 4) == 'EDIF' ) return self::TOKEN_IND_LOC;
  566.  
  567.             return ( ( $token_origem == self::TOKEN_NOME and strlen( $valor) < 3 ) ? self::TOKEN_IND_COM : $token_origem );
  568.         }   // function
  569.        
  570.         private function formatar( $valor)
  571.         {
  572.             return strtoupper( $this->apenasLetrasENumeros( $valor));
  573.         }
  574.  
  575.         private function avaliarCaracter( $caracter)
  576.         {
  577.             $corrigido = strtoupper( $this->retirarAcentosEEspeciais( $caracter));
  578.             $ascii = ord( $corrigido);
  579.  
  580.             if( $corrigido == 'N' or $corrigido == 'O') return self::CHAR_N;
  581.             if( $caracter == ',' or $caracter == '/') return self::CHAR_VIRGULA;
  582.             if( $ascii >= 65 and $ascii <= 90) return self::CHAR_LETRA;
  583.             if( $ascii >= 48 and $ascii <= 57) return self::CHAR_NUMERO;
  584.             if( strpos( '|:! ', $caracter) !== FALSE) return self::CHAR_DIVISOR;
  585.             if( $corrigido == '-') return self::CHAR_HIFEN;
  586.             if( $corrigido == '#') return self::CHAR_VELHA;
  587.             return self::CHAR_NULO;
  588.         }
  589.     }
  590.  
  591.  
  592.     //***********************************************************************************************
  593.     // Classe com lista com as informações sobre cada Token que a análise léxica encontrar
  594.  
  595.     class TokenEndereco
  596.     {
  597.         // ATRIBUTOS
  598.  
  599.         private $_tokens = array();
  600.         private $_n_tokens = 0;
  601.  
  602.         // MÉTODOS
  603.  
  604.         function getNumeroTokens()      // get do número total de Tokens armazenados
  605.         {
  606.             return $this->_n_tokens;
  607.         }
  608.  
  609.         function incluirToken( $tipo, $valor, $formatado, $inicio, $tamanho)        // inclui um token ao final da lista
  610.         {
  611.             return $this->incluirInterno( $this->_n_tokens + 1, $tipo, $valor, $formatado, $inicio, $tamanho );
  612.         }
  613.  
  614.         private function incluirInterno( $ordem, $tipo, $valor, $formatado, $inicio, $tamanho)      // utilizado internamente
  615.         {
  616.             if( $ordem < 1) return FALSE;
  617.  
  618.             $incluindo = ( $ordem > $this->_n_tokens);
  619.             if( $incluindo) $this->_n_tokens = $ordem;
  620.  
  621.             $this->_tokens[ $ordem] = array( 1 => $tipo, $valor, $formatado, $inicio, $tamanho);
  622.  
  623.             return $incluindo;
  624.         }
  625.  
  626.         function excluirTodos()     // exclui todos os tokens
  627.         {
  628.             unset( $this->_tokens);
  629.             $this->_tokens = array();
  630.             $this->_n_tokens = 0;
  631.         }
  632.  
  633.         function getTokenInfo( $token, $informacao)     // recupera informação de um token (inclusive inexistente)
  634.         {
  635.             if( $token > 0 and $token <= $this->_n_tokens and is_array( $this->_tokens[ $token]) )
  636.             {
  637.                 return $this->_tokens[ $token][ $informacao];
  638.             }
  639.             else
  640.             {
  641.                 switch ( $informacao)
  642.                 {
  643.                     case TOKEN_INF_TIPO:
  644.                         return INDEFINIDO;
  645.  
  646.                     case TOKEN_INF_VALOR:
  647.                     case TOKEN_INF_FORMATADO:
  648.                         return '';
  649.  
  650.                     case TOKEN_INF_INICIO:
  651.                     case TOKEN_INF_TAMANHO:
  652.                         return 0;
  653.  
  654.                     default:
  655.                         return INDEFINIDO;
  656.                 }
  657.             }
  658.         }
  659.  
  660.         function setTokenInfo( $token, $informacao, $valor)     // escreve informação de um token (retorna se existe o token)
  661.         {
  662.             if( is_array( $this->_tokens[ $token]) )
  663.             {
  664.                 $this->_tokens[ $token][ $informacao] = $valor;
  665.                 return TRUE;
  666.             }
  667.             else
  668.             {
  669.                 return FALSE;
  670.             }
  671.         }
  672.     }
  673. ?>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!