1 /*

     2 * Copyright (c) 2000 - 2001 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include "cxml_internal.h"

    19 #include <xml/cxml/nw_xmlp_xmlreader.h>

    20 #include <xml/cxml/nw_xmlp_xmlparser.h>

    21 #include <xml/cxml/nw_encoder_wbxmlwriter.h>

    22 

    23 

    24 #include "cxml_xmlp_entity.h"

    25 #include <xml/cxml/nw_string_string.h>

    26 #include "cxml_xmlp_int_entity.h"

    27 

    28 

    29 

    30 /* "<?" len 2 */

    31 #define NW_XML_String_PiFormStartLength 2

    32 static

    33 const NW_Uint8 NW_XML_String_PiFormStart[NW_XML_String_PiFormStartLength] =

    34 {

    35     '<', '?'

    36 };

    37 

    38 /* "?>" len 2 */

    39 #define NW_XML_String_PiFormStopLength 2

    40 static

    41 const NW_Uint8 NW_XML_String_PiFormStop[NW_XML_String_PiFormStopLength] =

    42 {

    43     '?', '>'

    44 };

    45 

    46 /* "version" len 7 */

    47 #define NW_XML_String_VersionLength 7

    48 static

    49 const NW_Uint8 NW_XML_String_Version[NW_XML_String_VersionLength] =

    50 {

    51     'v', 'e', 'r', 's', 'i', 'o', 'n'

    52 };

    53 

    54 /* "encoding" len 8 */

    55 #define NW_XML_String_EncodingLength 8

    56 static

    57 const NW_Uint8 NW_XML_String_Encoding[NW_XML_String_EncodingLength] =

    58 {

    59     'e', 'n', 'c', 'o', 'd', 'i', 'n', 'g'

    60 };

    61 

    62 /* "standalone" len 10 */

    63 #define NW_XML_String_StandaloneLength 10

    64 static

    65 const NW_Uint8 NW_XML_String_Standalone[NW_XML_String_StandaloneLength] =

    66 {

    67     's', 't', 'a', 'n', 'd', 'a', 'l', 'o', 'n', 'e'

    68 };

    69 

    70 /* "<!DOCTYPE" len 9 */

    71 #define NW_XML_String_DoctypeStartLength 9

    72 static

    73 const NW_Uint8 NW_XML_String_DoctypeStart[NW_XML_String_DoctypeStartLength] =

    74 {

    75     '<', '!', 'D', 'O', 'C', 'T', 'Y', 'P', 'E'

    76 };

    77 

    78 /* "<!ENTITY" len 8 in the DTD */

    79 

    80 #define NW_XML_String_EntityStartLength 8

    81 static

    82 const NW_Uint8 NW_XML_String_EntityStart[NW_XML_String_EntityStartLength] =

    83 {

    84     '<', '!', 'E', 'N', 'T', 'I', 'T', 'Y'

    85 };

    86 

    87 /* "<!--" len 4 comment start */

    88 #define NW_XML_String_CommentStartLength 4

    89 static

    90 const NW_Uint8 NW_XML_String_CommentStart[NW_XML_String_CommentStartLength] =

    91 {

    92     '<', '!', '-', '-'

    93 };

    94 

    95 /* "-->" len 3 comment end */

    96 #define NW_XML_String_CommentStopLength 3

    97 static

    98 const NW_Uint8 NW_XML_String_CommentStop[NW_XML_String_CommentStopLength] =

    99 {

   100     '-', '-', '>'

   101 };

   102 

   103 /* "/>" len 2 */

   104 #define NW_XML_String_EmptyTagEndLength 2

   105 static

   106 const NW_Uint8 NW_XML_String_EmptyTagEnd[NW_XML_String_EmptyTagEndLength] =

   107 {

   108     '/', '>'

   109 };

   110 

   111 /* "</" len 2 */

   112 #define NW_XML_String_EndTagStartLength 2

   113 static

   114 const NW_Uint8 NW_XML_String_EndTagStart[NW_XML_String_EndTagStartLength] =

   115 {

   116     '<', '/'

   117 };

   118 

   119 /* "<![CDATA[" len 9 */

   120 #define NW_XML_String_CdataStartLength 9

   121 static

   122 const NW_Uint8 NW_XML_String_CdataStart[NW_XML_String_CdataStartLength] =

   123 {

   124     '<', '!', '[', 'C', 'D', 'A', 'T', 'A', '['

   125 };

   126 

   127 /* "]]>" len 3 */

   128 #define NW_XML_String_CdataEndLength 3

   129 static

   130 const NW_Uint8 NW_XML_String_CdataEnd[NW_XML_String_CdataEndLength] =

   131 {

   132     ']', ']', '>'

   133 };

   134 

   135 /* All case variations of "xml" */

   136 #define NW_XML_String_XmlNameVariationCount 8

   137 #define NW_XML_String_XmlLength 3

   138 static

   139 const NW_Uint8 NW_XML_String_XmlVariations[(NW_XML_String_XmlNameVariationCount

   140                                         * NW_XML_String_XmlLength)] =

   141 {

   142     'x', 'm', 'l', /* all lower case form must be first */

   143     'x', 'm', 'L',

   144     'x', 'M', 'l',

   145     'x', 'M', 'L',

   146     'X', 'm', 'l',

   147     'X', 'm', 'L',

   148     'X', 'M', 'l',

   149     'X', 'M', 'L'

   150 };

   151 

   152 

   153 /* Assumes position in Reader is at the first character of keyword.

   154 returns: *pMatch = 1 if found keyword and advanced over it, 0 if no match

   155 NOTE: Keyword match just means the string of keyword chars

   156 exists at the read position so it does not mean that the keyword

   157 is delimited at the end---it might be followed by more name chars. */

   158 static

   159 NW_Status_t

   160 NW_XML_Parse_KeywordConsume(NW_XML_Reader_t* pT, NW_XML_Reader_Interval_t* pI,

   161                             NW_Uint32 l, const NW_Uint8* pKeyword,

   162                             NW_Uint32* pMatch)

   163 {

   164     NW_Status_t s;

   165     NW_XML_Reader_Interval_Init(pI);

   166     s = NW_XML_Reader_AsciiStringMatch(pT, l, pKeyword, pMatch);

   167     if (NW_STAT_IS_SUCCESS(s) && *pMatch) {

   168         NW_XML_Reader_Interval_Start(pI, pT);

   169         NW_XML_Reader_AdvanceOffset(pT, l);

   170         NW_XML_Reader_Interval_Stop(pI, pT);

   171     }

   172     return s;

   173 }

   174 

   175 /*

   176 Parses an XML Name (productions 5, 4) in Reader.

   177 If no parse error, then *pI marks the Name.

   178 Assumes position in Reader is at the first character of name.

   179 returns: *pMatch = 1 if found name and advanced over it, 0 if no match

   180 */

   181 static

   182 NW_Status_t

   183 NW_XML_Parse_NameConsume(NW_XML_Reader_t* pT, NW_XML_Reader_Interval_t* pI,

   184                          NW_Uint32* pMatch)

   185 {

   186     /*

   187     [4] NameChar ::= Letter | Digit | '.' | '-' | '_' | ':'

   188                      | CombiningChar | Extender

   189 

   190                      Note: combining and extender ignored here.

   191 

   192     [5] Name ::= (Letter | '_' | ':') (NameChar)*

   193     */

   194     NW_Status_t sl;

   195     NW_Uint32 isLetter;

   196     NW_Status_t su;

   197     NW_Uint32 isUnderscore;

   198     NW_Status_t sc;

   199     NW_Uint32 isColon;

   200     NW_Status_t sd = NW_STAT_SUCCESS;

   201     NW_Uint32 isDigit = 0;

   202     NW_Status_t sp = NW_STAT_SUCCESS;

   203     NW_Uint32 isPeriod = 0;

   204     NW_Status_t sh = NW_STAT_SUCCESS;

   205     NW_Uint32 isHyphen = 0;

   206     NW_Status_t s = NW_STAT_SUCCESS;

   207 

   208     sl = NW_XML_Reader_IsLetter(pT, &isLetter);

   209     su = NW_XML_Reader_AsciiCharMatch(pT, '_', &isUnderscore);

   210     sc = NW_XML_Reader_AsciiCharMatch(pT, ':', &isColon);

   211     *pMatch = 0;

   212     NW_XML_Reader_Interval_Init(pI);

   213     if (NW_STAT_IS_SUCCESS(sl) && NW_STAT_IS_SUCCESS(su)

   214         && NW_STAT_IS_SUCCESS(sc)) {

   215         if (isLetter | isUnderscore | isColon) {

   216             NW_XML_Reader_Interval_Start(pI, pT);

   217             while ((NW_STAT_IS_SUCCESS(sl) && NW_STAT_IS_SUCCESS(su)

   218                     && NW_STAT_IS_SUCCESS(sc) && NW_STAT_IS_SUCCESS(sd)

   219                     && NW_STAT_IS_SUCCESS(sp) && NW_STAT_IS_SUCCESS(sh)

   220                     && NW_STAT_IS_SUCCESS(s))

   221                    && (isLetter | isDigit | isPeriod | isHyphen | isUnderscore

   222                       | isColon )) {

   223                 s = NW_XML_Reader_Advance(pT);

   224                 sl = NW_XML_Reader_IsLetter(pT, &isLetter);

   225                 sd = NW_XML_Reader_IsDigit(pT, &isDigit);

   226                 sp = NW_XML_Reader_AsciiCharMatch(pT, '.', &isPeriod);

   227                 sh = NW_XML_Reader_AsciiCharMatch(pT, '-', &isHyphen);

   228                 su = NW_XML_Reader_AsciiCharMatch(pT, '_', &isUnderscore);

   229                 sc = NW_XML_Reader_AsciiCharMatch(pT, ':', &isColon);

   230             }

   231             NW_XML_Reader_Interval_Stop(pI, pT);

   232             *pMatch = 1;

   233         }

   234     }

   235     if (NW_STAT_IS_SUCCESS(sl) && NW_STAT_IS_SUCCESS(su)

   236         && NW_STAT_IS_SUCCESS(sc) && NW_STAT_IS_SUCCESS(sd)

   237         && NW_STAT_IS_SUCCESS(sp) && NW_STAT_IS_SUCCESS(sh)

   238         && NW_STAT_IS_SUCCESS(s)) {

   239         return NW_STAT_SUCCESS;

   240     }

   241     return NW_STAT_FAILURE;

   242 }

   243 

   244 /* This function reads data from the pT->pBuf and converts this data to

   245  * the NW_String_t. The string memory is allocated  here but it is freed

   246  * in the calling function.

   247  *

   248  * pT        --> Parser Structute (IN)

   249  * I_attrVal --> Attribute value Interval parameter (IN)

   250  * *dataStr   --> Output string (OUT)

   251  *

   252  * 

   253  */

   254 

   255 static NW_Status_t NW_XML_Data_to_String(NW_XML_Reader_t* pT, NW_XML_Reader_Interval_t* I_attrVal,

   256                              NW_String_t* dataStr)

   257 {

   258  NW_Uint8* pData;

   259  NW_Uint32 numbytes = 0;

   260  NW_Uint32 totalByteCount = 0;

   261  CXML_Uint8* tempAttrValBuf;

   262  CXML_Uint32 tempBufLen = 0;

   263  NW_Uint32 length;

   264  NW_Uint32 i =0;

   265  NW_Ucs2 c;

   266  NW_Status_t s;

   267 

   268      length = I_attrVal->stop - I_attrVal->start; 

   269      tempBufLen = length; //Desired bytes need to read.

   270 

   271      s = NW_XML_Reader_DataAddressFromBuffer(pT,I_attrVal->start,

   272                                              &tempBufLen,

   273                                              &tempAttrValBuf);

   274 

   275          if (NW_STAT_IS_FAILURE(s))

   276          {

   277             return s;

   278          }

   279 

   280         if (tempBufLen != length) 

   281         {

   282             return NW_STAT_FAILURE;

   283         }

   284 

   285 

   286  

   287     /* pData is not NULL terminated so need to use following method. The num byte

   288      * will be used for both pName and pVlaue.

   289      */

   290 

   291 

   292     numbytes = NW_String_readChar( (NW_Byte*) tempAttrValBuf,&c,pT->encoding);

   293 

   294     /* Calculate the length of string. Also add the number of characters 

   295      * required for the NULL termination.

   296      */

   297         

   298     totalByteCount = length + numbytes;

   299 

   300     pData = (NW_Uint8*) NW_Mem_Malloc(totalByteCount);

   301 

   302     if (pData != NULL) 

   303      {

   304       (void)NW_Mem_memcpy(pData , tempAttrValBuf, length );

   305 

   306 

   307        for(i=0; i < numbytes; i++)

   308        {

   309         pData[length+i] = '\0';

   310        }

   311       } /*end if (pName  != NULL)*/

   312      else

   313      {

   314       return NW_STAT_OUT_OF_MEMORY;

   315      }

   316 

   317      s = NW_String_initialize( dataStr , pData, pT->encoding);

   318 

   319      if (NW_STAT_IS_FAILURE(s))

   320      {

   321       return s;

   322      }

   323 

   324      /* This will the storage of the dataStr by the NW_String_delete() */

   325 

   326      dataStr->length |= 0x80000000;

   327 

   328  return NW_STAT_SUCCESS;

   329 

   330 }/*end NW_XML_Data_to_String()*/

   331 

   332 /* Assumes position in Reader is at the opening quote character for value. 

   333 * BUG not yet spec compliant.

   334 * The following function is called for Process Instruction and Element

   335 * attribute consume. The predefined entities will be handled in 

   336 * element attributes only. So, the "entity" parameter is used to 

   337 * distinguish between these two cases.

   338 * Careful about the "entity" parameter passed. This is used both as 

   339 * IN/OUT paramter.

   340 

   341 *  IN --> if(entity == CXML_TRUE): Then parse attribute value for the

   342 *         entities.

   343 

   344 *  OUT --> (entity=CXML_TRUE): The entity is found in the attribute value.

   345 

   346 */

   347 

   348 static

   349 NW_Status_t

   350 NW_XML_Parse_ValueConsume(NW_XML_Reader_t* pT, NW_XML_Reader_Interval_t* pI,

   351 						  CXML_Bool* entityCheck, NW_String_t* attrValStr,

   352                           const RPointerArray <CXML_Internal_Entity_t>*  internalEntityList)

   353 {

   354     /*

   355     Literal data is any quoted string not containing the quotation mark

   356     used as a delimiter for that string.

   357 

   358     [10] AttValue ::=   '"' ([^<&"] | Reference)* '"'

   359                       | "'" ([^<&'] | Reference)* "'"

   360     */

   361 

   362     /* BUG this only pays attention to the quote chars not the value

   363     so it ignores [<&]. */

   364     NW_Status_t s;

   365     NW_Status_t ssq;

   366     NW_Uint32 isOpenSingleQuote;

   367     NW_Uint32 isCloseSingleQuote = 0;

   368     NW_Status_t sdq;

   369     NW_Uint32 isOpenDoubleQuote;

   370     NW_Uint32 isCloseDoubleQuote = 0;

   371     NW_Status_t slt;

   372     NW_Uint32 isLessThan;

   373 

   374 	NW_Uint32 prevIndex;

   375 	NW_Uint32 prevCharIndex;

   376 	NW_XML_Reader_LineColumn_t prevLineColumn;

   377     CXML_Uint8* intEntityValStr = NULL;

   378     CXML_Uint32 tempBufLen = 0;

   379 	NW_String_t* tempStr = NULL;

   380 	NW_String_t entityValStr;

   381     CXML_Bool entityFoundLevel_2 =  NW_FALSE;

   382 	CXML_Bool entityFoundOnce = NW_FALSE;

   383 	NW_String_initialize (&entityValStr, NULL, 0);

   384 	

   385 

   386 

   387 

   388     NW_XML_Reader_Interval_Init(pI);

   389     ssq = NW_XML_Reader_AsciiCharMatch(pT, '\'', &isOpenSingleQuote);

   390     sdq = NW_XML_Reader_AsciiCharMatch(pT, '\"', &isOpenDoubleQuote);

   391     if (NW_STAT_IS_FAILURE(sdq) || NW_STAT_IS_FAILURE(ssq)

   392         || (!isOpenSingleQuote && !isOpenDoubleQuote)) {

   393         return NW_STAT_FAILURE;

   394     }

   395     /* xor, mutually exclusive */

   396     NW_ASSERT(isOpenSingleQuote ^ isOpenDoubleQuote);

   397     s = NW_XML_Reader_Advance(pT);

   398     if (NW_STAT_IS_FAILURE(s)) {

   399         return NW_STAT_FAILURE;

   400     }

   401     NW_XML_Reader_Interval_Start(pI, pT);

   402     for (;;) {

   403 

   404         /* Check for the closing quotes. If this is empty attribute value 

   405          * then no need for the checking the entities.

   406          */

   407 

   408         if (isOpenSingleQuote) {

   409             ssq = NW_XML_Reader_AsciiCharMatch(pT, '\'', &isCloseSingleQuote);

   410         }

   411         if (isOpenDoubleQuote) {

   412             sdq = NW_XML_Reader_AsciiCharMatch(pT, '\"', &isCloseDoubleQuote);

   413         }

   414         slt = NW_XML_Reader_AsciiCharMatch(pT, '<', &isLessThan);

   415         if (NW_STAT_IS_FAILURE(ssq) || NW_STAT_IS_FAILURE(sdq)

   416             || NW_STAT_IS_FAILURE(slt) || isLessThan) {

   417             return NW_STAT_FAILURE;

   418         }

   419 

   420 

   421         if( (*entityCheck == CXML_TRUE) && !isCloseSingleQuote && !isCloseDoubleQuote)

   422         {

   423             NW_Uint32 match;

   424 

   425             s = NW_XML_Reader_AsciiCharMatch(pT, '&', &match); 

   426 

   427 		    if (NW_STAT_IS_FAILURE(s))

   428 		    {

   429                 return NW_STAT_FAILURE;

   430             }

   431             if (match) 

   432 		    {

   433               NW_XML_Reader_Interval_t I_entityData;

   434 		      NW_Bool entityFoundLevel_1 =  NW_FALSE; //If end of entity (;) found

   435 		      NW_Uint32 entityVal = 0;

   436 		      NW_XML_Reader_Interval_t* I_attrVal = pI;

   437               

   438 

   439 

   440 		      entityFoundLevel_2 =  NW_FALSE;

   441               NW_XML_Reader_Interval_Stop(I_attrVal, pT); //Contents before entity

   442              

   443 			  //Will back if not a valid entity

   444 			  NW_XML_Reader_GetPosition(pT,

   445                               &prevIndex, &prevCharIndex, &prevLineColumn);

   446 

   447 		      s = CXML_XML_Parser_Entity(pT,&I_entityData,&entityFoundLevel_1);

   448 

   449                 if (NW_STAT_IS_FAILURE(s))

   450 		        {

   451                     return NW_STAT_FAILURE;

   452                 }

   453                /*

   454                 if(entityFoundLevel_1 == NW_FALSE)

   455                 {

   456                   return NW_STAT_XHTML_BAD_CONTENT;

   457                 }

   458                 */

   459 		      if (entityFoundLevel_1) 

   460               {

   461 			    // Validate the entity

   462                 // The following function checks for the character,

   463                 // predefined and Internal Entities.

   464 

   465                 if( (I_entityData.stop - I_entityData.start) > 0)

   466                 {

   467 			    s = CXML_XML_Handle_entity(pT,

   468                                            &I_entityData,&entityVal,&intEntityValStr,

   469                                            &entityFoundLevel_2,

   470                                            (void*) internalEntityList);

   471                 }

   472                 else

   473                 {

   474                  //Not a valid entity e.g. "&&;" test case

   475                  entityFoundLevel_2 = NW_FALSE;

   476                 }

   477 

   478 			    if (NW_STAT_IS_FAILURE(s)) 

   479 			    {

   480 			     return NW_STAT_FAILURE;

   481 			    }

   482 

   483                 if(entityFoundLevel_2 == CXML_TRUE)

   484 			    {

   485                  /* Read contents before entity*/

   486 

   487                    tempBufLen = I_attrVal->stop - I_attrVal->start; 

   488 

   489 				   if(tempBufLen > 0)

   490 				   {

   491 

   492                     if(tempStr == NULL)

   493 					 {

   494 					  tempStr = NW_String_new();

   495 					  if(tempStr == NULL)

   496 					  {

   497 					   return NW_STAT_OUT_OF_MEMORY;

   498                       }

   499 					  

   500                     } /*end if(tempStr == NULL)*/

   501 

   502                     s = NW_XML_Data_to_String (pT,I_attrVal,tempStr);

   503                                                           

   504                     if (NW_STAT_IS_FAILURE(s))

   505                     {

   506                      return s;

   507                     }

   508 

   509 					 s = NW_String_concatenate(attrValStr,tempStr,pT->encoding);

   510 

   511 

   512 					 if (NW_STAT_IS_FAILURE(s))

   513                      {

   514                       return s;

   515                      }

   516                     

   517                     // Do some clean up

   518 

   519 					if(tempStr != NULL)

   520 					{

   521 					 NW_String_delete(tempStr);

   522 					 tempStr = NULL;

   523 					}

   524 

   525 				   }//end if(tempBufLen > 0)

   526 

   527                  // Write the entity content now. There are two possibilities for entities.

   528                  //

   529                  // 1) If it is character or decimal or predefined entities. 

   530                  //    In this case, intEntityValStr = NULL.

   531                  //

   532                  // 2) If it is "Internal Entity" then In this case, entityVal = 0;

   533 

   534                    if (intEntityValStr == NULL)

   535                    {

   536 

   537                     /* convert contents of the character/predfined entity to string */    

   538 

   539 				     s = NW_String_entityToString(entityVal,&entityValStr,pT->encoding);

   540 

   541 					 if (NW_STAT_IS_FAILURE(s))

   542                      {

   543                       return s;

   544                      }

   545                    }/*end if (intEntityValStr == NULL)*/

   546                    else if(entityVal == 0)

   547                    {

   548                         /* This is a internal entity string */

   549 

   550                          s = NW_String_initialize(&entityValStr,intEntityValStr,pT->encoding);

   551                          if (NW_STAT_IS_FAILURE(s))

   552                          {

   553                           return s;

   554                          }

   555                    } /*end else if(entityVal == 0)*/

   556 

   557                      /* Add this entity value to the string */

   558 			

   559 					 s = NW_String_concatenate(attrValStr,&entityValStr,pT->encoding);

   560 

   561 					 if (NW_STAT_IS_FAILURE(s))

   562                      {

   563                       return s;

   564                      }

   565                   

   566 

   567 				

   568 					if(entityValStr.storage != NULL)

   569                     {

   570                      NW_Mem_Free (entityValStr.storage);

   571                     }

   572                     // Initialize the entity string for next entity 

   573 

   574 					NW_String_initialize (&entityValStr, NULL, 0);

   575 

   576                    //Again start the top level interval

   577 

   578                     NW_XML_Reader_Interval_Init(pI);

   579                     NW_XML_Reader_Interval_Start(pI, pT);

   580 

   581 					/*Check for the closing quotes after entity parsing */

   582 

   583 					if (isOpenSingleQuote) {

   584 						ssq = NW_XML_Reader_AsciiCharMatch(pT, '\'', &isCloseSingleQuote);

   585 					}

   586 					if (isOpenDoubleQuote) {

   587 						sdq = NW_XML_Reader_AsciiCharMatch(pT, '\"', &isCloseDoubleQuote);

   588 					}

   589 					slt = NW_XML_Reader_AsciiCharMatch(pT, '<', &isLessThan);

   590 					if (NW_STAT_IS_FAILURE(ssq) || NW_STAT_IS_FAILURE(sdq)

   591 						|| NW_STAT_IS_FAILURE(slt) || isLessThan) {

   592 						return NW_STAT_FAILURE;

   593 					}

   594 					entityFoundOnce = CXML_TRUE;

   595 			    }//endif(entityFoundLevel_2 == CXML_TRUE)

   596                 else

   597                 {

   598                  /* If it is here, the entity is not well formed or a entity is

   599                   * not supported. But, it is error for now. 

   600                   */

   601                 /*

   602                    return NW_STAT_XHTML_BAD_CONTENT;*/

   603 

   604                 //No valid entity found. Parse as the normal string

   605                  NW_XML_Reader_SetPosition(pT,

   606                                         prevIndex,

   607                                         prevCharIndex,

   608                                         &prevLineColumn);

   609                 }

   610                 

   611              } //end if (entityFound && inContent)

   612 			else

   613 			{

   614 			 //No valid entity found. Parse as the normal string

   615 			  NW_XML_Reader_SetPosition(pT,

   616                                         prevIndex,

   617                                         prevCharIndex,

   618                                         &prevLineColumn);

   619 			}//end else

   620 		  } //end match

   621         } //end if( !isCloseSingleQuote && !isCloseDoubleQuote)

   622 

   623 

   624 

   625         if ((isOpenSingleQuote & isCloseSingleQuote)

   626             | (isOpenDoubleQuote & isCloseDoubleQuote)) {

   627             break;

   628         }

   629 

   630 		if(entityFoundLevel_2 != CXML_TRUE)

   631 		{

   632          s = NW_XML_Reader_Advance(pT);

   633 		}

   634 		else

   635 		{

   636 		 entityFoundLevel_2 = CXML_FALSE;

   637 		}

   638     }//end for (;;)

   639     NW_XML_Reader_Interval_Stop(pI, pT);

   640     s = NW_XML_Reader_Advance(pT);

   641 

   642     

   643     if( (*entityCheck == CXML_TRUE) && 

   644 		( (entityFoundLevel_2 == CXML_TRUE) || (entityFoundOnce == CXML_TRUE) ) )

   645     {

   646       /* Get rest of the attribute value contents */

   647      

   648 		

   649        tempBufLen = pI->stop - pI->start; 

   650 

   651 		if(tempBufLen > 0)

   652 		{

   653          if(tempStr == NULL)

   654 		 {

   655 		  tempStr = NW_String_new();

   656 		  if(tempStr == NULL)

   657 		  {

   658 		   return NW_STAT_OUT_OF_MEMORY;

   659           }

   660 		  

   661          } /*end if(tempStr == NULL)*/

   662         s = NW_XML_Data_to_String (pT,pI,tempStr);

   663 

   664         if (NW_STAT_IS_FAILURE(s))

   665          {

   666           return s;

   667          }

   668 

   669 

   670 			s = NW_String_concatenate(attrValStr,tempStr,pT->encoding);

   671 

   672 			if (NW_STAT_IS_FAILURE(s))

   673              {

   674               return s;

   675              }

   676 

   677             // Do some clean up

   678 

   679 			if(tempStr != NULL)

   680 			{

   681 			 NW_String_delete(tempStr);

   682 			 tempStr = NULL;

   683 			}

   684 

   685 		}//endif(tempBufLen > 0)

   686 

   687     }//end if( (*entityCheck == CXML_TRUE) && (entityFoundLevel_2 == CXML_TRUE) )

   688 	else

   689 	{

   690 	 *entityCheck = CXML_FALSE;

   691 	}

   692 

   693     return s;

   694 }

   695 

   696 /*

   697 Parses an XML attribute (production ???) in Reader.

   698 If no parse error, then ti_name and ti_attvalue mark the two items.

   699 Allows for leading whitespace.  If l is > 0 then p is a "string" of

   700 length l that is the name that must match (parse error if doesn't).

   701 Assumes position in Reader is at whitespace before or first character

   702 of attribute.

   703 return: *pMatch = 1 if keyword or attribute name found

   704 

   705  Careful about the "entity" parameter passed. This is used both as 

   706  IN/OUT paramter.

   707 

   708   IN --> if(entity == CXML_TRUE): Then parse attribute value for the

   709          entities.

   710 

   711   OUT --> (entity=CXML_TRUE): The entity is found in the attribute value.

   712 */

   713 

   714 

   715 static

   716 NW_Status_t

   717 NW_XML_Parse_AttributeValueConsume(NW_XML_Reader_t* pT,

   718                                    NW_XML_Reader_Interval_t* pI_name,

   719                                    NW_XML_Reader_Interval_t* pI_attvalue,

   720                                    NW_Uint32 l, const NW_Uint8* pKeyword,

   721                                    NW_Uint32* pMatch,

   722 								   CXML_Bool* entity, NW_String_t*  attrValStr,

   723                                    const RPointerArray <CXML_Internal_Entity_t>*  internalEntityList)

   724 {

   725     /*

   726     [41] Attribute ::= Name Eq AttValue

   727     where Name is possibly a keyword that must match

   728     */

   729     NW_Status_t s;

   730     NW_Uint32 match;

   731     NW_Uint32 prevIndex0;

   732     NW_Uint32 prevIndex1;

   733     NW_Uint32 prevCharIndex0;

   734     NW_Uint32 prevCharIndex1;

   735     NW_XML_Reader_LineColumn_t prevLineColumn0;

   736     NW_XML_Reader_LineColumn_t prevLineColumn1;

   737 

   738     *pMatch = 0;

   739 

   740     /* S mandatory */

   741     NW_XML_Reader_GetPosition(pT, &prevIndex0, &prevCharIndex0, &prevLineColumn0);

   742     s = NW_XML_Reader_SkipSpace(pT);

   743     if (NW_STAT_IS_FAILURE(s)) {

   744         return s;

   745     }

   746     NW_XML_Reader_GetPosition(pT, &prevIndex1, &prevCharIndex1, &prevLineColumn1);

   747     if (prevIndex0 == prevIndex1) {

   748         return NW_STAT_FAILURE;

   749     }

   750     /* Name */

   751     if ((l != 0U) && (pKeyword != NULL)) {

   752         s = NW_XML_Parse_KeywordConsume(pT, pI_name, l, pKeyword, pMatch);

   753         if (NW_STAT_IS_SUCCESS(s) && !*pMatch) {

   754             /* backup so mandatory space not consumed */

   755             NW_XML_Reader_SetPosition(pT, prevIndex0, prevCharIndex0, &prevLineColumn0);

   756         }

   757     } else {

   758         s = NW_XML_Parse_NameConsume(pT, pI_name, pMatch);

   759     }

   760     if (NW_STAT_IS_FAILURE(s) || !*pMatch) {

   761         return NW_STAT_FAILURE;

   762     }

   763     /* S */

   764     s = NW_XML_Reader_SkipSpace(pT);

   765     if (NW_STAT_IS_FAILURE(s)) {

   766         return s;

   767     }

   768     /* = */

   769     s = NW_XML_Reader_AsciiCharMatch(pT, '=', &match);

   770     if (NW_STAT_IS_FAILURE(s) || !match) {

   771         return NW_STAT_FAILURE;

   772     }

   773     s = NW_XML_Reader_Advance(pT);

   774     if (NW_STAT_IS_FAILURE(s)) {

   775         return NW_STAT_FAILURE;

   776     }

   777     /* S */

   778     s = NW_XML_Reader_SkipSpace(pT);

   779     if (NW_STAT_IS_FAILURE(s)) {

   780         return s;

   781     }

   782     /* attValue */

   783 

   784    if(*entity == CXML_FALSE)

   785    {

   786     return NW_XML_Parse_ValueConsume(pT, pI_attvalue,entity,NULL, internalEntityList);  

   787    }

   788    else

   789    {

   790     return NW_XML_Parse_ValueConsume(pT, pI_attvalue,entity,attrValStr, internalEntityList);

   791    }

   792 }

   793 

   794 /*

   795 Parses an XML Comment (production 15) in Reader.

   796 If no parse error, then ti marks the Comment--all chars

   797 between the start and end marks including spaces.

   798 Assumes position in Reader is the character after "<!--".

   799 */

   800 static

   801 NW_Status_t

   802 NW_XML_Parse_CommentConsume(NW_XML_Reader_t* pT, NW_XML_Reader_Interval_t* pI,

   803                             const struct NW_XML_Parser_EventCallbacks_s* pE)

   804 {

   805     /*

   806     [15] Comment ::= '<!--' ((Char - '-') | ('-' (Char - '-')))* '-->'

   807 

   808     Note: the pattern with (Char - '-') means that the comment cannot

   809     end with '--->' although it can begin with '<!--...'.

   810 

   811     Also, '--' may not appear in a comment.

   812     BUG not yet implemented

   813     */

   814     NW_Status_t s;

   815     NW_Uint32 match;

   816 

   817     NW_XML_Reader_Interval_Start(pI, pT);

   818     for (;;) {

   819         s = NW_XML_Reader_AsciiStringMatch(pT, NW_XML_String_CommentStopLength,

   820                                         NW_XML_String_CommentStop, &match);

   821         if (NW_STAT_IS_FAILURE(s)) {

   822             return NW_STAT_FAILURE;

   823         }

   824         if (match) {

   825             break;

   826         }

   827         s = NW_XML_Reader_Advance(pT);

   828         if (NW_STAT_IS_FAILURE(s)) {

   829             return NW_STAT_FAILURE;

   830         }

   831     }

   832     NW_XML_Reader_Interval_Stop(pI, pT);

   833     s = NW_XML_Reader_AdvanceOffset(pT, NW_XML_String_CommentStopLength);

   834     NW_ASSERT(NW_STAT_IS_SUCCESS(s)); /* should never fail */

   835     if (pE->Comment_CB != NULL) {

   836         s = (*(pE->Comment_CB))(pT, pI, pE->pClientPointer);

   837     }

   838     return s;

   839 }

   840 

   841 /*

   842 Parses things that start with "<?".  These are XMLDecl, TextDecl and

   843 the Processing Instruction.  On return the formType distinguishes which one

   844 was consumed.  If it was a PI then ti_name marks the PITarget and

   845 ti_content marks the text "argument" of the PI.  If it was an XMLDecl

   846 (or TextDecl) then examine the booleans to see if various attributes appeared.

   847 Note that XMLDecl must have VersionInfo and a TextDecl must not have an SDDecl.

   848 Neither XMLDecl or TextDecl should have additional content

   849 (i.e., *ti_contentValid should be 0).

   850 Assumes position in Reader is the character after "<?".

   851 */

   852 static

   853 NW_Status_t

   854 NW_XML_Parse_PiFormConsume(NW_XML_Reader_t* pT, NW_PiFormTypeTag_t* pFormType,

   855                            NW_Uint32* pNameValid,

   856                            NW_XML_Reader_Interval_t* pI_name,

   857                            NW_Uint32* pVersionValid,

   858                            NW_XML_Reader_Interval_t* pI_version,

   859                            NW_Uint32* pEncodingValid,

   860                            NW_XML_Reader_Interval_t* pI_encoding,

   861                            NW_Uint32* pStandaloneValid,

   862                            NW_XML_Reader_Interval_t* pI_standalone,

   863                            NW_Uint32* pContentValid,

   864                            NW_XML_Reader_Interval_t* pI_content,

   865                            const RPointerArray <CXML_Internal_Entity_t>*  internalEntityList)

   866 {

   867     /*

   868     [16] PI ::= '<?' PITarget (S (Char* - (Char* '?>' Char*)))? '?>'

   869 

   870     [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))

   871 

   872     when name is an XMLDecl or TextDecl then parse according to

   873 

   874     [23] XMLDecl ::= '<?xml' VersionInfo EncodingDecl? SDDecl? S? '?>'

   875 

   876     [77] TextDecl ::= '<?xml' VersionInfo? EncodingDecl S? '?>'

   877 

   878     [24] VersionInfo ::= S 'version' Eq ("'" VersionNum "'"

   879                          | '"' VersionNum '"')

   880 

   881     [26] VersionNum ::= ([a-zA-Z0-9_.:] | '-')+

   882 

   883     [80] EncodingDecl ::= S 'encoding' Eq

   884                           ('"' EncName '"' | "'" EncName "'" )

   885 

   886     [81] EncName ::= [A-Za-z] ([A-Za-z0-9._] | '-')*

   887 

   888     [32] SDDecl ::= S 'standalone' Eq (("'" ('yes' | 'no') "'")

   889                     | ('"' ('yes' | 'no') '"'))

   890 

   891     */

   892     NW_Status_t s;

   893     NW_XML_Reader_Interval_t I_keyword;

   894     NW_Uint32 prevIndex;

   895     NW_Uint32 prevCharIndex;

   896     NW_XML_Reader_LineColumn_t prevLineColumn;

   897     NW_Uint32 match;

   898     NW_Uint32 i;

   899 	CXML_Bool entity = CXML_FALSE;

   900 

   901 

   902     *pNameValid = *pVersionValid = *pEncodingValid = 0;

   903     *pStandaloneValid = *pContentValid = 0;

   904     *pFormType = UNKNOWFORM;

   905 

   906 

   907     s = NW_STAT_FAILURE;

   908     match = 0;

   909     /* Will back up if "xml" is part of a longer name like "xml-stylesheet". */

   910     NW_XML_Reader_GetPosition(pT,

   911                               &prevIndex, &prevCharIndex, &prevLineColumn);

   912     for (i = 0; i < NW_XML_String_XmlNameVariationCount; i++) {

   913         s = NW_XML_Parse_KeywordConsume(pT, pI_name,

   914                                         NW_XML_String_XmlLength,

   915                                         (NW_XML_String_XmlVariations

   916                                          + NW_XML_String_XmlLength * i),

   917                                         &match);

   918         if (NW_STAT_IS_SUCCESS(s) && match) {

   919             /* Make sure that the "xml" variant isn't part of a longer name */

   920             NW_Uint32 m;

   921             /* look for end of piform */

   922             s = NW_XML_Reader_AsciiStringMatch(pT, NW_XML_String_PiFormStopLength,

   923                                             NW_XML_String_PiFormStop, &m);

   924             if (NW_STAT_IS_SUCCESS(s) && m) {

   925                 break;

   926             }

   927             /* look for whitespace */

   928             s = NW_XML_Reader_IsSpace(pT, &m);

   929             if (NW_STAT_IS_SUCCESS(s) && m) {

   930                 break;

   931             }

   932             /* if get here then "xml" variant is part of a longer name,

   933             fail match, back up and shortcut out of loop */

   934             match = 0;

   935             NW_XML_Reader_SetPosition(pT,

   936                                       prevIndex,

   937                                       prevCharIndex,

   938                                       &prevLineColumn);

   939             i = NW_XML_String_XmlNameVariationCount;

   940             break;

   941         }

   942     }

   943 

   944     if (NW_STAT_IS_SUCCESS(s) && !match) {

   945         s = NW_XML_Parse_NameConsume(pT, pI_name, &match);

   946     }

   947     if (NW_STAT_IS_FAILURE(s) || !match) {

   948         return NW_STAT_FAILURE;

   949     }

   950     *pNameValid = 1;

   951 

   952     /* Support all the XML declaration starting with any possible combination. */

   953 

   954     if (i < NW_XML_String_XmlNameVariationCount) 

   955     { 

   956         /* BUG there is currently no checking of legal values according

   957         to productions 26, 81 and 32 */

   958         *pFormType = XMLDECL;

   959         s = NW_XML_Parse_AttributeValueConsume(pT, &I_keyword, pI_version,

   960                                                NW_XML_String_VersionLength,

   961                                                NW_XML_String_Version, &match,

   962 											   &entity,NULL,

   963                                                internalEntityList);

   964         if (NW_STAT_IS_FAILURE(s)) {

   965             if (match) {

   966                 return NW_STAT_FAILURE; /* couldn't parse version value */

   967             }

   968         } else {

   969             if (match) {

   970                 *pVersionValid = 1;

   971             }

   972         }

   973         s = NW_XML_Parse_AttributeValueConsume(pT, &I_keyword, pI_encoding,

   974                                                NW_XML_String_EncodingLength,

   975                                                NW_XML_String_Encoding, &match,

   976 											   &entity,NULL,internalEntityList);

   977         if (NW_STAT_IS_FAILURE(s)) {

   978             if (match) {

   979                 return NW_STAT_FAILURE; /* couldn't parse encoding value */

   980             }

   981         } else {

   982             if (match) {

   983                 *pEncodingValid = 1;

   984             }

   985         }

   986         s = NW_XML_Parse_AttributeValueConsume(pT, &I_keyword, pI_standalone,

   987                                                NW_XML_String_StandaloneLength,

   988                                                NW_XML_String_Standalone, &match,

   989 											   &entity,NULL,internalEntityList);

   990         if (NW_STAT_IS_FAILURE(s)) {

   991             if (match) {

   992                 return NW_STAT_FAILURE; /* couldn't parse standalone value */

   993             }

   994         } else {

   995             if (match) {

   996                 *pStandaloneValid = 1;

   997             }

   998         }

   999     } else {

  1000         *pFormType = PI;

  1001     }

  1002     s = NW_XML_Reader_SkipSpace(pT);

  1003     if (NW_STAT_IS_FAILURE(s)) {

  1004         return NW_STAT_FAILURE;

  1005     }

  1006     NW_XML_Reader_Interval_Start(pI_content, pT);

  1007     for (;;) {

  1008         s = NW_XML_Reader_AsciiStringMatch(pT, NW_XML_String_PiFormStopLength,

  1009                                         NW_XML_String_PiFormStop, &match);

  1010         if (NW_STAT_IS_FAILURE(s)) {

  1011             return NW_STAT_FAILURE;

  1012         }

  1013         if (match) {

  1014             break;

  1015         }

  1016         s = NW_XML_Reader_Advance(pT);

  1017         if (NW_STAT_IS_FAILURE(s)) {

  1018             return NW_STAT_FAILURE;

  1019         }

  1020     }

  1021     NW_XML_Reader_Interval_Stop(pI_content, pT);

  1022     if (pI_content->start == pI_content->stop) {

  1023         *pContentValid = 0;

  1024     } else {

  1025         *pContentValid = 1;

  1026     }

  1027     s = NW_XML_Reader_AdvanceOffset(pT, NW_XML_String_PiFormStopLength);

  1028     NW_ASSERT(NW_STAT_IS_SUCCESS(s)); /* should never fail */

  1029     return s;

  1030 }

  1031 

  1032 /* Assumes position is either at whitespace or beginning of text. */

  1033 static

  1034 NW_Status_t

  1035 NW_XML_Parse_MiscConsume(NW_XML_Reader_t* pT,

  1036                          const struct NW_XML_Parser_EventCallbacks_s* pE,

  1037                          const RPointerArray <CXML_Internal_Entity_t>*  internalEntityList)

  1038 {

  1039     /*

  1040     [27] Misc ::= Comment | PI | S

  1041 

  1042     Note: All invocations of this production take the form "Misc*"

  1043     */

  1044     NW_Status_t s;

  1045     NW_XML_Reader_Interval_t I;

  1046     NW_Uint32 match;

  1047     NW_Uint32 prevIndex0; /* will do while there is advancement thru Reader */

  1048     NW_Uint32 prevIndex1; /* will do while there is advancement thru Reader */

  1049     NW_Uint32 prevCharIndex; /* ignored */

  1050     NW_XML_Reader_LineColumn_t prevLineColumn; /* ignored */

  1051     do {

  1052         NW_XML_Reader_GetPosition(pT, &prevIndex0, &prevCharIndex, &prevLineColumn);

  1053         s = NW_XML_Reader_SkipSpace(pT);

  1054         if (NW_STAT_IS_FAILURE(s)) {

  1055             return NW_STAT_FAILURE;

  1056         }

  1057 

  1058         if(pT->end){

  1059             break;

  1060         }

  1061         s = NW_XML_Parse_KeywordConsume(pT, &I,

  1062                                         NW_XML_String_CommentStartLength,

  1063                                         NW_XML_String_CommentStart, &match);

  1064         if (NW_STAT_IS_FAILURE(s)) {

  1065             return NW_STAT_FAILURE;

  1066         }

  1067         if (match) {

  1068             s = NW_XML_Parse_CommentConsume(pT, &I, pE);

  1069             if (NW_STAT_IS_FAILURE(s)) {

  1070                 return NW_STAT_FAILURE;

  1071             }

  1072         } else {

  1073             s = NW_XML_Parse_KeywordConsume(pT, &I,

  1074                                             NW_XML_String_PiFormStartLength,

  1075                                             NW_XML_String_PiFormStart, &match);

  1076             if (NW_STAT_IS_FAILURE(s)) {

  1077                 return NW_STAT_FAILURE;

  1078             }

  1079             if (match) {

  1080                 NW_PiFormTypeTag_t pi_type;

  1081                 NW_XML_Reader_Interval_t I_name, I_version, I_encoding, I_standalone;

  1082                 NW_XML_Reader_Interval_t I_content;

  1083                 NW_Uint32 nameValid, versionValid, encodingValid, standaloneValid;

  1084                 NW_Uint32 contentValid;

  1085                 s = NW_XML_Parse_PiFormConsume(pT, &pi_type,

  1086                                                &nameValid,

  1087                                                &I_name,

  1088                                                &versionValid,

  1089                                                &I_version,

  1090                                                &encodingValid,

  1091                                                &I_encoding,

  1092                                                &standaloneValid,

  1093                                                &I_standalone,

  1094                                                &contentValid,

  1095                                                &I_content,

  1096                                                internalEntityList);

  1097                 if (NW_STAT_IS_FAILURE(s) || !nameValid) {

  1098                     return NW_STAT_FAILURE;

  1099                 }

  1100                 if (pi_type != PI) {

  1101                     /* BUG Is this really an illegal case? */

  1102                     return NW_STAT_FAILURE;

  1103                 }

  1104                 if (pE->PiForm_CB != NULL) {

  1105                     s = (*(pE->PiForm_CB))(pT, pi_type,

  1106                                            (nameValid ? &I_name : NULL),

  1107                                            (versionValid ? &I_version : NULL),

  1108                                            (encodingValid ? &I_encoding : NULL),

  1109                                            (standaloneValid ? &I_standalone : NULL),

  1110                                            (contentValid ? &I_content : NULL),

  1111                                            pE->pClientPointer);

  1112                 }

  1113             }

  1114         }

  1115         NW_XML_Reader_GetPosition(pT, &prevIndex1, &prevCharIndex, &prevLineColumn);

  1116     } while (prevIndex0 != prevIndex1); /* do while */

  1117     return NW_STAT_SUCCESS;

  1118 }

  1119 

  1120 

  1121 /* on entry position should be just after '<!DOCTYPE' */

  1122 

  1123 static

  1124 NW_Status_t

  1125 NW_XML_Parse_InternalEntity(NW_XML_Reader_t* pT,

  1126                            RPointerArray <CXML_Internal_Entity_t>*  internalEntityList)

  1127 {

  1128  NW_Status_t s;

  1129  NW_XML_Reader_Interval_t I_EntityName;

  1130  NW_Uint32 match;

  1131  NW_XML_Reader_Interval_t I_EntityValue;

  1132  NW_Uint32 quoteChar = 0; /* 0 = double quote, 1 = single quote */

  1133  NW_Uint32 matchDoubleQuote;

  1134  NW_Uint32 matchSingleQuote;