videoProcessor/httpLexer.cpp at master · dknvdenis/videoProcessor · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include "httpLexer.h"
#include <tuple>
#include "log.h"

#if 0
    #define PRINT_TOKEN(token) \
        PRINT_LOG(">>> " << TokenTypeToString(token.type) \
                  << (token.type == TokenType::string \
                      ? "\t\"" + token.toString() + "\"" \
                      : ""))
#else
    #define PRINT_TOKEN(token)
#endif


HttpLexer::HttpLexer(IStreamReaderPtr reader)
    : m_reader(reader)
{

}

std::vector<Token> HttpLexer::getTokens()
{
    std::vector<Token> result;

    while (true)
    {
        Token token = getToken();
        if (token.isUnknown())
            break;

        result.push_back(token);
    }

    return result;
}

Token HttpLexer::getToken()
{
    if (m_charIter.eof())
        m_charIter = m_reader->read();

    if (m_charIter.eof())
    {
        PRINT_TOKEN(Token());
        return Token();
    }

    TokenType type = TokenType::unknown;
    auto iter = m_charIter.begin;

    for (; iter != m_charIter.end; ++iter)
    {
        char sym = *iter;

        switch (sym)
        {
        case ' ':
            type = TokenType::space;
            break;

        case '=':
            type = TokenType::equalSign;
            break;

        case '&':
            type = TokenType::ampersand;
            break;

        case '\n':
            type = TokenType::lf;
            break;

        case '\r':
            type = TokenType::cr;
            break;

        default:
            type = TokenType::unknown;
        }

        if (type != TokenType::unknown)
        {
            if (m_charIter.begin != iter)
            {
                auto token = Token(TokenType::string, m_charIter.begin, iter);
                m_charIter.begin = iter;
                PRINT_TOKEN(token);
                return token;
            }
            else
            {
                m_charIter.begin = iter + 1;
                auto token = Token(type, iter, iter + 1);
                PRINT_TOKEN(token);
                return token;
            }
        }
    }

    if (type == TokenType::unknown)
    {
        auto token = Token(TokenType::string, m_charIter.begin, m_charIter.end);
        m_charIter.begin = iter;
        PRINT_TOKEN(token);
        return token;
    }

    PRINT_TOKEN(Token());
    return Token();
}