ANTLR4 Python analizando archivos grandes

parsing

Question

Estoy intentando escribir analizadores para las listas de control de acceso del enrutador Juniper / srx. A continuación se muestra la gramática que estoy usando:

grammar SRXBackend;

acl:
    ''security'' ''{'' ''policies'' ''{'' COMMENT* replaceStmt ''{'' policy* ''}'' ''}'' ''}''
            applications
            addressBook
;

replaceStmt:
    ''replace:'' IDENT
|   ''replace:'' ''from-zone'' IDENT ''to-zone'' IDENT
;

policy:
    ''policy'' IDENT ''{'' ''match'' ''{'' fromStmt* ''}'' ''then'' (action | ''{'' action+ ''}'') ''}''
;

fromStmt:
     ''source-address'' addrBlock                     # sourceAddrStmt
|    ''destination-address'' addrBlock                # destinationAddrStmt
|    ''application'' (srxName '';'' | ''['' srxName+ '']'')  # applicationBlock
;

action:
    ''permit'' '';''
|   ''deny'' '';''
|   ''log { session-close; }''
;

addrBlock:
    ''['' srxName+ '']''
|   srxName '';''
;

applications:
    ''applications'' ''{'' application* ''}''
|   ''applications'' ''{'' ''apply-groups'' IDENT '';'' ''}'' ''groups'' ''{'' replaceStmt  ''{'' ''applications'' ''{'' application* ''}'' ''}'' ''}''
;

addressBook:
    ''security'' ''{'' ''address-book'' ''{'' replaceStmt ''{'' addrEntry* ''}'' ''}'' ''}''
|   ''groups'' ''{'' replaceStmt  ''{'' ''security'' ''{'' ''address-book'' ''{'' IDENT ''{'' addrEntry* ''}'' ''}'' ''}'' ''}'' ''}'' ''security'' ''{'' ''apply-groups'' IDENT '';'' ''}''
;

application:
    ''replace:''? ''application'' srxName ''{'' applicationStmt+ ''}''
;

applicationStmt:
    ''protocol'' srxName '';''            #applicationProtocol
|   ''source-port'' portRange '';''       #applicationSrcPort
|   ''destination-port'' portRange '';''  #applicationDstPort
;

portRange:
    NUMBER             #portRangeOne
|   NUMBER ''-'' NUMBER  #portRangeMinMax
;

addrEntry:
    ''address-set'' IDENT ''{'' addrEntryStmt+ ''}'' #addrEntrySet
|   ''address'' srxName cidr '';''                 #addrEntrySingle
;

addrEntryStmt:
    (''address-set'' | ''address'') srxName '';''
;

cidr:
    NUMBER ''.'' NUMBER ''.'' NUMBER ''.'' NUMBER (''/'' NUMBER)?
;

srxName:
    NUMBER
|   IDENT
|   cidr
;

COMMENT : ''/*'' .*? ''*/'' ;
NUMBER  : [0-9]+ ;
IDENT   : [a-zA-Z][a-zA-Z0-9,/-_:/./]* ;
WS      : [ /t/n]+ -> skip ;

Cuando trato de usar una ACL con ~ 80,000 líneas, demora hasta ~ 10 minutos generar el árbol de análisis. Estoy usando el siguiente código para crear el árbol de análisis:

from antlr4 import *
from SRXBackendLexer import SRXBackendLexer
from SRXBackendParser import SRXBackendParser
import sys


    def main(argv):
        ipt = FileStream(argv[1])
        lexer = SRXBackendLexer(ipt)
        stream = CommonTokenStream(lexer)
        parser = SRXBackendParser(stream)
        parser.acl()

    if __name__ == ''__main__'':
        main(sys.argv)

Estoy usando Python 2.7 como idioma de destino. También ejecuté cProfile para identificar qué código lleva más tiempo. A continuación se muestran los primeros registros ordenados a tiempo:

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
   608448   62.699    0.000  272.359    0.000 LexerATNSimulator.py:152(execATN)
  5007036   41.253    0.000   71.458    0.000 LexerATNSimulator.py:570(consume)
  5615722   32.048    0.000   70.416    0.000 DFAState.py:131(__eq__)
 11230968   24.709    0.000   24.709    0.000 InputStream.py:73(LA)
  5006814   21.881    0.000   31.058    0.000 LexerATNSimulator.py:486(captureSimState)
  5007274   20.497    0.000   29.349    0.000 ATNConfigSet.py:160(__eq__)
 10191162   18.313    0.000   18.313    0.000 {isinstance}
 10019610   16.588    0.000   16.588    0.000 {ord}
  5615484   13.331    0.000   13.331    0.000 LexerATNSimulator.py:221(getExistingTargetState)
  6832160   12.651    0.000   12.651    0.000 InputStream.py:52(index)
  5007036   10.593    0.000   10.593    0.000 InputStream.py:67(consume)
   449433    9.442    0.000  319.463    0.001 Lexer.py:125(nextToken)
        1    8.834    8.834   16.930   16.930 InputStream.py:47(_loadString)
   608448    8.220    0.000  285.163    0.000 LexerATNSimulator.py:108(match)
  1510237    6.841    0.000   10.895    0.000 CommonTokenStream.py:84(LT)
   449432    6.044    0.000  363.766    0.001 Parser.py:344(consume)
   449433    5.801    0.000    9.933    0.000 Token.py:105(__init__)

Realmente no puedo entenderlo, excepto que InputStream.LA toma alrededor de medio minuto. Supongo que esto se debe al hecho de que toda la cadena de texto se amortigua / carga a la vez. ¿Hay alguna forma alternativa / más perezosa de analizar o cargar datos para el objetivo de Python? ¿Hay alguna mejora que pueda hacer en la gramática para que el análisis sea más rápido?

Gracias

Answer 1

Tengo entendido que su IDENT puede ser de tamaño cero debido a * lugar de + . Esto envía su analizador en bucles para cada carácter individual, generando nodos IDENT tamaño cero.