← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to tools/porting/src/cpplexer.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/porting/src/cpplexer.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2004-2005 Trolltech AS. All rights reserved.
 
4
** Copyright (C) 2001-2004 Roberto Raggi
 
5
**
 
6
** This file is part of the porting application of the Qt Toolkit.
 
7
**
 
8
** This file may be distributed under the terms of the Q Public License
 
9
** as defined by Trolltech AS of Norway and appearing in the file
 
10
** LICENSE.QPL included in the packaging of this file.
 
11
**
 
12
** This file may be distributed and/or modified under the terms of the
 
13
** GNU General Public License version 2 as published by the Free Software
 
14
** Foundation and appearing in the file LICENSE.GPL included in the
 
15
** packaging of this file.
 
16
**
 
17
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 
18
**   information about Qt Commercial License Agreements.
 
19
** See http://www.trolltech.com/qpl/ for QPL licensing information.
 
20
** See http://www.trolltech.com/gpl/ for GPL licensing information.
 
21
**
 
22
** Contact info@trolltech.com if any conditions of this licensing are
 
23
** not clear to you.
 
24
**
 
25
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
26
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
27
**
 
28
****************************************************************************/
 
29
#include "cpplexer.h"
 
30
#include <locale>
 
31
#include <QChar>
 
32
using namespace TokenEngine;
 
33
 
 
34
CppLexer::CppLexer()
 
35
{
 
36
    setupScanTable();
 
37
}
 
38
 
 
39
void CppLexer::setupScanTable()
 
40
{
 
41
    s_scan_keyword_table[0] = &CppLexer::scanKeyword0;
 
42
    s_scan_keyword_table[1] = &CppLexer::scanKeyword0;
 
43
    s_scan_keyword_table[2] = &CppLexer::scanKeyword2;
 
44
    s_scan_keyword_table[3] = &CppLexer::scanKeyword3;
 
45
    s_scan_keyword_table[4] = &CppLexer::scanKeyword4;
 
46
    s_scan_keyword_table[5] = &CppLexer::scanKeyword5;
 
47
    s_scan_keyword_table[6] = &CppLexer::scanKeyword6;
 
48
    s_scan_keyword_table[7] = &CppLexer::scanKeyword7;
 
49
    s_scan_keyword_table[8] = &CppLexer::scanKeyword8;
 
50
    s_scan_keyword_table[9] = &CppLexer::scanKeyword9;
 
51
    s_scan_keyword_table[10] = &CppLexer::scanKeyword10;
 
52
    s_scan_keyword_table[11] = &CppLexer::scanKeyword11;
 
53
    s_scan_keyword_table[12] = &CppLexer::scanKeyword12;
 
54
    s_scan_keyword_table[13] = &CppLexer::scanKeyword0;
 
55
    s_scan_keyword_table[14] = &CppLexer::scanKeyword14;
 
56
    s_scan_keyword_table[15] = &CppLexer::scanKeyword0;
 
57
    s_scan_keyword_table[16] = &CppLexer::scanKeyword16;
 
58
 
 
59
    memset(s_attr_table, 0, 256);
 
60
 
 
61
    for (int i=0; i<128; ++i) {
 
62
        switch (i) {
 
63
        case ':':
 
64
        case '*':
 
65
        case '/':
 
66
        case '%':
 
67
        case '^':
 
68
        case '=':
 
69
        case '!':
 
70
        case '&':
 
71
        case '|':
 
72
        case '+':
 
73
        case '<':
 
74
        case '>':
 
75
        case '-':
 
76
        case '.':
 
77
            s_scan_table[i] = &CppLexer::scanOperator;
 
78
            break;
 
79
 
 
80
        case '\r':
 
81
        case '\n':
 
82
            s_scan_table[i] = &CppLexer::scanNewline;
 
83
            break;
 
84
 
 
85
        case '\'':
 
86
            s_scan_table[i] = &CppLexer::scanCharLiteral;
 
87
            break;
 
88
 
 
89
        case '"':
 
90
            s_scan_table[i] = &CppLexer::scanStringLiteral;
 
91
            break;
 
92
 
 
93
        default:
 
94
            if (isspace(i)) {
 
95
                s_scan_table[i] = &CppLexer::scanWhiteSpaces;
 
96
                s_attr_table[i] |= A_Whitespace;
 
97
            } else if (isalpha(i) || i == '_') {
 
98
                s_scan_table[i] = &CppLexer::scanIdentifier;
 
99
                s_attr_table[i] |= A_Alpha;
 
100
            } else if (isdigit(i)) {
 
101
                s_scan_table[i] = &CppLexer::scanNumberLiteral;
 
102
                s_attr_table[i] |= A_Digit;
 
103
            } else
 
104
                s_scan_table[i] = &CppLexer::scanChar;
 
105
        }
 
106
    }
 
107
 
 
108
    s_scan_table[128] = &CppLexer::scanUnicodeChar;
 
109
}
 
110
 
 
111
QVector<Type> CppLexer::lex(TokenSectionSequence tokenSectionSequence)
 
112
{
 
113
    QVector<Type> tokenTypes;
 
114
    tokenTypes.reserve(tokenSectionSequence.count());
 
115
    TokenSectionSequenceIterator it(tokenSectionSequence);
 
116
    while(it.nextToken()) {
 
117
        tokenTypes.append(identify(it.tokenTempRef()));
 
118
    }
 
119
    return tokenTypes;
 
120
}
 
121
 
 
122
Type CppLexer::identify(const TokenTempRef &tokenTempRef)
 
123
{
 
124
    Q_ASSERT(tokenTempRef.length() >= 0 );
 
125
    m_buffer = tokenTempRef.constData();
 
126
    m_len = tokenTempRef.length();
 
127
    m_ptr = 0;
 
128
    const unsigned char ch = m_buffer[0];
 
129
    int kind = 0;
 
130
    (this->*s_scan_table[ch < 128 ? ch : 128])(&kind);
 
131
    return (Type)kind;
 
132
}
 
133
 
 
134
void CppLexer::scanKeyword0(int *kind)
 
135
{
 
136
    *kind = Token_identifier;
 
137
}
 
138
 
 
139
void CppLexer::scanKeyword2(int *kind)
 
140
{
 
141
    switch (m_buffer[m_ptr]) {
 
142
        case 'i':
 
143
        if (m_buffer[m_ptr+1] == 'f')
 
144
        {
 
145
            *kind = Token_if;
 
146
            return;
 
147
        }
 
148
        break;
 
149
 
 
150
        case 'd':
 
151
        if (m_buffer[m_ptr+1] == 'o')
 
152
        {
 
153
            *kind = Token_do;
 
154
            return;
 
155
        }
 
156
        break;
 
157
 
 
158
        case 'o':
 
159
        if (m_buffer[m_ptr+1] == 'r')
 
160
        {
 
161
            *kind = Token_or;
 
162
            return;
 
163
        }
 
164
        break;
 
165
 
 
166
    }
 
167
    *kind = Token_identifier;
 
168
}
 
169
 
 
170
void CppLexer::scanKeyword3(int *kind)
 
171
{
 
172
    switch (m_buffer[m_ptr]) {
 
173
        case 'a':
 
174
        if (m_buffer[m_ptr+1] == 'n' &&
 
175
            m_buffer[m_ptr+2] == 'd')
 
176
        {
 
177
            *kind = Token_and;
 
178
            return;
 
179
        }
 
180
        if (m_buffer[m_ptr+1] == 's' &&
 
181
            m_buffer[m_ptr+2] == 'm')
 
182
        {
 
183
            *kind = Token_asm;
 
184
            return;
 
185
        }
 
186
        break;
 
187
 
 
188
        case 'f':
 
189
        if (m_buffer[m_ptr+1] == 'o' &&
 
190
            m_buffer[m_ptr+2] == 'r')
 
191
        {
 
192
            *kind = Token_for;
 
193
            return;
 
194
        }
 
195
        break;
 
196
 
 
197
        case 'i':
 
198
        if (m_buffer[m_ptr+1] == 'n' &&
 
199
            m_buffer[m_ptr+2] == 't')
 
200
        {
 
201
            *kind = Token_int;
 
202
            return;
 
203
        }
 
204
        break;
 
205
 
 
206
        case 'n':
 
207
        if (m_buffer[m_ptr+1] == 'e' &&
 
208
            m_buffer[m_ptr+2] == 'w')
 
209
        {
 
210
            *kind = Token_new;
 
211
            return;
 
212
        }
 
213
        if (m_buffer[m_ptr+1] == 'o' &&
 
214
            m_buffer[m_ptr+2] == 't')
 
215
        {
 
216
            *kind = Token_not;
 
217
            return;
 
218
        }
 
219
        break;
 
220
 
 
221
        case 't':
 
222
        if (m_buffer[m_ptr+1] == 'r' &&
 
223
            m_buffer[m_ptr+2] == 'y')
 
224
        {
 
225
            *kind = Token_try;
 
226
            return;
 
227
        }
 
228
        break;
 
229
 
 
230
         case 'x':
 
231
        if (m_buffer[m_ptr+1] == 'o' &&
 
232
            m_buffer[m_ptr+2] == 'r')
 
233
        {
 
234
            *kind = Token_xor;
 
235
            return;
 
236
        }
 
237
        break;
 
238
 
 
239
    }
 
240
    *kind = Token_identifier;
 
241
}
 
242
 
 
243
void CppLexer::scanKeyword4(int *kind)
 
244
{
 
245
    switch (m_buffer[m_ptr]) {
 
246
        case 'a':
 
247
        if (m_buffer[m_ptr+1] == 'u' &&
 
248
            m_buffer[m_ptr+2] == 't' &&
 
249
            m_buffer[m_ptr+3] == 'o')
 
250
        {
 
251
            *kind = Token_auto;
 
252
            return;
 
253
        }
 
254
        break;
 
255
 
 
256
        case 'c':
 
257
        if (m_buffer[m_ptr+1] == 'a' &&
 
258
            m_buffer[m_ptr+2] == 's' &&
 
259
            m_buffer[m_ptr+3] == 'e')
 
260
        {
 
261
            *kind = Token_case;
 
262
            return;
 
263
        }
 
264
        if (m_buffer[m_ptr+1] == 'h' &&
 
265
            m_buffer[m_ptr+2] == 'a' &&
 
266
            m_buffer[m_ptr+3] == 'r')
 
267
        {
 
268
            *kind = Token_char;
 
269
            return;
 
270
        }
 
271
        break;
 
272
 
 
273
        case 'b':
 
274
        if (m_buffer[m_ptr+1] == 'o' &&
 
275
            m_buffer[m_ptr+2] == 'o' &&
 
276
            m_buffer[m_ptr+3] == 'l')
 
277
        {
 
278
            *kind = Token_bool;
 
279
            return;
 
280
        }
 
281
        break;
 
282
 
 
283
        case 'e':
 
284
        if (m_buffer[m_ptr+1] == 'l' &&
 
285
            m_buffer[m_ptr+2] == 's' &&
 
286
            m_buffer[m_ptr+3] == 'e')
 
287
        {
 
288
            *kind = Token_else;
 
289
            return;
 
290
        }
 
291
        if (m_buffer[m_ptr+1] == 'm' &&
 
292
            m_buffer[m_ptr+2] == 'i' &&
 
293
            m_buffer[m_ptr+3] == 't')
 
294
        {
 
295
            *kind = Token_emit;
 
296
            return;
 
297
        }
 
298
        if (m_buffer[m_ptr+1] == 'n' &&
 
299
            m_buffer[m_ptr+2] == 'u' &&
 
300
            m_buffer[m_ptr+3] == 'm')
 
301
        {
 
302
            *kind = Token_enum;
 
303
            return;
 
304
        }
 
305
        break;
 
306
 
 
307
        case 'g':
 
308
        if (m_buffer[m_ptr+1] == 'o' &&
 
309
            m_buffer[m_ptr+2] == 't' &&
 
310
            m_buffer[m_ptr+3] == 'o')
 
311
        {
 
312
            *kind = Token_goto;
 
313
             return;
 
314
        }
 
315
        break;
 
316
 
 
317
        case 'l':
 
318
        if (m_buffer[m_ptr+1] == 'o' &&
 
319
            m_buffer[m_ptr+2] == 'n' &&
 
320
            m_buffer[m_ptr+3] == 'g')
 
321
        {
 
322
            *kind = Token_long;
 
323
            return;
 
324
        }
 
325
        break;
 
326
 
 
327
        case 't':
 
328
        if (m_buffer[m_ptr+1] == 'h' &&
 
329
            m_buffer[m_ptr+2] == 'i' &&
 
330
            m_buffer[m_ptr+3] == 's')
 
331
        {
 
332
            *kind = Token_this;
 
333
            return;
 
334
        }
 
335
        break;
 
336
 
 
337
        case 'v':
 
338
        if (m_buffer[m_ptr+1] == 'o' &&
 
339
            m_buffer[m_ptr+2] == 'i' &&
 
340
            m_buffer[m_ptr+3] == 'd')
 
341
        {
 
342
            *kind = Token_void;
 
343
            return;
 
344
        }
 
345
        break;
 
346
 
 
347
    }
 
348
    *kind = Token_identifier;
 
349
}
 
350
 
 
351
void CppLexer::scanKeyword5(int *kind)
 
352
{
 
353
    switch (m_buffer[m_ptr]) {
 
354
        case 'c':
 
355
        if (m_buffer[m_ptr+1] == 'a' &&
 
356
            m_buffer[m_ptr+2] == 't' &&
 
357
            m_buffer[m_ptr+3] == 'c' &&
 
358
            m_buffer[m_ptr+4] == 'h')
 
359
        {
 
360
            *kind = Token_catch;
 
361
            return;
 
362
        }
 
363
        if (m_buffer[m_ptr+1] == 'l' &&
 
364
            m_buffer[m_ptr+2] == 'a' &&
 
365
            m_buffer[m_ptr+3] == 's' &&
 
366
            m_buffer[m_ptr+4] == 's')
 
367
        {
 
368
            *kind = Token_class;
 
369
            return;
 
370
        }
 
371
        if (m_buffer[m_ptr+1] == 'o' &&
 
372
            m_buffer[m_ptr+2] == 'm' &&
 
373
            m_buffer[m_ptr+3] == 'p' &&
 
374
            m_buffer[m_ptr+4] == 'l')
 
375
        {
 
376
            *kind = Token_compl;
 
377
            return;
 
378
        }
 
379
        if (m_buffer[m_ptr+1] == 'o' &&
 
380
            m_buffer[m_ptr+2] == 'n' &&
 
381
            m_buffer[m_ptr+3] == 's' &&
 
382
            m_buffer[m_ptr+4] == 't')
 
383
        {
 
384
            *kind = Token_const;
 
385
            return;
 
386
        }
 
387
        break;
 
388
 
 
389
        case 'b':
 
390
        if (m_buffer[m_ptr+1] == 'i' &&
 
391
            m_buffer[m_ptr+2] == 't' &&
 
392
            m_buffer[m_ptr+3] == 'o' &&
 
393
            m_buffer[m_ptr+4] == 'r')
 
394
        {
 
395
            *kind = Token_bitor;
 
396
            return;
 
397
        }
 
398
        if (m_buffer[m_ptr+1] == 'r' &&
 
399
            m_buffer[m_ptr+2] == 'e' &&
 
400
            m_buffer[m_ptr+3] == 'a' &&
 
401
            m_buffer[m_ptr+4] == 'k')
 
402
        {
 
403
            *kind = Token_break;
 
404
            return;
 
405
        }
 
406
        break;
 
407
 
 
408
        case 'f':
 
409
        if (m_buffer[m_ptr+1] == 'l' &&
 
410
            m_buffer[m_ptr+2] == 'o' &&
 
411
            m_buffer[m_ptr+3] == 'a' &&
 
412
            m_buffer[m_ptr+4] == 't')
 
413
        {
 
414
            *kind = Token_float;
 
415
            return;
 
416
        }
 
417
        break;
 
418
 
 
419
        case 'o':
 
420
        if (m_buffer[m_ptr+1] == 'r' &&
 
421
            m_buffer[m_ptr+2] == '_' &&
 
422
            m_buffer[m_ptr+3] == 'e' &&
 
423
            m_buffer[m_ptr+4] == 'q')
 
424
        {
 
425
            *kind = Token_or_eq;
 
426
            return;
 
427
        }
 
428
        break;
 
429
 
 
430
        case 's':
 
431
        if (m_buffer[m_ptr+1] == 'h' &&
 
432
            m_buffer[m_ptr+2] == 'o' &&
 
433
            m_buffer[m_ptr+3] == 'r' &&
 
434
            m_buffer[m_ptr+4] == 't')
 
435
        {
 
436
            *kind = Token_short;
 
437
            return;
 
438
        }
 
439
        if (m_buffer[m_ptr+1] == 'l' &&
 
440
            m_buffer[m_ptr+2] == 'o' &&
 
441
            m_buffer[m_ptr+3] == 't' &&
 
442
            m_buffer[m_ptr+4] == 's')
 
443
        {
 
444
            *kind = Token_slots;
 
445
            return;
 
446
        }
 
447
        break;
 
448
 
 
449
        case 'u':
 
450
        if (m_buffer[m_ptr+1] == 'n' &&
 
451
            m_buffer[m_ptr+2] == 'i' &&
 
452
            m_buffer[m_ptr+3] == 'o' &&
 
453
            m_buffer[m_ptr+4] == 'n')
 
454
        {
 
455
            *kind = Token_union;
 
456
            return;
 
457
        }
 
458
        if (m_buffer[m_ptr+1] == 's' &&
 
459
            m_buffer[m_ptr+2] == 'i' &&
 
460
            m_buffer[m_ptr+3] == 'n' &&
 
461
            m_buffer[m_ptr+4] == 'g')
 
462
        {
 
463
            *kind = Token_using;
 
464
            return;
 
465
        }
 
466
        break;
 
467
 
 
468
        case 't':
 
469
        if (m_buffer[m_ptr+1] == 'h' &&
 
470
            m_buffer[m_ptr+2] == 'r' &&
 
471
            m_buffer[m_ptr+3] == 'o' &&
 
472
            m_buffer[m_ptr+4] == 'w')
 
473
        {
 
474
            *kind = Token_throw;
 
475
            return;
 
476
        }
 
477
        break;
 
478
 
 
479
        case 'w':
 
480
        if (m_buffer[m_ptr+1] == 'h' &&
 
481
            m_buffer[m_ptr+2] == 'i' &&
 
482
            m_buffer[m_ptr+3] == 'l' &&
 
483
            m_buffer[m_ptr+4] == 'e')
 
484
        {
 
485
            *kind = Token_while;
 
486
            return;
 
487
        }
 
488
        break;
 
489
 
 
490
    }
 
491
    *kind = Token_identifier;
 
492
}
 
493
 
 
494
void CppLexer::scanKeyword6(int *kind)
 
495
{
 
496
    switch (m_buffer[m_ptr]) {
 
497
        case 'a':
 
498
        if (m_buffer[m_ptr+1] == 'n' &&
 
499
            m_buffer[m_ptr+2] == 'd' &&
 
500
            m_buffer[m_ptr+3] == '_' &&
 
501
            m_buffer[m_ptr+4] == 'e' &&
 
502
            m_buffer[m_ptr+5] == 'q')
 
503
        {
 
504
            *kind = Token_and_eq;
 
505
            return;
 
506
        }
 
507
        break;
 
508
 
 
509
        case 'b':
 
510
        if (m_buffer[m_ptr+1] == 'i' &&
 
511
            m_buffer[m_ptr+2] == 't' &&
 
512
            m_buffer[m_ptr+3] == 'a' &&
 
513
            m_buffer[m_ptr+4] == 'n' &&
 
514
            m_buffer[m_ptr+5] == 'd')
 
515
        {
 
516
            *kind = Token_bitand;
 
517
            return;
 
518
        }
 
519
        break;
 
520
 
 
521
        case 'e':
 
522
        if (m_buffer[m_ptr+1] == 'x' &&
 
523
            m_buffer[m_ptr+2] == 'p' &&
 
524
            m_buffer[m_ptr+3] == 'o' &&
 
525
            m_buffer[m_ptr+4] == 'r' &&
 
526
            m_buffer[m_ptr+5] == 't')
 
527
        {
 
528
            *kind = Token_export;
 
529
            return;
 
530
        }
 
531
        if (m_buffer[m_ptr+1] == 'x' &&
 
532
            m_buffer[m_ptr+2] == 't' &&
 
533
            m_buffer[m_ptr+3] == 'e' &&
 
534
            m_buffer[m_ptr+4] == 'r' &&
 
535
            m_buffer[m_ptr+5] == 'n')
 
536
        {
 
537
            *kind = Token_extern;
 
538
            return;
 
539
        }
 
540
        break;
 
541
 
 
542
        case 'd':
 
543
        if (m_buffer[m_ptr+1] == 'e' &&
 
544
            m_buffer[m_ptr+2] == 'l' &&
 
545
            m_buffer[m_ptr+3] == 'e' &&
 
546
            m_buffer[m_ptr+4] == 't' &&
 
547
            m_buffer[m_ptr+5] == 'e')
 
548
        {
 
549
            *kind = Token_delete;
 
550
            return;
 
551
        }
 
552
        if (m_buffer[m_ptr+1] == 'o' &&
 
553
            m_buffer[m_ptr+2] == 'u' &&
 
554
            m_buffer[m_ptr+3] == 'b' &&
 
555
            m_buffer[m_ptr+4] == 'l' &&
 
556
            m_buffer[m_ptr+5] == 'e')
 
557
        {
 
558
            *kind = Token_double;
 
559
            return;
 
560
        }
 
561
        break;
 
562
 
 
563
        case 'f':
 
564
        if (m_buffer[m_ptr+1] == 'r' &&
 
565
            m_buffer[m_ptr+2] == 'i' &&
 
566
            m_buffer[m_ptr+3] == 'e' &&
 
567
            m_buffer[m_ptr+4] == 'n' &&
 
568
            m_buffer[m_ptr+5] == 'd')
 
569
        {
 
570
            *kind = Token_friend;
 
571
            return;
 
572
        }
 
573
        break;
 
574
 
 
575
        case 'i':
 
576
        if (m_buffer[m_ptr+1] == 'n' &&
 
577
            m_buffer[m_ptr+2] == 'l' &&
 
578
            m_buffer[m_ptr+3] == 'i' &&
 
579
            m_buffer[m_ptr+4] == 'n' &&
 
580
            m_buffer[m_ptr+5] == 'e')
 
581
        {
 
582
            *kind = Token_inline;
 
583
            return;
 
584
        }
 
585
        break;
 
586
 
 
587
        case 'K':
 
588
        if (m_buffer[m_ptr+1] == '_' &&
 
589
            m_buffer[m_ptr+2] == 'D' &&
 
590
            m_buffer[m_ptr+3] == 'C' &&
 
591
            m_buffer[m_ptr+4] == 'O' &&
 
592
            m_buffer[m_ptr+5] == 'P')
 
593
        {
 
594
            *kind = Token_K_DCOP;
 
595
            return;
 
596
        }
 
597
        break;
 
598
 
 
599
        case 'n':
 
600
        if (m_buffer[m_ptr+1] == 'o' &&
 
601
            m_buffer[m_ptr+2] == 't' &&
 
602
            m_buffer[m_ptr+3] == '_' &&
 
603
            m_buffer[m_ptr+4] == 'e' &&
 
604
            m_buffer[m_ptr+5] == 'q')
 
605
        {
 
606
            *kind = Token_not_eq;
 
607
            return;
 
608
        }
 
609
        break;
 
610
 
 
611
        case 'p':
 
612
        if (m_buffer[m_ptr+1] == 'u' &&
 
613
            m_buffer[m_ptr+2] == 'b' &&
 
614
            m_buffer[m_ptr+3] == 'l' &&
 
615
            m_buffer[m_ptr+4] == 'i' &&
 
616
            m_buffer[m_ptr+5] == 'c')
 
617
        {
 
618
            *kind = Token_public;
 
619
            return;
 
620
        }
 
621
        break;
 
622
 
 
623
        case 's':
 
624
        if (m_buffer[m_ptr+1] == 'i' &&
 
625
            m_buffer[m_ptr+2] == 'g' &&
 
626
            m_buffer[m_ptr+3] == 'n' &&
 
627
            m_buffer[m_ptr+4] == 'e' &&
 
628
            m_buffer[m_ptr+5] == 'd')
 
629
        {
 
630
            *kind = Token_signed;
 
631
            return;
 
632
        }
 
633
        if (m_buffer[m_ptr+1] == 'i' &&
 
634
            m_buffer[m_ptr+2] == 'z' &&
 
635
            m_buffer[m_ptr+3] == 'e' &&
 
636
            m_buffer[m_ptr+4] == 'o' &&
 
637
            m_buffer[m_ptr+5] == 'f')
 
638
        {
 
639
            *kind = Token_sizeof;
 
640
            return;
 
641
        }
 
642
        if (m_buffer[m_ptr+1] == 't' &&
 
643
            m_buffer[m_ptr+2] == 'a' &&
 
644
            m_buffer[m_ptr+3] == 't' &&
 
645
            m_buffer[m_ptr+4] == 'i' &&
 
646
            m_buffer[m_ptr+5] == 'c')
 
647
        {
 
648
            *kind = Token_static;
 
649
            return;
 
650
        }
 
651
        if (m_buffer[m_ptr+1] == 't' &&
 
652
            m_buffer[m_ptr+2] == 'r' &&
 
653
            m_buffer[m_ptr+3] == 'u' &&
 
654
            m_buffer[m_ptr+4] == 'c' &&
 
655
            m_buffer[m_ptr+5] == 't')
 
656
        {
 
657
            *kind = Token_struct;
 
658
            return;
 
659
        }
 
660
        if (m_buffer[m_ptr+1] == 'w' &&
 
661
            m_buffer[m_ptr+2] == 'i' &&
 
662
            m_buffer[m_ptr+3] == 't' &&
 
663
            m_buffer[m_ptr+4] == 'c' &&
 
664
            m_buffer[m_ptr+5] == 'h')
 
665
        {
 
666
            *kind = Token_switch;
 
667
            return;
 
668
        }
 
669
        break;
 
670
 
 
671
        case 'r':
 
672
        if (m_buffer[m_ptr+1] == 'e' &&
 
673
            m_buffer[m_ptr+2] == 't' &&
 
674
            m_buffer[m_ptr+3] == 'u' &&
 
675
            m_buffer[m_ptr+4] == 'r' &&
 
676
            m_buffer[m_ptr+5] == 'n')
 
677
        {
 
678
            *kind = Token_return;
 
679
            return;
 
680
        }
 
681
        break;
 
682
 
 
683
        case 't':
 
684
        if (m_buffer[m_ptr+1] == 'y' &&
 
685
            m_buffer[m_ptr+2] == 'p' &&
 
686
            m_buffer[m_ptr+3] == 'e' &&
 
687
            m_buffer[m_ptr+4] == 'i' &&
 
688
            m_buffer[m_ptr+5] == 'd')
 
689
        {
 
690
            *kind = Token_typeid;
 
691
            return;
 
692
        }
 
693
        break;
 
694
 
 
695
        case 'x':
 
696
        if (m_buffer[m_ptr+1] == 'o' &&
 
697
            m_buffer[m_ptr+2] == 'r' &&
 
698
            m_buffer[m_ptr+3] == '_' &&
 
699
            m_buffer[m_ptr+4] == 'e' &&
 
700
            m_buffer[m_ptr+5] == 'q')
 
701
        {
 
702
            *kind = Token_xor_eq;
 
703
            return;
 
704
        }
 
705
        break;
 
706
 
 
707
        case 'k':
 
708
        if (m_buffer[m_ptr+1] == '_' &&
 
709
            m_buffer[m_ptr+2] == 'd' &&
 
710
            m_buffer[m_ptr+3] == 'c' &&
 
711
            m_buffer[m_ptr+4] == 'o' &&
 
712
            m_buffer[m_ptr+5] == 'p')
 
713
        {
 
714
            *kind = Token_k_dcop;
 
715
            return;
 
716
        }
 
717
        break;
 
718
 
 
719
    }
 
720
    *kind = Token_identifier;
 
721
}
 
722
 
 
723
void CppLexer::scanKeyword7(int *kind)
 
724
{
 
725
    switch (m_buffer[m_ptr]) {
 
726
        case 'd':
 
727
        if (m_buffer[m_ptr+1] == 'e' &&
 
728
            m_buffer[m_ptr+2] == 'f' &&
 
729
            m_buffer[m_ptr+3] == 'a' &&
 
730
            m_buffer[m_ptr+4] == 'u' &&
 
731
            m_buffer[m_ptr+5] == 'l' &&
 
732
            m_buffer[m_ptr+6] == 't')
 
733
        {
 
734
            *kind = Token_default;
 
735
            return;
 
736
        }
 
737
        break;
 
738
 
 
739
        case 'm':
 
740
        if (m_buffer[m_ptr+1] == 'u' &&
 
741
            m_buffer[m_ptr+2] == 't' &&
 
742
            m_buffer[m_ptr+3] == 'a' &&
 
743
            m_buffer[m_ptr+4] == 'b' &&
 
744
            m_buffer[m_ptr+5] == 'l' &&
 
745
            m_buffer[m_ptr+6] == 'e')
 
746
        {
 
747
            *kind = Token_mutable;
 
748
            return;
 
749
        }
 
750
        break;
 
751
 
 
752
        case 'p':
 
753
        if (m_buffer[m_ptr+1] == 'r' &&
 
754
            m_buffer[m_ptr+2] == 'i' &&
 
755
            m_buffer[m_ptr+3] == 'v' &&
 
756
            m_buffer[m_ptr+4] == 'a' &&
 
757
            m_buffer[m_ptr+5] == 't' &&
 
758
            m_buffer[m_ptr+6] == 'e')
 
759
        {
 
760
            *kind = Token_private;
 
761
            return;
 
762
        }
 
763
        break;
 
764
#if 0
 
765
        case 's':
 
766
        if (m_buffer[m_ptr+1] == 'i' &&
 
767
            m_buffer[m_ptr+2] == 'g' &&
 
768
            m_buffer[m_ptr+3] == 'n' &&
 
769
            m_buffer[m_ptr+4] == 'a' &&
 
770
            m_buffer[m_ptr+5] == 'l' &&
 
771
            m_buffer[m_ptr+6] == 's')
 
772
        {
 
773
            *kind = Token_signals;
 
774
            return;
 
775
        }
 
776
        break;
 
777
#endif
 
778
        case 't':
 
779
        if (m_buffer[m_ptr+1] == 'y' &&
 
780
            m_buffer[m_ptr+2] == 'p' &&
 
781
            m_buffer[m_ptr+3] == 'e' &&
 
782
            m_buffer[m_ptr+4] == 'd' &&
 
783
            m_buffer[m_ptr+5] == 'e' &&
 
784
            m_buffer[m_ptr+6] == 'f')
 
785
        {
 
786
            *kind = Token_typedef;
 
787
            return;
 
788
        }
 
789
        break;
 
790
 
 
791
        case 'v':
 
792
        if (m_buffer[m_ptr+1] == 'i' &&
 
793
            m_buffer[m_ptr+2] == 'r' &&
 
794
            m_buffer[m_ptr+3] == 't' &&
 
795
            m_buffer[m_ptr+4] == 'u' &&
 
796
            m_buffer[m_ptr+5] == 'a' &&
 
797
            m_buffer[m_ptr+6] == 'l')
 
798
        {
 
799
            *kind = Token_virtual;
 
800
            return;
 
801
        }
 
802
        break;
 
803
    }
 
804
    *kind = Token_identifier;
 
805
}
 
806
 
 
807
void CppLexer::scanKeyword8(int *kind)
 
808
{
 
809
    switch (m_buffer[m_ptr]) {
 
810
        case '_':
 
811
        if (m_buffer[m_ptr+1] == '_' &&
 
812
            m_buffer[m_ptr+2] == 't' &&
 
813
            m_buffer[m_ptr+3] == 'y' &&
 
814
            m_buffer[m_ptr+4] == 'p' &&
 
815
            m_buffer[m_ptr+5] == 'e' &&
 
816
            m_buffer[m_ptr+6] == 'o' &&
 
817
            m_buffer[m_ptr+7] == 'f')
 
818
        {
 
819
            *kind = Token___typeof;
 
820
            return;
 
821
        }
 
822
        break;
 
823
 
 
824
        case 'c':
 
825
        if (m_buffer[m_ptr+1] == 'o' &&
 
826
            m_buffer[m_ptr+2] == 'n' &&
 
827
            m_buffer[m_ptr+3] == 't' &&
 
828
            m_buffer[m_ptr+4] == 'i' &&
 
829
            m_buffer[m_ptr+5] == 'n' &&
 
830
            m_buffer[m_ptr+6] == 'u' &&
 
831
            m_buffer[m_ptr+7] == 'e')
 
832
        {
 
833
            *kind = Token_continue;
 
834
            return;
 
835
        }
 
836
        break;
 
837
 
 
838
        case 'e':
 
839
        if (m_buffer[m_ptr+1] == 'x' &&
 
840
            m_buffer[m_ptr+2] == 'p' &&
 
841
            m_buffer[m_ptr+3] == 'l' &&
 
842
            m_buffer[m_ptr+4] == 'i' &&
 
843
            m_buffer[m_ptr+5] == 'c' &&
 
844
            m_buffer[m_ptr+6] == 'i' &&
 
845
            m_buffer[m_ptr+7] == 't')
 
846
        {
 
847
            *kind = Token_explicit;
 
848
            return;
 
849
        }
 
850
        break;
 
851
 
 
852
        case 'o':
 
853
        if (m_buffer[m_ptr+1] == 'p' &&
 
854
            m_buffer[m_ptr+2] == 'e' &&
 
855
            m_buffer[m_ptr+3] == 'r' &&
 
856
            m_buffer[m_ptr+4] == 'a' &&
 
857
            m_buffer[m_ptr+5] == 't' &&
 
858
            m_buffer[m_ptr+6] == 'o' &&
 
859
            m_buffer[m_ptr+7] == 'r')
 
860
        {
 
861
            *kind = Token_operator;
 
862
            return;
 
863
        }
 
864
        break;
 
865
 
 
866
        case 'Q':
 
867
        if (m_buffer[m_ptr+1] == '_' &&
 
868
            m_buffer[m_ptr+2] == 'O' &&
 
869
            m_buffer[m_ptr+3] == 'B' &&
 
870
            m_buffer[m_ptr+4] == 'J' &&
 
871
            m_buffer[m_ptr+5] == 'E' &&
 
872
            m_buffer[m_ptr+6] == 'C' &&
 
873
            m_buffer[m_ptr+7] == 'T')
 
874
        {
 
875
            *kind = Token_Q_OBJECT;
 
876
            return;
 
877
        }
 
878
        break;
 
879
 
 
880
        case 'r':
 
881
        if (m_buffer[m_ptr+1] == 'e' &&
 
882
            m_buffer[m_ptr+2] == 'g' &&
 
883
            m_buffer[m_ptr+3] == 'i' &&
 
884
            m_buffer[m_ptr+4] == 's' &&
 
885
            m_buffer[m_ptr+5] == 't' &&
 
886
            m_buffer[m_ptr+6] == 'e' &&
 
887
            m_buffer[m_ptr+7] == 'r')
 
888
        {
 
889
            *kind = Token_register;
 
890
            return;
 
891
        }
 
892
        break;
 
893
 
 
894
        case 'u':
 
895
        if (m_buffer[m_ptr+1] == 'n' &&
 
896
            m_buffer[m_ptr+2] == 's' &&
 
897
            m_buffer[m_ptr+3] == 'i' &&
 
898
            m_buffer[m_ptr+4] == 'g' &&
 
899
            m_buffer[m_ptr+5] == 'n' &&
 
900
            m_buffer[m_ptr+6] == 'e' &&
 
901
            m_buffer[m_ptr+7] == 'd')
 
902
        {
 
903
            *kind = Token_unsigned;
 
904
            return;
 
905
        }
 
906
        break;
 
907
 
 
908
        case 't':
 
909
        if (m_buffer[m_ptr+1] == 'e' &&
 
910
            m_buffer[m_ptr+2] == 'm' &&
 
911
            m_buffer[m_ptr+3] == 'p' &&
 
912
            m_buffer[m_ptr+4] == 'l' &&
 
913
            m_buffer[m_ptr+5] == 'a' &&
 
914
            m_buffer[m_ptr+6] == 't' &&
 
915
            m_buffer[m_ptr+7] == 'e')
 
916
        {
 
917
            *kind = Token_template;
 
918
            return;
 
919
        }
 
920
        if (m_buffer[m_ptr+1] == 'y' &&
 
921
            m_buffer[m_ptr+2] == 'p' &&
 
922
            m_buffer[m_ptr+3] == 'e' &&
 
923
            m_buffer[m_ptr+4] == 'n' &&
 
924
            m_buffer[m_ptr+5] == 'a' &&
 
925
            m_buffer[m_ptr+6] == 'm' &&
 
926
            m_buffer[m_ptr+7] == 'e')
 
927
        {
 
928
            *kind = Token_typename;
 
929
            return;
 
930
        }
 
931
        break;
 
932
 
 
933
        case 'v':
 
934
        if (m_buffer[m_ptr+1] == 'o' &&
 
935
            m_buffer[m_ptr+2] == 'l' &&
 
936
            m_buffer[m_ptr+3] == 'a' &&
 
937
            m_buffer[m_ptr+4] == 't' &&
 
938
            m_buffer[m_ptr+5] == 'i' &&
 
939
            m_buffer[m_ptr+6] == 'l' &&
 
940
            m_buffer[m_ptr+7] == 'e')
 
941
        {
 
942
            *kind = Token_volatile;
 
943
            return;
 
944
        }
 
945
        break;
 
946
 
 
947
    }
 
948
    *kind = Token_identifier;
 
949
}
 
950
 
 
951
void CppLexer::scanKeyword9(int *kind)
 
952
{
 
953
    switch (m_buffer[m_ptr]) {
 
954
        case 'p':
 
955
        if (m_buffer[m_ptr+1] == 'r' &&
 
956
            m_buffer[m_ptr+2] == 'o' &&
 
957
            m_buffer[m_ptr+3] == 't' &&
 
958
            m_buffer[m_ptr+4] == 'e' &&
 
959
            m_buffer[m_ptr+5] == 'c' &&
 
960
            m_buffer[m_ptr+6] == 't' &&
 
961
            m_buffer[m_ptr+7] == 'e' &&
 
962
            m_buffer[m_ptr+8] == 'd')
 
963
        {
 
964
            *kind = Token_protected;
 
965
            return;
 
966
        }
 
967
        break;
 
968
 
 
969
        case 'n':
 
970
        if (m_buffer[m_ptr+1] == 'a' &&
 
971
            m_buffer[m_ptr+2] == 'm' &&
 
972
            m_buffer[m_ptr+3] == 'e' &&
 
973
            m_buffer[m_ptr+4] == 's' &&
 
974
            m_buffer[m_ptr+5] == 'p' &&
 
975
            m_buffer[m_ptr+6] == 'a' &&
 
976
            m_buffer[m_ptr+7] == 'c' &&
 
977
            m_buffer[m_ptr+8] == 'e')
 
978
        {
 
979
            *kind = Token_namespace;
 
980
            return;
 
981
        }
 
982
        break;
 
983
 
 
984
    }
 
985
    *kind = Token_identifier;
 
986
}
 
987
 
 
988
void CppLexer::scanKeyword10(int *kind)
 
989
{
 
990
    switch (m_buffer[m_ptr]) {
 
991
        case 'c':
 
992
        if (m_buffer[m_ptr+1] == 'o' &&
 
993
            m_buffer[m_ptr+2] == 'n' &&
 
994
            m_buffer[m_ptr+3] == 's' &&
 
995
            m_buffer[m_ptr+4] == 't' &&
 
996
            m_buffer[m_ptr+5] == '_' &&
 
997
            m_buffer[m_ptr+6] == 'c' &&
 
998
            m_buffer[m_ptr+7] == 'a' &&
 
999
            m_buffer[m_ptr+8] == 's' &&
 
1000
            m_buffer[m_ptr+9] == 't')
 
1001
        {
 
1002
            *kind = Token_const_cast;
 
1003
            return;
 
1004
        }
 
1005
        break;
 
1006
 
 
1007
    }
 
1008
    *kind = Token_identifier;
 
1009
}
 
1010
 
 
1011
void CppLexer::scanKeyword11(int *kind)
 
1012
{
 
1013
    switch (m_buffer[m_ptr]) {
 
1014
        case 's':
 
1015
        if (m_buffer[m_ptr+1] == 't' &&
 
1016
            m_buffer[m_ptr+2] == 'a' &&
 
1017
            m_buffer[m_ptr+3] == 't' &&
 
1018
            m_buffer[m_ptr+4] == 'i' &&
 
1019
            m_buffer[m_ptr+5] == 'c' &&
 
1020
            m_buffer[m_ptr+6] == '_' &&
 
1021
            m_buffer[m_ptr+7] == 'c' &&
 
1022
            m_buffer[m_ptr+8] == 'a' &&
 
1023
            m_buffer[m_ptr+9] == 's' &&
 
1024
            m_buffer[m_ptr+10] == 't')
 
1025
        {
 
1026
            *kind = Token_static_cast;
 
1027
            return;
 
1028
        }
 
1029
        break;
 
1030
 
 
1031
    }
 
1032
    *kind = Token_identifier;
 
1033
}
 
1034
 
 
1035
void CppLexer::scanKeyword12(int *kind)
 
1036
{
 
1037
    switch (m_buffer[m_ptr]) {
 
1038
        case 'd':
 
1039
        if (m_buffer[m_ptr+1] == 'y' &&
 
1040
            m_buffer[m_ptr+2] == 'n' &&
 
1041
            m_buffer[m_ptr+3] == 'a' &&
 
1042
            m_buffer[m_ptr+4] == 'm' &&
 
1043
            m_buffer[m_ptr+5] == 'i' &&
 
1044
            m_buffer[m_ptr+6] == 'c' &&
 
1045
            m_buffer[m_ptr+7] == '_' &&
 
1046
            m_buffer[m_ptr+8] == 'c' &&
 
1047
            m_buffer[m_ptr+9] == 'a' &&
 
1048
            m_buffer[m_ptr+10] == 's' &&
 
1049
            m_buffer[m_ptr+11] == 't')
 
1050
        {
 
1051
            *kind = Token_dynamic_cast;
 
1052
            return;
 
1053
        }
 
1054
        break;
 
1055
 
 
1056
    }
 
1057
    *kind = Token_identifier;
 
1058
}
 
1059
 
 
1060
void CppLexer::scanKeyword14(int *kind)
 
1061
{
 
1062
    switch (m_buffer[m_ptr]) {
 
1063
        case 'k':
 
1064
        if (m_buffer[m_ptr+1] == '_' &&
 
1065
            m_buffer[m_ptr+2] == 'd' &&
 
1066
            m_buffer[m_ptr+3] == 'c' &&
 
1067
            m_buffer[m_ptr+4] == 'o' &&
 
1068
            m_buffer[m_ptr+5] == 'p' &&
 
1069
            m_buffer[m_ptr+6] == '_' &&
 
1070
            m_buffer[m_ptr+7] == 's' &&
 
1071
            m_buffer[m_ptr+8] == 'i' &&
 
1072
            m_buffer[m_ptr+9] == 'g' &&
 
1073
            m_buffer[m_ptr+10] == 'n' &&
 
1074
            m_buffer[m_ptr+11] == 'a' &&
 
1075
            m_buffer[m_ptr+12] == 'l' &&
 
1076
            m_buffer[m_ptr+13] == 's')
 
1077
        {
 
1078
            *kind = Token_k_dcop_signals;
 
1079
            return;
 
1080
        }
 
1081
        break;
 
1082
 
 
1083
    }
 
1084
    *kind = Token_identifier;
 
1085
}
 
1086
 
 
1087
void CppLexer::scanKeyword16(int *kind)
 
1088
{
 
1089
    switch (m_buffer[m_ptr]) {
 
1090
        case 'r':
 
1091
        if (m_buffer[m_ptr+1] == 'e' &&
 
1092
            m_buffer[m_ptr+2] == 'i' &&
 
1093
            m_buffer[m_ptr+3] == 'n' &&
 
1094
            m_buffer[m_ptr+4] == 't' &&
 
1095
            m_buffer[m_ptr+5] == 'e' &&
 
1096
            m_buffer[m_ptr+6] == 'r' &&
 
1097
            m_buffer[m_ptr+7] == 'p' &&
 
1098
            m_buffer[m_ptr+8] == 'r' &&
 
1099
            m_buffer[m_ptr+9] == 'e' &&
 
1100
            m_buffer[m_ptr+10] == 't' &&
 
1101
            m_buffer[m_ptr+11] == '_' &&
 
1102
            m_buffer[m_ptr+12] == 'c' &&
 
1103
            m_buffer[m_ptr+13] == 'a' &&
 
1104
            m_buffer[m_ptr+14] == 's' &&
 
1105
            m_buffer[m_ptr+15] == 't')
 
1106
        {
 
1107
            *kind = Token_reinterpret_cast;
 
1108
            return;
 
1109
        }
 
1110
        break;
 
1111
 
 
1112
    }
 
1113
    *kind = Token_identifier;
 
1114
}
 
1115
 
 
1116
 
 
1117
 
 
1118
void CppLexer::scanChar(int *kind)
 
1119
{
 
1120
    *kind = m_buffer[m_ptr++];
 
1121
}
 
1122
 
 
1123
void CppLexer::scanWhiteSpaces(int *kind)
 
1124
{
 
1125
    *kind = Token_whitespaces;
 
1126
}
 
1127
 
 
1128
void CppLexer::scanNewline(int *kind)
 
1129
{
 
1130
    *kind = '\n';
 
1131
}
 
1132
 
 
1133
void CppLexer::scanUnicodeChar(int *kind)
 
1134
{
 
1135
    *kind = m_buffer[0];
 
1136
}
 
1137
 
 
1138
void CppLexer::scanCharLiteral(int *kind)
 
1139
{
 
1140
    *kind = Token_char_literal;
 
1141
}
 
1142
 
 
1143
void CppLexer::scanStringLiteral(int *kind)
 
1144
{
 
1145
    *kind = Token_string_literal;
 
1146
}
 
1147
 
 
1148
void CppLexer::scanIdentifier(int *kind)
 
1149
{
 
1150
    if (m_len <16)
 
1151
        (this->*s_scan_keyword_table[m_len])(kind);
 
1152
    else
 
1153
        (this->*s_scan_keyword_table[0])(kind);
 
1154
}
 
1155
 
 
1156
void CppLexer::scanNumberLiteral(int *kind)
 
1157
{
 
1158
    *kind = Token_number_literal;
 
1159
}
 
1160
 
 
1161
void CppLexer::scanOperator(int *kind)
 
1162
{
 
1163
    switch (m_buffer[m_ptr]) {
 
1164
    case ':':
 
1165
        if (m_buffer[m_ptr+1] == ':') {
 
1166
            *kind = Token_scope;
 
1167
            return;
 
1168
        }
 
1169
        break;
 
1170
 
 
1171
    case '*':
 
1172
    case '/':
 
1173
    case '%':
 
1174
    case '^':
 
1175
        if (m_buffer[m_ptr+1] == '=') {
 
1176
            *kind = Token_assign;
 
1177
            return;
 
1178
        }
 
1179
        break;
 
1180
 
 
1181
    case '=':
 
1182
    case '!':
 
1183
        if (m_buffer[m_ptr+1] == '=') {
 
1184
            *kind = Token_eq;
 
1185
            return;
 
1186
        }
 
1187
        break;
 
1188
 
 
1189
    case '&':
 
1190
        if (m_buffer[m_ptr+1] == '&') {
 
1191
            *kind = Token_and;
 
1192
            return;
 
1193
        } else if (m_buffer[m_ptr+1] == '=') {
 
1194
            *kind = Token_assign;
 
1195
            return;
 
1196
        }
 
1197
        break;
 
1198
 
 
1199
    case '|':
 
1200
        if (m_buffer[m_ptr+1] == '|' ) {
 
1201
            *kind = Token_or;
 
1202
            return;
 
1203
        } else if (m_buffer[m_ptr+1] == '=') {
 
1204
            *kind = Token_assign;
 
1205
            return;
 
1206
        }
 
1207
        break;
 
1208
 
 
1209
    case '+':
 
1210
        if (m_buffer[m_ptr+1] == '+' ) {
 
1211
            *kind = Token_incr;
 
1212
            return;
 
1213
        } else if (m_buffer[m_ptr+1] == '=') {
 
1214
            *kind = Token_assign;
 
1215
            return;
 
1216
        }
 
1217
        break;
 
1218
 
 
1219
    case '<':
 
1220
        if (m_buffer[m_ptr+1] == '<') {
 
1221
            if (m_buffer[m_ptr+2] == '=') {
 
1222
                *kind = Token_assign;
 
1223
                return;
 
1224
            }
 
1225
            *kind = Token_shift;
 
1226
            return;
 
1227
        } else if (m_buffer[m_ptr+1] == '=') {
 
1228
            *kind = Token_leq;
 
1229
            return;
 
1230
        }
 
1231
        break;
 
1232
 
 
1233
    case '>':
 
1234
        if (m_buffer[m_ptr+1] == '>') {
 
1235
            if (m_buffer[m_ptr+2] == '=') {
 
1236
                *kind = Token_assign;
 
1237
                return;
 
1238
            }
 
1239
            *kind = Token_shift;
 
1240
            return;
 
1241
        } else if (m_buffer[m_ptr+1] == '=') {
 
1242
            *kind = Token_geq;
 
1243
            return;
 
1244
        }
 
1245
        break;
 
1246
 
 
1247
    case '-':
 
1248
        if (m_buffer[m_ptr+1] == '>') {
 
1249
            if (m_buffer[m_ptr+2] == '*') {
 
1250
                *kind = Token_ptrmem;
 
1251
                return;
 
1252
            }
 
1253
            *kind = Token_arrow;
 
1254
            return;
 
1255
        } else if (m_buffer[m_ptr+1] == '-') {
 
1256
            *kind = Token_decr;
 
1257
            return;
 
1258
        } else if (m_buffer[m_ptr+1] == '=') {
 
1259
            *kind = Token_assign;
 
1260
            return;
 
1261
        }
 
1262
        break;
 
1263
 
 
1264
    case '.':
 
1265
        if (m_buffer[m_ptr+1] == '.' && m_buffer[m_ptr+2] == '.') {
 
1266
            *kind = Token_ellipsis;
 
1267
            return;
 
1268
        } else if (m_buffer[m_ptr+1] == '*') {
 
1269
            *kind = Token_ptrmem;
 
1270
            return;
 
1271
        }
 
1272
        break;
 
1273
 
 
1274
    }
 
1275
 
 
1276
    *kind = m_buffer[m_ptr++];
 
1277
}