parameters: (baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')'))
return_statement: return ret
docstring: Helper method for constructing grammars of expressions made up of
      operators working in a precedence hierarchy.  Operators may be unary
      or binary, left- or right-associative.  Parse actions can also be
      attached to operator expressions. The generated parser will also
      recognize the use of parentheses to override operator precedences
      (see example below).
  
      Note: if you define a deep operator list, you may see performance
      issues when using infixNotation. See
      :class:`ParserElement.enablePackrat` for a mechanism to potentially
      improve your parser performance.
  
      Parameters:
       - baseExpr - expression representing the most basic element for the
         nested
       - opList - list of tuples, one for each operator precedence level
         in the expression grammar; each tuple is of the form ``(opExpr,
         numTerms, rightLeftAssoc, parseAction)``, where:
  
         - opExpr is the pyparsing expression for the operator; may also
           be a string, which will be converted to a Literal; if numTerms
           is 3, opExpr is a tuple of two expressions, for the two
           operators separating the 3 terms
         - numTerms is the number of terms for this operator (must be 1,
           2, or 3)
         - rightLeftAssoc is the indicator whether the operator is right
           or left associative, using the pyparsing-defined constants
           ``opAssoc.RIGHT`` and ``opAssoc.LEFT``.
         - parseAction is the parse action to be associated with
           expressions matching this operator expression (the parse action
           tuple member may be omitted); if the parse action is passed
           a tuple or list of functions, this is equivalent to calling
           ``setParseAction(*fn)``
           (:class:`ParserElement.setParseAction`)
       - lpar - expression for matching left-parentheses
         (default= ``Suppress('(')``)
       - rpar - expression for matching right-parentheses
         (default= ``Suppress(')')``)
  
      Example::
  
          # simple example of four-function arithmetic with ints and
          # variable names
          integer = pyparsing_common.signed_integer
          varname = pyparsing_common.identifier
  
          arith_expr = infixNotation(integer | varname,
              [
              ('-', 1, opAssoc.RIGHT),
              (oneOf('* /'), 2, opAssoc.LEFT),
              (oneOf('+ -'), 2, opAssoc.LEFT),
              ])
  
          arith_expr.runTests('''
              5+3*6
              (5+3)*6
              -2--11
              ''', fullDump=False)
  
      prints::
  
          5+3*6
          [[5, '+', [3, '*', 6]]]
  
          (5+3)*6
          [[[5, '+', 3], '*', 6]]
  
          -2--11
          [[['-', 2], '-', ['-', 11]]]
docstring_summary: Helper method for constructing grammars of expressions made up of
      operators working in a precedence hierarchy.  Operators may be unary
      or binary, left- or right-associative.  Parse actions can also be
      attached to operator expressions. The generated parser will also
      recognize the use of parentheses to override operator precedences
      (see example below).
docstring_tokens: Helper method for constructing grammars of expressions made up of operators working in a precedence hierarchy . Operators may be unary or binary left - or right - associative . Parse actions can also be attached to operator expressions . The generated parser will also recognize the use of parentheses to override operator precedences ( see example below ) .
function: def infixNotation(baseExpr, opList, lpar=Suppress('('), rpar=Suppress(')')):
      """Helper method for constructing grammars of expressions made up of
      operators working in a precedence hierarchy.  Operators may be unary
      or binary, left- or right-associative.  Parse actions can also be
      attached to operator expressions. The generated parser will also
      recognize the use of parentheses to override operator precedences
      (see example below).
  
      Note: if you define a deep operator list, you may see performance
      issues when using infixNotation. See
      :class:`ParserElement.enablePackrat` for a mechanism to potentially
      improve your parser performance.
  
      Parameters:
       - baseExpr - expression representing the most basic element for the
         nested
       - opList - list of tuples, one for each operator precedence level
         in the expression grammar; each tuple is of the form ``(opExpr,
         numTerms, rightLeftAssoc, parseAction)``, where:
  
         - opExpr is the pyparsing expression for the operator; may also
           be a string, which will be converted to a Literal; if numTerms
           is 3, opExpr is a tuple of two expressions, for the two
           operators separating the 3 terms
         - numTerms is the number of terms for this operator (must be 1,
           2, or 3)
         - rightLeftAssoc is the indicator whether the operator is right
           or left associative, using the pyparsing-defined constants
           ``opAssoc.RIGHT`` and ``opAssoc.LEFT``.
         - parseAction is the parse action to be associated with
           expressions matching this operator expression (the parse action
           tuple member may be omitted); if the parse action is passed
           a tuple or list of functions, this is equivalent to calling
           ``setParseAction(*fn)``
           (:class:`ParserElement.setParseAction`)
       - lpar - expression for matching left-parentheses
         (default= ``Suppress('(')``)
       - rpar - expression for matching right-parentheses
         (default= ``Suppress(')')``)
  
      Example::
  
          # simple example of four-function arithmetic with ints and
          # variable names
          integer = pyparsing_common.signed_integer
          varname = pyparsing_common.identifier
  
          arith_expr = infixNotation(integer | varname,
              [
              ('-', 1, opAssoc.RIGHT),
              (oneOf('* /'), 2, opAssoc.LEFT),
              (oneOf('+ -'), 2, opAssoc.LEFT),
              ])
  
          arith_expr.runTests('''
              5+3*6
              (5+3)*6
              -2--11
              ''', fullDump=False)
  
      prints::
  
          5+3*6
          [[5, '+', [3, '*', 6]]]
  
          (5+3)*6
          [[[5, '+', 3], '*', 6]]
  
          -2--11
          [[['-', 2], '-', ['-', 11]]]
      """
      # captive version of FollowedBy that does not do parse actions or capture results names
      class _FB(FollowedBy):
          def parseImpl(self, instring, loc, doActions=True):
              self.expr.tryParse(instring, loc)
              return loc, []
  
      ret = Forward()
      lastExpr = baseExpr | (lpar + ret + rpar)
      for i, operDef in enumerate(opList):
          opExpr, arity, rightLeftAssoc, pa = (operDef + (None, ))[:4]
          termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr
          if arity == 3:
              if opExpr is None or len(opExpr) != 2:
                  raise ValueError(
                      "if numterms=3, opExpr must be a tuple or list of two expressions")
              opExpr1, opExpr2 = opExpr
          thisExpr = Forward().setName(termName)
          if rightLeftAssoc == opAssoc.LEFT:
              if arity == 1:
                  matchExpr = _FB(lastExpr + opExpr) + Group(lastExpr + OneOrMore(opExpr))
              elif arity == 2:
                  if opExpr is not None:
                      matchExpr = _FB(lastExpr + opExpr + lastExpr) + Group(lastExpr + OneOrMore(opExpr + lastExpr))
                  else:
                      matchExpr = _FB(lastExpr + lastExpr) + Group(lastExpr + OneOrMore(lastExpr))
              elif arity == 3:
                  matchExpr = (_FB(lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr)
                               + Group(lastExpr + OneOrMore(opExpr1 + lastExpr + opExpr2 + lastExpr)))
              else:
                  raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
          elif rightLeftAssoc == opAssoc.RIGHT:
              if arity == 1:
                  # try to avoid LR with this extra test
                  if not isinstance(opExpr, Optional):
                      opExpr = Optional(opExpr)
                  matchExpr = _FB(opExpr.expr + thisExpr) + Group(opExpr + thisExpr)
              elif arity == 2:
                  if opExpr is not None:
                      matchExpr = _FB(lastExpr + opExpr + thisExpr) + Group(lastExpr + OneOrMore(opExpr + thisExpr))
                  else:
                      matchExpr = _FB(lastExpr + thisExpr) + Group(lastExpr + OneOrMore(thisExpr))
              elif arity == 3:
                  matchExpr = (_FB(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr)
                               + Group(lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr))
              else:
                  raise ValueError("operator must be unary (1), binary (2), or ternary (3)")
          else:
              raise ValueError("operator must indicate right or left associativity")
          if pa:
              if isinstance(pa, (tuple, list)):
                  matchExpr.setParseAction(*pa)
              else:
                  matchExpr.setParseAction(pa)
          thisExpr <<= (matchExpr.setName(termName) | lastExpr)
          lastExpr = thisExpr
      ret <<= lastExpr
      return ret
function_tokens: def infixNotation ( baseExpr , opList , lpar = Suppress ( '(' ) , rpar = Suppress ( ')' ) ) : # captive version of FollowedBy that does not do parse actions or capture results names class _FB ( FollowedBy ) : def parseImpl ( self , instring , loc , doActions = True ) : self . expr . tryParse ( instring , loc ) return loc , [ ] ret = Forward ( ) lastExpr = baseExpr | ( lpar + ret + rpar ) for i , operDef in enumerate ( opList ) : opExpr , arity , rightLeftAssoc , pa = ( operDef + ( None , ) ) [ : 4 ] termName = "%s term" % opExpr if arity < 3 else "%s%s term" % opExpr if arity == 3 : if opExpr is None or len ( opExpr ) != 2 : raise ValueError ( "if numterms=3, opExpr must be a tuple or list of two expressions" ) opExpr1 , opExpr2 = opExpr thisExpr = Forward ( ) . setName ( termName ) if rightLeftAssoc == opAssoc . LEFT : if arity == 1 : matchExpr = _FB ( lastExpr + opExpr ) + Group ( lastExpr + OneOrMore ( opExpr ) ) elif arity == 2 : if opExpr is not None : matchExpr = _FB ( lastExpr + opExpr + lastExpr ) + Group ( lastExpr + OneOrMore ( opExpr + lastExpr ) ) else : matchExpr = _FB ( lastExpr + lastExpr ) + Group ( lastExpr + OneOrMore ( lastExpr ) ) elif arity == 3 : matchExpr = ( _FB ( lastExpr + opExpr1 + lastExpr + opExpr2 + lastExpr ) + Group ( lastExpr + OneOrMore ( opExpr1 + lastExpr + opExpr2 + lastExpr ) ) ) else : raise ValueError ( "operator must be unary (1), binary (2), or ternary (3)" ) elif rightLeftAssoc == opAssoc . RIGHT : if arity == 1 : # try to avoid LR with this extra test if not isinstance ( opExpr , Optional ) : opExpr = Optional ( opExpr ) matchExpr = _FB ( opExpr . expr + thisExpr ) + Group ( opExpr + thisExpr ) elif arity == 2 : if opExpr is not None : matchExpr = _FB ( lastExpr + opExpr + thisExpr ) + Group ( lastExpr + OneOrMore ( opExpr + thisExpr ) ) else : matchExpr = _FB ( lastExpr + thisExpr ) + Group ( lastExpr + OneOrMore ( thisExpr ) ) elif arity == 3 : matchExpr = ( _FB ( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr ) + Group ( lastExpr + opExpr1 + thisExpr + opExpr2 + thisExpr ) ) else : raise ValueError ( "operator must be unary (1), binary (2), or ternary (3)" ) else : raise ValueError ( "operator must indicate right or left associativity" ) if pa : if isinstance ( pa , ( tuple , list ) ) : matchExpr . setParseAction ( * pa ) else : matchExpr . setParseAction ( pa ) thisExpr <<= ( matchExpr . setName ( termName ) | lastExpr ) lastExpr = thisExpr ret <<= lastExpr return ret