source: sources/src/dataTplProcessor.cc @ 1500:872b0b69e0d5

Revision 1500:872b0b69e0d5, 51.7 KB checked in by niam, 12 months ago (diff)

{issue #103} added implementation of sl- and dl- lists
Line 
1/***************************************************************************
2 *            dataTplProcessor.cc
3 *
4 *  Sun Jan 22 2006
5 *  Copyright  2005  Dmytro Milinevskyy
6 *  milinevskyy@gmail.com
7 ****************************************************************************/
8
9/*
10 *  This program is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU Lesser General Public License version 2.1 as published by
12 *  the Free Software Foundation;
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 Library General Public License for more details.
18 *
19 *  You should have received a copy of the GNU Lesser General Public License
20 *  along with this program; if not, write to the Free Software
21 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 */
23
24/**
25 * vim indentation settings
26 * set tabstop=4
27 * set shiftwidth=4
28 */
29
30#include <libdodo/directives.h>
31
32#include <libdodo/dataTplProcessor.h>
33#include <libdodo/dataTplProcessorEx.h>
34#include <libdodo/types.h>
35#include <libdodo/toolsFilesystem.h>
36#include <libdodo/toolsMisc.h>
37#include <libdodo/ioChannel.h>
38#include <libdodo/toolsString.h>
39
40using namespace dodo::data::tpl;
41
42const dodo::string processor::statements[] = {
43    "dodo",
44    "<(",
45    ")>",
46    "<(>",
47    "<)>",
48    "<(*",
49    "*)>",
50    "if",
51    "else",
52    "fi",
53    "for",
54    "in",
55    "=>",
56    "rof",
57    "print",
58    "break",
59    "continue",
60    "assign",
61    "=",
62    "ns",
63    "sn",
64    "include",
65    "iterator",
66    "version",
67    ".",
68    ",",
69    "$",
70    "false",
71    "{",
72    "}"
73};
74
75//-------------------------------------------------------------------
76
77processor::processor() : continueFlag(false),
78                         breakDeepness(0),
79                         loopDeepness(0),
80                         iterator(1),
81                         namespaceDeepness(1)
82{
83    dodo[statements[STATEMENT_VERSION]] = PACKAGE_STRING;
84    dodo[statements[STATEMENT_ITERATOR]] = "1";
85}
86
87//-------------------------------------------------------------------
88
89processor::~processor()
90{
91}
92
93//-------------------------------------------------------------------
94
95dodoArray<unsigned long>
96processor::detectNewLines(const dodo::string &tpl)
97{
98    dodoArray<unsigned long> newLinePos;
99
100    long i(0), j(tpl.size());
101    for (; i < j; ++i)
102        if (tpl[i] == '\n')
103            newLinePos.push_back(i);
104    newLinePos.push_back(i);
105
106    return newLinePos;
107}
108
109//-------------------------------------------------------------------
110
111dodo::string
112processor::preProcessString(const dodo::string &buffer)
113{
114    return _preProcessString(buffer, "memory");
115}
116
117//-------------------------------------------------------------------
118
119dodo::string
120processor::_preProcessString(const dodo::string &buffer,
121                             const dodo::string &path)
122{
123    dodoArray<unsigned long> newLinePos = detectNewLines(buffer);
124
125    unsigned long i(0), j(0), begin(0);
126
127    while (true) {
128        begin = j;
129
130        i = buffer.find(statements[STATEMENT_OPEN_ST], begin);
131        if (i == dodo::string::POSITION_END) {
132            j = buffer.find(statements[STATEMENT_CLOSE_ST], begin);
133            if (j != dodo::string::POSITION_END)
134                dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__PREPROCESSSTRING, exception::ERRNO_LIBDODO, PROCESSOREX_NOTCLOSEDBRACKET, DATATPLPROCESSOREX_NOTCLOSEDBRACKET_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s Bracket `<(`", getLineNumber(newLinePos, j), path.data()));
135
136            break;
137        } else {
138            dodo::string temp = dodo::string(buffer.data() + begin, i - begin);
139
140            j = temp.find(statements[STATEMENT_CLOSE_ST], begin);
141            if (j != dodo::string::POSITION_END)
142                dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__PREPROCESSSTRING, exception::ERRNO_LIBDODO, PROCESSOREX_NOTCLOSEDBRACKET, DATATPLPROCESSOREX_NOTCLOSEDBRACKET_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s Bracket `)>`", getLineNumber(newLinePos, i), path.data()));
143        }
144
145        i += 2;
146
147        if (buffer[i] == '>') {
148            j = buffer.find(statements[STATEMENT_CLOSE_NP], i);
149            if (j != dodo::string::POSITION_END) {
150                j += 3;
151
152                continue;
153            } else
154                dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__PREPROCESSSTRING, exception::ERRNO_LIBDODO, PROCESSOREX_NOTCLOSEDBRACKET, DATATPLPROCESSOREX_NOTCLOSEDBRACKET_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s Bracket `<)>`", getLineNumber(newLinePos, j), path.data()));
155        }
156
157        if (buffer[i] == '*') {
158            j = buffer.find(statements[STATEMENT_CLOSE_COMM], i);
159            if (j != dodo::string::POSITION_END) {
160                j += 3;
161
162                continue;
163            } else
164                dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__PREPROCESSSTRING, exception::ERRNO_LIBDODO, PROCESSOREX_NOTCLOSEDBRACKET, DATATPLPROCESSOREX_NOTCLOSEDBRACKET_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s Bracket `*)>`", getLineNumber(newLinePos, j), path.data()));
165        }
166
167        j = buffer.find(statements[STATEMENT_CLOSE_ST], i);
168        if (j == dodo::string::POSITION_END)
169            dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__PREPROCESSSTRING, exception::ERRNO_LIBDODO, PROCESSOREX_NOTCLOSEDBRACKET, DATATPLPROCESSOREX_NOTCLOSEDBRACKET_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s Bracket `)>`", getLineNumber(newLinePos, j), path.data()));
170
171        if (j > 0 && buffer[j - 1] == '*')
172            dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__PREPROCESSSTRING, exception::ERRNO_LIBDODO, PROCESSOREX_NOTCLOSEDBRACKET, DATATPLPROCESSOREX_NOTCLOSEDBRACKET_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s Bracket `*)>", getLineNumber(newLinePos, j), path.data()));
173
174        if (j > 0 && buffer[j - 1] == '<')
175            dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__PREPROCESSSTRING, exception::ERRNO_LIBDODO, PROCESSOREX_NOTCLOSEDBRACKET, DATATPLPROCESSOREX_NOTCLOSEDBRACKET_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s Bracket `<)>", getLineNumber(newLinePos, j), path.data()));
176
177        dodo::string temp = dodo::string(buffer.data() + i, j - i);
178
179        if (temp.find(statements[STATEMENT_OPEN_ST]) != dodo::string::POSITION_END)
180            dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__PREPROCESSSTRING, exception::ERRNO_LIBDODO, PROCESSOREX_NOTCLOSEDBRACKET, DATATPLPROCESSOREX_NOTCLOSEDBRACKET_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s Bracket `<(`", getLineNumber(newLinePos, j), path.data()));
181
182        j += 2;
183    }
184
185    newLinePositions.push_back(newLinePos);
186
187    return buffer;
188}
189
190//-------------------------------------------------------------------
191
192dodo::string
193processor::preProcessFile(const dodo::string &path)
194{
195    if (basePath.empty())
196        return _preProcessString(tools::filesystem::fileContents(path), path);
197    else
198        return _preProcessString(tools::filesystem::fileContents(basePath + "/" + path), path);
199}
200
201//-------------------------------------------------------------------
202
203unsigned long
204processor::getLineNumber(const dodoArray<unsigned long> &newLinePos,
205                         unsigned long                  pos)
206{
207    dodoArray<unsigned long>::const_iterator o(newLinePos.begin()), p(newLinePos.end());
208
209    unsigned long i(1);
210
211    for (; o != p; ++o, ++i)
212        if (pos <= *o)
213            return i;
214
215    return i - 1;
216}
217
218//-------------------------------------------------------------------
219
220void
221processor::processString(const dodo::string &buffer,
222                         io::channel      &tpl)
223{
224    _processString(preProcessString(buffer), "memory", tpl);
225
226    newLinePositions.pop_back();
227}
228
229//-------------------------------------------------------------------
230
231void
232processor::processFile(const dodo::string &path,
233                       io::channel      &tpl)
234{
235    _processString(preProcessFile(path), path, tpl);
236
237    newLinePositions.pop_back();
238}
239
240//-------------------------------------------------------------------
241
242void
243processor::clear()
244{
245    globalArray.clear();
246    globalHash.clear();
247    globalArrayHash.clear();
248    global.clear();
249
250    processed.clear();
251    localHash.clear();
252    local.clear();
253}
254
255//-------------------------------------------------------------------
256
257void
258processor::_processString(const dodo::string &buffer,
259                          const dodo::string &path,
260                          io::channel      &tpl)
261{
262    unsigned long i(0), j(0), begin(0), k(0);
263    unsigned long stI;
264
265    dodo::string temp;
266
267    bool breakLoop = false;
268    bool keywordNotFound = false;
269
270    while (true) {
271        begin = j;
272
273        i = buffer.find(statements[STATEMENT_OPEN_ST], begin);
274        if (i == dodo::string::POSITION_END) {
275            tpl.writeString(dodo::string(buffer.data() + begin, buffer.size() - begin));
276
277            break;
278        } else
279            tpl.writeString(dodo::string(buffer.data() + begin, i - begin));
280
281        i += 2;
282
283        if (buffer[i] == '>') {
284            j = buffer.find(statements[STATEMENT_CLOSE_NP], i);
285
286            ++i;
287            tpl.writeString(dodo::string(buffer.data() + i, j - i));
288            j += 3;
289
290            continue;
291        }
292
293        if (buffer[i] == '*') {
294            j = buffer.find(statements[STATEMENT_CLOSE_COMM], i);
295
296            j += 3;
297
298            continue;
299        }
300
301        j = buffer.find(statements[STATEMENT_CLOSE_ST], i);
302
303        for (stI = i; stI < j; ++stI)
304            if (buffer[stI] != '\t' && buffer[stI] != ' ' && buffer[stI] != '\r' && buffer[stI] != '\n')
305                break;
306
307        temp = dodo::string(buffer.data() + stI, j - stI);
308
309        j += 2;
310
311        keywordNotFound = false;
312
313        switch (temp[0]) {
314            case 'p':
315
316                k = temp.find(statements[STATEMENT_PRINT]);
317                if (k == 0)
318                    j = _print(j, dodo::string(temp.data() + 5, temp.size() - 5), tpl, path);
319                else
320                    keywordNotFound = true;
321
322                break;
323
324            case 'i':
325
326                k = temp.find(statements[STATEMENT_OPEN_IF]);
327                if (k == 0) {
328                    ++namespaceDeepness;
329
330                    j = _if(buffer, j, dodo::string(temp.data() + 2, temp.size() - 2), tpl, path);
331
332                    cleanNamespace();
333
334                    --namespaceDeepness;
335                } else {
336                    k = temp.find(statements[STATEMENT_INCLUDE]);
337                    if (k == 0)
338                        j = _include(j, dodo::string(temp.data() + 8, temp.size() - 8), tpl, path);
339                    else
340                        keywordNotFound = true;
341                }
342
343                break;
344
345            case 'f':
346
347                k = temp.find(statements[STATEMENT_OPEN_FOR]);
348                if (k == 0) {
349                    ++loopDeepness;
350                    ++namespaceDeepness;
351
352                    j = _for(buffer, j, dodo::string(temp.data() + 3, temp.size() - 3), tpl, path);
353
354                    cleanNamespace();
355
356                    --namespaceDeepness;
357                    --loopDeepness;
358                } else
359                    keywordNotFound = true;
360
361                break;
362
363            case 'b':
364
365                k = temp.find(statements[STATEMENT_BREAK]);
366                if (k == 0) {
367                    if (_break(j, dodo::string(temp.data() + 5, temp.size() - 5), path))
368                        breakLoop = true;
369                } else
370                    keywordNotFound = true;
371
372                break;
373
374            case 'c':
375
376                k = temp.find(statements[STATEMENT_CONT]);
377                if (k == 0) {
378                    if (loopDeepness > 0) {
379                        continueFlag = true;
380
381                        breakLoop = true;
382                    }
383                } else
384                    keywordNotFound = true;
385
386                break;
387
388            case 'a':
389
390                k = temp.find(statements[STATEMENT_ASSIGN]);
391                if (k == 0)
392                    j = _assign(j, dodo::string(temp.data() + 6, temp.size() - 6), path);
393                else
394                    keywordNotFound = true;
395
396                break;
397
398            case 'n':
399
400                k = temp.find(statements[STATEMENT_OPEN_NS]);
401                if (k == 0) {
402                    ++namespaceDeepness;
403
404                    j = _ns(buffer, j, tpl, path);
405
406                    cleanNamespace();
407
408                    --namespaceDeepness;
409                } else
410                    keywordNotFound = true;
411
412                break;
413
414            default:
415
416                keywordNotFound = true;
417        }
418
419        if (keywordNotFound)
420            tpl.writeString(dodo::string(buffer.data() + i - 2, j - i + 2));
421
422        if (breakLoop)
423            break;
424
425        if (breakDeepness > 0)
426            break;
427
428        if (continueFlag)
429            break;
430    }
431}
432
433//-------------------------------------------------------------------
434
435void
436processor::assign(dodo::string                     varName,
437                  const dodoArray<dodoStringMap> &varVal)
438{
439    if (tools::string::equal(varName, statements[STATEMENT_DODO]))
440        dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX_ASSIGN, exception::ERRNO_LIBDODO, PROCESSOREX_DODOISRESERVEDVARNAME, DATATPLPROCESSOREX_DODOISRESERVEDVARNAME_STR, __LINE__, __FILE__);
441
442    global.erase(varName);
443    globalArray.erase(varName);
444    globalHash.erase(varName);
445
446    globalArrayHash[varName] = varVal;
447}
448
449//-------------------------------------------------------------------
450
451void
452processor::assign(dodo::string          varName,
453                  const dodoStringMap &varVal)
454{
455    if (tools::string::equal(varName, statements[STATEMENT_DODO]))
456        dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX_ASSIGN, exception::ERRNO_LIBDODO, PROCESSOREX_DODOISRESERVEDVARNAME, DATATPLPROCESSOREX_DODOISRESERVEDVARNAME_STR, __LINE__, __FILE__);
457
458    global.erase(varName);
459    globalArray.erase(varName);
460    globalArrayHash.erase(varName);
461
462    globalHash[varName] = varVal;
463}
464
465//-------------------------------------------------------------------
466
467void
468processor::assign(dodo::string            varName,
469                  const dodoStringArray &varVal)
470{
471    if (tools::string::equal(varName, statements[STATEMENT_DODO]))
472        dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX_ASSIGN, exception::ERRNO_LIBDODO, PROCESSOREX_DODOISRESERVEDVARNAME, DATATPLPROCESSOREX_DODOISRESERVEDVARNAME_STR, __LINE__, __FILE__);
473
474    global.erase(varName);
475    globalHash.erase(varName);
476    globalArrayHash.erase(varName);
477
478    globalArray[varName] = varVal;
479}
480
481//-------------------------------------------------------------------
482
483void
484processor::assign(dodo::string       varName,
485                  const dodo::string &varVal)
486{
487    if (tools::string::equal(varName, statements[STATEMENT_DODO]))
488        dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX_ASSIGN, exception::ERRNO_LIBDODO, PROCESSOREX_DODOISRESERVEDVARNAME, DATATPLPROCESSOREX_DODOISRESERVEDVARNAME_STR, __LINE__, __FILE__);
489
490    globalArray.erase(varName);
491    globalHash.erase(varName);
492    globalArrayHash.erase(varName);
493
494    global[varName] = varVal;
495}
496
497//-------------------------------------------------------------------
498
499unsigned long
500processor::_if(const dodo::string &buffer,
501               unsigned long    start,
502               const dodo::string &statement,
503               io::channel      &tpl,
504               const dodo::string &path)
505{
506    bool _float(false), invert(false);
507
508    enum operEnum {
509        OPERTYPE_NONE,
510        OPERTYPE_LE,
511        OPERTYPE_GE,
512        OPERTYPE_LT,
513        OPERTYPE_GT
514    };
515
516    unsigned short oper(OPERTYPE_NONE);
517
518    dodo::string temp1;
519    dodoArray<dodo::string> temp2;
520    unsigned long i = 0, j = statement.size();
521
522    for (; i < j; ++i) {
523        if ((j - i) > 1) {
524            if (statement[i] == '=' && statement[i + 1] == '=') {
525                temp2.push_back(dodo::string(statement.data(), i));
526                temp2.push_back(dodo::string(statement.data() + i + 2, j - i - 2));
527
528                break;
529            }
530            if (statement[i] == '!' && statement[i + 1] == '=') {
531                invert = true;
532
533                temp2.push_back(dodo::string(statement.data(), i));
534                temp2.push_back(dodo::string(statement.data() + i + 2, j - i - 2));
535
536                break;
537            }
538            if (statement[i] == '>' && statement[i + 1] == '=') {
539                oper = OPERTYPE_GE;
540                _float = true;
541
542                temp2.push_back(dodo::string(statement.data(), i));
543                temp2.push_back(dodo::string(statement.data() + i + 2, j - i - 2));
544
545                break;
546            }
547            if (statement[i] == '<' && statement[i + 1] == '=') {
548                oper = OPERTYPE_LE;
549                _float = true;
550
551                temp2.push_back(dodo::string(statement.data(), i));
552                temp2.push_back(dodo::string(statement.data() + i + 2, j - i - 2));
553
554                break;
555            }
556        }
557        if (statement[i] == '<') {
558            oper = OPERTYPE_LT;
559            _float = true;
560
561            temp2.push_back(dodo::string(statement.data(), i));
562            temp2.push_back(dodo::string(statement.data() + i + 1, j - i - 1));
563
564            break;
565        }
566        if (statement[i] == '>') {
567            oper = OPERTYPE_GT;
568            _float = true;
569
570            temp2.push_back(dodo::string(statement.data(), i));
571            temp2.push_back(dodo::string(statement.data() + i + 1, j - i - 1));
572
573            break;
574        }
575        if (statement[i] == '!') {
576            invert = true;
577
578            temp1 = dodo::string(statement.data() + i + 1, j - i - 1);
579
580            break;
581        }
582    }
583
584    bool accept(invert);
585
586    if (temp2.size() != 2) {
587        if (!tools::string::equal(getVar(temp1, start, path), statements[STATEMENT_FALSE]))
588            accept = !invert;
589        else
590            accept = invert;
591    } else {
592        temp1 = getVar(temp2[0], start, path);
593
594        dodo::string temp3 = getVar(temp2[1], start, path);
595
596        if (_float) {
597            double first(tools::string::stringToD(temp1)), second(tools::string::stringToD(temp3));
598
599            switch (oper) {
600                case OPERTYPE_LE:
601
602                    accept = (first <= second);
603
604                    break;
605
606                case OPERTYPE_GE:
607
608                    accept = (first >= second);
609
610                    break;
611
612                case OPERTYPE_LT:
613
614                    accept = (first < second);
615
616                    break;
617
618                case OPERTYPE_GT:
619
620                    accept = (first > second);
621
622                    break;
623            }
624        } else if (tools::string::equal(temp1, temp3))
625            accept = !invert;
626    }
627
628    unsigned long u(blockEnd(buffer, start, statements[STATEMENT_OPEN_IF], statements[STATEMENT_CLOSE_IF], path)), v(0);
629    bool found(true);
630
631    dodo_try {
632        v = blockEnd(buffer, start, statements[STATEMENT_OPEN_IF], statements[STATEMENT_ELSE], path);
633    } dodo_catch (exception::basic *e UNUSED) {
634        found = false;
635    }
636
637    if (accept) {
638        if (!found)
639            v = u;
640
641        _processString(dodo::string(buffer.data() + start, v - start), path, tpl);
642    } else {
643        if (found) {
644            v = buffer.find(statements[STATEMENT_CLOSE_ST], v) + 2;
645
646            _processString(dodo::string(buffer.data() + v, u - v), path, tpl);
647        }
648    }
649
650    return buffer.find(statements[STATEMENT_CLOSE_ST], u) + 2;
651}
652
653//-------------------------------------------------------------------
654
655unsigned long
656processor::blockEnd(const dodo::string &buffer,
657                    unsigned long    start,
658                    const dodo::string &st,
659                    const dodo::string &ts,
660                    const dodo::string &path)
661{
662    unsigned long u, m(start), _st(1), b, p, stLen(st.size()), tsLen(ts.size());
663
664    while (true) {
665        u = buffer.find(statements[STATEMENT_OPEN_ST], m);
666        if (u == dodo::string::POSITION_END)
667            dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX_BLOCKEND, exception::ERRNO_LIBDODO, PROCESSOREX_WRONGBLOCK, DATATPLPROCESSOREX_WRONGBLOCK_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s", getLineNumber(newLinePositions.back(), start), path.data()));
668
669        b = buffer.find(statements[STATEMENT_CLOSE_ST], u + 2);
670        if (b == dodo::string::POSITION_END)
671            dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX_BLOCKEND, exception::ERRNO_LIBDODO, PROCESSOREX_WRONGBLOCK, DATATPLPROCESSOREX_WRONGBLOCK_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s", getLineNumber(newLinePositions.back(), start), path.data()));
672
673        for (p = u; p < b; ++p) {
674            if (buffer[p] != ' ' && buffer[p] != '\t' && buffer[p] != '\n' && buffer[p] != '\r') {
675                if (tools::string::equal(dodo::string(buffer.data() + p, tsLen), ts))
676                    --_st;
677                else if (tools::string::equal(dodo::string(buffer.data() + p, stLen), st))
678                    ++_st;
679            }
680        }
681
682        if (_st == 0)
683            break;
684
685        m = b + 2;
686    }
687
688    return u;
689}
690
691//-------------------------------------------------------------------
692
693unsigned long
694processor::_include(unsigned long    start,
695                    const dodo::string &statement,
696                    io::channel      &tpl,
697                    const dodo::string &path)
698{
699    dodo::string temp1 = getVar(statement, start, path);
700
701    if (!tools::string::equal(temp1, path) && !tools::misc::isInList(processed, temp1, false)) {
702        if (!basePath.empty())
703            temp1 = basePath + "/" + temp1;
704
705        if (tools::filesystem::exists(temp1)) {
706            processed.push(path);
707
708            processFile(temp1, tpl);
709
710            processed.pop();
711        }
712    }
713
714    return start;
715}
716
717//-------------------------------------------------------------------
718
719unsigned long
720processor::_print(unsigned long    start,
721                  const dodo::string &statement,
722                  io::channel      &tpl,
723                  const dodo::string &path)
724{
725    dodoStringArray temp = tools::misc::split(statement, statements[STATEMENT_COMA]);
726    if (temp.size() <= 1)
727        tpl.writeString(getVar(statement, start, path));
728    else {
729        dodoStringArray::iterator i(temp.begin()), j(temp.end());
730        for (; i != j; ++i)
731            tpl.writeString(getVar(*i, start, path));
732    }
733
734    return start;
735}
736
737//-------------------------------------------------------------------
738
739bool
740processor::_break(unsigned long    start,
741                  const dodo::string &statement,
742                  const dodo::string &path)
743{
744    if (loopDeepness > 0) {
745        breakDeepness = tools::string::stringToUL(getVar(statement, start, path));
746
747        if (breakDeepness == 0)
748            breakDeepness = 1;
749        else if (breakDeepness > loopDeepness)
750            breakDeepness = loopDeepness;
751
752        return true;
753    }
754
755    return false;
756}
757
758//-------------------------------------------------------------------
759
760unsigned long
761processor::_assign(unsigned long    start,
762                   const dodo::string &statement,
763                   const dodo::string &path)
764{
765    dodoStringArray temp = tools::misc::split(statement, statements[STATEMENT_ASSIGN_OP], 2);
766
767    if (temp.size() == 0)
768        dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__ASSIGN, exception::ERRNO_LIBDODO, PROCESSOREX_WRONGASSIGNSTATEMENT, DATATPLPROCESSOREX_WRONGASSIGNSTATEMENT_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s", getLineNumber(newLinePositions.back(), start), path.data()));
769
770    dodo::string varName = trim(tools::string::trim(temp[0], " \t\r\n", 4));
771    if (varName.size() == 0)
772        dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__ASSIGN, exception::ERRNO_LIBDODO, PROCESSOREX_WRONGASSIGNSTATEMENT, DATATPLPROCESSOREX_WRONGASSIGNSTATEMENT_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s", getLineNumber(newLinePositions.back(), start), path.data()));
773
774    if (varName[0] == '$')
775        varName = dodo::string(varName.data() + 1, varName.size() - 1);
776
777    if (tools::string::equal(varName, statements[STATEMENT_DODO]))
778        dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__ASSIGN, exception::ERRNO_LIBDODO, PROCESSOREX_DODOISRESERVEDVARNAME, DATATPLPROCESSOREX_DODOISRESERVEDVARNAME_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s", getLineNumber(newLinePositions.back(), start), path.data()));
779
780    local[namespaceDeepness][varName] = getVar(temp[1], start, path);
781
782    return start;
783}
784
785//-------------------------------------------------------------------
786
787void
788processor::cleanNamespace()
789{
790    local.erase(namespaceDeepness);
791    localHash.erase(namespaceDeepness);
792}
793
794//-------------------------------------------------------------------
795
796unsigned long
797processor::_ns(const dodo::string &buffer,
798               unsigned long    start,
799               io::channel      &tpl,
800               const dodo::string &path)
801{
802    unsigned long u(blockEnd(buffer, start, statements[STATEMENT_OPEN_NS], statements[STATEMENT_CLOSE_NS], path));
803
804    _processString(dodo::string(buffer.data() + start, u - start), path, tpl);
805
806    return buffer.find(statements[STATEMENT_CLOSE_ST], u) + 2;
807}
808
809//-------------------------------------------------------------------
810
811unsigned long
812processor::_for(const dodo::string &buffer,
813                unsigned long    start,
814                const dodo::string &statement,
815                io::channel      &tpl,
816                const dodo::string &path)
817{
818    unsigned long u(blockEnd(buffer, start, statements[STATEMENT_OPEN_FOR], statements[STATEMENT_CLOSE_FOR], path));
819
820    unsigned long p = statement.find(statements[STATEMENT_DOLLAR]);
821    unsigned long i(p), j(statement.size());
822
823    for (; i < j; ++i)
824        if (statement[i] == ' ' || statement[i] == '\t' || statement[i] == '\n')
825            break;
826    --i;
827
828    dodo::string varName = dodo::string(statement.data() + p + 1, i - p);
829
830    bool key(false);
831    dodo::string keyName;
832
833    p = statement.find(statements[STATEMENT_KEY_VALUE], i + 1);
834    if (p != dodo::string::POSITION_END) {
835        key = true;
836        p = statement.find(statements[STATEMENT_DOLLAR], p + 2);
837
838        for (i = p; i < j; ++i)
839            if (statement[i] == ' ' || statement[i] == '\t' || statement[i] == '\n')
840                break;
841        --i;
842
843        keyName = varName;
844        varName = dodo::string(statement.data() + p + 1, i - p);
845    }
846
847    p = statement.find(statements[STATEMENT_IN], i + 1);
848    if (p == dodo::string::POSITION_END)
849        dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX__FOR, exception::ERRNO_LIBDODO, PROCESSOREX_WRONGFORSTATEMENT, DATATPLPROCESSOREX_WRONGFORSTATEMENT_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s", getLineNumber(newLinePositions.back(), start), path.data()));
850
851    dodo::string targetVar = getVarName(tools::string::trim(dodo::string(statement.data() + p + 2), " \t\r\n", 4), start, path);
852    dodo::string forSpace = dodo::string(buffer.data() + start, u - start);
853
854    u = buffer.find(statements[STATEMENT_CLOSE_ST], u) + 2;
855
856    if (targetVar[0] == '$') {
857        targetVar = dodo::string(targetVar.data() + 1, targetVar.size() - 1);
858
859        dodoStringArray temp = tools::misc::split(targetVar, statements[STATEMENT_DOT]);
860
861        if (temp.size() == 1) {
862            dodoMap<unsigned int, dodoMap<dodo::string, dodoStringMap> >::reverse_iterator lhpnsi = localHash.rbegin();
863            dodoMap<unsigned int, dodoMap<dodo::string, dodoStringMap> >::reverse_iterator lhpnsj = localHash.rend();
864            for (; lhpnsi != lhpnsj; ++lhpnsi) {
865                dodoMap<dodo::string, dodoStringMap>::iterator g = lhpnsi->second.find(targetVar);
866                if (g != lhpnsi->second.end()) {
867                    dodoStringMap &lns = local[namespaceDeepness];
868
869                    unsigned long iteratorPrev = iterator;
870                    iterator = 1;
871
872                    dodoStringMap::iterator k = g->second.begin();
873                    dodoStringMap::iterator l = g->second.end();
874                    for (; k != l; ++k, ++iterator) {
875                        dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
876
877                        if (key)
878                            lns[keyName] = k->first;
879                        lns[varName] = k->second;
880
881                        _processString(forSpace, path, tpl);
882
883                        if (breakDeepness > 0) {
884                            --breakDeepness;
885
886                            break;
887                        }
888                        if (continueFlag)
889                            continueFlag = false;
890                    }
891
892                    iterator =  iteratorPrev;
893                    dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
894
895                    return u;
896                }
897            }
898
899            dodoMap<unsigned int, dodoStringMap>::reverse_iterator lpnsi = local.rbegin();
900            dodoMap<unsigned int, dodoStringMap>::reverse_iterator lpnsj = local.rend();
901            for (; lpnsi != lpnsj; ++lpnsi) {
902                dodoStringMap::iterator k = lpnsi->second.find(targetVar);
903                if (k != lpnsi->second.end()) {
904                    dodoStringMap &lns = local[namespaceDeepness];
905
906                    unsigned long iteratorPrev = iterator;
907                    iterator = 1;
908
909                    unsigned long i(0), j(k->second.size());
910                    for (; i < j; ++i, ++iterator) {
911                        dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
912
913                        if (key)
914                            lns[keyName] = tools::string::lToString(i);
915                        lns[varName] = k->second[i];
916
917                        _processString(forSpace, path, tpl);
918
919                        if (breakDeepness > 0) {
920                            --breakDeepness;
921
922                            break;
923                        }
924                        if (continueFlag)
925                            continueFlag = false;
926                    }
927
928                    iterator =  iteratorPrev;
929                    dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
930
931                    return u;
932                }
933            }
934
935            dodoStringMap::iterator k = global.find(targetVar);
936            if (k != global.end()) {
937                dodoStringMap &lns = local[namespaceDeepness];
938
939                unsigned long iteratorPrev = iterator;
940                iterator = 1;
941
942                unsigned long i(0), j(k->second.size());
943                for (; i < j; ++i, ++iterator) {
944                    dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
945
946                    if (key)
947                        lns[keyName] = tools::string::lToString(i);
948                    lns[varName] = k->second[i];
949
950                    _processString(forSpace, path, tpl);
951
952                    if (breakDeepness > 0) {
953                        --breakDeepness;
954
955                        break;
956                    }
957                    if (continueFlag)
958                        continueFlag = false;
959                }
960
961                iterator =  iteratorPrev;
962                dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
963
964                return u;
965            }
966
967            dodoMap<dodo::string, dodoStringMap>::iterator g = globalHash.find(targetVar);
968            if (g != globalHash.end()) {
969                dodoStringMap &lns = local[namespaceDeepness];
970
971                unsigned long iteratorPrev = iterator;
972                iterator = 1;
973
974                dodoStringMap::iterator k = g->second.begin();
975                dodoStringMap::iterator l = g->second.end();
976                for (; k != l; ++k, ++iterator) {
977                    dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
978
979                    if (key)
980                        lns[keyName] = k->first;
981                    lns[varName] = k->second;
982
983                    _processString(forSpace, path, tpl);
984
985                    if (breakDeepness > 0) {
986                        --breakDeepness;
987
988                        break;
989                    }
990                    if (continueFlag)
991                        continueFlag = false;
992                }
993
994                iterator =  iteratorPrev;
995                dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
996
997                return u;
998            }
999
1000            dodoMap<dodo::string, dodoStringArray>::iterator o = globalArray.find(targetVar);
1001            if (o != globalArray.end()) {
1002                dodoStringMap &lns = local[namespaceDeepness];
1003
1004                unsigned long iteratorPrev = iterator;
1005                iterator = 1;
1006
1007                dodoStringArray::iterator k = o->second.begin();
1008                dodoStringArray::iterator l = o->second.end();
1009                for (unsigned long keyNIter(0); k != l; ++k, ++keyNIter, ++iterator) {
1010                    dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
1011
1012                    if (key)
1013                        lns[keyName] = tools::string::lToString(keyNIter);
1014                    lns[varName] = *k;
1015
1016                    _processString(forSpace, path, tpl);
1017
1018                    if (breakDeepness > 0) {
1019                        --breakDeepness;
1020
1021                        break;
1022                    }
1023                    if (continueFlag)
1024                        continueFlag = false;
1025                }
1026
1027                iterator =  iteratorPrev;
1028                dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
1029
1030                return u;
1031            }
1032
1033            dodoMap<dodo::string, dodoArray<dodoStringMap> >::iterator d = globalArrayHash.find(targetVar);
1034            if (d != globalArrayHash.end()) {
1035                dodoStringMap &lns = local[namespaceDeepness];
1036                dodoMap<dodo::string, dodoStringMap> &lnsh = localHash[namespaceDeepness];
1037
1038                unsigned long iteratorPrev = iterator;
1039                iterator = 1;
1040
1041                dodoArray<dodoStringMap>::iterator k = d->second.begin();
1042                dodoArray<dodoStringMap>::iterator l = d->second.end();
1043                for (unsigned long keyNIter(0); k != l; ++k, ++keyNIter, ++iterator) {
1044                    dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
1045
1046                    if (key)
1047                        lns[keyName] = tools::string::lToString(keyNIter);
1048                    lnsh[varName] = *k;
1049
1050                    _processString(forSpace, path, tpl);
1051
1052                    if (breakDeepness > 0) {
1053                        --breakDeepness;
1054
1055                        break;
1056                    }
1057                    if (continueFlag)
1058                        continueFlag = false;
1059                }
1060
1061                iterator =  iteratorPrev;
1062                dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
1063
1064                return u;
1065            }
1066        } else {
1067            if (temp.size() == 2) {
1068                dodoMap<unsigned int, dodoMap<dodo::string, dodoStringMap> >::reverse_iterator lhpnsi = localHash.rbegin();
1069                dodoMap<unsigned int, dodoMap<dodo::string, dodoStringMap> >::reverse_iterator lhpnsj = localHash.rend();
1070                for (; lhpnsi != lhpnsj; ++lhpnsi) {
1071                    dodoMap<dodo::string, dodoStringMap>::iterator g = lhpnsi->second.find(targetVar);
1072                    if (g != lhpnsi->second.end()) {
1073                        dodoStringMap::iterator k = g->second.find(temp[1]);
1074                        if (k != g->second.end()) {
1075                            dodoStringMap &lns = local[namespaceDeepness];
1076
1077                            unsigned long iteratorPrev = iterator;
1078                            iterator = 1;
1079
1080                            unsigned long i(0), j(k->second.size());
1081                            for (; i < j; ++i, ++iterator) {
1082                                dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
1083
1084                                if (key)
1085                                    lns[keyName] = tools::string::lToString(i);
1086                                lns[varName] = k->second[i];
1087
1088                                _processString(forSpace, path, tpl);
1089
1090                                if (breakDeepness > 0) {
1091                                    --breakDeepness;
1092
1093                                    break;
1094                                }
1095                                if (continueFlag)
1096                                    continueFlag = false;
1097                            }
1098
1099                            iterator =  iteratorPrev;
1100                            dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
1101
1102                            return u;
1103                        }
1104                    }
1105                }
1106
1107                dodoMap<dodo::string, dodoStringMap>::iterator g = globalHash.find(temp[0]);
1108                if (g != globalHash.end()) {
1109                    dodoStringMap::iterator k = g->second.find(temp[1]);
1110                    if (k != g->second.end()) {
1111                        dodoStringMap &lns = local[namespaceDeepness];
1112
1113                        unsigned long iteratorPrev = iterator;
1114                        iterator = 1;
1115
1116                        unsigned long i(0), j(k->second.size());
1117                        for (; i < j; ++i, ++iterator) {
1118                            dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
1119
1120                            if (key)
1121                                lns[keyName] = tools::string::lToString(i);
1122                            lns[varName] = k->second[i];
1123
1124                            _processString(forSpace, path, tpl);
1125
1126                            if (breakDeepness > 0) {
1127                                --breakDeepness;
1128
1129                                break;
1130                            }
1131                            if (continueFlag)
1132                                continueFlag = false;
1133                        }
1134
1135                        iterator =  iteratorPrev;
1136                        dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
1137
1138                        return u;
1139                    }
1140                }
1141
1142                dodoMap<dodo::string, dodoStringArray>::iterator o = globalArray.find(temp[0]);
1143                if (o != globalArray.end()) {
1144                    unsigned long pos = tools::string::stringToUL(temp[1]);
1145                    if (pos <= o->second.size()) {
1146                        dodoStringMap &lns = local[namespaceDeepness];
1147
1148                        unsigned long iteratorPrev = iterator;
1149                        iterator = 1;
1150
1151                        unsigned long i(0), j(o->second[pos].size());
1152                        for (; i < j; ++i, ++iterator) {
1153                            dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
1154
1155                            if (key)
1156                                lns[keyName] = tools::string::lToString(i);
1157                            lns[varName] = o->second[pos][i];
1158
1159                            _processString(forSpace, path, tpl);
1160
1161                            if (breakDeepness > 0) {
1162                                --breakDeepness;
1163
1164                                break;
1165                            }
1166                            if (continueFlag)
1167                                continueFlag = false;
1168                        }
1169
1170                        iterator =  iteratorPrev;
1171                        dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
1172
1173                        return u;
1174                    }
1175                }
1176
1177                dodoMap<dodo::string, dodoArray<dodoStringMap> >::iterator d = globalArrayHash.find(temp[0]);
1178                if (d != globalArrayHash.end()) {
1179                    unsigned long pos = tools::string::stringToUL(temp[1]);
1180                    if (pos <= d->second.size()) {
1181                        dodoStringMap &lns = local[namespaceDeepness];
1182
1183                        unsigned long iteratorPrev = iterator;
1184                        iterator = 1;
1185
1186                        dodoStringMap::iterator k = d->second[pos].begin();
1187                        dodoStringMap::iterator l = d->second[pos].end();
1188                        for (; k != l; ++k, ++iterator) {
1189                            dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
1190
1191                            if (key)
1192                                lns[keyName] = k->first;
1193                            lns[varName] = k->second;
1194
1195                            _processString(forSpace, path, tpl);
1196
1197                            if (breakDeepness > 0) {
1198                                --breakDeepness;
1199
1200                                break;
1201                            }
1202                            if (continueFlag)
1203                                continueFlag = false;
1204                        }
1205
1206                        iterator =  iteratorPrev;
1207                        dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
1208
1209                        return u;
1210                    }
1211                }
1212            } else {
1213                if (temp.size() == 3) {
1214                    dodoMap<dodo::string, dodoArray<dodoStringMap> >::iterator d = globalArrayHash.find(temp[0]);
1215                    if (d != globalArrayHash.end()) {
1216                        unsigned long pos = tools::string::stringToUL(temp[1]);
1217                        if (pos <= d->second.size()) {
1218                            dodoStringMap::iterator k = d->second[pos].find(temp[2]);
1219                            if (k != d->second[pos].end()) {
1220                                dodoStringMap &lns = local[namespaceDeepness];
1221
1222                                unsigned long iteratorPrev = iterator;
1223                                iterator = 1;
1224
1225                                unsigned long i(0), j(k->second.size());
1226                                for (; i < j; ++i, ++iterator) {
1227                                    dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
1228
1229                                    if (key)
1230                                        lns[keyName] = tools::string::lToString(i);
1231                                    lns[varName] = k->second[i];
1232
1233                                    _processString(forSpace, path, tpl);
1234
1235                                    if (breakDeepness > 0) {
1236                                        --breakDeepness;
1237
1238                                        break;
1239                                    }
1240                                    if (continueFlag)
1241                                        continueFlag = false;
1242                                }
1243
1244                                iterator =  iteratorPrev;
1245                                dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
1246
1247                                return u;
1248                            }
1249                        }
1250                    }
1251                }
1252            }
1253        }
1254    } else {
1255        dodoStringMap &lns = local[namespaceDeepness];
1256
1257        unsigned long iteratorPrev = iterator;
1258        iterator = 1;
1259
1260        unsigned long i(0), j(targetVar.size());
1261        for (; i < j; ++i, ++iterator) {
1262            dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iterator);
1263
1264            if (key)
1265                lns[keyName] = tools::string::lToString(i);
1266            lns[varName] = targetVar[i];
1267
1268            _processString(forSpace, path, tpl);
1269
1270            if (breakDeepness > 0) {
1271                --breakDeepness;
1272
1273                break;
1274            }
1275            if (continueFlag)
1276                continueFlag = false;
1277        }
1278
1279        iterator =  iteratorPrev;
1280        dodo[statements[STATEMENT_ITERATOR]] = tools::string::lToString(iteratorPrev);
1281
1282        return u;
1283    }
1284
1285    return u;
1286}
1287
1288//-------------------------------------------------------------------
1289
1290dodo::string
1291processor::getVarName(const dodo::string &a_varName,
1292                      unsigned long    start,
1293                      const dodo::string &path)
1294{
1295    dodo::string varName = a_varName, tempVar;
1296
1297    unsigned long u, b, m(0), ob, cb, i, c;
1298
1299    while (true) {
1300        ob = 1;
1301        cb = 0;
1302
1303        u = varName.find(statements[STATEMENT_OPEN_VARPART], m);
1304        if (u == dodo::string::POSITION_END)
1305            break;
1306
1307        c = u;
1308        while (true) {
1309            b = varName.find(statements[STATEMENT_CLOSE_VARPART], c + 1);
1310            if (b == dodo::string::POSITION_END)
1311                dodo_throw exception::basic(exception::MODULE_DATATPLPROCESSOR, PROCESSOREX_GETVARNAME, exception::ERRNO_LIBDODO, PROCESSOREX_WRONGVARSTATEMENT, DATATPLPROCESSOREX_WRONGVARSTATEMENT_STR, __LINE__, __FILE__, tools::string::format(" Line: %li File: %s", getLineNumber(newLinePositions.back(), start), path.data()));
1312
1313            ++cb;
1314
1315            for (i = c + 1; i < b; ++i)
1316                if (varName[i] == '{')
1317                    ++ob;
1318
1319            c = b;
1320
1321            if (cb == ob)
1322                break;
1323        }
1324
1325        tempVar = trim(tools::string::trim(dodo::string(varName.data() + u + 1, b - 1 - u), " \t\r\n", 4));
1326        if (tempVar[0] == '$')
1327            tempVar = getVar(tempVar, start, path);
1328
1329        varName.replace(u, b + 1 - u, tempVar);
1330
1331        m = b - 1;
1332    }
1333
1334    return varName;
1335}
1336
1337//-------------------------------------------------------------------
1338
1339dodo::string
1340processor::getVar(const dodo::string &a_varName,
1341                  unsigned long    start,
1342                  const dodo::string &path)
1343{
1344    dodo::string varName = tools::string::trim(a_varName, " \t\r\n", 4);
1345
1346    if (varName[0] != '$')
1347        return trim(varName);
1348
1349    varName.erase(0, 1);
1350    varName = getVarName(varName, start, path);
1351
1352    dodoStringArray temp = tools::misc::split(varName, statements[STATEMENT_DOT]);
1353
1354    if (temp.size() == 1) {
1355        if (tools::string::equal(varName, statements[STATEMENT_DODO]))
1356            return "cgi framework libdodo";
1357
1358        dodoStringMap::iterator k;
1359
1360        dodoMap<unsigned int, dodoStringMap>::reverse_iterator lpnsi = local.rbegin();
1361        dodoMap<unsigned int, dodoStringMap>::reverse_iterator lpnsj = local.rend();
1362        for (; lpnsi != lpnsj; ++lpnsi) {
1363            k = lpnsi->second.find(varName);
1364            if (k != lpnsi->second.end())
1365                return k->second;
1366        }
1367
1368        k = global.find(varName);
1369        if (k != global.end())
1370            return k->second;
1371
1372        return __dodostring__;
1373    } else {
1374        if (tools::string::equal(temp[0], statements[STATEMENT_DODO])) {
1375            dodoStringMap::iterator k = dodo.find(temp[1]);
1376            if (k != dodo.end()) {
1377                if (temp.size() == 3) {
1378                    unsigned long pos = tools::string::stringToUL(temp[2]);
1379                    if (pos <= k->second.size())
1380                        return dodo::string(k->second[pos]);
1381                    else
1382                        return __dodostring__;
1383                } else
1384                    return k->second;
1385            }
1386
1387            return __dodostring__;
1388        }
1389
1390        dodoMap<unsigned int, dodoStringMap>::reverse_iterator lpnsi = local.rbegin();
1391        dodoMap<unsigned int, dodoStringMap>::reverse_iterator lpnsj = local.rend();
1392        for (; lpnsi != lpnsj; ++lpnsi) {
1393            dodoStringMap::iterator k = lpnsi->second.find(temp[0]);
1394            if (k != lpnsi->second.end()) {
1395                unsigned long pos = tools::string::stringToUL(temp[1]);
1396                if (pos <= k->second.size())
1397                    return dodo::string(k->second[pos]);
1398                else
1399                    return __dodostring__;
1400            }
1401        }
1402
1403        dodoMap<unsigned int, dodoMap<dodo::string, dodoStringMap> >::reverse_iterator lhpnsi = localHash.rbegin();
1404        dodoMap<unsigned int, dodoMap<dodo::string, dodoStringMap> >::reverse_iterator lhpnsj = localHash.rend();
1405        for (; lhpnsi != lhpnsj; ++lhpnsi) {
1406            dodoMap<dodo::string, dodoStringMap>::iterator g = lhpnsi->second.find(temp[0]);
1407            if (g != lhpnsi->second.end()) {
1408                dodoStringMap::iterator k = g->second.find(temp[1]);
1409                if (k != g->second.end()) {
1410                    if (temp.size() == 3) {
1411                        unsigned long pos = tools::string::stringToUL(temp[2]);
1412                        if (pos <= k->second.size())
1413                            return dodo::string(k->second[pos]);
1414                        else
1415                            return __dodostring__;
1416                    } else
1417                        return k->second;
1418                }
1419            }
1420        }
1421
1422        dodoStringMap::iterator k = global.find(temp[0]);
1423        if (k != global.end()) {
1424            unsigned long pos = tools::string::stringToUL(temp[1]);
1425            if (pos <= k->second.size())
1426                return dodo::string(k->second[pos]);
1427            else
1428                return __dodostring__;
1429        }
1430
1431        dodoMap<dodo::string, dodoStringMap>::iterator g = globalHash.find(temp[0]);
1432        if (g != globalHash.end()) {
1433            k = g->second.find(temp[1]);
1434            if (k != g->second.end()) {
1435                if (temp.size() == 3) {
1436                    unsigned long pos = tools::string::stringToUL(temp[2]);
1437                    if (pos <= k->second.size())
1438                        return dodo::string(k->second[pos]);
1439                    else
1440                        return __dodostring__;
1441                } else
1442                    return k->second;
1443            }
1444        }
1445
1446        dodoMap<dodo::string, dodoStringArray>::iterator o = globalArray.find(temp[0]);
1447        if (o != globalArray.end()) {
1448            unsigned long pos = tools::string::stringToUL(temp[1]);
1449            if (pos <= o->second.size()) {
1450                if (temp.size() == 3) {
1451                    unsigned long pos1 = tools::string::stringToUL(temp[2]);
1452                    if (pos1 <= o->second[pos].size())
1453                        return dodo::string(o->second[pos][pos1]);
1454                    else
1455                        return __dodostring__;
1456                } else
1457                    return o->second[pos];
1458            }
1459        }
1460
1461        if (temp.size() >= 3) {
1462            dodoMap<dodo::string, dodoArray<dodoStringMap> >::iterator d = globalArrayHash.find(temp[0]);
1463            if (d != globalArrayHash.end()) {
1464                unsigned long pos = tools::string::stringToUL(temp[1]);
1465                if (pos <= d->second.size()) {
1466                    k = d->second[pos].find(temp[2]);
1467                    if (k != d->second[pos].end()) {
1468                        if (temp.size() == 4) {
1469                            pos = tools::string::stringToUL(temp[3]);
1470                            if (pos <= k->second.size())
1471                                return dodo::string(k->second[pos]);
1472                            else
1473                                return __dodostring__;
1474                        } else
1475                            return k->second;
1476                    }
1477                }
1478            }
1479        }
1480    }
1481
1482    return __dodostring__;
1483}
1484
1485//-------------------------------------------------------------------
1486
1487dodo::string
1488processor::trim(const dodo::string &statement)
1489{
1490    unsigned long i(statement.size() - 1);
1491
1492    if (statement[0] == '\"' && statement[i] == '\"')
1493        return dodo::string(statement.data() + 1, statement.size() - 2);
1494    else if (statement[0] == '\'' && statement[i] == '\'')
1495        return dodo::string(statement.data() + 1, statement.size() - 2);
1496
1497    return statement;
1498}
1499
1500//-------------------------------------------------------------------
1501
Note: See TracBrowser for help on using the repository browser.