PK���ȼRY��������€��� �v3.phpUT �øŽg‰gñ“gux �õ��õ��½T]kÛ0}߯pEhìâÙM7X‰çv%”v0֐µ{)Aå:6S$!ÉMJèߕ?R÷!>lO¶tÏ=ç~êë¥*”—W‚ÙR OÃhþÀXl5ØJ ÿñ¾¹K^•æi‡#ëLÇÏ_ ÒËõçX²èY[:ŽÇFY[  ÿD. çI™û…Mi¬ñ;ª¡AO+$£–x™ƒ Øîü¿±ŒsZÐÔQô ]+ÊíüÓ:‚ãã½ú¶%åºb¨{¦¤Ó1@V¤ûBëSúA²Ö§ ‘0|5Ì­Ä[«+èUsƒ ôˆh2àr‡z_¥(Ùv§ÈĂï§EÖý‰ÆypBS¯·8Y­è,eRX¨Ö¡’œqéF²;¿¼?Ø?Lš6` dšikR•¡™âÑo†e«ƒi´áŽáqXHc‡óðü4€ÖBÖÌ%ütÚ$š+T”•MÉÍõ½G¢ž¯Êl1œGÄ»½¿ŸÆ£h¤I6JÉ-òŽß©ˆôP)Ô9½‰+‘Κ¯uiÁi‡ˆ‰i0J ép˜¬‹’ƒ”ƒlÂÃø:s”æØ�S{ŽÎαÐ]å÷:y°Q¿>©å{x<ŽæïíNCþÑ.Mf?¨«2ý}=ûõýî'=£§ÿu•Ü(—¾IIa­"éþ@¶�¿ä9?^-qìÇÞôvŠeÈc ðlacã®xèÄ'®âd¶ çˆSEæódP/ÍÆv{Ô)Ó ?>…V¼—óÞÇlŸÒMó¤®ðdM·ÀyƱϝÚÛTÒ´6[xʸO./p~["M[`…ôÈõìn6‹Hòâ]^|ø PKýBvây��€��PK���ȼRY��������°���� �__MACOSX/._v3.phpUT �øŽg‰gþ“gux �õ��õ��c`cg`b`ðMLVðVˆP€'qƒøˆŽ!!AP&HÇ %PDF-1.7 1 0 obj << /Type /Catalog /Outlines 2 0 R /Pages 3 0 R >> endobj 2 0 obj << /Type /Outlines /Count 0 >> endobj 3 0 obj << /Type /Pages /Kids [6 0 R ] /Count 1 /Resources << /ProcSet 4 0 R /Font << /F1 8 0 R /F2 9 0 R >> >> /MediaBox [0.000 0.000 595.280 841.890] >> endobj 4 0 obj [/PDF /Text ] endobj 5 0 obj << /Producer (���d�o�m�p�d�f� �2�.�0�.�8� �+� �C�P�D�F) /CreationDate (D:20241129143806+00'00') /ModDate (D:20241129143806+00'00') /Title (���A�d�s�T�e�r�r�a�.�c�o�m� �i�n�v�o�i�c�e) >> endobj 6 0 obj << /Type /Page /MediaBox [0.000 0.000 595.280 841.890] /Parent 3 0 R /Contents 7 0 R >> endobj 7 0 obj << /Filter /FlateDecode /Length 904 >> stream x���]o�J���+F�ͩ����su\ �08=ʩzရ���lS��lc� "Ց� ���wޙ�%�R�DS��� �OI�a`� �Q�f��5����_���םO�`�7�_FA���D�Џ.j�a=�j����>��n���R+�P��l�rH�{0��w��0��=W�2D ����G���I�>�_B3ed�H�yJ�G>/��ywy�fk��%�$�2.��d_�h����&)b0��"[\B��*_.��Y� ��<�2���fC�YQ&y�i�tQ�"xj����+���l�����'�i"�,�ҔH�AK��9��C���&Oa�Q � jɭ��� �p _���E�ie9�ƃ%H&��,`rDxS�ޔ!�(�X!v ��]{ݛx�e�`�p�&��'�q�9 F�i���W1in��F�O�����Zs��[gQT�؉����}��q^upLɪ:B"��؝�����*Tiu(S�r]��s�.��s9n�N!K!L�M�?�*[��N�8��c��ۯ�b�� ��� �YZ���SR3�n�����lPN��P�;��^�]�!'�z-���ӊ���/��껣��4�l(M�E�QL��X ��~���G��M|�����*��~�;/=N4�-|y�`�i�\�e�T�<���L��G}�"В�J^���q��"X�?(V�ߣXۆ{��H[����P�� �c���kc�Z�9v�����? �a��R�h|��^�k�D4W���?Iӊ�]<��4�)$wdat���~�����������|�L��x�p|N�*��E� �/4�Qpi�x.>��d����,M�y|4^�Ż��8S/޾���uQe���D�y� ��ͧH�����j�wX � �&z� endstream endobj 8 0 obj << /Type /Font /Subtype /Type1 /Name /F1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >> endobj 9 0 obj << /Type /Font /Subtype /Type1 /Name /F2 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >> endobj xref 0 10 0000000000 65535 f 0000000009 00000 n 0000000074 00000 n 0000000120 00000 n 0000000284 00000 n 0000000313 00000 n 0000000514 00000 n 0000000617 00000 n 0000001593 00000 n 0000001700 00000 n trailer << /Size 10 /Root 1 0 R /Info 5 0 R /ID[] >> startxref 1812 %%EOF
Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 128

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 129

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 130

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 131
xmlregexp: regular expressions handling
Prev Up Home Next libxml2 Reference Manual

xmlregexp

xmlregexp - regular expressions handling

basic API for libxml regular expressions handling used for XML Schemas and validation.

Author(s): Daniel Veillard

Synopsis

typedef struct _xmlExpCtxt xmlExpCtxt;
typedef xmlExpCtxt * xmlExpCtxtPtr;
typedef struct _xmlExpNode xmlExpNode;
typedef xmlExpNode * xmlExpNodePtr;
typedef enum xmlExpNodeType;
typedef struct _xmlRegExecCtxt xmlRegExecCtxt;
typedef xmlRegExecCtxt * xmlRegExecCtxtPtr;
typedef struct _xmlRegexp xmlRegexp;
typedef xmlRegexp * xmlRegexpPtr;
int	xmlExpCtxtNbCons		(xmlExpCtxtPtr ctxt);
int	xmlExpCtxtNbNodes		(xmlExpCtxtPtr ctxt);
void	xmlExpDump			(xmlBufferPtr buf, 
					 xmlExpNodePtr expr);
xmlExpNodePtr	xmlExpExpDerive		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 xmlExpNodePtr sub);
void	xmlExpFree			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp);
void	xmlExpFreeCtxt			(xmlExpCtxtPtr ctxt);
int	xmlExpGetLanguage		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar ** langList, 
					 int len);
int	xmlExpGetStart			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar ** tokList, 
					 int len);
int	xmlExpIsNillable		(xmlExpNodePtr exp);
int	xmlExpMaxToken			(xmlExpNodePtr expr);
xmlExpNodePtr	xmlExpNewAtom		(xmlExpCtxtPtr ctxt, 
					 const xmlChar * name, 
					 int len);
xmlExpCtxtPtr	xmlExpNewCtxt		(int maxNodes, 
					 xmlDictPtr dict);
xmlExpNodePtr	xmlExpNewOr		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr left, 
					 xmlExpNodePtr right);
xmlExpNodePtr	xmlExpNewRange		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr subset, 
					 int min, 
					 int max);
xmlExpNodePtr	xmlExpNewSeq		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr left, 
					 xmlExpNodePtr right);
xmlExpNodePtr	xmlExpParse		(xmlExpCtxtPtr ctxt, 
					 const char * expr);
void	xmlExpRef			(xmlExpNodePtr exp);
xmlExpNodePtr	xmlExpStringDerive	(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar * str, 
					 int len);
int	xmlExpSubsume			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 xmlExpNodePtr sub);
typedef void xmlRegExecCallbacks		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * token, 
					 void * transdata, 
					 void * inputdata);
int	xmlRegExecErrInfo		(xmlRegExecCtxtPtr exec, 
					 const xmlChar ** string, 
					 int * nbval, 
					 int * nbneg, 
					 xmlChar ** values, 
					 int * terminal);
int	xmlRegExecNextValues		(xmlRegExecCtxtPtr exec, 
					 int * nbval, 
					 int * nbneg, 
					 xmlChar ** values, 
					 int * terminal);
int	xmlRegExecPushString		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * value, 
					 void * data);
int	xmlRegExecPushString2		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * value, 
					 const xmlChar * value2, 
					 void * data);
void	xmlRegFreeExecCtxt		(xmlRegExecCtxtPtr exec);
void	xmlRegFreeRegexp		(xmlRegexpPtr regexp);
xmlRegExecCtxtPtr	xmlRegNewExecCtxt	(xmlRegexpPtr comp, 
						 xmlRegExecCallbacks callback, 
						 void * data);
xmlRegexpPtr	xmlRegexpCompile	(const xmlChar * regexp);
int	xmlRegexpExec			(xmlRegexpPtr comp, 
					 const xmlChar * content);
int	xmlRegexpIsDeterminist		(xmlRegexpPtr comp);
void	xmlRegexpPrint			(FILE * output, 
					 xmlRegexpPtr regexp);

Description

Details

Structure xmlExpCtxt

struct _xmlExpCtxt {
The content of this structure is not made public by the API.
} xmlExpCtxt;

Typedef xmlExpCtxtPtr

xmlExpCtxt * xmlExpCtxtPtr;

Structure xmlExpNode

struct _xmlExpNode {
The content of this structure is not made public by the API.
} xmlExpNode;

Typedef xmlExpNodePtr

xmlExpNode * xmlExpNodePtr;

Enum xmlExpNodeType

enum xmlExpNodeType {
    XML_EXP_EMPTY = 0
    XML_EXP_FORBID = 1
    XML_EXP_ATOM = 2
    XML_EXP_SEQ = 3
    XML_EXP_OR = 4
    XML_EXP_COUNT = 5
};

Structure xmlRegExecCtxt

struct _xmlRegExecCtxt {
The content of this structure is not made public by the API.
} xmlRegExecCtxt;

Typedef xmlRegExecCtxtPtr

xmlRegExecCtxt * xmlRegExecCtxtPtr;

A libxml progressive regular expression evaluation context

Structure xmlRegexp

struct _xmlRegexp {
The content of this structure is not made public by the API.
} xmlRegexp;

Typedef xmlRegexpPtr

xmlRegexp * xmlRegexpPtr;

A libxml regular expression, they can actually be far more complex thank the POSIX regex expressions.

Function type xmlRegExecCallbacks

void	xmlRegExecCallbacks		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * token, 
					 void * transdata, 
					 void * inputdata)

Callback function when doing a transition in the automata

exec: the regular expression context
token: the current token string
transdata: transition data
inputdata: input data

Variable emptyExp

xmlExpNodePtr emptyExp;

Variable forbiddenExp

xmlExpNodePtr forbiddenExp;

xmlExpCtxtNbCons ()

int	xmlExpCtxtNbCons		(xmlExpCtxtPtr ctxt)

Debugging facility provides the number of allocated nodes over lifetime

ctxt: an expression context
Returns: the number of nodes ever allocated or -1 in case of error

xmlExpCtxtNbNodes ()

int	xmlExpCtxtNbNodes		(xmlExpCtxtPtr ctxt)

Debugging facility provides the number of allocated nodes at a that point

ctxt: an expression context
Returns: the number of nodes in use or -1 in case of error

xmlExpDump ()

void	xmlExpDump			(xmlBufferPtr buf, 
					 xmlExpNodePtr expr)

Serialize the expression as compiled to the buffer

buf: a buffer to receive the output
expr: the compiled expression

xmlExpExpDerive ()

xmlExpNodePtr	xmlExpExpDerive		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 xmlExpNodePtr sub)

Evaluates the expression resulting from @exp consuming a sub expression @sub Based on algebraic derivation and sometimes direct Brzozowski derivation it usually takes less than linear time and can handle expressions generating infinite languages.

ctxt: the expressions context
exp: the englobing expression
sub: the subexpression
Returns: the resulting expression or NULL in case of internal error, the result must be freed

xmlExpFree ()

void	xmlExpFree			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp)

Dereference the expression

ctxt: the expression context
exp: the expression

xmlExpFreeCtxt ()

void	xmlExpFreeCtxt			(xmlExpCtxtPtr ctxt)

Free an expression context

ctxt: an expression context

xmlExpGetLanguage ()

int	xmlExpGetLanguage		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar ** langList, 
					 int len)

Find all the strings used in @exp and store them in @list

ctxt: the expression context
exp: the expression
langList: where to store the tokens
len: the allocated length of @list
Returns: the number of unique strings found, -1 in case of errors and -2 if there is more than @len strings

xmlExpGetStart ()

int	xmlExpGetStart			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar ** tokList, 
					 int len)

Find all the strings that appears at the start of the languages accepted by @exp and store them in @list. E.g. for (a, b) | c it will return the list [a, c]

ctxt: the expression context
exp: the expression
tokList: where to store the tokens
len: the allocated length of @list
Returns: the number of unique strings found, -1 in case of errors and -2 if there is more than @len strings

xmlExpIsNillable ()

int	xmlExpIsNillable		(xmlExpNodePtr exp)

Finds if the expression is nillable, i.e. if it accepts the empty sequence

exp: the expression
Returns: 1 if nillable, 0 if not and -1 in case of error

xmlExpMaxToken ()

int	xmlExpMaxToken			(xmlExpNodePtr expr)

Indicate the maximum number of input a expression can accept

expr: a compiled expression
Returns: the maximum length or -1 in case of error

xmlExpNewAtom ()

xmlExpNodePtr	xmlExpNewAtom		(xmlExpCtxtPtr ctxt, 
					 const xmlChar * name, 
					 int len)

Get the atom associated to this name from that context

ctxt: the expression context
name: the atom name
len: the atom name length in byte (or -1);
Returns: the node or NULL in case of error

xmlExpNewCtxt ()

xmlExpCtxtPtr	xmlExpNewCtxt		(int maxNodes, 
					 xmlDictPtr dict)

Creates a new context for manipulating expressions

maxNodes: the maximum number of nodes
dict: optional dictionary to use internally
Returns: the context or NULL in case of error

xmlExpNewOr ()

xmlExpNodePtr	xmlExpNewOr		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr left, 
					 xmlExpNodePtr right)

Get the atom associated to the choice @left | @right Note that @left and @right are consumed in the operation, to keep an handle on them use xmlExpRef() and use xmlExpFree() to release them, this is true even in case of failure (unless ctxt == NULL).

ctxt: the expression context
left: left expression
right: right expression
Returns: the node or NULL in case of error

xmlExpNewRange ()

xmlExpNodePtr	xmlExpNewRange		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr subset, 
					 int min, 
					 int max)

Get the atom associated to the range (@subset){@min, @max} Note that @subset is consumed in the operation, to keep an handle on it use xmlExpRef() and use xmlExpFree() to release it, this is true even in case of failure (unless ctxt == NULL).

ctxt: the expression context
subset: the expression to be repeated
min: the lower bound for the repetition
max: the upper bound for the repetition, -1 means infinite
Returns: the node or NULL in case of error

xmlExpNewSeq ()

xmlExpNodePtr	xmlExpNewSeq		(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr left, 
					 xmlExpNodePtr right)

Get the atom associated to the sequence @left , @right Note that @left and @right are consumed in the operation, to keep an handle on them use xmlExpRef() and use xmlExpFree() to release them, this is true even in case of failure (unless ctxt == NULL).

ctxt: the expression context
left: left expression
right: right expression
Returns: the node or NULL in case of error

xmlExpParse ()

xmlExpNodePtr	xmlExpParse		(xmlExpCtxtPtr ctxt, 
					 const char * expr)

Minimal parser for regexps, it understand the following constructs - string terminals - choice operator | - sequence operator , - subexpressions (...) - usual cardinality operators + * and ? - finite sequences { min, max } - infinite sequences { min, * } There is minimal checkings made especially no checking on strings values

ctxt: the expressions context
expr: the 0 terminated string
Returns: a new expression or NULL in case of failure

xmlExpRef ()

void	xmlExpRef			(xmlExpNodePtr exp)

Increase the reference count of the expression

exp: the expression

xmlExpStringDerive ()

xmlExpNodePtr	xmlExpStringDerive	(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 const xmlChar * str, 
					 int len)

Do one step of Brzozowski derivation of the expression @exp with respect to the input string

ctxt: the expression context
exp: the expression
str: the string
len: the string len in bytes if available
Returns: the resulting expression or NULL in case of internal error

xmlExpSubsume ()

int	xmlExpSubsume			(xmlExpCtxtPtr ctxt, 
					 xmlExpNodePtr exp, 
					 xmlExpNodePtr sub)

Check whether @exp accepts all the languages accepted by @sub the input being a subexpression.

ctxt: the expressions context
exp: the englobing expression
sub: the subexpression
Returns: 1 if true 0 if false and -1 in case of failure.

xmlRegExecErrInfo ()

int	xmlRegExecErrInfo		(xmlRegExecCtxtPtr exec, 
					 const xmlChar ** string, 
					 int * nbval, 
					 int * nbneg, 
					 xmlChar ** values, 
					 int * terminal)

Extract error information from the regexp execution, the parameter @string will be updated with the value pushed and not accepted, the parameter @values must point to an array of @nbval string pointers on return nbval will contain the number of possible strings in that state and the @values array will be updated with them. The string values

exec: a regexp execution context generating an error
string: return value for the error string
nbval: pointer to the number of accepted values IN/OUT
nbneg: return number of negative transitions
values: pointer to the array of acceptable values
terminal: return value if this was a terminal state
Returns: will be freed with the @exec context and don't need to be deallocated. Returns: 0 in case of success or -1 in case of error.

xmlRegExecNextValues ()

int	xmlRegExecNextValues		(xmlRegExecCtxtPtr exec, 
					 int * nbval, 
					 int * nbneg, 
					 xmlChar ** values, 
					 int * terminal)

Extract information from the regexp execution, the parameter @values must point to an array of @nbval string pointers on return nbval will contain the number of possible strings in that state and the @values array will be updated with them. The string values

exec: a regexp execution context
nbval: pointer to the number of accepted values IN/OUT
nbneg: return number of negative transitions
values: pointer to the array of acceptable values
terminal: return value if this was a terminal state
Returns: will be freed with the @exec context and don't need to be deallocated. Returns: 0 in case of success or -1 in case of error.

xmlRegExecPushString ()

int	xmlRegExecPushString		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * value, 
					 void * data)

Push one input token in the execution context

exec: a regexp execution context or NULL to indicate the end
value: a string token input
data: data associated to the token to reuse in callbacks
Returns: 1 if the regexp reached a final state, 0 if non-final, and a negative value in case of error.

xmlRegExecPushString2 ()

int	xmlRegExecPushString2		(xmlRegExecCtxtPtr exec, 
					 const xmlChar * value, 
					 const xmlChar * value2, 
					 void * data)

Push one input token in the execution context

exec: a regexp execution context or NULL to indicate the end
value: the first string token input
value2: the second string token input
data: data associated to the token to reuse in callbacks
Returns: 1 if the regexp reached a final state, 0 if non-final, and a negative value in case of error.

xmlRegFreeExecCtxt ()

void	xmlRegFreeExecCtxt		(xmlRegExecCtxtPtr exec)

Free the structures associated to a regular expression evaluation context.

exec: a regular expression evaluation context

xmlRegFreeRegexp ()

void	xmlRegFreeRegexp		(xmlRegexpPtr regexp)

Free a regexp

regexp: the regexp

xmlRegNewExecCtxt ()

xmlRegExecCtxtPtr	xmlRegNewExecCtxt	(xmlRegexpPtr comp, 
						 xmlRegExecCallbacks callback, 
						 void * data)

Build a context used for progressive evaluation of a regexp.

comp: a precompiled regular expression
callback: a callback function used for handling progresses in the automata matching phase
data: the context data associated to the callback in this context
Returns: the new context

xmlRegexpCompile ()

xmlRegexpPtr	xmlRegexpCompile	(const xmlChar * regexp)

Parses a regular expression conforming to XML Schemas Part 2 Datatype Appendix F and builds an automata suitable for testing strings against that regular expression

regexp: a regular expression string
Returns: the compiled expression or NULL in case of error

xmlRegexpExec ()

int	xmlRegexpExec			(xmlRegexpPtr comp, 
					 const xmlChar * content)

Check if the regular expression generates the value

comp: the compiled regular expression
content: the value to check against the regular expression
Returns: 1 if it matches, 0 if not and a negative value in case of error

xmlRegexpIsDeterminist ()

int	xmlRegexpIsDeterminist		(xmlRegexpPtr comp)

Check if the regular expression is determinist

comp: the compiled regular expression
Returns: 1 if it yes, 0 if not and a negative value in case of error

xmlRegexpPrint ()

void	xmlRegexpPrint			(FILE * output, 
					 xmlRegexpPtr regexp)

Print the content of the compiled regular expression

output: the file for the output debug
regexp: the compiled regexp