Чем лучше парсить xml?

#include <vcl.h>
#pragma hdrstop
 
#include "XMLParser.h"
 
//---------------------------------------------------------------------------
 
#pragma package(smart_init)
 
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
 
XmlParser::XmlParser(string fileName) : m_fileName(fileName)
{
  // Открыть файл XML документа.
  curState = 0;
  predStack = 0;
  startNode = NULL;
  fp = fopen( fileName.c_str(), "r" );
}
 
XmlParser::~XmlParser()
{
// Закрываем XML файл и высвобождаем все ресурсы
  fclose(fp);
}
 
int XmlParser::runParse()
{   
char predChar;// Предыдущий символ
char curChar; // Текущий символ
curState = 0;
gotAttribName = false;// Имя или значение атрибута
numArgs = -1;
bool startTag = false;
 // Process characters until the file is empty.
    predChar = ' ';
    curChar = (char)fgetc(fp);
    while(!feof(fp))
    {
      switch(curState)
      {
    case XML_NOSTATE:// Стартовый тег ещё не найден
      if (curChar == '<')// Нашли стартовый тег
      {
            if(numArgs >= 0)
              for(int i=0; i<=numArgs; i++)
              {
                curArgs[i].argName = "";
                curArgs[i].argValue = "";
              }
            curText = "";
            startTag = false;
        curState = XML_TAGNAME;// Переходим к получению наименования тега
        numArgs = -1;           // Сбрасываем счётчик аргументов
        curTagName = "";        // Обнуляем имя тега
        gotAttribName = false;  // Получить имя атрибута
      }
       break;
 
    case XML_TAGNAME:// Получаем наименование тега
          if((predChar == '<' && curChar == '!') ||
             (predChar == '<' && curChar == '?')) {curState = XML_NOSTATE; break;}
          if(predChar == '<' && curChar == '/')// Переходим на ввод замыкающего тега
            {curState = XML_ENDTAG; break;}
          // Только латинские буквы, цифры от 0 до 9 и знак подчёркивания
      if ((curChar >= 'a' && curChar <= 'z')||(curChar >= 'A' && curChar <= 'Z')||
              (curChar >= '0' && curChar <= '9') || curChar == '_')
        curTagName += curChar;// Если символ допустимый, то формируем имя тега
      else
            if (curChar == ' ')
              {
            curState = XML_TAGATTRIB;// Имя получено, переходим к получению аргументов
                numArgs++;
              }
        else
              if (curChar == '>')// Тег закрылся, переходим к анализу нового тега
          {
        curState = XML_NOTAG;
        // Имя тега, количество атрибутов и массив аргументов передаём для анализа
        beginTag(curTagName, numArgs, curArgs);
          }
              else return 1; // Ошибка в имени тега
      break;
 
    case XML_TAGATTRIB:// Получение атрибутов тега
          if(gotAttribName)
            {
              if((predChar == '=' && curChar == '"') ||
                 (predChar == '"' && curChar == '"'))
                 break;
              if((predChar == '"' && curChar == '>') ||
                 (predChar == '"' && curChar == '/'))
              {
                curState = XML_NOTAG;
                beginTag(curTagName, numArgs, curArgs);
                break;
              }
              if(predChar == '"' && curChar == ' ')
              {
                gotAttribName = false;
                numArgs++;
                break;
              }
              else
              {
                if(curChar != '"')
                  curArgs[numArgs].argValue += curChar;
                break;
              }
            }
          else  
          {
            // Символ допустимый?
        if ((curChar >= 'a' && curChar <= 'z')||(curChar >= 'A' && curChar <= 'Z')||
                (curChar >= '0' && curChar <= '9') || curChar == '_')
        { // Да, формируем имя аргумента
              curArgs[numArgs].argName += curChar; break;
            }
            else // Нет
            {
              if(curChar == '='){gotAttribName = true; break;}
              return 2;// Ошибка в аргументе
            }
          }
 
    case XML_NOTAG:
              if(predChar == '/' && curChar == '>')
              {
                curState = XML_NOSTATE;
                break;
              }
      if (curChar == '<')
      {
        startTag = true;
            curState = XML_NOSTATE;
            if(curText != "")
              doInside(curText);
      }
      else
      {
            if((predChar == '>' && curChar == ' ') ||
               (predChar == ' ' && curChar == ' ') ||
               (predChar == ' ' && curChar == '<') ||
                curChar == '\n' || curChar == '\t') break;
        curText += curChar;
      }
          break;
    case XML_ENDTAG:
      if (curChar == '>')
      {
        curState = XML_NOSTATE;
        endTag(curTagName);
      }
      else
            // Только латинские буквы, цифры от 0 до 9 и знак подчёркивания
            if ((curChar >= 'a' && curChar <= 'z')||(curChar >= 'A' && curChar <= 'Z')||
                (curChar >= '0' && curChar <= '9') || curChar == '_')
          curTagName += curChar;
          break;
      } // end switch
      if(!startTag)
      {
        predChar = curChar;// Сохраняем предыдущий символ
        curChar = (unsigned char)fgetc(fp);
      }
    } // end while
return 0;
}
// Имя и атрибуты тега получены
bool XmlParser::beginTag(string tagID, int numParams, TagArg params[10])
{
/* Создаём новый узел
newNode = new XMLnode;    // Создаём корневой элемент списка
newNode->tagName = tagID; // Вводим имя тега
newNode->tagText = "";    // Текст тега = пустая строка
newNode->numParams = numParams;
if(numParams >= 0)// Вводим параметры
  for(int i=0; i<=numParams; i++) newNode->argum[i] = params[i];
newNode->leftNode  = NULL;
newNode->rightNode = NULL;
 
if(Stack.empty())// Стек пуст ?
{// Да, создать корневой узел
  startNode = newNode;
  leftNode  = newNode;
  rightNode = newNode;    
}
else
{
  if(Stack.size() == predStack)// Текущее = предыдущему ?
  {// Да, добавить в правую ветку
    rightNode = newNode;
  }
  else
  {
    if(Stack.size() > predStack)// Текущее больше предыдущего ?
    {// Да, добавить в левую ветку
       //int size = Stack.size();
    }
    else// Нет, добавить в правую ветку
      if((Stack.size() +1) != predStack)// Текущее +1 != предыдущему ?
      {// Ошибка в порядке следования тегов
        return false;
      }
  }
}
predStack = Stack.size();
Stack.push(tagID);*/
//string N = params[0].argName;
//string V = params[0].argValue;
return true;
//
}
// Имя закрывающего тега получено
void XmlParser::endTag(string tagID)
{/*
if(! Stack.empty())
{
  Stack.pop();
  predStack = Stack.size();
} */
return;
}
// Текст между тегами получен
void XmlParser::doInside(string tagText)
{
return;
}

/*
// Пример подключения класса
XmlParser * XMP = new XmlParser("Test.xml");
XMP->runParse();
delete XMP;
*/
//---------------------------------------------------------------------------
#ifndef __XMLPARSER_H
#define __XMLPARSER_H
 
#include <stack>
#include <string>
//#include <stdio.h>
 
#define XML_NOSTATE   0
#define XML_TAGNAME   1
#define XML_TAGATTRIB 2
#define XML_NOTAG     3
#define XML_ENDTAG    4
using namespace::std;
 
// Тип Данных для параметров тэга
struct TagArg
{
    string argName;
    string argValue;
};
 
struct XMLnode
{
string tagName;
string tagText;
int numParams;
TagArg argum[10];
XMLnode *leftNode;// Движение по столбцу
XMLnode *rightNode;// Движение по строке
};
/*
struct XMLrecipe
{
bool ooo;
int arg;
XMLnode argum[3];
int desc;
XMLnode descript[10];
int ingr;
XMLnode ingred[25];
//XMLrecipe recipe_ptr;
};
*/
class XmlParser
{
public:
    XmlParser(string fileName);
    ~XmlParser();
 
    int runParse();
 
protected:
    virtual void endTag(string tagID);
    virtual bool beginTag(string tagID, int numParams, TagArg params[10]);
    virtual void doInside(string tagText);
 
private:
        stack<string> Stack;
        unsigned int predStack;
 
    string m_fileName; // Имя файла
    FILE* fp;
 
    int curState;      // Переключатель
    bool gotAttribName; // false - имя атрибута true - его параметр
 
    string curTagName;  // Наименование тега
    string curText;     // Текст между тегами
 
    int numArgs;       // Количество атрибутов
    TagArg curArgs[10]; // Список атрибутов
 
        // Переменные управления узлами
        XMLnode *newNode;  // Указатель на новый узел
        XMLnode *startNode;// Указатель на первый элемент
        XMLnode *leftNode;  // Указатель на последний элемент столбца
        XMLnode *rightNode;  // Указатель на последний элемент строки
 
};
 
#endif