m�
ڍ�Oc@s�dZd
k
Z
d
kZd
kZd
kZd
kZhde<de<de<de<de<de<de<Zhde<Z	d	Z
d
ZdZdZ
d
ZdZdZdeiif
d��YZdef
d��YZdef
d��YZd
S(sTokenize DNS master file formatNt
 s
	s

t
;t
(t
)t
"ii
iiiiitUngetBufferFullc
BstZ
dZRS(
sRRaised when an attempt is made to unget a token when the unget
    buffer is full.(t__name__t
__module__t__doc__(((t1/usr/lib/python2.4/site-packages/dns/tokenizer.pyR,stTokencBs�tZ
dZd
ed�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zd�Zd�ZRS(s�A DNS master file format token.

    @ivar ttype: The token type
    @type ttype: int
    @ivar value: The token value
    @type value: string
    @ivar has_escape: Does the token value contain escapes?
    @type has_escape: bool
    tcCs|
|_||_||_d
S(s
Initialize a token instance.

        @param ttype: The token type
        @type ttype: int
        @param value: The token value
        @type value: string
        @param has_escape: Does the token value contain escapes?
        @type has_escape: bool
        N(tttypetselftvaluet
has_escape(R
RRR((R	t__init__<s	
	
	
c

Cs
|i
tjS(
N(R
RtEOF(
R
((R	tis_eofJs
c

Cs
|i
tjS(
N(R
RtEOL(
R
((R	tis_eolMs
c

Cs
|i
tjS(
N(R
Rt
WHITESPACE(
R
((R	t
is_whitespacePs
c

Cs
|i
tjS(
N(R
Rt
IDENTIFIER(
R
((R	t
is_identifierSs
c

Cs
|i
tjS(
N(R
Rt
QUOTED_STRING(
R
((R	tis_quoted_stringVs
c

Cs
|i
tjS(
N(R
RtCOMMENT(
R
((R	t
is_commentYs
c

Cs
|i
tjS(
N(R
Rt	DELIMITER(
R
((R	tis_delimiter\s
c

Cs|i
tjp

|i
tjS(
N(R
RRR(
R
((R	t
is_eol_or_eof_s
cCs;t|
t�p
tSn

|i|
ijo
|i|
ijS(
N(t
isinstancetotherR
tFalseR
RR(R
R!((R	t__eq__bs


cCs;t|
t�p
tSn

|i|
ijp
|i|
ijS(
N(R R!R
tTrueR
RR(R
R!((R	t__ne__hs


c

Csd
|i
|ifS(Ns%d "%s"(R
RR(
R
((R	t__str__ns
c
Cs�
|i
p
|Sn

d
}t|i�
}d}xI
||jo;

|i|}
|d7}|
djo	

||jo
ti	i
�
n

|i|}
|d7}|
i�o�
||jo
ti	i
�
n

|i|}|d7}||jo
ti	i
�
n

|i|}|d7}|i�o

|i�p
ti	i�
n

tt|
�
dt|�
dt|�
�
}
qj

n

||
7}q0
Wt|i|�S(NRii
s
\idi
(R
Rt	unescapedtlenRt
lt
it
ctdnst	exceptiont
UnexpectedEndtisdigittc2tc3tSyntaxErrortchrtintR
R(R
R+R*R'R)R1R0((R	tunescapeqs8







































6

c


Csd
S(Ni((
R
((R	t__len__�s
c

Cst|i|if�
S(
N(titerR
RR(
R
((R	t__iter__�s
cCs:|
d
jo
|iSn
|
djo
|iSn
t�
dS(Nii
(R*R
RRt
IndexError(R
R*((R	t__getitem__�s






(RRRR"RRRRRRRRRR#R%R&R5R6R8R:(((R	R
1s"															t	TokenizercBs�tZ
dZeied
�Zd�Zd�Zd�Z	d�Z
eed�Zd�Z
d�Zd	�Zd
�Zd�Zd�Zd
�Zed�
Zed�
Zed�
Zd�Zd�ZRS(s�A DNS master file format tokenizer.

    A token is a (type, value) tuple, where I{type} is an int, and
    I{value} is a string.  The valid types are EOF, EOL, WHITESPACE,
    IDENTIFIER, QUOTED_STRING, COMMENT, and DELIMITER.

    @ivar file: The file to tokenize
    @type file: file
    @ivar ungotten_char: The most recently ungotten character, or None.
    @type ungotten_char: string
    @ivar ungotten_token: The most recently ungotten token, or None.
    @type ungotten_token: (int, string) token tuple
    @ivar multiline: The current multiline level.  This value is increased
    by one every time a '(' delimiter is read, and decreased by one every time
    a ')' delimiter is read.
    @type multiline: int
    @ivar quoting: This variable is true if the tokenizer is currently
    reading a quoted string.
    @type quoting: bool
    @ivar eof: This variable is true if the tokenizer has encountered EOF.
    @type eof: bool
    @ivar delimiters: The current delimiter dictionary.
    @type delimiters: dict
    @ivar line_number: The current line number
    @type line_number: int
    @ivar filename: A filename that will be returned by the L{where} method.
    @type filename: string
    cCs�t|
t�o*
ti|
�
}
|djo

d
}qk
n2
|djo$
|
tijo

d}qk
d}n

|
|_
d|_d|_d|_
t|_t|_t|_d|_||_dS(s�
Initialize a tokenizer instance.

        @param f: The file to tokenize.  The default is sys.stdin.
        This parameter may also be a string, in which case the tokenizer
        will take its input from the contents of the string.
        @type f: file or string
        @param filename: the name of the filename that the L{where} method
        will return.
        @type filename: string
        s<string>s<stdin>s<file>ii
N(R t
ftstrt	cStringIOtStringIOtfilenametNonetsyststdinR
tfilet
ungotten_chartungotten_tokent	multilineR"tquotingteoft_DELIMITERSt
delimiterstline_number(R
R<R@((R	R�s$










	
	
	
	
	
	
	
	
c
Cs�|i
djod
|io

d
}
q�
|iid�
}
|
d
jo

t|_q�
|
djo
|id7_q�
n
|i
}
d|_
|
S(s<Read a character from input.
        @rtype: string
        Ri
s

N(	R
RERARIR+RDtreadR$RL(R
R+((R	t	_get_char�s










	
	
c

Cs|i
|ifS(s�Return the current location in the input.

        @rtype: (string, int) tuple.  The first item is the filename of
        the input, the second is the current line number.
        N(R
R@RL(
R
((R	twhere�scCs'|i
d
j	o

t�
n

|
|_
d
S(sE
Unget a character.

        The unget buffer for characters is only one character large; it is
        an error to try to unget a character when the unget buffer is not
        empty.

        @param c: the character to unget
        @type c: string
        @raises UngetBufferFull: there is already an ungotten char
        N(R
RERARR+(R
R+((R	t_unget_char�s



c
Cszd
}
xmt
oe
|i�}|djo>
|djo1
|djp
|io
|i|�

|
Sqg
n

|
d7}
q	
WdS(s(
Consume input until a non-whitespace character is encountered.

        The non-whitespace character is then ungotten, and the number of
        whitespace characters consumed is returned.

        If the tokenizer is in multiline mode, then newlines are whitespace.

        @rtype: int
        iRs
	s

i
N(tskippedR$R
RNR+RGRP(R
RQR+((R	tskip_whitespace
s	







c
Cs�|i
dj	oZ
|i
}	d|_
|	i�o
|
o
|	Sqf
qj
|	i�o
|o
|	Sqf
qj
|	Sn

|i�}|
o
|d
jo
t
td�Sn

d}	t}t}x�to�
|i�}|djp
||ijo0
|djo
|io
tii�
n

|	djo�

|tjo�

|djo 
|id7_|i�
q�q
|djo@
|id
jp
tii�
n

|id8_|i�
q�q
|djoL
|ip
t|_t|_t}q�q�
t|_t|_|i�
q�q
|djo
t
td�Sq
|d	jo�
x:|i�}|djp

|djo
Pn

|	|7}	q"
W|o
|i|�

t
t|	�Sq�
|djo.
|io
tiid
�
�
n

t
t �
Sq�
|io
|i�
d}	q�q�
t
td�Sq
|}	t!}n
|i|�

Pn~

|io

|djo�
|i�}|djo
tii�
n

|i"�o�
|i�}|djo
tii�
n

|i�}|djo
tii�
n

|i"�o

|i"�p
tii�
n

t%t&|�
dt&|�
d
t&|�
�
}q2
q�
|djo
tiid�
�
q�
nX
|djoJ
|	|7}	t}|i�}|djp

|djo
tii�
q�
n

|	|7}	q�
W|	djo7
|tjo*
|io
tiid
�
�
n

t }n

t
||	|�S(sGet the next token.

        @param want_leading: If True, return a WHITESPACE token if the
        first character read is whitespace.  The default is False.
        @type want_leading: bool
        @param want_comment: If True, return a COMMENT token if the
        first token read is a comment.  The default is False.
        @type want_comment: bool
        @rtype: Token object
        @raises dns.exception.UnexpectedEnd: input ended prematurely
        @raises dns.exception.SyntaxError: input was badly formed
        iRRRi
RRs

R
sunbalanced parenthesess
\idi
snewline in quoted stringN('R
RFRAttokenRtwant_leadingRtwant_commentRRRQR
RRRR"RR$RNR+RKRHR,R-R.RRGR2t_QUOTING_DELIMITERSRJRRPRRRR/R0R1R3R4(
R
RTRURRRQR1R0R+RS((R	tget
s�
	
	






































	
	

	
	





















































6

















cCs'|i
d
j	o

t�
n

|
|_
d
S(s@
Unget a token.

        The unget buffer for tokens is only one token large; it is
        an error to try to unget a token when the unget buffer is not
        empty.

        @param token: the token to unget
        @type token: Token object
        @raises UngetBufferFull: there is already an ungotten token
        N(R
RFRARRS(R
RS((R	tunget�
s



c

Cs'|i
�}
|
i�o

t�
n

|
S(sLReturn the next item in an iteration.
        @rtype: (int, string)
        N(R
RWRSRt
StopIteration(R
RS((R	tnext�
s





c


Cs|S(
N(
R
(
R
((R	R8�
s
c
Csh|i
�i�}
|
i�p
tiid
�
�
n

|
ii	�p
tiid�
�
n

t
|
i�
S(s|Read the next token and interpret it as an integer.

        @raises dns.exception.SyntaxError:
        @rtype: int
        sexpecting an identifiersexpecting an integerN(R
RWR5RSRR,R-R2RR/R4(R
RS((R	tget_int�
s





c
CsD|i
�}
|
d
jp

|
djo
tiid|
�
�
n

|
S(s�Read the next token and interpret it as an 8-bit unsigned
        integer.

        @raises dns.exception.SyntaxError:
        @rtype: int
        ii�s#%d is not an unsigned 8-bit integerN(R
R[RR,R-R2(R
R((R	t	get_uint8�
s



c
CsD|i
�}
|
d
jp

|
djo
tiid|
�
�
n

|
S(s�Read the next token and interpret it as a 16-bit unsigned
        integer.

        @raises dns.exception.SyntaxError:
        @rtype: int
        ii��s$%d is not an unsigned 16-bit integerN(R
R[RR,R-R2(R
R((R	t
get_uint16�
s



c
Cs�|i
�i�}|i�p
tiid
�
�
n

|ii	�p
tiid�
�
n

t
|i�
}
|
djp

|
djo
tiid|
�
�
n

|
S(s�Read the next token and interpret it as a 32-bit unsigned
        integer.

        @raises dns.exception.SyntaxError:
        @rtype: int
        sexpecting an identifiersexpecting an integerils$%d is not an unsigned 32-bit integerN(R
RWR5RSRR,R-R2RR/tlong(R
RRS((R	t
get_uint32�
s








cCsI|i
�i�}|i�p

|i�p
tiid
�
�
n

|i	S(s}Read the next token and interpret it as a string.

        @raises dns.exception.SyntaxError:
        @rtype: string
        sexpecting a stringN(
R
RWR5RSRRR,R-R2R(R
toriginRS((R	t
get_string�
s



cCs<|i
�i�}|i�p
tiid
�
�
n

|iS(s�Read the next token and raise an exception if it is not an identifier.

        @raises dns.exception.SyntaxError:
        @rtype: string
        sexpecting an identifierN(	R
RWR5RSRR,R-R2R(R
R`RS((R	tget_identifier�
s




cCsE|i
�}|i�p
tiid
�
�
n

tii|i	|
�S(s�Read the next token and interpret it as a DNS name.

        @raises dns.exception.SyntaxError:
        @rtype: dns.name.Name objectsexpecting an identifierN(R
RWRSRR,R-R2tnamet	from_textRR`(R
R`RS((R	tget_names




c
CsF|i
�}
|
i�p&
tiid
|
i|
if�
�
n

|
iS(s�Read the next token and raise an exception if it isn't EOL or
        EOF.

        @raises dns.exception.SyntaxError:
        @rtype: string
        s expected EOL or EOF, got %d "%s"N(	R
RWRSRR,R-R2RR(R
RS((R	tget_eols



&
c
CsH|i
�i�}
|
i�p
tiid
�
�
n

tii	|
i
�
S(Nsexpecting an identifier(R
RWR5RSRR,R-R2tttlRdR(R
RS((R	tget_ttls




(RRRRBRCRARRNRORPRRR"RWRXRZR8R[R\R]R_RaRbReRfRh(((R	R;�s& 					z		
			
	
		
(RR>RBt
dns.exceptionR,tdns.nametdns.ttlR$RJRVRRRRRRRR-tDNSExceptionRtobjectR
R;(RR>RR;R
RRRBRRR,RJRRVR((R	t
?s"	
		
	
	E	





m