Skip to content

Commit

Permalink
Apply const qualifier to dynFunction.
Browse files Browse the repository at this point in the history
  • Loading branch information
@PengZheng
PengZheng committed Jan 11, 2024
1 parent 0bde38e commit e3562a5
Show file tree
Hide file tree
Showing 2 changed files with 44 additions and 44 deletions.
24 changes: 12 additions & 12 deletions libs/dfi/include/dyn_function.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -66,7 +66,7 @@ enum dyn_function_argument_meta {
* @retval 1 If there is not enough memory to create dyn_function_type.
* @retval 2 Errors other than out-of-memory.
*/
CELIX_DFI_EXPORT int dynFunction_parse(FILE *descriptorStream, struct types_head *refTypes, dyn_function_type **dynFunc);
CELIX_DFI_EXPORT int dynFunction_parse(FILE* descriptorStream, struct types_head* refTypes, dyn_function_type** dynFunc);

/**
* @brief Creates a dyn_function_type according to the given function descriptor string.
Expand All @@ -82,43 +82,43 @@ CELIX_DFI_EXPORT int dynFunction_parse(FILE *descriptorStream, struct types_head
* @retval 1 If there is not enough memory to create dyn_function_type.
* @retval 2 Errors other than out-of-memory.
*/
CELIX_DFI_EXPORT int dynFunction_parseWithStr(const char *descriptor, struct types_head *refTypes, dyn_function_type **dynFunc);
CELIX_DFI_EXPORT int dynFunction_parseWithStr(const char* descriptor, struct types_head* refTypes, dyn_function_type** dynFunc);

/**
* @brief Returns the number of arguments of the given dynamic function type instance.
* @param[in] dynFunc The dynamic type instance for function.
* @return The number of arguments.
*/
CELIX_DFI_EXPORT int dynFunction_nrOfArguments(dyn_function_type *dynFunc);
CELIX_DFI_EXPORT int dynFunction_nrOfArguments(const dyn_function_type* dynFunc);

/**
* @brief Returns the argument type for the given argument index.
* @param[in] dynFunc The dynamic type instance for function.
* @param[in] argumentNr The argument index.
* @return The argument type.
*/
CELIX_DFI_EXPORT const dyn_type* dynFunction_argumentTypeForIndex(dyn_function_type* dynFunc, int argumentNr);
CELIX_DFI_EXPORT const dyn_type* dynFunction_argumentTypeForIndex(const dyn_function_type* dynFunc, int argumentNr);

/**
* @brief Returns the argument meta for the given argument index.
* @param[in] dynFunc The dynamic type instance for function.
* @param[in] argumentNr The argument index.
* @return The argument meta.
*/
CELIX_DFI_EXPORT enum dyn_function_argument_meta dynFunction_argumentMetaForIndex(dyn_function_type *dynFunc, int argumentNr);
CELIX_DFI_EXPORT enum dyn_function_argument_meta dynFunction_argumentMetaForIndex(const dyn_function_type* dynFunc, int argumentNr);

/**
* @brief Returns the return value type for the given dynamic function type instance.
* @param[in] dynFunc The dynamic type instance for function.
* @return The return value type.
*/
CELIX_DFI_EXPORT const dyn_type* dynFunction_returnType(dyn_function_type *dynFunction);
CELIX_DFI_EXPORT const dyn_type* dynFunction_returnType(const dyn_function_type* dynFunction);

/**
* @brief Destroys the given dynamic function type instance.
* @param[in] dynFunc The dynamic type instance for function.
*/
CELIX_DFI_EXPORT void dynFunction_destroy(dyn_function_type *dynFunc);
CELIX_DFI_EXPORT void dynFunction_destroy(dyn_function_type* dynFunc);

CELIX_DEFINE_AUTOPTR_CLEANUP_FUNC(dyn_function_type, dynFunction_destroy);

Expand All @@ -130,7 +130,7 @@ CELIX_DEFINE_AUTOPTR_CLEANUP_FUNC(dyn_function_type, dynFunction_destroy);
* @param[in] argValues The argument values.
* @return 0
*/
CELIX_DFI_EXPORT int dynFunction_call(dyn_function_type *dynFunc, void(*fn)(void), void *returnValue, void **argValues);
CELIX_DFI_EXPORT int dynFunction_call(const dyn_function_type* dynFunc, void(*fn)(void), void* returnValue, void** argValues);

/**
* @brief Creates a closure for the given dynamic function type instance.
Expand All @@ -142,26 +142,26 @@ CELIX_DFI_EXPORT int dynFunction_call(dyn_function_type *dynFunc, void(*fn)(void
* @retval 1 If there is not enough memory to create the closure.
* @retval 2 Errors other than out-of-memory.
*/
CELIX_DFI_EXPORT int dynFunction_createClosure(dyn_function_type *func, void (*bind)(void *, void **, void*), void *userData, void(**fn)(void));
CELIX_DFI_EXPORT int dynFunction_createClosure(dyn_function_type* func, void (*bind)(void*, void**, void*), void* userData, void(**fn)(void));

/**
* @brief Returns the function pointer for the given dynamic function type instance.
* @param[in] func The dynamic type instance for function.
* @param[out] fn The function pointer.
* @return 0 If successful, 1 if the dynamic function type instance has no function pointer.
*/
CELIX_DFI_EXPORT int dynFunction_getFnPointer(dyn_function_type *func, void (**fn)(void));
CELIX_DFI_EXPORT int dynFunction_getFnPointer(const dyn_function_type* func, void (**fn)(void));

/**
* Returns whether the function has a return type.
* Will return false if return is void.
*/
CELIX_DFI_EXPORT bool dynFunction_hasReturn(dyn_function_type *dynFunction);
CELIX_DFI_EXPORT bool dynFunction_hasReturn(const dyn_function_type* dynFunction);

/**
* @brief Returns the name of the given dynamic function type instance.
*/
CELIX_DFI_EXPORT const char* dynFunction_getName(const dyn_function_type *func);
CELIX_DFI_EXPORT const char* dynFunction_getName(const dyn_function_type* func);

#ifdef __cplusplus
}
Expand Down
64 changes: 32 additions & 32 deletions libs/dfi/src/dyn_function.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -31,13 +31,13 @@ static const int MEM_ERROR = 1;
static const int PARSE_ERROR = 2;
static const int ERROR = 2;

static int dynFunction_initCif(dyn_function_type *dynFunc);
static int dynFunction_parseDescriptor(dyn_function_type *dynFunc, FILE *descriptor);
static void dynFunction_ffiBind(ffi_cif *cif, void *ret, void *args[], void *userData);
static int dynFunction_initCif(dyn_function_type* dynFunc);
static int dynFunction_parseDescriptor(dyn_function_type* dynFunc, FILE* descriptor);
static void dynFunction_ffiBind(ffi_cif* cif, void* ret, void* args[], void* userData);

int dynFunction_parse(FILE *descriptor, struct types_head *refTypes, dyn_function_type **out) {
int dynFunction_parse(FILE* descriptor, struct types_head* refTypes, dyn_function_type** out) {
int status = OK;
dyn_function_type *dynFunc = NULL;
dyn_function_type* dynFunc = NULL;

dynFunc = calloc(1, sizeof(*dynFunc));

Expand All @@ -58,9 +58,9 @@ int dynFunction_parse(FILE *descriptor, struct types_head *refTypes, dyn_functio
}

if (status == OK) {
dyn_function_argument_type *arg = NULL;
dyn_function_argument_type* arg = NULL;
TAILQ_FOREACH(arg, &dynFunc->arguments, entries) {
const char *meta = dynType_getMetaInfo(arg->type, "am");
const char* meta = dynType_getMetaInfo(arg->type, "am");
if (meta == NULL) {
arg->argumentMeta = DYN_FUNCTION_ARGUMENT_META__STD;
} else if (strcmp(meta, "handle") == 0) {
Expand Down Expand Up @@ -88,9 +88,9 @@ int dynFunction_parse(FILE *descriptor, struct types_head *refTypes, dyn_functio
return status;
}

int dynFunction_parseWithStr(const char *descriptor, struct types_head *refTypes, dyn_function_type **out) {
int dynFunction_parseWithStr(const char* descriptor, struct types_head* refTypes, dyn_function_type** out) {
int status = OK;
FILE *stream = fmemopen((char *)descriptor, strlen(descriptor) + 1, "r");
FILE* stream = fmemopen((char* )descriptor, strlen(descriptor) + 1, "r");
if (stream != NULL) {
status = dynFunction_parse(stream, refTypes, out);
fclose(stream);
Expand All @@ -101,9 +101,9 @@ int dynFunction_parseWithStr(const char *descriptor, struct types_head *refTypes
return status;
}

static int dynFunction_parseDescriptor(dyn_function_type *dynFunc, FILE *descriptor) {
static int dynFunction_parseDescriptor(dyn_function_type* dynFunc, FILE* descriptor) {
int status = OK;
char *name = NULL;
char* name = NULL;

status = dynCommon_parseName(descriptor, &name);

Expand All @@ -121,13 +121,13 @@ static int dynFunction_parseDescriptor(dyn_function_type *dynFunc, FILE *descrip

int nextChar = fgetc(descriptor);
int index = 0;
dyn_type *type = NULL;
dyn_type* type = NULL;
char argName[32];
while (nextChar != ')' && status == 0) {
ungetc(nextChar, descriptor);
type = NULL;

dyn_function_argument_type *arg = NULL;
dyn_function_argument_type* arg = NULL;

status = dynType_parse(descriptor, NULL, dynFunc->refTypes, &type);
if (status == OK) {
Expand Down Expand Up @@ -159,9 +159,9 @@ static int dynFunction_parseDescriptor(dyn_function_type *dynFunc, FILE *descrip
return status;
}

enum dyn_function_argument_meta dynFunction_argumentMetaForIndex(dyn_function_type *dynFunc, int argumentNr) {
enum dyn_function_argument_meta dynFunction_argumentMetaForIndex(const dyn_function_type* dynFunc, int argumentNr) {
enum dyn_function_argument_meta result = 0;
dyn_function_argument_type *arg = NULL;
dyn_function_argument_type* arg = NULL;
int index = 0;
TAILQ_FOREACH(arg, &dynFunc->arguments, entries) {
if (index == argumentNr) {
Expand All @@ -174,11 +174,11 @@ enum dyn_function_argument_meta dynFunction_argumentMetaForIndex(dyn_function_ty
}


static int dynFunction_initCif(dyn_function_type *dynFunc) {
static int dynFunction_initCif(dyn_function_type* dynFunc) {
int status = 0;

unsigned int nargs = 0;
dyn_function_argument_type *entry = NULL;
dyn_function_argument_type* entry = NULL;
TAILQ_FOREACH(entry, &dynFunc->arguments, entries) {
nargs +=1;
}
Expand All @@ -189,8 +189,8 @@ static int dynFunction_initCif(dyn_function_type *dynFunc) {
dynFunc->ffiArguments[entry->index] = dynType_ffiType(entry->type);
}

ffi_type **args = dynFunc->ffiArguments;
ffi_type *returnType = dynType_ffiType(dynFunc->funcReturn);
ffi_type** args = dynFunc->ffiArguments;
ffi_type* returnType = dynType_ffiType(dynFunc->funcReturn);

int ffiResult = ffi_prep_cif(&dynFunc->cif, FFI_DEFAULT_ABI, nargs, returnType, args);
if (ffiResult != FFI_OK) {
Expand All @@ -200,7 +200,7 @@ static int dynFunction_initCif(dyn_function_type *dynFunc) {
return status;
}

void dynFunction_destroy(dyn_function_type *dynFunc) {
void dynFunction_destroy(dyn_function_type* dynFunc) {
if (dynFunc != NULL) {
if (dynFunc->funcReturn != NULL) {
dynType_destroy(dynFunc->funcReturn);
Expand All @@ -215,8 +215,8 @@ void dynFunction_destroy(dyn_function_type *dynFunc) {
free(dynFunc->ffiArguments);
}

dyn_function_argument_type *entry = NULL;
dyn_function_argument_type *tmp = NULL;
dyn_function_argument_type* entry = NULL;
dyn_function_argument_type* tmp = NULL;
entry = TAILQ_FIRST(&dynFunc->arguments);
while (entry != NULL) {
if (entry->name != NULL) {
Expand All @@ -232,17 +232,17 @@ void dynFunction_destroy(dyn_function_type *dynFunc) {
}
}

int dynFunction_call(dyn_function_type *dynFunc, void(*fn)(void), void *returnValue, void **argValues) {
ffi_call(&dynFunc->cif, fn, returnValue, argValues);
int dynFunction_call(const dyn_function_type* dynFunc, void(*fn)(void), void* returnValue, void** argValues) {
ffi_call((ffi_cif*)&dynFunc->cif, fn, returnValue, argValues);
return 0;
}

static void dynFunction_ffiBind(ffi_cif *cif, void *ret, void *args[], void *userData) {
dyn_function_type *dynFunc = userData;
static void dynFunction_ffiBind(ffi_cif* cif, void* ret, void* args[], void* userData) {
dyn_function_type* dynFunc = userData;
dynFunc->bind(dynFunc->userData, args, ret);
}

int dynFunction_createClosure(dyn_function_type *dynFunc, void (*bind)(void *, void **, void*), void *userData, void(**out)(void)) {
int dynFunction_createClosure(dyn_function_type* dynFunc, void (*bind)(void*, void**, void*), void* userData, void(**out)(void)) {
int status = 0;
void (*fn)(void);
dynFunc->ffiClosure = ffi_closure_alloc(sizeof(ffi_closure), (void **)&fn);
Expand All @@ -265,7 +265,7 @@ int dynFunction_createClosure(dyn_function_type *dynFunc, void (*bind)(void *, v
return status;
}

int dynFunction_getFnPointer(dyn_function_type *dynFunc, void (**fn)(void)) {
int dynFunction_getFnPointer(const dyn_function_type* dynFunc, void (**fn)(void)) {
int status = 0;
if (dynFunc != NULL && dynFunc->fn != NULL) {
(*fn) = dynFunc->fn;
Expand All @@ -275,7 +275,7 @@ int dynFunction_getFnPointer(dyn_function_type *dynFunc, void (**fn)(void)) {
return status;
}

int dynFunction_nrOfArguments(dyn_function_type *dynFunc) {
int dynFunction_nrOfArguments(const dyn_function_type* dynFunc) {
int count = 0;
dyn_function_argument_type *entry = NULL;
TAILQ_FOREACH(entry, &dynFunc->arguments, entries) {
Expand All @@ -284,7 +284,7 @@ int dynFunction_nrOfArguments(dyn_function_type *dynFunc) {
return count;
}

const dyn_type* dynFunction_argumentTypeForIndex(dyn_function_type* dynFunc, int argumentNr) {
const dyn_type* dynFunction_argumentTypeForIndex(const dyn_function_type* dynFunc, int argumentNr) {
dyn_type* result = NULL;
int index = 0;
dyn_function_argument_type* entry = NULL;
Expand All @@ -298,11 +298,11 @@ const dyn_type* dynFunction_argumentTypeForIndex(dyn_function_type* dynFunc, int
return result;
}

const dyn_type* dynFunction_returnType(dyn_function_type *dynFunction) {
const dyn_type* dynFunction_returnType(const dyn_function_type *dynFunction) {
return dynFunction->funcReturn;
}

bool dynFunction_hasReturn(dyn_function_type* dynFunction) {
bool dynFunction_hasReturn(const dyn_function_type* dynFunction) {
const dyn_type* t = dynFunction_returnType(dynFunction);
return t->descriptor != 'V';
}
Expand Down

0 comments on commit e3562a5

Please sign in to comment.