xmlwf.c

一个基于SAX分析方法的XML文档解析函数包

void SkipSpace()
{	
	if(!IsMemberOf(buffer[cursor], space, SizeOfSpace)) return;
	if(cursor > BUF_SIZE+1) RefreshBuffer();

	while(IsMemberOf(buffer[cursor], space, SizeOfSpace)){		
		if(buffer[cursor] == '\n'){ 
			row++;
			col = 0;
		}
		cursor++;
		if(cursor > BUF_SIZE+1) RefreshBuffer();
	}	
}

void GetXMLCharUntilSpace(Pxml_parser parser,   PXML_String pXML_String)
{
	XML_Char currentChar;

	SkipSpace();

	currentChar=GetChar();
		while(!IsMemberOf(currentChar, space, STRLEN(space))){
			if(XML_AddXMLChar(pXML_String, currentChar) != STRING_SUCCESS){
				ErrorHappen(parser,  "Adding a character to a string error.");
				return;
			} 
			currentChar=GetChar();
		}
}

/**
The file stream pointer ending in pointing to the character 'xml_char'. 
*/
void GetXMLCharUntil(XML_Char xml_char, Pxml_parser parser,   PXML_String pXML_String)
{
	XML_Char currentChar;

	SkipSpace();
	currentChar=GetChar();

	while(currentChar != xml_char){
		if(XML_AddXMLChar(pXML_String, currentChar) != XML_SUCCESS){
			ErrorHappen(parser, "Error in system:Out Of memory");
			return;
		} 
		currentChar=GetChar();
	}
}

void GetCharForProperName(Pxml_parser parser, PXML_String pStr)
{
	XML_Char currentChar= GetChar();
	while((currentChar == '_')||(currentChar == '-')||(currentChar == ':')||(currentChar == '.')||(IsMemberOf(currentChar, letters, STRLEN(letters)))||(IsMemberOf(currentChar, digit, STRLEN(digit)))||(IsMemberOf(currentChar, signs, STRLEN(signs)))||(IsMemberOf(currentChar, ascii2, STRLEN(ascii2)))){
		if(currentChar == '='){
			GoBack(1);
			return;
		}
		if(currentChar == '/' && buffer[cursor] == '>'){
			GoBack(1);			
			return;
		}
		if(XML_AddXMLChar(pStr, currentChar) != XML_SUCCESS){
			 ((PXML_Parser)parser)->parserErrorHandler( ((PXML_Parser)parser)->userData, "Error in system:Out Of memory");
			return;
		}
		currentChar = GetChar();
	}

	GoBack(1);
}
/**
The property name is also the element name.
*/
void proper_name(Pxml_parser parser,   PXML_String pStrProperName)
{
	XML_Char current = GetChar();
	if(!((current == '_')||(IsMemberOf(current, letters, STRLEN(letters)))||(IsMemberOf(current, ascii2, STRLEN(ascii2))))){
		 ((PXML_Parser)parser)->parserErrorHandler( ((PXML_Parser)parser)->userData, "Error in element or property naming:The start char of name is invalid!");
		return;
	}

	if(XML_AddXMLChar(pStrProperName, current) != XML_SUCCESS){
			 ((PXML_Parser)parser)->parserErrorHandler( ((PXML_Parser)parser)->userData, "Error in system:Out Of memory");
			return;
		}

	GetCharForProperName(parser, pStrProperName);
}


void  GetCharForProperValue(Pxml_parser parser, PXML_String pStr)
{
	XML_Char currentChar= GetChar();
	while(( currentChar != '\'')&&( currentChar !='\"')){
		if(currentChar == '<' || currentChar=='>'||currentChar=='&'){
			 ((PXML_Parser)parser)->parserErrorHandler( ((PXML_Parser)parser)->userData, "Error in peoperty value syntax:Reserved character is used.");
			return;
		}
		if(XML_AddXMLChar(pStr, currentChar) != STRING_SUCCESS){
			ErrorHappen(parser, "Error in head parsing: Adding character failed.");
		}
		currentChar = GetChar();
	}
}

void proper_value(Pxml_parser parser,   PXML_String pStrProperValue)
{	
	GetCharForProperValue(parser,  pStrProperValue);
}

PAttriPairs Proper_token(Pxml_parser parser )
{	
	XML_Char currentChar;
	PAttriPairs ppttripairs = NULL;
	PXML_String properName = CreateXML_String();
	PXML_String properValue = CreateXML_String();	
	XML_ASSERT(properName);
	XML_ASSERT(properValue);

	SkipSpace();

	proper_name(parser, properName);
	if(!properName->length) return NULL;

	SkipSpace();
	if(currentChar=GetChar() != '='){		
			 ((PXML_Parser)parser)->parserErrorHandler( ((PXML_Parser)parser)->userData, "Error in peoperty syntax:No '=' between name and value.");
			return NULL;
		}
	SkipSpace();

	if(currentChar=GetChar() != '\"' && currentChar !='\''){
			 ((PXML_Parser)parser)->parserErrorHandler( ((PXML_Parser)parser)->userData, "Error in peoperty syntax:No '\"' before property value.");
			return NULL;
		} 

	proper_value(parser,  properValue);

	ppttripairs= AttriPairsCreate(properName->data, properValue->data);

	FreeXML_String(properName);
	FreeXML_String(properValue);

	return ppttripairs;
}
/**
*/
  //begin: Header process function series
void XML_Header(Pxml_parser parser)
{
	int i = 0;
	XML_Char currentChar ;
	PXML_String buf = CreateXML_String();
	PAttributes pAttri = AtrributesCreate();
	PAttriPairs pattriPairs = NULL;
	XML_ASSERT_VOID(pAttri);

	SkipSpace(); 
	currentChar = GetChar();
	if(currentChar == '<'){
		SkipSpace();
		currentChar = GetChar();
		
		while(!IsMemberOf(currentChar, space, STRLEN(space))){		
			if(XML_AddXMLChar(buf, currentChar) != XML_SUCCESS){
				ErrorHappen(parser, "Error in Head processing:Memory out!");				 
				return;
			}
			currentChar = GetChar();
		}
	}else{
		ErrorHappen(parser, "Error in Head processing:Xml file error in syntax!");
		return;
	}

	if(XML_StrPCharCmp(buf, JTEXT("?xml"))){
		ErrorHappen(parser, "Error in Head processing:No valid head assert! \"<?xml>\" is expected.");		
		return;
	}

	FreeXML_String(buf);
	SkipSpace();

	currentChar = GetChar();

	while(currentChar != '?'){
		GoBack(1);
		pattriPairs = Proper_token( parser);
/**
puts(pattriPairs->name->data);
putchar('\n');
puts(pattriPairs->value->data);
putchar('\n');
*/
		XML_ASSERT_VOID(pattriPairs);
	    addAttribute(pAttri, pattriPairs);	

		SkipSpace();
		currentChar = GetChar();
	}

	currentChar = GetChar();
	if(currentChar != '>') {
		ErrorHappen(parser, "Error in head syntax:Invalid end character of the head.");		
		return;
	}

	if(((PXML_Parser)parser)->startDocumentHandler != NULL)
		((PXML_Parser)parser)->startDocumentHandler( ((PXML_Parser)parser)->userData, pAttri);
	/*
	pattriPairs = pAttri->pairsHead;
	
	for(i = 0;i< pAttri->size; i++){
		printf("Name:%s\n", pattriPairs->name->data);
		printf("Value:%s\n", pattriPairs->value->data);
		printf("----------------------------\n");
		pattriPairs = pattriPairs->next;
	}
	*/
	AttributesFree(pAttri);
}
  //end: Header process function series

  //Start: Explanation, comments, instruction process function series
void XML_Comments(Pxml_parser parser)
{
	XML_Char xml_char;
	PXML_String pXml_string = CreateXML_String();
	XML_ASSERT_VOID(pXml_string);

	xml_char = GetChar();
		
	while(1){
//		if(IsMemberOf(xml_char, letters, STRLEN(letters))||IsMemberOf(xml_char, digit, STRLEN(digit))||IsMemberOf(xml_char, signs, STRLEN(signs))||IsMemberOf(xml_char, ascii2, STRLEN(ascii2))||IsMemberOf(xml_char, space, STRLEN(space)) )
		if(xml_char == '-'){
			xml_char = GetChar();
			if(xml_char == '-'){
				xml_char = GetChar();
				if(xml_char == '>'){
					GoBack(2);
					break;
				}else{
					GoBack(1);
					if(XML_AddXMLChar(pXml_string, '-') != STRING_SUCCESS){
						ErrorHappen(parser, "Error in comments: Invalid characters included in the comment.");
						return;
					}
					if(XML_AddXMLChar(pXml_string, '-') != STRING_SUCCESS){
						ErrorHappen(parser, "Error in comments: Invalid characters included in the comment.");
						return;
					}
				}
			}else{
				GoBack(1);
			}
		}

		if(xml_char == '<' || xml_char == '>'){
			ErrorHappen(parser, "Error in syntax of comments:\'<\' or \'>\' should not appear.");
			return;
		}
			if(XML_AddXMLChar(pXml_string, xml_char) != STRING_SUCCESS){
				ErrorHappen(parser, "Error in comments: Invalid characters included in the comment.");
				return;
			}
		xml_char = GetChar();		
	}

	if(((PXML_Parser)parser)->commentHandler != NULL)
		((PXML_Parser)parser)->commentHandler(pXml_string->data);

	XML_ClearStr(pXml_string);

	GetXMLCharUntil('>', parser, pXml_string);

	if(XML_StrPCharCmp(pXml_string, JTEXT("-"))){
		ErrorHappen(parser, "Error in comments: Invalid end string of the comment \"-->\" expected.");
		FreeXML_String(pXml_string);
		return;
	}

	FreeXML_String(pXml_string);
}

void InstructProcess(PXML_String pReservedWord, PAttributes pAttri)
{
	PAttriPairs p = pAttri->pairsHead;
//	printf("\t%s\n", pReservedWord->data);
/*
	for(i = 0; i<pAttri->size;i++){
		printf("Name:%s; Value:%s\n", p->name->data, p->value->data);
		p = p->next;
	}
*/

	/**
	Lefted to implement in latter version.
	*/
}

void XML_Instruct(Pxml_parser parser)
{
	PAttributes pAttri = AtrributesCreate();
	PAttriPairs pattriPairs = NULL;
	XML_Char currentChar;
	PXML_String pReservedWord = CreateXML_String();

	XML_ASSERT_VOID(pAttri);		
	XML_ASSERT_VOID(pReservedWord);

	SkipSpace();
	GetXMLCharUntilSpace(parser, pReservedWord);
	SkipSpace();
	currentChar = GetChar();
	while(currentChar !='?'){
		GoBack(1);
		pattriPairs = Proper_token(parser);
		XML_ASSERT_VOID(pattriPairs);
	    addAttribute(pAttri, pattriPairs);

		SkipSpace();
		currentChar = GetChar();
	}

	InstructProcess(pReservedWord, pAttri);
	
	AttributesFree(pAttri);
	FreeXML_String(pReservedWord);

	currentChar = GetChar();
	if(currentChar != '>'){
		ErrorHappen(parser, "Error in instruction syntax:Invalid end string.");
		return;
	}
}

void DeclareProByReserved(PXML_String pReservedWord, PXML_String pToken)
{
//	printf("\t%s:%s\n", pReservedWord->data, pToken->data);

	/**
	Lefted to implement in latter version.
	*/
}

void XML_Declare(Pxml_parser parser)
{
	PXML_String pReservedWord = CreateXML_String();
	PXML_String pToken        = CreateXML_String();
	XML_ASSERT_VOID(pReservedWord);
	XML_ASSERT_VOID(pToken);

	SkipSpace();
	GetXMLCharUntilSpace(parser, pReservedWord);
	SkipSpace();
	GetXMLCharUntil('>', parser, pToken);

//	XML_AddXMLChar(pToken, '>');

	DeclareProByReserved(pReservedWord, pToken);
	FreeXML_String(pReservedWord);
	FreeXML_String(pToken);

}

  //End: Explanation, comments, instruction process function series

  //Start: Element process function series
void XML_ElementText(Pxml_parser parser, PXML_String pElementText, _BOOL isCdata)
{	 
	XML_Char currentChar = GetChar();
	if(currentChar == '<'){
		GoBack(1);
		return;
	}

	GoBack(1);

	if(isCdata) 	GetXMLCharUntil(']', parser, pElementText);
	else GetXMLCharUntil('<', parser, pElementText);
	
	GoBack(1);
}

void ProcessCommentInElement(Pxml_parser parser)
{
	PXML_String pComment = CreateXML_String();
	XML_Char    xml_char;

	XML_ASSERT_VOID(pComment);

	xml_char = GetChar();
	while(1){
		if(xml_char == '-'){
			xml_char = GetChar();
			if(xml_char == '-'){
				xml_char = GetChar();
				if(xml_char == '>') break;
				else{
					XML_StrPCharCat(pComment, JTEXT("--"));
					XML_AddXMLChar(pComment, xml_char);
				}
			}else{
				XML_AddXMLChar(pComment, '-');
				XML_AddXMLChar(pComment, xml_char);
			}
		}else XML_AddXMLChar(pComment, xml_char);