Парсер HTML

void __fastcall TForm1::Button3Click(TObject *Sender)
{
 
Memo2->Clear();
 
AnsiString One;
 
Memo1->Lines->LoadFromFile("baza.txt");
 
One=Memo1->Lines->Text;
 
int p,p2;
 
 while (One.Pos("<a href=")&&One.Pos("</a>")) {
 
 
  if (p == 0 && p2 == 0) break;
 
p=One.Pos("<a href=");
p2=One.Pos("</a>");
AnsiString Value="";
Value=One.SubString(p,p2-p);
if (p!=0&&p2!=0) Memo2->Lines->Add(Value+"</a><br>");
 
 int sPos = One.Pos("<a href=");
  int ePos = One.Pos("</a>");
  if (sPos == 0 && ePos == 0) break;
  if (sPos != 0) One.Delete(sPos,1);
  if (ePos != 0) One.Delete(ePos,1);
}
 
}

#include <boost/regex.hpp>
#include <boost/spirit/core.hpp>
#include <boost/spirit/actor/push_back_actor.hpp>
#include <vector>
#include <string>
 
//...
 
std::string s(Form1->IdHTTP1->Get(SiteURL.t_str());
for (int i = 0; i < 4; i++) {
// Контейнер для значений
std::vector<std::string>values;
// Выражение для разбора
boost::regex expression("[^-+0-9]+");
 
switch (i) {
  case 0: s = forecast1; break;
  case 1: s = forecast2; break;
  case 2: s = forecast3; break;
  case 3: s = forecast4; break;
}
 
// Разбор и заполнение контейнера
if (regex_split(back_inserter(values), s, expression)) {
  int j = 0;
  weather[i].dd = StrToInt(values[j++].c_str());
  weather[i].mm = StrToInt(values[j++].c_str());
  weather[i].yy = StrToInt(values[j++].c_str());
}
 
// ...

#include <windows.h>
//-------------------------------------------------------------------------------------
LRESULT CALLBACK WinProc(HWND, UINT, WPARAM, LPARAM);
//-------------------------------------------------------------------------------------
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hprevInst, LPSTR lpCmdLine, int nCmdShow)
{
  HWND hMainWnd;
  TCHAR szClassName[] = TEXT("WndClass");
  MSG msg;
  WNDCLASSEX wc;
 
  wc.cbSize = sizeof(wc);
  wc.style = CS_HREDRAW | CS_VREDRAW;
  wc.lpfnWndProc = WinProc;
  wc.cbClsExtra = 0;
  wc.cbWndExtra = 0;
  wc.hInstance = hInst;
  wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
  wc.lpszMenuName = NULL;
  wc.lpszClassName = szClassName;
  wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
 
  if(!RegisterClassEx(&wc)) {
    MessageBox(NULL, TEXT("Can't register window class!"), TEXT("Error message"), MB_OK);
    return 0;
  }
 
  hMainWnd = CreateWindow(
    szClassName,
    TEXT("Simple window"),
    WS_OVERLAPPEDWINDOW,
    CW_USEDEFAULT,
    0,
    CW_USEDEFAULT,
    CW_USEDEFAULT,
    (HWND)NULL,
    (HMENU)NULL,
    hInst,
    NULL);
 
  if(!hMainWnd) {
    MessageBox(NULL, TEXT("Can't create the window!"), TEXT("Error message"), MB_OK);
    return 0;
  }
 
  ShowWindow(hMainWnd, nCmdShow);
 
  while(GetMessage(&msg, NULL, 0, 0)) {
    TranslateMessage(&msg);
    DispatchMessage(&msg);
  }
  return msg.wParam;
}
//-------------------------------------------------------------------------------------
LRESULT CALLBACK WinProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  HDC hDC;
  PAINTSTRUCT ps;
  RECT rect;
  switch(uMsg) {
    case WM_PAINT:
      hDC = BeginPaint(hwnd, &ps);
      GetClientRect(hwnd, &rect);
      DrawText(hDC, TEXT("This is just a Window"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
      EndPaint(hwnd, &ps);
      break;
    case WM_CLOSE:
      DestroyWindow(hwnd);
      break;
    case WM_DESTROY:
      PostQuitMessage(0);
      break;
  default:
    return DefWindowProc(hwnd, uMsg, wParam, lParam);
  }
  return 0;
}
//-------------------------------------------------------------------------------------

    class tokenizer
    {
    public:
        enum sep_flag
        {
            single,
            multiple,
            whole_str
        };
        struct token
        {
            const char* ptr;
            unsigned    len;
        };
    public:
        tokenizer(const char* sep, 
                  const char* trim=0,
                  const char* quote="\"",
                  char mask_chr='\\',
                  sep_flag sf=multiple);
        void  set_str(const char* str);
        token next_token();
    private:
        int  check_chr(const char *str, char chr);
    private:
        const char* m_src_string;
        int         m_start;
        const char* m_sep;
        const char* m_trim;
        const char* m_quote;
        char        m_mask_chr;
        unsigned    m_sep_len;
        sep_flag    m_sep_flag;
    };
//-----------------------------------------------------------------------
    inline void tokenizer::set_str(const char* str) 
    { 
        m_src_string = str; 
        m_start = 0;
    }
//-----------------------------------------------------------------------
    inline int tokenizer::check_chr(const char *str, char chr)
    {
        return int(strchr(str, chr));
    }
//-----------------------------------------------------------------------
    tokenizer::tokenizer(const char* sep, 
                         const char* trim,
                         const char* quote,
                         char mask_chr,
                         sep_flag sf) :
        m_src_string(0),
        m_start(0),
        m_sep(sep),
        m_trim(trim),
        m_quote(quote),
        m_mask_chr(mask_chr),
        m_sep_len(sep ? strlen(sep) : 0),
        m_sep_flag(sep ? sf : single)
    {
    }
//-----------------------------------------------------------------------
    tokenizer::token tokenizer::next_token()
    {
        unsigned count = 0;
        char quote_chr = 0;
        token tok;
        tok.ptr = 0;
        tok.len = 0;
        if(m_src_string == 0 || m_start == -1) return tok;
        register const char *pstr = m_src_string + m_start;
        if(*pstr == 0) 
        {
            m_start = -1;
            return tok;
        }
        int sep_len = 1;
        if(m_sep_flag == whole_str) sep_len = m_sep_len;
        if(m_sep_flag == multiple)
        {
//Pass all the separator symbols at the begin of the string
            while(*pstr && check_chr(m_sep, *pstr)) 
            {
                ++pstr;
                ++m_start;
            }
        }
        if(*pstr == 0) 
        {
            m_start = -1;
            return tok;
        }
        for(count = 0;; ++count) 
        {
            char c = *pstr;
            int found = 0;
//We are outside of qotation: find one of separator symbols
            if(quote_chr == 0)
            {
                if(sep_len == 1)
                {
                    found = check_chr(m_sep, c);
                }
                else
                {
                    found = strncmp(m_sep, pstr, m_sep_len) == 0; 
                }
            }
            ++pstr;
            if(c == 0 || found) 
            {
                if(m_trim)
                {
                    while(count && 
                          check_chr(m_trim, m_src_string[m_start]))
                    {
                        ++m_start;
                        --count;
                    }
                    while(count && 
                     check_chr(m_trim, m_src_string[m_start + count - 1]))
                    {
                        --count;
                    }
                }
                tok.ptr = m_src_string + m_start;
                tok.len = count;
//Next time it will be the next separator character
//But we must check, whether it is NOT the end of the string.
                m_start += count;
                if(c) 
                {
                    m_start += sep_len;
                    if(m_sep_flag == multiple)
                    {
//Pass all the separator symbols 
//after the end of the string
                        while(check_chr(m_sep, m_src_string[m_start])) 
                        {
                            ++m_start;
                        }
                    }
                }
                break;
            }
//Switch quote. If it is not a quote yet, try to check any of
//quote symbols. Otherwise quote must be finished with quote_symb
            if(quote_chr == 0)
            {
                if(check_chr(m_quote, c)) 
                {
                    quote_chr = c;
                    continue;
                }
            }
            else
            {
//We are inside quote: pass all the mask symbols
                if(m_mask_chr && c == m_mask_chr)
                {
                    if(*pstr) 
                    {
                        ++count;
                        ++pstr;
                    }
                    continue; 
                }
                if(c == quote_chr) 
                {
                    quote_chr = 0;
                    continue;
                }
            }
        }
        return tok;
    }

    tokenizer cmd_line(" ", "\"' ", "\"'", '\\', tokenizer::multiple);
    cmd_line.set_str(lpszCmdLine);
 
    int argc = 0;
    argv[argc++] = argv_ptr;
    *argv_ptr++ = 0;
 
    while(argc < 64)
    {
        agg::tokenizer::token tok = cmd_line.next_token();
        if(tok.ptr == 0) break;
        if(tok.len)
        {
            memcpy(argv_ptr, tok.ptr, tok.len);
            argv[argc++] = argv_ptr;
            argv_ptr += tok.len;
            *argv_ptr++ = 0;
        }
    }

RichEdit2->Clear();
 
AnsiString One;
 
 
One = RichEdit1->Lines->Text;
 
int p,p2,i;
 
 while (One.Pos("[")&&One.Pos("]")) {
    if (p == 0 && p2 == 0) break;
 
p=One.Pos("[");
p2=One.Pos("]");
AnsiString Value="";
Value=One.SubString(p,p2-p);
if (p!=0&&p2!=0) RichEdit2->Lines->Add(Value);
 
 int sPos = One.Pos("[");
  int ePos = One.Pos("]");
  if (sPos == 0 && ePos == 0) break;
  if (sPos != 0) One.Delete(sPos,1);
  if (ePos != 0) One.Delete(ePos,1);