Main Page | Class List | Directories | File List | Class Members | File Members
extensions » expat » lib

xmltok_impl.c File Reference

Go to the source code of this file.

Defines

#define IS_INVALID_CHAR(enc, ptr, n)   (0)
#define INVALID_LEAD_CASE(n, ptr, nextTokPtr)
#define INVALID_CASES(ptr, nextTokPtr)
#define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr)
#define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
#define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr)
#define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
#define PREFIX(ident)   ident
#define LEAD_CASE(n)
#define START_NAME

Variables

static int PTRCALL PREFIX( scanComment )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanDecl )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( checkPiTarget )(const ENCODING *enc, const char *ptr, const char *end, int *tokPtr)
static int PTRCALL PREFIX( scanPi )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanCdataSection )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( cdataSectionTok )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanEndTag )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanHexCharRef )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanCharRef )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanRef )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanAtts )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanLt )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( contentTok )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanPercent )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanPoundName )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( scanLit )(int open, const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( prologTok )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( attributeValueTok )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( entityValueTok )(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr)
static int PTRCALL PREFIX( isPublicId )(const ENCODING *enc, const char *ptr, const char *end, const char **badPtr)
static int PTRCALL PREFIX( getAtts )(const ENCODING *enc, const char *ptr, int attsMax, ATTRIBUTE *atts)
static int PTRFASTCALL PREFIX( charRefNumber )(const ENCODING *enc, const char *ptr)
static int PTRCALL PREFIX( predefinedEntityName )(const ENCODING *enc, const char *ptr, const char *end)
static int PTRCALL PREFIX( sameName )(const ENCODING *enc, const char *ptr1, const char *ptr2)
static int PTRCALL PREFIX( nameMatchesAscii )(const ENCODING *enc, const char *ptr1, const char *end1, const char *ptr2)
static int PTRFASTCALL PREFIX( nameLength )(const ENCODING *enc, const char *ptr)
static const char *PTRFASTCALL
PREFIX( 		skipS )(const ENCODING *enc, const char *ptr)
static void PTRCALL PREFIX( updatePosition )(const ENCODING *enc, const char *ptr, const char *end, POSITION *pos)

Define Documentation

#define CHECK_NAME_CASE (  n,
enc,
ptr,
end,
nextTokPtr   ) 
 

Value:

case BT_LEAD ## n: \
     if (end - ptr < n) \
       return XML_TOK_PARTIAL_CHAR; \
     if (!IS_NAME_CHAR(enc, ptr, n)) { \
       *nextTokPtr = ptr; \
       return XML_TOK_INVALID; \
     } \
     ptr += n; \
     break;

Definition at line 30 of file xmltok_impl.c.

#define CHECK_NAME_CASES (  enc,
ptr,
end,
nextTokPtr   ) 
 

Value:

case BT_NONASCII: \
    if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
      *nextTokPtr = ptr; \
      return XML_TOK_INVALID; \
    } \
  case BT_NMSTRT: \
  case BT_HEX: \
  case BT_DIGIT: \
  case BT_NAME: \
  case BT_MINUS: \
    ptr += MINBPC(enc); \
    break; \
  CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
  CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
  CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)

Definition at line 41 of file xmltok_impl.c.

#define CHECK_NMSTRT_CASE (  n,
enc,
ptr,
end,
nextTokPtr   ) 
 

Value:

case BT_LEAD ## n: \
     if (end - ptr < n) \
       return XML_TOK_PARTIAL_CHAR; \
     if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
       *nextTokPtr = ptr; \
       return XML_TOK_INVALID; \
     } \
     ptr += n; \
     break;

Definition at line 58 of file xmltok_impl.c.

#define CHECK_NMSTRT_CASES (  enc,
ptr,
end,
nextTokPtr   ) 
 

Value:

case BT_NONASCII: \
    if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
      *nextTokPtr = ptr; \
      return XML_TOK_INVALID; \
    } \
  case BT_NMSTRT: \
  case BT_HEX: \
    ptr += MINBPC(enc); \
    break; \
  CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
  CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
  CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)

Definition at line 69 of file xmltok_impl.c.

#define INVALID_CASES (  ptr,
nextTokPtr   ) 
 

Value:

INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
  INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
  INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
  case BT_NONXML: \
  case BT_MALFORM: \
  case BT_TRAIL: \
    *(nextTokPtr) = (ptr); \
    return XML_TOK_INVALID;

Definition at line 20 of file xmltok_impl.c.

#define INVALID_LEAD_CASE (  n,
ptr,
nextTokPtr   ) 
 

Value:

case BT_LEAD ## n: \
      if (end - ptr < n) \
        return XML_TOK_PARTIAL_CHAR; \
      if (IS_INVALID_CHAR(enc, ptr, n)) { \
        *(nextTokPtr) = (ptr); \
        return XML_TOK_INVALID; \
      } \
      ptr += n; \
      break;

Definition at line 9 of file xmltok_impl.c.

#define IS_INVALID_CHAR (  enc,
ptr,
n   )     (0)
 

Definition at line 6 of file xmltok_impl.c.

#define LEAD_CASE (  n   ) 
 

Value:

case BT_LEAD ## n: \
      if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
        *nextTokPtr = ptr; \
        return XML_TOK_DATA_CHARS; \
      } \
      ptr += n; \
      break;

#define PREFIX (  ident   )     ident
 

Definition at line 84 of file xmltok_impl.c.

#define START_NAME
 

Value:

if (state == other) { \
        if (nAtts < attsMax) { \
          atts[nAtts].name = ptr; \
          atts[nAtts].normalized = 1; \
        } \
        state = inName; \
      }

Variable Documentation

int PTRCALL PREFIX( attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) [static]
 

Definition at line 1200 of file xmltok_impl.c.

01202 {
01203   const char *start;
01204   if (ptr == end)
01205     return XML_TOK_NONE;
01206   start = ptr;
01207   while (ptr != end) {
01208     switch (BYTE_TYPE(enc, ptr)) {
01209 #define LEAD_CASE(n) \
01210     case BT_LEAD ## n: ptr += n; break;
01211     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
01212 #undef LEAD_CASE
01213     case BT_AMP:
01214       if (ptr == start)
01215         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
01216       *nextTokPtr = ptr;
01217       return XML_TOK_DATA_CHARS;
01218     case BT_LT:
01219       /* this is for inside entity references */
01220       *nextTokPtr = ptr;
01221       return XML_TOK_INVALID;
01222     case BT_LF:
01223       if (ptr == start) {
01224         *nextTokPtr = ptr + MINBPC(enc);
01225         return XML_TOK_DATA_NEWLINE;
01226       }
01227       *nextTokPtr = ptr;
01228       return XML_TOK_DATA_CHARS;
01229     case BT_CR:
01230       if (ptr == start) {
01231         ptr += MINBPC(enc);
01232         if (ptr == end)
01233           return XML_TOK_TRAILING_CR;
01234         if (BYTE_TYPE(enc, ptr) == BT_LF)
01235           ptr += MINBPC(enc);
01236         *nextTokPtr = ptr;
01237         return XML_TOK_DATA_NEWLINE;
01238       }
01239       *nextTokPtr = ptr;
01240       return XML_TOK_DATA_CHARS;
01241     case BT_S:
01242       if (ptr == start) {
01243         *nextTokPtr = ptr + MINBPC(enc);
01244         return XML_TOK_ATTRIBUTE_VALUE_S;
01245       }
01246       *nextTokPtr = ptr;
01247       return XML_TOK_DATA_CHARS;
01248     default:
01249       ptr += MINBPC(enc);
01250       break;
01251     }
01252   }
01253   *nextTokPtr = ptr;
01254   return XML_TOK_DATA_CHARS;
01255 }

int PTRCALL PREFIX( cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) [static]
 

Definition at line 302 of file xmltok_impl.c.

00304 {
00305   if (ptr == end)
00306     return XML_TOK_NONE;
00307   if (MINBPC(enc) > 1) {
00308     size_t n = end - ptr;
00309     if (n & (MINBPC(enc) - 1)) {
00310       n &= ~(MINBPC(enc) - 1);
00311       if (n == 0)
00312         return XML_TOK_PARTIAL;
00313       end = ptr + n;
00314     }
00315   }
00316   switch (BYTE_TYPE(enc, ptr)) {
00317   case BT_RSQB:
00318     ptr += MINBPC(enc);
00319     if (ptr == end)
00320       return XML_TOK_PARTIAL;
00321     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
00322       break;
00323     ptr += MINBPC(enc);
00324     if (ptr == end)
00325       return XML_TOK_PARTIAL;
00326     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
00327       ptr -= MINBPC(enc);
00328       break;
00329     }
00330     *nextTokPtr = ptr + MINBPC(enc);
00331     return XML_TOK_CDATA_SECT_CLOSE;
00332   case BT_CR:
00333     ptr += MINBPC(enc);
00334     if (ptr == end)
00335       return XML_TOK_PARTIAL;
00336     if (BYTE_TYPE(enc, ptr) == BT_LF)
00337       ptr += MINBPC(enc);
00338     *nextTokPtr = ptr;
00339     return XML_TOK_DATA_NEWLINE;
00340   case BT_LF:
00341     *nextTokPtr = ptr + MINBPC(enc);
00342     return XML_TOK_DATA_NEWLINE;
00343   INVALID_CASES(ptr, nextTokPtr)
00344   default:
00345     ptr += MINBPC(enc);
00346     break;
00347   }
00348   while (ptr != end) {
00349     switch (BYTE_TYPE(enc, ptr)) {
00350 #define LEAD_CASE(n) \
00351     case BT_LEAD ## n: \
00352       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
00353         *nextTokPtr = ptr; \
00354         return XML_TOK_DATA_CHARS; \
00355       } \
00356       ptr += n; \
00357       break;
00358     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
00359 #undef LEAD_CASE
00360     case BT_NONXML:
00361     case BT_MALFORM:
00362     case BT_TRAIL:
00363     case BT_CR:
00364     case BT_LF:
00365     case BT_RSQB:
00366       *nextTokPtr = ptr;
00367       return XML_TOK_DATA_CHARS;
00368     default:
00369       ptr += MINBPC(enc);
00370       break;
00371     }
00372   }
00373   *nextTokPtr = ptr;
00374   return XML_TOK_DATA_CHARS;
00375 }

int PTRFASTCALL PREFIX( charRefNumber)(const ENCODING *enc, const char *ptr) [static]
 

Definition at line 1521 of file xmltok_impl.c.

01522 {
01523   int result = 0;
01524   /* skip &# */
01525   ptr += 2*MINBPC(enc);
01526   if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
01527     for (ptr += MINBPC(enc);
01528          !CHAR_MATCHES(enc, ptr, ASCII_SEMI);
01529          ptr += MINBPC(enc)) {
01530       int c = BYTE_TO_ASCII(enc, ptr);
01531       switch (c) {
01532       case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4:
01533       case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9:
01534         result <<= 4;
01535         result |= (c - ASCII_0);
01536         break;
01537       case ASCII_A: case ASCII_B: case ASCII_C:
01538       case ASCII_D: case ASCII_E: case ASCII_F:
01539         result <<= 4;
01540         result += 10 + (c - ASCII_A);
01541         break;
01542       case ASCII_a: case ASCII_b: case ASCII_c:
01543       case ASCII_d: case ASCII_e: case ASCII_f:
01544         result <<= 4;
01545         result += 10 + (c - ASCII_a);
01546         break;
01547       }
01548       if (result >= 0x110000)
01549         return -1;
01550     }
01551   }
01552   else {
01553     for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
01554       int c = BYTE_TO_ASCII(enc, ptr);
01555       result *= 10;
01556       result += (c - ASCII_0);
01557       if (result >= 0x110000)
01558         return -1;
01559     }
01560   }
01561   return checkCharRefNumber(result);
01562 }

int PTRCALL PREFIX( checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end, int *tokPtr) [static]
 

Definition at line 175 of file xmltok_impl.c.

00177 {
00178   int upper = 0;
00179   *tokPtr = XML_TOK_PI;
00180   if (end - ptr != MINBPC(enc)*3)
00181     return 1;
00182   switch (BYTE_TO_ASCII(enc, ptr)) {
00183   case ASCII_x:
00184     break;
00185   case ASCII_X:
00186     upper = 1;
00187     break;
00188   default:
00189     return 1;
00190   }
00191   ptr += MINBPC(enc);
00192   switch (BYTE_TO_ASCII(enc, ptr)) {
00193   case ASCII_m:
00194     break;
00195   case ASCII_M:
00196     upper = 1;
00197     break;
00198   default:
00199     return 1;
00200   }
00201   ptr += MINBPC(enc);
00202   switch (BYTE_TO_ASCII(enc, ptr)) {
00203   case ASCII_l:
00204     break;
00205   case ASCII_L:
00206     upper = 1;
00207     break;
00208   default:
00209     return 1;
00210   }
00211   if (upper)
00212     return 0;
00213   *tokPtr = XML_TOK_XML_DECL;
00214   return 1;
00215 }

int PTRCALL PREFIX( contentTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) [static]
 

Definition at line 782 of file xmltok_impl.c.

00784 {
00785   if (ptr == end)
00786     return XML_TOK_NONE;
00787   if (MINBPC(enc) > 1) {
00788     size_t n = end - ptr;
00789     if (n & (MINBPC(enc) - 1)) {
00790       n &= ~(MINBPC(enc) - 1);
00791       if (n == 0)
00792         return XML_TOK_PARTIAL;
00793       end = ptr + n;
00794     }
00795   }
00796   switch (BYTE_TYPE(enc, ptr)) {
00797   case BT_LT:
00798     return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
00799   case BT_AMP:
00800     return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
00801   case BT_CR:
00802     ptr += MINBPC(enc);
00803     if (ptr == end)
00804       return XML_TOK_TRAILING_CR;
00805     if (BYTE_TYPE(enc, ptr) == BT_LF)
00806       ptr += MINBPC(enc);
00807     *nextTokPtr = ptr;
00808     return XML_TOK_DATA_NEWLINE;
00809   case BT_LF:
00810     *nextTokPtr = ptr + MINBPC(enc);
00811     return XML_TOK_DATA_NEWLINE;
00812   case BT_RSQB:
00813     ptr += MINBPC(enc);
00814     if (ptr == end)
00815       return XML_TOK_TRAILING_RSQB;
00816     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
00817       break;
00818     ptr += MINBPC(enc);
00819     if (ptr == end)
00820       return XML_TOK_TRAILING_RSQB;
00821     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
00822       ptr -= MINBPC(enc);
00823       break;
00824     }
00825     *nextTokPtr = ptr;
00826     return XML_TOK_INVALID;
00827   INVALID_CASES(ptr, nextTokPtr)
00828   default:
00829     ptr += MINBPC(enc);
00830     break;
00831   }
00832   while (ptr != end) {
00833     switch (BYTE_TYPE(enc, ptr)) {
00834 #define LEAD_CASE(n) \
00835     case BT_LEAD ## n: \
00836       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
00837         *nextTokPtr = ptr; \
00838         return XML_TOK_DATA_CHARS; \
00839       } \
00840       ptr += n; \
00841       break;
00842     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
00843 #undef LEAD_CASE
00844     case BT_RSQB:
00845       if (ptr + MINBPC(enc) != end) {
00846          if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
00847            ptr += MINBPC(enc);
00848            break;
00849          }
00850          if (ptr + 2*MINBPC(enc) != end) {
00851            if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
00852              ptr += MINBPC(enc);
00853              break;
00854            }
00855            *nextTokPtr = ptr + 2*MINBPC(enc);
00856            return XML_TOK_INVALID;
00857          }
00858       }
00859       /* fall through */
00860     case BT_AMP:
00861     case BT_LT:
00862     case BT_NONXML:
00863     case BT_MALFORM:
00864     case BT_TRAIL:
00865     case BT_CR:
00866     case BT_LF:
00867       *nextTokPtr = ptr;
00868       return XML_TOK_DATA_CHARS;
00869     default:
00870       ptr += MINBPC(enc);
00871       break;
00872     }
00873   }
00874   *nextTokPtr = ptr;
00875   return XML_TOK_DATA_CHARS;
00876 }

int PTRCALL PREFIX( entityValueTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) [static]
 

Definition at line 1258 of file xmltok_impl.c.

01260 {
01261   const char *start;
01262   if (ptr == end)
01263     return XML_TOK_NONE;
01264   start = ptr;
01265   while (ptr != end) {
01266     switch (BYTE_TYPE(enc, ptr)) {
01267 #define LEAD_CASE(n) \
01268     case BT_LEAD ## n: ptr += n; break;
01269     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
01270 #undef LEAD_CASE
01271     case BT_AMP:
01272       if (ptr == start)
01273         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
01274       *nextTokPtr = ptr;
01275       return XML_TOK_DATA_CHARS;
01276     case BT_PERCNT:
01277       if (ptr == start) {
01278         int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
01279                                        end, nextTokPtr);
01280         return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
01281       }
01282       *nextTokPtr = ptr;
01283       return XML_TOK_DATA_CHARS;
01284     case BT_LF:
01285       if (ptr == start) {
01286         *nextTokPtr = ptr + MINBPC(enc);
01287         return XML_TOK_DATA_NEWLINE;
01288       }
01289       *nextTokPtr = ptr;
01290       return XML_TOK_DATA_CHARS;
01291     case BT_CR:
01292       if (ptr == start) {
01293         ptr += MINBPC(enc);
01294         if (ptr == end)
01295           return XML_TOK_TRAILING_CR;
01296         if (BYTE_TYPE(enc, ptr) == BT_LF)
01297           ptr += MINBPC(enc);
01298         *nextTokPtr = ptr;
01299         return XML_TOK_DATA_NEWLINE;
01300       }
01301       *nextTokPtr = ptr;
01302       return XML_TOK_DATA_CHARS;
01303     default:
01304       ptr += MINBPC(enc);
01305       break;
01306     }
01307   }
01308   *nextTokPtr = ptr;
01309   return XML_TOK_DATA_CHARS;
01310 }

int PTRCALL PREFIX( getAtts)(const ENCODING *enc, const char *ptr, int attsMax, ATTRIBUTE *atts) [static]
 

Definition at line 1428 of file xmltok_impl.c.

01430 {
01431   enum { other, inName, inValue } state = inName;
01432   int nAtts = 0;
01433   int open = 0; /* defined when state == inValue;
01434                    initialization just to shut up compilers */
01435 
01436   for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
01437     switch (BYTE_TYPE(enc, ptr)) {
01438 #define START_NAME \
01439       if (state == other) { \
01440         if (nAtts < attsMax) { \
01441           atts[nAtts].name = ptr; \
01442           atts[nAtts].normalized = 1; \
01443         } \
01444         state = inName; \
01445       }
01446 #define LEAD_CASE(n) \
01447     case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
01448     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
01449 #undef LEAD_CASE
01450     case BT_NONASCII:
01451     case BT_NMSTRT:
01452     case BT_HEX:
01453       START_NAME
01454       break;
01455 #undef START_NAME
01456     case BT_QUOT:
01457       if (state != inValue) {
01458         if (nAtts < attsMax)
01459           atts[nAtts].valuePtr = ptr + MINBPC(enc);
01460         state = inValue;
01461         open = BT_QUOT;
01462       }
01463       else if (open == BT_QUOT) {
01464         state = other;
01465         if (nAtts < attsMax)
01466           atts[nAtts].valueEnd = ptr;
01467         nAtts++;
01468       }
01469       break;
01470     case BT_APOS:
01471       if (state != inValue) {
01472         if (nAtts < attsMax)
01473           atts[nAtts].valuePtr = ptr + MINBPC(enc);
01474         state = inValue;
01475         open = BT_APOS;
01476       }
01477       else if (open == BT_APOS) {
01478         state = other;
01479         if (nAtts < attsMax)
01480           atts[nAtts].valueEnd = ptr;
01481         nAtts++;
01482       }
01483       break;
01484     case BT_AMP:
01485       if (nAtts < attsMax)
01486         atts[nAtts].normalized = 0;
01487       break;
01488     case BT_S:
01489       if (state == inName)
01490         state = other;
01491       else if (state == inValue
01492                && nAtts < attsMax
01493                && atts[nAtts].normalized
01494                && (ptr == atts[nAtts].valuePtr
01495                    || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
01496                    || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
01497                    || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
01498         atts[nAtts].normalized = 0;
01499       break;
01500     case BT_CR: case BT_LF:
01501       /* This case ensures that the first attribute name is counted
01502          Apart from that we could just change state on the quote. */
01503       if (state == inName)
01504         state = other;
01505       else if (state == inValue && nAtts < attsMax)
01506         atts[nAtts].normalized = 0;
01507       break;
01508     case BT_GT:
01509     case BT_SOL:
01510       if (state != inValue)
01511         return nAtts;
01512       break;
01513     default:
01514       break;
01515     }
01516   }
01517   /* not reached */
01518 }

int PTRCALL PREFIX( isPublicId)(const ENCODING *enc, const char *ptr, const char *end, const char **badPtr) [static]
 

Definition at line 1368 of file xmltok_impl.c.

01370 {
01371   ptr += MINBPC(enc);
01372   end -= MINBPC(enc);
01373   for (; ptr != end; ptr += MINBPC(enc)) {
01374     switch (BYTE_TYPE(enc, ptr)) {
01375     case BT_DIGIT:
01376     case BT_HEX:
01377     case BT_MINUS:
01378     case BT_APOS:
01379     case BT_LPAR:
01380     case BT_RPAR:
01381     case BT_PLUS:
01382     case BT_COMMA:
01383     case BT_SOL:
01384     case BT_EQUALS:
01385     case BT_QUEST:
01386     case BT_CR:
01387     case BT_LF:
01388     case BT_SEMI:
01389     case BT_EXCL:
01390     case BT_AST:
01391     case BT_PERCNT:
01392     case BT_NUM:
01393 #ifdef XML_NS
01394     case BT_COLON:
01395 #endif
01396       break;
01397     case BT_S:
01398       if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
01399         *badPtr = ptr;
01400         return 0;
01401       }
01402       break;
01403     case BT_NAME:
01404     case BT_NMSTRT:
01405       if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
01406         break;
01407     default:
01408       switch (BYTE_TO_ASCII(enc, ptr)) {
01409       case 0x24: /* $ */
01410       case 0x40: /* @ */
01411         break;
01412       default:
01413         *badPtr = ptr;
01414         return 0;
01415       }
01416       break;
01417     }
01418   }
01419   return 1;
01420 }

int PTRFASTCALL PREFIX( nameLength)(const ENCODING *enc, const char *ptr) [static]
 

Definition at line 1696 of file xmltok_impl.c.

01697 {
01698   const char *start = ptr;
01699   for (;;) {
01700     switch (BYTE_TYPE(enc, ptr)) {
01701 #define LEAD_CASE(n) \
01702     case BT_LEAD ## n: ptr += n; break;
01703     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
01704 #undef LEAD_CASE
01705     case BT_NONASCII:
01706     case BT_NMSTRT:
01707 #ifdef XML_NS
01708     case BT_COLON:
01709 #endif
01710     case BT_HEX:
01711     case BT_DIGIT:
01712     case BT_NAME:
01713     case BT_MINUS:
01714       ptr += MINBPC(enc);
01715       break;
01716     default:
01717       return ptr - start;
01718     }
01719   }
01720 }

int PTRCALL PREFIX( nameMatchesAscii)(const ENCODING *enc, const char *ptr1, const char *end1, const char *ptr2) [static]
 

Definition at line 1683 of file xmltok_impl.c.

01685 {
01686   for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
01687     if (ptr1 == end1)
01688       return 0;
01689     if (!CHAR_MATCHES(enc, ptr1, *ptr2))
01690       return 0;
01691   }
01692   return ptr1 == end1;
01693 }

int PTRCALL PREFIX( predefinedEntityName)(const ENCODING *enc, const char *ptr, const char *end) [static]
 

Definition at line 1565 of file xmltok_impl.c.

01567 {
01568   switch ((end - ptr)/MINBPC(enc)) {
01569   case 2:
01570     if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
01571       switch (BYTE_TO_ASCII(enc, ptr)) {
01572       case ASCII_l:
01573         return ASCII_LT;
01574       case ASCII_g:
01575         return ASCII_GT;
01576       }
01577     }
01578     break;
01579   case 3:
01580     if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
01581       ptr += MINBPC(enc);
01582       if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
01583         ptr += MINBPC(enc);
01584         if (CHAR_MATCHES(enc, ptr, ASCII_p))
01585           return ASCII_AMP;
01586       }
01587     }
01588     break;
01589   case 4:
01590     switch (BYTE_TO_ASCII(enc, ptr)) {
01591     case ASCII_q:
01592       ptr += MINBPC(enc);
01593       if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
01594         ptr += MINBPC(enc);
01595         if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
01596           ptr += MINBPC(enc);
01597           if (CHAR_MATCHES(enc, ptr, ASCII_t))
01598             return ASCII_QUOT;
01599         }
01600       }
01601       break;
01602     case ASCII_a:
01603       ptr += MINBPC(enc);
01604       if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
01605         ptr += MINBPC(enc);
01606         if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
01607           ptr += MINBPC(enc);
01608           if (CHAR_MATCHES(enc, ptr, ASCII_s))
01609             return ASCII_APOS;
01610         }
01611       }
01612       break;
01613     }
01614   }
01615   return 0;
01616 }

int PTRCALL PREFIX( prologTok)(const ENCODING *enc, const char *ptr, const char *end, const char **nextTokPtr) [static]
 

Definition at line 969 of file xmltok_impl.c.

00971 {
00972   int tok;
00973   if (ptr == end)
00974     return XML_TOK_NONE;
00975   if (MINBPC(enc) > 1) {
00976     size_t n = end - ptr;
00977     if (n & (MINBPC(enc) - 1)) {
00978       n &= ~(MINBPC(enc) - 1);
00979       if (n == 0)
00980         return XML_TOK_PARTIAL;
00981       end = ptr + n;
00982     }
00983   }
00984   switch (BYTE_TYPE(enc, ptr)) {
00985   case BT_QUOT:
00986     return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
00987   case BT_APOS:
00988     return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
00989   case BT_LT:
00990     {
00991       ptr += MINBPC(enc);
00992       if (ptr == end)
00993         return XML_TOK_PARTIAL;
00994       switch (BYTE_TYPE(enc, ptr)) {
00995       case BT_EXCL:
00996         return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
00997       case BT_QUEST:
00998         return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
00999       case BT_NMSTRT:
01000       case BT_HEX:
01001       case BT_NONASCII:
01002       case BT_LEAD2:
01003       case BT_LEAD3:
01004       case BT_LEAD4:
01005         *nextTokPtr = ptr - MINBPC(enc);
01006         return XML_TOK_INSTANCE_START;
01007       }
01008       *nextTokPtr = ptr;
01009       return XML_TOK_INVALID;
01010     }
01011   case BT_CR:
01012     if (ptr + MINBPC(enc) == end) {
01013       *nextTokPtr = end;
01014       /* indicate that this might be part of a CR/LF pair */
01015       return -XML_TOK_PROLOG_S;
01016     }
01017     /* fall through */
01018   case BT_S: case BT_LF:
01019     for (;;) {
01020       ptr += MINBPC(enc);
01021       if (ptr == end)
01022         break;
01023       switch (BYTE_TYPE(enc, ptr)) {
01024       case BT_S: case BT_LF:
01025         break;
01026       case BT_CR:
01027         /* don't split CR/LF pair */
01028         if (ptr + MINBPC(enc) != end)
01029           break;
01030         /* fall through */
01031       default:
01032         *nextTokPtr = ptr;
01033         return XML_TOK_PROLOG_S;
01034       }
01035     }
01036     *nextTokPtr = ptr;
01037     return XML_TOK_PROLOG_S;
01038   case BT_PERCNT:
01039     return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
01040   case BT_COMMA:
01041     *nextTokPtr = ptr + MINBPC(enc);
01042     return XML_TOK_COMMA;
01043   case BT_LSQB:
01044     *nextTokPtr = ptr + MINBPC(enc);
01045     return XML_TOK_OPEN_BRACKET;
01046   case BT_RSQB:
01047     ptr += MINBPC(enc);
01048     if (ptr == end)
01049       return -XML_TOK_CLOSE_BRACKET;
01050     if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
01051       if (ptr + MINBPC(enc) == end)
01052         return XML_TOK_PARTIAL;
01053       if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
01054         *nextTokPtr = ptr + 2*MINBPC(enc);
01055         return XML_TOK_COND_SECT_CLOSE;
01056       }
01057     }
01058     *nextTokPtr = ptr;
01059     return XML_TOK_CLOSE_BRACKET;
01060   case BT_LPAR:
01061     *nextTokPtr = ptr + MINBPC(enc);
01062     return XML_TOK_OPEN_PAREN;
01063   case BT_RPAR:
01064     ptr += MINBPC(enc);
01065     if (ptr == end)
01066       return -XML_TOK_CLOSE_PAREN;
01067     switch (BYTE_TYPE(enc, ptr)) {
01068     case BT_AST:
01069       *nextTokPtr = ptr + MINBPC(enc);
01070       return XML_TOK_CLOSE_PAREN_ASTERISK;
01071     case BT_QUEST:
01072       *nextTokPtr = ptr + MINBPC(enc);
01073       return XML_TOK_CLOSE_PAREN_QUESTION;
01074     case BT_PLUS:
01075       *nextTokPtr = ptr + MINBPC(enc);
01076       return XML_TOK_CLOSE_PAREN_PLUS;
01077     case BT_CR: case BT_LF: case BT_S:
01078     case BT_GT: case BT_COMMA: case BT_VERBAR:
01079     case BT_RPAR:
01080       *nextTokPtr = ptr;
01081       return XML_TOK_CLOSE_PAREN;
01082     }
01083     *nextTokPtr = ptr;
01084     return XML_TOK_INVALID;
01085   case BT_VERBAR:
01086     *nextTokPtr = ptr + MINBPC(enc);
01087     return XML_TOK_OR;
01088   case BT_GT:
01089     *nextTokPtr = ptr + MINBPC(enc);
01090     return XML_TOK_DECL_CLOSE;
01091   case BT_NUM:
01092     return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
01093 #define LEAD_CASE(n) \
01094   case BT_LEAD ## n: \
01095     if (end - ptr < n) \
01096       return XML_TOK_PARTIAL_CHAR; \
01097     if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
01098       ptr += n; \
01099       tok = XML_TOK_NAME; \
01100       break; \
01101     } \
01102     if (IS_NAME_CHAR(enc, ptr, n)) { \
01103       ptr += n; \
01104       tok = XML_TOK_NMTOKEN; \
01105       break; \
01106     } \
01107     *nextTokPtr = ptr; \
01108     return XML_TOK_INVALID;
01109     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
01110 #undef LEAD_CASE
01111   case BT_NMSTRT:
01112   case BT_HEX:
01113     tok = XML_TOK_NAME;
01114     ptr += MINBPC(enc);
01115     break;
01116   case BT_DIGIT:
01117   case BT_NAME:
01118   case BT_MINUS:
01119 #ifdef XML_NS
01120   case BT_COLON:
01121 #endif
01122     tok = XML_TOK_NMTOKEN;
01123     ptr += MINBPC(enc);
01124     break;
01125   case BT_NONASCII:
01126     if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
01127       ptr += MINBPC(enc);
01128       tok = XML_TOK_NAME;
01129       break;
01130     }
01131     if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
01132       ptr += MINBPC(enc);
01133       tok = XML_TOK_NMTOKEN;
01134       break;
01135     }
01136     /* fall through */
01137   default:
01138     *nextTokPtr = ptr;
01139     return XML_TOK_INVALID;
01140   }
01141   while (ptr != end) {
01142     switch (BYTE_TYPE(enc, ptr)) {
01143     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
01144     case BT_GT: case BT_RPAR: case BT_COMMA:
01145     case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
01146     case BT_S: case BT_CR: case BT_LF:
01147       *nextTokPtr = ptr;
01148       return tok;
01149 #ifdef XML_NS
01150     case BT_COLON:
01151       ptr += MINBPC(enc);
01152       switch (tok) {
01153       case XML_TOK_NAME:
01154         if (ptr == end)
01155           return XML_TOK_PARTIAL;
01156         tok = XML_TOK_PREFIXED_NAME;
01157         switch (BYTE_TYPE(enc, ptr)) {
01158         CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
01159         default:
01160           tok = XML_TOK_NMTOKEN;
01161           break;
01162         }
01163         break;
01164       case XML_TOK_PREFIXED_NAME:
01165         tok = XML_TOK_NMTOKEN;
01166         break;
01167       }
01168       break;
01169 #endif
01170     case BT_PLUS:
01171       if (tok == XML_TOK_NMTOKEN)  {
01172         *nextTokPtr = ptr;
01173         return XML_TOK_INVALID;
01174       }
01175       *nextTokPtr = ptr + MINBPC(enc);
01176       return XML_TOK_NAME_PLUS;
01177     case BT_AST:
01178       if (tok == XML_TOK_NMTOKEN)  {
01179         *nextTokPtr = ptr;
01180         return XML_TOK_INVALID;
01181       }
01182       *nextTokPtr = ptr + MINBPC(enc);
01183       return XML_TOK_NAME_ASTERISK;
01184     case BT_QUEST:
01185       if (tok == XML_TOK_NMTOKEN)  {
01186         *nextTokPtr = ptr;
01187         return XML_TOK_INVALID;
01188       }
01189       *nextTokPtr = ptr + MINBPC(enc);
01190       return XML_TOK_NAME_QUESTION;
01191     default:
01192       *nextTokPtr = ptr;
01193       return XML_TOK_INVALID;
01194     }
01195   }
01196   return -tok;
01197 }

int PTRCALL PREFIX( sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2) [static]
 

Definition at line 1619 of file xmltok_impl.c.

01620 {
01621   for (;;) {
01622     switch (BYTE_TYPE(enc, ptr1)) {
01623 #define LEAD_CASE(n) \
01624     case BT_LEAD ## n: \
01625       if (*ptr1++ != *ptr2++) \
01626         return 0;
01627     LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
01628 #undef LEAD_CASE
01629       /* fall through */
01630       if (*ptr1++ != *ptr2++)
01631         return 0;
01632       break;
01633     case BT_NONASCII:
01634     case BT_NMSTRT:
01635 #ifdef XML_NS
01636     case BT_COLON:
01637 #endif
01638     case BT_HEX:
01639     case BT_DIGIT:
01640     case BT_NAME:
01641     case BT_MINUS:
01642       if (*ptr2++ != *ptr1++)
01643         return 0;
01644       if (MINBPC(enc) > 1) {
01645         if (*ptr2++ != *ptr1++)
01646           return 0;
01647         if (MINBPC(enc) > 2) {
01648           if (*ptr2++ != *ptr1++)
01649             return 0;
01650           if (MINBPC(enc) > 3) {
01651             if (*ptr2++ != *ptr1++)
01652               return 0;
01653           }
01654         }
01655       }
01656       break;
01657     default:
01658       if (