Check macro usage on every identifier like token: issues and discussions

Developer forums (C::B DEVELOPMENT STRICTLY!) > CodeCompletion redesign

<< < (3/8) > >>

ollydbg:
OK, I found the cause of this regression, I get the parenthesis is L"(* FuncArray [ 10 ] [ 20 ])", and if without my patch, it don't have a space after the "FuncArray", this is because in my patch serials, I have change the function of reading the parenthesis. (The old code is hard to understand for me, and using raw wxChar pointers).

Then in the function:

--- Code: --- // pattern: m_Str AAA (*BBB) (...);
if (peek == ParserConsts::semicolon && pos != wxNOT_FOUND)
{
name.RemoveLast(); // remove ")"
name.Remove(0, pos+1).Trim(false); // remove "(* "

// pattern: m_Str AAA (*BBB[X][Y]) (...);
pos = name.find(ParserConsts::oparray_chr);
if (pos != wxNOT_FOUND)
name.Remove(pos);

TRACE(_T("HandleFunction() : Add token name='")+name+_T("', args='")+args+_T("', return type='") + m_Str+ _T("'"));
Token* newToken = DoAddToken(tkFunction, name, lineNr, 0, 0, args);

--- End code ---
We pass the name as "FuncArray " (note a space after "FuncArray".

Now, I think I need to return a more compact form like "(*FuncArray[10][20])".

EDIT: the old code for reading parenthesis dose not consider the macro expansion in its content, it just find the "(" and ")" pair in the raw wxString, while in my patch serials, I do macro expansion on every token if possible.

ollydbg:
Now, here comes the function I need to implement, it looks like "space" are added only in some very special cases.

--- Code: ---void Tokenizer::ReadParentheses(wxString& str)
{
// we create a local buffer here, so the data is copied from m_Buffer to buffer
// once the local buffer is full, we append the content in local buffer to the result str
static const size_t maxBufferLen = 4093;
// local buffer
wxChar buffer[maxBufferLen + 3];
buffer[0] = _T('$'); // avoid segfault error, because we have some *(p - 1) = x in the code
wxChar* realBuffer = buffer + 1;
// p points to the local buffer
wxChar* p = realBuffer;

int level = 0; // brace level of '(' and ')'

while (NotEOF())
{
while (SkipComment())
;
wxChar ch = CurrentChar();

while (ch == _T('#')) // do not use if
{
const PreprocessorType type = GetPreprocessorType();
if (type == ptOthers)
break;
HandleConditionPreprocessor(type);
ch = CurrentChar();
}

const unsigned int startIndex = m_TokenIndex;

switch(ch)
{
case _T('('):
{
++level;
*p = ch;
++p;
}
break;

case _T(')'):
{
if (*(p - 1) <= _T(' '))
--p; // if previous char is a space, we overwrite the space with a ')', so we save one char
--level;
*p = ch;
++p;
}
break;

case _T('\''):
case _T('"'):
{
MoveToNextChar(); // skip the leading '"' or '\''
SkipToStringEnd(ch); // m_TokenIndex point to the trailing '"' or '\'' now
MoveToNextChar(); // move to the char after trailing char
const size_t writeLen = m_TokenIndex - startIndex; // the string length
const size_t usedLen = p - realBuffer;
if (usedLen + writeLen > maxBufferLen) // there is not enough space left to write the string
{
if (writeLen > maxBufferLen) // to big string?
{
TRACE(_T("ReadParentheses(): Catch exception 1: %lu"), static_cast<unsigned long>(writeLen));
return;
}

if (p != realBuffer) // add the used string to the result str
{
str.Append(realBuffer, usedLen);
p = realBuffer; // adjust the p, as it was an empty buffer
}
// append the string to str (not write the string to the buffer)
str.Append((const wxChar*)m_Buffer + startIndex, writeLen);
}
else
{ // the buffer can hold the string, so copy it to the buffer
memcpy(p, (const wxChar*)m_Buffer + startIndex, writeLen * sizeof(wxChar));
p += writeLen;
}

continue;
}
break;

case _T(','): // if there is a space before the comma, we just remove it, but we should add a space after the comma
case _T('*'):
case _T('&'):
{
if (*(p - 1) <= _T(' '))
--p;

*p = ch;
*++p = _T(' ');
++p;
}
break;

case _T('='):
{
if (*(p - 1) <= _T(' '))
{
*p = _T('=');
// Don't add a space after '=' sign, in case another '=' follows it
// (see how the 'else' block below works).
//*++p = _T(' ');
++p;
}
else // special handling of "==" "=!" "=>" and "=<"
{
switch (*(p - 1))
{
case _T('='):
case _T('!'):
case _T('>'):
case _T('<'):
{
*p = _T('=');
*++p = _T(' ');
++p;
}
break;

default:
{
*p = _T(' ');
*++p = _T('=');
*++p = _T(' ');
++p;
}
break;
}
}
}
break;

case _T(' '): // we only add a space if the former char is not a space, also not a '('
case _T('\r'): // the tab char are regard as space
case _T('\t'):
{
if (*(p - 1) != _T(' ') && *(p - 1) != _T('('))
{
*p = _T(' ');
++p;
}
}
break;

case _T('\n'): // we need keep the \n for records paras correct position
if (*(p - 1) == _T(' '))
--p;
if (*(p - 1) != _T('('))
{
*p = ch;
++p;
}
break;

default: // any other case, we can directly copy the char
{
*p = ch;
++p;
}
break;
}

if (p >= realBuffer + maxBufferLen)
{
str.Append(realBuffer, p - realBuffer);
p = realBuffer;
}

MoveToNextChar();

if (level == 0)
break;
}//while (NotEOF())

if (p > realBuffer)
str.Append(realBuffer, p - realBuffer);
TRACE(_T("ReadParentheses(): %s, line=%u"), str.wx_str(), m_LineNumber);
if (str.Len() > 512)
{ TRACE(_T("ReadParentheses(): Catch exception 2: %lu"), static_cast<unsigned long>(str.Len())); }
}

--- End code ---

So, I need to follow this way. :)

ollydbg:
OK, the only regression is fixed now.
I have attach the full patches (include git style patch serials, or a single svn patch)

ollydbg:
One issue for macro replacement parsing is that if you have such code:

--- Code: ---#define uint8 unsigned char
void f(uint8 aaa);

--- End code ---

Then the parser will see this function declaration:

--- Code: ---void f(unsigned char aaa);
--- End code ---

This is because we try to expand every macro usage.

Does this cause some issue?

oBFusCATed:
Would you this problem affect the autocompletion, calltip and symbol browser?

Navigation

[0] Message Index

[#] Next page

[*] Previous page

Go to full version