1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtScript module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qscriptast_p.h"

    43 

    44 #include "qscriptastvisitor_p.h"

    45 

    46 QT_BEGIN_NAMESPACE

    47 

    48 namespace QScript { namespace AST {

    49 

    50 ExpressionNode *Node::expressionCast()

    51 {

    52     return 0;

    53 }

    54 

    55 BinaryExpression *Node::binaryExpressionCast()

    56 {

    57     return 0;

    58 }

    59 

    60 Statement *Node::statementCast()

    61 {

    62     return 0;

    63 }

    64 

    65 ExpressionNode *ExpressionNode::expressionCast()

    66 {

    67     return this;

    68 }

    69 

    70 BinaryExpression *BinaryExpression::binaryExpressionCast()

    71 {

    72     return this;

    73 }

    74 

    75 Statement *Statement::statementCast()

    76 {

    77     return this;

    78 }

    79 

    80 void ThisExpression::accept0(Visitor *visitor)

    81 {

    82     if (visitor->visit(this)) {

    83     }

    84 

    85     visitor->endVisit(this);

    86 }

    87 

    88 void IdentifierExpression::accept0(Visitor *visitor)

    89 {

    90     if (visitor->visit(this)) {

    91     }

    92 

    93     visitor->endVisit(this);

    94 }

    95 

    96 void NullExpression::accept0(Visitor *visitor)

    97 {

    98     if (visitor->visit(this)) {

    99     }

   100 

   101     visitor->endVisit(this);

   102 }

   103 

   104 void TrueLiteral::accept0(Visitor *visitor)

   105 {

   106     if (visitor->visit(this)) {

   107     }

   108 

   109     visitor->endVisit(this);

   110 }

   111 

   112 void FalseLiteral::accept0(Visitor *visitor)

   113 {

   114     if (visitor->visit(this)) {

   115     }

   116 

   117     visitor->endVisit(this);

   118 }

   119 

   120 void StringLiteral::accept0(Visitor *visitor)

   121 {

   122     if (visitor->visit(this)) {

   123     }

   124 

   125     visitor->endVisit(this);

   126 }

   127 

   128 void NumericLiteral::accept0(Visitor *visitor)

   129 {

   130     if (visitor->visit(this)) {

   131     }

   132 

   133     visitor->endVisit(this);

   134 }

   135 

   136 void RegExpLiteral::accept0(Visitor *visitor)

   137 {

   138     if (visitor->visit(this)) {

   139     }

   140 

   141     visitor->endVisit(this);

   142 }

   143 

   144 void ArrayLiteral::accept0(Visitor *visitor)

   145 {

   146     if (visitor->visit(this)) {

   147         acceptChild(elements, visitor);

   148         acceptChild(elision, visitor);

   149     }

   150 

   151     visitor->endVisit(this);

   152 }

   153 

   154 void ObjectLiteral::accept0(Visitor *visitor)

   155 {

   156     if (visitor->visit(this)) {

   157         acceptChild(properties, visitor);

   158     }

   159 

   160     visitor->endVisit(this);

   161 }

   162 

   163 void ElementList::accept0(Visitor *visitor)

   164 {

   165     if (visitor->visit(this)) {

   166         ElementList *it = this;

   167         do {

   168             acceptChild(it->elision, visitor);

   169             acceptChild(it->expression, visitor);

   170             it = it->next;

   171         } while (it);

   172     }

   173 

   174     visitor->endVisit(this);

   175 }

   176 

   177 void Elision::accept0(Visitor *visitor)

   178 {

   179     if (visitor->visit(this)) {

   180         // ###

   181     }

   182 

   183     visitor->endVisit(this);

   184 }

   185 

   186 void PropertyNameAndValueList::accept0(Visitor *visitor)

   187 {

   188     if (visitor->visit(this)) {

   189         PropertyNameAndValueList *it = this;

   190         do {

   191             acceptChild(it->name, visitor);

   192             acceptChild(it->value, visitor);

   193             it = it->next;

   194         } while (it);

   195     }

   196 

   197     visitor->endVisit(this);

   198 }

   199 

   200 void IdentifierPropertyName::accept0(Visitor *visitor)

   201 {

   202     if (visitor->visit(this)) {

   203     }

   204 

   205     visitor->endVisit(this);

   206 }

   207 

   208 void StringLiteralPropertyName::accept0(Visitor *visitor)

   209 {

   210     if (visitor->visit(this)) {

   211     }

   212 

   213     visitor->endVisit(this);

   214 }

   215 

   216 void NumericLiteralPropertyName::accept0(Visitor *visitor)

   217 {

   218     if (visitor->visit(this)) {

   219     }

   220 

   221     visitor->endVisit(this);

   222 }

   223 

   224 void ArrayMemberExpression::accept0(Visitor *visitor)

   225 {

   226     if (visitor->visit(this)) {

   227         acceptChild(base, visitor);

   228         acceptChild(expression, visitor);

   229     }

   230 

   231     visitor->endVisit(this);

   232 }

   233 

   234 void FieldMemberExpression::accept0(Visitor *visitor)

   235 {

   236     if (visitor->visit(this)) {

   237         acceptChild(base, visitor);

   238     }

   239 

   240     visitor->endVisit(this);

   241 }

   242 

   243 void NewMemberExpression::accept0(Visitor *visitor)

   244 {

   245     if (visitor->visit(this)) {

   246         acceptChild(base, visitor);

   247         acceptChild(arguments, visitor);

   248     }

   249 

   250     visitor->endVisit(this);

   251 }

   252 

   253 void NewExpression::accept0(Visitor *visitor)

   254 {

   255     if (visitor->visit(this)) {

   256         acceptChild(expression, visitor);

   257     }

   258 

   259     visitor->endVisit(this);

   260 }

   261 

   262 void CallExpression::accept0(Visitor *visitor)

   263 {

   264     if (visitor->visit(this)) {

   265         acceptChild(base, visitor);

   266         acceptChild(arguments, visitor);

   267     }

   268 

   269     visitor->endVisit(this);

   270 }

   271 

   272 void ArgumentList::accept0(Visitor *visitor)

   273 {

   274     if (visitor->visit(this)) {

   275         ArgumentList *it = this;

   276         do {

   277             acceptChild(it->expression, visitor);

   278             it = it->next;

   279         } while (it);

   280     }

   281 

   282     visitor->endVisit(this);

   283 }

   284 

   285 void PostIncrementExpression::accept0(Visitor *visitor)

   286 {

   287     if (visitor->visit(this)) {

   288         acceptChild(base, visitor);

   289     }

   290 

   291     visitor->endVisit(this);

   292 }

   293 

   294 void PostDecrementExpression::accept0(Visitor *visitor)

   295 {

   296     if (visitor->visit(this)) {

   297         acceptChild(base, visitor);

   298     }

   299 

   300     visitor->endVisit(this);

   301 }

   302 

   303 void DeleteExpression::accept0(Visitor *visitor)

   304 {

   305     if (visitor->visit(this)) {

   306         acceptChild(expression, visitor);

   307     }

   308 

   309     visitor->endVisit(this);

   310 }

   311 

   312 void VoidExpression::accept0(Visitor *visitor)

   313 {

   314     if (visitor->visit(this)) {

   315         acceptChild(expression, visitor);

   316     }

   317 

   318     visitor->endVisit(this);

   319 }

   320 

   321 void TypeOfExpression::accept0(Visitor *visitor)

   322 {

   323     if (visitor->visit(this)) {

   324         acceptChild(expression, visitor);

   325     }

   326 

   327     visitor->endVisit(this);

   328 }

   329 

   330 void PreIncrementExpression::accept0(Visitor *visitor)

   331 {

   332     if (visitor->visit(this)) {

   333         acceptChild(expression, visitor);

   334     }

   335 

   336     visitor->endVisit(this);

   337 }

   338 

   339 void PreDecrementExpression::accept0(Visitor *visitor)

   340 {

   341     if (visitor->visit(this)) {

   342         acceptChild(expression, visitor);

   343     }

   344 

   345     visitor->endVisit(this);

   346 }

   347 

   348 void UnaryPlusExpression::accept0(Visitor *visitor)

   349 {

   350     if (visitor->visit(this)) {

   351         acceptChild(expression, visitor);

   352     }

   353 

   354     visitor->endVisit(this);

   355 }

   356 

   357 void UnaryMinusExpression::accept0(Visitor *visitor)

   358 {

   359     if (visitor->visit(this)) {

   360         acceptChild(expression, visitor);

   361     }

   362 

   363     visitor->endVisit(this);

   364 }

   365 

   366 void TildeExpression::accept0(Visitor *visitor)

   367 {

   368     if (visitor->visit(this)) {

   369         acceptChild(expression, visitor);

   370     }

   371 

   372     visitor->endVisit(this);

   373 }

   374 

   375 void NotExpression::accept0(Visitor *visitor)

   376 {

   377     if (visitor->visit(this)) {

   378         acceptChild(expression, visitor);

   379     }

   380 

   381     visitor->endVisit(this);

   382 }

   383 

   384 void BinaryExpression::accept0(Visitor *visitor)

   385 {

   386     if (visitor->visit(this)) {

   387         acceptChild(left, visitor);

   388         acceptChild(right, visitor);

   389     }

   390 

   391     visitor->endVisit(this);

   392 }

   393 

   394 void ConditionalExpression::accept0(Visitor *visitor)

   395 {

   396     if (visitor->visit(this)) {

   397         acceptChild(expression, visitor);

   398         acceptChild(ok, visitor);

   399         acceptChild(ko, visitor);

   400     }

   401 

   402     visitor->endVisit(this);

   403 }

   404 

   405 void Expression::accept0(Visitor *visitor)

   406 {

   407     if (visitor->visit(this)) {

   408         acceptChild(left, visitor);

   409         acceptChild(right, visitor);

   410     }

   411 

   412     visitor->endVisit(this);

   413 }

   414 

   415 void Block::accept0(Visitor *visitor)

   416 {

   417     if (visitor->visit(this)) {

   418         acceptChild(statements, visitor);

   419     }

   420 

   421     visitor->endVisit(this);

   422 }

   423 

   424 void StatementList::accept0(Visitor *visitor)

   425 {

   426     if (visitor->visit(this)) {

   427         StatementList *it = this;

   428         do {

   429             acceptChild(it->statement, visitor);

   430             it = it->next;

   431         } while (it);

   432     }

   433 

   434     visitor->endVisit(this);

   435 }

   436 

   437 void VariableStatement::accept0(Visitor *visitor)

   438 {

   439     if (visitor->visit(this)) {

   440         acceptChild(declarations, visitor);

   441     }

   442 

   443     visitor->endVisit(this);

   444 }

   445 

   446 void VariableDeclarationList::accept0(Visitor *visitor)

   447 {

   448     if (visitor->visit(this)) {

   449         VariableDeclarationList *it = this;

   450         do {

   451             acceptChild(it->declaration, visitor);

   452             it = it->next;

   453         } while (it);

   454     }

   455 

   456     visitor->endVisit(this);

   457 }

   458 

   459 void VariableDeclaration::accept0(Visitor *visitor)

   460 {

   461     if (visitor->visit(this)) {

   462         acceptChild(expression, visitor);

   463     }

   464 

   465     visitor->endVisit(this);

   466 }

   467 

   468 void EmptyStatement::accept0(Visitor *visitor)

   469 {

   470     if (visitor->visit(this)) {

   471     }

   472 

   473     visitor->endVisit(this);

   474 }

   475 

   476 void ExpressionStatement::accept0(Visitor *visitor)

   477 {

   478     if (visitor->visit(this)) {

   479         acceptChild(expression, visitor);

   480     }

   481 

   482     visitor->endVisit(this);

   483 }

   484 

   485 void IfStatement::accept0(Visitor *visitor)

   486 {

   487     if (visitor->visit(this)) {

   488         acceptChild(expression, visitor);

   489         acceptChild(ok, visitor);

   490         acceptChild(ko, visitor);

   491     }

   492 

   493     visitor->endVisit(this);

   494 }

   495 

   496 void DoWhileStatement::accept0(Visitor *visitor)

   497 {

   498     if (visitor->visit(this)) {

   499         acceptChild(statement, visitor);

   500         acceptChild(expression, visitor);

   501     }

   502 

   503     visitor->endVisit(this);

   504 }

   505 

   506 void WhileStatement::accept0(Visitor *visitor)

   507 {

   508     if (visitor->visit(this)) {

   509         acceptChild(expression, visitor);

   510         acceptChild(statement, visitor);

   511     }

   512 

   513     visitor->endVisit(this);

   514 }

   515 

   516 void ForStatement::accept0(Visitor *visitor)

   517 {

   518     if (visitor->visit(this)) {

   519         acceptChild(initialiser, visitor);

   520         acceptChild(condition, visitor);

   521         acceptChild(expression, visitor);

   522         acceptChild(statement, visitor);

   523     }

   524 

   525     visitor->endVisit(this);

   526 }

   527 

   528 void LocalForStatement::accept0(Visitor *visitor)

   529 {

   530     if (visitor->visit(this)) {

   531         acceptChild(declarations, visitor);

   532         acceptChild(condition, visitor);

   533         acceptChild(expression, visitor);

   534         acceptChild(statement, visitor);

   535     }

   536 

   537     visitor->endVisit(this);

   538 }

   539 

   540 void ForEachStatement::accept0(Visitor *visitor)

   541 {

   542     if (visitor->visit(this)) {

   543         acceptChild(initialiser, visitor);

   544         acceptChild(expression, visitor);

   545         acceptChild(statement, visitor);

   546     }

   547 

   548     visitor->endVisit(this);

   549 }

   550 

   551 void LocalForEachStatement::accept0(Visitor *visitor)

   552 {

   553     if (visitor->visit(this)) {

   554         acceptChild(declaration, visitor);

   555         acceptChild(expression, visitor);

   556         acceptChild(statement, visitor);

   557     }

   558 

   559     visitor->endVisit(this);

   560 }

   561 

   562 void ContinueStatement::accept0(Visitor *visitor)

   563 {

   564     if (visitor->visit(this)) {

   565     }

   566 

   567     visitor->endVisit(this);

   568 }

   569 

   570 void BreakStatement::accept0(Visitor *visitor)

   571 {

   572     if (visitor->visit(this)) {

   573     }

   574 

   575     visitor->endVisit(this);

   576 }

   577 

   578 void ReturnStatement::accept0(Visitor *visitor)

   579 {

   580     if (visitor->visit(this)) {

   581         acceptChild(expression, visitor);

   582     }

   583 

   584     visitor->endVisit(this);

   585 }

   586 

   587 void WithStatement::accept0(Visitor *visitor)

   588 {

   589     if (visitor->visit(this)) {

   590         acceptChild(expression, visitor);

   591         acceptChild(statement, visitor);

   592     }

   593 

   594     visitor->endVisit(this);

   595 }

   596 

   597 void SwitchStatement::accept0(Visitor *visitor)

   598 {

   599     if (visitor->visit(this)) {

   600         acceptChild(expression, visitor);

   601         acceptChild(block, visitor);

   602     }

   603 

   604     visitor->endVisit(this);

   605 }

   606 

   607 void CaseBlock::accept0(Visitor *visitor)

   608 {

   609     if (visitor->visit(this)) {

   610         acceptChild(clauses, visitor);

   611         acceptChild(defaultClause, visitor);

   612         acceptChild(moreClauses, visitor);

   613     }

   614 

   615     visitor->endVisit(this);

   616 }

   617 

   618 void CaseClauses::accept0(Visitor *visitor)

   619 {

   620     if (visitor->visit(this)) {

   621         CaseClauses *it = this;

   622         do {

   623             acceptChild(it->clause, visitor);

   624             it = it->next;

   625         } while (it);

   626     }

   627 

   628     visitor->endVisit(this);

   629 }

   630 

   631 void CaseClause::accept0(Visitor *visitor)

   632 {

   633     if (visitor->visit(this)) {

   634         acceptChild(expression, visitor);

   635         acceptChild(statements, visitor);

   636     }

   637 

   638     visitor->endVisit(this);

   639 }

   640 

   641 void DefaultClause::accept0(Visitor *visitor)

   642 {

   643     if (visitor->visit(this)) {

   644         acceptChild(statements, visitor);

   645     }

   646 

   647     visitor->endVisit(this);

   648 }

   649 

   650 void LabelledStatement::accept0(Visitor *visitor)

   651 {

   652     if (visitor->visit(this)) {

   653         acceptChild(statement, visitor);

   654     }

   655 

   656     visitor->endVisit(this);

   657 }

   658 

   659 void ThrowStatement::accept0(Visitor *visitor)

   660 {

   661     if (visitor->visit(this)) {

   662         acceptChild(expression, visitor);

   663     }

   664 

   665     visitor->endVisit(this);

   666 }

   667 

   668 void TryStatement::accept0(Visitor *visitor)

   669 {

   670     if (visitor->visit(this)) {

   671         acceptChild(statement, visitor);

   672         acceptChild(catchExpression, visitor);

   673         acceptChild(finallyExpression, visitor);

   674     }

   675 

   676     visitor->endVisit(this);

   677 }

   678 

   679 void Catch::accept0(Visitor *visitor)

   680 {

   681     if (visitor->visit(this)) {

   682         acceptChild(statement, visitor);

   683     }

   684 

   685     visitor->endVisit(this);

   686 }

   687 

   688 void Finally::accept0(Visitor *visitor)

   689 {

   690     if (visitor->visit(this)) {

   691         acceptChild(statement, visitor);

   692     }

   693 

   694     visitor->endVisit(this);

   695 }

   696 

   697 void FunctionDeclaration::accept0(Visitor *visitor)

   698 {

   699     if (visitor->visit(this)) {

   700         acceptChild(formals, visitor);

   701         acceptChild(body, visitor);

   702     }

   703 

   704     visitor->endVisit(this);

   705 }

   706 

   707 void FunctionExpression::accept0(Visitor *visitor)

   708 {

   709     if (visitor->visit(this)) {

   710         acceptChild(formals, visitor);

   711         acceptChild(body, visitor);

   712     }

   713 

   714     visitor->endVisit(this);

   715 }

   716 

   717 void FormalParameterList::accept0(Visitor *visitor)

   718 {

   719     if (visitor->visit(this)) {

   720         // ###

   721     }

   722 

   723     visitor->endVisit(this);

   724 }

   725 

   726 void FunctionBody::accept0(Visitor *visitor)

   727 {

   728     if (visitor->visit(this)) {

   729         acceptChild(elements, visitor);

   730     }

   731 

   732     visitor->endVisit(this);

   733 }

   734 

   735 void Program::accept0(Visitor *visitor)

   736 {

   737     if (visitor->visit(this)) {

   738         acceptChild(elements, visitor);

   739     }

   740 

   741     visitor->endVisit(this);

   742 }

   743 

   744 void SourceElements::accept0(Visitor *visitor)

   745 {

   746     if (visitor->visit(this)) {

   747         SourceElements *it = this;

   748         do {

   749             acceptChild(it->element, visitor);

   750             it = it->next;

   751         } while (it);

   752     }

   753 

   754     visitor->endVisit(this);

   755 }

   756 

   757 void FunctionSourceElement::accept0(Visitor *visitor)

   758 {

   759     if (visitor->visit(this)) {

   760         acceptChild(declaration, visitor);

   761     }

   762 

   763     visitor->endVisit(this);

   764 }

   765 

   766 void StatementSourceElement::accept0(Visitor *visitor)

   767 {

   768     if (visitor->visit(this)) {

   769         acceptChild(statement, visitor);

   770     }

   771 

   772     visitor->endVisit(this);

   773 }

   774 

   775 void DebuggerStatement::accept0(Visitor *visitor)

   776 {

   777     if (visitor->visit(this)) {

   778     }

   779 

   780     visitor->endVisit(this);

   781 }

   782 

   783 } } // namespace QScript::AST

   784 

   785 QT_END_NAMESPACE