pyparsing.QuotedString Class Reference

Inheritance diagram for pyparsing.QuotedString:

Collaboration diagram for pyparsing.QuotedString:

Public Member Functions
def	__init__
def	parseImpl
def	__str__
Public Member Functions inherited from pyparsing.Token
def	__init__
def	setName
Public Member Functions inherited from pyparsing.ParserElement
def	setDefaultWhitespaceChars
def	__init__
def	copy
def	setName
def	setResultsName
def	setBreak
def	setParseAction
def	addParseAction
def	setFailAction
def	preParse
def	parseImpl
def	postParse
def	tryParse
def	resetCache
def	enablePackrat
def	parseString
def	scanString
def	transformString
def	searchString
def	__add__
def	__radd__
def	__sub__
def	__rsub__
def	__mul__
def	__rmul__
def	__or__
def	__ror__
def	__xor__
def	__rxor__
def	__and__
def	__rand__
def	__invert__
def	__call__
def	suppress
def	leaveWhitespace
def	setWhitespaceChars
def	parseWithTabs
def	ignore
def	setDebugActions
def	setDebug
def	__str__
def	__repr__
def	streamline
def	checkRecursion
def	validate
def	parseFile
def	getException
def	__getattr__
def	__eq__
def	__ne__
def	__hash__
def	__req__
def	__rne__

Public Attributes
	quoteChar
	quoteCharLen
	firstQuoteChar
	endQuoteChar
	endQuoteCharLen
	escChar
	escQuote
	unquoteResults
	flags
	pattern
	escCharReplacePattern
	re
	reString
	name
	errmsg
	mayIndexError
	mayReturnEmpty
	strRepr
Public Attributes inherited from pyparsing.Token
	errmsg
Public Attributes inherited from pyparsing.ParserElement
	parseAction
	failAction
	strRepr
	resultsName
	saveAsList
	skipWhitespace
	whiteChars
	copyDefaultWhiteChars
	mayReturnEmpty
	keepTabs
	ignoreExprs
	debug
	streamlined
	mayIndexError
	errmsg
	modalResults
	debugActions
	re
	callPreparse
	callDuringTry
	name
	myException

Additional Inherited Members
Static Public Attributes inherited from pyparsing.ParserElement
string	DEFAULT_WHITE_CHARS " \n\t\r"
tuple	setDefaultWhitespaceChars staticmethod(setDefaultWhitespaceChars)
tuple	resetCache staticmethod(resetCache)
tuple	enablePackrat staticmethod(enablePackrat)

Detailed Description

Token for matching strings that are delimited by quoting characters.

Definition at line 1799 of file pyparsing.py.

Constructor & Destructor Documentation

def pyparsing.QuotedString.__init__	(		self,
			quoteChar,
			escChar = None,
			escQuote = None,
			multiline = False,
			unquoteResults = True,
			endQuoteChar = None
	)

   Defined with the following parameters:
    - quoteChar - string of one or more characters defining the quote delimiting string
    - escChar - character to escape quotes, typically backslash (default=None)
    - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=None)
    - multiline - boolean indicating whether quotes can span multiple lines (default=False)
    - unquoteResults - boolean indicating whether the matched text should be unquoted (default=True)
    - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=None => same as quoteChar)

Definition at line 1802 of file pyparsing.py.

    def __init__( self, quoteChar, escChar=None, escQuote=None, multiline=False, unquoteResults=True, endQuoteChar=None):
        """
           Defined with the following parameters:
            - quoteChar - string of one or more characters defining the quote delimiting string
            - escChar - character to escape quotes, typically backslash (default=None)
            - escQuote - special quote sequence to escape an embedded quote string (such as SQL's "" to escape an embedded ") (default=None)
            - multiline - boolean indicating whether quotes can span multiple lines (default=False)
            - unquoteResults - boolean indicating whether the matched text should be unquoted (default=True)
            - endQuoteChar - string of one or more characters defining the end of the quote delimited string (default=None => same as quoteChar)
        """
        super(QuotedString,self).__init__()

        # remove white space from quote chars - wont work anyway
        quoteChar = quoteChar.strip()
        if len(quoteChar) == 0:
            warnings.warn("quoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
            raise SyntaxError()

        if endQuoteChar is None:
            endQuoteChar = quoteChar
        else:
            endQuoteChar = endQuoteChar.strip()
            if len(endQuoteChar) == 0:
                warnings.warn("endQuoteChar cannot be the empty string",SyntaxWarning,stacklevel=2)
                raise SyntaxError()

        self.quoteChar = quoteChar
        self.quoteCharLen = len(quoteChar)
        self.firstQuoteChar = quoteChar[0]
        self.endQuoteChar = endQuoteChar
        self.endQuoteCharLen = len(endQuoteChar)
        self.escChar = escChar
        self.escQuote = escQuote
        self.unquoteResults = unquoteResults

        if multiline:
            self.flags = re.MULTILINE | re.DOTALL
            self.pattern = r'%s(?:[^%s%s]' % \
                ( re.escape(self.quoteChar),
                  _escapeRegexRangeChars(self.endQuoteChar[0]),
                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
        else:
            self.flags = 0
            self.pattern = r'%s(?:[^%s\n\r%s]' % \
                ( re.escape(self.quoteChar),
                  _escapeRegexRangeChars(self.endQuoteChar[0]),
                  (escChar is not None and _escapeRegexRangeChars(escChar) or '') )
        if len(self.endQuoteChar) > 1:
            self.pattern += (
                '|(?:' + ')|(?:'.join(["%s[^%s]" % (re.escape(self.endQuoteChar[:i]),
                                               _escapeRegexRangeChars(self.endQuoteChar[i]))
                                    for i in range(len(self.endQuoteChar)-1,0,-1)]) + ')'
                )
        if escQuote:
            self.pattern += (r'|(?:%s)' % re.escape(escQuote))
        if escChar:
            self.pattern += (r'|(?:%s.)' % re.escape(escChar))
            self.escCharReplacePattern = re.escape(self.escChar)+"(.)"
        self.pattern += (r')*%s' % re.escape(self.endQuoteChar))

        try:
            self.re = re.compile(self.pattern, self.flags)
            self.reString = self.pattern
        except sre_constants.error:
            warnings.warn("invalid pattern (%s) passed to Regex" % self.pattern,
                SyntaxWarning, stacklevel=2)
            raise

        self.name = _ustr(self)
        self.errmsg = "Expected " + self.name
        #self.myException.msg = self.errmsg
        self.mayIndexError = False
        self.mayReturnEmpty = True