Code::Blocks - User contributions [en]

Talk:Code Completion Design

2009-08-01T02:38:57Z

Blueshake: /* others */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet a char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to store the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g.
<pre>delete p;

MyClass.fun();

MyClass->fun();
</pre>

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.eg.
<pre>
int main() {cout <<endl;}
</pre>

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is. And set the related scope.

e.g.
<pre>
class MyClass
{
public :
int x;
int y;
};
</pre>
Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.e.g.
<pre>
if (a > b)

c = a;

else

c = b;
</pre>

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }
<pre>
typedef int INT;
</pre>
More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here. e.g.
<pre>
int add(int a, int b)

{

return a+b;

}
</pre>
==deal with const ==
just clear the m_str.It means that maybe a new variable or function is going to be defined.

e.g.

<pre>
const int a = 3;

const int getVal(int a);
</pre>

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g.
<pre>
#include <iostream>

#define MAXNUM 10

#if

#else

#endif
</pre>

==deal with using ==
skip the context until it meet ;or }

e.g.
<pre>
using namespace std;
</pre>

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if handleclass in the option is true.Otherwise skip context until the parser meet } or ;

e.g.
<pre>
class Myclass
{

int x;
int y;

};
</pre>

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

==deal with operator ==
eg.
<pre>
MyClass operator () (size_t param);
MyClass operator += (MyClass param);
</pre>
== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (
<pre>
Macro(a, b) fun(int a , int b);
vector<int> fun(int a , int b);
</pre>

2) : and the current is not public /protected /private

eg.
<pre>int x:1,y:1,z:1;</pre>

3),

e.g.
<pre>int x , y, z;</pre>

4)<

e.g.
<pre>
someclass<void>::memberfunc;

std::map<int, int> somevar;
</pre>
5)::

e.g.
<pre>
std::string

MyClass MyClass ::fun() {}
</pre>
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-08-01T02:38:00Z

Blueshake: /* others */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet a char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to store the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g.
<pre>delete p;

MyClass.fun();

MyClass->fun();
</pre>

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.eg.
<pre>
int main() {cout <<endl;}
</pre>

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is. And set the related scope.

e.g.
<pre>
class MyClass
{
public :
int x;
int y;
};
</pre>
Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.e.g.
<pre>
if (a > b)

c = a;

else

c = b;
</pre>

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }
<pre>
typedef int INT;
</pre>
More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here. e.g.
<pre>
int add(int a, int b)

{

return a+b;

}
</pre>
==deal with const ==
just clear the m_str.It means that maybe a new variable or function is going to be defined.

e.g.

<pre>
const int a = 3;

const int getVal(int a);
</pre>

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g.
<pre>
#include <iostream>

#define MAXNUM 10

#if

#else

#endif
</pre>

==deal with using ==
skip the context until it meet ;or }

e.g.
<pre>
using namespace std;
</pre>

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if handleclass in the option is true.Otherwise skip context until the parser meet } or ;

e.g.
<pre>
class Myclass
{

int x;
int y;

};
</pre>

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

==deal with operator ==
eg.
<pre>
MyClass operator () (size_t param);
MyClass operator += (MyClass param);
</pre>
== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (
<pre>
Macro(a, b) fun(int a , int b);
vector<int> fun(int a , int b);
</pre>

2) : and the current is not public /protected /private

eg.
<pre>int x:1,y:1,z:1;</pre>

3),

e.g.
<pre>int x , y, z;</pre>

4)<
<pre>
e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;
</pre>
5)::
e.g.
<pre>
std::string

MyClass MyClass ::fun() {}
</pre>
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-08-01T02:36:20Z

Blueshake: /* deal with class */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet a char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to store the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g.
<pre>delete p;

MyClass.fun();

MyClass->fun();
</pre>

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.eg.
<pre>
int main() {cout <<endl;}
</pre>

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is. And set the related scope.

e.g.
<pre>
class MyClass
{
public :
int x;
int y;
};
</pre>
Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.e.g.
<pre>
if (a > b)

c = a;

else

c = b;
</pre>

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }
<pre>
typedef int INT;
</pre>
More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here. e.g.
<pre>
int add(int a, int b)

{

return a+b;

}
</pre>
==deal with const ==
just clear the m_str.It means that maybe a new variable or function is going to be defined.

e.g.

<pre>
const int a = 3;

const int getVal(int a);
</pre>

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g.
<pre>
#include <iostream>

#define MAXNUM 10

#if

#else

#endif
</pre>

==deal with using ==
skip the context until it meet ;or }

e.g.
<pre>
using namespace std;
</pre>

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if handleclass in the option is true.Otherwise skip context until the parser meet } or ;

e.g.
<pre>
class Myclass
{

int x;
int y;

};
</pre>

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

==deal with operator ==
eg.
<pre>
MyClass operator () (size_t param);
MyClass operator += (MyClass param);
</pre>
== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (
<pre>
Macro(a, b) fun(int a , int b);
vector<int> fun(int a , int b);
</pre>

2): and the current is not public /protected /private

eg.
<pre>int x:1,y:1,z:1;</pre>

3),

e.g.
<pre>int x , y, z;</pre>

4)<
<pre>
e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;
</pre>
5)::
e.g.
<pre>
std::string

MyClass MyClass ::fun() {}
</pre>
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-08-01T02:34:23Z

Blueshake: /* deal with using */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet a char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to store the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g.
<pre>delete p;

MyClass.fun();

MyClass->fun();
</pre>

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.eg.
<pre>
int main() {cout <<endl;}
</pre>

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is. And set the related scope.

e.g.
<pre>
class MyClass
{
public :
int x;
int y;
};
</pre>
Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.e.g.
<pre>
if (a > b)

c = a;

else

c = b;
</pre>

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }
<pre>
typedef int INT;
</pre>
More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here. e.g.
<pre>
int add(int a, int b)

{

return a+b;

}
</pre>
==deal with const ==
just clear the m_str.It means that maybe a new variable or function is going to be defined.

e.g.

<pre>
const int a = 3;

const int getVal(int a);
</pre>

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g.
<pre>
#include <iostream>

#define MAXNUM 10

#if

#else

#endif
</pre>

==deal with using ==
skip the context until it meet ;or }

e.g.
<pre>
using namespace std;
</pre>

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ; e.g.
<pre>
class Myclass
{

int x;
int y;

};
</pre>

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

==deal with operator ==
eg.
<pre>
MyClass operator () (size_t param);
MyClass operator += (MyClass param);
</pre>
== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (
<pre>
Macro(a, b) fun(int a , int b);
vector<int> fun(int a , int b);
</pre>

2): and the current is not public /protected /private

eg.
<pre>int x:1,y:1,z:1;</pre>

3),

e.g.
<pre>int x , y, z;</pre>

4)<
<pre>
e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;
</pre>
5)::
e.g.
<pre>
std::string

MyClass MyClass ::fun() {}
</pre>
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-08-01T02:34:01Z

Blueshake: /* deal with # */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet a char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to store the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g.
<pre>delete p;

MyClass.fun();

MyClass->fun();
</pre>

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.eg.
<pre>
int main() {cout <<endl;}
</pre>

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is. And set the related scope.

e.g.
<pre>
class MyClass
{
public :
int x;
int y;
};
</pre>
Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.e.g.
<pre>
if (a > b)

c = a;

else

c = b;
</pre>

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }
<pre>
typedef int INT;
</pre>
More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here. e.g.
<pre>
int add(int a, int b)

{

return a+b;

}
</pre>
==deal with const ==
just clear the m_str.It means that maybe a new variable or function is going to be defined.

e.g.

<pre>
const int a = 3;

const int getVal(int a);
</pre>

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g.
<pre>
#include <iostream>

#define MAXNUM 10

#if

#else

#endif
</pre>

==deal with using ==
skip the context until it meet ;or }
<pre>
using namespace std;
</pre>

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ; e.g.
<pre>
class Myclass
{

int x;
int y;

};
</pre>

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

==deal with operator ==
eg.
<pre>
MyClass operator () (size_t param);
MyClass operator += (MyClass param);
</pre>
== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (
<pre>
Macro(a, b) fun(int a , int b);
vector<int> fun(int a , int b);
</pre>

2): and the current is not public /protected /private

eg.
<pre>int x:1,y:1,z:1;</pre>

3),

e.g.
<pre>int x , y, z;</pre>

4)<
<pre>
e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;
</pre>
5)::
e.g.
<pre>
std::string

MyClass MyClass ::fun() {}
</pre>
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-08-01T02:33:01Z

Blueshake: /* deal with const */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet a char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to store the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g.
<pre>delete p;

MyClass.fun();

MyClass->fun();
</pre>

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.eg.
<pre>
int main() {cout <<endl;}
</pre>

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is. And set the related scope.

e.g.
<pre>
class MyClass
{
public :
int x;
int y;
};
</pre>
Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.e.g.
<pre>
if (a > b)

c = a;

else

c = b;
</pre>

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }
<pre>
typedef int INT;
</pre>
More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here. e.g.
<pre>
int add(int a, int b)

{

return a+b;

}
</pre>
==deal with const ==
just clear the m_str.It means that maybe a new variable or function is going to be defined.

e.g.

<pre>
const int a = 3;

const int getVal(int a);
</pre>

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g.
<pre>
#include <iostream>

#define MAXNUM 10

#if
</pre>

==deal with using ==
skip the context until it meet ;or }
<pre>
using namespace std;
</pre>

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ; e.g.
<pre>
class Myclass
{

int x;
int y;

};
</pre>

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

==deal with operator ==
eg.
<pre>
MyClass operator () (size_t param);
MyClass operator += (MyClass param);
</pre>
== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (
<pre>
Macro(a, b) fun(int a , int b);
vector<int> fun(int a , int b);
</pre>

2): and the current is not public /protected /private

eg.
<pre>int x:1,y:1,z:1;</pre>

3),

e.g.
<pre>int x , y, z;</pre>

4)<
<pre>
e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;
</pre>
5)::
e.g.
<pre>
std::string

MyClass MyClass ::fun() {}
</pre>
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-08-01T02:26:14Z

Blueshake: /* Parsethread */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet a char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to store the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g.
<pre>delete p;

MyClass.fun();

MyClass->fun();
</pre>

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.eg.
<pre>
int main() {cout <<endl;}
</pre>

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is. And set the related scope.

e.g.
<pre>
class MyClass
{
public :
int x;
int y;
};
</pre>
Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.e.g.
<pre>
if (a > b)

c = a;

else

c = b;
</pre>

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }
<pre>
typedef int INT;
</pre>
More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here. e.g.
<pre>
int add(int a, int b)

{

return a+b;

}
</pre>
==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g.
<pre>
#include <iostream>

#define MAXNUM 10

#if
</pre>

==deal with using ==
skip the context until it meet ;or }
<pre>
using namespace std;
</pre>

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ; e.g.
<pre>
class Myclass
{

int x;
int y;

};
</pre>

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

==deal with operator ==
eg.
<pre>
MyClass operator () (size_t param);
MyClass operator += (MyClass param);
</pre>
== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (
<pre>
Macro(a, b) fun(int a , int b);
vector<int> fun(int a , int b);
</pre>

2): and the current is not public /protected /private

eg.
<pre>int x:1,y:1,z:1;</pre>

3),

e.g.
<pre>int x , y, z;</pre>

4)<
<pre>
e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;
</pre>
5)::
e.g.
<pre>
std::string

MyClass MyClass ::fun() {}
</pre>
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:19:38Z

Blueshake: /* operator */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

==deal with using ==
skip the context until it meet ;or }

e.g.

using namespace std;

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

==deal with operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:17:52Z

Blueshake: /* untion */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

==deal with using ==
skip the context until it meet ;or }

e.g.

using namespace std;

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

==deal with struct ==
the same to class

==deal with enum ==
the same to class

==deal with untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.

== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:17:39Z

Blueshake: /* enum */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

==deal with using ==
skip the context until it meet ;or }

e.g.

using namespace std;

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

==deal with struct ==
the same to class

==deal with enum ==
the same to class

== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:17:23Z

Blueshake: /* struct */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

==deal with using ==
skip the context until it meet ;or }

e.g.

using namespace std;

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

==deal with struct ==
the same to class

== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:17:09Z

Blueshake: /* class */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

==deal with using ==
skip the context until it meet ;or }

e.g.

using namespace std;

==deal with namespace ==
skip context between < and > if the next token is <

==deal with class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:16:57Z

Blueshake: /* namespace */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

==deal with using ==
skip the context until it meet ;or }

e.g.

using namespace std;

==deal with namespace ==
skip context between < and > if the next token is <

== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:16:43Z

Blueshake: /* using */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

==deal with using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:16:28Z

Blueshake: /* # */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

==deal with # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:16:11Z

Blueshake: /* static virtual inline */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

==deal with static virtual inline ==
do nothing

== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:15:57Z

Blueshake: /* __asm */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

==deal with __asm ==
skip the context until it meet ;

== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:15:41Z

Blueshake: /* extern */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

==deal with extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;

== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:15:26Z

Blueshake: /* const */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

==deal with const ==
just clear th e m_str

== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:14:56Z

Blueshake: /* return : */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

==deal with return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:14:24Z

Blueshake: /* typedef */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

==deal with typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:14:06Z

Blueshake: /* while if do else for switch */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

==deal with while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:13:46Z

Blueshake: /* delete . -> */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==deal with delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:13:08Z

Blueshake: /* Parsethread */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# '''SkipToOneOfChars''' This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# '''SkipBlock''' This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# '''SkipAngleBraces''' This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:02:04Z

Blueshake: /* Parsethread */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.

The '''m_Str''' is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.

In the function DoParse,it analyze the tokens it meets as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T04:00:35Z

Blueshake: /* while if do else for switch */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g.

if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:59:56Z

Blueshake: /* operator */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g. if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg.

MyClass operator () (size_t param);
MyClass operator += (MyClass param);

== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:59:15Z

Blueshake: /* others */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g. if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above.So the next token should be judged.

According to the next token ,it can be divided into several situation as followed.

1) the next one's fisrt char is (

eg. Macro(a, b) fun(int a , int b);

eg. vector<int> fun(int a , int b);

2): and the current is not public /protected /private

eg. int x:1,y:1,z:1;

3),

e.g. int x , y, z;

4)<

e.g. someclass<void>::memberfunc;

e.g. std::map<int, int> somevar;

5)::

e.g. std::string

e.g. MyClass MyClass ::fun() {}

6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:56:04Z

Blueshake: /* class */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g. if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip context until the
parser meet } or ;

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:54:29Z

Blueshake: /* class */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g. if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it.

e.g.

class Myclass

{

int x;
int y;

};

== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:53:04Z

Blueshake: /* using */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g. if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }

e.g.

using namespace std;

== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:52:02Z

Blueshake: /* while if do else for switch */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.

e.g. if (a > b)

c = a;

else

c = b;

== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:51:10Z

Blueshake: /* typedef */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

typedef int INT;

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:50:09Z

Blueshake: /* return : */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

e.g. int add(int a, int b)

{

return a+b;

}

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:48:22Z

Blueshake: /* # */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

e.g. #include <iostream>

e.g. #define MAXNUM 10

e.g. #if

== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:46:26Z

Blueshake: /* # */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
Handle include if the next token is include.

Handle define if the next token is define.

otherwise handle the preprocessor block.

== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:43:22Z

Blueshake: /* return : */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }

Because the parser believe that there is no chance for variab definition here.

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
handle include if the next token is include
handle define if the next token is define
otherwise handle the preprocessor block
== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:43:03Z

Blueshake: /* return : */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

More Information, see below.

== return :==
The parser skips the context until it meet the ; or }
Because the parser believe that there is no chance for variab definition here.

== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
handle include if the next token is include
handle define if the next token is define
otherwise handle the preprocessor block
== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:39:47Z

Blueshake: /* typedef */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
When parser meet this token ,it calls HandleTypedef function to deal with it if the option handletypedef is true.
Otherwise,it will skip the next context until it meet ;or }

More Information, see below.

== return :==
skip the context until it meet the ; or }
== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
handle include if the next token is include
handle define if the next token is define
otherwise handle the preprocessor block
== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:36:25Z

Blueshake: /* deal with } */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
The parser clears the scope and domain.So it means it's a new begin.
By the way,it also clear m_Str.

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
call HandleTypedef to deal with it if the option handletypedef is true.
otherwise,it will skip the context until it meet ;or }
== return :==
skip the context until it meet the ; or }
== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
handle include if the next token is include
handle define if the next token is define
otherwise handle the preprocessor block
== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:31:10Z

Blueshake: /* : */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
clear the scope and relation it belong to .

== deal with : ==
When parser meets this token.It will judge what the last token is.And set the related scope.

e.g.

class MyClass

{
public :
int x;
int y;
};

Here the scope is public.

== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
call HandleTypedef to deal with it if the option handletypedef is true.
otherwise,it will skip the context until it meet ;or }
== return :==
skip the context until it meet the ; or }
== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
handle include if the next token is include
handle define if the next token is define
otherwise handle the preprocessor block
== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:24:02Z

Blueshake: /* deal with { */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
The parser will skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.

e.g. int main() {cout <<endl;}

==deal with }==
clear the scope and relation it belong to .

== : ==
set the scope .
== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
call HandleTypedef to deal with it if the option handletypedef is true.
otherwise,it will skip the context until it meet ;or }
== return :==
skip the context until it meet the ; or }
== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
handle include if the next token is include
handle define if the next token is define
otherwise handle the preprocessor block
== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:22:46Z

Blueshake: /* delete . -> */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
when parser meet these three tokens it will skip the next tokens until it meet token ; or }

e.g. delete p;

e.g. MyClass.fun();

e.g. MyClass->fun();

==deal with { ==
skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.
e.g. int main() {cout <<endl;}
==deal with }==
clear the scope and relation it belong to .

== : ==
set the scope .
== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
call HandleTypedef to deal with it if the option handletypedef is true.
otherwise,it will skip the context until it meet ;or }
== return :==
skip the context until it meet the ; or }
== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
handle include if the next token is include
handle define if the next token is define
otherwise handle the preprocessor block
== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.

Talk:Code Completion Design

2009-07-31T03:18:26Z

Blueshake: /* clear m_Str */

=Should be added to the article page soon=

=Parsethread=
Three important functions should be introduced before we started .
# SkipToOneOfChars This function is used to skip any tokens until it meet any char in chars which is the parameter you pass.
# SkipBlock This function is used to skip block between two brances,for example ,{[()]}.If the block contain the proprocessor ,it will deal with it.
# SkipAngleBraces This function is used to skip the context between < and >.
the m_Str is used to stored the token can not be decided .

The three functions above are used to skip tokens we wantn't to parse.It can acclerate the speed of parser.
In the function DoParse,it analyze the tokens it meet as follow:

==clear m_Str==
just clear the m_str,because the parser believe the token has been recognized correctly.
e.g. int a;

==delete . ->==
skip the tokens until it meet ; or }
e.g. delete p;
e.g. MyClass .fun();
e.g. MyClass->fun();
==deal with { ==
skip the context between { and } if the usebuffer or the bufferskipblock is true in the option.
e.g. int main() {cout <<endl;}
==deal with }==
clear the scope and relation it belong to .

== : ==
set the scope .
== while if do else for switch==
skip the context until it meet ;or } if the usebuffer or the bufferskipblock is true in the option.
== typedef==
call HandleTypedef to deal with it if the option handletypedef is true.
otherwise,it will skip the context until it meet ;or }
== return :==
skip the context until it meet the ; or }
== const ==
just clear th e m_str
== extern ==
call DoParse if the next token is "c",otherwise,skip the context until it meet ;
== __asm ==
skip the context until it meet ;
== static virtual inline ==
do nothing
== # ==
handle include if the next token is include
handle define if the next token is define
otherwise handle the preprocessor block
== using ==
skip the context until it meet ;or }
== namespace ==
skip context between < and > if the next token is <
== class ==
handle class if the option handleclass is true.otherwise skip it
== struct ==
the same to class
== enum ==
the same to class
== untion ==
skip the context until it meet }or;
call DoParse to analyze the context in the untion.
== operator ==
eg. MyClass operator () (size_t param);
MyClass operator += (MyClass param);
== others ==
It means that the current token is not any one above .
According to the next token ,it can be divided into several situation as followed .
1) the next one's fisrt char is (.
eg. Macro(a, b) fun(int a , int b);
eg. vector<int> fun(int a , int b);
2): and the current is not public /protected /private .
eg. int x:1,y:1,z:1;
3),
e.g. int x , y, z;
4)<
e.g. someclass<void>::memberfunc;
e.g. std::map<int, int> somevar;
5)::
e.g. std::string
e.g. MyClass MyClass ::fun() {}
6) ;

==Handling class example==
The main routing of handling class was in
ParserThread::HandleClass function
If the parserThread meet these statement
<pre>
class AAA{
int m_a;
int m_b;
} ;
</pre>
It will surely add a Token of "AAA", which has a type of "class".

What about these statements
<pre>
class AAA{
int m_a;
int m_b;
} x,y,z;
</pre>
The parserThread should firstly add a Token "AAA", then it should regard "x", "y", "z" are three variables of type "AAA". This was done by "ReadVarNames()" function, it will read every comma separated variables after a class declaration

==Handling typedef==

Sometimes, you can see these code:
<pre>
typedef class AAA{
int m_a;
int m_b;
} BBB,CCC;
</pre>
If the parser meet the keyword "typedef", firstly it set the "m_ParsingTypedef = ture" to indicate that we are parsing a typedef statement.

Next, it meets a keyword "class", which also indicate it is a class declaration. So, the HandleClass function will do the task. A Token of "class AAA" will be added to the TokensTree. Wait a minute, how can we deal with "BBB" and "CCC", this is not the same case as previous code, we can't regard "BBB","CCC" as variables. In this case, another function "ReadClsName()" will be called. For simplicity of TokensTree, we just regard "BBB" and "CCC" as derived class of "AAA".

How does the parser know between these two cases. Here is the code:

<pre>
if (m_ParsingTypedef)
{
m_Str.Clear();
ReadClsNames(newToken->m_Name);
// m_ParsingTypedef = false;
break;

}
else
{
m_Str = newToken->m_Name;
ReadVarNames();
m_Str.Clear();
break;
}
</pre>

That's the whole thing I would like to write about handling class and handling typedef.