← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sflphone/trusty

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/pjlib/include/pj++/scanner.hpp

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (4.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20140128182336-jrsv0k9u6cawc068
Tags: 1.3.0-1
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.1.0/pjlib/include/pj++/scanner.hpp
 
1
/* $Id: scanner.hpp 2394 2008-12-23 17:27:53Z bennylp $ */
 
2
/* 
 
3
 * Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
 
4
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 
19
 */
 
20
#ifndef __PJPP_SCANNER_HPP__
 
21
#define __PJPP_SCANNER_HPP__
 
22
 
 
23
#include <pjlib-util/scanner.h>
 
24
#include <pj++/string.hpp>
 
25
 
 
26
class Pj_Cis;
 
27
class Pj_Cis_Buffer;
 
28
class Pj_Scanner;
 
29
 
 
30
class Pj_Cis_Buffer
 
31
{
 
32
    friend class Pj_Cis;
 
33
 
 
34
public:
 
35
    Pj_Cis_Buffer() 
 
36
    { 
 
37
        pj_cis_buf_init(&buf_); 
 
38
    }
 
39
 
 
40
private:
 
41
    pj_cis_buf_t buf_;
 
42
};
 
43
 
 
44
 
 
45
class Pj_Cis
 
46
{
 
47
    friend class Pj_Scanner;
 
48
 
 
49
public:
 
50
    Pj_Cis(Pj_Cis_Buffer *buf)
 
51
    {
 
52
        pj_cis_init(&buf->buf_, &cis_);
 
53
    }
 
54
 
 
55
    Pj_Cis(const Pj_Cis &rhs)
 
56
    {
 
57
        pj_cis_dup(&cis_, (pj_cis_t*)&rhs.cis_);
 
58
    }
 
59
 
 
60
    void add_range(int start, int end)
 
61
    {
 
62
        pj_cis_add_range(&cis_, start, end);
 
63
    }
 
64
 
 
65
    void add_alpha()
 
66
    {
 
67
        pj_cis_add_alpha(&cis_);
 
68
    }
 
69
 
 
70
    void add_num()
 
71
    {
 
72
        pj_cis_add_num(&cis_);
 
73
    }
 
74
 
 
75
    void add_str(const char *str)
 
76
    {
 
77
        pj_cis_add_str(&cis_, str);
 
78
    }
 
79
 
 
80
    void add_cis(const Pj_Cis &rhs)
 
81
    {
 
82
        pj_cis_add_cis(&cis_, &rhs.cis_);
 
83
    }
 
84
 
 
85
    void del_range(int start, int end)
 
86
    {
 
87
        pj_cis_del_range(&cis_, start, end);
 
88
    }
 
89
 
 
90
    void del_str(const char *str)
 
91
    {
 
92
        pj_cis_del_str(&cis_, str);
 
93
    }
 
94
 
 
95
    void invert()
 
96
    {
 
97
        pj_cis_invert(&cis_);
 
98
    }
 
99
 
 
100
    bool match(int c) const
 
101
    {
 
102
        return pj_cis_match(&cis_, c) != 0;
 
103
    }
 
104
 
 
105
private:
 
106
    pj_cis_t cis_;
 
107
};
 
108
 
 
109
 
 
110
 
 
111
class Pj_Scanner
 
112
{
 
113
public:
 
114
    Pj_Scanner() {}
 
115
 
 
116
    enum
 
117
    {
 
118
        SYNTAX_ERROR = 101
 
119
    };
 
120
    static void syntax_error_handler_throw_pj(pj_scanner *);
 
121
 
 
122
    typedef pj_scan_state State;
 
123
 
 
124
    void init(char *buf, int len, unsigned options=PJ_SCAN_AUTOSKIP_WS, 
 
125
              pj_syn_err_func_ptr callback = &syntax_error_handler_throw_pj)
 
126
    {
 
127
        pj_scan_init(&scanner_, buf, len, options, callback);
 
128
    }
 
129
 
 
130
    void fini()
 
131
    {
 
132
        pj_scan_fini(&scanner_);
 
133
    }
 
134
 
 
135
    int eof() const
 
136
    {
 
137
        return pj_scan_is_eof(&scanner_);
 
138
    }
 
139
 
 
140
    int peek_char() const
 
141
    {
 
142
        return *scanner_.curptr;
 
143
    }
 
144
 
 
145
    int peek(const Pj_Cis *cis, Pj_String *out)
 
146
    {
 
147
        return pj_scan_peek(&scanner_,  &cis->cis_, out);
 
148
    }
 
149
 
 
150
    int peek_n(pj_size_t len, Pj_String *out)
 
151
    {
 
152
        return pj_scan_peek_n(&scanner_, len, out);
 
153
    }
 
154
 
 
155
    int peek_until(const Pj_Cis *cis, Pj_String *out)
 
156
    {
 
157
        return pj_scan_peek_until(&scanner_, &cis->cis_, out);
 
158
    }
 
159
 
 
160
    void get(const Pj_Cis *cis, Pj_String *out)
 
161
    {
 
162
        pj_scan_get(&scanner_, &cis->cis_, out);
 
163
    }
 
164
 
 
165
    void get_n(unsigned N, Pj_String *out)
 
166
    {
 
167
        pj_scan_get_n(&scanner_, N, out);
 
168
    }
 
169
 
 
170
    int get_char()
 
171
    {
 
172
        return pj_scan_get_char(&scanner_);
 
173
    }
 
174
 
 
175
    void get_quote(int begin_quote, int end_quote, Pj_String *out)
 
176
    {
 
177
        pj_scan_get_quote(&scanner_, begin_quote, end_quote, out);
 
178
    }
 
179
 
 
180
    void get_newline()
 
181
    {
 
182
        pj_scan_get_newline(&scanner_);
 
183
    }
 
184
 
 
185
    void get_until(const Pj_Cis *cis, Pj_String *out)
 
186
    {
 
187
        pj_scan_get_until(&scanner_, &cis->cis_, out);
 
188
    }
 
189
 
 
190
    void get_until_ch(int until_ch, Pj_String *out)
 
191
    {
 
192
        pj_scan_get_until_ch(&scanner_, until_ch, out);
 
193
    }
 
194
 
 
195
    void get_until_chr(const char *spec, Pj_String *out)
 
196
    {
 
197
        pj_scan_get_until_chr(&scanner_, spec, out);
 
198
    }
 
199
 
 
200
    void advance_n(unsigned N, bool skip_ws=true)
 
201
    {
 
202
        pj_scan_advance_n(&scanner_, N, skip_ws);
 
203
    }
 
204
 
 
205
    int strcmp(const char *s, int len)
 
206
    {
 
207
        return pj_scan_strcmp(&scanner_, s, len);
 
208
    }
 
209
 
 
210
    int stricmp(const char *s, int len)
 
211
    {
 
212
        return pj_scan_stricmp(&scanner_, s, len);
 
213
    }
 
214
 
 
215
    void skip_ws()
 
216
    {
 
217
        pj_scan_skip_whitespace(&scanner_);
 
218
    }
 
219
 
 
220
    void save_state(State *state) const
 
221
    {
 
222
        pj_scan_save_state(&scanner_, state);
 
223
    }
 
224
 
 
225
    void restore_state(State *state)
 
226
    {
 
227
        pj_scan_restore_state(&scanner_, state);
 
228
    }
 
229
 
 
230
    int get_pos_line() const
 
231
    {
 
232
        return scanner_.line;
 
233
    }
 
234
 
 
235
    int get_pos_col() const
 
236
    {
 
237
        return pj_scan_get_col(&scanner_);
 
238
    }
 
239
 
 
240
 
 
241
private:
 
242
    pj_scanner scanner_;
 
243
};
 
244
 
 
245
#endif  /* __PJPP_SCANNER_HPP__ */
 
246