Statements: Removed this bastard from cppcheck
This commit is contained in:
Daniel Marjamäki
parent
62e06185f8
commit
7b084fb1c4
477
Statements.cpp
477
Statements.cpp
|
|
@ -1,477 +0,0 @@
|
|||
|
||||
#include "Statements.h"
|
||||
#include "tokenize.h"
|
||||
|
||||
#include "CommonCheck.h" // <- IsName
|
||||
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
|
||||
std::vector<std::string> VariableNames;
|
||||
std::list<STATEMENT> Statements;
|
||||
|
||||
extern bool Debug;
|
||||
extern bool ShowAll;
|
||||
|
||||
|
||||
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
// Create statement list
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
static void AppendStatement(STATEMENT::etype Type, TOKEN *tok, std::string Var="")
|
||||
{
|
||||
STATEMENT NewStatement;
|
||||
NewStatement.Type = Type;
|
||||
NewStatement.Token = tok;
|
||||
if (Var.empty())
|
||||
{
|
||||
NewStatement.VarIndex = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
bool Found = false;
|
||||
for (unsigned int i = 0; i < VariableNames.size(); i++)
|
||||
{
|
||||
if (VariableNames[i] == Var)
|
||||
{
|
||||
Found = true;
|
||||
NewStatement.VarIndex = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if ( ! Found )
|
||||
{
|
||||
NewStatement.VarIndex = VariableNames.size();
|
||||
VariableNames.push_back(Var);
|
||||
}
|
||||
}
|
||||
|
||||
Statements.push_back(NewStatement);
|
||||
}
|
||||
|
||||
static TOKEN *GotoNextStatement(TOKEN *tok)
|
||||
{
|
||||
if (tok && (tok->str[0]=='{' || tok->str[0]=='}'))
|
||||
return tok->next;
|
||||
|
||||
if (tok)
|
||||
tok = tok->next;
|
||||
int parlevel = 0;
|
||||
for (; tok; tok = tok->next)
|
||||
{
|
||||
if (tok->str[0] == '(')
|
||||
parlevel++;
|
||||
else if (tok->str[0] == ')')
|
||||
parlevel--;
|
||||
if (strchr("{}", tok->str[0]))
|
||||
break;
|
||||
if (parlevel==0 && tok->str[0] == ';')
|
||||
{
|
||||
while (tok && tok->str[0] == ';')
|
||||
tok = tok->next;
|
||||
break;
|
||||
}
|
||||
}
|
||||
return tok;
|
||||
}
|
||||
|
||||
|
||||
static void GetVariableName(TOKEN * &Token, std::string &varname)
|
||||
{
|
||||
varname = "";
|
||||
|
||||
if (Token == NULL)
|
||||
return;
|
||||
|
||||
if (!IsName(Token->str))
|
||||
return;
|
||||
|
||||
// Get variable name..
|
||||
std::ostringstream ostr;
|
||||
bool array = false;
|
||||
bool name = false;
|
||||
for (TOKEN *tok = Token; tok; tok = tok->next)
|
||||
{
|
||||
const char *str = tok->str;
|
||||
|
||||
if ((array) || (str[0]=='['))
|
||||
{
|
||||
ostr << str;
|
||||
array = (str[0] != ']');
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
if (name && IsName(str))
|
||||
return;
|
||||
name = IsName(str);
|
||||
if (!name && strcmp(str,".") && strcmp(str,"->") && strcmp(str,"::"))
|
||||
{
|
||||
if (str[0] == '(')
|
||||
return;
|
||||
Token = tok;
|
||||
break;
|
||||
}
|
||||
ostr << str;
|
||||
}
|
||||
}
|
||||
|
||||
varname = ostr.str();
|
||||
}
|
||||
|
||||
|
||||
void CreateStatementList()
|
||||
{
|
||||
// Clear lists..
|
||||
VariableNames.clear();
|
||||
Statements.clear();
|
||||
|
||||
int indentlevel = 0;
|
||||
for (TOKEN *tok = tokens; tok; tok = GotoNextStatement(tok))
|
||||
{
|
||||
if (tok->str[0] == '{')
|
||||
{
|
||||
AppendStatement(STATEMENT::OBRACE, tok);
|
||||
indentlevel++;
|
||||
}
|
||||
else if (tok->str[0] == '}')
|
||||
{
|
||||
AppendStatement(STATEMENT::EBRACE, tok);
|
||||
indentlevel--;
|
||||
}
|
||||
else if (indentlevel >= 1)
|
||||
{
|
||||
bool hasif = false, hasloop = false, hasswitch = false;
|
||||
|
||||
if (strcmp(tok->str,"if")==0)
|
||||
{
|
||||
hasif = true;
|
||||
AppendStatement(STATEMENT::IF, tok);
|
||||
}
|
||||
else if (strcmp(tok->str,"else")==0)
|
||||
{
|
||||
hasif = true;
|
||||
if (strcmp(getstr(tok,1),"if")==0)
|
||||
AppendStatement(STATEMENT::ELSEIF, tok);
|
||||
else
|
||||
AppendStatement(STATEMENT::ELSE, tok);
|
||||
}
|
||||
|
||||
else if (strcmp(tok->str,"do")==0 ||
|
||||
strcmp(tok->str,"while")==0 ||
|
||||
strcmp(tok->str,"for")==0)
|
||||
{
|
||||
AppendStatement(STATEMENT::LOOP, tok);
|
||||
hasloop = true;
|
||||
}
|
||||
|
||||
else if (strcmp(tok->str,"switch")==0)
|
||||
{
|
||||
AppendStatement(STATEMENT::SWITCH, tok);
|
||||
hasswitch = true;
|
||||
}
|
||||
|
||||
// Declaring variables..
|
||||
if (IsName(tok->str) && strcmp(tok->str,"delete") && strcmp(tok->str,"return"))
|
||||
{
|
||||
const char *str1 = getstr(tok, 1);
|
||||
bool decl = IsName(str1) || str1[0]=='*';
|
||||
for (TOKEN *tok2 = decl ? tok->next : NULL; tok2; tok2 = tok2->next)
|
||||
{
|
||||
if (strchr("{};.", tok2->str[0]))
|
||||
break;
|
||||
|
||||
const char *str1 = getstr(tok2, 1);
|
||||
if (IsName(tok2->str) && strchr("[=,;",str1[0]))
|
||||
{
|
||||
AppendStatement(STATEMENT::DECL, tok2, tok2->str);
|
||||
while (tok2 && !strchr(",;", tok2->str[0]))
|
||||
tok2 = tok2->next;
|
||||
if (tok2->str[0] == ';')
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// Assign..
|
||||
for (TOKEN *tok2 = tok; tok2; tok2 = tok2->next)
|
||||
{
|
||||
if (strchr("{};", tok2->str[0]))
|
||||
break;
|
||||
|
||||
TOKEN *eq = tok2;
|
||||
std::string varname = "";
|
||||
GetVariableName(eq, varname);
|
||||
|
||||
// Equal with..
|
||||
if (eq && strcmp(eq->str,"=")==0 && !varname.empty())
|
||||
{
|
||||
TOKEN *rs = eq->next;
|
||||
|
||||
bool ismalloc = false;
|
||||
if ( Match(rs, "%var% (") )
|
||||
{
|
||||
ismalloc |= Match(rs, "strdup (");
|
||||
ismalloc |= Match(rs, "malloc (");
|
||||
ismalloc |= Match(rs, "kmalloc (");
|
||||
}
|
||||
else
|
||||
{
|
||||
ismalloc |= Match(rs, "( %type% * ) malloc (");
|
||||
ismalloc |= Match(rs, "( %type% * * ) malloc (");
|
||||
ismalloc |= Match(rs, "( %type% %type% * ) malloc (");
|
||||
ismalloc |= Match(rs, "( %type% %type% * * ) malloc (");
|
||||
ismalloc |= Match(rs, "( %type% * ) kmalloc (");
|
||||
ismalloc |= Match(rs, "( %type% * * ) kmalloc (");
|
||||
ismalloc |= Match(rs, "( %type% %type% * ) kmalloc (");
|
||||
ismalloc |= Match(rs, "( %type% %type% * * ) kmalloc (");
|
||||
}
|
||||
|
||||
if ( ismalloc )
|
||||
AppendStatement(STATEMENT::MALLOC, tok2, varname);
|
||||
|
||||
else if ( Match(rs,"new %type% ;") )
|
||||
AppendStatement(STATEMENT::NEW, tok2, varname);
|
||||
|
||||
else if ( Match(rs, "new %type% (") )
|
||||
AppendStatement(STATEMENT::NEW, tok2, varname);
|
||||
|
||||
else if ( Match(rs, "new %type% [") )
|
||||
AppendStatement(STATEMENT::NEWARRAY, tok2, varname);
|
||||
|
||||
else
|
||||
AppendStatement(STATEMENT::ASSIGN, tok2, varname);
|
||||
|
||||
tok2 = eq;
|
||||
}
|
||||
}
|
||||
|
||||
// Delete..
|
||||
for (TOKEN *tok2 = tok; tok2; tok2 = tok2->next)
|
||||
{
|
||||
if (strchr("{};", tok2->str[0]))
|
||||
break;
|
||||
|
||||
if (Match(tok2, "free ( %var% ) ;"))
|
||||
AppendStatement(STATEMENT::FREE, tok2, getstr(tok2, 2));
|
||||
|
||||
if (Match(tok2, "kfree ( %var% ) ;"))
|
||||
AppendStatement(STATEMENT::FREE, tok2, getstr(tok2, 2));
|
||||
|
||||
if (Match(tok2, "delete %var% ;"))
|
||||
AppendStatement(STATEMENT::DELETE, tok2, getstr(tok2,1));
|
||||
|
||||
if (Match(tok2, "delete [ ] %var% ;"))
|
||||
AppendStatement(STATEMENT::DELETEARRAY, tok2, getstr(tok2,3));
|
||||
}
|
||||
|
||||
// Use..
|
||||
bool UseVar = false;
|
||||
int parlevel = 0;
|
||||
for (TOKEN *tok2 = tok; tok2; tok2 = tok2->next)
|
||||
{
|
||||
if (parlevel==0 && strchr("{};", tok2->str[0]))
|
||||
break;
|
||||
|
||||
if (Match(tok2,"free ( %var% )"))
|
||||
break;
|
||||
|
||||
if (tok2->str[0] == '(')
|
||||
parlevel++;
|
||||
if (tok2->str[0] == ')')
|
||||
parlevel--;
|
||||
if (parlevel == 0 && tok2->str[0] == ',')
|
||||
UseVar = false;
|
||||
|
||||
else if (tok2->str[0]=='=' || tok2->str[0]=='(')
|
||||
UseVar = true;
|
||||
|
||||
else if (UseVar && IsName(tok2->str))
|
||||
{
|
||||
std::string varname = "";
|
||||
GetVariableName(tok2, varname);
|
||||
|
||||
if (!varname.empty() &&
|
||||
varname!="continue" &&
|
||||
varname!="break" &&
|
||||
varname!="return")
|
||||
{
|
||||
AppendStatement(STATEMENT::USE, tok2, varname);
|
||||
}
|
||||
|
||||
if (tok2->str[0] == ')')
|
||||
parlevel--;
|
||||
|
||||
if (parlevel==0 && tok2->str[0]==';')
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Return, continue, break..
|
||||
for (TOKEN *tok2 = tok; tok2; tok2 = tok2->next)
|
||||
{
|
||||
if (strchr("{};", tok2->str[0]))
|
||||
break;
|
||||
|
||||
if (strcmp(tok2->str,"continue")==0)
|
||||
{
|
||||
AppendStatement(STATEMENT::CONTINUE, tok2);
|
||||
break;
|
||||
}
|
||||
|
||||
if (strcmp(tok2->str,"break")==0)
|
||||
{
|
||||
AppendStatement(STATEMENT::BREAK, tok2);
|
||||
break;
|
||||
}
|
||||
|
||||
if (strcmp(tok2->str,"return")==0)
|
||||
{
|
||||
if (IsName(getstr(tok2,1)) && strcmp(getstr(tok2,2),";")==0)
|
||||
AppendStatement(STATEMENT::RETURN, tok2, getstr(tok2,1));
|
||||
|
||||
else
|
||||
AppendStatement(STATEMENT::RETURN, tok2, ";");
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (hasif)
|
||||
{
|
||||
AppendStatement(STATEMENT::ENDIF, tok);
|
||||
}
|
||||
else if (hasloop)
|
||||
{
|
||||
AppendStatement(STATEMENT::ENDLOOP, tok);
|
||||
}
|
||||
else if (hasswitch)
|
||||
{
|
||||
AppendStatement(STATEMENT::ENDSWITCH, tok);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (Debug)
|
||||
{
|
||||
OutputStatementList( std::cout );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void OutputStatementList( std::ostream &ostr )
|
||||
{
|
||||
std::list<STATEMENT>::const_iterator it;
|
||||
for (it = Statements.begin(); it != Statements.end(); it++)
|
||||
{
|
||||
STATEMENT s = *it;
|
||||
// ostr << it->Token->linenr << " : ";
|
||||
switch (s.Type)
|
||||
{
|
||||
case STATEMENT::OBRACE:
|
||||
ostr << "{";
|
||||
break;
|
||||
|
||||
case STATEMENT::EBRACE:
|
||||
ostr << "}";
|
||||
break;
|
||||
|
||||
case STATEMENT::DECL:
|
||||
ostr << "decl " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::ASSIGN:
|
||||
ostr << "assign " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::MALLOC:
|
||||
ostr << "malloc " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::FREE:
|
||||
ostr << "free " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::NEW:
|
||||
ostr << "new " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::NEWARRAY:
|
||||
ostr << "new[] " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::DELETE:
|
||||
ostr << "delete " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::DELETEARRAY:
|
||||
ostr << "delete[] " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::USE:
|
||||
ostr << "use " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
|
||||
case STATEMENT::LOOP:
|
||||
ostr << "loop";
|
||||
break;
|
||||
|
||||
case STATEMENT::ENDLOOP:
|
||||
ostr << "endloop";
|
||||
break;
|
||||
|
||||
|
||||
case STATEMENT::SWITCH:
|
||||
ostr << "switch";
|
||||
break;
|
||||
|
||||
case STATEMENT::ENDSWITCH:
|
||||
ostr << "endswitch";
|
||||
break;
|
||||
|
||||
|
||||
case STATEMENT::IF:
|
||||
ostr << "if";
|
||||
break;
|
||||
|
||||
case STATEMENT::ELSEIF:
|
||||
ostr << "elseif";
|
||||
break;
|
||||
|
||||
case STATEMENT::ELSE:
|
||||
ostr << "else";
|
||||
break;
|
||||
|
||||
case STATEMENT::ENDIF:
|
||||
ostr << "endif";
|
||||
break;
|
||||
|
||||
case STATEMENT::RETURN:
|
||||
ostr << "return " << VariableNames[s.VarIndex];
|
||||
break;
|
||||
|
||||
case STATEMENT::CONTINUE:
|
||||
ostr << "continue";
|
||||
break;
|
||||
|
||||
case STATEMENT::BREAK:
|
||||
ostr << "break";
|
||||
break;
|
||||
|
||||
default:
|
||||
ostr << "ERROR. Unknown code!!";
|
||||
break;
|
||||
}
|
||||
ostr << "\n";
|
||||
}
|
||||
}
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
|
||||
|
||||
|
||||
39
Statements.h
39
Statements.h
|
|
@ -1,39 +0,0 @@
|
|||
//---------------------------------------------------------------------------
|
||||
#ifndef StatementsH
|
||||
#define StatementsH
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
#include <list>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
extern std::vector<std::string> VariableNames;
|
||||
|
||||
// Forward declaration
|
||||
struct TOKEN;
|
||||
|
||||
struct STATEMENT
|
||||
{
|
||||
enum etype {OBRACE, EBRACE,
|
||||
DECL, ASSIGN, USE,
|
||||
MALLOC, FREE,
|
||||
NEW, DELETE,
|
||||
NEWARRAY, DELETEARRAY,
|
||||
LOOP, ENDLOOP,
|
||||
IF, ELSE, ELSEIF, ENDIF,
|
||||
SWITCH, ENDSWITCH,
|
||||
RETURN, CONTINUE, BREAK};
|
||||
etype Type;
|
||||
unsigned int VarIndex;
|
||||
TOKEN *Token;
|
||||
};
|
||||
|
||||
extern std::list<STATEMENT> Statements;
|
||||
|
||||
void CreateStatementList();
|
||||
|
||||
void OutputStatementList( std::ostream &ostr );
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
#endif
|
||||
//---------------------------------------------------------------------------
|
||||
Loading…
Reference in New Issue