void assignment(ecc_context *ctx, const char *variable)
{
const char *token;
unsigned int var_pos;
int number;
/* advance past variable */
ctx->lex_advance(ctx, str_nlen(variable, TOKEN_MAX));
token = ctx->lex_look_ahead(ctx);
if (token[0] != '=') {
err_msg("token '");
err_msg(token);
err_msg("' is not an '='\n");
die();
}
ctx->lex_advance(ctx, str_nlen(token, TOKEN_MAX));
token = ctx->lex_look_ahead(ctx);
if (is_number(token[0])) {
number = a_to_i(token, str_nlen(token, TOKEN_MAX));
ctx->lex_advance(ctx, str_nlen(token, TOKEN_MAX));
var_pos = ctx->stack_name_pos(ctx, variable);
ctx->output_stack_assign_int(ctx, var_pos, number);
} else {
err_msg("not supported\n");
die();
}
}
void factor(ecc_context *ctx, const char *token)
{
int number;
unsigned int negate;
if (token[0] == '(') {
ctx->lex_advance(ctx, 1);
token = ctx->lex_look_ahead(ctx);
expression(ctx, token);
/* eat close paren */
ctx->lex_advance(ctx, 1);
} else {
if ((token[0] == '-') && (str_nlen(token, TOKEN_MAX) == 1)) {
negate = 1;
ctx->lex_advance(ctx, 1);
token = ctx->lex_look_ahead(ctx);
} else {
negate = 0;
}
number = a_to_i(token, str_nlen(token, TOKEN_MAX));
if (negate) {
number = -number;
}
ctx->lex_advance(ctx, str_nlen(token, TOKEN_MAX));
ctx->output_term(ctx, number);
}
}
char *strndup_null(char *s, int n)
{
int len;
char *str;
if (!s)
return strdup("");
len = str_nlen(s, n);
str = malloc_e(len+1);
memcpy(str, s, len);
str[len] = 0;
return str;
}
void test_str_nlen()
{
const char *input = "foo";
const char *input2 = "fo\0bar";
const char *input3 = "";
unsigned int result, expected_result;
result = str_nlen(input, sizeof(input));
expected_result = strlen(input);
check_unsigned_ints(result, expected_result, "compare with libc");
check_unsigned_int(result, 3);
result = str_nlen(input2, sizeof(input2));
expected_result = strlen(input2);
check_unsigned_int(result, expected_result);
result = str_nlen(input3, sizeof(input3));
expected_result = strlen(input3);
check_unsigned_int(result, expected_result);
result = str_nlen(input, 2);
check_unsigned_ints(result, 2, "limit to 2 not 3");
}
void declaration(ecc_context *ctx, const char *token)
{
ctx->lex_advance(ctx, str_nlen(token, TOKEN_MAX));
token = ctx->lex_look_ahead(ctx);
if (!(is_valid_name(token))) {
err_msg("token '");
err_msg(token);
err_msg("' not a valid name\n");
die();
}
ctx->stack_assign_name(ctx, token);
token = ctx->lex_look_ahead(ctx);
if (!(is_declaration(token))) {
done_declaring(ctx);
}
}
void stack_name_add(names_stack *stack, const char *name)
{
names_list *names_lists;
const char **old_names;
const char **names;
char *new_buffer;
unsigned int size;
unsigned int i;
names_lists = stack->names_lists[stack->names_lists_c - 1];
old_names = names_lists->names;
size = sizeof(const char *) * (names_lists->names_c + 1);
names = (const char **)heap_malloc(size);
if (!names) {
err_msg("malloc char**\n");
die();
}
for (i = 0; i < names_lists->names_c; i++) {
names[i] = old_names[i];
}
if (old_names) {
heap_free(old_names);
}
size = sizeof(char) * str_nlen(name, 100) + 1;
new_buffer = (char *)heap_malloc(size);
if (!new_buffer) {
err_msg("malloc char*\n");
die();
}
names[names_lists->names_c] = new_buffer;
str_ncpy(new_buffer, name, size);
names_lists->names = names;
names_lists->names_c++;
}
size_t strnlen(const char *s, size_t maxlen)
{
return str_nlen(s, maxlen);
}
