source: trunk/src/script/qscriptxmlgenerator.cpp@ 11

Last change on this file since 11 was 2, checked in by Dmitry A. Kuminov, 16 years ago

Initially imported qt-all-opensource-src-4.5.1 from Trolltech.
File size: 25.9 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
4** Contact: Qt Software Information (qt-info@nokia.com)
5**
6** This file is part of the QtScript module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial Usage
10** Licensees holding valid Qt Commercial licenses may use this file in
11** accordance with the Qt Commercial License Agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Nokia.
14**
15** GNU Lesser General Public License Usage
16** Alternatively, this file may be used under the terms of the GNU Lesser
17** General Public License version 2.1 as published by the Free Software
18** Foundation and appearing in the file LICENSE.LGPL included in the
19** packaging of this file. Please review the following information to
20** ensure the GNU Lesser General Public License version 2.1 requirements
21** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
22**
23** In addition, as a special exception, Nokia gives you certain
24** additional rights. These rights are described in the Nokia Qt LGPL
25** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
26** package.
27**
28** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you are unsure which license is appropriate for your use, please
37** contact the sales department at qt-sales@nokia.com.
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "qscriptxmlgenerator_p.h"
43
44#ifndef QT_NO_SCRIPT
45
46#include "qscriptast_p.h"
47#include "qscriptengine_p.h"
48#include "qscriptvalueimpl_p.h"
49#include "qscriptcontext_p.h"
50#include "qscriptmember_p.h"
51#include "qscriptobject_p.h"
52#include "qscriptlexer_p.h"
53#include "qscriptparser_p.h"
54
55#include <QtCore/qstring.h>
56#include <QtCore/qtextstream.h>
57
58QT_BEGIN_NAMESPACE
59
60namespace QScript {
61
62extern QString numberToString(qsreal value);
63
64// copy of Qt::escape() (it's in QtGui :-( )
65
66static QString escape(const QString& plain)
67{
68 QString rich;
69 rich.reserve(int(plain.length() * 1.1));
70 for (int i = 0; i < plain.length(); ++i) {
71 if (plain.at(i) == QLatin1Char('<'))
72 rich += QLatin1String("&lt;");
73 else if (plain.at(i) == QLatin1Char('>'))
74 rich += QLatin1String("&gt;");
75 else if (plain.at(i) == QLatin1Char('&'))
76 rich += QLatin1String("&amp;");
77 else
78 rich += plain.at(i);
79 }
80 return rich;
81}
82
83XmlGenerator::XmlGenerator(QTextStream &o):
84 out(o), m_indentLevel(-1), m_formatOutput(false)
85{
86}
87
88XmlGenerator::~XmlGenerator()
89{
90}
91
92QTextStream &XmlGenerator::operator()(const QString &program, int lineNumber)
93{
94 QScriptEnginePrivate priv;
95 NodePool *pool = new NodePool(/*fileName=*/QString(), &priv);
96 priv.setNodePool(pool);
97
98 Lexer lex(&priv);
99 priv.setLexer(&lex);
100 lex.setCode(program, lineNumber);
101
102 QScriptParser parser;
103 if (parser.parse(&priv)) {
104 accept(priv.abstractSyntaxTree());
105 }
106
107 delete pool;
108
109 return out;
110}
111
112QTextStream &XmlGenerator::newlineAndIndent()
113{
114 enum { IND = 2 };
115 if (m_formatOutput)
116 out << endl << QString().fill(QLatin1Char(' '), m_indentLevel * IND);
117 return out;
118}
119
120QTextStream &XmlGenerator::startTag(const QString &name, AST::Node *locationNode)
121{
122 pushIndentLevel();
123 newlineAndIndent();
124 out << QLatin1String("<") << name;
125 if (locationNode)
126 out << QLatin1String(" line=\"") << locationNode->startLine << QLatin1String("\"");
127 out << QLatin1String(">");
128 return out;
129}
130
131QTextStream &XmlGenerator::endTag(const QString &name)
132{
133 newlineAndIndent();
134 popIndentLevel();
135 out << QLatin1String("</") << escape(name) << QLatin1String(">");
136 return out;
137}
138
139void XmlGenerator::accept(AST::Node *node)
140{
141 AST::Node::acceptChild(node, this);
142}
143
144bool XmlGenerator::visit(AST::ThisExpression *)
145{
146 pushIndentLevel();
147 newlineAndIndent();
148 out << QLatin1String("<this/>");
149 popIndentLevel();
150 return true;
151}
152
153void XmlGenerator::endVisit(AST::ThisExpression *)
154{
155}
156
157bool XmlGenerator::visit(AST::IdentifierExpression *node)
158{
159 startTag(QLatin1String("identifier"));
160 out << escape(QScriptEnginePrivate::toString(node->name));
161 out << QLatin1String("</identifier>");
162 popIndentLevel();
163 return false;
164}
165
166void XmlGenerator::endVisit(AST::IdentifierExpression *)
167{
168}
169
170bool XmlGenerator::visit(AST::NullExpression *)
171{
172 pushIndentLevel();
173 newlineAndIndent();
174 out << QLatin1String("<null/>");
175 popIndentLevel();
176 return false;
177}
178
179void XmlGenerator::endVisit(AST::NullExpression *)
180{
181}
182
183bool XmlGenerator::visit(AST::TrueLiteral *)
184{
185 pushIndentLevel();
186 newlineAndIndent();
187 out << QLatin1String("<true/>");
188 popIndentLevel();
189 return false;
190}
191
192void XmlGenerator::endVisit(AST::TrueLiteral *)
193{
194}
195
196bool XmlGenerator::visit(AST::FalseLiteral *)
197{
198 pushIndentLevel();
199 newlineAndIndent();
200 out << QLatin1String("<false/>");
201 popIndentLevel();
202 return false;
203}
204
205void XmlGenerator::endVisit(AST::FalseLiteral *)
206{
207}
208
209bool XmlGenerator::visit(AST::StringLiteral *node)
210{
211 startTag(QLatin1String("string"));
212 out << escape(QScriptEnginePrivate::toString(node->value)) << QLatin1String("</string>");
213 popIndentLevel();
214 return false;
215}
216
217void XmlGenerator::endVisit(AST::StringLiteral *)
218{
219}
220
221bool XmlGenerator::visit(AST::NumericLiteral *node)
222{
223 startTag(QLatin1String("number"));
224 out << QString::number(node->value) << QLatin1String("</number>");
225 popIndentLevel();
226 return false;
227}
228
229void XmlGenerator::endVisit(AST::NumericLiteral *)
230{
231}
232
233bool XmlGenerator::visit(AST::RegExpLiteral *node)
234{
235 startTag(QLatin1String("regexp"));
236 out << QLatin1String("/") << escape(QScriptEnginePrivate::toString(node->pattern)) << QLatin1String("/");
237 if (node->flags)
238 out << QScript::Ecma::RegExp::flagsToString(node->flags);
239 out << QLatin1String("</regexp>");
240 popIndentLevel();
241 return false;
242}
243
244void XmlGenerator::endVisit(AST::RegExpLiteral *)
245{
246}
247
248bool XmlGenerator::visit(AST::ArrayLiteral *)
249{
250 startTag(QLatin1String("array-literal"));
251 return true;
252}
253
254void XmlGenerator::endVisit(AST::ArrayLiteral *)
255{
256 endTag(QLatin1String("array-literal"));
257}
258
259bool XmlGenerator::visit(AST::ObjectLiteral *)
260{
261 startTag(QLatin1String("object-literal"));
262 return true;
263}
264
265void XmlGenerator::endVisit(AST::ObjectLiteral *)
266{
267 endTag(QLatin1String("object-literal"));
268}
269
270bool XmlGenerator::visit(AST::ElementList *)
271{
272 startTag(QLatin1String("element-list"));
273 return true;
274}
275
276void XmlGenerator::endVisit(AST::ElementList *)
277{
278 endTag(QLatin1String("element-list"));
279}
280
281bool XmlGenerator::visit(AST::Elision *)
282{
283 startTag(QLatin1String("elision")); // ### count
284 return true;
285}
286
287void XmlGenerator::endVisit(AST::Elision *)
288{
289 endTag(QLatin1String("elision"));
290}
291
292bool XmlGenerator::visit(AST::PropertyNameAndValueList *)
293{
294 startTag(QLatin1String("property-name-and-value-list"));
295 return true;
296}
297
298void XmlGenerator::endVisit(AST::PropertyNameAndValueList *)
299{
300 endTag(QLatin1String("property-name-and-value-list"));
301}
302
303bool XmlGenerator::visit(AST::IdentifierPropertyName *node)
304{
305 startTag(QLatin1String("identifier"));
306 out << escape(QScriptEnginePrivate::toString(node->id)) << QLatin1String("</identifier>");
307 popIndentLevel();
308 return false;
309}
310
311void XmlGenerator::endVisit(AST::IdentifierPropertyName *)
312{
313}
314
315bool XmlGenerator::visit(AST::StringLiteralPropertyName *node)
316{
317 startTag(QLatin1String("string"));
318 out << escape(QScriptEnginePrivate::toString(node->id)) << QLatin1String("</string>");
319 popIndentLevel();
320 return false;
321}
322
323void XmlGenerator::endVisit(AST::StringLiteralPropertyName *)
324{
325}
326
327bool XmlGenerator::visit(AST::NumericLiteralPropertyName *node)
328{
329 startTag(QLatin1String("number"));
330 out << escape(QScript::numberToString(node->id)) << QLatin1String("</number>");
331 popIndentLevel();
332 return false;
333}
334
335void XmlGenerator::endVisit(AST::NumericLiteralPropertyName *)
336{
337}
338
339bool XmlGenerator::visit(AST::ArrayMemberExpression *)
340{
341 startTag(QLatin1String("array-member-expression"));
342 return true;
343}
344
345void XmlGenerator::endVisit(AST::ArrayMemberExpression *)
346{
347 endTag(QLatin1String("array-member-expression"));
348}
349
350bool XmlGenerator::visit(AST::FieldMemberExpression *)
351{
352 startTag(QLatin1String("field-member-expression"));
353 return true;
354}
355
356void XmlGenerator::endVisit(AST::FieldMemberExpression *node)
357{
358 startTag(QLatin1String("identifier"));
359 out << escape(QScriptEnginePrivate::toString(node->name));
360 out << QLatin1String("</identifier>");
361 popIndentLevel();
362 endTag(QLatin1String("field-member-expression"));
363}
364
365bool XmlGenerator::visit(AST::NewMemberExpression *)
366{
367 startTag(QLatin1String("new-member-expression"));
368 return true;
369}
370
371void XmlGenerator::endVisit(AST::NewMemberExpression *)
372{
373 endTag(QLatin1String("new-member-expression"));
374}
375
376bool XmlGenerator::visit(AST::NewExpression *)
377{
378 startTag(QLatin1String("new"));
379 return true;
380}
381
382void XmlGenerator::endVisit(AST::NewExpression *)
383{
384 endTag(QLatin1String("new"));
385}
386
387bool XmlGenerator::visit(AST::CallExpression *)
388{
389 startTag(QLatin1String("call"));
390 return true;
391}
392
393void XmlGenerator::endVisit(AST::CallExpression *)
394{
395 endTag(QLatin1String("call"));
396}
397
398bool XmlGenerator::visit(AST::ArgumentList *)
399{
400 startTag(QLatin1String("argument-list"));
401 return true;
402}
403
404void XmlGenerator::endVisit(AST::ArgumentList *)
405{
406 endTag(QLatin1String("argument-list"));
407}
408
409bool XmlGenerator::visit(AST::PostIncrementExpression *)
410{
411 startTag(QLatin1String("post-increment"));
412 return true;
413}
414
415void XmlGenerator::endVisit(AST::PostIncrementExpression *)
416{
417 endTag(QLatin1String("post-increment"));
418}
419
420bool XmlGenerator::visit(AST::PostDecrementExpression *)
421{
422 startTag(QLatin1String("post-decrement"));
423 return true;
424}
425
426void XmlGenerator::endVisit(AST::PostDecrementExpression *)
427{
428 endTag(QLatin1String("post-decrement"));
429}
430
431bool XmlGenerator::visit(AST::DeleteExpression *)
432{
433 startTag(QLatin1String("delete"));
434 return true;
435}
436
437void XmlGenerator::endVisit(AST::DeleteExpression *)
438{
439 endTag(QLatin1String("delete"));
440}
441
442bool XmlGenerator::visit(AST::VoidExpression *)
443{
444 startTag(QLatin1String("void"));
445 return true;
446}
447
448void XmlGenerator::endVisit(AST::VoidExpression *)
449{
450 endTag(QLatin1String("void"));
451}
452
453bool XmlGenerator::visit(AST::TypeOfExpression *)
454{
455 startTag(QLatin1String("typeof"));
456 return true;
457}
458
459void XmlGenerator::endVisit(AST::TypeOfExpression *)
460{
461 endTag(QLatin1String("typeof"));
462}
463
464bool XmlGenerator::visit(AST::PreIncrementExpression *)
465{
466 startTag(QLatin1String("pre-increment"));
467 return true;
468}
469
470void XmlGenerator::endVisit(AST::PreIncrementExpression *)
471{
472 endTag(QLatin1String("pre-increment"));
473}
474
475bool XmlGenerator::visit(AST::PreDecrementExpression *)
476{
477 startTag(QLatin1String("pre-decrement"));
478 return true;
479}
480
481void XmlGenerator::endVisit(AST::PreDecrementExpression *)
482{
483 endTag(QLatin1String("pre-decrement"));
484}
485
486bool XmlGenerator::visit(AST::UnaryPlusExpression *)
487{
488 startTag(QLatin1String("unary-plus"));
489 return true;
490}
491
492void XmlGenerator::endVisit(AST::UnaryPlusExpression *)
493{
494 endTag(QLatin1String("unary-plus"));
495}
496
497bool XmlGenerator::visit(AST::UnaryMinusExpression *)
498{
499 startTag(QLatin1String("unary-minus"));
500 return true;
501}
502
503void XmlGenerator::endVisit(AST::UnaryMinusExpression *)
504{
505 endTag(QLatin1String("unary-minus"));
506}
507
508bool XmlGenerator::visit(AST::TildeExpression *)
509{
510 startTag(QLatin1String("bitwise-not"));
511 return true;
512}
513
514void XmlGenerator::endVisit(AST::TildeExpression *)
515{
516 endTag(QLatin1String("bitwise-not"));
517}
518
519bool XmlGenerator::visit(AST::NotExpression *)
520{
521 startTag(QLatin1String("logical-not"));
522 return true;
523}
524
525void XmlGenerator::endVisit(AST::NotExpression *)
526{
527 endTag(QLatin1String("logical-not"));
528}
529
530bool XmlGenerator::visit(AST::BinaryExpression *node)
531{
532 QString s;
533 switch (node->op) {
534 case QSOperator::Add:
535 s = QLatin1String("+"); break;
536 case QSOperator::And:
537 s = QLatin1String("&amp;&amp;"); break;
538 case QSOperator::InplaceAnd:
539 s = QLatin1String("&amp;="); break;
540 case QSOperator::Assign:
541 s = QLatin1String("="); break;
542 case QSOperator::BitAnd:
543 s = QLatin1String("&amp;"); break;
544 case QSOperator::BitOr:
545 s = QLatin1String("|"); break;
546 case QSOperator::BitXor:
547 s = QLatin1String("^"); break;
548 case QSOperator::InplaceSub:
549 s = QLatin1String("-="); break;
550 case QSOperator::Div:
551 s = QLatin1String("/"); break;
552 case QSOperator::InplaceDiv:
553 s = QLatin1String("/="); break;
554 case QSOperator::Equal:
555 s = QLatin1String("=="); break;
556 case QSOperator::Ge:
557 s = QLatin1String(">="); break;
558 case QSOperator::Gt:
559 s = QLatin1String("&gt;"); break;
560 case QSOperator::In:
561 s = QLatin1String("in"); break;
562 case QSOperator::InplaceAdd:
563 s = QLatin1String("+="); break;
564 case QSOperator::InstanceOf:
565 s = QLatin1String("instanceof"); break;
566 case QSOperator::Le:
567 s = QLatin1String("&lt;="); break;
568 case QSOperator::LShift:
569 s = QLatin1String("&lt;&lt;"); break;
570 case QSOperator::InplaceLeftShift:
571 s = QLatin1String("&lt;&lt;="); break;
572 case QSOperator::Lt:
573 s = QLatin1String("&lt;"); break;
574 case QSOperator::Mod:
575 s = QLatin1String("%"); break;
576 case QSOperator::InplaceMod:
577 s = QLatin1String("%="); break;
578 case QSOperator::Mul:
579 s = QLatin1String("*"); break;
580 case QSOperator::InplaceMul:
581 s = QLatin1String("*="); break;
582 case QSOperator::NotEqual:
583 s = QLatin1String("!="); break;
584 case QSOperator::Or:
585 s = QLatin1String("||"); break;
586 case QSOperator::InplaceOr:
587 s = QLatin1String("|="); break;
588 case QSOperator::RShift:
589 s = QLatin1String("&gt;&gt;"); break;
590 case QSOperator::InplaceRightShift:
591 s = QLatin1String("&gt;&gt;="); break;
592 case QSOperator::StrictEqual:
593 s = QLatin1String("==="); break;
594 case QSOperator::StrictNotEqual:
595 s = QLatin1String("!=="); break;
596 case QSOperator::Sub:
597 s = QLatin1String("-"); break;
598 case QSOperator::URShift:
599 s = QLatin1String("&gt;&gt;&gt;"); break;
600 case QSOperator::InplaceURightShift:
601 s = QLatin1String("&gt;&gt;&gt;="); break;
602 case QSOperator::InplaceXor:
603 s = QLatin1String("^="); break;
604 default:
605 Q_ASSERT (0);
606 }
607 pushIndentLevel();
608 newlineAndIndent();
609 out << QLatin1String("<binary-expression op=\"") << s << QLatin1String("\">");
610 return true;
611}
612
613void XmlGenerator::endVisit(AST::BinaryExpression *)
614{
615 endTag(QLatin1String("binary-expression"));
616}
617
618bool XmlGenerator::visit(AST::ConditionalExpression *)
619{
620 startTag(QLatin1String("conditional"));
621 return true;
622}
623
624void XmlGenerator::endVisit(AST::ConditionalExpression *)
625{
626 endTag(QLatin1String("conditional"));
627}
628
629bool XmlGenerator::visit(AST::Expression *)
630{
631 startTag(QLatin1String("comma-expression"));
632 return true;
633}
634
635void XmlGenerator::endVisit(AST::Expression *)
636{
637 endTag(QLatin1String("comma-expression"));
638}
639
640bool XmlGenerator::visit(AST::Block *)
641{
642 startTag(QLatin1String("block"));
643 return true;
644}
645
646void XmlGenerator::endVisit(AST::Block *)
647{
648 endTag(QLatin1String("block"));
649}
650
651bool XmlGenerator::visit(AST::StatementList *)
652{
653 startTag(QLatin1String("statement-list"));
654 return true;
655}
656
657void XmlGenerator::endVisit(AST::StatementList *)
658{
659 endTag(QLatin1String("statement-list"));
660}
661
662bool XmlGenerator::visit(AST::VariableDeclarationList *)
663{
664 startTag(QLatin1String("variable-declaration-list"));
665 return true;
666}
667
668void XmlGenerator::endVisit(AST::VariableDeclarationList *)
669{
670 endTag(QLatin1String("variable-declaration-list"));
671}
672
673bool XmlGenerator::visit(AST::VariableStatement *node)
674{
675 startTag(QLatin1String("variable-statement"), node);
676 return true;
677}
678
679void XmlGenerator::endVisit(AST::VariableStatement *)
680{
681 endTag(QLatin1String("variable-statement"));
682}
683
684bool XmlGenerator::visit(AST::VariableDeclaration *node)
685{
686 startTag(QLatin1String("variable-declaration"), node);
687 startTag(QLatin1String("name"));
688 out << escape(QScriptEnginePrivate::toString(node->name));
689 out << QLatin1String("</name>");
690 popIndentLevel();
691 return true;
692}
693
694void XmlGenerator::endVisit(AST::VariableDeclaration *)
695{
696 endTag(QLatin1String("variable-declaration"));
697}
698
699bool XmlGenerator::visit(AST::EmptyStatement *node)
700{
701 startTag(QLatin1String("empty-statement"), node);
702 return true;
703}
704
705void XmlGenerator::endVisit(AST::EmptyStatement *)
706{
707 endTag(QLatin1String("empty-statement"));
708}
709
710bool XmlGenerator::visit(AST::ExpressionStatement *node)
711{
712 startTag(QLatin1String("expression-statement"), node);
713 return true;
714}
715
716void XmlGenerator::endVisit(AST::ExpressionStatement *)
717{
718 endTag(QLatin1String("expression-statement"));
719}
720
721bool XmlGenerator::visit(AST::IfStatement *node)
722{
723 startTag(QLatin1String("if"), node);
724 return true;
725}
726
727void XmlGenerator::endVisit(AST::IfStatement *)
728{
729 endTag(QLatin1String("if"));
730}
731
732bool XmlGenerator::visit(AST::DoWhileStatement *node)
733{
734 startTag(QLatin1String("do-while"), node);
735 return true;
736}
737
738void XmlGenerator::endVisit(AST::DoWhileStatement *)
739{
740 endTag(QLatin1String("do-while"));
741}
742
743bool XmlGenerator::visit(AST::WhileStatement *node)
744{
745 startTag(QLatin1String("while"), node);
746 return true;
747}
748
749void XmlGenerator::endVisit(AST::WhileStatement *)
750{
751 endTag(QLatin1String("while"));
752}
753
754bool XmlGenerator::visit(AST::ForStatement *node)
755{
756 startTag(QLatin1String("for"), node);
757 return true;
758}
759
760void XmlGenerator::endVisit(AST::ForStatement *)
761{
762 endTag(QLatin1String("for"));
763}
764
765bool XmlGenerator::visit(AST::LocalForStatement *node)
766{
767 startTag(QLatin1String("for"), node);
768 return true;
769}
770
771void XmlGenerator::endVisit(AST::LocalForStatement *)
772{
773 endTag(QLatin1String("for"));
774}
775
776bool XmlGenerator::visit(AST::ForEachStatement *node)
777{
778 startTag(QLatin1String("for-in"), node);
779 return false;
780}
781
782void XmlGenerator::endVisit(AST::ForEachStatement *)
783{
784 endTag(QLatin1String("for-in"));
785}
786
787bool XmlGenerator::visit(AST::LocalForEachStatement *node)
788{
789 startTag(QLatin1String("for-in"), node);
790 return true;
791}
792
793void XmlGenerator::endVisit(AST::LocalForEachStatement *)
794{
795 endTag(QLatin1String("for-in"));
796}
797
798bool XmlGenerator::visit(AST::ContinueStatement *node)
799{
800 startTag(QLatin1String("continue"), node);
801 if (node->label) {
802 startTag(QLatin1String("label"));
803 out << escape(QScriptEnginePrivate::toString(node->label));
804 out << QLatin1String("</label>");
805 popIndentLevel();
806 }
807 return true;
808}
809
810void XmlGenerator::endVisit(AST::ContinueStatement *)
811{
812 endTag(QLatin1String("continue"));
813}
814
815bool XmlGenerator::visit(AST::BreakStatement *node)
816{
817 startTag(QLatin1String("break"), node);
818 if (node->label) {
819 startTag(QLatin1String("label"));
820 out << escape(QScriptEnginePrivate::toString(node->label));
821 out << QLatin1String("</label>");
822 popIndentLevel();
823 }
824 return true;
825}
826
827void XmlGenerator::endVisit(AST::BreakStatement *)
828{
829 endTag(QLatin1String("break"));
830}
831
832bool XmlGenerator::visit(AST::ReturnStatement *node)
833{
834 startTag(QLatin1String("return"), node);
835 return true;
836}
837
838void XmlGenerator::endVisit(AST::ReturnStatement *)
839{
840 endTag(QLatin1String("return"));
841}
842
843bool XmlGenerator::visit(AST::WithStatement *node)
844{
845 startTag(QLatin1String("with"), node);
846 return true;
847}
848
849void XmlGenerator::endVisit(AST::WithStatement *)
850{
851 endTag(QLatin1String("with"));
852}
853
854bool XmlGenerator::visit(AST::SwitchStatement *node)
855{
856 startTag(QLatin1String("switch"), node);
857 return true;
858}
859
860void XmlGenerator::endVisit(AST::SwitchStatement *)
861{
862 endTag(QLatin1String("switch"));
863}
864
865bool XmlGenerator::visit(AST::CaseBlock *)
866{
867 startTag(QLatin1String("case-block"));
868 return true;
869}
870
871void XmlGenerator::endVisit(AST::CaseBlock *)
872{
873 endTag(QLatin1String("case-block"));
874}
875
876bool XmlGenerator::visit(AST::CaseClauses *)
877{
878 startTag(QLatin1String("case-clauses"));
879 return true;
880}
881
882void XmlGenerator::endVisit(AST::CaseClauses *)
883{
884 endTag(QLatin1String("case-clauses"));
885}
886
887bool XmlGenerator::visit(AST::CaseClause *)
888{
889 startTag(QLatin1String("case-clause"));
890 return true;
891}
892
893void XmlGenerator::endVisit(AST::CaseClause *)
894{
895 endTag(QLatin1String("case-clause"));
896}
897
898bool XmlGenerator::visit(AST::DefaultClause *)
899{
900 startTag(QLatin1String("default-clause"));
901 return true;
902}
903
904void XmlGenerator::endVisit(AST::DefaultClause *)
905{
906 endTag(QLatin1String("default-clause"));
907}
908
909bool XmlGenerator::visit(AST::LabelledStatement *node)
910{
911 startTag(QLatin1String("labelled-statement"), node);
912 startTag(QLatin1String("label"));
913 out << escape(QScriptEnginePrivate::toString(node->label));
914 out << QLatin1String("</label>");
915 popIndentLevel();
916 return true;
917}
918
919void XmlGenerator::endVisit(AST::LabelledStatement *)
920{
921 endTag(QLatin1String("labelled-statement"));
922}
923
924bool XmlGenerator::visit(AST::ThrowStatement *node)
925{
926 startTag(QLatin1String("throw"), node);
927 return true;
928}
929
930void XmlGenerator::endVisit(AST::ThrowStatement *)
931{
932 endTag(QLatin1String("throw"));
933}
934
935bool XmlGenerator::visit(AST::TryStatement *node)
936{
937 startTag(QLatin1String("try"), node);
938 return true;
939}
940
941void XmlGenerator::endVisit(AST::TryStatement *)
942{
943 endTag(QLatin1String("try"));
944}
945
946bool XmlGenerator::visit(AST::Catch *node)
947{
948 startTag(QLatin1String("catch"));
949 startTag(QLatin1String("identifier"));
950 out << escape(QScriptEnginePrivate::toString(node->name));
951 out << QLatin1String("</identifier>");
952 popIndentLevel();
953 return true;
954}
955
956void XmlGenerator::endVisit(AST::Catch *)
957{
958 endTag(QLatin1String("catch"));
959}
960
961bool XmlGenerator::visit(AST::Finally *)
962{
963 startTag(QLatin1String("finally"));
964 return true;
965}
966
967void XmlGenerator::endVisit(AST::Finally *)
968{
969 endTag(QLatin1String("finally"));
970}
971
972bool XmlGenerator::visit(AST::FunctionDeclaration *node)
973{
974 startTag(QLatin1String("function-declaration"), node);
975 startTag(QLatin1String("name"));
976 if (node->name)
977 out << escape(QScriptEnginePrivate::toString(node->name));
978 out << QLatin1String("</name>");
979 popIndentLevel();
980 if (!node->formals) {
981 startTag(QLatin1String("formal-parameter-list"));
982 endTag(QLatin1String("formal-parameter-list"));
983 }
984 if (!node->body) {
985 startTag(QLatin1String("function-body"));
986 endTag(QLatin1String("function-body"));
987 }
988 return true;
989}
990
991void XmlGenerator::endVisit(AST::FunctionDeclaration *)
992{
993 endTag(QLatin1String("function-declaration"));
994}
995
996bool XmlGenerator::visit(AST::FunctionExpression *node)
997{
998 startTag(QLatin1String("function-expression"), node);
999 startTag(QLatin1String("name"));
1000 if (node->name)
1001 out << escape(QScriptEnginePrivate::toString(node->name));
1002 out << QLatin1String("</name>");
1003 if (!node->formals) {
1004 startTag(QLatin1String("formal-parameter-list"));
1005 endTag(QLatin1String("formal-parameter-list"));
1006 }
1007 if (!node->body) {
1008 startTag(QLatin1String("function-body"));
1009 endTag(QLatin1String("function-body"));
1010 }
1011 return true;
1012}
1013
1014void XmlGenerator::endVisit(AST::FunctionExpression *)
1015{
1016 endTag(QLatin1String("function-expression"));
1017}
1018
1019bool XmlGenerator::visit(AST::FormalParameterList *node)
1020{
1021 Q_UNUSED(node);
1022 startTag(QLatin1String("formal-parameter-list"));
1023 for (AST::FormalParameterList *it = node; it; it = it->next) {
1024 startTag(QLatin1String("identifier"));
1025 out << escape(QScriptEnginePrivate::toString(it->name));
1026 out << QLatin1String("</identifier>");
1027 popIndentLevel();
1028 }
1029 return true;
1030}
1031
1032void XmlGenerator::endVisit(AST::FormalParameterList *)
1033{
1034 endTag(QLatin1String("formal-parameter-list"));
1035}
1036
1037bool XmlGenerator::visit(AST::FunctionBody *)
1038{
1039 startTag(QLatin1String("function-body"));
1040 return true;
1041}
1042
1043void XmlGenerator::endVisit(AST::FunctionBody *)
1044{
1045 endTag(QLatin1String("function-body"));
1046}
1047
1048bool XmlGenerator::visit(AST::Program *)
1049{
1050 startTag(QLatin1String("program"));
1051 return true;
1052}
1053
1054void XmlGenerator::endVisit(AST::Program *)
1055{
1056 endTag(QLatin1String("program"));
1057}
1058
1059bool XmlGenerator::visit(AST::SourceElements *)
1060{
1061 startTag(QLatin1String("source-elements"));
1062 return true;
1063}
1064
1065void XmlGenerator::endVisit(AST::SourceElements *)
1066{
1067 endTag(QLatin1String("source-elements"));
1068}
1069
1070bool XmlGenerator::visit(AST::FunctionSourceElement *)
1071{
1072 return true;
1073}
1074
1075void XmlGenerator::endVisit(AST::FunctionSourceElement *)
1076{
1077}
1078
1079bool XmlGenerator::visit(AST::StatementSourceElement *)
1080{
1081 return true;
1082}
1083
1084void XmlGenerator::endVisit(AST::StatementSourceElement *)
1085{
1086}
1087
1088bool XmlGenerator::visit(AST::DebuggerStatement *node)
1089{
1090 startTag(QLatin1String("debugger-statement"), node);
1091 return true;
1092}
1093
1094void XmlGenerator::endVisit(AST::DebuggerStatement *)
1095{
1096 endTag(QLatin1String("debugger-statement"));
1097}
1098
1099bool XmlGenerator::preVisit(AST::Node *)
1100{
1101 return true;
1102}
1103
1104} // namespace QScript
1105
1106Q_SCRIPT_EXPORT QString qt_scriptToXml(const QString &program, int lineNumber = 1)
1107{
1108 QString result;
1109 QTextStream out(&result, QIODevice::WriteOnly);
1110 QScript::XmlGenerator gen(out);
1111 gen(program, lineNumber);
1112 out.flush();
1113 return result;
1114}
1115
1116QT_END_NAMESPACE
1117
1118#endif // QT_NO_SCRIPT
Note: See TracBrowser for help on using the repository browser.