static void *hvm_str_replace(const char *method,
hefesto_common_list_ctx **string_var,
hefesto_type_t *otype,
hefesto_var_list_ctx **lo_vars,
hefesto_var_list_ctx **gl_vars,
hefesto_func_list_ctx *functions) {
size_t offset = 0, outsz;
char *regex_arg, *pattern_arg;
char *replaced_buffer = NULL;
const char *m;
char errors[HEFESTO_MAX_BUFFER_SIZE];
void *usr_regex, *usr_pattern, *result;
hefesto_type_t etype = HEFESTO_VAR_TYPE_STRING;
here_search_program_ctx *search_program;
*otype = HEFESTO_VAR_TYPE_INT;
result = hefesto_mloc(sizeof(hefesto_int_t));
*(hefesto_int_t *)result = 0;
if (string_var == NULL || (*string_var) == NULL ||
(*string_var)->data == NULL) return result;
for (m = method; *m != '(' && *m != 0; m++);
regex_arg = get_arg_from_call(m+1, &offset);
pattern_arg = get_arg_from_call(m+1, &offset);
usr_regex = expr_eval(regex_arg, lo_vars, gl_vars, functions,
&etype, &outsz);
if ((search_program = here_compile(usr_regex, errors)) != NULL) {
usr_pattern = expr_eval(pattern_arg, lo_vars, gl_vars, functions,
&etype, &outsz);
*(hefesto_int_t *)result = here_replace_string((*string_var)->data,
search_program,
usr_pattern,
&replaced_buffer,
&outsz);
free((*string_var)->data);
(*string_var)->data = (char *) hefesto_mloc(outsz+1);
(*string_var)->dsize = outsz;
memset((*string_var)->data, 0, outsz+1);
strncpy((*string_var)->data, replaced_buffer, outsz+1);
free(replaced_buffer);
free(usr_pattern);
del_here_search_program_ctx(search_program);
} else {
hlsc_info(HLSCM_MTYPE_RUNTIME, HLSCM_SYN_ERROR_INVAL_REGEX, errors);
}
free(usr_regex);
return result;
}
static char *infix2postfix_function_args(const char *expr_args,
const size_t esize) {
char *e;
char *iexpr, *pexpr;
char *result = (char *) hefesto_mloc(HEFESTO_MAX_BUFFER_SIZE);
char *r;
size_t offset = 1;
iexpr = get_arg_from_call(expr_args, &offset);
r = result;
*r = '(';
r++;
while (*iexpr) {
pexpr = infix2postfix(iexpr, strlen(iexpr), 0);
for (e = pexpr; *e != 0; e++, r++) *r = *e;
free(iexpr);
free(pexpr);
iexpr = get_arg_from_call(expr_args, &offset);
if (*iexpr) {
*r = ',';
r++;
}
}
free(iexpr);
*r = 0;
return result;
}
static void *hvm_str_match(const char *method,
hefesto_common_list_ctx **string_var,
hefesto_type_t *otype, hefesto_var_list_ctx **lo_vars,
hefesto_var_list_ctx **gl_vars,
hefesto_func_list_ctx *functions) {
size_t offset = 0, outsz;
char *arg;
const char *m;
char errors[HEFESTO_MAX_BUFFER_SIZE];
void *usr_regex, *result;
here_search_program_ctx *search_program;
here_search_result_ctx *search_result;
hefesto_type_t etype = HEFESTO_VAR_TYPE_STRING;
*otype = HEFESTO_VAR_TYPE_INT;
result = hefesto_mloc(sizeof(hefesto_int_t));
*(hefesto_int_t *)result = 0;
if (string_var == NULL || (*string_var) == NULL ||
(*string_var)->data == NULL) return result;
for (m = method; *m != '(' && *m != 0; m++);
arg = get_arg_from_call(m+1, &offset);
usr_regex = expr_eval(arg, lo_vars, gl_vars, functions,
&etype, &outsz);
if ((search_program = here_compile(usr_regex, errors)) != NULL) {
search_result = here_match_string((*string_var)->data,
search_program);
*(hefesto_int_t *)result = here_matches(search_result);
del_here_search_program_ctx(search_program);
del_here_search_result_ctx(search_result);
} else {
hlsc_info(HLSCM_MTYPE_RUNTIME, HLSCM_SYN_ERROR_INVAL_REGEX, errors);
}
free(usr_regex);
return result;
}
char *infix2postfix_args(const char *arg_list, const size_t arg_list_size) {
char *e = NULL;
const char *ap = NULL, *ap_end = NULL;
char *arg_pf = NULL;
size_t offset = 0;
size_t real_arg_list_size = 0;
char *retval = NULL;
char arg_list_cpy[HEFESTO_MAX_BUFFER_SIZE];
if (arg_list == NULL) {
return NULL;
}
memset(arg_list_cpy, 0, sizeof(arg_list_cpy));
strncpy(arg_list_cpy, arg_list, sizeof(arg_list_cpy) - 1);
real_arg_list_size = strnlen(arg_list_cpy, sizeof(arg_list_cpy));
ap_end = get_stmt_end(arg_list_cpy, real_arg_list_size);
ap = &arg_list_cpy[0];
if (ap_end != NULL) {
memset((char *)ap_end, 0, real_arg_list_size - (ap_end - ap));
}
while (*ap != '(' && *ap != 0) {
ap++;
}
if (*ap == 0) {
return NULL;
}
ap++;
retval = (char *) hefesto_mloc(arg_list_size * 2);
memset(retval, 0, arg_list_size * 2);
*retval = '(';
e = get_arg_from_call(ap, &offset);
while (*e) {
arg_pf = infix2postfix(e, strlen(e), 1);
strcat(retval, arg_pf);
free(arg_pf);
free(e);
if (arg_list_cpy[offset] == ',') {
offset++;
}
e = get_arg_from_call(arg_list_cpy, &offset);
if (*e) {
strcat(retval, ",");
} else {
strcat(retval, ")");
}
}
free(e);
return retval;
}
void hvm_init_function_args(const char *args,
hefesto_var_list_ctx **lo_vars,
hefesto_var_list_ctx **gl_vars,
hefesto_func_list_ctx *functions,
hefesto_func_list_ctx **function) {
char *expr;
char *expr_pfix;
void *expr_result;
hefesto_type_t etype;
size_t sz;
hefesto_var_list_ctx *vp = (*function)->vars, *ap = (*function)->args, *vlp = NULL;
size_t offset = 0;
//hefesto_instruction_code_t c_intr = hvm_get_current_executed_instruction();
char *temp = (char *) hefesto_mloc(HEFESTO_MAX_BUFFER_SIZE);
strncpy(temp, args, HEFESTO_MAX_BUFFER_SIZE);
strcat(temp, ";");
//printf("FUNCTION: %s [%s]\n", (*function)->name, temp);
for (expr = temp; *expr != 0 && *expr != '('; expr++);
offset = expr - args + 1;
expr = get_arg_from_call(args, &offset);
while (vp != NULL && *expr != 0) {
if (ap->contents != NULL) {
del_hefesto_common_list_ctx(ap->contents);
ap->contents = NULL;
}
ap->contents = add_data_to_hefesto_common_list_ctx(ap->contents, expr,
strlen(expr));
// if (c_intr != HEFESTO_ATTRIB && c_intr != HEFESTO_RET &&
// c_intr != HEFESTO_IF && c_intr != HEFESTO_WHILE) {
// expr_pfix = infix2postfix(expr, strlen(expr), 1);
// free(expr);
// } else {
expr_pfix = expr;
// }
etype = vp->type;
//printf("\tF-ARG: %s\n", expr_pfix);
// INFO(Santiago):
// truque sujo, aqui gl_vars precisa ser varrida primeiro, lo_vars nem
// precisa pois argumentos nao serao formados por variaveis ou
// expressoes com variaveis definidas no corpo dessa mesma funcao
// prestes a ser executada.
//expr_result = expr_eval(expr_pfix, (*lo_vars == vp) ? gl_vars : lo_vars, gl_vars, functions, &etype, &sz);
/*if (hvm_get_last_executed_function() != NULL) {
printf("last -> %s\n", hvm_get_last_executed_function()->name);
}
printf("current -> %s\n", (*function)->name);*/
expr_result = expr_eval(expr_pfix,
(hvm_get_last_executed_function() == *function) ?
&(*function)->vars : lo_vars, gl_vars,
functions, &etype, &sz);
if (*expr_pfix == '$') {
vlp = get_hefesto_var_list_ctx_name(expr_pfix + 1, *lo_vars);
if (vlp == NULL) {
vlp = get_hefesto_var_list_ctx_name(expr_pfix + 1, *gl_vars);
}
}
free(expr_pfix);
if (vp->contents != NULL) {
del_hefesto_common_list_ctx(vp->contents);
vp->contents = NULL;
}
if (etype != HEFESTO_VAR_TYPE_LIST) {
vp->contents = add_data_to_hefesto_common_list_ctx(vp->contents,
expr_result,
(etype == HEFESTO_VAR_TYPE_STRING) ?
strlen((char*)expr_result) : sizeof(hefesto_int_t));
free(expr_result);
} else {
if (vlp != NULL) {
vp->subtype = vlp->subtype;
} else {
vp->subtype = get_hsl_list_subtype((hefesto_common_list_ctx *)expr_result);
/*if (((hefesto_common_list_ctx *)expr_result)->data &&
is_hefesto_numeric_constant(((hefesto_common_list_ctx *)
expr_result)->data)) {
vp->subtype = HEFESTO_VAR_TYPE_INT;
} else {
vp->subtype = HEFESTO_VAR_TYPE_STRING;
}*/
}
vp->contents =
cp_hefesto_common_list_ctx((hefesto_common_list_ctx *)expr_result);
del_hefesto_common_list_ctx((hefesto_common_list_ctx *)expr_result);
}
vp = vp->next;
ap = ap->next;
expr = get_arg_from_call(args, &offset);
}
free(expr);
// we must to clear local stack initializing all with null or zero.
for (; vp != NULL; vp = vp->next) {
if (vp->type == HEFESTO_VAR_TYPE_FILE_DESCRIPTOR && vp->contents) {
close_hefesto_file_handle((hefesto_file_handle *) vp->contents->data);
}
del_hefesto_common_list_ctx(vp->contents);
new_hefesto_common_list_ctx(vp->contents);
if (vp->type == HEFESTO_VAR_TYPE_LIST) {
vp->subtype = HEFESTO_VAR_TYPE_NONE;
vp->contents->is_dummy_item = 1;
}
}
}
