The Ecere SDK - sdk/blob - ide/src/designer/findParams.ec

   1 import "ide"
   2
   3 //extern Class thisClass;
   4 extern Class insideClass;
   5 extern Type instanceType;
   6 extern char * instanceName;
   7 extern Expression paramsInsideExp;
   8 extern int paramsID;
   9 extern Type functionType;
  10
  11 static bool insideParams;
  12 static Class currentClass;
  13 static bool isAfterEqual;
  14 static bool allocedDummyExp;
  15
  16 static bool InsideIncl(Location loc, int line, int charPos)
  17 {
  18    /*
  19    return (loc.start.line < line || (loc.start.line == line && loc.start.charPos <= charPos)) &&
  20           (loc.end.line > line || (loc.end.line == line && loc.end.charPos >= charPos));
  21           */
  22    return !loc.start.included && (loc.start.line < line || (loc.start.line == line && loc.start.charPos <= charPos)) &&
  23           (loc.end.line > line || (loc.end.line == line && loc.end.charPos >= charPos));
  24 }
  25
  26 static bool Inside(Location loc, int line, int charPos)
  27 {
  28    return !loc.start.included && (loc.start.line < line || (loc.start.line == line && loc.start.charPos < charPos)) &&
  29           (loc.end.line > line || (loc.end.line == line && loc.end.charPos > charPos));
  30 }
  31
  32 static bool InsideEndIncl(Location loc, int line, int charPos)
  33 {
  34    return !loc.start.included && (loc.start.line < line || (loc.start.line == line && loc.start.charPos < charPos)) &&
  35           (loc.end.line > line || (loc.end.line == line && loc.end.charPos >= charPos));
  36 }
  37
  38 Identifier FindParamsIdentifier(Identifier id, int line, int charPos)
  39 {
  40    //if(id.loc.end.line == line && id.loc.end.charPos == charPos)
  41    //if(InsideIncl(&id.loc.end.line == line && id.loc.end.charPos == charPos)
  42    return id;
  43    return null;
  44 }
  45
  46 Identifier FindParamsExpression(Expression exp, int line, int charPos)
  47 {
  48    Identifier idResult = null;
  49    Expression oldExp = paramsInsideExp;
  50
  51    paramsInsideExp = exp;
  52    switch(exp.type)
  53    {
  54       case newExp:
  55          if(InsideIncl(&exp._new.size.loc, line, charPos))
  56          {
  57             idResult = FindParamsExpression(exp._new.size, line, charPos);
  58             if(idResult) return idResult;
  59          }
  60          break;
  61       case renewExp:
  62          if(InsideIncl(&exp._renew.exp.loc, line, charPos))
  63          {
  64             idResult = FindParamsExpression(exp._renew.exp, line, charPos);
  65             if(idResult) return idResult;
  66          }
  67          if(InsideIncl(&exp._renew.size.loc, line, charPos))
  68          {
  69             idResult = FindParamsExpression(exp._renew.size, line, charPos);
  70             if(idResult) return idResult;
  71          }
  72          break;
  73       case identifierExp:
  74       case constantExp:
  75          idResult = FindParamsIdentifier(exp.identifier, line, charPos);
  76          if(idResult) return idResult;
  77          //return (void *)-1;
  78          break;
  79       case instanceExp:
  80          if(InsideIncl(&exp.instance.loc, line, charPos))
  81          {
  82             idResult = FindParamsInstance(exp.instance, line, charPos);
  83             if(idResult) return idResult;
  84          }
  85          break;
  86       case stringExp:
  87          break;
  88       case opExp:
  89          if(exp.op.exp1)
  90          {
  91             if(InsideIncl(&exp.op.exp1.loc, line, charPos))
  92             {
  93                idResult = FindParamsExpression(exp.op.exp1, line, charPos);
  94                if(idResult) return idResult;
  95             }
  96          }
  97          if(exp.op.exp2)
  98          {
  99             // Changed this here, assuming this was changed first in findCtx and not needed here...
 100             // Bug when "a = atoi()" parameters popup dissappear when on the a of atoi
 101             if(InsideIncl(&exp.op.exp2.loc, line, charPos))
 102             //if(InsideEndIncl(&exp.op.exp2.loc, line, charPos))
 103             {
 104                idResult = FindParamsExpression(exp.op.exp2, line, charPos);
 105                if(idResult) return idResult;
 106             }
 107             paramsInsideExp = exp.op.exp2;
 108          }
 109          break;
 110       case bracketsExp:
 111       {
 112          Expression expression;
 113
 114          for(expression = exp.list->first; expression; expression = expression.next)
 115          {
 116             if(InsideIncl(&expression.loc, line, charPos))
 117             {
 118                idResult = FindParamsExpression(expression, line, charPos);
 119                if(idResult) return idResult;
 120             }
 121          }
 122          break;
 123       }
 124       case indexExp:
 125       {
 126          Expression expression;
 127          if(InsideIncl(&exp.index.exp.loc, line, charPos))
 128          {
 129             idResult = FindParamsExpression(exp.index.exp, line, charPos);
 130             if(idResult) return idResult;
 131          }
 132
 133          for(expression = exp.index.index->first; expression; expression = expression.next)
 134          {
 135             if(InsideIncl(&expression.loc, line, charPos))
 136             {
 137                idResult = FindParamsExpression(expression, line, charPos);
 138                if(idResult) return idResult;
 139             }
 140          }
 141          break;
 142       }
 143       case callExp:
 144       {
 145          int arg;
 146          Type type = exp.call.exp.expType;
 147
 148          if(InsideIncl(&exp.call.exp.loc, line, charPos))
 149          {
 150             idResult = FindParamsExpression(exp.call.exp, line, charPos);
 151             // Check for type here?
 152             if(!functionType && !instanceType)
 153             {
 154                functionType = type;
 155                if(paramsInsideExp == exp.call.exp)
 156                   paramsInsideExp = exp;
 157             }
 158             if(idResult) return idResult;
 159          }
 160
 161          if(exp.call.argLoc.start.line > line || (line == exp.call.argLoc.start.line && exp.call.argLoc.start.charPos >= charPos))
 162             arg = -1;
 163          else
 164             arg = 0;
 165
 166          if(exp.call.arguments)
 167          {
 168             Expression expression;
 169
 170             for(expression = exp.call.arguments->first; expression; expression = expression.next)
 171             {
 172                if(InsideIncl(&expression.loc, line, charPos) || (expression.loc.end.line > line || (line == expression.loc.end.line && expression.loc.end.charPos > charPos)))
 173                {
 174                   idResult = FindParamsExpression(expression, line, charPos);
 175                   insideParams = true;
 176                   // TOCHECK: Verify && vs || priority here
 177                   if((functionType && paramsID != -1) || instanceType)
 178                      return (void *)-1;
 179                   break;
 180                }
 181                if(expression.next)
 182                   arg++;
 183             }
 184
 185             if(exp.call.argLoc.end.line < line || (line == exp.call.argLoc.end.line && exp.call.argLoc.end.charPos <= charPos))
 186                arg = -1;
 187             else if(arg > -1)
 188                insideParams = true;
 189
 190             if(type && (type.kind == functionType || type.kind == methodType))
 191             {
 192                int c;
 193                Type param;
 194                if(type.kind == methodType)
 195                   type = type.method.dataType;
 196
 197                paramsInsideExp = exp;
 198                functionType = type;
 199                paramsID = arg;
 200
 201                for(param = type.params.first, c = 0; c<arg && param; c++, param = (param.kind == ellipsisType ? param : param.next));
 202                if(!param) paramsID = -1;
 203             }
 204             return (void *)-1;
 205          }
 206          break;
 207       }
 208       case memberExp:
 209          if(InsideIncl(&exp.member.exp.loc, line, charPos))
 210          {
 211             idResult = FindParamsExpression(exp.member.exp, line, charPos);
 212             if(idResult) return idResult;
 213          }
 214          break;
 215       case pointerExp:
 216          if(InsideIncl(&exp.member.exp.loc, line, charPos))
 217          {
 218             idResult = FindParamsExpression(exp.member.exp, line, charPos);
 219             if(idResult) return idResult;
 220          }
 221          break;
 222       case typeSizeExp:
 223          break;
 224       case castExp:
 225          if(InsideIncl(&exp.cast.exp.loc, line, charPos))
 226          {
 227             idResult = FindParamsExpression(exp.cast.exp, line, charPos);
 228             if(idResult) return idResult;
 229          }
 230          break;
 231       case conditionExp:
 232          if(Inside(&exp.cond.cond.loc, line, charPos))
 233          {
 234             idResult = FindParamsExpression(exp.cond.cond, line, charPos);
 235             if(idResult) return idResult;
 236          }
 237
 238          {
 239             Expression expression;
 240             for(expression = exp.cond.exp->first; expression; expression = expression.next)
 241             {
 242                if(InsideIncl(&expression.loc, line, charPos))
 243                {
 244                   idResult = FindParamsExpression(expression, line, charPos);
 245                   if(idResult) return idResult;
 246                }
 247             }
 248          }
 249          if(InsideIncl(&exp.cond.elseExp.loc, line, charPos))
 250          {
 251             idResult = FindParamsExpression(exp.cond.elseExp, line, charPos);
 252             if(idResult) return idResult;
 253          }
 254          break;
 255    }
 256    paramsInsideExp = oldExp;
 257    return null;
 258 }
 259
 260 static Identifier FindParamsStatement(Statement stmt, int line, int charPos)
 261 {
 262    Identifier idResult;
 263
 264    switch(stmt.type)
 265    {
 266       case labeledStmt:
 267          if(InsideIncl(&stmt.labeled.stmt.loc, line, charPos))
 268             return FindParamsStatement(stmt.labeled.stmt, line, charPos);
 269          break;
 270       case caseStmt:
 271          if(stmt.caseStmt.exp)
 272          {
 273             if(InsideIncl(&stmt.caseStmt.exp.loc, line, charPos))
 274                return FindParamsExpression(stmt.caseStmt.exp, line, charPos);
 275          }
 276
 277          if(stmt.caseStmt.stmt)
 278          {
 279             if(InsideIncl(&stmt.caseStmt.stmt.loc, line, charPos))
 280                return FindParamsStatement(stmt.caseStmt.stmt, line, charPos);
 281          }
 282          break;
 283       case badDeclarationStmt:
 284       {
 285          Declaration decl = stmt.decl;
 286          if(InsideIncl(&decl.loc, line, charPos))
 287          {
 288             idResult = FindParamsDeclaration(decl, line, charPos);
 289             if(idResult) return idResult;
 290          }
 291          break;
 292       }
 293       case compoundStmt:
 294       {
 295          if(!stmt.compound.isSwitch)
 296             SetCurrentContext(stmt.compound.context);
 297          if(stmt.compound.declarations)
 298          {
 299             Declaration decl;
 300             for(decl = stmt.compound.declarations->first; decl; decl = decl.next)
 301             {
 302                if(InsideIncl(&decl.loc, line, charPos))
 303                {
 304                   idResult = FindParamsDeclaration(decl, line, charPos);
 305                   if(idResult) return idResult;
 306                }
 307             }
 308          }
 309          if(stmt.compound.statements)
 310          {
 311             Statement statement;
 312             for(statement = stmt.compound.statements->first; statement; statement = statement.next)
 313             {
 314                if(InsideIncl(&statement.loc, line, charPos))
 315                {
 316                   idResult = FindParamsStatement(statement, line, charPos);
 317                   if(idResult) return idResult;
 318                }
 319             }
 320          }
 321          return (void *)-1;
 322          //curContext = stmt.compound.context.parent;
 323          //break;
 324       }
 325       case expressionStmt:
 326       {
 327          if(stmt.expressions)
 328          {
 329             Expression exp;
 330             for(exp = stmt.expressions->first; exp; exp = exp.next)
 331             {
 332                if(InsideIncl(&exp.loc, line, charPos))
 333                {
 334                   idResult = FindParamsExpression(exp, line, charPos);
 335                   if(idResult) return idResult;
 336                }
 337             }
 338          }
 339          break;
 340       }
 341       case ifStmt:
 342       {
 343          Expression exp;
 344          for(exp = stmt.ifStmt.exp->first; exp; exp = exp.next)
 345          {
 346             if(InsideIncl(&exp.loc, line, charPos))
 347             {
 348                idResult = FindParamsExpression(exp, line, charPos);
 349                if(idResult) return idResult;
 350             }
 351          }
 352          if(stmt.ifStmt.stmt)
 353          {
 354             if(InsideIncl(&stmt.ifStmt.stmt.loc, line, charPos))
 355             {
 356                idResult = FindParamsStatement(stmt.ifStmt.stmt, line, charPos);
 357                if(idResult) return idResult;
 358             }
 359          }
 360          if(stmt.ifStmt.elseStmt)
 361          {
 362             if(InsideIncl(&stmt.ifStmt.elseStmt.loc, line, charPos))
 363                return FindParamsStatement(stmt.ifStmt.elseStmt, line, charPos);
 364          }
 365          break;
 366       }
 367       case switchStmt:
 368       {
 369          Expression exp;
 370          for(exp = stmt.switchStmt.exp->first; exp; exp = exp.next)
 371          {
 372             if(InsideIncl(&exp.loc, line, charPos))
 373             {
 374                idResult = FindParamsExpression(exp, line, charPos);
 375                if(idResult) return idResult;
 376             }
 377          }
 378          if(stmt.switchStmt.stmt && InsideIncl(&stmt.switchStmt.stmt.loc, line, charPos))
 379             return FindParamsStatement(stmt.switchStmt.stmt, line, charPos);
 380          break;
 381       }
 382       case whileStmt:
 383       {
 384          if(stmt.whileStmt.exp)
 385          {
 386             Expression exp;
 387             for(exp = stmt.whileStmt.exp->first; exp; exp = exp.next)
 388             {
 389                if(InsideIncl(&exp.loc, line, charPos))
 390                {
 391                   idResult = FindParamsExpression(exp, line, charPos);
 392                   if(idResult) return idResult;
 393                }
 394             }
 395          }
 396          if(stmt.whileStmt.stmt && InsideIncl(&stmt.whileStmt.stmt.loc, line, charPos))
 397             return FindParamsStatement(stmt.whileStmt.stmt, line, charPos);
 398          break;
 399       }
 400       case doWhileStmt:
 401       {
 402          Expression exp;
 403
 404          if(stmt.doWhile.stmt && InsideIncl(&stmt.doWhile.stmt.loc, line, charPos))
 405          {
 406             idResult = FindParamsStatement(stmt.doWhile.stmt, line, charPos);
 407             if(idResult) return idResult;
 408          }
 409
 410          if(stmt.doWhile.exp)
 411          {
 412             for(exp = stmt.doWhile.exp->first; exp; exp = exp.next)
 413             {
 414                if(InsideIncl(&exp.loc, line, charPos))
 415                {
 416                   idResult = FindParamsExpression(exp, line, charPos);
 417                   if(idResult) return idResult;
 418                }
 419             }
 420          }
 421          break;
 422       }
 423       case forStmt:
 424       {
 425          Expression exp;
 426
 427          if(stmt.forStmt.init && InsideIncl(&stmt.forStmt.init.loc, line, charPos))
 428          {
 429             idResult = FindParamsStatement(stmt.forStmt.init, line, charPos);
 430             if(idResult) return idResult;
 431          }
 432
 433          if(stmt.forStmt.check && InsideIncl(&stmt.forStmt.check.loc, line, charPos))
 434          {
 435             idResult = FindParamsStatement(stmt.forStmt.check, line, charPos);
 436             if(idResult) return idResult;
 437          }
 438
 439          if(stmt.forStmt.increment)
 440          {
 441             for(exp = stmt.forStmt.increment->first; exp; exp = exp.next)
 442             {
 443                if(InsideIncl(&exp.loc, line, charPos))
 444                {
 445                   idResult = FindParamsExpression(exp, line, charPos);
 446                   if(idResult) return idResult;
 447                }
 448             }
 449          }
 450
 451          if(stmt.forStmt.stmt)
 452             return FindParamsStatement(stmt.forStmt.stmt, line, charPos);
 453          break;
 454       }
 455       case gotoStmt:
 456          break;
 457       case continueStmt:
 458          break;
 459       case breakStmt:
 460          break;
 461       case returnStmt:
 462          if(stmt.expressions)
 463          {
 464             Expression exp;
 465
 466             for(exp = stmt.expressions->first; exp; exp = exp.next)
 467             {
 468                if(InsideIncl(&exp.loc, line, charPos))
 469                {
 470                   idResult = FindParamsExpression(exp, line, charPos);
 471                   if(idResult) return idResult;
 472                }
 473             }
 474          }
 475          break;
 476       case fireWatchersStmt:
 477       case stopWatchingStmt:
 478       {
 479          Identifier _watch;
 480          if(stmt._watch.watcher && InsideIncl(&stmt._watch.watcher.loc, line, charPos))
 481          {
 482             idResult = FindParamsExpression(stmt._watch.watcher, line, charPos);
 483             if(idResult) return idResult;
 484          }
 485          if(stmt._watch.object && InsideIncl(&stmt._watch.object.loc, line, charPos))
 486          {
 487             idResult = FindParamsExpression(stmt._watch.object, line, charPos);
 488             if(idResult) return idResult;
 489          }
 490          if(stmt._watch.watches)
 491          {
 492             for(_watch = stmt._watch.watches->first; _watch; _watch = _watch.next)
 493             {
 494                if(InsideIncl(&_watch.loc, line, charPos))
 495                {
 496                   idResult = FindParamsIdentifier(_watch, line, charPos);
 497                   if(idResult) return idResult;
 498                }
 499             }
 500          }
 501          break;
 502       }
 503       case watchStmt:
 504       {
 505          PropertyWatch _watch;
 506          if(stmt._watch.watcher && InsideIncl(&stmt._watch.watcher.loc, line, charPos))
 507          {
 508             idResult = FindParamsExpression(stmt._watch.watcher, line, charPos);
 509             if(idResult) return idResult;
 510          }
 511          if(stmt._watch.object && InsideIncl(&stmt._watch.object.loc, line, charPos))
 512          {
 513             idResult = FindParamsExpression(stmt._watch.object, line, charPos);
 514             if(idResult) return idResult;
 515          }
 516          if(stmt._watch.watches)
 517          {
 518             for(_watch = stmt._watch.watches->first; _watch; _watch = _watch.next)
 519             {
 520                if(_watch.compound && InsideIncl(&_watch.compound.loc, line, charPos))
 521                {
 522                   idResult = FindParamsStatement(_watch.compound, line, charPos);
 523                   if(idResult) return idResult;
 524                }
 525             }
 526          }
 527          break;
 528       }
 529    }
 530    return null;
 531 }
 532
 533 static Identifier FindParamsInitializer(Initializer initializer, int line, int charPos)
 534 {
 535    switch(initializer.type)
 536    {
 537       case listInitializer:
 538       {
 539          Initializer init;
 540          Identifier idResult;
 541
 542          for(init = initializer.list->first; init; init = init.next)
 543          {
 544             if(InsideIncl(&init.loc, line, charPos))
 545             {
 546                idResult = FindParamsInitializer(init, line, charPos);
 547                if(idResult) return idResult;
 548             }
 549          }
 550          break;
 551       }
 552       case expInitializer:
 553          if(InsideIncl(&initializer.exp.loc, line, charPos))
 554             return FindParamsExpression(initializer.exp, line, charPos);
 555
 556          {
 557             paramsInsideExp = initializer.exp;
 558             return (void *)-1;
 559          }
 560          break;
 561    }
 562    return null;
 563 }
 564
 565 static Identifier FindParamsInitDeclarator(InitDeclarator decl, int line, int charPos)
 566 {
 567    if(decl.initializer && InsideIncl(&decl.initializer.loc, line, charPos))
 568       return FindParamsInitializer(decl.initializer, line, charPos);
 569    return null;
 570 }
 571
 572 static Identifier FindParamsSpecifier(Specifier spec, int line, int charPos)
 573 {
 574    Identifier idResult;
 575    switch(spec.type)
 576    {
 577       case enumSpecifier:
 578       case structSpecifier:
 579       case unionSpecifier:
 580       {
 581          if(spec.definitions)
 582          {
 583             ClassDef def;
 584             for(def = spec.definitions->first; def; def = def.next)
 585             {
 586                // TODO: Should use FindParamsClassDef here right?
 587
 588                //if(def.type == ClassDefDeclaration && def.decl && def.decl.type == DeclarationStruct)
 589                //   ProcessDeclaration(def.decl);
 590                switch(def.type)
 591                {
 592                   case declarationClassDef:
 593                      if(InsideIncl(&def.decl.loc, line, charPos))
 594                      {
 595                         idResult = FindParamsDeclaration(def.decl, line, charPos);
 596                         if(idResult)
 597                            return idResult;
 598                      }
 599                      break;
 600                   case defaultPropertiesClassDef:
 601                   {
 602                      MemberInit init;
 603                      for(init = def.defProperties->first; init; init = init.next)
 604                      {
 605                         if(InsideIncl(&init.realLoc, line, charPos))
 606                         {
 607                            Class oldThisClass = GetThisClass();
 608                            Context oldTopContext = GetTopContext();
 609                            SetThisClass(currentClass);
 610                            idResult = FindParamsMemberInit(init, line, charPos);
 611                            if(idResult)
 612                               return idResult;
 613                            SetThisClass(oldThisClass);
 614                         }
 615                      }
 616                      break;
 617                   }
 618                   case functionClassDef:
 619                      if(InsideIncl(&def.function.loc, line, charPos))
 620                      {
 621                         idResult = FindParamsClassFunction(def.function, line, charPos);
 622
 623                         if(idResult)
 624                            return idResult;
 625                      }
 626                      break;
 627                   case propertyClassDef:
 628                      if(def.propertyDef)
 629                      {
 630                         if(InsideIncl(&def.propertyDef.loc, line, charPos))
 631                         {
 632                            idResult = FindParamsProperty(def.propertyDef, line, charPos);
 633                            if(idResult)
 634                               return idResult;
 635                         }
 636                      }
 637                      break;
 638                   case propertyWatchClassDef:
 639                      if(def.propertyWatch && def.propertyWatch.compound && InsideIncl(&def.propertyWatch.compound.loc, line, charPos))
 640                      {
 641                         Class oldThisClass = GetThisClass();
 642                         Context oldTopContext = GetTopContext();
 643                         SetThisClass(currentClass);
 644                         idResult = FindParamsStatement(def.propertyWatch.compound, line, charPos);
 645                         if(idResult) return idResult;
 646                         SetThisClass(oldThisClass);
 647                      }
 648                      break;
 649                }
 650             }
 651          }
 652          break;
 653       }
 654    }
 655    return null;
 656 }
 657
 658 static Identifier FindParamsDeclaration(Declaration decl, int line, int charPos)
 659 {
 660    Identifier idResult;
 661
 662    switch(decl.type)
 663    {
 664       case structDeclaration:
 665       {
 666          Specifier spec;
 667          if(decl.specifiers)
 668          {
 669             for(spec = decl.specifiers->first; spec; spec = spec.next)
 670             {
 671                if(InsideIncl(&spec.loc, line, charPos))
 672                {
 673                   idResult = FindParamsSpecifier(spec, line, charPos);
 674                   if(idResult) return idResult;
 675                }
 676             }
 677          }
 678          break;
 679       }
 680       case initDeclaration:
 681       {
 682          InitDeclarator d;
 683          // Need to loop through specifiers to look for :: completion
 684          if(decl.specifiers)
 685          {
 686             Specifier s;
 687
 688             for(s = decl.specifiers->first; s; s = s.next)
 689             {
 690                if(InsideIncl(&s.loc, line, charPos))
 691                {
 692                   idResult = FindParamsSpecifier(s, line, charPos);
 693                   if(idResult) return idResult;
 694                }
 695             }
 696          }
 697
 698          if(decl.declarators && decl.declarators->first)
 699          {
 700             for(d = decl.declarators->first; d; d = d.next)
 701             {
 702                if(InsideIncl(&d.loc, line, charPos))
 703                {
 704                   idResult = FindParamsInitDeclarator(d, line, charPos);
 705                   if(idResult) return idResult;
 706                }
 707             }
 708          }
 709          break;
 710       }
 711       case instDeclaration:
 712          if(InsideIncl(&decl.inst.loc, line, charPos))
 713             return FindParamsInstance(decl.inst, line, charPos);
 714          break;
 715    }
 716    return null;
 717 }
 718
 719 static Identifier FindParamsFunction(FunctionDefinition func, int line, int charPos)
 720 {
 721    if(func.body && Inside(&func.body.loc, line, charPos))
 722    {
 723       Identifier idResult;
 724
 725       Identifier id = GetDeclId(func.declarator);
 726       Symbol symbol = func.declarator.symbol;
 727       Type type = symbol.type;
 728       Class oldThisClass = GetThisClass();
 729       Context oldTopContext = GetTopContext();
 730
 731       idResult = FindParamsStatement(func.body, line, charPos);
 732       if(idResult)
 733          return idResult;
 734
 735       SetThisClass(oldThisClass);
 736       SetTopContext(oldTopContext);
 737    }
 738    return null;
 739 }
 740
 741 static Identifier FindParamsMemberInit(MemberInit init, int line, int charPos)
 742 {
 743    Identifier idResult;
 744    if(init.initializer && InsideIncl(&init.initializer.loc, line, charPos))
 745    {
 746       idResult = FindParamsInitializer(init.initializer, line, charPos);
 747       if(idResult)
 748       {
 749          if(init.identifiers && init.identifiers->first)
 750             isAfterEqual = true;
 751          return idResult;
 752       }
 753    }
 754    if(init.identifiers && init.identifiers->first && InsideIncl(&((Identifier)init.identifiers->first).loc, line, charPos))
 755    {
 756       idResult = FindParamsIdentifier(init.identifiers->first, line, charPos);
 757       if(idResult)
 758          return idResult;
 759    }
 760    if(init.initializer && Inside(&init.initializer.loc, line, charPos))
 761    {
 762       if(init.identifiers && init.identifiers->first)
 763          isAfterEqual = true;
 764
 765       if(init.initializer.type == expInitializer)
 766       {
 767          paramsInsideExp = init.initializer.exp;
 768          return (void *)-1;
 769       }
 770    }
 771    return null;
 772 }
 773
 774 static Identifier FindParamsInstance(Instantiation inst, int line, int charPos)
 775 {
 776    Identifier idResult = null;
 777    Class oldThisClass = GetThisClass();
 778    Symbol sym = inst._class ? FindClass(inst._class.name) : null;
 779    bool insideSomething = false;
 780    bool insideBrackets;
 781    Method method = null;
 782
 783    Class curClass = null;
 784    DataMember curMember = null;
 785    DataMember dataMember = null;
 786    DataMember subMemberStack[256];
 787    int subMemberStackPos = 0;
 788
 789    if(sym)
 790       SetThisClass(sym.registered);
 791
 792    insideBrackets = !(inst.insideLoc.start.line > line || (line == inst.insideLoc.start.line && inst.insideLoc.start.charPos > charPos));
 793    if(insideBrackets)
 794    {
 795       // Start with first member
 796       eClass_FindNextMember(GetThisClass(), &curClass, &curMember, subMemberStack, &subMemberStackPos);
 797       dataMember = curMember;
 798    }
 799
 800    if(inst.members)
 801    {
 802       MembersInit init;
 803       MemberInit memberInit;
 804       for(init = inst.members->first; init; init = init.next)
 805       {
 806          if(init.loc.start.line > line || (line == init.loc.start.line && init.loc.start.charPos > charPos))
 807             break;
 808
 809          if(init.type == dataMembersInit && init.dataMembers && insideBrackets && sym)
 810          {
 811             for(memberInit = init.dataMembers->first; memberInit; memberInit = memberInit.next)
 812             {
 813                isAfterEqual = false;
 814
 815                if(memberInit.identifiers && memberInit.identifiers->first)
 816                {
 817                   DataMember _subMemberStack[256];
 818                   int _subMemberStackPos = 0;
 819                   DataMember thisMember = eClass_FindDataMember(GetThisClass(), ((Identifier)memberInit.identifiers->first).string, GetPrivateModule(), _subMemberStack, &_subMemberStackPos);
 820                   if(!thisMember)
 821                   {
 822                      // WARNING: Brackets needed until precomp fix
 823                      thisMember = (DataMember)eClass_FindProperty(GetThisClass(), ((Identifier)memberInit.identifiers->first).string, GetPrivateModule());
 824                   }
 825                   if(thisMember)
 826                   {
 827                      method = null;
 828                      dataMember = thisMember;
 829                      if(thisMember.memberAccess == publicAccess)
 830                      {
 831                         curMember = thisMember;
 832                         curClass = thisMember._class;
 833                         memcpy(subMemberStack, _subMemberStack, sizeof(DataMember) * _subMemberStackPos);
 834                         subMemberStackPos = _subMemberStackPos;
 835                      }
 836                   }
 837                   else
 838                      method = eClass_FindMethod(GetThisClass(), ((Identifier)memberInit.identifiers->first).string, GetPrivateModule());
 839                }
 840
 841                if(!idResult && InsideIncl(&memberInit.realLoc, line, charPos))
 842                   idResult = FindParamsMemberInit(memberInit, line, charPos);
 843
 844                if(InsideIncl(&memberInit.realLoc, line, charPos) || (memberInit.realLoc.end.line > line || (line == memberInit.realLoc.end.line && memberInit.realLoc.end.charPos > charPos)))
 845                {
 846                   if(memberInit.identifiers && memberInit.identifiers->first && InsideIncl(&memberInit.loc, line, charPos) && !dataMember)
 847                      insideBrackets = false;
 848                   break;
 849                }
 850                else if((!memberInit.identifiers || !memberInit.identifiers->first || curMember) && (memberInit.next || !Inside(&init.loc, line, charPos)))
 851                {
 852                   method = null;
 853                   eClass_FindNextMember(GetThisClass(), &curClass, &curMember, subMemberStack, &subMemberStackPos);
 854                   dataMember = curMember;
 855                }
 856             }
 857          }
 858
 859          if(InsideIncl(&init.loc, line, charPos))
 860          {
 861             if(Inside(&init.loc, line, charPos))
 862                if(init.type == methodMembersInit)
 863                   insideSomething = true;
 864
 865             if(init.type == methodMembersInit && Inside(&init.function.loc, line, charPos))
 866             {
 867                idResult = FindParamsClassFunction(init.function, line, charPos);
 868             }
 869
 870             if(Inside(&init.loc, line, charPos))
 871                break;
 872          }
 873
 874          if((init.loc.end.line > line || (line == init.loc.end.line && init.loc.end.charPos > charPos)))
 875             break;
 876       }
 877    }
 878    if(!insideParams && sym && sym.registered && InsideIncl(&inst.insideLoc, line, charPos) && insideBrackets && !insideSomething)
 879    {
 880       if(dataMember && !method)
 881       {
 882          if(!dataMember.dataType)
 883             dataMember.dataType = ProcessTypeString(dataMember.dataTypeString, false);
 884          paramsInsideExp = MkExpDummy();
 885          allocedDummyExp = true;
 886          paramsInsideExp.destType = dataMember.dataType;
 887          if(paramsInsideExp.destType) paramsInsideExp.destType.refCount++;
 888
 889          functionType = null;
 890          instanceType = paramsInsideExp.destType;
 891          instanceName = dataMember.name;
 892          insideParams = true;
 893       }
 894    }
 895
 896    if(!insideParams && sym && sym.registered && InsideIncl(&inst.insideLoc, line, charPos) && !insideSomething && insideBrackets)
 897    {
 898       if(method)
 899       {
 900          paramsInsideExp = MkExpDummy();
 901          allocedDummyExp = true;
 902          paramsInsideExp.destType = method.dataType;
 903          if(paramsInsideExp.destType) paramsInsideExp.destType.refCount++;
 904
 905          functionType = null;
 906          instanceType = paramsInsideExp.destType;
 907          instanceName = method.name;
 908       }
 909       insideParams = true;
 910    }
 911
 912    if(sym && !insideSomething && InsideIncl(&inst.insideLoc, line, charPos))
 913    {
 914       if(!isAfterEqual && !insideClass)
 915          insideClass = sym.registered;
 916
 917       if(isAfterEqual && currentClass)
 918          SetThisClass(currentClass);
 919
 920       return idResult ? idResult : (void *) -1;
 921    }
 922
 923    if(idResult)
 924       return idResult;
 925
 926    SetThisClass(oldThisClass);
 927
 928    return null;
 929 }
 930
 931 static Identifier FindParamsClassFunction(ClassFunction func, int line, int charPos)
 932 {
 933    if(func.body && Inside(&func.body.loc, line, charPos))
 934    {
 935       Identifier idResult;
 936
 937       Identifier id = GetDeclId(func.declarator);
 938       Symbol symbol = func.declarator ? func.declarator.symbol : null;
 939       Type type = symbol ? symbol.type : null;
 940       Class oldThisClass = GetThisClass();
 941       Context oldTopContext = GetTopContext();
 942       SetThisClass((type && type.thisClass) ? type.thisClass.registered : currentClass);
 943
 944       idResult = FindParamsStatement(func.body, line, charPos);
 945       if(idResult)
 946          return idResult;
 947
 948       SetThisClass(oldThisClass);
 949       SetTopContext(oldTopContext);
 950    }
 951    return null;
 952 }
 953
 954 static Identifier FindParamsProperty(PropertyDef def, int line, int charPos)
 955 {
 956    Identifier result;
 957    if(def.getStmt && Inside(&def.getStmt.loc, line, charPos))
 958    {
 959       Class oldThisClass = GetThisClass();
 960       Context oldTopContext = GetTopContext();
 961       SetThisClass(currentClass);
 962       result = FindParamsStatement(def.getStmt, line, charPos);
 963       if(result) return result;
 964       SetThisClass(oldThisClass);
 965    }
 966    if(def.setStmt && Inside(&def.setStmt.loc, line, charPos))
 967    {
 968       Class oldThisClass = GetThisClass();
 969       Context oldTopContext = GetTopContext();
 970       SetThisClass(currentClass);
 971       result = FindParamsStatement(def.setStmt, line, charPos);
 972       if(result) return result;
 973       SetThisClass(oldThisClass);
 974    }
 975    return null;
 976 }
 977
 978 static Identifier FindParamsClassDef(ClassDef def, int line, int charPos)
 979 {
 980    Identifier idResult;
 981    switch(def.type)
 982    {
 983       case declarationClassDef:
 984          if(Inside(&def.decl.loc, line, charPos))
 985          {
 986             idResult = FindParamsDeclaration(def.decl, line, charPos);
 987             if(idResult)
 988                return idResult;
 989          }
 990          break;
 991       case defaultPropertiesClassDef:
 992       {
 993          MemberInit init;
 994          for(init = def.defProperties->first; init; init = init.next)
 995          {
 996             if(InsideIncl(&init.realLoc, line, charPos))
 997             {
 998                Class oldThisClass = GetThisClass();
 999                Context oldTopContext = GetTopContext();
1000                SetThisClass(currentClass);
1001                idResult = FindParamsMemberInit(init, line, charPos);
1002                if(idResult)
1003                   return idResult;
1004                SetThisClass(oldThisClass);
1005             }
1006          }
1007          break;
1008       }
1009       case functionClassDef:
1010          if(Inside(&def.function.loc, line, charPos))
1011          {
1012             idResult = FindParamsClassFunction(def.function, line, charPos);
1013             if(idResult)
1014                return idResult;
1015          }
1016          break;
1017       case propertyClassDef:
1018          if(def.propertyDef)
1019          {
1020             if(Inside(&def.propertyDef.loc, line, charPos))
1021             {
1022                idResult = FindParamsProperty(def.propertyDef, line, charPos);
1023                if(idResult)
1024                   return idResult;
1025             }
1026          }
1027          break;
1028       case propertyWatchClassDef:
1029          if(def.propertyWatch && def.propertyWatch.compound && Inside(&def.propertyWatch.compound.loc, line, charPos))
1030          {
1031             Class oldThisClass = GetThisClass();
1032             Context oldTopContext = GetTopContext();
1033             SetThisClass(currentClass);
1034             idResult = FindParamsStatement(def.propertyWatch.compound, line, charPos);
1035             if(idResult) return idResult;
1036             SetThisClass(oldThisClass);
1037          }
1038          break;
1039    }
1040    return null;
1041 }
1042
1043 static Identifier FindParamsClass(ClassDefinition _class, int line, int charPos)
1044 {
1045    Identifier idResult;
1046    bool insideSomething = false;
1047    if(_class.definitions)
1048    {
1049       ClassDef def;
1050       for(def = _class.definitions->first; def; def = def.next)
1051       {
1052          if(def.type == defaultPropertiesClassDef ? InsideIncl(&def.loc, line, charPos) : Inside(&def.loc, line, charPos) )
1053          {
1054             if(def.type != defaultPropertiesClassDef)
1055                insideSomething = true;
1056
1057             idResult = FindParamsClassDef(def, line, charPos);
1058             if(idResult)
1059                return idResult;
1060          }
1061       }
1062    }
1063    if(!insideSomething)
1064    {
1065       insideClass = _class.symbol.registered;
1066       return (void *)-1;
1067    }
1068    return null;
1069 }
1070
1071 Identifier FindParamsTree(OldList ast, int line, int charPos)
1072 {
1073    Identifier idResult;
1074    External external;
1075
1076    if(allocedDummyExp)
1077    {
1078       FreeExpression(paramsInsideExp);
1079       allocedDummyExp = false;
1080    }
1081
1082    insideClass = null;
1083    paramsInsideExp = null;
1084    SetThisClass(null);
1085    paramsID = -1;
1086    functionType = null;
1087    instanceType = null;
1088    instanceName = null;
1089    insideParams = false;
1090    isAfterEqual = false;
1091
1092    if(ast != null)
1093    {
1094       for(external = ast.first; external; external = external.next)
1095       {
1096          switch(external.type)
1097          {
1098             case functionExternal:
1099                if(Inside(&external.loc, line, charPos))
1100                {
1101                   idResult = FindParamsFunction(external.function, line, charPos);
1102                   if(idResult)
1103                      return (idResult == (void *)-1) ? null : idResult;
1104                }
1105                break;
1106             case declarationExternal:
1107                if(InsideIncl(&external.loc, line, charPos))
1108                {
1109                   idResult = FindParamsDeclaration(external.declaration, line, charPos);
1110                   if(idResult)
1111                      return (idResult == (void *)-1) ? null : idResult;
1112                }
1113                break;
1114             case classExternal:
1115                if(Inside(&external._class.loc, line, charPos))
1116                {
1117                   currentClass = external._class.symbol.registered;
1118                   idResult = FindParamsClass(external._class, line, charPos);
1119                   currentClass = null;
1120                   if(idResult)
1121                      return (idResult == (void *)-1) ? null : idResult;
1122                }
1123                break;
1124          }
1125       }
1126    }
1127    return null;
1128 }
1129
1130 void FindParams_Terminate()
1131 {
1132    if(allocedDummyExp)
1133    {
1134       FreeExpression(paramsInsideExp);
1135       allocedDummyExp = false;
1136    }
1137 }