← Back to branch summary

~ubuntu-branches/ubuntu/wily/muse/wily-proposed

« back to all changes in this revision

Viewing changes to muse/xml.cpp

  • Committer: Package Import Robot
  • Author(s): Alessio Treglia
  • Date: 2011-12-03 17:12:54 UTC
  • mfrom: (1.1.8)
  • Revision ID: package-import@ubuntu.com-20111203171254-28b1j4lpb46r5jtl
Tags: 2.0~rc1-1
* New upstream RC release.
* Refresh patches, remove those patches not needed anymore.

Show diffs side-by-side

added added

removed removed

Lines of Context:
muse/xml.cpp
4
4
//  $Id: xml.cpp,v 1.17.2.6 2009/12/07 20:48:45 spamatica Exp $
5
5
//
6
6
//  (C) Copyright 2000 Werner Schweer (ws@seh.de)
 
7
//  (C) Copyright 2011 Tim E. Real (terminator356 on sourceforge)
 
8
//
 
9
//  This program is free software; you can redistribute it and/or
 
10
//  modify it under the terms of the GNU General Public License
 
11
//  as published by the Free Software Foundation; version 2 of
 
12
//  the License, or (at your option) any later version.
 
13
//
 
14
//  This program is distributed in the hope that it will be useful,
 
15
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
//  GNU General Public License for more details.
 
18
//
 
19
//  You should have received a copy of the GNU General Public License
 
20
//  along with this program; if not, write to the Free Software
 
21
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
22
//
7
23
//=========================================================
8
24
 
9
25
#include <stdio.h>
10
26
#include <stdarg.h>
11
27
 
 
28
#include <QByteArray>
12
29
#include <QString>
13
30
#include <QColor>
14
31
#include <QWidget>
16
33
 
17
34
#include "xml.h"
18
35
 
 
36
namespace MusECore {
 
37
 
19
38
//---------------------------------------------------------
20
39
//  Note:
21
40
//    this code is a Q/D hack for reading/parsing and
95
114
 
96
115
void Xml::token(int cc)
97
116
      {
98
 
      char buffer[512];
 
117
      //char buffer[512];
 
118
      QByteArray buffer;
 
119
 
99
120
      int i = 0;
100
 
      for (; i < 511;) {
 
121
      //for (; i < 511;) {
 
122
      for (; i < 9999999;) {   // Stop at a reasonably large amount 10 million.
101
123
            if (c == ' ' || c == '\t' || c == cc || c == '\n' || c == EOF)
102
124
                  break;
103
125
            buffer[i++] = c;
114
136
 
115
137
void Xml::stoken()
116
138
      {
117
 
      char buffer[1024*4];
 
139
      //char buffer[1024*4];
 
140
      QByteArray buffer;
 
141
      
118
142
      int i = 0;
119
143
      buffer[i] = c;
120
144
      ++i;
121
145
      next();
122
 
      for (;i < 1024*4-1;) {
 
146
 
 
147
      //for (;i < 1024*4-1;) {
 
148
      for (;i < 10000000*4-1;) {  // Stop at a reasonably large amount 10 million.
123
149
            if (c == '"') {
124
150
                  buffer[i++] = c;
125
151
                  next();
190
216
 
191
217
Xml::Token Xml::parse()
192
218
      {
193
 
      char buffer[1024*1024];   // increase buffer -rj
194
 
      char* p;
 
219
      //char buffer[1024*1024];   // increase buffer -rj
 
220
      //char* p;
 
221
      QByteArray buffer;
 
222
      int idx = 0;
195
223
 
196
224
 again:
197
225
      bool endFlag = false;
245
273
                  }
246
274
            if (c == '?') {
247
275
                  next();
248
 
                  p = buffer;
 
276
                  //p = buffer;
 
277
                  //p = buffer.data();
 
278
                  idx = 0;
249
279
                  for (;;) {
250
280
                        if (c == '?' || c == EOF || c == '>')
251
281
                              break;
252
 
                        *p++ = c;
 
282
                        
 
283
                        //*p++ = c;
 
284
                        buffer[idx++] = c;
 
285
                        
253
286
                        // TODO: check overflow
254
287
                        next();
255
288
                        }
256
 
                  *p = 0;
 
289
                  
 
290
                  //*p = 0;
 
291
                  buffer[idx] = 0;
 
292
                  
257
293
                  _s1 = QString(buffer);
258
294
                  if (c == EOF) {
259
295
                        fprintf(stderr, "XML: unexpected EOF\n");
281
317
                        }
282
318
                  goto again;
283
319
                  }
284
 
            p = buffer;
 
320
            //p = buffer;
 
321
            //p = buffer.data();
 
322
            idx = 0;
285
323
            for (;;) {
286
324
                  if (c == '/' || c == ' ' || c == '\t' || c == '>' || c == '\n' || c == EOF)
287
325
                        break;
288
326
                  // TODO: check overflow
289
 
                  *p++ = c;
 
327
                  
 
328
                  //*p++ = c;
 
329
                  buffer[idx++] = c;
 
330
                  
290
331
                  next();
291
332
                  }
292
 
            *p = 0;
 
333
            
 
334
            //*p = 0;
 
335
            buffer[idx] = 0;
 
336
            
293
337
            _s1 = QString(buffer);
294
338
            // skip white space:
295
339
            while (c == ' ' || c == '\t' || c == '\n')
338
382
                  fprintf(stderr, "XML: level = 0\n");
339
383
                  goto error;
340
384
                  }
341
 
            p = buffer;
 
385
            //p = buffer;
 
386
            //p = buffer.data();
 
387
            idx = 0;
342
388
            for (;;) {
343
389
                  if (c == EOF || c == '<')
344
390
                        break;
345
391
                  if (c == '&') {
346
392
                        next();
347
393
                        if (c == '<') {         // be tolerant with old muse files
348
 
                              *p++ = '&';
 
394
                              
 
395
                              //*p++ = '&';
 
396
                              buffer[idx++] = '&';
 
397
                              
349
398
                              continue;
350
399
                              }
351
 
                        char name[32];
352
 
                        char* dp = name;
353
 
                        *dp++ = c;
354
 
                        for (; dp-name < 31;) {
 
400
                              
 
401
                        //char name[32];
 
402
                        //char* dp = name;
 
403
                        QByteArray name;
 
404
                        int name_idx = 0;
 
405
                        
 
406
                        //*dp++ = c;
 
407
                        name[name_idx++] = c;
 
408
                        
 
409
                        //for (; dp-name < 31;) {
 
410
                        for (; name_idx < 9999999;) {   // Stop at a reasonably large amount 10 million.
355
411
                              next();
356
412
                              if (c == ';')
357
413
                                    break;
358
 
                              *dp++ = c;
 
414
                              
 
415
                              //*dp++ = c;
 
416
                              name[name_idx++] = c;
359
417
                              }
360
 
                        *dp = 0;
 
418
                              
 
419
                        //*dp = 0;
 
420
                        name[name_idx] = 0;
 
421
                        
361
422
                        if (strcmp(name, "lt") == 0)
362
423
                              c = '<';
363
424
                        else if (strcmp(name, "gt") == 0)
371
432
                        else
372
433
                              c = '?';
373
434
                        }
374
 
                  *p++ = c;
 
435
                        
 
436
                  //*p++ = c;
 
437
                  buffer[idx++] = c;
 
438
                  
375
439
                  next();
376
440
                  }
377
 
            *p = 0;
 
441
                  
 
442
            //*p = 0;
 
443
            buffer[idx] = 0;
 
444
            
378
445
            _s1 = QString(buffer);
379
446
 
380
447
            if (c == '<')
732
799
          dump.append(lbuffer);
733
800
       fsetpos(f, &pos);
734
801
      }
 
802
 
 
803
} // namespace MusECore