Ignore:
Timestamp:
Mar 19, 2014, 11:11:30 AM (11 years ago)
Author:
dmik
Message:

python: Update vendor to 2.7.6.

Location:
python/vendor/current/Modules/expat
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • python/vendor/current/Modules/expat/amigaconfig.h

    r2 r388  
    1111#undef HAVE_CHECK_H
    1212
    13 /* Define to 1 if you have the <dlfcn.h> header file. */
    14 #undef HAVE_DLFCN_H
    15 
    16 /* Define to 1 if you have the <fcntl.h> header file. */
    17 #define HAVE_FCNTL_H 1
    18 
    19 /* Define to 1 if you have the `getpagesize' function. */
    20 #undef HAVE_GETPAGESIZE
    21 
    22 /* Define to 1 if you have the <inttypes.h> header file. */
    23 #define HAVE_INTTYPES_H 1
    24 
    2513/* Define to 1 if you have the `memmove' function. */
    2614#define HAVE_MEMMOVE 1
    2715
    28 /* Define to 1 if you have the <memory.h> header file. */
    29 #undef HAVE_MEMORY_H
    30 
    31 /* Define to 1 if you have a working `mmap' system call. */
    32 #undef HAVE_MMAP
    33 
    34 /* Define to 1 if you have the <stdint.h> header file. */
    35 #define HAVE_STDINT_H 1
    36 
    37 /* Define to 1 if you have the <stdlib.h> header file. */
    38 #define HAVE_STDLIB_H 1
    39 
    40 /* Define to 1 if you have the <strings.h> header file. */
    41 #define HAVE_STRINGS_H 1
    42 
    43 /* Define to 1 if you have the <string.h> header file. */
    44 #define HAVE_STRING_H 1
    45 
    46 /* Define to 1 if you have the <sys/stat.h> header file. */
    47 #define HAVE_SYS_STAT_H 1
    48 
    49 /* Define to 1 if you have the <sys/types.h> header file. */
    50 #define HAVE_SYS_TYPES_H 1
    51 
    5216/* Define to 1 if you have the <unistd.h> header file. */
    5317#define HAVE_UNISTD_H 1
    54 
    55 /* Define to the address where bug reports for this package should be sent. */
    56 #define PACKAGE_BUGREPORT "expat-bugs@mail.libexpat.org"
    57 
    58 /* Define to the full name of this package. */
    59 #define PACKAGE_NAME "expat"
    60 
    61 /* Define to the full name and version of this package. */
    62 #define PACKAGE_STRING "expat 1.95.8"
    63 
    64 /* Define to the one symbol short name of this package. */
    65 #undef PACKAGE_TARNAME
    66 
    67 /* Define to the version of this package. */
    68 #define PACKAGE_VERSION "1.95.8"
    69 
    70 /* Define to 1 if you have the ANSI C header files. */
    71 #define STDC_HEADERS 1
    7218
    7319/* whether byteorder is bigendian */
    … …  
    8430#define XML_NS
    8531
    86 /* Define to empty if `const' does not conform to ANSI C. */
    87 #undef const
    88 
    89 /* Define to `long' if <sys/types.h> does not define. */
    90 #undef off_t
    91 
    92 /* Define to `unsigned' if <sys/types.h> does not define. */
    93 #undef size_t
    94 
    95 
    9632#endif  /* AMIGACONFIG_H */

  • python/vendor/current/Modules/expat/ascii.h

    r2 r388  
    8484#define ASCII_RSQB 0x5D
    8585#define ASCII_UNDERSCORE 0x5F
     86#define ASCII_LPAREN 0x28
     87#define ASCII_RPAREN 0x29
     88#define ASCII_FF 0x0C
     89#define ASCII_SLASH 0x2F
     90#define ASCII_HASH 0x23
     91#define ASCII_PIPE 0x7C
     92#define ASCII_COMMA 0x2C

  • python/vendor/current/Modules/expat/expat.h

    r2 r388  
    743743XML_GetIdAttributeIndex(XML_Parser parser);
    744744
     745#ifdef XML_ATTR_INFO
     746/* Source file byte offsets for the start and end of attribute names and values.
     747   The value indices are exclusive of surrounding quotes; thus in a UTF-8 source
     748   file an attribute value of "blah" will yield:
     749   info->valueEnd - info->valueStart = 4 bytes.
     750*/
     751typedef struct {
     752  XML_Index  nameStart;  /* Offset to beginning of the attribute name. */
     753  XML_Index  nameEnd;    /* Offset after the attribute name's last byte. */
     754  XML_Index  valueStart; /* Offset to beginning of the attribute value. */
     755  XML_Index  valueEnd;   /* Offset after the attribute value's last byte. */
     756} XML_AttrInfo;
     757
     758/* Returns an array of XML_AttrInfo structures for the attribute/value pairs
     759   passed in last call to the XML_StartElementHandler that were specified
     760   in the start-tag rather than defaulted. Each attribute/value pair counts
     761   as 1; thus the number of entries in the array is
     762   XML_GetSpecifiedAttributeCount(parser) / 2.
     763*/
     764XMLPARSEAPI(const XML_AttrInfo *)
     765XML_GetAttributeInfo(XML_Parser parser);
     766#endif
     767
    745768/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
    746769   detected.  The last call to XML_Parse must have isFinal true; len
    … …  
    884907                          enum XML_ParamEntityParsing parsing);
    885908
     909/* Sets the hash salt to use for internal hash calculations.
     910   Helps in preventing DoS attacks based on predicting hash
     911   function behavior. This must be called before parsing is started.
     912   Returns 1 if successful, 0 when called after parsing has started.
     913*/
     914XMLPARSEAPI(int)
     915XML_SetHashSalt(XML_Parser parser,
     916                unsigned long hash_salt);
     917
     918#define XML_HAS_SET_HASH_SALT  /* Python Only: Defined for pyexpat.c. */
     919
    886920/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
    887921   XML_GetErrorCode returns information about the error.
    … …  
    9841018  XML_FEATURE_SIZEOF_XML_CHAR,
    9851019  XML_FEATURE_SIZEOF_XML_LCHAR,
    986   XML_FEATURE_NS
     1020  XML_FEATURE_NS,
     1021  XML_FEATURE_LARGE_SIZE,
     1022  XML_FEATURE_ATTR_INFO
    9871023  /* Additional features must be added to the end of this enum. */
    9881024};
    … …  
    10041040*/
    10051041#define XML_MAJOR_VERSION 2
    1006 #define XML_MINOR_VERSION 0
     1042#define XML_MINOR_VERSION 1
    10071043#define XML_MICRO_VERSION 0
    10081044

  • python/vendor/current/Modules/expat/expat_external.h

    r2 r388  
    3939*/
    4040#ifndef XMLCALL
    41 #if defined(XML_USE_MSC_EXTENSIONS)
     41#if defined(_MSC_VER)
    4242#define XMLCALL __cdecl
    43 #elif defined(__GNUC__) && defined(__i386)
     43#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
    4444#define XMLCALL __attribute__((cdecl))
    4545#else

  • python/vendor/current/Modules/expat/internal.h

    r2 r388  
    2121*/
    2222
    23 #if defined(__GNUC__) && defined(__i386__)
     23#if defined(__GNUC__) && defined(__i386__) && !defined(__MINGW32__)
    2424/* We'll use this version by default only where we know it helps.
    2525

  • python/vendor/current/Modules/expat/pyexpatns.h

    r2 r388  
    9898#define XML_SetExternalEntityRefHandler PyExpat_XML_SetExternalEntityRefHandler
    9999#define XML_SetExternalEntityRefHandlerArg  PyExpat_XML_SetExternalEntityRefHandlerArg
     100#define XML_SetHashSalt                 PyExpat_XML_SetHashSalt
    100101#define XML_SetNamespaceDeclHandler     PyExpat_XML_SetNamespaceDeclHandler
    101102#define XML_SetNotationDeclHandler      PyExpat_XML_SetNotationDeclHandler

  • python/vendor/current/Modules/expat/xmlparse.c

    r2 r388  
    22   See the file COPYING for copying permission.
    33*/
     4
     5#include <stddef.h>
     6#include <string.h>                     /* memset(), memcpy() */
     7#include <assert.h>
     8#include <limits.h>                     /* UINT_MAX */
     9#include <time.h>                       /* time() */
    410
    511#define XML_BUILDING_EXPAT 1
    … …  
    915#elif defined(MACOS_CLASSIC)
    1016#include "macconfig.h"
    11 #elif defined(__amigaos4__)
     17#elif defined(__amigaos__)
    1218#include "amigaconfig.h"
     19#elif defined(__WATCOMC__)
     20#include "watcomconfig.h"
    1321#elif defined(HAVE_EXPAT_CONFIG_H)
    1422#include <expat_config.h>
    1523#endif /* ndef COMPILED_FROM_DSP */
    1624
    17 #include <stddef.h>
    18 #include <string.h>                     /* memset(), memcpy() */
    19 #include <assert.h>
    20 
     25#include "ascii.h"
    2126#include "expat.h"
    2227
    … …  
    2732#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
    2833#define XmlEncode XmlUtf16Encode
    29 #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))
     34/* Using pointer subtraction to convert to integer type. */
     35#define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((char *)(s) - (char *)NULL) & 1))
    3036typedef unsigned short ICHAR;
    3137#else
    … …  
    324330initializeEncoding(XML_Parser parser);
    325331static enum XML_Error
    326 doProlog(XML_Parser parser, const ENCODING *enc, const char *s, 
    327          const char *end, int tok, const char *next, const char **nextPtr, 
     332doProlog(XML_Parser parser, const ENCODING *enc, const char *s,
     333         const char *end, int tok, const char *next, const char **nextPtr,
    328334         XML_Bool haveMore);
    329335static enum XML_Error
    330 processInternalEntity(XML_Parser parser, ENTITY *entity, 
     336processInternalEntity(XML_Parser parser, ENTITY *entity,
    331337                      XML_Bool betweenDecl);
    332338static enum XML_Error
    333339doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
    334           const char *start, const char *end, const char **endPtr, 
     340          const char *start, const char *end, const char **endPtr,
    335341          XML_Bool haveMore);
    336342static enum XML_Error
    … …  
    350356           const XML_Char *uri, BINDING **bindingsPtr);
    351357static int
    352 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata, 
     358defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
    353359                XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);
    354360static enum XML_Error
    … …  
    388394dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);
    389395static int
    390 dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);
     396dtdCopy(XML_Parser oldParser,
     397        DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);
    391398static int
    392 copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
    393 
     399copyEntityTable(XML_Parser oldParser,
     400                HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
    394401static NAMED *
    395 lookup(HASH_TABLE *table, KEY name, size_t createSize);
     402lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize);
    396403static void FASTCALL
    397404hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);
    … …  
    426433               const char *ptr, const char *end);
    427434
     435static unsigned long generate_hash_secret_salt(void);
     436static XML_Bool startParsing(XML_Parser parser);
     437
    428438static XML_Parser
    429439parserCreate(const XML_Char *encodingName,
    … …  
    431441             const XML_Char *nameSep,
    432442             DTD *dtd);
     443
    433444static void
    434445parserInit(XML_Parser parser, const XML_Char *encodingName);
    … …  
    530541  unsigned long m_nsAttsVersion;
    531542  unsigned char m_nsAttsPower;
     543#ifdef XML_ATTR_INFO
     544  XML_AttrInfo *m_attInfo;
     545#endif
    532546  POSITION m_position;
    533547  STRING_POOL m_tempPool;
    … …  
    543557  enum XML_ParamEntityParsing m_paramEntityParsing;
    544558#endif
     559  unsigned long m_hash_secret_salt;
    545560};
    546561
    … …  
    637652#define nsAttsVersion (parser->m_nsAttsVersion)
    638653#define nsAttsPower (parser->m_nsAttsPower)
     654#define attInfo (parser->m_attInfo)
    639655#define tempPool (parser->m_tempPool)
    640656#define temp2Pool (parser->m_temp2Pool)
    … …  
    650666#define paramEntityParsing (parser->m_paramEntityParsing)
    651667#endif /* XML_DTD */
     668#define hash_secret_salt (parser->m_hash_secret_salt)
    652669
    653670XML_Parser XMLCALL
    … …  
    666683
    667684static const XML_Char implicitContext[] = {
    668   'x', 'm', 'l', '=', 'h', 't', 't', 'p', ':', '/', '/',
    669   'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',
    670   'X', 'M', 'L', '/', '1', '9', '9', '8', '/',
    671   'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'
     685  ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p,
     686  ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w,
     687  ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,
     688  ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9,
     689  ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,
     690  ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'
    672691};
     692
     693static unsigned long
     694generate_hash_secret_salt(void)
     695{
     696  unsigned int seed = time(NULL) % UINT_MAX;
     697  srand(seed);
     698  return rand();
     699}
     700
     701static XML_Bool  /* only valid for root parser */
     702startParsing(XML_Parser parser)
     703{
     704    /* hash functions must be initialized before setContext() is called */
     705    if (hash_secret_salt == 0)
     706      hash_secret_salt = generate_hash_secret_salt();
     707    if (ns) {
     708      /* implicit context only set for root parser, since child
     709         parsers (i.e. external entity parsers) will inherit it
     710      */
     711      return setContext(parser, implicitContext);
     712    }
     713    return XML_TRUE;
     714}
    673715
    674716XML_Parser XMLCALL
    … …  
    677719                    const XML_Char *nameSep)
    678720{
    679   XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);
    680   if (parser != NULL && ns) {
    681     /* implicit context only set for root parser, since child
    682        parsers (i.e. external entity parsers) will inherit it
    683     */
    684     if (!setContext(parser, implicitContext)) {
    685       XML_ParserFree(parser);
    686       return NULL;
    687     }
    688   }
    689   return parser;
     721  return parserCreate(encodingName, memsuite, nameSep, NULL);
    690722}
    691723
    … …  
    732764    return NULL;
    733765  }
     766#ifdef XML_ATTR_INFO
     767  attInfo = (XML_AttrInfo*)MALLOC(attsSize * sizeof(XML_AttrInfo));
     768  if (attInfo == NULL) {
     769    FREE(atts);
     770    FREE(parser);
     771    return NULL;
     772  }
     773#endif
    734774  dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
    735775  if (dataBuf == NULL) {
    736776    FREE(atts);
     777#ifdef XML_ATTR_INFO
     778    FREE(attInfo);
     779#endif
    737780    FREE(parser);
    738781    return NULL;
    … …  
    747790      FREE(dataBuf);
    748791      FREE(atts);
     792#ifdef XML_ATTR_INFO
     793      FREE(attInfo);
     794#endif
    749795      FREE(parser);
    750796      return NULL;
    … …  
    762808  unknownEncodingHandlerData = NULL;
    763809
    764   namespaceSeparator = '!';
     810  namespaceSeparator = ASCII_EXCL;
    765811  ns = XML_FALSE;
    766812  ns_triplets = XML_FALSE;
    … …  
    861907  paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
    862908#endif
     909  hash_secret_salt = 0;
    863910}
    864911
    … …  
    908955  parserInit(parser, encodingName);
    909956  dtdReset(_dtd, &parser->m_mem);
    910   return setContext(parser, implicitContext);
     957  return XML_TRUE;
    911958}
    912959
    … …  
    9771024#endif
    9781025  XML_Bool oldns_triplets = ns_triplets;
     1026  /* Note that the new parser shares the same hash secret as the old
     1027     parser, so that dtdCopy and copyEntityTable can lookup values
     1028     from hash tables associated with either parser without us having
     1029     to worry which hash secrets each table has.
     1030  */
     1031  unsigned long oldhash_secret_salt = hash_secret_salt;
    9791032
    9801033#ifdef XML_DTD
    … …  
    10301083  defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
    10311084  ns_triplets = oldns_triplets;
     1085  hash_secret_salt = oldhash_secret_salt;
    10321086  parentParser = oldParser;
    10331087#ifdef XML_DTD
    … …  
    10361090  if (context) {
    10371091#endif /* XML_DTD */
    1038     if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)
     1092    if (!dtdCopy(oldParser, _dtd, oldDtd, &parser->m_mem)
    10391093      || !setContext(parser, context)) {
    10401094      XML_ParserFree(parser);
    … …  
    11251179    dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);
    11261180  FREE((void *)atts);
     1181#ifdef XML_ATTR_INFO
     1182  FREE((void *)attInfo);
     1183#endif
    11271184  FREE(groupConnector);
    11281185  FREE(buffer);
    … …  
    12051262}
    12061263
     1264#ifdef XML_ATTR_INFO
     1265const XML_AttrInfo * XMLCALL
     1266XML_GetAttributeInfo(XML_Parser parser)
     1267{
     1268  return attInfo;
     1269}
     1270#endif
     1271
    12071272void XMLCALL
    12081273XML_SetElementHandler(XML_Parser parser,
    … …  
    14211486}
    14221487
     1488int XMLCALL
     1489XML_SetHashSalt(XML_Parser parser,
     1490                unsigned long hash_salt)
     1491{
     1492  /* block after XML_Parse()/XML_ParseBuffer() has been called */
     1493  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
     1494    return 0;
     1495  hash_secret_salt = hash_salt;
     1496  return 1;
     1497}
     1498
    14231499enum XML_Status XMLCALL
    14241500XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
    … …  
    14311507    errorCode = XML_ERROR_FINISHED;
    14321508    return XML_STATUS_ERROR;
     1509  case XML_INITIALIZED:
     1510    if (parentParser == NULL && !startParsing(parser)) {
     1511      errorCode = XML_ERROR_NO_MEMORY;
     1512      return XML_STATUS_ERROR;
     1513    }
    14331514  default:
    14341515    ps_parsing = XML_PARSING;
    … …  
    14541535        positionPtr = bufferPtr;
    14551536        return XML_STATUS_SUSPENDED;
    1456       case XML_INITIALIZED: 
     1537      case XML_INITIALIZED:
    14571538      case XML_PARSING:
    14581539        ps_parsing = XML_FINISHED;
    … …  
    14891570      case XML_INITIALIZED:
    14901571      case XML_PARSING:
    1491         result = XML_STATUS_OK;
    14921572        if (isFinal) {
    14931573          ps_parsing = XML_FINISHED;
    1494           return result;
    1495         }
     1574          return XML_STATUS_OK;
     1575        }
     1576      /* fall through */
     1577      default:
     1578        result = XML_STATUS_OK;
    14961579      }
    14971580    }
    … …  
    15081591        if (temp == NULL) {
    15091592          errorCode = XML_ERROR_NO_MEMORY;
    1510           return XML_STATUS_ERROR;
    1511         }
    1512         buffer = temp;
    1513         if (!buffer) {
    1514           errorCode = XML_ERROR_NO_MEMORY;
    15151593          eventPtr = eventEndPtr = NULL;
    15161594          processor = errorProcessor;
    15171595          return XML_STATUS_ERROR;
    15181596        }
     1597        buffer = temp;
    15191598        bufferLim = buffer + len * 2;
    15201599      }
    … …  
    15541633    errorCode = XML_ERROR_FINISHED;
    15551634    return XML_STATUS_ERROR;
     1635  case XML_INITIALIZED:
     1636    if (parentParser == NULL && !startParsing(parser)) {
     1637      errorCode = XML_ERROR_NO_MEMORY;
     1638      return XML_STATUS_ERROR;
     1639    }
    15561640  default:
    15571641    ps_parsing = XML_PARSING;
    … …  
    15771661      result = XML_STATUS_SUSPENDED;
    15781662      break;
    1579     case XML_INITIALIZED: 
     1663    case XML_INITIALIZED:
    15801664    case XML_PARSING:
    15811665      if (isFinal) {
    … …  
    16671751#endif  /* not defined XML_CONTEXT_BYTES */
    16681752    }
     1753    eventPtr = eventEndPtr = NULL;
     1754    positionPtr = NULL;
    16691755  }
    16701756  return bufferEnd;
    … …  
    17241810      result = XML_STATUS_SUSPENDED;
    17251811      break;
    1726     case XML_INITIALIZED: 
     1812    case XML_INITIALIZED:
    17271813    case XML_PARSING:
    17281814      if (ps_finalBuffer) {
    … …  
    19492035    {XML_FEATURE_NS,               XML_L("XML_NS"), 0},
    19502036#endif
     2037#ifdef XML_LARGE_SIZE
     2038    {XML_FEATURE_LARGE_SIZE,       XML_L("XML_LARGE_SIZE"), 0},
     2039#endif
     2040#ifdef XML_ATTR_INFO
     2041    {XML_FEATURE_ATTR_INFO,        XML_L("XML_ATTR_INFO"), 0},
     2042#endif
    19512043    {XML_FEATURE_END,              NULL, 0}
    19522044  };
    … …  
    20112103                 const char **endPtr)
    20122104{
    2013   enum XML_Error result = doContent(parser, 0, encoding, start, end, 
     2105  enum XML_Error result = doContent(parser, 0, encoding, start, end,
    20142106                                    endPtr, (XML_Bool)!ps_finalBuffer);
    20152107  if (result == XML_ERROR_NONE) {
    … …  
    20932185        return result;
    20942186      switch (ps_parsing) {
    2095       case XML_SUSPENDED: 
     2187      case XML_SUSPENDED:
    20962188        *endPtr = next;
    20972189        return XML_ERROR_NONE;
    … …  
    21272219                               const char **endPtr)
    21282220{
    2129   enum XML_Error result = doContent(parser, 1, encoding, start, end, 
     2221  enum XML_Error result = doContent(parser, 1, encoding, start, end,
    21302222                                    endPtr, (XML_Bool)!ps_finalBuffer);
    21312223  if (result == XML_ERROR_NONE) {
    … …  
    21462238{
    21472239  /* save one level of indirection */
    2148   DTD * const dtd = _dtd; 
     2240  DTD * const dtd = _dtd;
    21492241
    21502242  const char **eventPP;
    … …  
    21772269      else if (defaultHandler)
    21782270        reportDefault(parser, enc, s, end);
    2179       /* We are at the end of the final buffer, should we check for 
    2180          XML_SUSPENDED, XML_FINISHED? 
     2271      /* We are at the end of the final buffer, should we check for
     2272         XML_SUSPENDED, XML_FINISHED?
    21812273      */
    21822274      if (startTagLevel == 0)
    … …  
    22322324        if (!name)
    22332325          return XML_ERROR_NO_MEMORY;
    2234         entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
     2326        entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
    22352327        poolDiscard(&dtd->pool);
    22362328        /* First, determine if a check for an existing declaration is needed;
    … …  
    25292621      else if (defaultHandler)
    25302622        reportDefault(parser, enc, s, end);
    2531       /* We are at the end of the final buffer, should we check for 
    2532          XML_SUSPENDED, XML_FINISHED? 
     2623      /* We are at the end of the final buffer, should we check for
     2624         XML_SUSPENDED, XML_FINISHED?
    25332625      */
    25342626      if (startTagLevel == 0) {
    … …  
    25432635      return XML_ERROR_NONE;
    25442636    case XML_TOK_DATA_CHARS:
    2545       if (characterDataHandler) {
    2546         if (MUST_CONVERT(enc, s)) {
    2547           for (;;) {
    2548             ICHAR *dataPtr = (ICHAR *)dataBuf;
    2549             XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
    2550             *eventEndPP = s;
    2551             characterDataHandler(handlerArg, dataBuf,
    2552                                  (int)(dataPtr - (ICHAR *)dataBuf));
    2553             if (s == next)
    2554               break;
    2555             *eventPP = s;
     2637      {
     2638        XML_CharacterDataHandler charDataHandler = characterDataHandler;
     2639        if (charDataHandler) {
     2640          if (MUST_CONVERT(enc, s)) {
     2641            for (;;) {
     2642              ICHAR *dataPtr = (ICHAR *)dataBuf;
     2643              XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
     2644              *eventEndPP = s;
     2645              charDataHandler(handlerArg, dataBuf,
     2646                              (int)(dataPtr - (ICHAR *)dataBuf));
     2647              if (s == next)
     2648                break;
     2649              *eventPP = s;
     2650            }
    25562651          }
    2557         }
    2558         else
    2559           characterDataHandler(handlerArg,
    2560                                (XML_Char *)s,
    2561                                (int)((XML_Char *)next - (XML_Char *)s));
    2562       }
    2563       else if (defaultHandler)
    2564         reportDefault(parser, enc, s, next);
     2652          else
     2653            charDataHandler(handlerArg,
     2654                            (XML_Char *)s,
     2655                            (int)((XML_Char *)next - (XML_Char *)s));
     2656        }
     2657        else if (defaultHandler)
     2658          reportDefault(parser, enc, s, next);
     2659      }
    25652660      break;
    25662661    case XML_TOK_PI:
    … …  
    25792674    *eventPP = s = next;
    25802675    switch (ps_parsing) {
    2581     case XML_SUSPENDED: 
     2676    case XML_SUSPENDED:
    25822677      *nextPtr = next;
    25832678      return XML_ERROR_NONE;
    … …  
    26192714
    26202715  /* lookup the element type name */
    2621   elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, tagNamePtr->str,0);
     2716  elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str,0);
    26222717  if (!elementType) {
    26232718    const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
    26242719    if (!name)
    26252720      return XML_ERROR_NO_MEMORY;
    2626     elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, name,
     2721    elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
    26272722                                         sizeof(ELEMENT_TYPE));
    26282723    if (!elementType)
    … …  
    26382733    int oldAttsSize = attsSize;
    26392734    ATTRIBUTE *temp;
     2735#ifdef XML_ATTR_INFO
     2736    XML_AttrInfo *temp2;
     2737#endif
    26402738    attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
    26412739    temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
    … …  
    26432741      return XML_ERROR_NO_MEMORY;
    26442742    atts = temp;
     2743#ifdef XML_ATTR_INFO
     2744    temp2 = (XML_AttrInfo *)REALLOC((void *)attInfo, attsSize * sizeof(XML_AttrInfo));
     2745    if (temp2 == NULL)
     2746      return XML_ERROR_NO_MEMORY;
     2747    attInfo = temp2;
     2748#endif
    26452749    if (n > oldAttsSize)
    26462750      XmlGetAttributes(enc, attStr, n, atts);
    … …  
    26492753  appAtts = (const XML_Char **)atts;
    26502754  for (i = 0; i < n; i++) {
     2755    ATTRIBUTE *currAtt = &atts[i];
     2756#ifdef XML_ATTR_INFO
     2757    XML_AttrInfo *currAttInfo = &attInfo[i];
     2758#endif
    26512759    /* add the name and value to the attribute list */
    2652     ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
    2653                                          atts[i].name
    2654                                          + XmlNameLength(enc, atts[i].name));
     2760    ATTRIBUTE_ID *attId = getAttributeId(parser, enc, currAtt->name,
     2761                                         currAtt->name
     2762                                         + XmlNameLength(enc, currAtt->name));
    26552763    if (!attId)
    26562764      return XML_ERROR_NO_MEMORY;
     2765#ifdef XML_ATTR_INFO
     2766    currAttInfo->nameStart = parseEndByteIndex - (parseEndPtr - currAtt->name);
     2767    currAttInfo->nameEnd = currAttInfo->nameStart +
     2768                           XmlNameLength(enc, currAtt->name);
     2769    currAttInfo->valueStart = parseEndByteIndex -
     2770                            (parseEndPtr - currAtt->valuePtr);
     2771    currAttInfo->valueEnd = parseEndByteIndex - (parseEndPtr - currAtt->valueEnd);
     2772#endif
    26572773    /* Detect duplicate attributes by their QNames. This does not work when
    26582774       namespace processing is turned on and different prefixes for the same
    … …  
    27932909        ATTRIBUTE_ID *id;
    27942910        const BINDING *b;
    2795         unsigned long uriHash = 0;
     2911        unsigned long uriHash = hash_secret_salt;
    27962912        ((XML_Char *)s)[-1] = 0;  /* clear flag */
    2797         id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);
    2798         if (!id)
    2799           return XML_ERROR_NO_MEMORY;
     2913        id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
    28002914        b = id->prefix->binding;
    28012915        if (!b)
    … …  
    28092923          uriHash = CHAR_HASH(uriHash, c);
    28102924        }
    2811         while (*s++ != XML_T(':'))
     2925        while (*s++ != XML_T(ASCII_COLON))
    28122926          ;
    28132927        do {  /* copies null terminator */
    … …  
    28192933
    28202934        { /* Check hash table for duplicate of expanded name (uriName).
    2821              Derived from code in lookup(HASH_TABLE *table, ...).
     2935             Derived from code in lookup(parser, HASH_TABLE *table, ...).
    28222936          */
    28232937          unsigned char step = 0;
    … …  
    28832997      return XML_ERROR_UNBOUND_PREFIX;
    28842998    localPart = tagNamePtr->str;
    2885     while (*localPart++ != XML_T(':'))
     2999    while (*localPart++ != XML_T(ASCII_COLON))
    28863000      ;
    28873001  }
    … …  
    29383052{
    29393053  static const XML_Char xmlNamespace[] = {
    2940     'h', 't', 't', 'p', ':', '/', '/',
    2941     'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',
    2942     'X', 'M', 'L', '/', '1', '9', '9', '8', '/',
    2943     'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'
     3054    ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
     3055    ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
     3056    ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L,
     3057    ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ASCII_8, ASCII_SLASH,
     3058    ASCII_n, ASCII_a, ASCII_m, ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c,
     3059    ASCII_e, '\0'
    29443060  };
    2945   static const int xmlLen = 
     3061  static const int xmlLen =
    29463062    (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;
    29473063  static const XML_Char xmlnsNamespace[] = {
    2948     'h', 't', 't', 'p', ':', '/', '/',
    2949     'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',
    2950     '2', '0', '0', '0', '/', 'x', 'm', 'l', 'n', 's', '/', '\0'
     3064    ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
     3065    ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
     3066    ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0,
     3067    ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,
     3068    ASCII_SLASH, '\0'
    29513069  };
    2952   static const int xmlnsLen = 
     3070  static const int xmlnsLen =
    29533071    (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;
    29543072
    … …  
    29563074  XML_Bool isXML = XML_TRUE;
    29573075  XML_Bool isXMLNS = XML_TRUE;
    2958  
     3076
    29593077  BINDING *b;
    29603078  int len;
    … …  
    29653083
    29663084  if (prefix->name
    2967       && prefix->name[0] == XML_T('x')
    2968       && prefix->name[1] == XML_T('m')
    2969       && prefix->name[2] == XML_T('l')) {
     3085      && prefix->name[0] == XML_T(ASCII_x)
     3086      && prefix->name[1] == XML_T(ASCII_m)
     3087      && prefix->name[2] == XML_T(ASCII_l)) {
    29703088
    29713089    /* Not allowed to bind xmlns */
    2972     if (prefix->name[3] == XML_T('n')
    2973         && prefix->name[4] == XML_T('s')
     3090    if (prefix->name[3] == XML_T(ASCII_n)
     3091        && prefix->name[4] == XML_T(ASCII_s)
    29743092        && prefix->name[5] == XML_T('\0'))
    29753093      return XML_ERROR_RESERVED_PREFIX_XMLNS;
    … …  
    29833101      isXML = XML_FALSE;
    29843102
    2985     if (!mustBeXML && isXMLNS 
     3103    if (!mustBeXML && isXMLNS
    29863104        && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
    29873105      isXMLNS = XML_FALSE;
    … …  
    31253243      break;
    31263244    case XML_TOK_DATA_CHARS:
    3127       if (characterDataHandler) {
    3128         if (MUST_CONVERT(enc, s)) {
    3129           for (;;) {
    3130             ICHAR *dataPtr = (ICHAR *)dataBuf;
    3131             XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
    3132             *eventEndPP = next;
    3133             characterDataHandler(handlerArg, dataBuf,
    3134                                  (int)(dataPtr - (ICHAR *)dataBuf));
    3135             if (s == next)
    3136               break;
    3137             *eventPP = s;
     3245      {
     3246        XML_CharacterDataHandler charDataHandler = characterDataHandler;
     3247        if (charDataHandler) {
     3248          if (MUST_CONVERT(enc, s)) {
     3249            for (;;) {
     3250              ICHAR *dataPtr = (ICHAR *)dataBuf;
     3251              XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
     3252              *eventEndPP = next;
     3253              charDataHandler(handlerArg, dataBuf,
     3254                              (int)(dataPtr - (ICHAR *)dataBuf));
     3255              if (s == next)
     3256                break;
     3257              *eventPP = s;
     3258            }
    31383259          }
    3139         }
    3140         else
    3141           characterDataHandler(handlerArg,
    3142                                (XML_Char *)s,
    3143                                (int)((XML_Char *)next - (XML_Char *)s));
    3144       }
    3145       else if (defaultHandler)
    3146         reportDefault(parser, enc, s, next);
     3260          else
     3261            charDataHandler(handlerArg,
     3262                            (XML_Char *)s,
     3263                            (int)((XML_Char *)next - (XML_Char *)s));
     3264        }
     3265        else if (defaultHandler)
     3266          reportDefault(parser, enc, s, next);
     3267      }
    31473268      break;
    31483269    case XML_TOK_INVALID:
    … …  
    31913312                       const char **endPtr)
    31923313{
    3193   enum XML_Error result = doIgnoreSection(parser, encoding, &start, end, 
     3314  enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,
    31943315                                          endPtr, (XML_Bool)!ps_finalBuffer);
    31953316  if (result != XML_ERROR_NONE)
    … …  
    34733594  eventPtr = start;
    34743595
    3475   for (;;) { 
     3596  for (;;) {
    34763597    tok = XmlPrologTok(encoding, start, end, &next);
    34773598    eventEndPtr = next;
    … …  
    35013622        return result;
    35023623      switch (ps_parsing) {
    3503       case XML_SUSPENDED: 
     3624      case XML_SUSPENDED:
    35043625        *nextPtr = next;
    35053626        return XML_ERROR_NONE;
    … …  
    35663687
    35673688  processor = prologProcessor;
    3568   return doProlog(parser, encoding, s, end, tok, next, 
     3689  return doProlog(parser, encoding, s, end, tok, next,
    35693690                  nextPtr, (XML_Bool)!ps_finalBuffer);
    35703691}
    … …  
    36163737  const char *next = s;
    36173738  int tok = XmlPrologTok(encoding, s, end, &next);
    3618   return doProlog(parser, encoding, s, end, tok, next, 
     3739  return doProlog(parser, encoding, s, end, tok, next,
    36193740                  nextPtr, (XML_Bool)!ps_finalBuffer);
    36203741}
    … …  
    36313752{
    36323753#ifdef XML_DTD
    3633   static const XML_Char externalSubsetName[] = { '#' , '\0' };
     3754  static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };
    36343755#endif /* XML_DTD */
    3635   static const XML_Char atypeCDATA[] = { 'C', 'D', 'A', 'T', 'A', '\0' };
    3636   static const XML_Char atypeID[] = { 'I', 'D', '\0' };
    3637   static const XML_Char atypeIDREF[] = { 'I', 'D', 'R', 'E', 'F', '\0' };
    3638   static const XML_Char atypeIDREFS[] = { 'I', 'D', 'R', 'E', 'F', 'S', '\0' };
    3639   static const XML_Char atypeENTITY[] = { 'E', 'N', 'T', 'I', 'T', 'Y', '\0' };
    3640   static const XML_Char atypeENTITIES[] =
    3641       { 'E', 'N', 'T', 'I', 'T', 'I', 'E', 'S', '\0' };
     3756  static const XML_Char atypeCDATA[] =
     3757      { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
     3758  static const XML_Char atypeID[] = { ASCII_I, ASCII_D, '\0' };
     3759  static const XML_Char atypeIDREF[] =
     3760      { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
     3761  static const XML_Char atypeIDREFS[] =
     3762      { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
     3763  static const XML_Char atypeENTITY[] =
     3764      { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
     3765  static const XML_Char atypeENTITIES[] = { ASCII_E, ASCII_N,
     3766      ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
    36423767  static const XML_Char atypeNMTOKEN[] = {
    3643       'N', 'M', 'T', 'O', 'K', 'E', 'N', '\0' };
    3644   static const XML_Char atypeNMTOKENS[] = {
    3645       'N', 'M', 'T', 'O', 'K', 'E', 'N', 'S', '\0' };
    3646   static const XML_Char notationPrefix[] = {
    3647       'N', 'O', 'T', 'A', 'T', 'I', 'O', 'N', '(', '\0' };
    3648   static const XML_Char enumValueSep[] = { '|', '\0' };
    3649   static const XML_Char enumValueStart[] = { '(', '\0' };
     3768      ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
     3769  static const XML_Char atypeNMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T,
     3770      ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
     3771  static const XML_Char notationPrefix[] = { ASCII_N, ASCII_O, ASCII_T,
     3772      ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0' };
     3773  static const XML_Char enumValueSep[] = { ASCII_PIPE, '\0' };
     3774  static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };
    36503775
    36513776  /* save one level of indirection */
    3652   DTD * const dtd = _dtd; 
     3777  DTD * const dtd = _dtd;
    36533778
    36543779  const char **eventPP;
    … …  
    37573882#ifdef XML_DTD
    37583883      useForeignDTD = XML_FALSE;
    3759       declEntity = (ENTITY *)lookup(&dtd->paramEntities,
     3884      declEntity = (ENTITY *)lookup(parser,
     3885                                    &dtd->paramEntities,
    37603886                                    externalSubsetName,
    37613887                                    sizeof(ENTITY));
    … …  
    37653891      dtd->hasParamEntityRefs = XML_TRUE;
    37663892      if (startDoctypeDeclHandler) {
     3893        XML_Char *pubId;
    37673894        if (!XmlIsPublicId(enc, s, next, eventPP))
    37683895          return XML_ERROR_PUBLICID;
    3769         doctypePubid = poolStoreString(&tempPool, enc,
    3770                                        s + enc->minBytesPerChar,
    3771                                        next - enc->minBytesPerChar);
    3772         if (!doctypePubid)
     3896        pubId = poolStoreString(&tempPool, enc,
     3897                                s + enc->minBytesPerChar,
     3898                                next - enc->minBytesPerChar);
     3899        if (!pubId)
    37733900          return XML_ERROR_NO_MEMORY;
    3774         normalizePublicId((XML_Char *)doctypePubid);
     3901        normalizePublicId(pubId);
    37753902        poolFinish(&tempPool);
     3903        doctypePubid = pubId;
    37763904        handleDefault = XML_FALSE;
    37773905        goto alreadyChecked;
    … …  
    38123940        dtd->hasParamEntityRefs = XML_TRUE;
    38133941        if (paramEntityParsing && externalEntityRefHandler) {
    3814           ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
     3942          ENTITY *entity = (ENTITY *)lookup(parser,
     3943                                            &dtd->paramEntities,
    38153944                                            externalSubsetName,
    38163945                                            sizeof(ENTITY));
    … …  
    38273956            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
    38283957          if (dtd->paramEntityRead) {
    3829             if (!dtd->standalone && 
    3830                 notStandaloneHandler && 
     3958            if (!dtd->standalone &&
     3959                notStandaloneHandler &&
    38313960                !notStandaloneHandler(handlerArg))
    38323961              return XML_ERROR_NOT_STANDALONE;
    … …  
    38563985        dtd->hasParamEntityRefs = XML_TRUE;
    38573986        if (paramEntityParsing && externalEntityRefHandler) {
    3858           ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
     3987          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
    38593988                                            externalSubsetName,
    38603989                                            sizeof(ENTITY));
    … …  
    39564085          return XML_ERROR_NO_MEMORY;
    39574086        if (attlistDeclHandler && declAttributeType) {
    3958           if (*declAttributeType == XML_T('(')
    3959               || (*declAttributeType == XML_T('N')
    3960                   && declAttributeType[1] == XML_T('O'))) {
     4087          if (*declAttributeType == XML_T(ASCII_LPAREN)
     4088              || (*declAttributeType == XML_T(ASCII_N)
     4089                  && declAttributeType[1] == XML_T(ASCII_O))) {
    39614090            /* Enumerated or Notation type */
    3962             if (!poolAppendChar(&tempPool, XML_T(')'))
     4091            if (!poolAppendChar(&tempPool, XML_T(ASCII_RPAREN))
    39634092                || !poolAppendChar(&tempPool, XML_T('\0')))
    39644093              return XML_ERROR_NO_MEMORY;
    … …  
    39934122          return XML_ERROR_NO_MEMORY;
    39944123        if (attlistDeclHandler && declAttributeType) {
    3995           if (*declAttributeType == XML_T('(')
    3996               || (*declAttributeType == XML_T('N')
    3997                   && declAttributeType[1] == XML_T('O'))) {
     4124          if (*declAttributeType == XML_T(ASCII_LPAREN)
     4125              || (*declAttributeType == XML_T(ASCII_N)
     4126                  && declAttributeType[1] == XML_T(ASCII_O))) {
    39984127            /* Enumerated or Notation type */
    3999             if (!poolAppendChar(&tempPool, XML_T(')'))
     4128            if (!poolAppendChar(&tempPool, XML_T(ASCII_RPAREN))
    40004129                || !poolAppendChar(&tempPool, XML_T('\0')))
    40014130              return XML_ERROR_NO_MEMORY;
    … …  
    40704199#else /* XML_DTD */
    40714200      if (!declEntity) {
    4072         declEntity = (ENTITY *)lookup(&dtd->paramEntities,
     4201        declEntity = (ENTITY *)lookup(parser,
     4202                                      &dtd->paramEntities,
    40734203                                      externalSubsetName,
    40744204                                      sizeof(ENTITY));
    … …  
    41454275          if (!name)
    41464276            return XML_ERROR_NO_MEMORY;
    4147           declEntity = (ENTITY *)lookup(&dtd->generalEntities, name,
     4277          declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities, name,
    41484278                                        sizeof(ENTITY));
    41494279          if (!declEntity)
    … …  
    41774307        if (!name)
    41784308          return XML_ERROR_NO_MEMORY;
    4179         declEntity = (ENTITY *)lookup(&dtd->paramEntities,
     4309        declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
    41804310                                           name, sizeof(ENTITY));
    41814311        if (!declEntity)
    … …  
    42664396      case XML_TOK_PARAM_ENTITY_REF:
    42674397        /* PE references in internal subset are
    4268            not allowed within declarations. */ 
     4398           not allowed within declarations. */
    42694399        return XML_ERROR_PARAM_ENTITY_REF;
    42704400      case XML_TOK_XML_DECL:
    … …  
    43244454      break;
    43254455    case XML_ROLE_GROUP_SEQUENCE:
    4326       if (groupConnector[prologState.level] == '|')
     4456      if (groupConnector[prologState.level] == ASCII_PIPE)
    43274457        return XML_ERROR_SYNTAX;
    4328       groupConnector[prologState.level] = ',';
     4458      groupConnector[prologState.level] = ASCII_COMMA;
    43294459      if (dtd->in_eldecl && elementDeclHandler)
    43304460        handleDefault = XML_FALSE;
    43314461      break;
    43324462    case XML_ROLE_GROUP_CHOICE:
    4333       if (groupConnector[prologState.level] == ',')
     4463      if (groupConnector[prologState.level] == ASCII_COMMA)
    43344464        return XML_ERROR_SYNTAX;
    43354465      if (dtd->in_eldecl
    … …  
    43434473          handleDefault = XML_FALSE;
    43444474      }
    4345       groupConnector[prologState.level] = '|';
     4475      groupConnector[prologState.level] = ASCII_PIPE;
    43464476      break;
    43474477    case XML_ROLE_PARAM_ENTITY_REF:
    … …  
    43594489        if (!name)
    43604490          return XML_ERROR_NO_MEMORY;
    4361         entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
     4491        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
    43624492        poolDiscard(&dtd->pool);
    43634493        /* first, determine if a check for an existing declaration is needed;
    … …  
    43874517        if (entity->textPtr) {
    43884518          enum XML_Error result;
    4389           XML_Bool betweenDecl = 
     4519          XML_Bool betweenDecl =
    43904520            (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
    43914521          result = processInternalEntity(parser, entity, betweenDecl);
    … …  
    45824712
    45834713    switch (ps_parsing) {
    4584     case XML_SUSPENDED: 
     4714    case XML_SUSPENDED:
    45854715      *nextPtr = next;
    45864716      return XML_ERROR_NONE;
    … …  
    46524782    eventPtr = s = next;
    46534783    switch (ps_parsing) {
    4654     case XML_SUSPENDED: 
     4784    case XML_SUSPENDED:
    46554785      *nextPtr = next;
    46564786      return XML_ERROR_NONE;
    … …  
    46954825  if (entity->is_param) {
    46964826    int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
    4697     result = doProlog(parser, internalEncoding, textStart, textEnd, tok, 
     4827    result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
    46984828                      next, &next, XML_FALSE);
    46994829  }
    4700   else 
     4830  else
    47014831#endif /* XML_DTD */
    4702     result = doContent(parser, tagLevel, internalEncoding, textStart, 
     4832    result = doContent(parser, tagLevel, internalEncoding, textStart,
    47034833                       textEnd, &next, XML_FALSE);
    47044834
    … …  
    47404870  if (entity->is_param) {
    47414871    int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
    4742     result = doProlog(parser, internalEncoding, textStart, textEnd, tok, 
     4872    result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
    47434873                      next, &next, XML_FALSE);
    47444874  }
    47454875  else
    47464876#endif /* XML_DTD */
    4747     result = doContent(parser, openEntity->startTagLevel, internalEncoding, 
    4748                        textStart, textEnd, &next, XML_FALSE); 
     4877    result = doContent(parser, openEntity->startTagLevel, internalEncoding,
     4878                       textStart, textEnd, &next, XML_FALSE);
    47494879
    47504880  if (result != XML_ERROR_NONE)
    … …  
    47674897    processor = prologProcessor;
    47684898    tok = XmlPrologTok(encoding, s, end, &next);
    4769     return doProlog(parser, encoding, s, end, tok, next, nextPtr, 
     4899    return doProlog(parser, encoding, s, end, tok, next, nextPtr,
    47704900                    (XML_Bool)!ps_finalBuffer);
    47714901  }
    … …  
    47764906    /* see externalEntityContentProcessor vs contentProcessor */
    47774907    return doContent(parser, parentParser ? 1 : 0, encoding, s, end,
    4778                      nextPtr, (XML_Bool)!ps_finalBuffer); 
    4779   } 
     4908                     nextPtr, (XML_Bool)!ps_finalBuffer);
     4909  }
    47804910}
    47814911
    … …  
    48835013        if (!name)
    48845014          return XML_ERROR_NO_MEMORY;
    4885         entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
     5015        entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
    48865016        poolDiscard(&temp2Pool);
    48875017        /* First, determine if a check for an existing declaration is needed;
    … …  
    49305060          if (enc == encoding)
    49315061            eventPtr = ptr;
    4932               return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
     5062          return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
    49335063        }
    49345064        else {
    … …  
    49925122          goto endEntityValue;
    49935123        }
    4994         entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
     5124        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
    49955125        poolDiscard(&tempPool);
    49965126        if (!entity) {
    … …  
    52735403  const XML_Char *name;
    52745404  for (name = elementType->name; *name; name++) {
    5275     if (*name == XML_T(':')) {
     5405    if (*name == XML_T(ASCII_COLON)) {
    52765406      PREFIX *prefix;
    52775407      const XML_Char *s;
    … …  
    52825412      if (!poolAppendChar(&dtd->pool, XML_T('\0')))
    52835413        return 0;
    5284       prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
     5414      prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
    52855415                                sizeof(PREFIX));
    52865416      if (!prefix)
    … …  
    53115441  /* skip quotation mark - its storage will be re-used (like in name[-1]) */
    53125442  ++name;
    5313   id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
     5443  id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
    53145444  if (!id)
    53155445    return NULL;
    … …  
    53205450    if (!ns)
    53215451      ;
    5322     else if (name[0] == XML_T('x')
    5323         && name[1] == XML_T('m')
    5324         && name[2] == XML_T('l')
    5325         && name[3] == XML_T('n')
    5326         && name[4] == XML_T('s')
    5327         && (name[5] == XML_T('\0') || name[5] == XML_T(':'))) {
     5452    else if (name[0] == XML_T(ASCII_x)
     5453        && name[1] == XML_T(ASCII_m)
     5454        && name[2] == XML_T(ASCII_l)
     5455        && name[3] == XML_T(ASCII_n)
     5456        && name[4] == XML_T(ASCII_s)
     5457        && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
    53285458      if (name[5] == XML_T('\0'))
    53295459        id->prefix = &dtd->defaultPrefix;
    53305460      else
    5331         id->prefix = (PREFIX *)lookup(&dtd->prefixes, name + 6, sizeof(PREFIX));
     5461        id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6, sizeof(PREFIX));
    53325462      id->xmlns = XML_TRUE;
    53335463    }
    … …  
    53365466      for (i = 0; name[i]; i++) {
    53375467        /* attributes without prefix are *not* in the default namespace */
    5338         if (name[i] == XML_T(':')) {
     5468        if (name[i] == XML_T(ASCII_COLON)) {
    53395469          int j;
    53405470          for (j = 0; j < i; j++) {
    … …  
    53445474          if (!poolAppendChar(&dtd->pool, XML_T('\0')))
    53455475            return NULL;
    5346           id->prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
     5476          id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
    53475477                                        sizeof(PREFIX));
    5348           if (!id->prefix)
    5349             return NULL;
    53505478          if (id->prefix->name == poolStart(&dtd->pool))
    53515479            poolFinish(&dtd->pool);
    … …  
    53605488}
    53615489
    5362 #define CONTEXT_SEP XML_T('\f')
     5490#define CONTEXT_SEP XML_T(ASCII_FF)
    53635491
    53645492static const XML_Char *
    … …  
    53725500    int i;
    53735501    int len;
    5374     if (!poolAppendChar(&tempPool, XML_T('=')))
     5502    if (!poolAppendChar(&tempPool, XML_T(ASCII_EQUALS)))
    53755503      return NULL;
    53765504    len = dtd->defaultPrefix.binding->uriLen;
    … …  
    53985526      if (!poolAppendChar(&tempPool, *s))
    53995527        return NULL;
    5400     if (!poolAppendChar(&tempPool, XML_T('=')))
     5528    if (!poolAppendChar(&tempPool, XML_T(ASCII_EQUALS)))
    54015529      return NULL;
    54025530    len = prefix->binding->uriLen;
    … …  
    54425570      if (!poolAppendChar(&tempPool, XML_T('\0')))
    54435571        return XML_FALSE;
    5444       e = (ENTITY *)lookup(&dtd->generalEntities, poolStart(&tempPool), 0);
     5572      e = (ENTITY *)lookup(parser, &dtd->generalEntities, poolStart(&tempPool), 0);
    54455573      if (e)
    54465574        e->open = XML_TRUE;
    … …  
    54505578      poolDiscard(&tempPool);
    54515579    }
    5452     else if (*s == XML_T('=')) {
     5580    else if (*s == XML_T(ASCII_EQUALS)) {
    54535581      PREFIX *prefix;
    54545582      if (poolLength(&tempPool) == 0)
    … …  
    54575585        if (!poolAppendChar(&tempPool, XML_T('\0')))
    54585586          return XML_FALSE;
    5459         prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&tempPool),
     5587        prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&tempPool),
    54605588                                  sizeof(PREFIX));
    54615589        if (!prefix)
    … …  
    56215749*/
    56225750static int
    5623 dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
     5751dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
    56245752{
    56255753  HASH_TABLE_ITER iter;
    … …  
    56365764    if (!name)
    56375765      return 0;
    5638     if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))
     5766    if (!lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
    56395767      return 0;
    56405768  }
    … …  
    56585786      return 0;
    56595787    ++name;
    5660     newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name,
     5788    newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
    56615789                                  sizeof(ATTRIBUTE_ID));
    56625790    if (!newA)
    … …  
    56685796        newA->prefix = &newDtd->defaultPrefix;
    56695797      else
    5670         newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes),
     5798        newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
    56715799                                        oldA->prefix->name, 0);
    56725800    }
    … …  
    56875815    if (!name)
    56885816      return 0;
    5689     newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name,
     5817    newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
    56905818                                  sizeof(ELEMENT_TYPE));
    56915819    if (!newE)
    … …  
    57015829    if (oldE->idAtt)
    57025830      newE->idAtt = (ATTRIBUTE_ID *)
    5703           lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);
     5831          lookup(oldParser, &(newDtd->attributeIds), oldE->idAtt->name, 0);
    57045832    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
    57055833    if (oldE->prefix)
    5706       newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes),
     5834      newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
    57075835                                      oldE->prefix->name, 0);
    57085836    for (i = 0; i < newE->nDefaultAtts; i++) {
    57095837      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)
    5710           lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
     5838          lookup(oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
    57115839      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
    57125840      if (oldE->defaultAtts[i].value) {
    … …  
    57225850
    57235851  /* Copy the entity tables. */
    5724   if (!copyEntityTable(&(newDtd->generalEntities),
     5852  if (!copyEntityTable(oldParser,
     5853                       &(newDtd->generalEntities),
    57255854                       &(newDtd->pool),
    57265855                       &(oldDtd->generalEntities)))
    … …  
    57285857
    57295858#ifdef XML_DTD
    5730   if (!copyEntityTable(&(newDtd->paramEntities),
     5859  if (!copyEntityTable(oldParser,
     5860                       &(newDtd->paramEntities),
    57315861                       &(newDtd->pool),
    57325862                       &(oldDtd->paramEntities)))
    … …  
    57515881
    57525882static int
    5753 copyEntityTable(HASH_TABLE *newTable,
     5883copyEntityTable(XML_Parser oldParser,
     5884                HASH_TABLE *newTable,
    57545885                STRING_POOL *newPool,
    57555886                const HASH_TABLE *oldTable)
    … …  
    57705901    if (!name)
    57715902      return 0;
    5772     newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY));
     5903    newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
    57735904    if (!newE)
    57745905      return 0;
    … …  
    58285959
    58295960static unsigned long FASTCALL
    5830 hash(KEY s)
    5831 {
    5832   unsigned long h = 0;
     5961hash(XML_Parser parser, KEY s)
     5962{
     5963  unsigned long h = hash_secret_salt;
    58335964  while (*s)
    58345965    h = CHAR_HASH(h, *s++);
    … …  
    58375968
    58385969static NAMED *
    5839 lookup(HASH_TABLE *table, KEY name, size_t createSize)
     5970lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
    58405971{
    58415972  size_t i;
    … …  
    58545985    }
    58555986    memset(table->v, 0, tsize);
    5856     i = hash(name) & ((unsigned long)table->size - 1);
     5987    i = hash(parser, name) & ((unsigned long)table->size - 1);
    58575988  }
    58585989  else {
    5859     unsigned long h = hash(name);
     5990    unsigned long h = hash(parser, name);
    58605991    unsigned long mask = (unsigned long)table->size - 1;
    58615992    unsigned char step = 0;
    … …  
    58836014      for (i = 0; i < table->size; i++)
    58846015        if (table->v[i]) {
    5885           unsigned long newHash = hash(table->v[i]->name);
     6016          unsigned long newHash = hash(parser, table->v[i]->name);
    58866017          size_t j = newHash & newMask;
    58876018          step = 0;
    … …  
    61046235  if (pool->blocks && pool->start == pool->blocks->s) {
    61056236    int blockSize = (int)(pool->end - pool->start)*2;
    6106     pool->blocks = (BLOCK *)
     6237    BLOCK *temp = (BLOCK *)
    61076238      pool->mem->realloc_fcn(pool->blocks,
    61086239                             (offsetof(BLOCK, s)
    61096240                              + blockSize * sizeof(XML_Char)));
    6110     if (pool->blocks == NULL)
     6241    if (temp == NULL)
    61116242      return XML_FALSE;
     6243    pool->blocks = temp;
    61126244    pool->blocks->size = blockSize;
    61136245    pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
    … …  
    62586390  if (!name)
    62596391    return NULL;
    6260   ret = (ELEMENT_TYPE *) lookup(&dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
     6392  ret = (ELEMENT_TYPE *) lookup(parser, &dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
    62616393  if (!ret)
    62626394    return NULL;

  • python/vendor/current/Modules/expat/xmlrole.c

    r2 r388  
    22   See the file COPYING for copying permission.
    33*/
     4
     5#include <stddef.h>
    46
    57#ifdef COMPILED_FROM_DSP
    … …  
    79#elif defined(MACOS_CLASSIC)
    810#include "macconfig.h"
    9 #elif defined(__amigaos4__)
     11#elif defined(__amigaos__)
    1012#include "amigaconfig.h"
     13#elif defined(__WATCOMC__)
     14#include "watcomconfig.h"
    1115#else
    1216#ifdef HAVE_EXPAT_CONFIG_H
    … …  
    1418#endif
    1519#endif /* ndef COMPILED_FROM_DSP */
    16 
    17 #include <stddef.h>
    1820
    1921#include "expat_external.h"
    … …  
    5456static const char KW_IDREFS[] = {
    5557    ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
     58#ifdef XML_DTD
    5659static const char KW_IGNORE[] = {
    5760    ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
     61#endif
    5862static const char KW_IMPLIED[] = {
    5963    ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
     64#ifdef XML_DTD
    6065static const char KW_INCLUDE[] = {
    6166    ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
     67#endif
    6268static const char KW_NDATA[] = {
    6369    ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };

  • python/vendor/current/Modules/expat/xmltok.c

    r2 r388  
    22   See the file COPYING for copying permission.
    33*/
     4
     5#include <stddef.h>
    46
    57#ifdef COMPILED_FROM_DSP
    … …  
    79#elif defined(MACOS_CLASSIC)
    810#include "macconfig.h"
    9 #elif defined(__amigaos4__)
     11#elif defined(__amigaos__)
    1012#include "amigaconfig.h"
     13#elif defined(__WATCOMC__)
     14#include "watcomconfig.h"
    1115#else
    1216#ifdef HAVE_EXPAT_CONFIG_H
    … …  
    1418#endif
    1519#endif /* ndef COMPILED_FROM_DSP */
    16 
    17 #include <stddef.h>
    1820
    1921#include "expat_external.h"
    … …  
    296298
    297299#define PREFIX(ident) normal_ ## ident
     300#define XML_TOK_IMPL_C
    298301#include "xmltok_impl.c"
     302#undef XML_TOK_IMPL_C
    299303
    300304#undef MINBPC
    … …  
    693697#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
    694698
     699#define XML_TOK_IMPL_C
    695700#include "xmltok_impl.c"
     701#undef XML_TOK_IMPL_C
    696702
    697703#undef MINBPC
    … …  
    832838#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
    833839
     840#define XML_TOK_IMPL_C
    834841#include "xmltok_impl.c"
     842#undef XML_TOK_IMPL_C
    835843
    836844#undef MINBPC
    … …  
    13381346XmlInitUnknownEncoding(void *mem,
    13391347                       int *table,
    1340                        CONVERTER convert, 
     1348                       CONVERTER convert,
    13411349                       void *userData)
    13421350{
    … …  
    15771585        /* 0 isn't a legal data character. Furthermore a document
    15781586           entity can only start with ASCII characters.  So the only
    1579            way this can fail to be big-endian UTF-16 if it it's an
     1587           way this can fail to be big-endian UTF-16 is if it is an
    15801588           external parsed general entity that's labelled as
    15811589           UTF-16LE.
    … …  
    16111619#define NS(x) x
    16121620#define ns(x) x
     1621#define XML_TOK_NS_C
    16131622#include "xmltok_ns.c"
     1623#undef XML_TOK_NS_C
    16141624#undef NS
    16151625#undef ns
    … …  
    16201630#define ns(x) x ## _ns
    16211631
     1632#define XML_TOK_NS_C
    16221633#include "xmltok_ns.c"
     1634#undef XML_TOK_NS_C
    16231635
    16241636#undef NS
    … …  
    16281640XmlInitUnknownEncodingNS(void *mem,
    16291641                         int *table,
    1630                          CONVERTER convert, 
     1642                         CONVERTER convert,
    16311643                         void *userData)
    16321644{

  • python/vendor/current/Modules/expat/xmltok_impl.c

    r2 r388  
    22   See the file COPYING for copying permission.
    33*/
     4
     5/* This file is included! */
     6#ifdef XML_TOK_IMPL_C
    47
    58#ifndef IS_INVALID_CHAR
    … …  
    883886{
    884887  if (ptr == end)
    885     return -XML_TOK_PERCENT;
     888    return XML_TOK_PARTIAL;
    886889  switch (BYTE_TYPE(enc, ptr)) {
    887890  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    … …  
    17781781#undef CHECK_NMSTRT_CASES
    17791782
     1783#endif /* XML_TOK_IMPL_C */

  • python/vendor/current/Modules/expat/xmltok_ns.c

    r2 r388  
     1/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
     2   See the file COPYING for copying permission.
     3*/
     4
     5/* This file is included! */
     6#ifdef XML_TOK_NS_C
     7
    18const ENCODING *
    29NS(XmlGetUtf8InternalEncoding)(void)
    … …  
    105112                        standalone);
    106113}
     114
     115#endif /* XML_TOK_NS_C */
Note: See TracChangeset for help on using the changeset viewer.