Archivist
/
ink
1
0
派生 0
代码 工单 4 合并请求 0 版本发布 0 百科 动态
浏览代码

C-ified some less antiquated constructs to the antiquated form

main
Ludovic 'Archivist' Lagouardette 6 个月前
父节点
6cdddb8543
当前提交
5411462218
共有 1 个文件被更改，包括 214 次插入 和 137 次删除
分列视图
Diff 选项
显示统计 下载 Patch 文件 下载 Diff 文件
  1. +214
    -137
      lib.c

+ 214
- 137
lib.c 查看文件

@ -33,7 +33,8 @@ struct label {
#ifdef NOSTDLIB
static size_t strlen(const char* c) {
size_t j = 0;
size_t j;
j = 0;
while(*(c++)) {
j++;
}
@ -41,8 +42,10 @@ static size_t strlen(const char* c) {
}
static void* memcpy(void* _dest, const void* _src, size_t sz) {
char* dest = _dest;
const char* src = _src;
char* dest;
const char* src;
dest = _dest;
src = _src;
while(sz--) {
*(dest++) = *(src++);
}
@ -59,8 +62,10 @@ static int strcmp(const char* dest, const char* src) {
}
static void* memmove(void* _dest, const void* _src, size_t sz) {
char* dest = _dest;
const char* src = _src;
char* dest;
const char* src;
dest = _dest;
src = _src;
if (src < dest) {
src += sz;
dest += sz;
@ -76,7 +81,8 @@ static void* memmove(void* _dest, const void* _src, size_t sz) {
}
static void* memset(void* _dest, int src, size_t sz) {
char* dest = _dest;
char* dest;
dest = _dest;
while(sz--) {
*(dest++) = src++;
}
@ -92,7 +98,8 @@ static int isdigit(int d) {
}
static int atoi(const char* c) {
int ret = 0;
int ret;
ret = 0;
while(*c) {
ret *= 10;
ret += *c - '0';
@ -104,13 +111,17 @@ static int atoi(const char* c) {
#endif
int ink_add_native(struct context* ctx, const char* name, void(*value)(struct context*)) {
int len;
char* copy;
if(ctx->native_words == NULL) {
ctx->native_words = ctx->inner_malloc(sizeof(struct native_fn) * 8);
ctx->native_words_top = 0;
ctx->native_words_capacity = 8;
} else if(ctx->native_words_top == ctx->native_words_capacity) {
int new_count = (ctx->native_words_capacity + ctx->native_words_capacity/2);
void* renewed = ctx->inner_realloc(ctx->native_words, sizeof(struct native_fn) * new_count);
int new_count;
void* renewed;
new_count = (ctx->native_words_capacity + ctx->native_words_capacity/2);
renewed = ctx->inner_realloc(ctx->native_words, sizeof(struct native_fn) * new_count);
if(renewed == NULL) {
return -3;
} else {
@ -118,8 +129,8 @@ int ink_add_native(struct context* ctx, const char* name, void(*value)(struct co
ctx->native_words_capacity = new_count;
}
}
kt">int len = strlen(name);
kt">char* copy = ctx->inner_malloc(len+1);
len = strlen(name);
copy = ctx->inner_malloc(len+1);
if(copy == NULL) {
return -4;
}
@ -132,13 +143,18 @@ int ink_add_native(struct context* ctx, const char* name, void(*value)(struct co
}
static int ink_add_indigenous(struct context* ctx, const char* name, struct elem* m, size_t count) {
int len, i;
char* copy;
if(ctx->words == NULL) {
ctx->words = ctx->malloc(sizeof(struct fn) * 8);
ctx->words_top = 0;
ctx->words_capacity = 8;
} else if(ctx->words_top == ctx->words_capacity) {
int new_count = (ctx->words_capacity + ctx->words_capacity/2);
void* renewed = ctx->realloc(ctx->words, sizeof(struct native_fn) * new_count);
int new_count;
void* renewed;
new_count = (ctx->words_capacity + ctx->words_capacity/2);
renewed = ctx->realloc(ctx->words, sizeof(struct native_fn) * new_count);
if(renewed == NULL) {
return -1;
} else {
@ -146,7 +162,6 @@ static int ink_add_indigenous(struct context* ctx, const char* name, struct elem
ctx->words_capacity = new_count;
}
}
int i;
for(i = 0; i < ctx->words_top; ++i) {
if(strcmp(name, ctx->words[i].name) == 0) {
ctx->free(ctx->words[i].things);
@ -156,8 +171,8 @@ static int ink_add_indigenous(struct context* ctx, const char* name, struct elem
return i;
}
}
kt">int len = strlen(name);
kt">char* copy = ctx->malloc(len+1);
len = strlen(name);
copy = ctx->malloc(len+1);
if(copy == NULL) {
return -2;
}
@ -184,8 +199,10 @@ static int ink_add_lex_string(struct context* ctx, const char* name) {
ctx->lex_reserved_words_top = 0;
ctx->lex_reserved_words_capacity = 8;
} else if(ctx->lex_reserved_words_top == ctx->lex_reserved_words_capacity) {
int new_count = (ctx->lex_reserved_words_capacity + ctx->lex_reserved_words_capacity/2);
void* renewed = ctx->inner_realloc(ctx->lex_reserved_words, sizeof(struct native_fn) * new_count);
int new_count;
new_count = (ctx->lex_reserved_words_capacity + ctx->lex_reserved_words_capacity/2);
void* renewed;
renewed = ctx->inner_realloc(ctx->lex_reserved_words, sizeof(struct native_fn) * new_count);
if(renewed == NULL) {
return -5;
} else {
@ -198,7 +215,8 @@ static int ink_add_lex_string(struct context* ctx, const char* name) {
return i;
}
}
int len = strlen(name);
int len;
len = strlen(name);
i = ctx->lex_reserved_words_top;
ctx->lex_reserved_words[i] = ctx->malloc(len+1);
memcpy(ctx->lex_reserved_words[i], name, len);
@ -208,15 +226,18 @@ static int ink_add_lex_string(struct context* ctx, const char* name) {
}
int ink_push(struct context* ctx, struct elem value) {
struct ink_routine* current;
if(ctx->routine_current >= ctx->routines_top) return -65;
k">struct ink_routine* current = ctx->routines + ctx->routine_current;
current = ctx->routines + ctx->routine_current;
if(current->stack == NULL) {
current->stack = ctx->malloc(sizeof(struct elem) * 8);
current->top = 0;
current->capacity = 8;
} else if(current->top == current->capacity) {
int new_count = (current->capacity + current->capacity/2);
void* renewed = ctx->realloc(current->stack, sizeof(struct elem) * new_count);
int new_count;
void* renewed;
new_count = (current->capacity + current->capacity/2);
renewed = ctx->realloc(current->stack, sizeof(struct elem) * new_count);
if(renewed == NULL) {
return -18;
} else {
@ -230,16 +251,20 @@ int ink_push(struct context* ctx, struct elem value) {
}
int ink_push_fn(struct context* ctx, struct stack_frame value) {
struct ink_routine* current;
if(ctx->routine_current >= ctx->routines_top) return -55;
struct ink_routine* current = ctx->routines + ctx->routine_current;
current = ctx->routines + ctx->routine_current;
if(current->panic) return -56;
if(current->function_stack == NULL) {
current->function_stack = ctx->malloc(sizeof(struct stack_frame) * 8);
current->function_stack_top = 0;
current->function_stack_capacity = 8;
} else if(current->function_stack_top == current->function_stack_capacity) {
int new_count = (current->function_stack_capacity + current->function_stack_capacity/2);
void* renewed = ctx->realloc(current->function_stack, sizeof(struct stack_frame) * new_count);
int new_count;
void* renewed;
new_count = (current->function_stack_capacity + current->function_stack_capacity/2);
renewed = ctx->realloc(current->function_stack, sizeof(struct stack_frame) * new_count);
if(renewed == NULL) {
return -9;
} else {
@ -269,7 +294,8 @@ void ink_pop(struct context* ctx) {
}
struct context* ink_make_context(void*(*malloc)(size_t), void*(*realloc)(void*, size_t), void(*free)(void*), int(*putchar)(int)) {
struct context* ctx = (struct context*)malloc(sizeof(struct context));
struct context* ctx;
ctx = (struct context*)malloc(sizeof(struct context));
ctx->malloc = malloc;
ctx->realloc = realloc;
ctx->free = free;
@ -320,7 +346,8 @@ static char* ink_itoa(struct context* _, int cpy) {
#ifndef NOSTDLIB
struct context* ink_make_default_context() {
struct context* ctx = ink_make_context(malloc, realloc, free, putchar);
struct context* ctx;
ctx = ink_make_context(malloc, realloc, free, putchar);
ink_std_library(ctx);
return ctx;
}
@ -328,12 +355,13 @@ struct context* ink_make_default_context() {
static int ink_consume_one(int* end, struct context* pContext, char** buffer, char* r) {
int i;
int done;
struct elem value;
if(*end == 0) {
return 0;
}
r[*end] = 0;
int done = 0;
struct elem value;
done = 0;
if (strcmp(r, _KEYWORD_INK_FUNCTION) == 0) {
value.value = 0;
value.type = INK_FUNCTION_KW;
@ -433,8 +461,9 @@ static int ink_lex(struct context *pContext, char* buffer) {
int i;
// Limits the token size to 127 chars
char r[128];
int end = 0;
int end;
int err;
end = 0;
while(*buffer != 0) {
if(isspace(*buffer)) {
@ -469,27 +498,32 @@ static int lblcmp(const char* label, const char* other, size_t label_sz) {
}
int ink_make_routine(struct context* ctx) {
struct ink_routine* it;
struct ink_routine* end;
// Allocate space if needed
if(ctx->routines == NULL) {
ctx->routines = ctx->inner_malloc(sizeof(struct ink_routine) * 8);
ctx->routines_top = 0;
ctx->routines_capacity = 8;
k">struct ink_routine* it = ctx->routines;
k">struct ink_routine* end = ctx->routines + 8;
it = ctx->routines;
end = ctx->routines + 8;
for(;it != end;++it) {
it->stack = NULL;
it->function_stack = NULL;
it->panic = INK_ROUTINE_CAN_REUSE;
}
} else if(ctx->routines_top == ctx->routines_capacity) {
int new_count = (ctx->routines_capacity + ctx->routines_capacity/2);
void* renewed = ctx->inner_realloc(ctx->routines, sizeof(struct stack_frame) * new_count);
int new_count;
void* renewed;
new_count = (ctx->routines_capacity + ctx->routines_capacity/2);
renewed = ctx->inner_realloc(ctx->routines, sizeof(struct stack_frame) * new_count);
if(renewed == NULL) {
return -99;
} else {
ctx->routines = renewed;
k">struct ink_routine* it = ctx->routines + ctx->routines_capacity;
k">struct ink_routine* end = ctx->routines + new_count;
it = ctx->routines + ctx->routines_capacity;
end = ctx->routines + new_count;
for(;it != end;++it) {
it->panic = INK_ROUTINE_CAN_REUSE;
}
@ -497,11 +531,12 @@ int ink_make_routine(struct context* ctx) {
}
}
k">struct ink_routine* it = ctx->routines;
k">struct ink_routine* end = ctx->routines + ctx->routines_capacity;
it = ctx->routines;
end = ctx->routines + ctx->routines_capacity;
// Looks for a reusable routine space then uses it
for(;it != end;++it) {
if(it->panic == INK_ROUTINE_CAN_REUSE) {
int idx;
it->panic = 0;
it->stack = NULL;
it->top = 0;
@ -509,7 +544,7 @@ int ink_make_routine(struct context* ctx) {
it->function_stack = NULL;
it->function_stack_top = 0;
it->function_stack_capacity = 0;
kt">int idx = it - ctx->routines;
idx = it - ctx->routines;
if(idx >= ctx->routines_top) {
ctx->routines_top = idx + 1;
}
@ -519,10 +554,11 @@ int ink_make_routine(struct context* ctx) {
}
int ink_kill_routine(struct context* ctx, int routine){
struct ink_routine* curr;
if(routine < 0 || routine >= ctx->routines_top) {
return 0;
}
k">struct ink_routine* curr = ctx->routines + routine;
curr = ctx->routines + routine;
if(curr->panic == INK_ROUTINE_CAN_REUSE) {
return 0;
}
@ -546,18 +582,19 @@ int ink_kill_routine(struct context* ctx, int routine){
* @internal Loop from hell
*/
static int ink_parse(struct context* pContext, struct elem* executable_buffer, int* executable_buffer_top) {
struct ink_routine* currentRoutine = pContext->routines + pContext->routine_current;
int i;
struct ink_routine* currentRoutine;
int i, function_buffer_top, function_name, mode;
#define LABEL_BUFFER 128
#define FUNCTION_BUFFER 256
struct label labels[LABEL_BUFFER];
struct elem function_buffer[FUNCTION_BUFFER];
int function_buffer_top = 0;
int function_name = -1;
currentRoutine = pContext->routines + pContext->routine_current;
function_buffer_top = 0;
function_name = -1;
#define MODE_EXECUTABLE 0
#define MODE_FUNCTION 1
#define MODE_DO 2
kt">int mode = mi">0;
mode = n">MODE_EXECUTABLE;
memset(labels, 0, sizeof(struct label)*LABEL_BUFFER);
// Loop from hell, good luck, pro-tip: leave the parser alone
@ -632,8 +669,10 @@ static int ink_parse(struct context* pContext, struct elem* executable_buffer, i
int k;
for(k = 0; k < LABEL_BUFFER; k++) {
if(labels[k].active) {
const char* lbl = labels[k].name;
int label_sz = strlen(lbl);
int label_sz;
const char* lbl;
lbl = labels[k].name;
label_sz = strlen(lbl);
if(lblcmp(labels[k].name, pContext->lex_reserved_words[pt.value], label_sz) == 0) {
function_buffer[j].type = INK_INTEGER;
function_buffer[j].value = labels[k].dest - j;
@ -672,16 +711,18 @@ static int ink_parse(struct context* pContext, struct elem* executable_buffer, i
}
int ink_step(struct context *pContext) {
struct ink_routine* currentRoutine = pContext->routines + pContext->routine_current;
struct ink_routine* currentRoutine;
struct stack_frame frame;
struct stack_frame* top;
struct elem next;
int t;
currentRoutine = pContext->routines + pContext->routine_current;
pContext->steps++;
if(currentRoutine->function_stack_top == 0) return 0;
if(pContext->panic) {
return -1;
}
struct stack_frame frame;
struct stack_frame* top;
struct elem next;
int t;
top = &currentRoutine->function_stack[currentRoutine->function_stack_top-1];
t = top->executing.type;
switch(t) {
@ -733,8 +774,11 @@ int ink_step(struct context *pContext) {
}
void ink_compile(struct context *pContext, char* buffer) {
int routine = ink_make_routine(pContext);
int saved = pContext->routine_current;
int routine, saved, i, executable_buffer_top;
// Main function has a size limit of 256 (need to know that for REPL
struct elem executable_buffer[256];
routine = ink_make_routine(pContext);
saved = pContext->routine_current;
pContext->routine_current = routine;
struct ink_routine* currentRoutine = pContext->routines + routine;
currentRoutine->stack = NULL;
@ -746,10 +790,8 @@ void ink_compile(struct context *pContext, char* buffer) {
pContext->panic = 1;
return;
}
int i = 0;
// Main function has a size limit of 256 (need to know that for REPL
struct elem executable_buffer[256];
int executable_buffer_top = 0;
i = 0;
executable_buffer_top = 0;
err = ink_parse(pContext, executable_buffer, &executable_buffer_top);
if(err < 0) {
pContext->panic = 1;
@ -780,8 +822,8 @@ void ink_compile(struct context *pContext, char* buffer) {
}
int ink_can_run(struct context* pContext) {
int it = 0;
for(;it < pContext->routines_top; ++it) {
int it;
for(n">it = 0; it < pContext->routines_top; ++it) {
if(pContext->routines[it].panic == 0) {
return 1;
}
@ -830,8 +872,10 @@ int ink_new_type(
ctx->types_top = 0;
ctx->types_capacity = 8;
} else if(ctx->types_top == ctx->types_capacity) {
int new_count = (ctx->types_capacity + ctx->types_capacity/2);
void* renewed = ctx->inner_realloc(ctx->types, sizeof(struct ink_type) * new_count);
int new_count;
void* renewed;
new_count = (ctx->types_capacity + ctx->types_capacity/2);
renewed = ctx->inner_realloc(ctx->types, sizeof(struct ink_type) * new_count);
if(renewed == NULL) {
return -129;
} else {
@ -855,8 +899,9 @@ int ink_new_type(
}
static struct element_slab* ink_get_value_link(struct context* ctx, struct elem ref) {
int type_id;
if(ref.type < 16) return NULL;
int type_id = ref.type - 16;
type_id = ref.type - 16;
if(type_id >= ctx->types_top) return NULL;
if(ctx->types[type_id].element_size == 0) return NULL;
if(ref.value < 0) return NULL;
@ -873,24 +918,23 @@ void* ink_get_value(struct context* ctx, struct elem ref) {
}
struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
int type_id;
struct elem ret;
if(type < 16) {
struct elem ret;
ret.type = 0;
ret.value = -130;
return ret;
}
// Apply invariant of the user defined types
kt">int type_id = type - 16;
type_id = type - 16;
if(type_id >= ctx->types_top) {
struct elem ret;
ret.type = 0;
ret.value = -129;
return ret;
}
if(ctx->panic) {
struct elem ret;
ret.type = 0;
ret.value = -135;
return ret;
@ -903,10 +947,11 @@ struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
ctx->types[type_id].elements_capacity = 8;
memset(ctx->types[type_id].elements + ctx->types[type_id].elements_top, 0, sizeof(struct element_slab)*(ctx->types[type_id].elements_capacity - ctx->types[type_id].elements_top));
} else if(ctx->types[type_id].elements_top == ctx->types[type_id].elements_capacity) {
int new_count = (ctx->types[type_id].elements_capacity + ctx->types[type_id].elements_capacity/2);
void* renewed = ctx->inner_realloc(ctx->types[type_id].elements, sizeof(struct element_slab) * new_count);
int new_count;
void* renewed;
new_count = (ctx->types[type_id].elements_capacity + ctx->types[type_id].elements_capacity/2);
renewed = ctx->inner_realloc(ctx->types[type_id].elements, sizeof(struct element_slab) * new_count);
if(renewed == NULL) {
struct elem ret;
ret.type = 0;
ret.value = -129;
return ret;
@ -918,8 +963,8 @@ struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
}
// Push value in store
int g = ctx->types[type_id].elements_capacity;
int i;
int g, i;
g = ctx->types[type_id].elements_capacity;
for(i = 0; i < g; ++i) {
if(! ctx->types[type_id].elements[i].in_use) {
ctx->types[type_id].elements[i].in_use = 1;
@ -929,7 +974,6 @@ struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
} else {
void* new_ptr = ctx->malloc(ctx->types[type_id].element_size);
if(new_ptr == NULL) {
struct elem ret;
ret.type = 0;
ret.value = -139;
return ret;
@ -938,13 +982,11 @@ struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
ctx->types[type_id].elements[i].data = new_ptr;
}
ctx->types[type_id].elements_top = max(ctx->types[type_id].elements_top, i+1);
struct elem ret;
ret.type = type;
ret.value = i;
return ret;
}
}
struct elem ret;
ret.type = 0;
ret.value = -140;
return ret;
@ -952,6 +994,9 @@ struct elem ink_make_native(struct context* ctx, int type, void* ptr) {
void ink_gc(struct context* ctx) {
int i, j, k;
int marked;
struct element_slab* v;
for(i = 0; i < ctx->types_top; ++i) {
for(j = 0; j < ctx->types[i].elements_top; ++j) {
ctx->types[i].elements[j].uses = 0;
@ -961,22 +1006,23 @@ void ink_gc(struct context* ctx) {
// Start by marking the roots of the routines
for(i = 0; i < ctx->routines_top; ++i) {
for(j = 0; j < ctx->routines[i].top; ++j) {
k">struct element_slab* v = ink_get_value_link(ctx, ctx->routines[i].stack[j]);
v = ink_get_value_link(ctx, ctx->routines[i].stack[j]);
if(v != NULL) ++v->uses;
}
}
// Mark the rest of the data
int marked;
do {
marked = 0;
for (i = 0; i < ctx->types_top; ++i) {
for (j = 0; j < ctx->types[i].elements_top; ++j) {
// Only mark from things that are active and detected as in use
if (ctx->types[i].elements[j].in_use && ctx->types[i].elements[j].uses) {
struct ink_collection_list c = ctx->types[i].gc(ctx, ctx->types[i].elements[j].data);
struct ink_collection_list c;
c = ctx->types[i].gc(ctx, ctx->types[i].elements[j].data);
for (k = 0; k < c.count; ++k) {
struct element_slab *v = ink_get_value_link(ctx, c.elements[k]);
struct element_slab *v;
v = ink_get_value_link(ctx, c.elements[k]);
// Never mark twice to avoid infinite loops with e.g. arrays that contain themselves
if (v != NULL && !v->uses) {
++v->uses;
@ -1009,14 +1055,17 @@ void ink_gc(struct context* ctx) {
/**********************************************************************************************************************/
static void print_stacktrace(struct context* _) {
int i = 0;
struct ink_routine* currentRoutine = _->routines + _->routine_current;
for(; i < currentRoutine->function_stack_top; ++i) {
int i;
struct ink_routine* currentRoutine;
currentRoutine = _->routines + _->routine_current;
for(i = 0; i < currentRoutine->function_stack_top; ++i) {
struct elem thing;
char *n;
thing = currentRoutine->function_stack[i].executing;
switch(thing.type) {
case INK_NATIVE_FUNCTION: {
kt">char *n = _->native_words[thing.value].name;
n = _->native_words[thing.value].name;
while (*n) {
_->putchar(*n);
++n;
@ -1025,7 +1074,7 @@ static void print_stacktrace(struct context* _) {
break;
}
case INK_FUNCTION:{
kt">char *n = _->native_words[thing.value].name;
n = _->native_words[thing.value].name;
while (*n) {
_->putchar(*n);
++n;
@ -1047,13 +1096,14 @@ static void print_stacktrace(struct context* _) {
}
static void add_int(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
struct elem b;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
@ -1065,13 +1115,14 @@ static void add_int(struct context* ctx) {
}
static void sub_int(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
struct elem b;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
@ -1083,13 +1134,14 @@ static void sub_int(struct context* ctx) {
}
static void mult_int(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
struct elem b;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
@ -1101,13 +1153,14 @@ static void mult_int(struct context* ctx) {
}
static void div_int(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
struct elem b;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
@ -1119,13 +1172,14 @@ static void div_int(struct context* ctx) {
}
static void rem_int(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
struct elem b;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
@ -1137,20 +1191,22 @@ static void rem_int(struct context* ctx) {
}
static void dupe_elem(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
int err;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
ctx->panic = 1;
return;
}
struct elem a;
a = currentRoutine->stack[currentRoutine->top-1];
int err;
err = ink_push(ctx, a);
if(err < 0) ctx->panic;
}
static void drop_elem(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
ctx->panic = 1;
return;
@ -1159,36 +1215,38 @@ static void drop_elem(struct context* ctx) {
}
static void pluck_elem(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
int position, err;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
currentRoutine->panic = 1;
return;
}
struct elem a;
a = currentRoutine->stack[currentRoutine->top-1];
if(a.type != INK_INTEGER) {
ctx->panic = 1;
return;
}
kt">int position = currentRoutine->top - (a.value + 1);
position = currentRoutine->top - (a.value + 1);
if(position >= currentRoutine->top || position < 0) {
ctx->panic = 1;
return;
}
ink_pop(ctx);
int err;
err = ink_push(ctx, currentRoutine->stack[position]);
if(err < 0) ctx->panic;
}
static void swap_elem(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
struct elem b;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
currentRoutine->stack[currentRoutine->top-2] = a;
@ -1196,12 +1254,13 @@ static void swap_elem(struct context* ctx) {
}
static void return_if(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
ctx->panic = 1;
return;
}
struct elem a;
a = currentRoutine->stack[currentRoutine->top-1];
if(a.type != INK_INTEGER) {
ctx->panic = 1;
@ -1216,12 +1275,13 @@ static void return_if(struct context* ctx) {
}
static void jump_if(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
ctx->panic = 1;
return;
}
struct elem a;
a = currentRoutine->stack[currentRoutine->top-1];
if(a.type != INK_INTEGER) {
ctx->panic = 1;
@ -1238,16 +1298,19 @@ static void jump_if(struct context* ctx) {
}
static void print_int(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
char* n;
char* str;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1 || currentRoutine->stack[currentRoutine->top-1].type != INK_INTEGER) {
currentRoutine->panic = 1;
return;
}
struct elem a;
a = currentRoutine->stack[currentRoutine->top-1];
ink_pop(ctx);
kt">char* n = ink_itoa(ctx, a.value);
kt">char* str = n;
n = ink_itoa(ctx, a.value);
str = n;
while (*str) {
ctx->putchar(*str);
++str;
@ -1256,12 +1319,13 @@ static void print_int(struct context* ctx) {
}
static void print_as_utf8(struct context* ctx) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
struct ink_routine* currentRoutine;
struct elem a;
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1 || currentRoutine->stack[currentRoutine->top-1].type != INK_INTEGER) {
ctx->panic = 1;
return;
}
struct elem a;
a = currentRoutine->stack[currentRoutine->top-1];
if(a.value <= 0x7F) {
ctx->putchar(a.value);
@ -1301,13 +1365,15 @@ static int get_type_by_name(struct context* ctx, const char* name) {
}
static void collect_array(struct context* ctx, void* array) {
struct ink_array* ary = array;
struct ink_array* ary;
ary = array;
if(ary->elements != NULL) ctx->free(ary->elements);
}
static struct ink_collection_list gc_array(struct context* ctx, void* array) {
struct ink_array* ary = array;
struct ink_array* ary;
struct ink_collection_list c;
ary = array;
c.elements = ctx->inner_malloc(sizeof(struct elem)*ary->top);
c.count = ary->top;
memcpy(c.elements, ary->elements, sizeof(struct elem)*ary->top);
@ -1315,25 +1381,30 @@ static struct ink_collection_list gc_array(struct context* ctx, void* array) {
}
static void new_array(struct context* ctx) {
int tid = get_type_by_name(ctx, "array");
int tid;
struct elem e;
struct ink_array ary;
tid = get_type_by_name(ctx, "array");
ary.elements = NULL;
ary.top = 0;
ary.capacity = 0;
k">struct elem e = ink_make_native(ctx, tid, &ary);
e = ink_make_native(ctx, tid, &ary);
ink_push(ctx, e);
}
static void push_array(struct context* ctx) {
int tid = get_type_by_name(ctx, "array");
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
int tid;
struct elem a;
struct ink_routine* currentRoutine;
struct ink_array* ary;
tid = get_type_by_name(ctx, "array");
currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2 || currentRoutine->stack[currentRoutine->top-1].type != tid) {
currentRoutine->panic = 1;
return;
}
struct elem a;
a = currentRoutine->stack[currentRoutine->top-1];
k">struct ink_array* ary= ink_get_value(ctx, a);
ary= ink_get_value(ctx, a);
if(ary == NULL) {
currentRoutine->panic = 1;
return;
@ -1345,8 +1416,10 @@ static void push_array(struct context* ctx) {
ary->top = 0;
ary->capacity = 8;
} else if(ary->top == ary->capacity) {
int new_count = (ary->capacity + ary->capacity/2);
void* renewed = ctx->realloc(ary->elements, sizeof(struct elem) * new_count);
int new_count;
void* renewed;
new_count = (ary->capacity + ary->capacity/2);
renewed = ctx->realloc(ary->elements, sizeof(struct elem) * new_count);
if(renewed == NULL) {
currentRoutine->panic = 1;
return;
@ -1363,22 +1436,26 @@ static void push_array(struct context* ctx) {
static void index_array(struct context* ctx) {
int tid = get_type_by_name(ctx, "array");
struct ink_routine *currentRoutine = ctx->routines + ctx->routine_current;
int tid;
struct ink_routine *currentRoutine;
struct elem a;
struct ink_array *ary;
struct elem idx;
tid = get_type_by_name(ctx, "array");
currentRoutine = ctx->routines + ctx->routine_current;
if (currentRoutine->top < 2 || currentRoutine->stack[currentRoutine->top - 1].type != tid || currentRoutine->stack[currentRoutine->top - 2].type != INK_INTEGER) {
currentRoutine->panic = 1;
return;
}
struct elem a;
a = currentRoutine->stack[currentRoutine->top - 1];
k">struct ink_array *ary = ink_get_value(ctx, a);
ary = ink_get_value(ctx, a);
if (ary == NULL) {
currentRoutine->panic = 1;
return;
}
ink_pop(ctx);
struct elem idx;
idx = currentRoutine->stack[currentRoutine->top - 1];
ink_pop(ctx);
@ -1396,9 +1473,9 @@ static void run_gc(struct context* ctx) {
int ink_std_library(struct context* ctx) {
int v;
int v, array_t;
v = 0;
kt">int array_t = ink_new_type(ctx, "array", sizeof(struct ink_array), collect_array, gc_array);
array_t = ink_new_type(ctx, "array", sizeof(struct ink_array), collect_array, gc_array);
v += ink_add_native(ctx, "array.new", new_array);
v += ink_add_native(ctx, "array.push", push_array);
v += ink_add_native(ctx, "array.index", index_array);

撰写 预览
正在加载...
取消
保存