~ubuntu-branches/debian/sid/kdevelop/sid

ExpressionEvaluation::ExpressionEvaluation( CppCodeCompletion* data, ExpressionInfo expr, OperatorSet& operators, const HashedStringSet& includeFiles, SimpleContext* ctx ) : m_data( data ), m_ctx( ctx ), m_expr( expr ), m_global(false), m_operators( operators ), m_includeFiles( includeFiles ) {

232

safetyCounter.init();

233

234

ifVerboseMajor( dbgMajor( ) << "Initializing evaluation of expression " << expr << endl );

235

236

if ( expr.expr().startsWith( "::" ) )

237

{

238

expr.setExpr( expr.expr().mid( 2 ) );

239

m_global = true;

240

}

241

242

//m_expr = m_data->splitExpression( expr.expr() ).join("");

243

}

244

245

EvaluationResult ExpressionEvaluation::evaluate() {

246

EvaluationResult res;

247

res = evaluateExpressionInternal( m_expr.expr(), m_ctx->global(), m_ctx, m_ctx, /*m_expr.canBeTypeExpression() cannot be safely determined*/true );

248

249

ExpressionInfo ex = res.expr; ///backup and set the type which was chosen while the evaluation-process

250

res.expr = m_expr;

251

res.expr.t = ex.t;

252

253

return res;

254

}

255

256

EvaluationResult ExpressionEvaluation::evaluateExpressionInternal( QString expr, EvaluationResult scope, SimpleContext * ctx, SimpleContext* innerCtx , bool canBeTypeExpression) {

257

LogDebug d( "#evl#" );

258

if( expr.isEmpty() || !safetyCounter ) {

259

scope.expr.t = ExpressionInfo::NormalExpression;

260

return scope;

261

}

262

263

/*if( !scope->resolved() ) {

264

ifVerboseMajor( dbgMajor() << "evaluateExpressionInternal(\"" << expr << "\") scope: \"" << scope->fullTypeStructure() << "\" is unresolved " << endl );

265

return EvaluationResult();

266

}*/

267

268

ifVerboseMajor( dbgMajor() << "evaluateExpressionInternal(\"" << expr << "\") scope: \"" << scope->fullNameChain() << "\" context: " << ctx << endl );

269

270

expr = expr.stripWhiteSpace();

271

272

///Find the rightmost operator with the lowest priority, for the first split.

273

QValueList<OperatorIdentification> idents;

274

for( uint a = 0; a < expr.length(); ++a ) {

275

QString part = expr.mid( a );

276

OperatorIdentification ident = m_operators.identifyOperator( part );

277

if( ident ) {

278

ifVerboseMajor( dbgMajor() << "identified \"" << ident.op->name() << "\" in string " << part << endl );

279

ident.start += a;

280

ident.end += a;

281

idents << ident;

282

a += ident.end;

283

} else {

284

if( isLeftParen( part[0] ) ) {

285

int jump = findClose( part, 0 );

286

if( jump != -1 )

287

a += jump;

288

}

289

}

290

}

291

292

if( !idents.isEmpty() ) {

293

OperatorIdentification lowest;

294

295

for( QValueList<OperatorIdentification>::iterator it = idents.begin(); it != idents.end(); ++it ) {

296

if( lowest ) {

297

if( lowest.op->priority() >= (*it).op->priority() )

298

lowest = *it;

299

} else {

300

lowest = *it;

301

}

302

}

303

304

if( lowest ) {

305

QString leftSide = expr.left( lowest.start ).stripWhiteSpace();

306

QString rightSide = expr.right( expr.length() - lowest.end ).stripWhiteSpace();

307

308

EvaluationResult left, right;

309

if( !leftSide.isEmpty() ) {

310

left = evaluateExpressionInternal( leftSide, scope, ctx, innerCtx, lowest.op->canBeType( Operator::Left ) );

311

} else {

312

left = scope;

313

}

314

315

if( !left && (lowest.op->binding() & Operator::Left) ) {

316

ifVerboseMajor( dbgMajor() << "problem while evaluating expression \"" << expr << "\", the operator \"" << lowest.op->name() << "\" has a binding to the left side, but no left side could be evaluated: \"" << leftSide << "\"" << endl );

317

}

318

319

if( !rightSide.isEmpty() && (lowest.op->binding() & Operator::Right) )

320

right = evaluateExpressionInternal( rightSide, SimpleType(), ctx, innerCtx, lowest.op->canBeType( Operator::Right ) );

321

322

if( !right && (lowest.op->binding() & Operator::Right) ) {

323

ifVerboseMajor( dbgMajor() << "problem while evaluating expression \"" << expr << "\", the operator \"" << lowest.op->name() << "\" has a binding to the right side, but no right side could be evaluated: \"" << rightSide << "\"" << endl );

324

}

325

326

QValueList<EvaluationResult> innerParams;

327

QValueList<EvaluationResult> params;

328

if( lowest.op->binding() & Operator::Left ) params << left;

329

if( lowest.op->binding() & Operator::Right ) params << right;

330

331

for( QValueList<QString>::iterator it = lowest.innerParams.begin(); it != lowest.innerParams.end(); ++it ) {

332

ifVerboseMajor(dbgMajor() << "evaluating inner parameter \"" + *it + "\"" );

333

innerParams << evaluateExpressionInternal( (*it), SimpleType(), innerCtx, innerCtx, lowest.op->canBeType( Operator::Neutral ) );

334

}

335

336

EvaluationResult applied = lowest.op->apply( params, innerParams );

337

if( !applied ) {

338

statusLog( "\"" + expr + "\": failed to apply the operator \"" + lowest.op->name() + "\"" );

339

}

340

341

if( ! (lowest.op->binding() & Operator::Left) && !leftSide.isEmpty() ) {

342

///When the operator has no binding to the left, the left side should be empty.

343

statusLog( "\"" + expr + "\": problem with the operator \"" + lowest.op->name() + ", it has no binding to the left side, but the left side is \""+ leftSide + "\"" );

344

}

345

346

if( ! (lowest.op->binding() & Operator::Right) && !rightSide.isEmpty() ) {

347

///When the operator has no binding to the right, we should continue evaluating the right side, using the left type as scope.

348

///Think about this.

349

return evaluateExpressionInternal( rightSide, applied, 0, innerCtx, lowest.op->canBeType( Operator::Right ) );

350

}

351

352

return applied;

353

} else {

354

ifVerboseMajor( dbgMajor() << " could not find an operator in " << expr << endl );

355

return evaluateAtomicExpression( expr, scope, ctx );

356

}

357

}

358

359

//dbgMajor() << " could not evaluate " << expr << endl;

360

ifVerboseMajor( dbgMajor() << "evaluating \"" << expr << "\" as atomic expression" << endl );

361

362

TypeDesc exp = m_ctx->container()->resolveTemplateParams( TypeDesc(expr) );

363

364

ifVerboseMajor( dbgMajor() << "after template-parameter resolution: \"" << exp.fullNameChain() << "\"" << endl );

365

366

EvaluationResult res = evaluateAtomicExpression( exp, scope, ctx, canBeTypeExpression );

367

return res;

368

}

369

370

/**This function needs a clean workover.

371

* An atomic expression is one that only consists of a type-, function- or variable-name(may include '::')

372

373

EvaluationResult ExpressionEvaluation::evaluateAtomicExpression( TypeDesc expr, EvaluationResult scope, SimpleContext * ctx, bool canBeTypeExpression ) {

374

LogDebug d( "#evt#");

375

if( !safetyCounter || !d ) return SimpleType();

376

bool canBeItemExpression = true; ///To be implemented

377

378

if( scope ) {

379

expr.setIncludeFiles( scope.resultType->includeFiles() );

380

} else {

381

expr.setIncludeFiles( m_includeFiles );

382

}

383

384

385

ifVerboseMajor( dbgMajor() << "evaluateAtomicExpression(\"" << expr.name() << "\") scope: \"" << scope->fullNameChain() << "\" context: " << ctx << endl );

386

387

EvaluationResult bestRet;

388

int bestDepth = 0;

389

390

if( expr.name().isEmpty() )

391

return scope;

392

393

TypePointer searchIn = scope->resolved();

394

if( !searchIn ) {

395

statusLog( "scope-type is not resolved" );

396

return EvaluationResult();

397

}

398

399

if( ctx )

400

searchIn = ctx->container().get();

401

402

if( ctx && canBeItemExpression ) {

403

///Search for variables and functions, first in the current context, and then through the container-classes upwards.

404

// find the variable in the current context

405

SimpleVariable var = ctx->findVariable( expr.name() );

406

407

if ( var.type ) {

408

TypeDesc d( var.type );

409

d.setIncludeFiles( m_includeFiles );

410

EvaluationResult ret = EvaluationResult( ctx->container()->locateDecType( d ), var.toDeclarationInfo( "current_file" ));

411

ret.expr.t = ExpressionInfo::NormalExpression;

412

return ret;

413

}

414

415

SimpleType current = ctx->container();

416

417

SimpleTypeImpl::TypeOfResult type;

418

419

SafetyCounter s( 20 );

420

bool ready = false;

421

int depth = 0;

422

423

while( !ready && s )

424

{

425

if( !current ) ready = true;

426

427

type = current->typeOf( expr );

428

if ( type) {

429

bestRet = EvaluationResult( type.type, type.decl );

430

bestDepth = depth;

431

bestRet.expr = expr.fullNameChain();

432

bestRet.expr.t = ExpressionInfo::NormalExpression;

433

}

434

435

depth++;

436

if( !ready ) current = current->parent();

437

}

438

}

439

440

if( scope.expr.t & ExpressionInfo::TypeExpression )

441

canBeTypeExpression = true;*/

442

443

if( canBeItemExpression && (!bestRet || bestDepth > 0 ) ) {

444

//SimpleTypeImpl::

445

SimpleTypeImpl::TypeOfResult res = searchIn->typeOf( expr );

446

447

if( res ) {

448

bestRet = EvaluationResult( res.type, res.decl );

449

bestDepth = 0;

450

}

451

}

452

if( canBeTypeExpression ) {

453

///Search for Types

454

LocateResult type = searchIn->locateDecType( expr );

455

456

if( !bestRet ||

457

/** Did we find a constructor within a class? */

458

(type->resolved() && ( bestRet->resolved() && type->resolved()->desc() == bestRet->resolved()->parent()->desc() && bestRet->resolved()->asFunction() ) ) ) {

459

/*if ( type && type->resolved() )

460

{*/

461

EvaluationResult ret = type;

462

ret.expr = expr.fullNameChain();

463

ret.expr.t = ExpressionInfo::TypeExpression;

464

bestRet = ret;

465

}

466

/*} else {

467

bestRet = EvaluationResult( type );

468

QStringList s = split+exprList;

469

s.pop_front();

470

if( !s.isEmpty() )

471

bestRet->append( new TypeDescShared( s.join("::") ) );

472

}*/

473

}

474

475

if( bestRet )

476

return bestRet;

477

478

ifVerboseMajor( dbgMajor() << "evaluateAtomicExpression: \"" << scope.resultType->fullNameChain() << "\"could not locate " << expr.fullNameChain() << endl );

479

return bestRet;

480

}

481

}

482

483

// kate: indent-mode csands; tab-width 2;

Older »