Извлечение входных параметров и их типа идентификатора при разборе файла AC с использованием PycParser
Примечание: те, кто знаком с pycparser, гораздо лучше поймут проблему.
Я использую pycparser v2.10, и я пытаюсь извлечь все функции, которые были определены в файле C, а также извлечь его имя входного параметра и тип идентификатора при синтаксическом анализе этого файла C (используя pycparser).
Пример кода
import sys
sys.path.extend(['.', '..'])
CPPPATH = '../utils/cpp.exe' if sys.platform == 'win32' else 'cpp'
from pycparser import c_parser, c_ast, parse_file
class FunctionParameter(c_ast.NodeVisitor):
def visit_FuncDef(self, node):
#node.decl.type.args.params
print "Function name is", node.decl.name, "at", node.decl.coord
print " It's parameters name and type is (are)"
for params in (node.decl.type.args.params):
print " ", params.name, params.type
def func_parameter(filename):
ast = parse_file(filename, use_cpp=True, cpp_path=CPPPATH, cpp_args=r'-I../utils/fake_libc/include')
vf = FunctionParameter()
vf.visit(ast)
if __name__ == '__main__':
if len(sys.argv) > 1:
filename = sys.argv[1]
else:
filename = 'c_files/hash.c'
func_parameter(filename)
Здесь, в visit_FuncDef, я печатаю имя функции, а затем в цикле for, это параметры.
Проблема в том, что я могу получить имя входного параметра, переданного функции, используя params.name но не в состоянии получить его тип идентификатора с помощью params.type в цикле for.
Может кто-нибудь сказать мне, как я могу извлечь идентификатор параметра?
Кстати, вывод выглядит так:
Function name is hash_func at c_files/hash.c:32
It's parameters name and type is (are)
str <pycparser.c_ast.PtrDecl object at 0x00000000024EFC88>
table_size <pycparser.c_ast.TypeDecl object at 0x00000000024EFEF0>
Function name is HashCreate at c_files/hash.c:44
It's parameters name and type is (are)
hash <pycparser.c_ast.PtrDecl object at 0x00000000024FABE0>
table_size <pycparser.c_ast.TypeDecl object at 0x00000000024FAE48>
Function name is HashInsert at c_files/hash.c:77
It's parameters name and type is (are)
hash <pycparser.c_ast.PtrDecl object at 0x00000000024F99E8>
entry <pycparser.c_ast.PtrDecl object at 0x00000000024F9BE0>
Function name is HashFind at c_files/hash.c:100
It's parameters name and type is (are)
hash <pycparser.c_ast.PtrDecl object at 0x00000000028C4160>
key <pycparser.c_ast.PtrDecl object at 0x00000000028C4358>
Function name is HashRemove at c_files/hash.c:117
It's parameters name and type is (are)
hash <pycparser.c_ast.PtrDecl object at 0x00000000028C5780>
key <pycparser.c_ast.PtrDecl object at 0x00000000028C5978>
Function name is HashPrint at c_files/hash.c:149
It's parameters name and type is (are)
hash <pycparser.c_ast.PtrDecl object at 0x00000000028E9438>
PrintFunc <pycparser.c_ast.PtrDecl object at 0x00000000028E9668>
Function name is HashDestroy at c_files/hash.c:170
It's parameters name and type is (are)
hash <pycparser.c_ast.PtrDecl object at 0x00000000028EF240>
Здесь, как вы можете видеть, вместо того, чтобы получить тип идентификатора, я получаю тип объекта в каждой строке. например <pycparser.c_ast.PtrDecl object at 0x00000000024EFC88>
Пример файла hash.c, который я использую в качестве тестового файла (в любом случае это все есть в pycparser):
/*
** C implementation of a hash table ADT
*/
typedef enum tagReturnCode {SUCCESS, FAIL} ReturnCode;
typedef struct tagEntry
{
char* key;
char* value;
} Entry;
typedef struct tagNode
{
Entry* entry;
struct tagNode* next;
} Node;
typedef struct tagHash
{
unsigned int table_size;
Node** heads;
} Hash;
static unsigned int hash_func(const char* str, unsigned int table_size)
{
unsigned int hash_value;
unsigned int a = 127;
for (hash_value = 0; *str != 0; ++str)
hash_value = (a*hash_value + *str) % table_size;
return hash_value;
}
ReturnCode HashCreate(Hash** hash, unsigned int table_size)
{
unsigned int i;
if (table_size < 1)
return FAIL;
//
// Allocate space for the Hash
//
if (((*hash) = malloc(sizeof(**hash))) == NULL)
return FAIL;
//
// Allocate space for the array of list heads
//
if (((*hash)->heads = malloc(table_size*sizeof(*((*hash)->heads)))) == NULL)
return FAIL;
//
// Initialize Hash info
//
for (i = 0; i < table_size; ++i)
{
(*hash)->heads[i] = NULL;
}
(*hash)->table_size = table_size;
return SUCCESS;
}
ReturnCode HashInsert(Hash* hash, const Entry* entry)
{
unsigned int index = hash_func(entry->key, hash->table_size);
Node* temp = hash->heads[index];
HashRemove(hash, entry->key);
if ((hash->heads[index] = malloc(sizeof(Node))) == NULL)
return FAIL;
hash->heads[index]->entry = malloc(sizeof(Entry));
hash->heads[index]->entry->key = malloc(strlen(entry->key)+1);
hash->heads[index]->entry->value = malloc(strlen(entry->value)+1);
strcpy(hash->heads[index]->entry->key, entry->key);
strcpy(hash->heads[index]->entry->value, entry->value);
hash->heads[index]->next = temp;
return SUCCESS;
}
const Entry* HashFind(const Hash* hash, const char* key)
{
unsigned int index = hash_func(key, hash->table_size);
Node* temp = hash->heads[index];
while (temp != NULL)
{
if (!strcmp(key, temp->entry->key))
return temp->entry;
temp = temp->next;
}
return NULL;
}
ReturnCode HashRemove(Hash* hash, const char* key)
{
unsigned int index = hash_func(key, hash->table_size);
Node* temp1 = hash->heads[index];
Node* temp2 = temp1;
while (temp1 != NULL)
{
if (!strcmp(key, temp1->entry->key))
{
if (temp1 == hash->heads[index])
hash->heads[index] = hash->heads[index]->next;
else
temp2->next = temp1->next;
free(temp1->entry->key);
free(temp1->entry->value);
free(temp1->entry);
free(temp1);
temp1 = NULL;
return SUCCESS;
}
temp2 = temp1;
temp1 = temp1->next;
}
return FAIL;
}
void HashPrint(Hash* hash, void (*PrintFunc)(char*, char*))
{
unsigned int i;
if (hash == NULL || hash->heads == NULL)
return;
for (i = 0; i < hash->table_size; ++i)
{
Node* temp = hash->heads[i];
while (temp != NULL)
{
PrintFunc(temp->entry->key, temp->entry->value);
temp = temp->next;
}
}
}
void HashDestroy(Hash* hash)
{
unsigned int i;
if (hash == NULL)
return;
for (i = 0; i < hash->table_size; ++i)
{
Node* temp = hash->heads[i];
while (temp != NULL)
{
Node* temp2 = temp;
free(temp->entry->key);
free(temp->entry->value);
free(temp->entry);
temp = temp->next;
free(temp2);
}
}
free(hash->heads);
hash->heads = NULL;
free(hash);
}
2 ответа
Что заставляет вас думать, что вы не извлекаете тип?
Function name is HashCreate at c_files/hash.c:44
It's parameters name and type is (are)
hash <pycparser.c_ast.PtrDecl object at 0x00000000024FABE0>
table_size <pycparser.c_ast.TypeDecl object at 0x00000000024FAE48>
Имя table_sizeтип находится в TypeDecl, Простые имена типов не предоставляются - вы должны восстановить их. Для примера того, как распознать "decl" к его текстовому представлению, см. Пример cdecl.
Чтобы получить точный тип идентификаторов в AST, вам, как и Лео в фильме "Начало", нужно "углубиться". 8]
Вот расширение вашей функции visit_FuncDef, чтобы продемонстрировать, как различные элементы AST могут быть достигнуты из данной точки:
def visit_FuncDef(self, node):
#node.decl.type.args.params
print "Function name is", node.decl.name, "at", node.decl.coord
print " It's parameters name and type is (are)"
for params in (node.decl.type.args.params): ###FuncDef/Decl/FuncDecl/ParamList
# Assign parameter name
pname = params.name ###ParamList/Decl
# Parameter is a pointer type of some kind
if type(params.type) is c_ast.PtrDecl:
# Parameter is a pointer to a pointer type - double indirection
if type(params.type.type) is c_ast.PtrDecl:
ptype = params.type.type.type.type.names ###Decl/PtrDecl/PtrDecl/TypeDecl/IdentifierType
# There is no double indirection
else:
# Parameter is a pointer to a function type
if type(params.type.type) is c_ast.FuncDecl:
pname = str(params.type.type.type.type.names) + ' (*' ###Decl/PtrDecl/TypeDecl/IdentifierType
pname = pname + params.type.type.type.declname + ')' ###Decl/PtrDecl/FuncDecl/TypeDecl
ptype = ''
for subparams in params.type.type.args.params: ###Decl/PtrDecl/FuncDecl/ParamList
ptype = ptype + str(subparams.type.type.type.names) ###Typename/PtrDecl/TypeDecl/IdentifierType
# Parameter is a pointer type - single indirection
else:
ptype = params.type.type.type.names ###Decl/PtrDecl/TypeDecl/IdentifierType
# Parameter is a variable
elif type(params.type.type) is c_ast.IdentifierType:
ptype = params.type.type.names
print " ", pname, ptype
В комментариях я попытался объяснить, какой тип параметра ищет код. Тройными хеш-метками я отметил фактическое местоположение в дереве AST.
В качестве примера здесь приведена часть дерева AST функции HashPrint(), которая содержит указатель на функцию в качестве параметра:
FuncDef:
Decl: HashPrint, [], [], []
FuncDecl:
ParamList:
Decl: hash, [], [], []
PtrDecl: []
TypeDecl: hash, []
IdentifierType: ['Hash']
Decl: PrintFunc, [], [], []
PtrDecl: []
FuncDecl:
ParamList:
Typename: None, []
PtrDecl: []
TypeDecl: None, []
IdentifierType: ['char']
Typename: None, []
PtrDecl: []
TypeDecl: None, []
IdentifierType: ['char']
TypeDecl: PrintFunc, []
IdentifierType: ['void']
TypeDecl: HashPrint, []
IdentifierType: ['void']
Compound:
И, наконец, вот вывод функции:
Function name is hash_func at c_files/hash.c:32
It's parameters name and type is (are)
str ['char']
table_size ['unsigned', 'int']
Function name is HashCreate at c_files/hash.c:44
It's parameters name and type is (are)
hash ['Hash']
table_size ['unsigned', 'int']
Function name is HashInsert at c_files/hash.c:77
It's parameters name and type is (are)
hash ['Hash']
entry ['Entry']
Function name is HashFind at c_files/hash.c:100
It's parameters name and type is (are)
hash ['Hash']
key ['char']
Function name is HashRemove at c_files/hash.c:117
It's parameters name and type is (are)
hash ['Hash']
key ['char']
Function name is HashPrint at c_files/hash.c:149
It's parameters name and type is (are)
hash ['Hash']
['void'] (*PrintFunc) ['char']['char']
Function name is HashDestroy at c_files/hash.c:170
It's parameters name and type is (are)
hash ['Hash']
Это работает специально для файла примера hash.c. Я просто хотел, чтобы вы получили представление о том, как получить доступ к определенным частям AST из одной точки.
Рекомендуется сохранить AST в файл:
file = open('ast.txt', 'w')
ast.show(buf=file)
file.close()
затем сравните AST с _c_ast.cfg, чтобы увидеть, какие свойства имеет каждый узел, чтобы вы могли "углубиться" в дерево.