Developer forums (C::B DEVELOPMENT STRICTLY!) > Development

Find declaration/implementation of fails on obects in containers

<< < (2/2)

p2rkw:
I done few tests:

Debug log for line 66:

--- Quote ---AI() Adding search namespace: Global namespace
BreakUpComponents() Breaking up '  aBar.getBar()->'
BreakUpComponents() Found component: 'aBar' (Class)
BreakUpComponents() Adding component: 'aBar'.
BreakUpComponents() Found component: 'getBar' (Class)
BreakUpComponents() Adding component: 'getBar'.
BreakUpComponents() Found component: '' (SearchText)
BreakUpComponents() Adding component: ''.
ResolveExpression() search scope is 2 result.
search scope: -1
search scope: 463
ResolveExpression() Looping 1 result.
ResolvExpression() Match:'aBar(ID=457) : type='A'
BreakUpComponents() Breaking up 'A'
BreakUpComponents() Found component: 'A' (SearchText)
BreakUpComponents() Adding component: 'A'.
ResolveExpression() search scope is 1 result.
search scope: 1259
ResolveExpression() Looping 1 result.
ResolvExpression() Match:'getBar(ID=1258) : type='T'
BreakUpComponents() Breaking up 'T'
BreakUpComponents() Found component: 'T' (SearchText)
BreakUpComponents() Adding component: 'T'.
ResolveExpression() search scope is 1 result.
search scope: 465
ResolveExpression() Looping 1 result.
ResolvExpression() Match:'tMethod(ID=464) : type='int'
AI() AI leave, returned 1 results
1 results
Generating tokens list...
Done generating tokens list
--- End quote ---

When breaking statement parser is looking for return value type of function before '->', and im my test it finds template parameter type ( in test named 'T' ). Parser don't recognize 'T' as template parameter but as normal class type, so it continues searching and finds class type with this name.

Test code:

--- Code: ---#include <list>

struct bar {
void foo() {}
};

template<class T>
struct opArrow
{
  opArrow(T t) : t(t) {}

  T* operator -> (){
    return &t;
  }

  T t;
};

template <class T>
struct A{
  T* getBar(){
    return &bar1;
  }

  T getBar2(){
    return bar1;
  }

  opArrow<T> getIterator(){
    return opArrow<T>( bar1 );
  }

  T bar1;
};

struct T{
  int tMethod(){
    return 0;
  }
};
int main() {
std::list< bar> foobar;
foobar.push_back(bar());
foobar.begin()->foo();
foobar.begin()->foo();
bar bar1;
bar1.foo();
bar1.foo();

typedef std::list<bar> foobarT;
foobarT foobar2;
foobar2.begin()->foo();

foobar2.begin()->foo();

  foobar2.begin()->foo();

  bar1.foo();
  bar1.foo();

  foobar.begin()->foo();


  A<bar> aBar;

  //aBar.getBar()->

  aBar.getIterator()->foo(); //cc doesnt work here



  opArrow<bar> opBar1(bar());
}

--- End code ---

ollydbg:
Hi, p2rkw, thanks for your test.

So, the remaining feature improvement is that the "T" should be replaced to "class bar", I remember there are some code handling this in CC, but I'm not sure why it does not work anymore.

Navigation

[0] Message Index

[*] Previous page