00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
#include "koscript_eval.h"
00021
#include "koscript_value.h"
00022
#include "koscript_context.h"
00023
#include "koscript_func.h"
00024
#include "koscript_struct.h"
00025
#include "koscript.h"
00026
#include "koscript_parsenode.h"
00027
#include "koscript_util.h"
00028
#include "koscript_property.h"
00029
#include "koscript_method.h"
00030
#include <kdebug.h>
00031
#include <stdio.h>
00032
#include <math.h>
00033
00034
#include <kregexp.h>
00035
00036
#include <qfileinfo.h>
00037
#include <klocale.h>
00038
00039
00040
00041
00042
#define EVAL_OPS( ctx, l, r, leftexpr ) \
00043
KSParseNode *left = node->branch1(); \
00044
KSParseNode *right = node->branch2(); \
00045
if ( !left || !right ) \
00046
return false; \
00047
\
00048
KSContext l( ctx, leftexpr ); \
00049
KSContext r( ctx ); \
00050
if ( !left->eval( l ) ) \
00051
{ \
00052
ctx.setException( l ); \
00053
return false; \
00054
} \
00055
if ( !right->eval( r ) ) \
00056
{ \
00057
ctx.setException( r ); \
00058
return false; \
00059
}
00060
00061
#define EVAL_LEFT_OP( ctx, l ) \
00062
KSParseNode *left = node->branch1(); \
00063
if ( !left ) \
00064
return false; \
00065
\
00066
KSContext l( ctx ); \
00067
if ( !left->eval( l ) ) \
00068
{ \
00069
ctx.setException( l ); \
00070
return false; \
00071
} \
00072
00073
#define EVAL_RIGHT_OP( ctx, r ) \
00074
KSParseNode *right = node->branch2(); \
00075
if ( !right ) \
00076
return false; \
00077
\
00078
KSContext r( ctx ); \
00079
if ( !right->eval( r ) ) \
00080
{ \
00081
ctx.setException( r ); \
00082
return false; \
00083
} \
00084
00085
00086
00087
00088
#define FILL_VALUE( ctx, l, r ) \
00089
if ( l.value()->mode() == KSValue::Temp ) \
00090
ctx.setValue( l.shareValue() ); \
00091
else if ( r.value()->mode() == KSValue::Temp ) \
00092
ctx.setValue( r.shareValue() ); \
00093
else \
00094
ctx.setValue( new KSValue );
00095
00096
bool KSEval_definitions( KSParseNode* node, KSContext& context )
00097 {
00098
if ( node->branch1() )
00099 {
00100
if ( node->branch1()->getType() == func_dcl )
00101 {
00102 Q_ASSERT( context.scope() );
00103 context.scope()->addObject( node->branch1()->getIdent(),
new KSValue(
new KSScriptFunction( context.scope()->module(), node->branch1() ) ) );
00104 }
00105
else if ( !node->branch1()->eval( context ) )
00106
return false;
00107 }
00108
if ( node->branch2() )
00109 {
00110
if ( node->branch2()->getType() == func_dcl )
00111 {
00112 Q_ASSERT( context.scope() );
00113 context.scope()->addObject( node->branch2()->getIdent(),
new KSValue(
new KSScriptFunction( context.scope()->module(), node->branch2() ) ) );
00114 }
00115
else if ( !node->branch2()->eval( context ) )
00116
return false;
00117 }
00118
00119
return true;
00120 }
00121
00122
bool KSEval_exports( KSParseNode* node, KSContext& context )
00123 {
00124 Q_ASSERT( context.value() );
00125
00126
if ( context.value()->type() == KSValue::StructClassType )
00127 {
00128
if ( node->branch1() )
00129 {
00130
if ( node->branch1()->getType() == func_dcl )
00131 context.value()->structClassValue()->nameSpace()->insert( node->branch1()->getIdent(),
new KSValue(
new KSScriptFunction( context.scope()->module(), node->branch1() ) ) );
00132
else if ( !node->branch1()->eval( context ) )
00133
return false;
00134 }
00135
if ( node->branch2() )
00136 {
00137
if ( node->branch2()->getType() == func_dcl )
00138 context.value()->structClassValue()->nameSpace()->insert( node->branch2()->getIdent(),
new KSValue(
new KSScriptFunction( context.scope()->module(), node->branch2() ) ) );
00139
else if ( !node->branch2()->eval( context ) )
00140
return false;
00141 }
00142 }
00143
else
00144 Q_ASSERT( 0 );
00145
00146
return true;
00147 }
00148
00149
bool KSEval_t_vertical_line( KSParseNode* node, KSContext& context )
00150 {
00151 EVAL_OPS( context, l, r,
false );
00152
00153
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) ||
00154 !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00155 {
00156 context.exception()->addLine( node->getLineNo() );
00157
return false;
00158 }
00159
00160 context.setValue(
new KSValue( (KScript::Boolean)( l.value()->intValue() | r.value()->intValue() ) ) );
00161
00162
return true;
00163 }
00164
00165
bool KSEval_t_circumflex( KSParseNode* node, KSContext& context )
00166 {
00167 EVAL_OPS( context, l, r,
false );
00168
00169
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) ||
00170 !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00171 {
00172 context.exception()->addLine( node->getLineNo() );
00173
return false;
00174 }
00175
00176 context.setValue(
new KSValue( (KScript::Boolean)( l.value()->intValue() ^ r.value()->intValue() ) ) );
00177
00178
return true;
00179 }
00180
00181
bool KSEval_t_ampersand( KSParseNode* node, KSContext& context )
00182 {
00183 EVAL_OPS( context, l, r,
false );
00184
00185
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) ||
00186 !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00187 {
00188 context.exception()->addLine( node->getLineNo() );
00189
return false;
00190 }
00191
00192 context.setValue(
new KSValue( (KScript::Boolean)( l.value()->intValue() & r.value()->intValue() ) ) );
00193
00194
return true;
00195 }
00196
00197
bool KSEval_t_shiftright( KSParseNode* node, KSContext& context )
00198 {
00199 EVAL_OPS( context, l, r,
false );
00200
00201
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) ||
00202 !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00203 {
00204 context.exception()->addLine( node->getLineNo() );
00205
return false;
00206 }
00207
00208 context.setValue(
new KSValue( (KScript::Long)( l.value()->intValue() >> r.value()->intValue() ) ) );
00209
00210
return true;
00211 }
00212
00213
bool KSEval_t_shiftleft( KSParseNode* node, KSContext& context )
00214 {
00215 EVAL_OPS( context, l, r,
false );
00216
00217
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) ||
00218 !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00219 {
00220 context.exception()->addLine( node->getLineNo() );
00221
return false;
00222 }
00223
00224 context.setValue(
new KSValue( (KScript::Long)( l.value()->intValue() << r.value()->intValue() ) ) );
00225
00226
return true;
00227 }
00228
00229
bool KSEval_t_plus_sign( KSParseNode* node, KSContext& context )
00230 {
00231
00232
if ( node->branch1() && !node->branch2() )
00233 {
00234
if ( !node->branch1()->eval( context ) )
00235
return false;
00236
00237
00238
00239
00240
00241
if ( context.value()->type() == KSValue::IntType ||
00242 context.value()->cast( KSValue::DoubleType) )
00243 {
00244
return true;
00245 }
00246
00247
QString tmp( i18n(
"Unary Operator + not defined for type %1") );
00248 context.setException(
new KSException(
"UnknownOperation", tmp.arg( context.value()->typeName() ), node->getLineNo() ) );
00249
return false;
00250 }
00251
00252
00253 EVAL_OPS( context, l, r,
false );
00254
00255
00256
00257
00258
if ( r.value()->type() == KSValue::TimeType )
00259 {
00260
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) )
00261
return false;
00262
QTime t = r.value()->timeValue();
00263 t = t.addSecs( l.value()->intValue() );
00264 FILL_VALUE( context, l, r );
00265 context.value()->setValue( t );
00266
return TRUE;
00267 }
00268
else if ( r.value()->type() == KSValue::DateType )
00269 {
00270
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) )
00271
return false;
00272
QDate d = r.value()->dateValue();
00273 d = d.addDays( l.value()->intValue() );
00274 FILL_VALUE( context, l, r );
00275 context.value()->setValue( d );
00276
return TRUE;
00277 }
00278
00279
00280
if ( r.value()->type() == KSValue::BoolType )
00281 {
00282 r.value()->cast( KSValue::IntType );
00283 }
00284
00285
if ( l.value()->type() == KSValue::TimeType )
00286 {
00287
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00288
return false;
00289
QTime t = l.value()->timeValue();
00290 t = t.addSecs( r.value()->intValue() );
00291 FILL_VALUE( context, l, r );
00292 context.value()->setValue( t );
00293
return TRUE;
00294 }
00295
else if ( l.value()->type() == KSValue::DateType )
00296 {
00297
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00298
return false;
00299
QDate d = l.value()->dateValue();
00300 d = d.addDays( r.value()->intValue() );
00301 FILL_VALUE( context, l, r );
00302 context.value()->setValue( d );
00303
return TRUE;
00304 }
00305
00306
00307
if ( l.value()->type() == KSValue::BoolType )
00308 {
00309 l.value()->cast( KSValue::IntType );
00310 }
00311
00312
00313
else if ( l.value()->type() == KSValue::DoubleType )
00314 {
00315
if ( !
KSUtil::checkType( context, r.value(), l.value()->type(),
true ) )
00316
return false;
00317 }
00318
else
00319 {
00320
if ( !
KSUtil::checkType( context, l.value(), r.value()->type(),
true ) )
00321
return false;
00322 l.value()->cast( r.value()->type());
00323 }
00324
00325
switch( l.value()->type() )
00326 {
00327
case KSValue::IntType:
00328 {
00329 KScript::Long result = r.value()->intValue() + l.value()->intValue();
00330 FILL_VALUE( context, l, r );
00331 context.value()->setValue( result );
00332
return true;
00333 }
00334
break;
00335
case KSValue::DoubleType:
00336 {
00337 KScript::Double result = l.value()->doubleValue() + r.value()->doubleValue();
00338 FILL_VALUE( context, l, r );
00339 context.value()->setValue( result );
00340
return true;
00341 }
00342
case KSValue::StringType:
00343 {
00344
QString result = l.value()->stringValue() + r.value()->stringValue();
00345 FILL_VALUE( context, l, r );
00346 context.value()->setValue( result );
00347
return true;
00348 }
00349
break;
00350
case KSValue::ListType:
00351 {
00352
QValueList<KSValue::Ptr> result = l.value()->listValue() + r.value()->listValue();
00353 FILL_VALUE( context, l, r );
00354 context.value()->setValue( result );
00355
return true;
00356 }
00357
break;
00358
case KSValue::MapType:
00359 {
00360
QMap<QString,KSValue::Ptr> result = l.value()->mapValue();
00361
QMap<QString,KSValue::Ptr>::ConstIterator it = r.value()->mapValue().begin();
00362
QMap<QString,KSValue::Ptr>::ConstIterator end = r.value()->mapValue().end();
00363
for( ; it != end; ++it )
00364 result.insert( it.key(), it.data() );
00365 FILL_VALUE( context, l, r );
00366 context.value()->setValue( result );
00367
return true;
00368 }
00369
break;
00370
case KSValue::DateType:
00371
case KSValue::TimeType:
00372
00373
return true;
00374
default:
00375
QString tmp( i18n(
"Operator + not defined for type %1") );
00376 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
00377
return false;
00378 }
00379
00380
00381
return false;
00382 }
00383
00384
bool KSEval_t_minus_sign( KSParseNode* node, KSContext& context )
00385 {
00386
00387
if ( node->branch1() && !node->branch2() )
00388 {
00389
if ( !node->branch1()->eval( context ) )
00390
return false;
00391
if ( context.value()->type() == KSValue::IntType )
00392 {
00393 context.setValue(
new KSValue( -( context.value()->intValue() ) ) );
00394
return true;
00395 }
00396
if ( context.value()->type() == KSValue::DoubleType )
00397 {
00398 context.setValue(
new KSValue( -( context.value()->doubleValue() ) ) );
00399
return true;
00400 }
00401
00402
QString tmp( i18n(
"Unary Operator - not defined for type %1") );
00403 context.setException(
new KSException(
"UnknownOperation", tmp.arg( context.value()->typeName() ), node->getLineNo() ) );
00404
return false;
00405 }
00406
00407 EVAL_OPS( context, l, r,
false );
00408
00409
00410
if ( r.value()->type() == KSValue::TimeType )
00411 {
00412
if (
KSUtil::checkType( context, l.value(), KSValue::TimeType,
false ) )
00413 {
00414
QTime d = r.value()->timeValue();
00415
int diff = d.secsTo( l.value()->timeValue() );
00416 FILL_VALUE( context, l, r );
00417
QTime _time(0,0,0);
00418 _time=_time.addSecs(diff);
00419 context.value()->setValue( _time );
00420
return TRUE;
00421 }
00422
00423
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) )
00424
return false;
00425
QTime t = r.value()->timeValue();
00426 t = t.addSecs( -l.value()->intValue() );
00427 FILL_VALUE( context, l, r );
00428 context.value()->setValue( t );
00429
return TRUE;
00430 }
00431
else if ( r.value()->type() == KSValue::DateType )
00432 {
00433
if (
KSUtil::checkType( context, l.value(), KSValue::DateType,
false ) )
00434 {
00435
QDate d = r.value()->dateValue();
00436
int diff = d.daysTo( l.value()->dateValue() );
00437 FILL_VALUE( context, l, r );
00438 context.value()->setValue( (KScript::Long)diff );
00439
return TRUE;
00440 }
00441
00442
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) )
00443
return false;
00444
QDate d = r.value()->dateValue();
00445 d = d.addDays( -l.value()->intValue() );
00446 FILL_VALUE( context, l, r );
00447 context.value()->setValue( d );
00448
return TRUE;
00449 }
00450
00451
00452
00453
if ( l.value()->type() == KSValue::TimeType )
00454 {
00455
if (
KSUtil::checkType( context, r.value(), KSValue::TimeType,
false ) )
00456 {
00457
QTime d = r.value()->timeValue();
00458
int diff = d.secsTo( l.value()->timeValue() );
00459 FILL_VALUE( context, l, r );
00460 context.value()->setValue( (KScript::Long) diff );
00461
return TRUE;
00462 }
00463
00464
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00465
return false;
00466
QTime t = l.value()->timeValue();
00467 t = t.addSecs( -r.value()->intValue() );
00468 FILL_VALUE( context, l, r );
00469 context.value()->setValue( t );
00470
return TRUE;
00471 }
00472
else if ( l.value()->type() == KSValue::DateType )
00473 {
00474
if (
KSUtil::checkType( context, r.value(), KSValue::DateType,
false ) )
00475 {
00476
QDate d = r.value()->dateValue();
00477
int diff = d.daysTo( l.value()->dateValue() );
00478 FILL_VALUE( context, l, r );
00479 context.value()->setValue( (KScript::Long)diff );
00480
return TRUE;
00481 }
00482
00483
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00484
return false;
00485
QDate d = l.value()->dateValue();
00486 d = d.addDays( -r.value()->intValue() );
00487 FILL_VALUE( context, l, r );
00488 context.value()->setValue( d );
00489
return TRUE;
00490 }
00491
00492
else if ( l.value()->type() == KSValue::DoubleType )
00493 {
00494
if ( !
KSUtil::checkType( context, r.value(), l.value()->type(),
true ) )
00495
return false;
00496 }
00497
else
00498 {
00499
if ( !
KSUtil::checkType( context, l.value(), r.value()->type(),
true ) )
00500
return false;
00501 l.value()->cast( r.value()->type());
00502 }
00503
00504
switch( l.value()->type() )
00505 {
00506
case KSValue::IntType:
00507 {
00508 KScript::Long result = l.value()->intValue() - r.value()->intValue();
00509 FILL_VALUE( context, l, r );
00510 context.value()->setValue( result );
00511
return true;
00512 }
00513
case KSValue::DoubleType:
00514 {
00515 KScript::Double result = l.value()->doubleValue() - r.value()->doubleValue();
00516 FILL_VALUE( context, l, r );
00517 context.value()->setValue( result );
00518
return true;
00519 }
00520
default:
00521
QString tmp( i18n(
"Operator - not defined for type %1") );
00522 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
00523
return false;
00524 }
00525
00526
00527
return false;
00528 }
00529
00530
bool KSEval_t_asterik( KSParseNode* node, KSContext& context )
00531 {
00532 EVAL_OPS( context, l, r,
false );
00533
00534
00535
if ( l.value()->type() == KSValue::DoubleType )
00536 {
00537
if ( !
KSUtil::checkType( context, r.value(), l.value()->type(),
true ) )
00538
return false;
00539 }
00540
else
00541 {
00542
if ( !
KSUtil::checkType( context, l.value(), r.value()->type(),
true ) )
00543
return false;
00544 l.value()->cast( r.value()->type());
00545 }
00546
00547
switch( l.value()->type() )
00548 {
00549
case KSValue::IntType:
00550 {
00551
00552
00553 KScript::Double v = r.value()->doubleValue() * l.value()->doubleValue();
00554 FILL_VALUE( context, l, r );
00555
if( fabs( v ) < 1e9 )
00556 context.value()->setValue( (
long) v );
00557
else
00558 context.value()->setValue( v );
00559
return true;
00560 }
00561
case KSValue::DoubleType:
00562 {
00563 KScript::Double result = r.value()->doubleValue() * l.value()->doubleValue();
00564 FILL_VALUE( context, l, r );
00565 context.value()->setValue( result );
00566
return true;
00567 }
00568
default:
00569
QString tmp( i18n(
"Operator * not defined for type %1") );
00570 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
00571
return false;
00572 }
00573
00574
00575
return false;
00576 }
00577
00578
bool KSEval_t_solidus( KSParseNode* node, KSContext& context )
00579 {
00580 EVAL_OPS( context, l, r,
false );
00581
00582
00583
if ( l.value()->type() == KSValue::DoubleType )
00584 {
00585
if ( !
KSUtil::checkType( context, r.value(), l.value()->type(),
true ) )
00586
return false;
00587 }
00588
else
00589 {
00590
if ( !
KSUtil::checkType( context, l.value(), r.value()->type(),
true ) )
00591
return false;
00592 l.value()->cast( r.value()->type());
00593 }
00594
00595
switch( l.value()->type() )
00596 {
00597
case KSValue::IntType:
00598 {
00599
00600
if ( r.value()->intValue()!=0 && ( l.value()->intValue() % r.value()->intValue() ) == 0 )
00601 {
00602 KScript::Long result = l.value()->intValue() / r.value()->intValue();
00603 FILL_VALUE( context, l, r );
00604 context.value()->setValue( result );
00605 }
00606
else
00607 {
00608 KScript::Double result = (
double)l.value()->intValue() / (
double)r.value()->intValue();
00609 FILL_VALUE( context, l, r );
00610 context.value()->setValue( result );
00611 }
00612
return true;
00613 }
00614
case KSValue::DoubleType:
00615 {
00616 KScript::Double result = l.value()->doubleValue() / r.value()->doubleValue();
00617 FILL_VALUE( context, l, r );
00618 context.value()->setValue( result );
00619
return true;
00620 }
00621
default:
00622
QString tmp( i18n(
"Operator / not defined for type %1") );
00623 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
00624
return false;
00625 }
00626
00627
00628
return false;
00629 }
00630
00631
bool KSEval_t_percent_sign( KSParseNode* node, KSContext& context )
00632 {
00633 EVAL_OPS( context, l, r,
false );
00634
00635
if ( !
KSUtil::checkType( context, l.value(), KSValue::IntType,
true ) )
00636
return false;
00637
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
00638
return false;
00639
00640
if(r.value()->intValue()!=0)
00641 {
00642 KScript::Long result = l.value()->intValue() % r.value()->intValue();
00643 FILL_VALUE( context, l, r );
00644 context.value()->setValue( result );
00645 }
00646
else
00647 {
00648 KScript::Double result = (
double)l.value()->intValue() / (
double)r.value()->intValue();
00649 FILL_VALUE( context, l, r );
00650 context.value()->setValue( result );
00651 }
00652
return true;
00653 }
00654
00655
bool KSEval_t_tilde( KSParseNode* , KSContext& ) {
return false; }
00656
00657
bool KSEval_t_integer_literal( KSParseNode* node, KSContext& context )
00658 {
00659 context.setValue(
new KSValue( node->getIntegerLiteral() ) );
00660
return true;
00661 }
00662
00663
bool KSEval_t_string_literal( KSParseNode* node, KSContext& context )
00664 {
00665 context.setValue(
new KSValue( node->getStringLiteral() ) );
00666
return true;
00667 }
00668
00669
bool KSEval_t_character_literal( KSParseNode* node, KSContext& context )
00670 {
00671 context.setValue(
new KSValue( node->getCharacterLiteral() ) );
00672
return true;
00673 }
00674
00675
bool KSEval_t_floating_pt_literal( KSParseNode* node, KSContext& context )
00676 {
00677 context.setValue(
new KSValue( node->getFloatingPtLiteral() ) );
00678
return true;
00679 }
00680
00681
bool KSEval_t_boolean_literal( KSParseNode* node, KSContext& context )
00682 {
00683 context.setValue(
new KSValue( node->getBooleanLiteral() ) );
00684
return true;
00685 }
00686
00687
bool KSEval_scoped_name( KSParseNode* node, KSContext& context )
00688 {
00689
KSValue* v = context.object( node->getIdent() );
00690
if ( !v )
00691 {
00692 context.setException(
new KSException(
"UnknownName", node->getIdent(), node->getLineNo() ) );
00693
return false;
00694 }
00695
00696 v->ref();
00697 context.setValue( v );
00698
00699
return true;
00700 }
00701
00702
00703
bool KSEval_const_dcl( KSParseNode* node, KSContext& context )
00704 {
00705 Q_ASSERT( node->branch1() );
00706
00707 KSContext( l );
00708
if ( !node->branch1()->eval( l ) )
00709 {
00710 context.setException( l );
00711
return false;
00712 }
00713
00714
if ( !context.value() )
00715 context.scope()->addObject( node->getIdent(), l.shareValue() );
00716
else if ( context.value()->type() == KSValue::StructClassType )
00717 context.value()->structClassValue()->nameSpace()->insert( node->getIdent(), l.shareValue() );
00718
else
00719 Q_ASSERT( 0 );
00720
00721
return true;
00722 }
00723
00724
bool KSEval_func_dcl( KSParseNode* node, KSContext& context )
00725 {
00726
00727
KSNamespace nspace;
00728 KSSubScope scope( &nspace );
00729 context.scope()->pushLocalScope( &scope );
00730
00731
00732
if ( node->branch1() )
00733
if ( !node->branch1()->eval( context ) )
00734 {
00735 context.scope()->popLocalScope();
00736
return false;
00737 }
00738
00739
00740
if ( !context.value()->listValue().isEmpty() )
00741 {
00742
const QString tmp( i18n(
"1 argument is not needed",
"%n arguments are not needed", context.value()->listValue().count() ) );
00743 context.setException(
new KSException(
"TooManyArguments", tmp, node->getLineNo() ) );
00744 context.scope()->popLocalScope();
00745
return false;
00746 }
00747
00748
bool res =
true;
00749
00750
if ( node->branch2() )
00751 res = node->branch2()->eval( context );
00752
00753
00754 context.clearReturnFlag();
00755
00756
00757 context.scope()->popLocalScope();
00758
00759
return res;
00760 }
00761
00762
bool KSEval_func_lines( KSParseNode* node, KSContext& context )
00763 {
00764
if ( node->branch1() )
00765 {
00766 context.interpreter()->context().setException( 0 );
00767
if ( !node->branch1()->eval( context ) )
00768
return false;
00769
if ( context.returnFlag() )
00770
return true;
00771
00772
00773 }
00774
00775
00776
00777 context.setValue( 0 );
00778
00779
00780
if ( context.interpreter()->context().exception() )
00781 {
00782 context.setException( context.interpreter()->context().exception() );
00783
return false;
00784 }
00785
00786
00787
if ( node->branch2() )
00788
if ( !node->branch2()->eval( context ) )
00789
return false;
00790
00791
return true;
00792 }
00793
00794
bool KSEval_assign_expr( KSParseNode* node, KSContext& context )
00795 {
00796 EVAL_OPS( context, l, r,
true );
00797
00798
if ( l.value()->mode() != KSValue::LeftExpr )
00799 {
00800 context.setException(
new KSException(
"NoLeftExpr", i18n(
"Expected a left expression in assignment"), node->getLineNo() ) );
00801
return false;
00802 }
00803
00804
00805
if ( l.value()->type() == KSValue::CharRefType )
00806 {
00807
if ( !r.value()->cast( KSValue::CharType ) )
00808 {
00809
QString tmp( i18n(
"From %1 to Char") );
00810 context.setException(
new KSException(
"CastingError", tmp.arg( r.value()->typeName() ), node->getLineNo() ) );
00811
return false;
00812 }
00813 l.value()->charRefValue() = r.value()->charValue();
00814
00815
00816 context.setValue(
new KSValue( r.value()->charValue() ) );
00817
return true;
00818 }
00819
00820
00821
if ( l.value()->type() == KSValue::PropertyType )
00822 {
00823
if ( ! l.value()->propertyValue()->set( context, r.shareValue() ) )
00824
return false;
00825
00826 context.setValue( r.shareValue() );
00827 }
00828
else
00829 {
00830 l.value()->suck( r.value() );
00831
00832 context.setValue( l.shareValue() );
00833 }
00834
00835
00836
00837
return true;
00838 }
00839
00840
bool KSEval_t_equal( KSParseNode* node, KSContext& context )
00841 {
00842 EVAL_OPS( context, l, r,
false );
00843
00844 KScript::Boolean result;
00845
if ( !r.value()->cast( l.value()->type() ) )
00846 {
00847
00848
00849
00850
00851 result =
false;
00852 }
00853
else
00854 {
00855
00856 result = ( r.value()->cmp( *l.value() ) );
00857 }
00858
00859 FILL_VALUE( context, l, r );
00860 context.value()->setValue( result );
00861
return true;
00862 }
00863
00864
bool KSEval_t_notequal( KSParseNode* node, KSContext& context )
00865 {
00866 EVAL_OPS( context, l, r,
false );
00867
00868
if ( !r.value()->cast( l.value()->type() ) )
00869 {
00870
QString tmp( i18n(
"From %1 to %2") );
00871 context.setException(
new KSException(
"CastingError", tmp.arg( r.value()->typeName() ).arg( l.value()->typeName() ), node->getLineNo() ) );
00872
return false;
00873 }
00874
00875 KScript::Boolean result = !( r.value()->cmp( *l.value() ) );
00876 FILL_VALUE( context, l, r );
00877 context.value()->setValue( result );
00878
return true;
00879 }
00880
00881
bool KSEval_t_less_or_equal( KSParseNode* node, KSContext& context )
00882 {
00883 EVAL_OPS( context, l, r,
false );
00884
00885
if ( !
KSUtil::checkType( context, r.value(), l.value()->type(),
true ) )
00886
return false;
00887
00888
switch( l.value()->type() )
00889 {
00890
case KSValue::IntType:
00891 {
00892 KScript::Boolean result = l.value()->intValue() <= r.value()->intValue();
00893 FILL_VALUE( context, l, r );
00894 context.value()->setValue( result );
00895
return true;
00896 }
00897
case KSValue::DoubleType:
00898 {
00899 KScript::Boolean result = l.value()->doubleValue() <= r.value()->doubleValue();
00900 FILL_VALUE( context, l, r );
00901 context.value()->setValue( result );
00902
return true;
00903 }
00904
case KSValue::CharType:
00905 {
00906 KScript::Boolean result = l.value()->charValue() <= r.value()->charValue();
00907 FILL_VALUE( context, l, r );
00908 context.value()->setValue( result );
00909
return true;
00910 }
00911
case KSValue::StringType:
00912 {
00913 KScript::Boolean result = l.value()->stringValue() <= r.value()->stringValue();
00914 FILL_VALUE( context, l, r );
00915 context.value()->setValue( result );
00916
return true;
00917 }
00918
case KSValue::DateType:
00919 {
00920 KScript::Boolean result = l.value()->dateValue() <= r.value()->dateValue();
00921 FILL_VALUE( context, l, r );
00922 context.value()->setValue( result );
00923
return true;
00924 }
00925
case KSValue::TimeType:
00926 {
00927 KScript::Boolean result = l.value()->timeValue() <= r.value()->timeValue();
00928 FILL_VALUE( context, l, r );
00929 context.value()->setValue( result );
00930
return true;
00931 }
00932
default:
00933
QString tmp( i18n(
"Operator <= not defined for type %1") );
00934 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
00935
return false;
00936 }
00937
00938
00939
return false;
00940 }
00941
00942
bool KSEval_t_greater_or_equal( KSParseNode* node, KSContext& context )
00943 {
00944 EVAL_OPS( context, l, r,
false );
00945
00946
if ( !
KSUtil::checkType( context, r.value(), l.value()->type(),
true ) )
00947
return false;
00948
00949
switch( l.value()->type() )
00950 {
00951
case KSValue::IntType:
00952 {
00953 KScript::Boolean result = l.value()->intValue() >= r.value()->intValue();
00954 FILL_VALUE( context, l, r );
00955 context.value()->setValue( result );
00956
return true;
00957 }
00958
case KSValue::DoubleType:
00959 {
00960 KScript::Boolean result = l.value()->doubleValue() >= r.value()->doubleValue();
00961 FILL_VALUE( context, l, r );
00962 context.value()->setValue( result );
00963
return true;
00964 }
00965
case KSValue::StringType:
00966 {
00967 KScript::Boolean result = l.value()->stringValue() >= r.value()->stringValue();
00968 FILL_VALUE( context, l, r );
00969 context.value()->setValue( result );
00970
return true;
00971 }
00972
case KSValue::CharType:
00973 {
00974 KScript::Boolean result = l.value()->charValue() >= r.value()->charValue();
00975 FILL_VALUE( context, l, r );
00976 context.value()->setValue( result );
00977
return true;
00978 }
00979
case KSValue::DateType:
00980 {
00981 KScript::Boolean result = l.value()->dateValue() >= r.value()->dateValue();
00982 FILL_VALUE( context, l, r );
00983 context.value()->setValue( result );
00984
return true;
00985 }
00986
case KSValue::TimeType:
00987 {
00988 KScript::Boolean result = l.value()->timeValue() >= r.value()->timeValue();
00989 FILL_VALUE( context, l, r );
00990 context.value()->setValue( result );
00991
return true;
00992 }
00993
default:
00994
QString tmp( i18n(
"Operator >= not defined for type %1") );
00995 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
00996
return false;
00997 }
00998
00999
01000
return false;
01001 }
01002
01003
bool KSEval_t_array( KSParseNode* node, KSContext& context )
01004 {
01005 EVAL_OPS( context, l, r,
false );
01006
01007
if ( !r.value()->cast( KSValue::IntType ) )
01008 {
01009
QString tmp( i18n(
"From %1 to Integer in array index") );
01010 context.setException(
new KSException(
"CastingError", tmp.arg( r.value()->typeName() ), node->getLineNo() ) );
01011
return false;
01012 }
01013
01014
int index = r.value()->intValue();
01015
01016
if ( index < 0 )
01017 {
01018
QString tmp( i18n(
"Negative array index %1"));
01019 context.setException(
new KSException(
"IndexOutOfRange", tmp.arg( index ), node->getLineNo() ) );
01020
return false;
01021 }
01022
01023
01024
if ( l.value()->type() == KSValue::StringType )
01025 {
01026
int len = l.value()->stringValue().length();
01027
01028
if ( index >= len && !context.leftExpr() )
01029 {
01030
QString tmp( i18n(
"Too large index %1"));
01031 context.setException(
new KSException(
"IndexOutOfRange", tmp.arg( index ), node->getLineNo() ) );
01032
return false;
01033 }
01034
01035
01036
if ( !context.leftExpr() )
01037 {
01038
const QString& str = l.value()->stringValue();
01039 context.setValue(
new KSValue( str[ index ] ) );
01040
return true;
01041 }
01042
01043
01044 context.setValue(
new KSValue( KScript::CharRef( &(l.value()->stringValue()), index ) ) );
01045 context.value()->setMode( KSValue::LeftExpr );
01046
return true;
01047 }
01048
01049
if ( !l.value()->cast( KSValue::ListType ) )
01050 {
01051
QString tmp( i18n(
"From %1 to List") );
01052 context.setException(
new KSException(
"CastingError", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
01053
return false;
01054 }
01055
01056
int len = l.value()->listValue().count();
01057
if ( index >= len )
01058 {
01059
if ( !context.leftExpr() )
01060 {
01061
QString tmp( i18n(
"Too large index %1"));
01062 context.setException(
new KSException(
"IndexOutOfRange", tmp.arg( index ), node->getLineNo() ) );
01063
return false;
01064 }
01065
else
01066 {
01067
01068
for(
int i = 0; i <= index - len; ++i )
01069 l.value()->listValue().append(
new KSValue() );
01070 }
01071 }
01072
01073 context.setValue( l.value()->listValue()[ index ] );
01074 context.value()->setMode( l.value()->mode() );
01075
01076
return true;
01077 }
01078
01079
bool KSEval_t_dict( KSParseNode* node, KSContext& context )
01080 {
01081 EVAL_OPS( context, l, r,
false );
01082
01083
if ( !r.value()->cast( KSValue::StringType ) )
01084 {
01085
QString tmp( i18n(
"From %1 to String in dict") );
01086 context.setException(
new KSException(
"CastingError", tmp.arg( r.value()->typeName() ), node->getLineNo() ) );
01087
return false;
01088 }
01089
01090
if ( !l.value()->cast( KSValue::MapType ) )
01091 {
01092
QString tmp( i18n(
"From %1 to Map") );
01093 context.setException(
new KSException(
"CastingError", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
01094
return false;
01095 }
01096
01097
QMap<QString,KSValue::Ptr>::Iterator it = l.value()->mapValue().find( r.value()->stringValue() );
01098
01099
if ( it == l.value()->mapValue().end() )
01100 {
01101
01102
if ( !context.leftExpr() )
01103 {
01104 context.setValue(
new KSValue() );
01105
return true;
01106 }
01107
01108
01109
else if ( l.value()->mode() == KSValue::LeftExpr )
01110 {
01111 KSValue::Ptr v(
new KSValue() );
01112 v->setMode( l.value()->mode() );
01113 l.value()->mapValue().insert( r.value()->stringValue(), v );
01114 context.setValue( v );
01115
return true;
01116 }
01117
01118
else
01119 {
01120 context.setException(
new KSException(
"NoLeftExpr", i18n(
"Expected a left expression."), node->getLineNo() ) );
01121
return false;
01122 }
01123 }
01124
01125 context.setValue( it.data() );
01126 context.value()->setMode( l.value()->mode() );
01127
01128
return true;
01129 }
01130
01131
bool KSEval_func_params( KSParseNode* node, KSContext& context )
01132 {
01133
01134
if ( node->branch1() )
01135
if ( !node->branch1()->eval( context ) )
01136
return false;
01137
01138
01139
if ( node->branch2() )
01140
if ( !node->branch2()->eval( context ) )
01141
return false;
01142
01143
return true;
01144 }
01145
01146
bool KSEval_func_param_in( KSParseNode* node, KSContext& context )
01147 {
01148
KSValue* v = 0;
01149
01150
01151
if ( context.value()->listValue().isEmpty() )
01152 {
01153
01154
if ( node->branch1() )
01155 {
01156 KSContext d( context );
01157
if ( !node->branch1()->eval( d ) )
01158
return false;
01159
if ( d.value()->mode() == KSValue::Temp )
01160 v = d.shareValue();
01161
else
01162 v =
new KSValue( *d.value() );
01163 }
01164
else
01165 {
01166
QString tmp( i18n(
"Argument for parameters %1 missing") );
01167 context.setException(
new KSException(
"ToFewArguments", tmp.arg( node->getIdent() ), node->getLineNo() ) );
01168
return false;
01169 }
01170 }
01171
else
01172 {
01173
01174
KSValue* arg = *(context.value()->listValue().begin());
01175
if ( arg->
mode() == KSValue::Temp )
01176 {
01177 arg->ref();
01178 v = arg;
01179 }
01180
else
01181 v =
new KSValue( *arg );
01182
01183
01184 context.value()->listValue().remove( context.value()->listValue().begin() );
01185 }
01186
01187 v->
setMode( KSValue::LeftExpr );
01188 context.scope()->addObject( node->getIdent(), v );
01189
01190
return true;
01191 }
01192
01193
bool KSEval_func_param_out( KSParseNode* node, KSContext& context )
01194 {
01195
01196
if ( context.value()->listValue().isEmpty() )
01197 {
01198
QString tmp( i18n(
"Argument for parameters %1 missing") );
01199 context.setException(
new KSException(
"ToFewArguments", tmp.arg( node->getIdent() ), node->getLineNo() ) );
01200
return false;
01201 }
01202
01203
KSValue* arg = *(context.value()->listValue().begin());
01204
01205
01206
if ( arg->
mode() != KSValue::LeftExpr )
01207 {
01208
QString tmp( i18n(
"LeftExpr needed for parameter %1") );
01209 context.setException(
new KSException(
"NoLeftExpr", tmp.arg( node->getIdent() ), node->getLineNo() ) );
01210
return false;
01211 }
01212
01213
01214
01215 context.value()->clear();
01216
01217
01218 arg->ref();
01219 context.scope()->addObject( node->getIdent(), arg );
01220
01221
01222 context.value()->listValue().remove( context.value()->listValue().begin() );
01223
01224
return true;
01225 }
01226
01227
bool KSEval_func_param_inout( KSParseNode* node, KSContext& context )
01228 {
01229
01230
if ( context.value()->listValue().isEmpty() )
01231 {
01232
QString tmp( i18n(
"Argument for parameters %1 missing") );
01233 context.setException(
new KSException(
"ToFewArguments", tmp.arg( node->getIdent() ), node->getLineNo() ) );
01234
return false;
01235 }
01236
01237
KSValue* arg = *(context.value()->listValue().begin());
01238
01239
01240
if ( arg->
mode() != KSValue::LeftExpr )
01241 {
01242
QString tmp( i18n(
"LeftExpr needed for parameter %1") );
01243 context.setException(
new KSException(
"NoLeftExpr", tmp.arg( node->getIdent() ), node->getLineNo() ) );
01244
return false;
01245 }
01246
01247
01248 arg->ref();
01249 context.scope()->addObject( node->getIdent(), arg );
01250
01251
01252 context.value()->listValue().remove( context.value()->listValue().begin() );
01253
01254
return true;
01255 }
01256
01257
bool KSEval_t_func_call( KSParseNode* node, KSContext& context )
01258 {
01259
01260 KSParseNode *left = node->branch1();
01261
if ( !left )
01262
return true;
01263
01264 KSContext l( context );
01265
if ( !left->eval( l ) )
01266 {
01267 context.setException( l );
01268
return false;
01269 }
01270
01271
if ( !l.value()->cast( KSValue::FunctionType ) &&
01272 !l.value()->cast( KSValue::MethodType ) && !l.value()->cast( KSValue::StructClassType ) )
01273 {
01274
QString tmp( i18n(
"From %1 to Function") );
01275 context.setException(
new KSException(
"CastingError", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
01276
return false;
01277 }
01278
01279
01280 context.setValue(
new KSValue( KSValue::ListType ) );
01281 context.setExtraData(
new KSValue(KSValue::ListType));
01282
01283 KSParseNode *right = node->branch2();
01284
if ( right )
01285
if ( !right->eval( context ) )
01286
return false;
01287
01288
01289 KSSubScope* scope = context.scope()->popLocalScope();
01290
KSModule* module = context.scope()->popModule();
01291
01292
bool b = FALSE;
01293
if ( l.value()->cast( KSValue::FunctionType ) )
01294 {
01295 context.scope()->pushModule( l.value()->functionValue()->module() );
01296
01297 b = l.value()->functionValue()->call( context );
01298 context.scope()->popModule();
01299 }
01300
else if ( l.value()->cast( KSValue::StructClassType ) )
01301 {
01302 context.scope()->pushModule( l.value()->structClassValue()->module() );
01303
01304 b = l.value()->structClassValue()->constructor( context );
01305 context.scope()->popModule();
01306 }
01307
else if ( l.value()->cast( KSValue::MethodType ) )
01308 {
01309 context.scope()->pushModule( l.value()->methodValue()->module() );
01310
01311 b = l.value()->methodValue()->call( context );
01312 context.scope()->popModule();
01313 }
01314
else
01315 Q_ASSERT( 0 );
01316
01317
01318 context.scope()->pushLocalScope( scope );
01319 context.scope()->pushModule( module );
01320
01321
if ( !b )
01322
return false;
01323
01324
01325
if ( !context.value() )
01326 context.setValue( KSValue::null() );
01327
01328
return true;
01329 }
01330
01331
bool KSEval_member_expr( KSParseNode* node, KSContext& context )
01332 {
01333 KSParseNode *left = node->branch1();
01334 Q_ASSERT( left );
01335
01336
01337 KSContext l( context );
01338
01339
if ( !left->eval( l ) )
01340 {
01341 context.setException( l );
01342
return false;
01343 }
01344
01351
if ( l.value()->type() == KSValue::FunctionType || l.value()->type() == KSValue::MethodType )
01352 {
01353
01354 KSContext func( context );
01355 func.setValue(
new KSValue( *l.value() ) );
01356
01357
01358 l.setValue(
new KSValue( KSValue::ListType ) );
01359
01360
01361 KSSubScope* scope = l.scope()->popLocalScope();
01362
KSModule* module = l.scope()->popModule();
01363
01364
bool b = FALSE;
01365
if ( func.value()->type() == KSValue::FunctionType )
01366 {
01367 l.scope()->pushModule( l.value()->functionValue()->module() );
01368
01369 b = func.value()->functionValue()->call( l );
01370 l.scope()->popModule();
01371 }
01372
else if ( func.value()->type() == KSValue::MethodType )
01373 {
01374 l.scope()->pushModule( l.value()->methodValue()->module() );
01375
01376 b = func.value()->methodValue()->call( l );
01377 l.scope()->popModule();
01378 }
01379
else
01380 Q_ASSERT( 0 );
01381
01382
01383 l.scope()->pushLocalScope( scope );
01384 l.scope()->pushModule( module );
01385
01386
if ( !b )
01387 {
01388 context.setException( l.exception() );
01389
return false;
01390 }
01391
01392
01393
if ( !l.value() )
01394 l.setValue( KSValue::null() );
01395 }
01398
01399
if ( l.value()->cast( KSValue::ModuleType ) )
01400 {
01401 KSValue::Ptr v = l.value()->
moduleValue()->
member( context, node->getIdent() );
01402
if ( !v )
01403 {
01404 context.exception()->addLine( node->getLineNo() );
01405
return false;
01406 }
01407
01408 context.setValue( v );
01409
01410
return true;
01411 }
01412
01413
else if ( l.value()->cast( KSValue::StructClassType ) )
01414 {
01415 KSValue::Ptr v = l.value()->
structClassValue()->member( context, node->getIdent() );
01416
if ( !v )
01417 {
01418 context.exception()->addLine( node->getLineNo() );
01419
return false;
01420 }
01421
01422 context.setValue( v );
01423
01424
return true;
01425 }
01426
01427 KSValue::Ptr v;
01428
KSModule* module;
01429
if ( l.value()->cast( KSValue::StructType ) )
01430 {
01431 v = l.value()->structValue()->
member( context, node->getIdent() );
01432 module = l.value()->structValue()->module();
01433 }
01434
01435
else
01436 {
01437
KSValue* v = context.object( node->getIdent() );
01438
if ( !v )
01439 {
01440 context.setException(
new KSException(
"UnknownName", node->getIdent(), node->getLineNo() ) );
01441
return false;
01442 }
01443
if ( v->
type() != KSValue::FunctionType )
01444 {
01445
KSUtil::castingError( context, v, KSValue::FunctionType );
01446
return false;
01447 }
01448 v->ref();
01449 context.setValue(
new KSValue(
new KSMethod( context.scope()->module(), l.shareValue(), v ) ) );
01450
return true;
01451 }
01452
01453
01454
01455
01456
01457
01458
01459
01460
if ( !v )
01461 {
01462 context.exception()->addLine( node->getLineNo() );
01463
return false;
01464 }
01465
01466
if ( v->
type() == KSValue::FunctionType )
01467 context.setValue(
new KSValue(
new KSMethod( module, l.shareValue(), v ) ) );
01468
else if ( v->
type() == KSValue::StructBuiltinMethodType )
01469 context.setValue(
new KSValue(
new KSMethod( module, l.shareValue(), v, node->getIdent() ) ) );
01470
else
01471 context.setValue( v );
01472
01473
return true;
01474 }
01475
01476
bool KSEval_t_array_const( KSParseNode* node, KSContext& context )
01477 {
01478 context.setValue(
new KSValue( KSValue::ListType ) );
01479
01480 KSParseNode *right = node->branch1();
01481
if ( !right )
01482
return true;
01483
01484
if ( !right->eval( context ) )
01485
return false;
01486
01487
return true;
01488 }
01489
01490
bool KSEval_t_array_element( KSParseNode* node, KSContext& context )
01491 {
01492 KSParseNode *left = node->branch1();
01493
if ( !left )
01494
return true;
01495
01496 KSContext l( context );
01497
if ( !left->eval( l ) )
01498 {
01499 context.setException( l );
01500
return false;
01501 }
01502
01503
if ( l.value()->mode() == KSValue::Temp )
01504 {
01505 l.value()->ref();
01506 context.value()->listValue().append( KSValue::Ptr( l.value() ) );
01507 }
01508
else
01509 {
01510 KSValue::Ptr v(
new KSValue );
01511 v->suck( l.value() );
01512 context.value()->listValue().append( v );
01513 }
01514
01515 KSParseNode *right = node->branch2();
01516
if ( !right )
01517
return true;
01518
01519
if ( !right->eval( context ) )
01520
return false;
01521
01522
return true;
01523 }
01524
01525
bool KSEval_t_dict_const( KSParseNode* node, KSContext& context )
01526 {
01527 context.setValue(
new KSValue( KSValue::MapType ) );
01528
01529 KSParseNode *right = node->branch1();
01530
if ( !right )
01531
return true;
01532
01533
if ( !right->eval( context ) )
01534
return false;
01535
01536
return true;
01537 }
01538
01539
bool KSEval_t_dict_element( KSParseNode* node, KSContext& context )
01540 {
01541 EVAL_OPS( context, l, r,
false );
01542
01543
if ( !l.value()->cast( KSValue::StringType ) )
01544 {
01545
QString tmp( i18n(
"From %1 to String") );
01546 context.setException(
new KSException(
"CastingError", tmp.arg( r.value()->typeName() ), node->getLineNo() ) );
01547
return false;
01548 }
01549
01550
if ( r.value()->mode() == KSValue::Temp )
01551 {
01552 r.value()->ref();
01553 context.value()->mapValue().insert( l.value()->stringValue(), KSValue::Ptr( r.value() ) );
01554 }
01555
else
01556 {
01557 KSValue::Ptr v(
new KSValue );
01558 v->suck( r.value() );
01559 context.value()->mapValue().insert( l.value()->stringValue(), v );
01560 }
01561
01562 KSParseNode *next = node->branch3();
01563
if ( !next )
01564
return true;
01565
01566
if ( !next->eval( context ) )
01567
return false;
01568
01569
return true;
01570 }
01571
01572
bool KSEval_t_while( KSParseNode* node, KSContext& context )
01573 {
01574
do
01575 {
01576 EVAL_LEFT_OP( context, l );
01577
01578
if ( !l.value()->implicitCast( KSValue::BoolType ) )
01579 {
01580
QString tmp( i18n(
"From %1 to Boolean") );
01581 context.setException(
new KSException(
"CastingError", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
01582
return false;
01583 }
01584
01585
01586
if ( !l.value()->boolValue() )
01587
return true;
01588
01589
01590 EVAL_RIGHT_OP( context, r );
01591 }
while( 1 );
01592
01593
01594
return false;
01595 }
01596
01597
bool KSEval_t_do( KSParseNode* node, KSContext& context )
01598 {
01599
do
01600 {
01601
01602
if ( !node->branch1()->eval( context ) )
01603
return false;
01604
01605
01606
if ( !node->branch2()->eval( context ) )
01607
return false;
01608
01609
if ( !context.value()->cast( KSValue::BoolType ) )
01610 {
01611
KSUtil::castingError( context, context.value(), KSValue::BoolType );
01612
return false;
01613 }
01614
01615
01616
if ( !context.value()->boolValue() )
01617
return true;
01618
01619 }
while( 1 );
01620
01621
01622
return false;
01623 }
01624
01625
bool KSEval_t_for( KSParseNode* node, KSContext& context )
01626 {
01627
01628
if ( !node->branch1()->eval( context ) )
01629
return false;
01630
01631
do
01632 {
01633
01634
if ( !node->branch2()->eval( context ) )
01635
return false;
01636
01637
if ( !context.value()->cast( KSValue::BoolType ) )
01638 {
01639
KSUtil::castingError( context, context.value(), KSValue::BoolType );
01640
return false;
01641 }
01642
01643
01644
if ( !context.value()->boolValue() )
01645
return true;
01646
01647
01648
if ( !node->branch4()->eval( context ) )
01649
return false;
01650
01651
01652
if ( !node->branch3()->eval( context ) )
01653
return false;
01654
01655 }
while(1);
01656
01657
01658
return false;
01659 }
01660
01661
bool KSEval_t_if( KSParseNode* node, KSContext& context )
01662 {
01663
01664
if ( !node->branch1()->eval( context ) )
01665
return false;
01666
01667
if ( !context.value()->cast( KSValue::BoolType ) )
01668 {
01669
KSUtil::castingError( context, context.value(), KSValue::BoolType );
01670
return false;
01671 }
01672
01673
01674
if ( !context.value()->boolValue() )
01675 {
01676
if ( node->branch3() )
01677
return node->branch3()->eval( context );
01678
return true;
01679 }
01680
01681
return node->branch2()->eval( context );
01682 }
01683
01684
bool KSEval_t_incr( KSParseNode* node, KSContext& context )
01685 {
01686
01687
if ( !node->branch1()->eval( context ) )
01688
return false;
01689
01690
if ( !
KSUtil::checkType( context, context.value(), KSValue::IntType,
true ) )
01691
return false;
01692
01693
if ( context.value()->mode() != KSValue::LeftExpr )
01694 {
01695 context.setException(
new KSException(
"NoLeftExpr", i18n(
"Expected a left expression in assignment"), node->getLineNo() ) );
01696
return false;
01697 }
01698
01699
01700
if ( node->branch2() )
01701 {
01702 KSValue::Ptr p = context.shareValue();
01703 KScript::Long l = p->intValue();
01704 p->setValue( p->intValue() + 1 );
01705 context.setValue(
new KSValue( l ) );
01706 context.value()->setMode( KSValue::Temp );
01707 }
01708
else
01709 context.value()->setValue( context.value()->intValue() + 1 );
01710
01711
return true;
01712 }
01713
01714
bool KSEval_t_decr( KSParseNode* node, KSContext& context )
01715 {
01716
01717
if ( !node->branch1()->eval( context ) )
01718
return false;
01719
01720
if ( !
KSUtil::checkType( context, context.value(), KSValue::IntType,
true ) )
01721
return false;
01722
01723
if ( context.value()->mode() != KSValue::LeftExpr )
01724 {
01725 context.setException(
new KSException(
"NoLeftExpr", i18n(
"Expected a left expression in assignment."), node->getLineNo() ) );
01726
return false;
01727 }
01728
01729
01730
if ( node->branch2() )
01731 {
01732 KSValue::Ptr p = context.shareValue();
01733 KScript::Long l = p->intValue();
01734 p->setValue( p->intValue() - 1 );
01735 context.setValue(
new KSValue( l ) );
01736 context.value()->setMode( KSValue::Temp );
01737 }
01738
else
01739 context.value()->setValue( context.value()->intValue() - 1 );
01740
01741
return true;
01742 }
01743
01744
bool KSEval_t_less( KSParseNode* node, KSContext& context )
01745 {
01746 EVAL_OPS( context, l, r,
false );
01747
01748
if ( !
KSUtil::checkType( context, r.value(), l.value()->type(),
true ) )
01749
return false;
01750
01751
switch( l.value()->type() )
01752 {
01753
case KSValue::IntType:
01754 {
01755 KScript::Boolean result = l.value()->intValue() < r.value()->intValue();
01756 FILL_VALUE( context, l, r );
01757 context.value()->setValue( result );
01758
return true;
01759 }
01760
case KSValue::DoubleType:
01761 {
01762 KScript::Boolean result = l.value()->doubleValue() < r.value()->doubleValue();
01763 FILL_VALUE( context, l, r );
01764 context.value()->setValue( result );
01765
return true;
01766 }
01767
case KSValue::StringType:
01768 {
01769 KScript::Boolean result = l.value()->stringValue() < r.value()->stringValue();
01770 FILL_VALUE( context, l, r );
01771 context.value()->setValue( result );
01772
return true;
01773 }
01774
case KSValue::DateType:
01775 {
01776 KScript::Boolean result = l.value()->dateValue() < r.value()->dateValue();
01777 FILL_VALUE( context, l, r );
01778 context.value()->setValue( result );
01779
return true;
01780 }
01781
case KSValue::TimeType:
01782 {
01783 KScript::Boolean result = l.value()->timeValue() < r.value()->timeValue();
01784 FILL_VALUE( context, l, r );
01785 context.value()->setValue( result );
01786
return true;
01787 }
01788
case KSValue::CharType:
01789 {
01790 KScript::Boolean result = l.value()->charValue() < r.value()->charValue();
01791 FILL_VALUE( context, l, r );
01792 context.value()->setValue( result );
01793
return true;
01794 }
01795
default:
01796
QString tmp( i18n(
"Operator < not defined for type %1") );
01797 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
01798
return false;
01799 }
01800
01801
01802
return false;
01803 }
01804
01805
bool KSEval_t_greater( KSParseNode* node, KSContext& context )
01806 {
01807 EVAL_OPS( context, l, r,
false );
01808
01809
if ( !
KSUtil::checkType( context, r.value(), l.value()->type(),
true ) )
01810
return false;
01811
01812
switch( l.value()->type() )
01813 {
01814
case KSValue::IntType:
01815 {
01816 KScript::Boolean result = l.value()->intValue() > r.value()->intValue();
01817 FILL_VALUE( context, l, r );
01818 context.value()->setValue( result );
01819
return true;
01820 }
01821
case KSValue::DoubleType:
01822 {
01823 KScript::Boolean result = l.value()->doubleValue() > r.value()->doubleValue();
01824 FILL_VALUE( context, l, r );
01825 context.value()->setValue( result );
01826
return true;
01827 }
01828
case KSValue::StringType:
01829 {
01830 KScript::Boolean result = l.value()->stringValue() > r.value()->stringValue();
01831 FILL_VALUE( context, l, r );
01832 context.value()->setValue( result );
01833
return true;
01834 }
01835
case KSValue::CharType:
01836 {
01837 KScript::Boolean result = l.value()->charValue() > r.value()->charValue();
01838 FILL_VALUE( context, l, r );
01839 context.value()->setValue( result );
01840
return true;
01841 }
01842
case KSValue::DateType:
01843 {
01844 KScript::Boolean result = l.value()->dateValue() > r.value()->dateValue();
01845 FILL_VALUE( context, l, r );
01846 context.value()->setValue( result );
01847
return true;
01848 }
01849
case KSValue::TimeType:
01850 {
01851 KScript::Boolean result = l.value()->timeValue() > r.value()->timeValue();
01852 FILL_VALUE( context, l, r );
01853 context.value()->setValue( result );
01854
return true;
01855 }
01856
default:
01857
QString tmp( i18n(
"Operator > not defined for type %1") );
01858 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
01859
return false;
01860 }
01861
01862
01863
return false;
01864 }
01865
01866
01867
bool KSEval_t_foreach( KSParseNode* node, KSContext& context )
01868 {
01869
01870
if ( !node->branch1()->eval( context ) )
01871
return false;
01872
01873
01874 KSValue::Mode mode = context.value()->mode();
01875
01876
01877
if ( node->branch3() )
01878 {
01879
if ( !context.value()->cast( KSValue::MapType ) )
01880 {
01881
KSUtil::castingError( context, context.value(), KSValue::MapType );
01882
return false;
01883 }
01884
01885
KSNamespace nspace;
01886 context.scope()->localScope()->pushNamespace( &nspace );
01887
01888
QMap<QString,KSValue::Ptr>::Iterator it = context.value()->mapValue().begin();
01889
QMap<QString,KSValue::Ptr>::Iterator end = context.value()->mapValue().end();
01890
for( ; it != end; ++it )
01891 {
01892
01893 it.data()->ref();
01894
KSValue* v = it.data();
01895
01896 v->
setMode( mode );
01897 context.scope()->addObject( node->getStringLiteral(), v );
01898
01899
01900 v =
new KSValue( it.key() );
01901 v->
setMode( KSValue::Constant );
01902 context.scope()->addObject( node->getIdent(), v );
01903
01904
01905 KSContext ctx( context );
01906
if ( !node->branch2()->eval( ctx ) )
01907 {
01908 context.setException( ctx );
01909 context.scope()->localScope()->popNamespace();
01910
return false;
01911 }
01912 }
01913
01914 context.scope()->localScope()->popNamespace();
01915 }
01916
else
01917 {
01918
if ( !context.value()->cast( KSValue::ListType ) )
01919 {
01920
KSUtil::castingError( context, context.value(), KSValue::ListType );
01921
return false;
01922 }
01923
01924
KSNamespace nspace;
01925 context.scope()->localScope()->pushNamespace( &nspace );
01926
01927
QValueList<KSValue::Ptr>::Iterator it = context.value()->listValue().begin();
01928
QValueList<KSValue::Ptr>::Iterator end = context.value()->listValue().end();
01929
for( ; it != end; ++it )
01930 {
01931
01932 (*it)->ref();
01933
KSValue* v = (*it);
01934
01935 v->
setMode( mode );
01936 context.scope()->addObject( node->getIdent(), v );
01937
01938
01939 KSContext ctx( context );
01940
if ( !node->branch2()->eval( ctx ) )
01941 {
01942 context.setException( ctx );
01943 context.scope()->localScope()->popNamespace();
01944
return false;
01945 }
01946 }
01947
01948 context.scope()->localScope()->popNamespace();
01949 }
01950
01951
return true;
01952 }
01953
01954
bool KSEval_t_match( KSParseNode* node , KSContext& context )
01955 {
01956
if ( !node->branch1()->eval( context ) )
01957
return false;
01958
01959
if ( !
KSUtil::checkType( context, context.value(), KSValue::StringType, TRUE ) )
01960
return FALSE;
01961
01962 KRegExp* exp = context.interpreter()->regexp();
01963 exp->compile( node->getIdent().latin1() );
01964
01965 kdDebug() <<
"Matching " << context.value()->stringValue() <<
" against " << node->getIdent() << endl;
01966
01967 context.setValue(
new KSValue( exp->match( context.value()->stringValue().latin1() ) ) );
01968
01969
return TRUE;
01970 }
01971
01972
bool KSEval_t_subst( KSParseNode* node, KSContext& context )
01973 {
01974 KSContext l( context, TRUE );
01975
if ( !node->branch1()->eval( l ) )
01976
return false;
01977
01978
if ( l.value()->mode() != KSValue::LeftExpr )
01979 {
01980 context.setException(
new KSException(
"NoLeftExpr", i18n(
"Expected a left expression in substitute."), node->getLineNo() ) );
01981
return false;
01982 }
01983
01984
if ( !
KSUtil::checkType( l, l.value(), KSValue::StringType, TRUE ) )
01985
return FALSE;
01986
01987
int pos = node->getIdent().find(
'/' );
01988 Q_ASSERT( pos != -1 );
01989
QString match = node->getIdent().left( pos );
01990
QString subst = node->getIdent().mid( pos + 1 );
01991 KRegExp* exp = context.interpreter()->regexp();
01992 exp->compile( match.latin1() );
01993
01994 kdDebug() <<
"Matching " << l.value()->stringValue() <<
" against " << node->getIdent() << endl;
01995
01996
if ( !exp->match( l.value()->stringValue().latin1() ) )
01997 {
01998 context.setValue(
new KSValue( FALSE ) );
01999
return TRUE;
02000 }
02001
else
02002 {
02003
int len = subst.length();
02004
int i = 0;
02005
while( i < len )
02006 {
02007
if ( subst[i] ==
'\\' && i + 1 < len && subst[i+1].isDigit() )
02008 {
02009
const char* grp = exp->group( subst[i+1].latin1() -
'0' );
02010
QString repl;
02011
if ( grp )
02012 repl = grp;
02013
else
02014 repl =
"";
02015 subst.replace( i, 2, repl );
02016 len += repl.length() + 1;
02017 i += repl.length();
02018 }
02019
else
02020 ++i;
02021 }
02022
QString& str = l.value()->stringValue();
02023 str.replace( exp->groupStart( 0 ), exp->groupEnd( 0 ) - exp->groupStart( 0 ), subst );
02024 }
02025
02026 context.setValue(
new KSValue( TRUE ) );
02027
return TRUE;
02028 }
02029
02030
bool KSEval_t_not( KSParseNode* node, KSContext& context )
02031 {
02032
if ( !node->branch1()->eval( context ) )
02033
return false;
02034
02035
if ( !context.value()->cast( KSValue::BoolType ) )
02036 {
02037
QString tmp( i18n(
"Unary Operator ! not defined for type %1") );
02038 context.setException(
new KSException(
"UnknownOperation", tmp.arg( context.value()->typeName() ), node->getLineNo() ) );
02039
return false;
02040 }
02041
02042 context.setValue(
new KSValue( !( context.value()->boolValue() ) ) );
02043
return true;
02044 }
02045
02046
bool KSEval_func_call_params( KSParseNode* node, KSContext& context )
02047 {
02048
02049 KSParseNode *left = node->branch1();
02050
if ( !left )
02051
return true;
02052
02053 KSContext l( context );
02054
if ( !left->eval( l ) )
02055 {
02056 context.setException( l );
02057
return false;
02058 }
02059
02060 context.value()->listValue().append( l.shareValue() );
02061
02062
if (left->getType() == t_cell || left->getType() == t_range)
02063 {
02064 context.extraData()->listValue().append(
new KSValue(left->getStringLiteral()));
02065 }
02066
else
02067 {
02068 context.extraData()->listValue().append(
new KSValue());
02069 }
02070
02071
02072 KSParseNode *right = node->branch2();
02073
if ( right )
02074
if ( !right->eval( context ) )
02075
return false;
02076
02077
return true;
02078 }
02079
02080
bool KSEval_t_return( KSParseNode* node, KSContext& context )
02081 {
02082
02083 KSParseNode *left = node->branch1();
02084
if ( left )
02085 {
02086
if ( !left->eval( context ) )
02087 {
02088 context.setException( context );
02089
return false;
02090 }
02091
02092
02093
if ( context.value()->mode() == KSValue::LeftExpr )
02094 {
02095
KSValue* v =
new KSValue( *context.value() );
02096 context.
setValue( v );
02097 }
02098 }
02099
02100
else
02101 {
02102
02103 context.setValue(
new KSValue() );
02104 }
02105
02106 context.setReturnFlag();
02107
02108
return true;
02109 }
02110
02111
bool KSEval_destructor_dcl( KSParseNode* node, KSContext& context )
02112 {
02113
02114
KSNamespace nspace;
02115 KSSubScope scope( &nspace );
02116 context.scope()->pushLocalScope( &scope );
02117
02118
02119
if ( node->branch1() )
02120
if ( !node->branch1()->eval( context ) )
02121 {
02122 context.scope()->popLocalScope();
02123
return false;
02124 }
02125
02126
02127
if ( !context.value()->listValue().isEmpty() )
02128 {
02129
const QString tmp( i18n(
"1 argument is not needed",
"%n arguments are not needed", context.value()->listValue().count() ) );
02130 context.setException(
new KSException(
"TooManyArguments", tmp, node->getLineNo() ) );
02131 context.scope()->popLocalScope();
02132
return false;
02133 }
02134
02135
02136
if ( node->branch2() )
02137
if ( !node->branch2()->eval( context ) )
02138 {
02139 context.scope()->popLocalScope();
02140
return false;
02141 }
02142
02143 context.scope()->popLocalScope();
02144
return true;
02145 }
02146
02147
bool KSEval_import( KSParseNode* node, KSContext& context )
02148 {
02149
02150
02151
02152 KSContext d( context );
02153
02154
if ( !context.interpreter()->runModule( d, node->getIdent() ) )
02155 {
02156 context.setException( d );
02157
return false;
02158 }
02159
02160
02161 context.scope()->addObject( node->getIdent(), d.shareValue() );
02162
02163
return true;
02164 }
02165
02166
bool KSEval_t_struct( KSParseNode* node, KSContext& context )
02167 {
02168 KSStructClass* p;
02169
02170
02171 context.setValue(
new KSValue( ( p =
new KSStructClass( context.scope()->module(), node->getIdent() ) ) ) );
02172 context.scope()->addObject( node->getIdent(), context.shareValue() );
02173
02174 KSParseNode *left = node->branch1();
02175
if ( left )
02176
if ( !left->eval( context ) )
02177
return false;
02178
02179 context.setValue( 0 );
02180
02181
return true;
02182 }
02183
02184
bool KSEval_t_struct_members( KSParseNode* node, KSContext& context )
02185 {
02186 Q_ASSERT( context.value() && context.value()->type() == KSValue::StructClassType );
02187
02188 context.value()->structClassValue()->addVariable( node->getIdent() );
02189
02190
02191
if ( node->branch1() )
02192
if ( !node->branch1()->eval( context ) )
02193
return false;
02194
02195
return true;
02196 }
02197
02198
extern bool KSEval_t_qualified_names( KSParseNode* node, KSContext& context )
02199 {
02200 Q_ASSERT( context.value() && context.value()->type() == KSValue::ListType );
02201
02202 KSParseNode *left = node->branch1();
02203
if ( !left )
02204
return true;
02205
02206 KSContext l( context );
02207
if ( !left->eval( l ) )
02208 {
02209 context.setException( l );
02210
return false;
02211 }
02212
02213 context.value()->listValue().append( l.shareValue() );
02214
02215 KSParseNode *right = node->branch2();
02216
if ( !right )
02217
return true;
02218
02219
if ( !right->eval( context ) )
02220
return false;
02221
02222
return true;
02223 }
02224
02225
extern bool KSEval_t_scope( KSParseNode* node, KSContext& context )
02226 {
02227 KSParseNode *left = node->branch1();
02228
02229
if ( !left )
02230
return TRUE;
02231
02232
KSNamespace nspace;
02233 context.scope()->localScope()->pushNamespace( &nspace );
02234
02235
bool res = left->eval( context );
02236
02237 context.scope()->localScope()->popNamespace();
02238
02239
return res;
02240 }
02241
02242
extern bool KSEval_t_try( KSParseNode* node, KSContext& context )
02243 {
02244
KSNamespace nspace;
02245 context.scope()->localScope()->pushNamespace( &nspace );
02246
02247
02248 KSParseNode *left = node->branch1();
02249 Q_ASSERT( left );
02250
02251
if ( left->eval( context ) )
02252 {
02253 context.scope()->localScope()->popNamespace();
02254
return true;
02255 }
02256
02257
02258
02259 context.scope()->localScope()->popNamespace();
02260
02261
02262 KSParseNode *right = node->branch2();
02263 Q_ASSERT( right );
02264
return right->eval( context );
02265 }
02266
02267
extern bool KSEval_t_catch( KSParseNode* node, KSContext& context )
02268 {
02269 KSContext d( context );
02270
02271
02272 KSParseNode *left = node->branch1();
02273 Q_ASSERT( left );
02274
if ( !left->eval( d ) )
02275 {
02276 context.setException( d );
02277
return false;
02278 }
02279
02280
02281 Q_ASSERT( context.exception() );
02282
if ( context.exception()->type()->cmp( *d.value() ) )
02283 {
02284
02285
KSValue* value = context.exception()->value();
02286 value->ref();
02287
02288
02289
KSNamespace nspace;
02290 nspace.insert( node->getIdent(),
new KSValue( *value ) );
02291 context.scope()->localScope()->pushNamespace( &nspace );
02292
02293
02294 context.setException( 0 );
02295
02296
02297 KSParseNode *right = node->branch2();
02298 Q_ASSERT( right );
02299
02300 right->eval( context );
02301
02302
02303 context.scope()->localScope()->popNamespace();
02304
02305
return true;
02306 }
02307
02308
02309 KSParseNode* more = node->branch4();
02310
if ( more )
02311
return more->eval( context );
02312
02313
02314
return false;
02315 }
02316
02317
extern bool KSEval_t_catch_default( KSParseNode* node, KSContext& context )
02318 {
02319 KSContext d( context );
02320
02321
02322
02323 KSParseNode *left = node->branch1();
02324 Q_ASSERT( left );
02325
QString name1 = left->getIdent();
02326
02327
02328
KSValue* type = context.exception()->type();
02329 type->ref();
02330
KSValue* value = context.exception()->value();
02331 value->ref();
02332 context.setException( 0 );
02333
02334
02335
KSNamespace nspace;
02336 nspace.insert( name1,
new KSValue( *type ) );
02337 nspace.insert( node->getIdent(),
new KSValue( *value ) );
02338 context.scope()->localScope()->pushNamespace( &nspace );
02339
02340
02341 KSParseNode *right = node->branch2();
02342 Q_ASSERT( right );
02343
bool res = right->eval( context );
02344
02345 context.scope()->localScope()->popNamespace();
02346
02347
return res;
02348 }
02349
02350
extern bool KSEval_t_raise( KSParseNode* node, KSContext& context )
02351 {
02352 EVAL_OPS( context, l, r,
false );
02353
02354
02355 context.setException(
new KSException( l.shareValue(), r.shareValue(), node->getLineNo() ) );
02356
02357
return false;
02358 }
02359
02360
extern bool KSEval_t_cell( KSParseNode* node, KSContext& context )
02361 {
02362
return context.interpreter()->processExtension( context, node );
02363 }
02364
02365
extern bool KSEval_t_range( KSParseNode* node, KSContext& context )
02366 {
02367
return context.interpreter()->processExtension( context, node );
02368 }
02369
02370
extern bool KSEval_from( KSParseNode* node, KSContext& context )
02371 {
02372
02373
QStringList lst = QStringList::split(
"/", node->getStringLiteral() );
02374
02375 KSContext d( context );
02376
02377
if ( !context.interpreter()->runModule( d, node->getIdent(), node->getIdent() +
".ks",
QStringList() ) )
02378 {
02379 context.setException( d );
02380
return false;
02381 }
02382
02383
02384 context.scope()->addObject( node->getIdent(), d.shareValue() );
02385
02386
02387
02388
if ( lst.isEmpty() )
02389 {
02390
02391 KSNamespace::Iterator it = d.value()->moduleValue()->nameSpace()->begin();
02392 KSNamespace::Iterator end = d.value()->moduleValue()->nameSpace()->end();
02393
for(; it != end; ++it )
02394 context.scope()->module()->addObject( it.key(), it.data() );
02395 }
02396
02397
else
02398 {
02399
02400
KSModule* m = d.value()->moduleValue();
02401
02402
02403 QStringList::ConstIterator sit = lst.begin();
02404
for( ; sit != lst.end(); ++sit )
02405 {
02406
02407
KSValue* v = m->
object( *sit );
02408
if ( !v )
02409 {
02410
QString tmp( i18n(
"The module %1 does not contain a symbol named %2") );
02411 context.setException(
new KSException(
"SymbolUnknown",
02412 tmp.arg( node->getIdent() ).arg( *sit ),
02413 node->getLineNo() ) );
02414
return false;
02415 }
02416
02417
02418 v->ref();
02419 context.scope()->module()->addObject( *sit, v );
02420 }
02421 }
02422
02423
return TRUE;
02424 }
02425
02426
bool KSEval_plus_assign( KSParseNode* node, KSContext& context )
02427 {
02428 EVAL_OPS( context, l, r,
true );
02429
02430
if ( l.value()->mode() != KSValue::LeftExpr )
02431 {
02432 context.setException(
new KSException(
"NoLeftExpr", i18n(
"Expected a left expression in assignment."), node->getLineNo() ) );
02433
return false;
02434 }
02435
02436
if ( l.value()->type() == KSValue::TimeType )
02437 {
02438
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
02439
return false;
02440
QTime t = l.value()->timeValue();
02441 t = t.addSecs( r.value()->intValue() );
02442 l.value()->setValue( t );
02443 }
02444
else if ( l.value()->type() == KSValue::DateType )
02445 {
02446
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
02447
return false;
02448
QDate d = l.value()->dateValue();
02449 d = d.addDays( r.value()->intValue() );
02450 l.value()->setValue( d );
02451 }
02452
else if ( !
KSUtil::checkType( context, l.value(), r.value()->type(),
true ) )
02453
return false;
02454
02455
switch( l.value()->type() )
02456 {
02457
case KSValue::IntType:
02458 l.value()->setValue( r.value()->intValue() + l.value()->intValue() );
02459
break;
02460
case KSValue::DoubleType:
02461 l.value()->setValue( r.value()->doubleValue() + l.value()->doubleValue() );
02462
break;
02463
case KSValue::StringType:
02464 l.value()->setValue( l.value()->stringValue() + r.value()->stringValue() );
02465
break;
02466
case KSValue::ListType:
02467 l.value()->setValue( l.value()->listValue() + r.value()->listValue() );
02468
break;
02469
case KSValue::MapType:
02470 {
02471
QMap<QString,KSValue::Ptr>& map = l.value()->mapValue();
02472
QMap<QString,KSValue::Ptr>::ConstIterator it = r.value()->mapValue().begin();
02473
QMap<QString,KSValue::Ptr>::ConstIterator end = r.value()->mapValue().end();
02474
for( ; it != end; ++it )
02475 map.insert( it.key(), it.data() );
02476 }
02477
break;
02478
case KSValue::TimeType:
02479
case KSValue::DateType:
02480
02481
break;
02482
default:
02483
QString tmp( i18n(
"Operator += not defined for type %1") );
02484 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
02485
return false;
02486 }
02487
02488 l.value()->setMode( KSValue::LeftExpr );
02489
02490 context.setValue( l.shareValue() );
02491
02492
return TRUE;
02493 }
02494
02495
bool KSEval_minus_assign( KSParseNode* node, KSContext& context )
02496 {
02497 EVAL_OPS( context, l, r,
true );
02498
02499
if ( l.value()->mode() != KSValue::LeftExpr )
02500 {
02501 context.setException(
new KSException(
"NoLeftExpr", i18n(
"Expected a left expression in assignment."), node->getLineNo() ) );
02502
return false;
02503 }
02504
02505
if ( l.value()->type() == KSValue::TimeType )
02506 {
02507
if (
KSUtil::checkType( context, r.value(), KSValue::TimeType,
false ) )
02508 {
02509
QTime d = r.value()->timeValue();
02510
int diff = d.secsTo( l.value()->timeValue() );
02511 l.value()->setValue( (KScript::Long)diff );
02512 }
02513
else
02514 {
02515
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
02516
return false;
02517
QTime t = l.value()->timeValue();
02518 t = t.addSecs( -r.value()->intValue() );
02519 l.value()->setValue( t );
02520 }
02521 }
02522
else if ( l.value()->type() == KSValue::DateType )
02523 {
02524
if (
KSUtil::checkType( context, r.value(), KSValue::DateType,
false ) )
02525 {
02526
QDate d = r.value()->dateValue();
02527
int diff = d.daysTo( l.value()->dateValue() );
02528 l.value()->setValue( (KScript::Long)diff );
02529 }
02530
else
02531 {
02532
if ( !
KSUtil::checkType( context, r.value(), KSValue::IntType,
true ) )
02533
return false;
02534
QDate d = l.value()->dateValue();
02535 d = d.addDays( -r.value()->intValue() );
02536 l.value()->setValue( d );
02537 }
02538 }
02539
else if ( !
KSUtil::checkType( context, l.value(), r.value()->type(),
true ) )
02540
return false;
02541
else
02542 {
02543
switch( l.value()->type() )
02544 {
02545
case KSValue::IntType:
02546 l.value()->setValue( r.value()->intValue() + l.value()->intValue() );
02547
break;
02548
case KSValue::DoubleType:
02549 l.value()->setValue( r.value()->doubleValue() + l.value()->doubleValue() );
02550
break;
02551
case KSValue::StringType:
02552 l.value()->setValue( l.value()->stringValue() + r.value()->stringValue() );
02553
break;
02554
case KSValue::ListType:
02555 l.value()->setValue( l.value()->listValue() + r.value()->listValue() );
02556
break;
02557
case KSValue::MapType:
02558 {
02559
QMap<QString,KSValue::Ptr>& map = l.value()->mapValue();
02560
QMap<QString,KSValue::Ptr>::ConstIterator it = r.value()->mapValue().begin();
02561
QMap<QString,KSValue::Ptr>::ConstIterator end = r.value()->mapValue().end();
02562
for( ; it != end; ++it )
02563 map.insert( it.key(), it.data() );
02564 }
02565
break;
02566
case KSValue::TimeType:
02567
case KSValue::DateType:
02568
02569
break;
02570
default:
02571
QString tmp( i18n(
"Operator += not defined for type %1") );
02572 context.setException(
new KSException(
"UnknownOperation", tmp.arg( l.value()->typeName() ), node->getLineNo() ) );
02573
return false;
02574 }
02575 }
02576
02577 l.value()->setMode( KSValue::LeftExpr );
02578
02579 context.setValue( l.shareValue() );
02580
02581
return TRUE;
02582 }
02583
02584
bool KSEval_bool_or( KSParseNode* node, KSContext& context )
02585 {
02586 EVAL_OPS( context, l, r,
false );
02587
02588
if ( !
KSUtil::checkType( context, l.value(), KSValue::BoolType,
true ) ||
02589 !
KSUtil::checkType( context, r.value(), KSValue::BoolType,
true ) )
02590 {
02591 context.exception()->addLine( node->getLineNo() );
02592
return false;
02593 }
02594
02595 context.setValue(
new KSValue( (KScript::Boolean)( l.value()->boolValue() || r.value()->boolValue() ) ) );
02596
02597
return true;
02598 }
02599
02600
bool KSEval_bool_and( KSParseNode* node, KSContext& context )
02601 {
02602 EVAL_OPS( context, l, r,
false );
02603
02604
if ( !
KSUtil::checkType( context, l.value(), KSValue::BoolType,
true ) ||
02605 !
KSUtil::checkType( context, r.value(), KSValue::BoolType,
true ) )
02606 {
02607 context.exception()->addLine( node->getLineNo() );
02608
return false;
02609 }
02610
02611 context.setValue(
new KSValue( (KScript::Boolean)( l.value()->boolValue() && r.value()->boolValue() ) ) );
02612
02613
return true;
02614 }
02615
02616
bool KSEval_t_regexp_group( KSParseNode* node, KSContext& context )
02617 {
02618 KRegExp* exp = context.interpreter()->regexp();
02619
const char* grp = exp->group( node->getIntegerLiteral() );
02620
if ( grp )
02621 context.setValue(
new KSValue(
QString( grp ) ) );
02622
else
02623 context.setValue(
new KSValue(
QString(
"" ) ) );
02624
02625
return TRUE;
02626 }
02627
02628
bool KSEval_t_input( KSParseNode*, KSContext& context )
02629 {
02630 context.setValue(
new KSValue( context.interpreter()->readInput() ) );
02631
02632
return TRUE;
02633 }
02634
02635
bool KSEval_t_line( KSParseNode* , KSContext& context )
02636 {
02637 context.setValue( context.interpreter()->lastInputLine() );
02638
02639
return TRUE;
02640 }
02641
02642
bool KSEval_t_match_line( KSParseNode* node, KSContext& context )
02643 {
02644 KSValue::Ptr line = context.interpreter()->lastInputLine();
02645
if ( !
KSUtil::checkType( context, line, KSValue::StringType, TRUE ) )
02646
return FALSE;
02647
02648 KRegExp* exp = context.interpreter()->regexp();
02649 exp->compile( node->getIdent().latin1() );
02650
02651 context.setValue(
new KSValue( exp->match( line->stringValue().latin1() ) ) );
02652
02653
return TRUE;
02654 }