Beispiel #1
0
    def __init__(self, loc, toks):
        self.name = toks[0].name
        self.expr = toks[1:]
        self.loc = loc

    def __repr__(self):
        return "{0}{1}".format(self.name, self.expr)


def pushExpr(sourceStr, loc, toks):
    expr = Expr(loc, toks)
    exprStack[exprStack.index(toks[0]) :] = [expr]  # replace tokens with production
    return expr


ParserElement.enablePackrat()
# define grammar
variableRef = Regex(
    "[$]"  # variable prefix
    # optional prefix part
    "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
    "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*:)?"
    # localname part
    "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
    "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*)"
)
# for now :: axis step is expected in QName production (processed in parser's QName structure)
# qName = Word(alphas + '_',alphanums + ':_-.*') # note: this will pick up forward and reverse axes and handle by pushQName

# try to match axis step, prefix, and localname, allowin wildcard prefix or localname
# don't grab occurence indicator if on qname, e.g., not * of xs:string*
Beispiel #2
0
class Expr:
    def __init__(self, loc, toks):
        self.name = toks[0].name
        self.expr = toks[1:]
        self.loc = loc
    def __repr__(self):
        return "{0}{1}".format(self.name,self.expr)

def pushExpr( sourceStr, loc, toks ):
    expr = Expr(loc, toks)
    # exprStack[exprStack.index(toks[0]):] = [expr]  # replace tokens with production
    exprStack[exprStackToksRIndex(toks):] = [expr]  # replace tokens with production
    return expr

ParserElement.enablePackrat()
# define grammar
variableRef = Regex("[$]"  # variable prefix
                    # optional prefix part
                    "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                    "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*:)?"
                    # localname part
                    "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                    "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*)"
                    )
# for now :: axis step is expected in QName production (processed in parser's QName structure)
#qName = Word(alphas + '_',alphanums + ':_-.*') # note: this will pick up forward and reverse axes and handle by pushQName

# try to match axis step, prefix, and localname, allowin wildcard prefix or localname
# don't grab occurence indicator if on qname, e.g., not * of xs:string*
qName = Regex("([A-Za-z-]+::)?"  # axis step part (just ansi characters)
Beispiel #3
0
def compileSphinxGrammar( cntlr ):
    global isGrammarCompiled, sphinxProg, lineno

    if isGrammarCompiled:
        return sphinxProg
    
    debugParsing = True
    
    cntlr.showStatus(_("Compiling Sphinx Grammar"))
    if sys.version[0] >= '3':
        # python 3 requires modified parser to allow release of global objects when closing DTS
        from arelle.pyparsing.pyparsing_py3 import (Word, Keyword, alphas, 
                     Literal, CaselessLiteral, 
                     Combine, Optional, nums, Or, Forward, Group, ZeroOrMore, StringEnd, alphanums,
                     ParserElement, quotedString, delimitedList, Suppress, Regex, FollowedBy,
                     lineno)
    else:
        from pyparsing import (Word, Keyword, alphas, 
                     Literal, CaselessLiteral, 
                     Combine, Optional, nums, Or, Forward, Group, ZeroOrMore, StringEnd, alphanums,
                     ParserElement, quotedString, delimitedList, Suppress, Regex, FollowedBy,
                     lineno)
    
    ParserElement.enablePackrat()
    
    """
    the pyparsing parser constructs are defined in this method to prevent the need to compile
    the grammar when the plug in is loaded (which is likely to be when setting up GUI
    menus or command line parser).
    
    instead the grammar is compiled the first time that any sphinx needs to be parsed
    
    only the sphinxExpression (result below) needs to be global for the parser
    """
    
    # define grammar
    sphinxComment = Regex(r"/(?:\*(?:[^*]*\*+)+?/|/[^\n]*(?:\n[^\n]*)*?(?:(?<!\\)|\Z))").setParseAction(compileComment)
    
    variableRef = Regex("[$]"  # variable prefix
                        # localname part
                        "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                        "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*)"
                        )

    
    qName = Regex("([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                  "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*:)?"
                  # localname or wildcard-localname part  
                  "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                  "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*|[*])"
                  )

    ncName = Regex("([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                  "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*)"
                  ).setName("ncName").setDebug(debugParsing)
    
    #annotationName = Word("@",alphanums + '_-.').setName("annotationName").setDebug(debugParsing)
    annotationName = Regex("@[A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]\w*").setName("annotationName").setDebug(debugParsing)
    

    decimalPoint = Literal('.')
    exponentLiteral = CaselessLiteral('e')
    plusorminusLiteral = Literal('+') | Literal('-')
    digits = Word(nums) 
    integerLiteral = Combine( Optional(plusorminusLiteral) + digits )
    decimalFractionLiteral = Combine( Optional(plusorminusLiteral) + decimalPoint + digits )
    infLiteral = Combine( Optional(plusorminusLiteral) + Literal("INF") )
    nanLiteral = Literal("NaN")
    floatLiteral = ( Combine( integerLiteral +
                         ( ( decimalPoint + Optional(digits) + exponentLiteral + integerLiteral ) |
                           ( exponentLiteral + integerLiteral ) |
                           ( decimalPoint + Optional(digits) ) )
                         ) | 
                     Combine( decimalFractionLiteral + exponentLiteral + integerLiteral ) |
                     decimalFractionLiteral |
                     infLiteral | nanLiteral ) 
    
    
    #emptySequence = Literal( "(" ) + Literal( ")" )
    lParen  = Literal( "(" )
    rParen  = Literal( ")" )
    lPred  = Literal( "[[" ) | Literal("[")
    rPred  = Literal( "]]" ) | Literal("]")
    
    commaOp = Literal(",")
    ifOp = Keyword("if")
    elseOp = Keyword("else")
    forOp = Keyword("for")
    inOp = Keyword("in")
    withOp = Keyword("with")
    notOp = Keyword("not")
    valuesOp = Keyword("values")
    andOp = Keyword("and")
    orOp = Keyword("or")
    neOp = Literal("!=")
    leOp = Literal("<=")
    ltOp = Literal("<")
    geOp = Literal(">=")
    gtOp = Literal(">")
    eqOp = Literal("==")
    compOp = leOp | ltOp | geOp | gtOp
    plusOp  = Literal("|+|") | Literal("|+") | Literal("+|") | Literal("+")
    minusOp = Literal("|-|") | Literal("|-") | Literal("-|") | Literal("-")
    plusMinusOp  = ( plusOp | minusOp ).setParseAction(compileOp)
    multOp  = Literal("*")
    divOp   = Literal("/")
    varAssign = Literal("=")
    tagOp = Literal("#")
    asOp = Keyword("as")
    whereOp = Keyword("where")
    wildOp = Literal("**") | Literal("*")
    methodOp = Literal("::")
    formulaOp = Literal(":=")
   
    namespaceDeclaration = (Literal("xmlns") + Optional( Suppress(Literal(":")) + ncName ) + Suppress(Literal("=")) + quotedString ).setParseAction(compileNamespaceDeclaration).ignore(sphinxComment)
    annotationDeclaration = (Suppress(Keyword("annotation")) + ncName + Optional( Suppress(Keyword("as")) + ncName )).setParseAction(compileAnnotationDeclaration).ignore(sphinxComment)
    
    packageDeclaration = (Suppress(Keyword("package")) + ncName ).setParseAction(compilePackageDeclaration).ignore(sphinxComment)
    
    severity = ( Suppress(Keyword("severity")) + ( ncName ) ).setParseAction(compileSeverity).ignore(sphinxComment) 
                     
    expr = Forward()
    
    atom = ( 
             ( forOp - Suppress(lParen) - ncName - Suppress(inOp) - expr - Suppress(rParen) - expr ).setParseAction(compileFor) |
             ( ifOp - Suppress(lParen) - expr - Suppress(rParen) -  expr - Suppress(elseOp) - expr ).setParseAction(compileIf) | 
             ( ncName + Suppress(lParen) + Optional(delimitedList( ZeroOrMore( ( ncName + Optional( tagOp + Optional(ncName) ) + varAssign + expr + Suppress(Literal(";")) ).setParseAction(compileVariableAssignment) ) +
                                                                   Optional( ncName + varAssign ) + expr
                                                                   )) + Suppress(rParen) ).setParseAction(compileFunctionReference) |
             ( floatLiteral ).setParseAction(compileFloatLiteral) |
             ( integerLiteral ).setParseAction(compileIntegerLiteral) |
             ( quotedString ).setParseAction(compileStringLiteral) |
             ( Optional(qName) + lPred + Optional(delimitedList( ((whereOp + expr) |
                                                                  ((qName | variableRef) + Optional( tagOp + Optional(ncName) ) +
                                                                   Optional( (varAssign + (wildOp | expr) | 
                                                                             (inOp + expr) | 
                                                                             (asOp + ncName + varAssign + wildOp + Optional( whereOp + expr ) ) ) ) )
                                                                  ).setParseAction(compileHyperspaceAxis), 
                                                                delim=';')) + rPred).setParseAction(compileHyperspaceExpression) |
             ( variableRef ).setParseAction(compileVariableReference)  |
             ( qName ).setParseAction(compileQname) |
             ( Suppress(lParen) - expr - Optional( commaOp - Optional( expr - ZeroOrMore( commaOp - expr ) ) ) - Suppress(rParen) ).setParseAction(compileBrackets)
           ).ignore(sphinxComment)
           
    atom.setName("atom").setDebug(debugParsing)
    
    valueExpr = atom
    taggedExpr = ( valueExpr - Optional(tagOp - ncName) ).setParseAction(compileTagAssignment).ignore(sphinxComment)
    methodExpr = ( ( methodOp + ncName + ZeroOrMore(methodOp + taggedExpr) ).setParseAction(compileMethodReference) |
                   ( ZeroOrMore(taggedExpr + methodOp) + taggedExpr )).setParseAction(compileMethodReference).ignore(sphinxComment)
    unaryExpr = ( Optional(plusMinusOp) + methodExpr ).setParseAction(compileUnaryOperation).ignore(sphinxComment)
    negateExpr = ( Optional(notOp) + unaryExpr ).setParseAction(compileUnaryOperation).ignore(sphinxComment)
    valuesExpr = ( Optional(valuesOp) + negateExpr ).setParseAction(compileValuesIteration).ignore(sphinxComment)
    method2Expr = ( valuesExpr + Optional( methodOp + methodExpr ) ).setParseAction(compileMethodReference).ignore(sphinxComment)
    multiplyExpr = ( method2Expr + Optional( multOp + method2Expr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    divideExpr = ( multiplyExpr + Optional( divOp + multiplyExpr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    addExpr = ( divideExpr + Optional( plusOp + divideExpr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    subtractExpr = ( addExpr + Optional( minusOp + addExpr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    equalityExpr = ( subtractExpr + Optional( eqOp + subtractExpr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    inequalityExpr = ( equalityExpr + Optional( neOp + equalityExpr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    comparisonExpr = ( inequalityExpr + Optional( compOp + inequalityExpr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    andExpr = ( comparisonExpr + Optional( andOp + comparisonExpr ) ).setParseAction(compileBinaryOperation ).ignore(sphinxComment)
    orExpr = ( andExpr + Optional( orOp + andExpr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    formulaExpr = ( orExpr + Optional( formulaOp + orExpr ) ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    withExpr = ( Optional( withOp + Suppress(lParen) + expr + Suppress(rParen) ) + 
                 ZeroOrMore( ( ncName + Optional( tagOp + Optional(ncName) ) + varAssign + expr + Suppress(Literal(";")) ).setParseAction(compileVariableAssignment).ignore(sphinxComment) ) +
                 formulaExpr ).setParseAction(compileWith)
    #parsedExpr = withExpr
    #parsedExpr.setName("parsedExpr").setDebug(debugParsing)

    #expr << parsedExpr
    expr << withExpr
    expr.setName("expr").setDebug(debugParsing)
    
    annotation = ( annotationName + Optional( Suppress(lParen) + Optional(delimitedList(expr)) + Suppress(rParen) ) ).setParseAction(compileAnnotation).ignore(sphinxComment).setName("annotation").setDebug(debugParsing)

    constant = ( Suppress(Keyword("constant")) + ncName + Optional( tagOp + Optional(ncName) ) + varAssign + expr ).setParseAction(compileConstant).ignore(sphinxComment)
    
    functionDeclaration = ( (Keyword("function") | Keyword("macro")) + ncName + lParen + Optional(delimitedList(ncName)) + rParen + expr ).setParseAction(compileFunctionDeclaration).ignore(sphinxComment)
    
    message = ( Suppress(Keyword("message")) + expr ).setParseAction(compileMessage)
    
    preconditionDeclaration = ( Suppress(Keyword("precondition")) + ncName + expr +
                                Optional(Keyword("otherwise") + Keyword("raise") + ncName + Optional( severity ) + Optional( message ) ) 
                                ).setParseAction(compilePreconditionDeclaration).ignore(sphinxComment)

    assignedExpr = ( ncName + Optional( tagOp + Optional(ncName) ) + varAssign + expr + Suppress(Literal(";")) ).setParseAction(compileVariableAssignment).ignore(sphinxComment)

    precondition = ( Suppress(Keyword("require")) + delimitedList(ncName) ).setParseAction(compilePrecondition).ignore(sphinxComment).setName("precondition").setDebug(debugParsing)
    
    formulaRule = ( Optional( precondition ) +
                    Keyword("formula") + ncName + 
                    Optional( severity ) + 
                    Optional( ( Keyword("bind") + expr ) ) +
                    ZeroOrMore( assignedExpr ) +
                    expr + 
                    Optional( message )).setParseAction(compileFormulaRule).ignore(sphinxComment)
    reportRule = ( Optional( precondition ) +
                   Keyword("report") + ncName + 
                   Optional( severity ) +
                   ZeroOrMore( assignedExpr ) +
                   expr + 
                   Optional( message )).setParseAction( compileReportRule).ignore(sphinxComment)
    validationRule = ( Optional( precondition ) +
                       Keyword("raise") + ncName + 
                       Optional( severity ) +
                       ZeroOrMore( assignedExpr ) +
                       expr + 
                       Optional( message )).setParseAction(compileValidationRule).ignore(sphinxComment)

    ruleBase = (Optional( precondition ) +
                Suppress(Keyword("rule-base")) +
                ZeroOrMore( (Suppress(Keyword("transform")) +
                             (Keyword("namespace") + expr + Suppress(Keyword("to")) + expr) | 
                             (Keyword ("qname") + expr + Suppress(Keyword("to")) + expr)
                             ).setParseAction(compileTransform)
                           )
                ).setParseAction(compileRuleBase).ignore(sphinxComment).setName("ruleBase").setDebug(debugParsing)
    
    sphinxProg = ( ZeroOrMore( namespaceDeclaration | sphinxComment ) + 
                   ZeroOrMore( annotationDeclaration |
                               annotation |
                               constant |
                               preconditionDeclaration |
                               packageDeclaration |
                               functionDeclaration |
                               ruleBase |
                               formulaRule | reportRule | validationRule  |
                               sphinxComment
                               )
                   ) + StringEnd()
    sphinxProg.ignore(sphinxComment)
    
    startedAt = time.time()
    cntlr.modelManager.showStatus(_("initializing sphinx grammar"))
    sphinxProg.parseString( "// force initialization\n", parseAll=True )
    from arelle.Locale import format_string
    logMessage("INFO", "info",
               format_string(cntlr.modelManager.locale, 
                             _("Sphinx grammar initialized in %.2f secs"), 
                             time.time() - startedAt))

    isGrammarCompiled = True

    return sphinxProg
Beispiel #4
0
def compileCdrGrammar( cntlr, _logMessage ):
    global isGrammarCompiled, cdrProg, lineno

    if isGrammarCompiled:
        return cdrProg
    
    global logMessage
    logMessage = _logMessage
    
    debugParsing = False #  True
    
    cntlr.showStatus(_("Compiling CDR Grammar"))
    if sys.version[0] >= '3':
        # python 3 requires modified parser to allow release of global objects when closing DTS
        from arelle.pyparsing.pyparsing_py3 import (Word, Keyword, alphas, 
                     Literal, CaselessLiteral, 
                     Combine, Optional, nums, Or, Forward, Group, ZeroOrMore, StringEnd, alphanums,
                     ParserElement, sglQuotedString, delimitedList, Suppress, Regex, FollowedBy,
                     lineno, restOfLine)
    else:
        from pyparsing import (Word, Keyword, alphas, 
                     Literal, CaselessLiteral, 
                     Combine, Optional, nums, Or, Forward, Group, ZeroOrMore, StringEnd, alphanums,
                     ParserElement, sglQuotedString, delimitedList, Suppress, Regex, FollowedBy,
                     lineno, restOfLine)
    
    ParserElement.enablePackrat()
    
    """
    the pyparsing parser constructs are defined in this method to prevent the need to compile
    the grammar when the plug in is loaded (which is likely to be when setting up GUI
    menus or command line parser).
    
    instead the grammar is compiled the first time that any sphinx needs to be parsed
    
    only the sphinxExpression (result below) needs to be global for the parser
    """
    
    # define grammar
    periodOffset = Regex("-?P[1-3]?[0-9][YQMD](/-[1]?[0-9]-([1-3]?[0-9]|end))?")
    qName = Regex("([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                  "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*:)?"
                  # localname or wildcard-localname part  
                  "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                  "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*|[*])"
                  ).setName("qName").setDebug(debugParsing)

    ncName = Regex("([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
                  "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*)"
                  ).setName("ncName").setDebug(debugParsing)
    

    decimalPoint = Literal('.')
    exponentLiteral = CaselessLiteral('e')
    plusorminusLiteral = Literal('+') | Literal('-')
    digits = Word(nums) 
    integerLiteral = Combine( Optional(plusorminusLiteral) + digits )
    decimalFractionLiteral = Combine( Optional(plusorminusLiteral) + decimalPoint + digits )
    infLiteral = Combine( Optional(plusorminusLiteral) + Literal("INF") )
    nanLiteral = Literal("NaN")
    floatLiteral = ( Combine( integerLiteral +
                         ( ( decimalPoint + Optional(digits) + exponentLiteral + integerLiteral ) |
                           ( exponentLiteral + integerLiteral ) |
                           ( decimalPoint + Optional(digits) ) )
                         ) | 
                     Combine( decimalFractionLiteral + exponentLiteral + integerLiteral ) |
                     decimalFractionLiteral |
                     infLiteral | nanLiteral ) 
    
    
    #emptySequence = Literal( "(" ) + Literal( ")" )
    lParen  = Literal( "(" )
    rParen  = Literal( ")" )
    lPred  = Literal("[")
    rPred  = Literal("]")
    refOp  = Literal("#")
    
    commaOp = Literal(",")
    neOp = Literal("<>")
    leOp = Literal("<=")
    ltOp = Literal("<")
    geOp = Literal(">=")
    gtOp = Literal(">")
    eqOp = Literal("=")
    eqNeOp = eqOp | neOp
    compOp = leOp | ltOp | geOp | gtOp
    plusOp  = Literal("+")
    minusOp = Literal("-")
    plusMinusOp  = plusOp | minusOp
    expOp  = Literal("^")
    multOp  = Literal("*")
    divOp   = Literal("/")
    multDivOp = multOp | divOp
    concatOp  = Literal("&")
    andOp = CaselessLiteral("And")
    orOp = CaselessLiteral("Or")
    xorOp = CaselessLiteral("Xor")
   
    expr = Forward()
    
    atom = ( 
             ( refOp + qName ).setParseAction(compileRefExpression) |
             ( qName + Suppress(lParen) + Optional(delimitedList( expr )) + Suppress(rParen) ).setParseAction(compileFunctionReference) |
             ( qName.setParseAction(compileQname) + lPred + ( periodOffset | ncName) 
                     + rPred).setParseAction(compilePeriodOffsetExpression) |
             ( floatLiteral ).setParseAction(compileFloatLiteral) |
             ( integerLiteral ).setParseAction(compileIntegerLiteral) |
             ( sglQuotedString ).setParseAction(compileStringLiteral) |
             ( qName ).setParseAction(compileQname) |
             ( Suppress(lParen) - expr - Optional( commaOp - Optional( expr - ZeroOrMore( commaOp - expr ) ) ) - Suppress(rParen) ).setParseAction(compileBrackets)
           )
           
    atom.setName("atom").setDebug(debugParsing)
    
    valueExpr = atom
    negationExpr = ( Optional(minusOp) + valueExpr ).setParseAction(compileUnaryOperation)
    expExpr = ( Optional(expOp) + negationExpr ).setParseAction(compileUnaryOperation)
    multDivExpr = ( expExpr + Optional( multDivOp + expExpr ) ).setParseAction(compileBinaryOperation)
    multDivExpr.setName("multDivExpr").setDebug(debugParsing)
    addSubExpr = ( multDivExpr + ZeroOrMore( plusMinusOp + multDivExpr ) ).setParseAction(compileBinaryOperation) 
    addSubExpr.setName("addSubExpr").setDebug(debugParsing)
    concatExpr = ( addSubExpr + ZeroOrMore( concatOp + addSubExpr ) ).setParseAction(compileBinaryOperation) 
    comparisonExpr = ( concatExpr + Optional( compOp + concatExpr ) ).setParseAction(compileBinaryOperation)
    equalityExpr = ( comparisonExpr + Optional( eqNeOp + comparisonExpr ) ).setParseAction(compileBinaryOperation)
    xorExpr = ( equalityExpr + ZeroOrMore( xorOp + equalityExpr) ).setParseAction(compileBinaryOperation)
    andExpr = ( xorExpr + ZeroOrMore( andOp + xorExpr ) ).setParseAction(compileBinaryOperation)
    orExpr = ( andExpr + ZeroOrMore( orOp + andExpr ) ).setParseAction(compileBinaryOperation)
    orExpr.setName("orExpr").setDebug(debugParsing)

    expr << orExpr
    expr.setName("expr").setDebug(debugParsing)
    
    cdrProg = expr + StringEnd()
    expr.setName("cdrProg").setDebug(debugParsing)
    
    startedAt = time.time()
    cntlr.modelManager.showStatus(_("initializing CDR grammar"))
    cdrProg.parseString( "0", parseAll=True )
    from arelle.Locale import format_string
    _msg = format_string(cntlr.modelManager.locale, 
                             _("CDR grammar initialized in %.2f secs"), 
                             time.time() - startedAt)
    logMessage("INFO", "info", _msg)
    cntlr.modelManager.showStatus(_msg, 5000)
    isGrammarCompiled = True

    return cdrProg
Beispiel #5
0
def compileSphinxGrammar(cntlr):
    global isGrammarCompiled, sphinxProg, lineno

    if isGrammarCompiled:
        return sphinxProg

    debugParsing = True

    cntlr.showStatus(_("Compiling Sphinx Grammar"))
    if sys.version[0] >= '3':
        # python 3 requires modified parser to allow release of global objects when closing DTS
        from arelle.pyparsing.pyparsing_py3 import (
            Word, Keyword, alphas, Literal, CaselessLiteral, Combine, Optional,
            nums, Or, Forward, Group, ZeroOrMore, StringEnd, alphanums,
            ParserElement, quotedString, delimitedList, Suppress, Regex,
            FollowedBy, lineno)
    else:
        from pyparsing import (Word, Keyword, alphas, Literal, CaselessLiteral,
                               Combine, Optional, nums, Or, Forward, Group,
                               ZeroOrMore, StringEnd, alphanums, ParserElement,
                               quotedString, delimitedList, Suppress, Regex,
                               FollowedBy, lineno)

    ParserElement.enablePackrat()
    """
    the pyparsing parser constructs are defined in this method to prevent the need to compile
    the grammar when the plug in is loaded (which is likely to be when setting up GUI
    menus or command line parser).
    
    instead the grammar is compiled the first time that any sphinx needs to be parsed
    
    only the sphinxExpression (result below) needs to be global for the parser
    """

    # define grammar
    sphinxComment = Regex(
        r"/(?:\*(?:[^*]*\*+)+?/|/[^\n]*(?:\n[^\n]*)*?(?:(?<!\\)|\Z))"
    ).setParseAction(compileComment)

    variableRef = Regex(
        "[$]"  # variable prefix
        # localname part
        "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
        "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*)"
    )

    qName = Regex(
        "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
        "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*:)?"
        # localname or wildcard-localname part
        "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
        "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*|[*])"
    )

    ncName = Regex(
        "([A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]"
        "[A-Za-z0-9\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u0300-\u036F\u203F-\u2040\xB7_.-]*)"
    ).setName("ncName").setDebug(debugParsing)

    #annotationName = Word("@",alphanums + '_-.').setName("annotationName").setDebug(debugParsing)
    annotationName = Regex(
        "@[A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD_]\w*"
    ).setName("annotationName").setDebug(debugParsing)

    decimalPoint = Literal('.')
    exponentLiteral = CaselessLiteral('e')
    plusorminusLiteral = Literal('+') | Literal('-')
    digits = Word(nums)
    integerLiteral = Combine(Optional(plusorminusLiteral) + digits)
    decimalFractionLiteral = Combine(
        Optional(plusorminusLiteral) + decimalPoint + digits)
    infLiteral = Combine(Optional(plusorminusLiteral) + Literal("INF"))
    nanLiteral = Literal("NaN")
    floatLiteral = (Combine(integerLiteral + (
        (decimalPoint + Optional(digits) + exponentLiteral + integerLiteral) |
        (exponentLiteral + integerLiteral) |
        (decimalPoint + Optional(digits))))
                    | Combine(decimalFractionLiteral + exponentLiteral +
                              integerLiteral) | decimalFractionLiteral
                    | infLiteral | nanLiteral)

    #emptySequence = Literal( "(" ) + Literal( ")" )
    lParen = Literal("(")
    rParen = Literal(")")
    lPred = Literal("[[") | Literal("[")
    rPred = Literal("]]") | Literal("]")

    commaOp = Literal(",")
    ifOp = Keyword("if")
    elseOp = Keyword("else")
    forOp = Keyword("for")
    inOp = Keyword("in")
    withOp = Keyword("with")
    notOp = Keyword("not")
    valuesOp = Keyword("values")
    andOp = Keyword("and")
    orOp = Keyword("or")
    neOp = Literal("!=")
    leOp = Literal("<=")
    ltOp = Literal("<")
    geOp = Literal(">=")
    gtOp = Literal(">")
    eqOp = Literal("==")
    compOp = leOp | ltOp | geOp | gtOp
    plusOp = Literal("|+|") | Literal("|+") | Literal("+|") | Literal("+")
    minusOp = Literal("|-|") | Literal("|-") | Literal("-|") | Literal("-")
    plusMinusOp = (plusOp | minusOp).setParseAction(compileOp)
    multOp = Literal("*")
    divOp = Literal("/")
    varAssign = Literal("=")
    tagOp = Literal("#")
    asOp = Keyword("as")
    whereOp = Keyword("where")
    wildOp = Literal("**") | Literal("*")
    methodOp = Literal("::")
    formulaOp = Literal(":=")

    namespaceDeclaration = (
        Literal("xmlns") + Optional(Suppress(Literal(":")) + ncName) +
        Suppress(Literal("=")) + quotedString
    ).setParseAction(compileNamespaceDeclaration).ignore(sphinxComment)
    annotationDeclaration = (
        Suppress(Keyword("annotation")) + ncName +
        Optional(Suppress(Keyword("as")) + ncName)
    ).setParseAction(compileAnnotationDeclaration).ignore(sphinxComment)

    packageDeclaration = (
        Suppress(Keyword("package")) +
        ncName).setParseAction(compilePackageDeclaration).ignore(sphinxComment)

    severity = (Suppress(Keyword("severity")) +
                (ncName)).setParseAction(compileSeverity).ignore(sphinxComment)

    expr = Forward()

    atom = ((forOp - Suppress(lParen) - ncName - Suppress(inOp) - expr -
             Suppress(rParen) - expr).setParseAction(compileFor) |
            (ifOp - Suppress(lParen) - expr - Suppress(rParen) - expr -
             Suppress(elseOp) - expr).setParseAction(compileIf) |
            (ncName + Suppress(lParen) + Optional(
                delimitedList(
                    ZeroOrMore((ncName + Optional(tagOp + Optional(ncName)) +
                                varAssign + expr + Suppress(Literal(";"))
                                ).setParseAction(compileVariableAssignment)) +
                    Optional(ncName + varAssign) + expr)) +
             Suppress(rParen)).setParseAction(compileFunctionReference) |
            (floatLiteral).setParseAction(compileFloatLiteral) |
            (integerLiteral).setParseAction(compileIntegerLiteral) |
            (quotedString).setParseAction(compileStringLiteral) |
            (Optional(qName) + lPred + Optional(
                delimitedList(
                    ((whereOp + expr) |
                     ((qName | variableRef) +
                      Optional(tagOp + Optional(ncName)) + Optional(
                          (varAssign + (wildOp | expr) | (inOp + expr) |
                           (asOp + ncName + varAssign + wildOp +
                            Optional(whereOp + expr)))))
                     ).setParseAction(compileHyperspaceAxis),
                    delim=';')) +
             rPred).setParseAction(compileHyperspaceExpression) |
            (variableRef).setParseAction(compileVariableReference) |
            (qName).setParseAction(compileQname) |
            (Suppress(lParen) - expr -
             Optional(commaOp - Optional(expr - ZeroOrMore(commaOp - expr))) -
             Suppress(rParen)).setParseAction(compileBrackets)
            ).ignore(sphinxComment)

    atom.setName("atom").setDebug(debugParsing)

    valueExpr = atom
    taggedExpr = (valueExpr - Optional(tagOp - ncName)
                  ).setParseAction(compileTagAssignment).ignore(sphinxComment)
    methodExpr = (
        (methodOp + ncName + ZeroOrMore(methodOp + taggedExpr)
         ).setParseAction(compileMethodReference) |
        (ZeroOrMore(taggedExpr + methodOp) + taggedExpr)
    ).setParseAction(compileMethodReference).ignore(sphinxComment)
    unaryExpr = (
        Optional(plusMinusOp) +
        methodExpr).setParseAction(compileUnaryOperation).ignore(sphinxComment)
    negateExpr = (
        Optional(notOp) +
        unaryExpr).setParseAction(compileUnaryOperation).ignore(sphinxComment)
    valuesExpr = (Optional(valuesOp) + negateExpr).setParseAction(
        compileValuesIteration).ignore(sphinxComment)
    method2Expr = (valuesExpr +
                   Optional(methodOp + methodExpr)).setParseAction(
                       compileMethodReference).ignore(sphinxComment)
    multiplyExpr = (method2Expr +
                    Optional(multOp + method2Expr)).setParseAction(
                        compileBinaryOperation).ignore(sphinxComment)
    divideExpr = (multiplyExpr +
                  Optional(divOp + multiplyExpr)).setParseAction(
                      compileBinaryOperation).ignore(sphinxComment)
    addExpr = (divideExpr + Optional(plusOp + divideExpr)
               ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    subtractExpr = (addExpr + Optional(minusOp + addExpr)).setParseAction(
        compileBinaryOperation).ignore(sphinxComment)
    equalityExpr = (subtractExpr +
                    Optional(eqOp + subtractExpr)).setParseAction(
                        compileBinaryOperation).ignore(sphinxComment)
    inequalityExpr = (equalityExpr +
                      Optional(neOp + equalityExpr)).setParseAction(
                          compileBinaryOperation).ignore(sphinxComment)
    comparisonExpr = (inequalityExpr +
                      Optional(compOp + inequalityExpr)).setParseAction(
                          compileBinaryOperation).ignore(sphinxComment)
    andExpr = (comparisonExpr + Optional(andOp + comparisonExpr)
               ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    orExpr = (andExpr + Optional(orOp + andExpr)
              ).setParseAction(compileBinaryOperation).ignore(sphinxComment)
    formulaExpr = (orExpr + Optional(formulaOp + orExpr)).setParseAction(
        compileBinaryOperation).ignore(sphinxComment)
    withExpr = (Optional(withOp + Suppress(lParen) + expr + Suppress(rParen)) +
                ZeroOrMore(
                    (ncName + Optional(tagOp + Optional(ncName)) + varAssign +
                     expr + Suppress(Literal(";"))).setParseAction(
                         compileVariableAssignment).ignore(sphinxComment)) +
                formulaExpr).setParseAction(compileWith)
    #parsedExpr = withExpr
    #parsedExpr.setName("parsedExpr").setDebug(debugParsing)

    #expr << parsedExpr
    expr << withExpr
    expr.setName("expr").setDebug(debugParsing)

    annotation = (annotationName + Optional(
        Suppress(lParen) + Optional(delimitedList(expr)) +
        Suppress(rParen))).setParseAction(compileAnnotation).ignore(
            sphinxComment).setName("annotation").setDebug(debugParsing)

    constant = (Suppress(Keyword("constant")) + ncName +
                Optional(tagOp + Optional(ncName)) + varAssign +
                expr).setParseAction(compileConstant).ignore(sphinxComment)

    functionDeclaration = (
        (Keyword("function") | Keyword("macro")) + ncName + lParen +
        Optional(delimitedList(ncName)) + rParen +
        expr).setParseAction(compileFunctionDeclaration).ignore(sphinxComment)

    message = (Suppress(Keyword("message")) +
               expr).setParseAction(compileMessage)

    preconditionDeclaration = (
        Suppress(Keyword("precondition")) + ncName + expr + Optional(
            Keyword("otherwise") + Keyword("raise") + ncName +
            Optional(severity) + Optional(message))
    ).setParseAction(compilePreconditionDeclaration).ignore(sphinxComment)

    assignedExpr = (ncName + Optional(tagOp + Optional(ncName)) + varAssign +
                    expr + Suppress(Literal(";"))).setParseAction(
                        compileVariableAssignment).ignore(sphinxComment)

    precondition = (
        Suppress(Keyword("require")) +
        delimitedList(ncName)).setParseAction(compilePrecondition).ignore(
            sphinxComment).setName("precondition").setDebug(debugParsing)

    formulaRule = (Optional(precondition) + Keyword("formula") + ncName +
                   Optional(severity) + Optional((Keyword("bind") + expr)) +
                   ZeroOrMore(assignedExpr) + expr + Optional(message)
                   ).setParseAction(compileFormulaRule).ignore(sphinxComment)
    reportRule = (Optional(precondition) + Keyword("report") + ncName +
                  Optional(severity) + ZeroOrMore(assignedExpr) + expr +
                  Optional(message)
                  ).setParseAction(compileReportRule).ignore(sphinxComment)
    validationRule = (Optional(precondition) + Keyword("raise") + ncName +
                      Optional(severity) + ZeroOrMore(assignedExpr) + expr +
                      Optional(message)).setParseAction(
                          compileValidationRule).ignore(sphinxComment)

    ruleBase = (
        Optional(precondition) + Suppress(Keyword("rule-base")) + ZeroOrMore(
            (Suppress(Keyword("transform")) +
             (Keyword("namespace") + expr + Suppress(Keyword("to")) + expr) |
             (Keyword("qname") + expr + Suppress(Keyword("to")) +
              expr)).setParseAction(compileTransform))
    ).setParseAction(compileRuleBase).ignore(sphinxComment).setName(
        "ruleBase").setDebug(debugParsing)

    sphinxProg = (
        ZeroOrMore(namespaceDeclaration | sphinxComment) +
        ZeroOrMore(annotationDeclaration | annotation | constant
                   | preconditionDeclaration | packageDeclaration
                   | functionDeclaration | ruleBase | formulaRule | reportRule
                   | validationRule | sphinxComment)) + StringEnd()
    sphinxProg.ignore(sphinxComment)

    startedAt = time.time()
    cntlr.modelManager.showStatus(_("initializing sphinx grammar"))
    sphinxProg.parseString("// force initialization\n", parseAll=True)
    from arelle.Locale import format_string
    logMessage(
        "INFO", "info",
        format_string(cntlr.modelManager.locale,
                      _("Sphinx grammar initialized in %.2f secs"),
                      time.time() - startedAt))

    isGrammarCompiled = True

    return sphinxProg