VirtualBox

source: vbox/trunk/src/libs/libxml2-2.6.30/include/libxml/tree.h@ 23452

最後變更 在這個檔案從23452是 6076,由 vboxsync 提交於 17 年 前

Merged dmik/s2 branch (r25959:26751) to the trunk.
  • 屬性 svn:eol-style 設為 native
  • 屬性 svn:keywords 設為 Date Revision Author Id
檔案大小: 34.0 KB
行 
1/*
2 * Summary: interfaces for tree manipulation
3 * Description: this module describes the structures found in an tree resulting
4 * from an XML or HTML parsing, as well as the API provided for
5 * various processing on that tree
6 *
7 * Copy: See Copyright for the status of this software.
8 *
9 * Author: Daniel Veillard
10 */
11
12#ifndef __XML_TREE_H__
13#define __XML_TREE_H__
14
15#include <stdio.h>
16#include <libxml/xmlversion.h>
17#include <libxml/xmlstring.h>
18
19#ifdef __cplusplus
20extern "C" {
21#endif
22
23/*
24 * Some of the basic types pointer to structures:
25 */
26/* xmlIO.h */
27typedef struct _xmlParserInputBuffer xmlParserInputBuffer;
28typedef xmlParserInputBuffer *xmlParserInputBufferPtr;
29
30typedef struct _xmlOutputBuffer xmlOutputBuffer;
31typedef xmlOutputBuffer *xmlOutputBufferPtr;
32
33/* parser.h */
34typedef struct _xmlParserInput xmlParserInput;
35typedef xmlParserInput *xmlParserInputPtr;
36
37typedef struct _xmlParserCtxt xmlParserCtxt;
38typedef xmlParserCtxt *xmlParserCtxtPtr;
39
40typedef struct _xmlSAXLocator xmlSAXLocator;
41typedef xmlSAXLocator *xmlSAXLocatorPtr;
42
43typedef struct _xmlSAXHandler xmlSAXHandler;
44typedef xmlSAXHandler *xmlSAXHandlerPtr;
45
46/* entities.h */
47typedef struct _xmlEntity xmlEntity;
48typedef xmlEntity *xmlEntityPtr;
49
50/**
51 * BASE_BUFFER_SIZE:
52 *
53 * default buffer size 4000.
54 */
55#define BASE_BUFFER_SIZE 4096
56
57/**
58 * LIBXML_NAMESPACE_DICT:
59 *
60 * Defines experimental behaviour:
61 * 1) xmlNs gets an additional field @context (a xmlDoc)
62 * 2) when creating a tree, xmlNs->href is stored in the dict of xmlDoc.
63 */
64/* #define LIBXML_NAMESPACE_DICT */
65
66/**
67 * xmlBufferAllocationScheme:
68 *
69 * A buffer allocation scheme can be defined to either match exactly the
70 * need or double it's allocated size each time it is found too small.
71 */
72
73typedef enum {
74 XML_BUFFER_ALLOC_DOUBLEIT,
75 XML_BUFFER_ALLOC_EXACT,
76 XML_BUFFER_ALLOC_IMMUTABLE
77} xmlBufferAllocationScheme;
78
79/**
80 * xmlBuffer:
81 *
82 * A buffer structure.
83 */
84typedef struct _xmlBuffer xmlBuffer;
85typedef xmlBuffer *xmlBufferPtr;
86struct _xmlBuffer {
87 xmlChar *content; /* The buffer content UTF8 */
88 unsigned int use; /* The buffer size used */
89 unsigned int size; /* The buffer size */
90 xmlBufferAllocationScheme alloc; /* The realloc method */
91};
92
93/**
94 * XML_XML_NAMESPACE:
95 *
96 * This is the namespace for the special xml: prefix predefined in the
97 * XML Namespace specification.
98 */
99#define XML_XML_NAMESPACE \
100 (const xmlChar *) "http://www.w3.org/XML/1998/namespace"
101
102/**
103 * XML_XML_ID:
104 *
105 * This is the name for the special xml:id attribute
106 */
107#define XML_XML_ID (const xmlChar *) "xml:id"
108
109/*
110 * The different element types carried by an XML tree.
111 *
112 * NOTE: This is synchronized with DOM Level1 values
113 * See http://www.w3.org/TR/REC-DOM-Level-1/
114 *
115 * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should
116 * be deprecated to use an XML_DTD_NODE.
117 */
118typedef enum {
119 XML_ELEMENT_NODE= 1,
120 XML_ATTRIBUTE_NODE= 2,
121 XML_TEXT_NODE= 3,
122 XML_CDATA_SECTION_NODE= 4,
123 XML_ENTITY_REF_NODE= 5,
124 XML_ENTITY_NODE= 6,
125 XML_PI_NODE= 7,
126 XML_COMMENT_NODE= 8,
127 XML_DOCUMENT_NODE= 9,
128 XML_DOCUMENT_TYPE_NODE= 10,
129 XML_DOCUMENT_FRAG_NODE= 11,
130 XML_NOTATION_NODE= 12,
131 XML_HTML_DOCUMENT_NODE= 13,
132 XML_DTD_NODE= 14,
133 XML_ELEMENT_DECL= 15,
134 XML_ATTRIBUTE_DECL= 16,
135 XML_ENTITY_DECL= 17,
136 XML_NAMESPACE_DECL= 18,
137 XML_XINCLUDE_START= 19,
138 XML_XINCLUDE_END= 20
139#ifdef LIBXML_DOCB_ENABLED
140 ,XML_DOCB_DOCUMENT_NODE= 21
141#endif
142} xmlElementType;
143
144
145/**
146 * xmlNotation:
147 *
148 * A DTD Notation definition.
149 */
150
151typedef struct _xmlNotation xmlNotation;
152typedef xmlNotation *xmlNotationPtr;
153struct _xmlNotation {
154 const xmlChar *name; /* Notation name */
155 const xmlChar *PublicID; /* Public identifier, if any */
156 const xmlChar *SystemID; /* System identifier, if any */
157};
158
159/**
160 * xmlAttributeType:
161 *
162 * A DTD Attribute type definition.
163 */
164
165typedef enum {
166 XML_ATTRIBUTE_CDATA = 1,
167 XML_ATTRIBUTE_ID,
168 XML_ATTRIBUTE_IDREF ,
169 XML_ATTRIBUTE_IDREFS,
170 XML_ATTRIBUTE_ENTITY,
171 XML_ATTRIBUTE_ENTITIES,
172 XML_ATTRIBUTE_NMTOKEN,
173 XML_ATTRIBUTE_NMTOKENS,
174 XML_ATTRIBUTE_ENUMERATION,
175 XML_ATTRIBUTE_NOTATION
176} xmlAttributeType;
177
178/**
179 * xmlAttributeDefault:
180 *
181 * A DTD Attribute default definition.
182 */
183
184typedef enum {
185 XML_ATTRIBUTE_NONE = 1,
186 XML_ATTRIBUTE_REQUIRED,
187 XML_ATTRIBUTE_IMPLIED,
188 XML_ATTRIBUTE_FIXED
189} xmlAttributeDefault;
190
191/**
192 * xmlEnumeration:
193 *
194 * List structure used when there is an enumeration in DTDs.
195 */
196
197typedef struct _xmlEnumeration xmlEnumeration;
198typedef xmlEnumeration *xmlEnumerationPtr;
199struct _xmlEnumeration {
200 struct _xmlEnumeration *next; /* next one */
201 const xmlChar *name; /* Enumeration name */
202};
203
204/**
205 * xmlAttribute:
206 *
207 * An Attribute declaration in a DTD.
208 */
209
210typedef struct _xmlAttribute xmlAttribute;
211typedef xmlAttribute *xmlAttributePtr;
212struct _xmlAttribute {
213 void *_private; /* application data */
214 xmlElementType type; /* XML_ATTRIBUTE_DECL, must be second ! */
215 const xmlChar *name; /* Attribute name */
216 struct _xmlNode *children; /* NULL */
217 struct _xmlNode *last; /* NULL */
218 struct _xmlDtd *parent; /* -> DTD */
219 struct _xmlNode *next; /* next sibling link */
220 struct _xmlNode *prev; /* previous sibling link */
221 struct _xmlDoc *doc; /* the containing document */
222
223 struct _xmlAttribute *nexth; /* next in hash table */
224 xmlAttributeType atype; /* The attribute type */
225 xmlAttributeDefault def; /* the default */
226 const xmlChar *defaultValue; /* or the default value */
227 xmlEnumerationPtr tree; /* or the enumeration tree if any */
228 const xmlChar *prefix; /* the namespace prefix if any */
229 const xmlChar *elem; /* Element holding the attribute */
230};
231
232/**
233 * xmlElementContentType:
234 *
235 * Possible definitions of element content types.
236 */
237typedef enum {
238 XML_ELEMENT_CONTENT_PCDATA = 1,
239 XML_ELEMENT_CONTENT_ELEMENT,
240 XML_ELEMENT_CONTENT_SEQ,
241 XML_ELEMENT_CONTENT_OR
242} xmlElementContentType;
243
244/**
245 * xmlElementContentOccur:
246 *
247 * Possible definitions of element content occurrences.
248 */
249typedef enum {
250 XML_ELEMENT_CONTENT_ONCE = 1,
251 XML_ELEMENT_CONTENT_OPT,
252 XML_ELEMENT_CONTENT_MULT,
253 XML_ELEMENT_CONTENT_PLUS
254} xmlElementContentOccur;
255
256/**
257 * xmlElementContent:
258 *
259 * An XML Element content as stored after parsing an element definition
260 * in a DTD.
261 */
262
263typedef struct _xmlElementContent xmlElementContent;
264typedef xmlElementContent *xmlElementContentPtr;
265struct _xmlElementContent {
266 xmlElementContentType type; /* PCDATA, ELEMENT, SEQ or OR */
267 xmlElementContentOccur ocur; /* ONCE, OPT, MULT or PLUS */
268 const xmlChar *name; /* Element name */
269 struct _xmlElementContent *c1; /* first child */
270 struct _xmlElementContent *c2; /* second child */
271 struct _xmlElementContent *parent; /* parent */
272 const xmlChar *prefix; /* Namespace prefix */
273};
274
275/**
276 * xmlElementTypeVal:
277 *
278 * The different possibilities for an element content type.
279 */
280
281typedef enum {
282 XML_ELEMENT_TYPE_UNDEFINED = 0,
283 XML_ELEMENT_TYPE_EMPTY = 1,
284 XML_ELEMENT_TYPE_ANY,
285 XML_ELEMENT_TYPE_MIXED,
286 XML_ELEMENT_TYPE_ELEMENT
287} xmlElementTypeVal;
288
289#ifdef __cplusplus
290}
291#endif
292#include <libxml/xmlregexp.h>
293#ifdef __cplusplus
294extern "C" {
295#endif
296
297/**
298 * xmlElement:
299 *
300 * An XML Element declaration from a DTD.
301 */
302
303typedef struct _xmlElement xmlElement;
304typedef xmlElement *xmlElementPtr;
305struct _xmlElement {
306 void *_private; /* application data */
307 xmlElementType type; /* XML_ELEMENT_DECL, must be second ! */
308 const xmlChar *name; /* Element name */
309 struct _xmlNode *children; /* NULL */
310 struct _xmlNode *last; /* NULL */
311 struct _xmlDtd *parent; /* -> DTD */
312 struct _xmlNode *next; /* next sibling link */
313 struct _xmlNode *prev; /* previous sibling link */
314 struct _xmlDoc *doc; /* the containing document */
315
316 xmlElementTypeVal etype; /* The type */
317 xmlElementContentPtr content; /* the allowed element content */
318 xmlAttributePtr attributes; /* List of the declared attributes */
319 const xmlChar *prefix; /* the namespace prefix if any */
320#ifdef LIBXML_REGEXP_ENABLED
321 xmlRegexpPtr contModel; /* the validating regexp */
322#else
323 void *contModel;
324#endif
325};
326
327
328/**
329 * XML_LOCAL_NAMESPACE:
330 *
331 * A namespace declaration node.
332 */
333#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL
334typedef xmlElementType xmlNsType;
335
336/**
337 * xmlNs:
338 *
339 * An XML namespace.
340 * Note that prefix == NULL is valid, it defines the default namespace
341 * within the subtree (until overridden).
342 *
343 * xmlNsType is unified with xmlElementType.
344 */
345
346typedef struct _xmlNs xmlNs;
347typedef xmlNs *xmlNsPtr;
348struct _xmlNs {
349 struct _xmlNs *next; /* next Ns link for this node */
350 xmlNsType type; /* global or local */
351 const xmlChar *href; /* URL for the namespace */
352 const xmlChar *prefix; /* prefix for the namespace */
353 void *_private; /* application data */
354 struct _xmlDoc *context; /* normally an xmlDoc */
355};
356
357/**
358 * xmlDtd:
359 *
360 * An XML DTD, as defined by <!DOCTYPE ... There is actually one for
361 * the internal subset and for the external subset.
362 */
363typedef struct _xmlDtd xmlDtd;
364typedef xmlDtd *xmlDtdPtr;
365struct _xmlDtd {
366 void *_private; /* application data */
367 xmlElementType type; /* XML_DTD_NODE, must be second ! */
368 const xmlChar *name; /* Name of the DTD */
369 struct _xmlNode *children; /* the value of the property link */
370 struct _xmlNode *last; /* last child link */
371 struct _xmlDoc *parent; /* child->parent link */
372 struct _xmlNode *next; /* next sibling link */
373 struct _xmlNode *prev; /* previous sibling link */
374 struct _xmlDoc *doc; /* the containing document */
375
376 /* End of common part */
377 void *notations; /* Hash table for notations if any */
378 void *elements; /* Hash table for elements if any */
379 void *attributes; /* Hash table for attributes if any */
380 void *entities; /* Hash table for entities if any */
381 const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */
382 const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */
383 void *pentities; /* Hash table for param entities if any */
384};
385
386/**
387 * xmlAttr:
388 *
389 * An attribute on an XML node.
390 */
391typedef struct _xmlAttr xmlAttr;
392typedef xmlAttr *xmlAttrPtr;
393struct _xmlAttr {
394 void *_private; /* application data */
395 xmlElementType type; /* XML_ATTRIBUTE_NODE, must be second ! */
396 const xmlChar *name; /* the name of the property */
397 struct _xmlNode *children; /* the value of the property */
398 struct _xmlNode *last; /* NULL */
399 struct _xmlNode *parent; /* child->parent link */
400 struct _xmlAttr *next; /* next sibling link */
401 struct _xmlAttr *prev; /* previous sibling link */
402 struct _xmlDoc *doc; /* the containing document */
403 xmlNs *ns; /* pointer to the associated namespace */
404 xmlAttributeType atype; /* the attribute type if validating */
405 void *psvi; /* for type/PSVI informations */
406};
407
408/**
409 * xmlID:
410 *
411 * An XML ID instance.
412 */
413
414typedef struct _xmlID xmlID;
415typedef xmlID *xmlIDPtr;
416struct _xmlID {
417 struct _xmlID *next; /* next ID */
418 const xmlChar *value; /* The ID name */
419 xmlAttrPtr attr; /* The attribute holding it */
420 const xmlChar *name; /* The attribute if attr is not available */
421 int lineno; /* The line number if attr is not available */
422 struct _xmlDoc *doc; /* The document holding the ID */
423};
424
425/**
426 * xmlRef:
427 *
428 * An XML IDREF instance.
429 */
430
431typedef struct _xmlRef xmlRef;
432typedef xmlRef *xmlRefPtr;
433struct _xmlRef {
434 struct _xmlRef *next; /* next Ref */
435 const xmlChar *value; /* The Ref name */
436 xmlAttrPtr attr; /* The attribute holding it */
437 const xmlChar *name; /* The attribute if attr is not available */
438 int lineno; /* The line number if attr is not available */
439};
440
441/**
442 * xmlNode:
443 *
444 * A node in an XML tree.
445 */
446typedef struct _xmlNode xmlNode;
447typedef xmlNode *xmlNodePtr;
448struct _xmlNode {
449 void *_private; /* application data */
450 xmlElementType type; /* type number, must be second ! */
451 const xmlChar *name; /* the name of the node, or the entity */
452 struct _xmlNode *children; /* parent->childs link */
453 struct _xmlNode *last; /* last child link */
454 struct _xmlNode *parent; /* child->parent link */
455 struct _xmlNode *next; /* next sibling link */
456 struct _xmlNode *prev; /* previous sibling link */
457 struct _xmlDoc *doc; /* the containing document */
458
459 /* End of common part */
460 xmlNs *ns; /* pointer to the associated namespace */
461 xmlChar *content; /* the content */
462 struct _xmlAttr *properties;/* properties list */
463 xmlNs *nsDef; /* namespace definitions on this node */
464 void *psvi; /* for type/PSVI informations */
465 unsigned short line; /* line number */
466 unsigned short extra; /* extra data for XPath/XSLT */
467};
468
469/**
470 * XML_GET_CONTENT:
471 *
472 * Macro to extract the content pointer of a node.
473 */
474#define XML_GET_CONTENT(n) \
475 ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content)
476
477/**
478 * XML_GET_LINE:
479 *
480 * Macro to extract the line number of an element node.
481 */
482#define XML_GET_LINE(n) \
483 (xmlGetLineNo(n))
484
485
486/**
487 * xmlDoc:
488 *
489 * An XML document.
490 */
491typedef struct _xmlDoc xmlDoc;
492typedef xmlDoc *xmlDocPtr;
493struct _xmlDoc {
494 void *_private; /* application data */
495 xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */
496 char *name; /* name/filename/URI of the document */
497 struct _xmlNode *children; /* the document tree */
498 struct _xmlNode *last; /* last child link */
499 struct _xmlNode *parent; /* child->parent link */
500 struct _xmlNode *next; /* next sibling link */
501 struct _xmlNode *prev; /* previous sibling link */
502 struct _xmlDoc *doc; /* autoreference to itself */
503
504 /* End of common part */
505 int compression;/* level of zlib compression */
506 int standalone; /* standalone document (no external refs)
507 1 if standalone="yes"
508 0 if standalone="no"
509 -1 if there is no XML declaration
510 -2 if there is an XML declaration, but no
511 standalone attribute was specified */
512 struct _xmlDtd *intSubset; /* the document internal subset */
513 struct _xmlDtd *extSubset; /* the document external subset */
514 struct _xmlNs *oldNs; /* Global namespace, the old way */
515 const xmlChar *version; /* the XML version string */
516 const xmlChar *encoding; /* external initial encoding, if any */
517 void *ids; /* Hash table for ID attributes if any */
518 void *refs; /* Hash table for IDREFs attributes if any */
519 const xmlChar *URL; /* The URI for that document */
520 int charset; /* encoding of the in-memory content
521 actually an xmlCharEncoding */
522 struct _xmlDict *dict; /* dict used to allocate names or NULL */
523 void *psvi; /* for type/PSVI informations */
524};
525
526
527typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt;
528typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr;
529
530/**
531 * xmlDOMWrapAcquireNsFunction:
532 * @ctxt: a DOM wrapper context
533 * @node: the context node (element or attribute)
534 * @nsName: the requested namespace name
535 * @nsPrefix: the requested namespace prefix
536 *
537 * A function called to acquire namespaces (xmlNs) from the wrapper.
538 *
539 * Returns an xmlNsPtr or NULL in case of an error.
540 */
541typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt,
542 xmlNodePtr node,
543 const xmlChar *nsName,
544 const xmlChar *nsPrefix);
545
546/**
547 * xmlDOMWrapCtxt:
548 *
549 * Context for DOM wrapper-operations.
550 */
551struct _xmlDOMWrapCtxt {
552 void * _private;
553 /*
554 * The type of this context, just in case we need specialized
555 * contexts in the future.
556 */
557 int type;
558 /*
559 * Internal namespace map used for various operations.
560 */
561 void * namespaceMap;
562 /*
563 * Use this one to acquire an xmlNsPtr intended for node->ns.
564 * (Note that this is not intended for elem->nsDef).
565 */
566 xmlDOMWrapAcquireNsFunction getNsForNodeFunc;
567};
568
569/**
570 * xmlChildrenNode:
571 *
572 * Macro for compatibility naming layer with libxml1. Maps
573 * to "children."
574 */
575#ifndef xmlChildrenNode
576#define xmlChildrenNode children
577#endif
578
579/**
580 * xmlRootNode:
581 *
582 * Macro for compatibility naming layer with libxml1. Maps
583 * to "children".
584 */
585#ifndef xmlRootNode
586#define xmlRootNode children
587#endif
588
589/*
590 * Variables.
591 */
592
593/*
594 * Some helper functions
595 */
596#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED)
597XMLPUBFUN int XMLCALL
598 xmlValidateNCName (const xmlChar *value,
599 int space);
600#endif
601
602#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
603XMLPUBFUN int XMLCALL
604 xmlValidateQName (const xmlChar *value,
605 int space);
606XMLPUBFUN int XMLCALL
607 xmlValidateName (const xmlChar *value,
608 int space);
609XMLPUBFUN int XMLCALL
610 xmlValidateNMToken (const xmlChar *value,
611 int space);
612#endif
613
614XMLPUBFUN xmlChar * XMLCALL
615 xmlBuildQName (const xmlChar *ncname,
616 const xmlChar *prefix,
617 xmlChar *memory,
618 int len);
619XMLPUBFUN xmlChar * XMLCALL
620 xmlSplitQName2 (const xmlChar *name,
621 xmlChar **prefix);
622XMLPUBFUN const xmlChar * XMLCALL
623 xmlSplitQName3 (const xmlChar *name,
624 int *len);
625
626/*
627 * Handling Buffers.
628 */
629
630XMLPUBFUN void XMLCALL
631 xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme);
632XMLPUBFUN xmlBufferAllocationScheme XMLCALL
633 xmlGetBufferAllocationScheme(void);
634
635XMLPUBFUN xmlBufferPtr XMLCALL
636 xmlBufferCreate (void);
637XMLPUBFUN xmlBufferPtr XMLCALL
638 xmlBufferCreateSize (size_t size);
639XMLPUBFUN xmlBufferPtr XMLCALL
640 xmlBufferCreateStatic (void *mem,
641 size_t size);
642XMLPUBFUN int XMLCALL
643 xmlBufferResize (xmlBufferPtr buf,
644 unsigned int size);
645XMLPUBFUN void XMLCALL
646 xmlBufferFree (xmlBufferPtr buf);
647XMLPUBFUN int XMLCALL
648 xmlBufferDump (FILE *file,
649 xmlBufferPtr buf);
650XMLPUBFUN int XMLCALL
651 xmlBufferAdd (xmlBufferPtr buf,
652 const xmlChar *str,
653 int len);
654XMLPUBFUN int XMLCALL
655 xmlBufferAddHead (xmlBufferPtr buf,
656 const xmlChar *str,
657 int len);
658XMLPUBFUN int XMLCALL
659 xmlBufferCat (xmlBufferPtr buf,
660 const xmlChar *str);
661XMLPUBFUN int XMLCALL
662 xmlBufferCCat (xmlBufferPtr buf,
663 const char *str);
664XMLPUBFUN int XMLCALL
665 xmlBufferShrink (xmlBufferPtr buf,
666 unsigned int len);
667XMLPUBFUN int XMLCALL
668 xmlBufferGrow (xmlBufferPtr buf,
669 unsigned int len);
670XMLPUBFUN void XMLCALL
671 xmlBufferEmpty (xmlBufferPtr buf);
672XMLPUBFUN const xmlChar* XMLCALL
673 xmlBufferContent (const xmlBufferPtr buf);
674XMLPUBFUN void XMLCALL
675 xmlBufferSetAllocationScheme(xmlBufferPtr buf,
676 xmlBufferAllocationScheme scheme);
677XMLPUBFUN int XMLCALL
678 xmlBufferLength (const xmlBufferPtr buf);
679
680/*
681 * Creating/freeing new structures.
682 */
683XMLPUBFUN xmlDtdPtr XMLCALL
684 xmlCreateIntSubset (xmlDocPtr doc,
685 const xmlChar *name,
686 const xmlChar *ExternalID,
687 const xmlChar *SystemID);
688XMLPUBFUN xmlDtdPtr XMLCALL
689 xmlNewDtd (xmlDocPtr doc,
690 const xmlChar *name,
691 const xmlChar *ExternalID,
692 const xmlChar *SystemID);
693XMLPUBFUN xmlDtdPtr XMLCALL
694 xmlGetIntSubset (xmlDocPtr doc);
695XMLPUBFUN void XMLCALL
696 xmlFreeDtd (xmlDtdPtr cur);
697#ifdef LIBXML_LEGACY_ENABLED
698XMLPUBFUN xmlNsPtr XMLCALL
699 xmlNewGlobalNs (xmlDocPtr doc,
700 const xmlChar *href,
701 const xmlChar *prefix);
702#endif /* LIBXML_LEGACY_ENABLED */
703XMLPUBFUN xmlNsPtr XMLCALL
704 xmlNewNs (xmlNodePtr node,
705 const xmlChar *href,
706 const xmlChar *prefix);
707XMLPUBFUN void XMLCALL
708 xmlFreeNs (xmlNsPtr cur);
709XMLPUBFUN void XMLCALL
710 xmlFreeNsList (xmlNsPtr cur);
711XMLPUBFUN xmlDocPtr XMLCALL
712 xmlNewDoc (const xmlChar *version);
713XMLPUBFUN void XMLCALL
714 xmlFreeDoc (xmlDocPtr cur);
715XMLPUBFUN xmlAttrPtr XMLCALL
716 xmlNewDocProp (xmlDocPtr doc,
717 const xmlChar *name,
718 const xmlChar *value);
719#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
720 defined(LIBXML_SCHEMAS_ENABLED)
721XMLPUBFUN xmlAttrPtr XMLCALL
722 xmlNewProp (xmlNodePtr node,
723 const xmlChar *name,
724 const xmlChar *value);
725#endif
726XMLPUBFUN xmlAttrPtr XMLCALL
727 xmlNewNsProp (xmlNodePtr node,
728 xmlNsPtr ns,
729 const xmlChar *name,
730 const xmlChar *value);
731XMLPUBFUN xmlAttrPtr XMLCALL
732 xmlNewNsPropEatName (xmlNodePtr node,
733 xmlNsPtr ns,
734 xmlChar *name,
735 const xmlChar *value);
736XMLPUBFUN void XMLCALL
737 xmlFreePropList (xmlAttrPtr cur);
738XMLPUBFUN void XMLCALL
739 xmlFreeProp (xmlAttrPtr cur);
740XMLPUBFUN xmlAttrPtr XMLCALL
741 xmlCopyProp (xmlNodePtr target,
742 xmlAttrPtr cur);
743XMLPUBFUN xmlAttrPtr XMLCALL
744 xmlCopyPropList (xmlNodePtr target,
745 xmlAttrPtr cur);
746#ifdef LIBXML_TREE_ENABLED
747XMLPUBFUN xmlDtdPtr XMLCALL
748 xmlCopyDtd (xmlDtdPtr dtd);
749#endif /* LIBXML_TREE_ENABLED */
750#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
751XMLPUBFUN xmlDocPtr XMLCALL
752 xmlCopyDoc (xmlDocPtr doc,
753 int recursive);
754#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
755/*
756 * Creating new nodes.
757 */
758XMLPUBFUN xmlNodePtr XMLCALL
759 xmlNewDocNode (xmlDocPtr doc,
760 xmlNsPtr ns,
761 const xmlChar *name,
762 const xmlChar *content);
763XMLPUBFUN xmlNodePtr XMLCALL
764 xmlNewDocNodeEatName (xmlDocPtr doc,
765 xmlNsPtr ns,
766 xmlChar *name,
767 const xmlChar *content);
768XMLPUBFUN xmlNodePtr XMLCALL
769 xmlNewNode (xmlNsPtr ns,
770 const xmlChar *name);
771XMLPUBFUN xmlNodePtr XMLCALL
772 xmlNewNodeEatName (xmlNsPtr ns,
773 xmlChar *name);
774#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
775XMLPUBFUN xmlNodePtr XMLCALL
776 xmlNewChild (xmlNodePtr parent,
777 xmlNsPtr ns,
778 const xmlChar *name,
779 const xmlChar *content);
780#endif
781XMLPUBFUN xmlNodePtr XMLCALL
782 xmlNewDocText (xmlDocPtr doc,
783 const xmlChar *content);
784XMLPUBFUN xmlNodePtr XMLCALL
785 xmlNewText (const xmlChar *content);
786XMLPUBFUN xmlNodePtr XMLCALL
787 xmlNewDocPI (xmlDocPtr doc,
788 const xmlChar *name,
789 const xmlChar *content);
790XMLPUBFUN xmlNodePtr XMLCALL
791 xmlNewPI (const xmlChar *name,
792 const xmlChar *content);
793XMLPUBFUN xmlNodePtr XMLCALL
794 xmlNewDocTextLen (xmlDocPtr doc,
795 const xmlChar *content,
796 int len);
797XMLPUBFUN xmlNodePtr XMLCALL
798 xmlNewTextLen (const xmlChar *content,
799 int len);
800XMLPUBFUN xmlNodePtr XMLCALL
801 xmlNewDocComment (xmlDocPtr doc,
802 const xmlChar *content);
803XMLPUBFUN xmlNodePtr XMLCALL
804 xmlNewComment (const xmlChar *content);
805XMLPUBFUN xmlNodePtr XMLCALL
806 xmlNewCDataBlock (xmlDocPtr doc,
807 const xmlChar *content,
808 int len);
809XMLPUBFUN xmlNodePtr XMLCALL
810 xmlNewCharRef (xmlDocPtr doc,
811 const xmlChar *name);
812XMLPUBFUN xmlNodePtr XMLCALL
813 xmlNewReference (xmlDocPtr doc,
814 const xmlChar *name);
815XMLPUBFUN xmlNodePtr XMLCALL
816 xmlCopyNode (const xmlNodePtr node,
817 int recursive);
818XMLPUBFUN xmlNodePtr XMLCALL
819 xmlDocCopyNode (const xmlNodePtr node,
820 xmlDocPtr doc,
821 int recursive);
822XMLPUBFUN xmlNodePtr XMLCALL
823 xmlDocCopyNodeList (xmlDocPtr doc,
824 const xmlNodePtr node);
825XMLPUBFUN xmlNodePtr XMLCALL
826 xmlCopyNodeList (const xmlNodePtr node);
827#ifdef LIBXML_TREE_ENABLED
828XMLPUBFUN xmlNodePtr XMLCALL
829 xmlNewTextChild (xmlNodePtr parent,
830 xmlNsPtr ns,
831 const xmlChar *name,
832 const xmlChar *content);
833XMLPUBFUN xmlNodePtr XMLCALL
834 xmlNewDocRawNode (xmlDocPtr doc,
835 xmlNsPtr ns,
836 const xmlChar *name,
837 const xmlChar *content);
838XMLPUBFUN xmlNodePtr XMLCALL
839 xmlNewDocFragment (xmlDocPtr doc);
840#endif /* LIBXML_TREE_ENABLED */
841
842/*
843 * Navigating.
844 */
845XMLPUBFUN long XMLCALL
846 xmlGetLineNo (xmlNodePtr node);
847#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED)
848XMLPUBFUN xmlChar * XMLCALL
849 xmlGetNodePath (xmlNodePtr node);
850#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */
851XMLPUBFUN xmlNodePtr XMLCALL
852 xmlDocGetRootElement (xmlDocPtr doc);
853XMLPUBFUN xmlNodePtr XMLCALL
854 xmlGetLastChild (xmlNodePtr parent);
855XMLPUBFUN int XMLCALL
856 xmlNodeIsText (xmlNodePtr node);
857XMLPUBFUN int XMLCALL
858 xmlIsBlankNode (xmlNodePtr node);
859
860/*
861 * Changing the structure.
862 */
863#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
864XMLPUBFUN xmlNodePtr XMLCALL
865 xmlDocSetRootElement (xmlDocPtr doc,
866 xmlNodePtr root);
867#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
868#ifdef LIBXML_TREE_ENABLED
869XMLPUBFUN void XMLCALL
870 xmlNodeSetName (xmlNodePtr cur,
871 const xmlChar *name);
872#endif /* LIBXML_TREE_ENABLED */
873XMLPUBFUN xmlNodePtr XMLCALL
874 xmlAddChild (xmlNodePtr parent,
875 xmlNodePtr cur);
876XMLPUBFUN xmlNodePtr XMLCALL
877 xmlAddChildList (xmlNodePtr parent,
878 xmlNodePtr cur);
879#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED)
880XMLPUBFUN xmlNodePtr XMLCALL
881 xmlReplaceNode (xmlNodePtr old,
882 xmlNodePtr cur);
883#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */
884#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \
885 defined(LIBXML_SCHEMAS_ENABLED)
886XMLPUBFUN xmlNodePtr XMLCALL
887 xmlAddPrevSibling (xmlNodePtr cur,
888 xmlNodePtr elem);
889#endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */
890XMLPUBFUN xmlNodePtr XMLCALL
891 xmlAddSibling (xmlNodePtr cur,
892 xmlNodePtr elem);
893XMLPUBFUN xmlNodePtr XMLCALL
894 xmlAddNextSibling (xmlNodePtr cur,
895 xmlNodePtr elem);
896XMLPUBFUN void XMLCALL
897 xmlUnlinkNode (xmlNodePtr cur);
898XMLPUBFUN xmlNodePtr XMLCALL
899 xmlTextMerge (xmlNodePtr first,
900 xmlNodePtr second);
901XMLPUBFUN int XMLCALL
902 xmlTextConcat (xmlNodePtr node,
903 const xmlChar *content,
904 int len);
905XMLPUBFUN void XMLCALL
906 xmlFreeNodeList (xmlNodePtr cur);
907XMLPUBFUN void XMLCALL
908 xmlFreeNode (xmlNodePtr cur);
909XMLPUBFUN void XMLCALL
910 xmlSetTreeDoc (xmlNodePtr tree,
911 xmlDocPtr doc);
912XMLPUBFUN void XMLCALL
913 xmlSetListDoc (xmlNodePtr list,
914 xmlDocPtr doc);
915/*
916 * Namespaces.
917 */
918XMLPUBFUN xmlNsPtr XMLCALL
919 xmlSearchNs (xmlDocPtr doc,
920 xmlNodePtr node,
921 const xmlChar *nameSpace);
922XMLPUBFUN xmlNsPtr XMLCALL
923 xmlSearchNsByHref (xmlDocPtr doc,
924 xmlNodePtr node,
925 const xmlChar *href);
926#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
927XMLPUBFUN xmlNsPtr * XMLCALL
928 xmlGetNsList (xmlDocPtr doc,
929 xmlNodePtr node);
930#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */
931
932XMLPUBFUN void XMLCALL
933 xmlSetNs (xmlNodePtr node,
934 xmlNsPtr ns);
935XMLPUBFUN xmlNsPtr XMLCALL
936 xmlCopyNamespace (xmlNsPtr cur);
937XMLPUBFUN xmlNsPtr XMLCALL
938 xmlCopyNamespaceList (xmlNsPtr cur);
939
940/*
941 * Changing the content.
942 */
943#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED)
944XMLPUBFUN xmlAttrPtr XMLCALL
945 xmlSetProp (xmlNodePtr node,
946 const xmlChar *name,
947 const xmlChar *value);
948XMLPUBFUN xmlAttrPtr XMLCALL
949 xmlSetNsProp (xmlNodePtr node,
950 xmlNsPtr ns,
951 const xmlChar *name,
952 const xmlChar *value);
953#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */
954XMLPUBFUN xmlChar * XMLCALL
955 xmlGetNoNsProp (xmlNodePtr node,
956 const xmlChar *name);
957XMLPUBFUN xmlChar * XMLCALL
958 xmlGetProp (xmlNodePtr node,
959 const xmlChar *name);
960XMLPUBFUN xmlAttrPtr XMLCALL
961 xmlHasProp (xmlNodePtr node,
962 const xmlChar *name);
963XMLPUBFUN xmlAttrPtr XMLCALL
964 xmlHasNsProp (xmlNodePtr node,
965 const xmlChar *name,
966 const xmlChar *nameSpace);
967XMLPUBFUN xmlChar * XMLCALL
968 xmlGetNsProp (xmlNodePtr node,
969 const xmlChar *name,
970 const xmlChar *nameSpace);
971XMLPUBFUN xmlNodePtr XMLCALL
972 xmlStringGetNodeList (xmlDocPtr doc,
973 const xmlChar *value);
974XMLPUBFUN xmlNodePtr XMLCALL
975 xmlStringLenGetNodeList (xmlDocPtr doc,
976 const xmlChar *value,
977 int len);
978XMLPUBFUN xmlChar * XMLCALL
979 xmlNodeListGetString (xmlDocPtr doc,
980 xmlNodePtr list,
981 int inLine);
982#ifdef LIBXML_TREE_ENABLED
983XMLPUBFUN xmlChar * XMLCALL
984 xmlNodeListGetRawString (xmlDocPtr doc,
985 xmlNodePtr list,
986 int inLine);
987#endif /* LIBXML_TREE_ENABLED */
988XMLPUBFUN void XMLCALL
989 xmlNodeSetContent (xmlNodePtr cur,
990 const xmlChar *content);
991#ifdef LIBXML_TREE_ENABLED
992XMLPUBFUN void XMLCALL
993 xmlNodeSetContentLen (xmlNodePtr cur,
994 const xmlChar *content,
995 int len);
996#endif /* LIBXML_TREE_ENABLED */
997XMLPUBFUN void XMLCALL
998 xmlNodeAddContent (xmlNodePtr cur,
999 const xmlChar *content);
1000XMLPUBFUN void XMLCALL
1001 xmlNodeAddContentLen (xmlNodePtr cur,
1002 const xmlChar *content,
1003 int len);
1004XMLPUBFUN xmlChar * XMLCALL
1005 xmlNodeGetContent (xmlNodePtr cur);
1006XMLPUBFUN int XMLCALL
1007 xmlNodeBufGetContent (xmlBufferPtr buffer,
1008 xmlNodePtr cur);
1009XMLPUBFUN xmlChar * XMLCALL
1010 xmlNodeGetLang (xmlNodePtr cur);
1011XMLPUBFUN int XMLCALL
1012 xmlNodeGetSpacePreserve (xmlNodePtr cur);
1013#ifdef LIBXML_TREE_ENABLED
1014XMLPUBFUN void XMLCALL
1015 xmlNodeSetLang (xmlNodePtr cur,
1016 const xmlChar *lang);
1017XMLPUBFUN void XMLCALL
1018 xmlNodeSetSpacePreserve (xmlNodePtr cur,
1019 int val);
1020#endif /* LIBXML_TREE_ENABLED */
1021XMLPUBFUN xmlChar * XMLCALL
1022 xmlNodeGetBase (xmlDocPtr doc,
1023 xmlNodePtr cur);
1024#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED)
1025XMLPUBFUN void XMLCALL
1026 xmlNodeSetBase (xmlNodePtr cur,
1027 const xmlChar *uri);
1028#endif
1029
1030/*
1031 * Removing content.
1032 */
1033XMLPUBFUN int XMLCALL
1034 xmlRemoveProp (xmlAttrPtr cur);
1035#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED)
1036XMLPUBFUN int XMLCALL
1037 xmlUnsetNsProp (xmlNodePtr node,
1038 xmlNsPtr ns,
1039 const xmlChar *name);
1040XMLPUBFUN int XMLCALL
1041 xmlUnsetProp (xmlNodePtr node,
1042 const xmlChar *name);
1043#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */
1044
1045/*
1046 * Internal, don't use.
1047 */
1048XMLPUBFUN void XMLCALL
1049 xmlBufferWriteCHAR (xmlBufferPtr buf,
1050 const xmlChar *string);
1051XMLPUBFUN void XMLCALL
1052 xmlBufferWriteChar (xmlBufferPtr buf,
1053 const char *string);
1054XMLPUBFUN void XMLCALL
1055 xmlBufferWriteQuotedString(xmlBufferPtr buf,
1056 const xmlChar *string);
1057
1058#ifdef LIBXML_OUTPUT_ENABLED
1059XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf,
1060 xmlDocPtr doc,
1061 xmlAttrPtr attr,
1062 const xmlChar *string);
1063#endif /* LIBXML_OUTPUT_ENABLED */
1064
1065#ifdef LIBXML_TREE_ENABLED
1066/*
1067 * Namespace handling.
1068 */
1069XMLPUBFUN int XMLCALL
1070 xmlReconciliateNs (xmlDocPtr doc,
1071 xmlNodePtr tree);
1072#endif
1073
1074#ifdef LIBXML_OUTPUT_ENABLED
1075/*
1076 * Saving.
1077 */
1078XMLPUBFUN void XMLCALL
1079 xmlDocDumpFormatMemory (xmlDocPtr cur,
1080 xmlChar **mem,
1081 int *size,
1082 int format);
1083XMLPUBFUN void XMLCALL
1084 xmlDocDumpMemory (xmlDocPtr cur,
1085 xmlChar **mem,
1086 int *size);
1087XMLPUBFUN void XMLCALL
1088 xmlDocDumpMemoryEnc (xmlDocPtr out_doc,
1089 xmlChar **doc_txt_ptr,
1090 int * doc_txt_len,
1091 const char *txt_encoding);
1092XMLPUBFUN void XMLCALL
1093 xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc,
1094 xmlChar **doc_txt_ptr,
1095 int * doc_txt_len,
1096 const char *txt_encoding,
1097 int format);
1098XMLPUBFUN int XMLCALL
1099 xmlDocFormatDump (FILE *f,
1100 xmlDocPtr cur,
1101 int format);
1102XMLPUBFUN int XMLCALL
1103 xmlDocDump (FILE *f,
1104 xmlDocPtr cur);
1105XMLPUBFUN void XMLCALL
1106 xmlElemDump (FILE *f,
1107 xmlDocPtr doc,
1108 xmlNodePtr cur);
1109XMLPUBFUN int XMLCALL
1110 xmlSaveFile (const char *filename,
1111 xmlDocPtr cur);
1112XMLPUBFUN int XMLCALL
1113 xmlSaveFormatFile (const char *filename,
1114 xmlDocPtr cur,
1115 int format);
1116XMLPUBFUN int XMLCALL
1117 xmlNodeDump (xmlBufferPtr buf,
1118 xmlDocPtr doc,
1119 xmlNodePtr cur,
1120 int level,
1121 int format);
1122
1123XMLPUBFUN int XMLCALL
1124 xmlSaveFileTo (xmlOutputBufferPtr buf,
1125 xmlDocPtr cur,
1126 const char *encoding);
1127XMLPUBFUN int XMLCALL
1128 xmlSaveFormatFileTo (xmlOutputBufferPtr buf,
1129 xmlDocPtr cur,
1130 const char *encoding,
1131 int format);
1132XMLPUBFUN void XMLCALL
1133 xmlNodeDumpOutput (xmlOutputBufferPtr buf,
1134 xmlDocPtr doc,
1135 xmlNodePtr cur,
1136 int level,
1137 int format,
1138 const char *encoding);
1139
1140XMLPUBFUN int XMLCALL
1141 xmlSaveFormatFileEnc (const char *filename,
1142 xmlDocPtr cur,
1143 const char *encoding,
1144 int format);
1145
1146XMLPUBFUN int XMLCALL
1147 xmlSaveFileEnc (const char *filename,
1148 xmlDocPtr cur,
1149 const char *encoding);
1150
1151#endif /* LIBXML_OUTPUT_ENABLED */
1152/*
1153 * XHTML
1154 */
1155XMLPUBFUN int XMLCALL
1156 xmlIsXHTML (const xmlChar *systemID,
1157 const xmlChar *publicID);
1158
1159/*
1160 * Compression.
1161 */
1162XMLPUBFUN int XMLCALL
1163 xmlGetDocCompressMode (xmlDocPtr doc);
1164XMLPUBFUN void XMLCALL
1165 xmlSetDocCompressMode (xmlDocPtr doc,
1166 int mode);
1167XMLPUBFUN int XMLCALL
1168 xmlGetCompressMode (void);
1169XMLPUBFUN void XMLCALL
1170 xmlSetCompressMode (int mode);
1171
1172/*
1173* DOM-wrapper helper functions.
1174*/
1175XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL
1176 xmlDOMWrapNewCtxt (void);
1177XMLPUBFUN void XMLCALL
1178 xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt);
1179XMLPUBFUN int XMLCALL
1180 xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt,
1181 xmlNodePtr elem,
1182 int options);
1183XMLPUBFUN int XMLCALL
1184 xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt,
1185 xmlDocPtr sourceDoc,
1186 xmlNodePtr node,
1187 xmlDocPtr destDoc,
1188 xmlNodePtr destParent,
1189 int options);
1190XMLPUBFUN int XMLCALL
1191 xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt,
1192 xmlDocPtr doc,
1193 xmlNodePtr node,
1194 int options);
1195XMLPUBFUN int XMLCALL
1196 xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt,
1197 xmlDocPtr sourceDoc,
1198 xmlNodePtr node,
1199 xmlNodePtr *clonedNode,
1200 xmlDocPtr destDoc,
1201 xmlNodePtr destParent,
1202 int deep,
1203 int options);
1204
1205#ifdef __cplusplus
1206}
1207#endif
1208#ifndef __XML_PARSER_H__
1209#include <libxml/xmlmemory.h>
1210#endif
1211
1212#endif /* __XML_TREE_H__ */
1213
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette