1: /*
2: * globals.c: definition and handling of the set of global variables
3: * of the library
4: *
5: * The bottom of this file is automatically generated by build_glob.py
6: * based on the description file global.data
7: *
8: * See Copyright for the status of this software.
9: *
10: * Gary Pennington <Gary.Pennington@uk.sun.com>
11: * daniel@veillard.com
12: */
13:
14: #define IN_LIBXML
15: #include "libxml.h"
16:
17: #ifdef HAVE_STDLIB_H
18: #include <stdlib.h>
19: #endif
20: #include <string.h>
21:
22: #include <libxml/globals.h>
23: #include <libxml/xmlmemory.h>
24: #include <libxml/threads.h>
25:
26: /* #define DEBUG_GLOBALS */
27:
28: /*
29: * Helpful Macro
30: */
31: #ifdef LIBXML_THREAD_ENABLED
32: #define IS_MAIN_THREAD (xmlIsMainThread())
33: #else
34: #define IS_MAIN_THREAD 1
35: #endif
36:
37: /*
38: * Mutex to protect "ForNewThreads" variables
39: */
40: static xmlMutexPtr xmlThrDefMutex = NULL;
41:
42: /**
43: * xmlInitGlobals:
44: *
45: * Additional initialisation for multi-threading
46: */
47: void xmlInitGlobals(void)
48: {
49: if (xmlThrDefMutex == NULL)
50: xmlThrDefMutex = xmlNewMutex();
51: }
52:
53: /**
54: * xmlCleanupGlobals:
55: *
56: * Additional cleanup for multi-threading
57: */
58: void xmlCleanupGlobals(void)
59: {
60: if (xmlThrDefMutex != NULL) {
61: xmlFreeMutex(xmlThrDefMutex);
62: xmlThrDefMutex = NULL;
63: }
64: __xmlGlobalInitMutexDestroy();
65: }
66:
67: /************************************************************************
68: * *
69: * All the user accessible global variables of the library *
70: * *
71: ************************************************************************/
72:
73: /*
74: * Memory allocation routines
75: */
76: #undef xmlFree
77: #undef xmlMalloc
78: #undef xmlMallocAtomic
79: #undef xmlMemStrdup
80: #undef xmlRealloc
81:
82: #if defined(DEBUG_MEMORY_LOCATION) || defined(DEBUG_MEMORY)
83: xmlFreeFunc xmlFree = (xmlFreeFunc) xmlMemFree;
84: xmlMallocFunc xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
85: xmlMallocFunc xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
86: xmlReallocFunc xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
87: xmlStrdupFunc xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
88: #else
89: /**
90: * xmlFree:
91: * @mem: an already allocated block of memory
92: *
93: * The variable holding the libxml free() implementation
94: */
95: xmlFreeFunc xmlFree = (xmlFreeFunc) free;
96: /**
97: * xmlMalloc:
98: * @size: the size requested in bytes
99: *
100: * The variable holding the libxml malloc() implementation
101: *
102: * Returns a pointer to the newly allocated block or NULL in case of error
103: */
104: xmlMallocFunc xmlMalloc = (xmlMallocFunc) malloc;
105: /**
106: * xmlMallocAtomic:
107: * @size: the size requested in bytes
108: *
109: * The variable holding the libxml malloc() implementation for atomic
110: * data (i.e. blocks not containings pointers), useful when using a
111: * garbage collecting allocator.
112: *
113: * Returns a pointer to the newly allocated block or NULL in case of error
114: */
115: xmlMallocFunc xmlMallocAtomic = (xmlMallocFunc) malloc;
116: /**
117: * xmlRealloc:
118: * @mem: an already allocated block of memory
119: * @size: the new size requested in bytes
120: *
121: * The variable holding the libxml realloc() implementation
122: *
123: * Returns a pointer to the newly reallocated block or NULL in case of error
124: */
125: xmlReallocFunc xmlRealloc = (xmlReallocFunc) realloc;
126: /**
127: * xmlMemStrdup:
128: * @str: a zero terminated string
129: *
130: * The variable holding the libxml strdup() implementation
131: *
132: * Returns the copy of the string or NULL in case of error
133: */
134: xmlStrdupFunc xmlMemStrdup = (xmlStrdupFunc) xmlStrdup;
135: #endif /* DEBUG_MEMORY_LOCATION || DEBUG_MEMORY */
136:
137: #include <libxml/threads.h>
138: #include <libxml/globals.h>
139: #include <libxml/SAX.h>
140:
141: #undef docbDefaultSAXHandler
142: #undef htmlDefaultSAXHandler
143: #undef oldXMLWDcompatibility
144: #undef xmlBufferAllocScheme
145: #undef xmlDefaultBufferSize
146: #undef xmlDefaultSAXHandler
147: #undef xmlDefaultSAXLocator
148: #undef xmlDoValidityCheckingDefaultValue
149: #undef xmlGenericError
150: #undef xmlStructuredError
151: #undef xmlGenericErrorContext
152: #undef xmlStructuredErrorContext
153: #undef xmlGetWarningsDefaultValue
154: #undef xmlIndentTreeOutput
155: #undef xmlTreeIndentString
156: #undef xmlKeepBlanksDefaultValue
157: #undef xmlLineNumbersDefaultValue
158: #undef xmlLoadExtDtdDefaultValue
159: #undef xmlParserDebugEntities
160: #undef xmlParserVersion
161: #undef xmlPedanticParserDefaultValue
162: #undef xmlSaveNoEmptyTags
163: #undef xmlSubstituteEntitiesDefaultValue
164: #undef xmlRegisterNodeDefaultValue
165: #undef xmlDeregisterNodeDefaultValue
166: #undef xmlLastError
167:
168: #undef xmlParserInputBufferCreateFilenameValue
169: #undef xmlOutputBufferCreateFilenameValue
170: /**
171: * xmlParserVersion:
172: *
173: * Constant string describing the internal version of the library
174: */
175: const char *xmlParserVersion = LIBXML_VERSION_STRING LIBXML_VERSION_EXTRA;
176:
177: /**
178: * xmlBufferAllocScheme:
179: *
180: * Global setting, default allocation policy for buffers, default is
181: * XML_BUFFER_ALLOC_EXACT
182: */
183: xmlBufferAllocationScheme xmlBufferAllocScheme = XML_BUFFER_ALLOC_EXACT;
184: static xmlBufferAllocationScheme xmlBufferAllocSchemeThrDef = XML_BUFFER_ALLOC_EXACT;
185: /**
186: * xmlDefaultBufferSize:
187: *
188: * Global setting, default buffer size. Default value is BASE_BUFFER_SIZE
189: */
190: int xmlDefaultBufferSize = BASE_BUFFER_SIZE;
191: static int xmlDefaultBufferSizeThrDef = BASE_BUFFER_SIZE;
192:
193: /*
194: * Parser defaults
195: */
196:
197: /**
198: * oldXMLWDcompatibility:
199: *
200: * Global setting, DEPRECATED.
201: */
202: int oldXMLWDcompatibility = 0; /* DEPRECATED */
203: /**
204: * xmlParserDebugEntities:
205: *
206: * Global setting, asking the parser to print out debugging informations.
207: * while handling entities.
208: * Disabled by default
209: */
210: int xmlParserDebugEntities = 0;
211: static int xmlParserDebugEntitiesThrDef = 0;
212: /**
213: * xmlDoValidityCheckingDefaultValue:
214: *
215: * Global setting, indicate that the parser should work in validating mode.
216: * Disabled by default.
217: */
218: int xmlDoValidityCheckingDefaultValue = 0;
219: static int xmlDoValidityCheckingDefaultValueThrDef = 0;
220: /**
221: * xmlGetWarningsDefaultValue:
222: *
223: * Global setting, indicate that the parser should provide warnings.
224: * Activated by default.
225: */
226: int xmlGetWarningsDefaultValue = 1;
227: static int xmlGetWarningsDefaultValueThrDef = 1;
228: /**
229: * xmlLoadExtDtdDefaultValue:
230: *
231: * Global setting, indicate that the parser should load DTD while not
232: * validating.
233: * Disabled by default.
234: */
235: int xmlLoadExtDtdDefaultValue = 0;
236: static int xmlLoadExtDtdDefaultValueThrDef = 0;
237: /**
238: * xmlPedanticParserDefaultValue:
239: *
240: * Global setting, indicate that the parser be pedantic
241: * Disabled by default.
242: */
243: int xmlPedanticParserDefaultValue = 0;
244: static int xmlPedanticParserDefaultValueThrDef = 0;
245: /**
246: * xmlLineNumbersDefaultValue:
247: *
248: * Global setting, indicate that the parser should store the line number
249: * in the content field of elements in the DOM tree.
250: * Disabled by default since this may not be safe for old classes of
251: * applicaton.
252: */
253: int xmlLineNumbersDefaultValue = 0;
254: static int xmlLineNumbersDefaultValueThrDef = 0;
255: /**
256: * xmlKeepBlanksDefaultValue:
257: *
258: * Global setting, indicate that the parser should keep all blanks
259: * nodes found in the content
260: * Activated by default, this is actually needed to have the parser
261: * conformant to the XML Recommendation, however the option is kept
262: * for some applications since this was libxml1 default behaviour.
263: */
264: int xmlKeepBlanksDefaultValue = 1;
265: static int xmlKeepBlanksDefaultValueThrDef = 1;
266: /**
267: * xmlSubstituteEntitiesDefaultValue:
268: *
269: * Global setting, indicate that the parser should not generate entity
270: * references but replace them with the actual content of the entity
271: * Disabled by default, this should be activated when using XPath since
272: * the XPath data model requires entities replacement and the XPath
273: * engine does not handle entities references transparently.
274: */
275: int xmlSubstituteEntitiesDefaultValue = 0;
276: static int xmlSubstituteEntitiesDefaultValueThrDef = 0;
277:
278: xmlRegisterNodeFunc xmlRegisterNodeDefaultValue = NULL;
279: static xmlRegisterNodeFunc xmlRegisterNodeDefaultValueThrDef = NULL;
280: xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue = NULL;
281: static xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValueThrDef = NULL;
282:
283: xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue = NULL;
284: static xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValueThrDef = NULL;
285:
286: xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue = NULL;
287: static xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValueThrDef = NULL;
288:
289: /*
290: * Error handling
291: */
292:
293: /* xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc; */
294: /* Must initialize xmlGenericError in xmlInitParser */
295: void XMLCDECL xmlGenericErrorDefaultFunc (void *ctx ATTRIBUTE_UNUSED,
296: const char *msg,
297: ...);
298: /**
299: * xmlGenericError:
300: *
301: * Global setting: function used for generic error callbacks
302: */
303: xmlGenericErrorFunc xmlGenericError = xmlGenericErrorDefaultFunc;
304: static xmlGenericErrorFunc xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
305: /**
306: * xmlStructuredError:
307: *
308: * Global setting: function used for structured error callbacks
309: */
310: xmlStructuredErrorFunc xmlStructuredError = NULL;
311: static xmlStructuredErrorFunc xmlStructuredErrorThrDef = NULL;
312: /**
313: * xmlGenericErrorContext:
314: *
315: * Global setting passed to generic error callbacks
316: */
317: void *xmlGenericErrorContext = NULL;
318: static void *xmlGenericErrorContextThrDef = NULL;
319: /**
320: * xmlStructuredErrorContext:
321: *
322: * Global setting passed to structured error callbacks
323: */
324: void *xmlStructuredErrorContext = NULL;
325: static void *xmlStructuredErrorContextThrDef = NULL;
326: xmlError xmlLastError;
327:
328: /*
329: * output defaults
330: */
331: /**
332: * xmlIndentTreeOutput:
333: *
334: * Global setting, asking the serializer to indent the output tree by default
335: * Enabled by default
336: */
337: int xmlIndentTreeOutput = 1;
338: static int xmlIndentTreeOutputThrDef = 1;
339:
340: /**
341: * xmlTreeIndentString:
342: *
343: * The string used to do one-level indent. By default is equal to " " (two spaces)
344: */
345: const char *xmlTreeIndentString = " ";
346: static const char *xmlTreeIndentStringThrDef = " ";
347:
348: /**
349: * xmlSaveNoEmptyTags:
350: *
351: * Global setting, asking the serializer to not output empty tags
352: * as <empty/> but <empty></empty>. those two forms are undistinguishable
353: * once parsed.
354: * Disabled by default
355: */
356: int xmlSaveNoEmptyTags = 0;
357: static int xmlSaveNoEmptyTagsThrDef = 0;
358:
359: #ifdef LIBXML_SAX1_ENABLED
360: /**
361: * xmlDefaultSAXHandler:
362: *
363: * Default SAX version1 handler for XML, builds the DOM tree
364: */
365: xmlSAXHandlerV1 xmlDefaultSAXHandler = {
366: xmlSAX2InternalSubset,
367: xmlSAX2IsStandalone,
368: xmlSAX2HasInternalSubset,
369: xmlSAX2HasExternalSubset,
370: xmlSAX2ResolveEntity,
371: xmlSAX2GetEntity,
372: xmlSAX2EntityDecl,
373: xmlSAX2NotationDecl,
374: xmlSAX2AttributeDecl,
375: xmlSAX2ElementDecl,
376: xmlSAX2UnparsedEntityDecl,
377: xmlSAX2SetDocumentLocator,
378: xmlSAX2StartDocument,
379: xmlSAX2EndDocument,
380: xmlSAX2StartElement,
381: xmlSAX2EndElement,
382: xmlSAX2Reference,
383: xmlSAX2Characters,
384: xmlSAX2Characters,
385: xmlSAX2ProcessingInstruction,
386: xmlSAX2Comment,
387: xmlParserWarning,
388: xmlParserError,
389: xmlParserError,
390: xmlSAX2GetParameterEntity,
391: xmlSAX2CDataBlock,
392: xmlSAX2ExternalSubset,
393: 0,
394: };
395: #endif /* LIBXML_SAX1_ENABLED */
396:
397: /**
398: * xmlDefaultSAXLocator:
399: *
400: * The default SAX Locator
401: * { getPublicId, getSystemId, getLineNumber, getColumnNumber}
402: */
403: xmlSAXLocator xmlDefaultSAXLocator = {
404: xmlSAX2GetPublicId,
405: xmlSAX2GetSystemId,
406: xmlSAX2GetLineNumber,
407: xmlSAX2GetColumnNumber
408: };
409:
410: #ifdef LIBXML_HTML_ENABLED
411: /**
412: * htmlDefaultSAXHandler:
413: *
414: * Default old SAX v1 handler for HTML, builds the DOM tree
415: */
416: xmlSAXHandlerV1 htmlDefaultSAXHandler = {
417: xmlSAX2InternalSubset,
418: NULL,
419: NULL,
420: NULL,
421: NULL,
422: xmlSAX2GetEntity,
423: NULL,
424: NULL,
425: NULL,
426: NULL,
427: NULL,
428: xmlSAX2SetDocumentLocator,
429: xmlSAX2StartDocument,
430: xmlSAX2EndDocument,
431: xmlSAX2StartElement,
432: xmlSAX2EndElement,
433: NULL,
434: xmlSAX2Characters,
435: xmlSAX2IgnorableWhitespace,
436: xmlSAX2ProcessingInstruction,
437: xmlSAX2Comment,
438: xmlParserWarning,
439: xmlParserError,
440: xmlParserError,
441: xmlSAX2GetParameterEntity,
442: xmlSAX2CDataBlock,
443: NULL,
444: 0,
445: };
446: #endif /* LIBXML_HTML_ENABLED */
447:
448: #ifdef LIBXML_DOCB_ENABLED
449: /**
450: * docbDefaultSAXHandler:
451: *
452: * Default old SAX v1 handler for SGML DocBook, builds the DOM tree
453: */
454: xmlSAXHandlerV1 docbDefaultSAXHandler = {
455: xmlSAX2InternalSubset,
456: xmlSAX2IsStandalone,
457: xmlSAX2HasInternalSubset,
458: xmlSAX2HasExternalSubset,
459: xmlSAX2ResolveEntity,
460: xmlSAX2GetEntity,
461: xmlSAX2EntityDecl,
462: NULL,
463: NULL,
464: NULL,
465: NULL,
466: xmlSAX2SetDocumentLocator,
467: xmlSAX2StartDocument,
468: xmlSAX2EndDocument,
469: xmlSAX2StartElement,
470: xmlSAX2EndElement,
471: xmlSAX2Reference,
472: xmlSAX2Characters,
473: xmlSAX2IgnorableWhitespace,
474: NULL,
475: xmlSAX2Comment,
476: xmlParserWarning,
477: xmlParserError,
478: xmlParserError,
479: xmlSAX2GetParameterEntity,
480: NULL,
481: NULL,
482: 0,
483: };
484: #endif /* LIBXML_DOCB_ENABLED */
485:
486: /**
487: * xmlInitializeGlobalState:
488: * @gs: a pointer to a newly allocated global state
489: *
490: * xmlInitializeGlobalState() initialize a global state with all the
491: * default values of the library.
492: */
493: void
494: xmlInitializeGlobalState(xmlGlobalStatePtr gs)
495: {
496: #ifdef DEBUG_GLOBALS
497: fprintf(stderr, "Initializing globals at %lu for thread %d\n",
498: (unsigned long) gs, xmlGetThreadId());
499: #endif
500:
501: /*
502: * Perform initialization as required by libxml
503: */
504: if (xmlThrDefMutex == NULL)
505: xmlInitGlobals();
506:
507: xmlMutexLock(xmlThrDefMutex);
508:
509: #if defined(LIBXML_DOCB_ENABLED) && defined(LIBXML_LEGACY_ENABLED) && defined(LIBXML_SAX1_ENABLED)
510: initdocbDefaultSAXHandler(&gs->docbDefaultSAXHandler);
511: #endif
512: #if defined(LIBXML_HTML_ENABLED) && defined(LIBXML_LEGACY_ENABLED) && defined(LIBXML_SAX1_ENABLED)
513: inithtmlDefaultSAXHandler(&gs->htmlDefaultSAXHandler);
514: #endif
515:
516: gs->oldXMLWDcompatibility = 0;
517: gs->xmlBufferAllocScheme = xmlBufferAllocSchemeThrDef;
518: gs->xmlDefaultBufferSize = xmlDefaultBufferSizeThrDef;
519: #if defined(LIBXML_SAX1_ENABLED) && defined(LIBXML_LEGACY_ENABLED)
520: initxmlDefaultSAXHandler(&gs->xmlDefaultSAXHandler, 1);
521: #endif /* LIBXML_SAX1_ENABLED */
522: gs->xmlDefaultSAXLocator.getPublicId = xmlSAX2GetPublicId;
523: gs->xmlDefaultSAXLocator.getSystemId = xmlSAX2GetSystemId;
524: gs->xmlDefaultSAXLocator.getLineNumber = xmlSAX2GetLineNumber;
525: gs->xmlDefaultSAXLocator.getColumnNumber = xmlSAX2GetColumnNumber;
526: gs->xmlDoValidityCheckingDefaultValue =
527: xmlDoValidityCheckingDefaultValueThrDef;
528: #if defined(DEBUG_MEMORY_LOCATION) | defined(DEBUG_MEMORY)
529: gs->xmlFree = (xmlFreeFunc) xmlMemFree;
530: gs->xmlMalloc = (xmlMallocFunc) xmlMemMalloc;
531: gs->xmlMallocAtomic = (xmlMallocFunc) xmlMemMalloc;
532: gs->xmlRealloc = (xmlReallocFunc) xmlMemRealloc;
533: gs->xmlMemStrdup = (xmlStrdupFunc) xmlMemoryStrdup;
534: #else
535: gs->xmlFree = (xmlFreeFunc) free;
536: gs->xmlMalloc = (xmlMallocFunc) malloc;
537: gs->xmlMallocAtomic = (xmlMallocFunc) malloc;
538: gs->xmlRealloc = (xmlReallocFunc) realloc;
539: gs->xmlMemStrdup = (xmlStrdupFunc) xmlStrdup;
540: #endif
541: gs->xmlGetWarningsDefaultValue = xmlGetWarningsDefaultValueThrDef;
542: gs->xmlIndentTreeOutput = xmlIndentTreeOutputThrDef;
543: gs->xmlTreeIndentString = xmlTreeIndentStringThrDef;
544: gs->xmlKeepBlanksDefaultValue = xmlKeepBlanksDefaultValueThrDef;
545: gs->xmlLineNumbersDefaultValue = xmlLineNumbersDefaultValueThrDef;
546: gs->xmlLoadExtDtdDefaultValue = xmlLoadExtDtdDefaultValueThrDef;
547: gs->xmlParserDebugEntities = xmlParserDebugEntitiesThrDef;
548: gs->xmlParserVersion = LIBXML_VERSION_STRING;
549: gs->xmlPedanticParserDefaultValue = xmlPedanticParserDefaultValueThrDef;
550: gs->xmlSaveNoEmptyTags = xmlSaveNoEmptyTagsThrDef;
551: gs->xmlSubstituteEntitiesDefaultValue =
552: xmlSubstituteEntitiesDefaultValueThrDef;
553:
554: gs->xmlGenericError = xmlGenericErrorThrDef;
555: gs->xmlStructuredError = xmlStructuredErrorThrDef;
556: gs->xmlGenericErrorContext = xmlGenericErrorContextThrDef;
557: gs->xmlStructuredErrorContext = xmlStructuredErrorContextThrDef;
558: gs->xmlRegisterNodeDefaultValue = xmlRegisterNodeDefaultValueThrDef;
559: gs->xmlDeregisterNodeDefaultValue = xmlDeregisterNodeDefaultValueThrDef;
560:
561: gs->xmlParserInputBufferCreateFilenameValue = xmlParserInputBufferCreateFilenameValueThrDef;
562: gs->xmlOutputBufferCreateFilenameValue = xmlOutputBufferCreateFilenameValueThrDef;
563: memset(&gs->xmlLastError, 0, sizeof(xmlError));
564:
565: xmlMutexUnlock(xmlThrDefMutex);
566: }
567:
568: /**
569: * DOC_DISABLE : we ignore missing doc for the xmlThrDef functions,
570: * those are really internal work
571: */
572: void
573: xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler) {
574: xmlMutexLock(xmlThrDefMutex);
575: xmlGenericErrorContextThrDef = ctx;
576: if (handler != NULL)
577: xmlGenericErrorThrDef = handler;
578: else
579: xmlGenericErrorThrDef = xmlGenericErrorDefaultFunc;
580: xmlMutexUnlock(xmlThrDefMutex);
581: }
582:
583: void
584: xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler) {
585: xmlMutexLock(xmlThrDefMutex);
586: xmlStructuredErrorContextThrDef = ctx;
587: xmlStructuredErrorThrDef = handler;
588: xmlMutexUnlock(xmlThrDefMutex);
589: }
590:
591: /**
592: * xmlRegisterNodeDefault:
593: * @func: function pointer to the new RegisterNodeFunc
594: *
595: * Registers a callback for node creation
596: *
597: * Returns the old value of the registration function
598: */
599: xmlRegisterNodeFunc
600: xmlRegisterNodeDefault(xmlRegisterNodeFunc func)
601: {
602: xmlRegisterNodeFunc old = xmlRegisterNodeDefaultValue;
603:
604: __xmlRegisterCallbacks = 1;
605: xmlRegisterNodeDefaultValue = func;
606: return(old);
607: }
608:
609: xmlRegisterNodeFunc
610: xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func)
611: {
612: xmlRegisterNodeFunc old;
613:
614: xmlMutexLock(xmlThrDefMutex);
615: old = xmlRegisterNodeDefaultValueThrDef;
616:
617: __xmlRegisterCallbacks = 1;
618: xmlRegisterNodeDefaultValueThrDef = func;
619: xmlMutexUnlock(xmlThrDefMutex);
620:
621: return(old);
622: }
623:
624: /**
625: * xmlDeregisterNodeDefault:
626: * @func: function pointer to the new DeregisterNodeFunc
627: *
628: * Registers a callback for node destruction
629: *
630: * Returns the previous value of the deregistration function
631: */
632: xmlDeregisterNodeFunc
633: xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func)
634: {
635: xmlDeregisterNodeFunc old = xmlDeregisterNodeDefaultValue;
636:
637: __xmlRegisterCallbacks = 1;
638: xmlDeregisterNodeDefaultValue = func;
639: return(old);
640: }
641:
642: xmlDeregisterNodeFunc
643: xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func)
644: {
645: xmlDeregisterNodeFunc old;
646:
647: xmlMutexLock(xmlThrDefMutex);
648: old = xmlDeregisterNodeDefaultValueThrDef;
649:
650: __xmlRegisterCallbacks = 1;
651: xmlDeregisterNodeDefaultValueThrDef = func;
652: xmlMutexUnlock(xmlThrDefMutex);
653:
654: return(old);
655: }
656:
657: xmlParserInputBufferCreateFilenameFunc
658: xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func)
659: {
660: xmlParserInputBufferCreateFilenameFunc old;
661:
662: xmlMutexLock(xmlThrDefMutex);
663: old = xmlParserInputBufferCreateFilenameValueThrDef;
664: if (old == NULL) {
665: old = __xmlParserInputBufferCreateFilename;
666: }
667:
668: xmlParserInputBufferCreateFilenameValueThrDef = func;
669: xmlMutexUnlock(xmlThrDefMutex);
670:
671: return(old);
672: }
673:
674: xmlOutputBufferCreateFilenameFunc
675: xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func)
676: {
677: xmlOutputBufferCreateFilenameFunc old;
678:
679: xmlMutexLock(xmlThrDefMutex);
680: old = xmlOutputBufferCreateFilenameValueThrDef;
681: #ifdef LIBXML_OUTPUT_ENABLED
682: if (old == NULL) {
683: old = __xmlOutputBufferCreateFilename;
684: }
685: #endif
686: xmlOutputBufferCreateFilenameValueThrDef = func;
687: xmlMutexUnlock(xmlThrDefMutex);
688:
689: return(old);
690: }
691:
692: #ifdef LIBXML_DOCB_ENABLED
693: #undef docbDefaultSAXHandler
694: xmlSAXHandlerV1 *
695: __docbDefaultSAXHandler(void) {
696: if (IS_MAIN_THREAD)
697: return (&docbDefaultSAXHandler);
698: else
699: return (&xmlGetGlobalState()->docbDefaultSAXHandler);
700: }
701: #endif
702:
703: #ifdef LIBXML_HTML_ENABLED
704: #undef htmlDefaultSAXHandler
705: xmlSAXHandlerV1 *
706: __htmlDefaultSAXHandler(void) {
707: if (IS_MAIN_THREAD)
708: return (&htmlDefaultSAXHandler);
709: else
710: return (&xmlGetGlobalState()->htmlDefaultSAXHandler);
711: }
712: #endif
713:
714: #undef xmlLastError
715: xmlError *
716: __xmlLastError(void) {
717: if (IS_MAIN_THREAD)
718: return (&xmlLastError);
719: else
720: return (&xmlGetGlobalState()->xmlLastError);
721: }
722:
723: /*
724: * The following memory routines were apparently lost at some point,
725: * and were re-inserted at this point on June 10, 2004. Hope it's
726: * the right place for them :-)
727: */
728: #if defined(LIBXML_THREAD_ALLOC_ENABLED) && defined(LIBXML_THREAD_ENABLED)
729: #undef xmlMalloc
730: xmlMallocFunc *
731: __xmlMalloc(void){
732: if (IS_MAIN_THREAD)
733: return (&xmlMalloc);
734: else
735: return (&xmlGetGlobalState()->xmlMalloc);
736: }
737:
738: #undef xmlMallocAtomic
739: xmlMallocFunc *
740: __xmlMallocAtomic(void){
741: if (IS_MAIN_THREAD)
742: return (&xmlMallocAtomic);
743: else
744: return (&xmlGetGlobalState()->xmlMallocAtomic);
745: }
746:
747: #undef xmlRealloc
748: xmlReallocFunc *
749: __xmlRealloc(void){
750: if (IS_MAIN_THREAD)
751: return (&xmlRealloc);
752: else
753: return (&xmlGetGlobalState()->xmlRealloc);
754: }
755:
756: #undef xmlFree
757: xmlFreeFunc *
758: __xmlFree(void){
759: if (IS_MAIN_THREAD)
760: return (&xmlFree);
761: else
762: return (&xmlGetGlobalState()->xmlFree);
763: }
764:
765: xmlStrdupFunc *
766: __xmlMemStrdup(void){
767: if (IS_MAIN_THREAD)
768: return (&xmlMemStrdup);
769: else
770: return (&xmlGetGlobalState()->xmlMemStrdup);
771: }
772:
773: #endif
774:
775: /*
776: * Everything starting from the line below is
777: * Automatically generated by build_glob.py.
778: * Do not modify the previous line.
779: */
780:
781:
782: #undef oldXMLWDcompatibility
783: int *
784: __oldXMLWDcompatibility(void) {
785: if (IS_MAIN_THREAD)
786: return (&oldXMLWDcompatibility);
787: else
788: return (&xmlGetGlobalState()->oldXMLWDcompatibility);
789: }
790:
791: #undef xmlBufferAllocScheme
792: xmlBufferAllocationScheme *
793: __xmlBufferAllocScheme(void) {
794: if (IS_MAIN_THREAD)
795: return (&xmlBufferAllocScheme);
796: else
797: return (&xmlGetGlobalState()->xmlBufferAllocScheme);
798: }
799: xmlBufferAllocationScheme xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v) {
800: xmlBufferAllocationScheme ret;
801: xmlMutexLock(xmlThrDefMutex);
802: ret = xmlBufferAllocSchemeThrDef;
803: xmlBufferAllocSchemeThrDef = v;
804: xmlMutexUnlock(xmlThrDefMutex);
805: return ret;
806: }
807:
808: #undef xmlDefaultBufferSize
809: int *
810: __xmlDefaultBufferSize(void) {
811: if (IS_MAIN_THREAD)
812: return (&xmlDefaultBufferSize);
813: else
814: return (&xmlGetGlobalState()->xmlDefaultBufferSize);
815: }
816: int xmlThrDefDefaultBufferSize(int v) {
817: int ret;
818: xmlMutexLock(xmlThrDefMutex);
819: ret = xmlDefaultBufferSizeThrDef;
820: xmlDefaultBufferSizeThrDef = v;
821: xmlMutexUnlock(xmlThrDefMutex);
822: return ret;
823: }
824:
825: #ifdef LIBXML_SAX1_ENABLED
826: #undef xmlDefaultSAXHandler
827: xmlSAXHandlerV1 *
828: __xmlDefaultSAXHandler(void) {
829: if (IS_MAIN_THREAD)
830: return (&xmlDefaultSAXHandler);
831: else
832: return (&xmlGetGlobalState()->xmlDefaultSAXHandler);
833: }
834: #endif /* LIBXML_SAX1_ENABLED */
835:
836: #undef xmlDefaultSAXLocator
837: xmlSAXLocator *
838: __xmlDefaultSAXLocator(void) {
839: if (IS_MAIN_THREAD)
840: return (&xmlDefaultSAXLocator);
841: else
842: return (&xmlGetGlobalState()->xmlDefaultSAXLocator);
843: }
844:
845: #undef xmlDoValidityCheckingDefaultValue
846: int *
847: __xmlDoValidityCheckingDefaultValue(void) {
848: if (IS_MAIN_THREAD)
849: return (&xmlDoValidityCheckingDefaultValue);
850: else
851: return (&xmlGetGlobalState()->xmlDoValidityCheckingDefaultValue);
852: }
853: int xmlThrDefDoValidityCheckingDefaultValue(int v) {
854: int ret;
855: xmlMutexLock(xmlThrDefMutex);
856: ret = xmlDoValidityCheckingDefaultValueThrDef;
857: xmlDoValidityCheckingDefaultValueThrDef = v;
858: xmlMutexUnlock(xmlThrDefMutex);
859: return ret;
860: }
861:
862: #undef xmlGenericError
863: xmlGenericErrorFunc *
864: __xmlGenericError(void) {
865: if (IS_MAIN_THREAD)
866: return (&xmlGenericError);
867: else
868: return (&xmlGetGlobalState()->xmlGenericError);
869: }
870:
871: #undef xmlStructuredError
872: xmlStructuredErrorFunc *
873: __xmlStructuredError(void) {
874: if (IS_MAIN_THREAD)
875: return (&xmlStructuredError);
876: else
877: return (&xmlGetGlobalState()->xmlStructuredError);
878: }
879:
880: #undef xmlGenericErrorContext
881: void * *
882: __xmlGenericErrorContext(void) {
883: if (IS_MAIN_THREAD)
884: return (&xmlGenericErrorContext);
885: else
886: return (&xmlGetGlobalState()->xmlGenericErrorContext);
887: }
888:
889: #undef xmlStructuredErrorContext
890: void * *
891: __xmlStructuredErrorContext(void) {
892: if (IS_MAIN_THREAD)
893: return (&xmlStructuredErrorContext);
894: else
895: return (&xmlGetGlobalState()->xmlStructuredErrorContext);
896: }
897:
898: #undef xmlGetWarningsDefaultValue
899: int *
900: __xmlGetWarningsDefaultValue(void) {
901: if (IS_MAIN_THREAD)
902: return (&xmlGetWarningsDefaultValue);
903: else
904: return (&xmlGetGlobalState()->xmlGetWarningsDefaultValue);
905: }
906: int xmlThrDefGetWarningsDefaultValue(int v) {
907: int ret;
908: xmlMutexLock(xmlThrDefMutex);
909: ret = xmlGetWarningsDefaultValueThrDef;
910: xmlGetWarningsDefaultValueThrDef = v;
911: xmlMutexUnlock(xmlThrDefMutex);
912: return ret;
913: }
914:
915: #undef xmlIndentTreeOutput
916: int *
917: __xmlIndentTreeOutput(void) {
918: if (IS_MAIN_THREAD)
919: return (&xmlIndentTreeOutput);
920: else
921: return (&xmlGetGlobalState()->xmlIndentTreeOutput);
922: }
923: int xmlThrDefIndentTreeOutput(int v) {
924: int ret;
925: xmlMutexLock(xmlThrDefMutex);
926: ret = xmlIndentTreeOutputThrDef;
927: xmlIndentTreeOutputThrDef = v;
928: xmlMutexUnlock(xmlThrDefMutex);
929: return ret;
930: }
931:
932: #undef xmlTreeIndentString
933: const char * *
934: __xmlTreeIndentString(void) {
935: if (IS_MAIN_THREAD)
936: return (&xmlTreeIndentString);
937: else
938: return (&xmlGetGlobalState()->xmlTreeIndentString);
939: }
940: const char * xmlThrDefTreeIndentString(const char * v) {
941: const char * ret;
942: xmlMutexLock(xmlThrDefMutex);
943: ret = xmlTreeIndentStringThrDef;
944: xmlTreeIndentStringThrDef = v;
945: xmlMutexUnlock(xmlThrDefMutex);
946: return ret;
947: }
948:
949: #undef xmlKeepBlanksDefaultValue
950: int *
951: __xmlKeepBlanksDefaultValue(void) {
952: if (IS_MAIN_THREAD)
953: return (&xmlKeepBlanksDefaultValue);
954: else
955: return (&xmlGetGlobalState()->xmlKeepBlanksDefaultValue);
956: }
957: int xmlThrDefKeepBlanksDefaultValue(int v) {
958: int ret;
959: xmlMutexLock(xmlThrDefMutex);
960: ret = xmlKeepBlanksDefaultValueThrDef;
961: xmlKeepBlanksDefaultValueThrDef = v;
962: xmlMutexUnlock(xmlThrDefMutex);
963: return ret;
964: }
965:
966: #undef xmlLineNumbersDefaultValue
967: int *
968: __xmlLineNumbersDefaultValue(void) {
969: if (IS_MAIN_THREAD)
970: return (&xmlLineNumbersDefaultValue);
971: else
972: return (&xmlGetGlobalState()->xmlLineNumbersDefaultValue);
973: }
974: int xmlThrDefLineNumbersDefaultValue(int v) {
975: int ret;
976: xmlMutexLock(xmlThrDefMutex);
977: ret = xmlLineNumbersDefaultValueThrDef;
978: xmlLineNumbersDefaultValueThrDef = v;
979: xmlMutexUnlock(xmlThrDefMutex);
980: return ret;
981: }
982:
983: #undef xmlLoadExtDtdDefaultValue
984: int *
985: __xmlLoadExtDtdDefaultValue(void) {
986: if (IS_MAIN_THREAD)
987: return (&xmlLoadExtDtdDefaultValue);
988: else
989: return (&xmlGetGlobalState()->xmlLoadExtDtdDefaultValue);
990: }
991: int xmlThrDefLoadExtDtdDefaultValue(int v) {
992: int ret;
993: xmlMutexLock(xmlThrDefMutex);
994: ret = xmlLoadExtDtdDefaultValueThrDef;
995: xmlLoadExtDtdDefaultValueThrDef = v;
996: xmlMutexUnlock(xmlThrDefMutex);
997: return ret;
998: }
999:
1000: #undef xmlParserDebugEntities
1001: int *
1002: __xmlParserDebugEntities(void) {
1003: if (IS_MAIN_THREAD)
1004: return (&xmlParserDebugEntities);
1005: else
1006: return (&xmlGetGlobalState()->xmlParserDebugEntities);
1007: }
1008: int xmlThrDefParserDebugEntities(int v) {
1009: int ret;
1010: xmlMutexLock(xmlThrDefMutex);
1011: ret = xmlParserDebugEntitiesThrDef;
1012: xmlParserDebugEntitiesThrDef = v;
1013: xmlMutexUnlock(xmlThrDefMutex);
1014: return ret;
1015: }
1016:
1017: #undef xmlParserVersion
1018: const char * *
1019: __xmlParserVersion(void) {
1020: if (IS_MAIN_THREAD)
1021: return (&xmlParserVersion);
1022: else
1023: return (&xmlGetGlobalState()->xmlParserVersion);
1024: }
1025:
1026: #undef xmlPedanticParserDefaultValue
1027: int *
1028: __xmlPedanticParserDefaultValue(void) {
1029: if (IS_MAIN_THREAD)
1030: return (&xmlPedanticParserDefaultValue);
1031: else
1032: return (&xmlGetGlobalState()->xmlPedanticParserDefaultValue);
1033: }
1034: int xmlThrDefPedanticParserDefaultValue(int v) {
1035: int ret;
1036: xmlMutexLock(xmlThrDefMutex);
1037: ret = xmlPedanticParserDefaultValueThrDef;
1038: xmlPedanticParserDefaultValueThrDef = v;
1039: xmlMutexUnlock(xmlThrDefMutex);
1040: return ret;
1041: }
1042:
1043: #undef xmlSaveNoEmptyTags
1044: int *
1045: __xmlSaveNoEmptyTags(void) {
1046: if (IS_MAIN_THREAD)
1047: return (&xmlSaveNoEmptyTags);
1048: else
1049: return (&xmlGetGlobalState()->xmlSaveNoEmptyTags);
1050: }
1051: int xmlThrDefSaveNoEmptyTags(int v) {
1052: int ret;
1053: xmlMutexLock(xmlThrDefMutex);
1054: ret = xmlSaveNoEmptyTagsThrDef;
1055: xmlSaveNoEmptyTagsThrDef = v;
1056: xmlMutexUnlock(xmlThrDefMutex);
1057: return ret;
1058: }
1059:
1060: #undef xmlSubstituteEntitiesDefaultValue
1061: int *
1062: __xmlSubstituteEntitiesDefaultValue(void) {
1063: if (IS_MAIN_THREAD)
1064: return (&xmlSubstituteEntitiesDefaultValue);
1065: else
1066: return (&xmlGetGlobalState()->xmlSubstituteEntitiesDefaultValue);
1067: }
1068: int xmlThrDefSubstituteEntitiesDefaultValue(int v) {
1069: int ret;
1070: xmlMutexLock(xmlThrDefMutex);
1071: ret = xmlSubstituteEntitiesDefaultValueThrDef;
1072: xmlSubstituteEntitiesDefaultValueThrDef = v;
1073: xmlMutexUnlock(xmlThrDefMutex);
1074: return ret;
1075: }
1076:
1077: #undef xmlRegisterNodeDefaultValue
1078: xmlRegisterNodeFunc *
1079: __xmlRegisterNodeDefaultValue(void) {
1080: if (IS_MAIN_THREAD)
1081: return (&xmlRegisterNodeDefaultValue);
1082: else
1083: return (&xmlGetGlobalState()->xmlRegisterNodeDefaultValue);
1084: }
1085:
1086: #undef xmlDeregisterNodeDefaultValue
1087: xmlDeregisterNodeFunc *
1088: __xmlDeregisterNodeDefaultValue(void) {
1089: if (IS_MAIN_THREAD)
1090: return (&xmlDeregisterNodeDefaultValue);
1091: else
1092: return (&xmlGetGlobalState()->xmlDeregisterNodeDefaultValue);
1093: }
1094:
1095: #undef xmlParserInputBufferCreateFilenameValue
1096: xmlParserInputBufferCreateFilenameFunc *
1097: __xmlParserInputBufferCreateFilenameValue(void) {
1098: if (IS_MAIN_THREAD)
1099: return (&xmlParserInputBufferCreateFilenameValue);
1100: else
1101: return (&xmlGetGlobalState()->xmlParserInputBufferCreateFilenameValue);
1102: }
1103:
1104: #undef xmlOutputBufferCreateFilenameValue
1105: xmlOutputBufferCreateFilenameFunc *
1106: __xmlOutputBufferCreateFilenameValue(void) {
1107: if (IS_MAIN_THREAD)
1108: return (&xmlOutputBufferCreateFilenameValue);
1109: else
1110: return (&xmlGetGlobalState()->xmlOutputBufferCreateFilenameValue);
1111: }
1112:
1113: #define bottom_globals
1114: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to globals.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2