Archivist
/
ink
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

Added coroutine handling

main
Ludovic 'Archivist' Lagouardette 4 months ago
parent
5c0cfba195
commit
d889788777
12 changed files with 347 additions and 117 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -0
      CMakeLists.txt
  2. +38
    -0
      bench.c
  3. +30
    -6
      ink.h
  4. +242
    -108
      lib.c
  5. +6
    -2
      main.c
  6. +5
    -0
      report.csv
  7. +6
    -0
      test/bench01.nk
  8. +7
    -0
      test/bench02.nk
  9. +1
    -0
      test/bench03.nk
  10. +7
    -0
      test/test01.nk
  11. +1
    -1
      test/test03.nk
  12. +1
    -0
      test/test04.nk

+ 3
- 0
CMakeLists.txt View File

@ -6,3 +6,6 @@ set(CMAKE_C_STANDARD 90)
add_library(ink lib.c ink.h)
add_executable(ink_exe main.c)
target_link_libraries(ink_exe PUBLIC ink)
add_executable(ink_bench bench.c)
target_link_libraries(ink_bench PUBLIC ink)

+ 38
- 0
bench.c View File

@ -0,0 +1,38 @@
#include "ink.h"
#include <stdio.h>
#include <string.h>
#include <malloc.h>
int nop_putchar(int n) {
return n;
}
int main(int _1, char** _2) {
char read_buffer[2048];
struct context* ctx = ink_make_default_context();
ctx->putchar = nop_putchar;
char* argv_d[3];
argv_d[0] = "test/bench01.nk";
argv_d[1] = "test/bench02.nk";
argv_d[2] = "test/bench03.nk";
char** it = argv_d;
char** end_argv = it + 3;
for(; it != end_argv; it++) {
FILE* file = fopen(*it, "r");
size_t cnt = fread(read_buffer, 1, 2047, file);
if(cnt == 0) {
}
read_buffer[cnt] = 0;
ink_compile(ctx, read_buffer);
if(ctx->panic) {
perror("Panicked !!");
}
fclose(file);
}
return ctx->panic;
}

+ 30
- 6
ink.h View File

@ -5,6 +5,9 @@
#define INK_NATIVE_FUNCTION 1
#define INK_FUNCTION 2
#define INK_ROUTINE_CAN_REUSE 32
#define INK_ROUTINE_SUCCESS 1
struct elem {
int type;
int value;
@ -28,12 +31,8 @@ struct native_fn {
void(*value)(struct context*);
};
struct context {
struct ink_routine {
int panic;
void*(*malloc)(size_t);
void*(*realloc)(void*, size_t);
void(*free)(void*);
int(*putchar)(int);
struct elem* stack;
int capacity;
@ -43,6 +42,21 @@ struct context {
int function_stack_capacity;
int function_stack_top;
void* routine_userdata;
};
struct context {
int panic;
void*(*malloc)(size_t);
void*(*realloc)(void*, size_t);
void(*free)(void*);
int(*putchar)(int);
struct ink_routine* routines;
int routines_capacity;
int routines_top;
int routine_current;
struct native_fn* native_words;
int native_words_capacity;
int native_words_top;
@ -54,8 +68,14 @@ struct context {
char** lex_reserved_words;
int lex_reserved_words_capacity;
int lex_reserved_words_top;
unsigned int steps;
void* persistent_userdata;
};
int ink_make_routine(struct context* ctx);
int ink_kill_routine(struct context* ctx, int routine);
int ink_add_native(struct context* ctx, const char* name, void(*value)(struct context*));
int ink_push(struct context* ctx, struct elem value);
int ink_push_fn(struct context* ctx, struct stack_frame value);
@ -64,5 +84,9 @@ struct context* ink_make_context(void*(*malloc)(size_t), void*(*realloc)(void*,
struct context* ink_make_default_context();
#endif
int ink_step(struct context *pContext);
void ink_run(struct context *pContext, char* buffer);
int ink_can_run(struct context *pContext);
int ink_step_everyone(struct context* pContext);
void ink_compile(struct context *pContext, char* buffer);
int ink_std_library(struct context* ctx);
void ink_pop_fn(struct context* ctx);
void ink_pop(struct context* ctx);

+ 242
- 108
lib.c View File

@ -4,6 +4,9 @@
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#ifndef NOINSTR
#include <time.h>
#endif
#endif
#define INK_RESERVED (-1)
@ -195,55 +198,64 @@ static int ink_add_lex_string(struct context* ctx, const char* name) {
}
int ink_push(struct context* ctx, struct elem value) {
if(ctx->stack == NULL) {
ctx->stack = ctx->malloc(sizeof(struct elem) * 8);
ctx->top = 0;
ctx->capacity = 8;
} else if(ctx->top == ctx->capacity) {
int new_count = (ctx->capacity + ctx->capacity/2);
void* renewed = ctx->realloc(ctx->stack, sizeof(struct elem) * new_count);
if(ctx->routine_current >= ctx->routines_top) return -65;
struct ink_routine* 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);
if(renewed == NULL) {
return -18;
} else {
ctx->stack = renewed;
ctx->capacity = new_count;
current->stack = renewed;
current->capacity = new_count;
}
}
ctx->stack[ctx->top] = value;
ctx->top++;
current->stack[current->top] = value;
current->top++;
return 0;
}
int ink_push_fn(struct context* ctx, struct stack_frame value) {
if(ctx->function_stack == NULL) {
ctx->function_stack = ctx->malloc(sizeof(struct stack_frame) * 8);
ctx->function_stack_top = 0;
ctx->function_stack_capacity = 8;
} else if(ctx->function_stack_top == ctx->function_stack_capacity) {
int new_count = (ctx->function_stack_capacity + ctx->function_stack_capacity/2);
void* renewed = ctx->realloc(ctx->function_stack, sizeof(struct stack_frame) * new_count);
if(ctx->routine_current >= ctx->routines_top) return -55;
struct ink_routine* 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);
if(renewed == NULL) {
return -9;
} else {
ctx->function_stack = renewed;
ctx->function_stack_capacity = new_count;
current->function_stack = renewed;
current->function_stack_capacity = new_count;
}
}
ctx->function_stack[ctx->function_stack_top] = value;
ctx->function_stack_top++;
current->function_stack[current->function_stack_top] = value;
current->function_stack_top++;
return 0;
}
static void ink_pop_fn(struct context* ctx) {
if(ctx->function_stack == NULL) return;
if(ctx->function_stack_top == 0) return;
ctx->function_stack_top--;
void ink_pop_fn(struct context* ctx) {
if(ctx->routine_current >= ctx->routines_top) return;
if(ctx->routines[ctx->routine_current].panic) return;
if(ctx->routines[ctx->routine_current].function_stack == NULL) return;
if(ctx->routines[ctx->routine_current].function_stack_top == 0) return;
ctx->routines[ctx->routine_current].function_stack_top--;
}
static void ink_pop(struct context* ctx) {
if(ctx->stack == NULL) return;
if(ctx->top == 0) return;
ctx->top--;
void ink_pop(struct context* ctx) {
if(ctx->routine_current >= ctx->routines_top) return;
if(ctx->routines[ctx->routine_current].panic) return;
if(ctx->routines[ctx->routine_current].stack == NULL) return;
if(ctx->routines[ctx->routine_current].top == 0) return;
ctx->routines[ctx->routine_current].top--;
}
struct context* ink_make_context(void*(*malloc)(size_t), void*(*realloc)(void*, size_t), void(*free)(void*), int(*putchar)(int)) {
@ -253,12 +265,9 @@ struct context* ink_make_context(void*(*malloc)(size_t), void*(*realloc)(void*,
ctx->free = free;
ctx->putchar = putchar;
ctx->panic = 0;
ctx->stack = NULL;
ctx->capacity = 0;
ctx->top = 0;
ctx->function_stack = NULL;
ctx->function_stack_capacity = 0;
ctx->function_stack_top = 0;
ctx->routines = NULL;
ctx->routines_capacity = 0;
ctx->routines_top = 0;
ctx->native_words = NULL;
ctx->native_words_capacity = 0;
ctx->native_words_top = 0;
@ -268,6 +277,7 @@ struct context* ink_make_context(void*(*malloc)(size_t), void*(*realloc)(void*,
ctx->lex_reserved_words = NULL;
ctx->lex_reserved_words_capacity = 0;
ctx->lex_reserved_words_top = 0;
ctx->steps = 0;
return ctx;
}
@ -276,6 +286,7 @@ struct context* ink_make_context(void*(*malloc)(size_t), void*(*realloc)(void*,
* @param _ context (used to allocate)
* @param cpy the value
* @return the allocated string, needs to be freed by ctx->free
* @internal this function is slightly cursed
*/
static char* ink_itoa(struct context* _, int cpy) {
char* n = _->malloc(16);
@ -439,6 +450,74 @@ static int lblcmp(const char* label, const char* other, size_t label_sz) {
return 0;
}
int ink_make_routine(struct context* ctx) {
if(ctx->routines == NULL) {
ctx->routines = ctx->malloc(sizeof(struct ink_routine) * 8);
ctx->routines_top = 0;
ctx->routines_capacity = 8;
struct ink_routine* it = ctx->routines;
struct ink_routine* 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->realloc(ctx->routines, sizeof(struct stack_frame) * new_count);
if(renewed == NULL) {
return -99;
} else {
ctx->routines = renewed;
struct ink_routine* it = ctx->routines + ctx->routines_capacity;
struct ink_routine* end = ctx->routines + new_count;
for(;it != end;++it) {
it->panic = INK_ROUTINE_CAN_REUSE;
}
ctx->routines_capacity = new_count;
}
}
struct ink_routine* it = ctx->routines;
struct ink_routine* end = ctx->routines + ctx->routines_capacity;
for(;it != end;++it) {
if(it->panic == INK_ROUTINE_CAN_REUSE) {
it->panic = 0;
it->stack = NULL;
it->top = 0;
it->capacity = 0;
it->function_stack = NULL;
it->function_stack_top = 0;
it->function_stack_capacity = 0;
int idx = it - ctx->routines;
if(idx >= ctx->routines_top) {
ctx->routines_top = idx + 1;
}
return idx;
}
}
}
int ink_kill_routine(struct context* ctx, int routine){
if(routine < 0 || routine >= ctx->routines_top) {
return 0;
}
struct ink_routine* curr = ctx->routines + routine;
if(curr->panic == INK_ROUTINE_CAN_REUSE) {
return 0;
}
if(curr->stack != NULL) {
ctx->free(curr->stack);
curr->stack = NULL;
}
if(curr->function_stack != NULL) {
ctx->free(curr->function_stack);
curr->function_stack = NULL;
}
curr->panic = INK_ROUTINE_CAN_REUSE;
}
/**
*
* @param pContext
@ -447,6 +526,7 @@ static int lblcmp(const char* label, const char* other, size_t label_sz) {
* @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;
#define LABEL_BUFFER 128
#define FUNCTION_BUFFER 256
@ -459,9 +539,9 @@ static int ink_parse(struct context* pContext, struct elem* executable_buffer, i
#define MODE_DO 2
int mode = 0;
memset(labels, 0, sizeof(struct label)*LABEL_BUFFER);
for(i = 0; i < pContext->top; ++i) {
for(i = 0; i < currentRoutine->top; ++i) {
struct elem current;
current = pContext->stack[i];
current = currentRoutine->stack[i];
switch (mode) {
case MODE_EXECUTABLE:
switch(current.type) {
@ -570,7 +650,9 @@ static int ink_parse(struct context* pContext, struct elem* executable_buffer, i
}
int ink_step(struct context *pContext) {
if(pContext->function_stack_top == 0) return 0;
struct ink_routine* currentRoutine = pContext->routines + pContext->routine_current;
pContext->steps++;
if(currentRoutine->function_stack_top == 0) return 0;
if(pContext->panic) {
return -1;
}
@ -578,7 +660,7 @@ int ink_step(struct context *pContext) {
struct stack_frame* top;
struct elem next;
int t;
top = &pContext->function_stack[pContext->function_stack_top-1];
top = &currentRoutine->function_stack[currentRoutine->function_stack_top-1];
t = top->executing.type;
switch(t) {
case INK_NATIVE_FUNCTION:
@ -628,11 +710,14 @@ int ink_step(struct context *pContext) {
return 1;
}
void ink_run(struct context *pContext, char* buffer) {
pContext->free(pContext->stack);
pContext->stack = NULL;
pContext->top = 0;
pContext->capacity = 0;
void ink_compile(struct context *pContext, char* buffer) {
int routine = ink_make_routine(pContext);
int saved = pContext->routine_current;
pContext->routine_current = routine;
struct ink_routine* currentRoutine = pContext->routines + routine;
currentRoutine->stack = NULL;
currentRoutine->top = 0;
currentRoutine->capacity = 0;
int err;
err = ink_lex(pContext, buffer);
if(err < 0) {
@ -648,7 +733,13 @@ void ink_run(struct context *pContext, char* buffer) {
return;
}
struct stack_frame frame;
frame.executing.value = ink_add_indigenous(pContext, "__-MAIN-__", executable_buffer, executable_buffer_top);
char main_fn[32] = "__-MAIN-__";
char* integer = ink_itoa(pContext, routine);
size_t integer_size = strlen(integer);
memcpy(main_fn+10, integer, integer_size);
pContext->free(integer);
main_fn[10+integer_size] = 0;
frame.executing.value = ink_add_indigenous(pContext, main_fn, executable_buffer, executable_buffer_top);
if(frame.executing.value < 0) {
pContext->panic = 1;
return;
@ -661,19 +752,49 @@ void ink_run(struct context *pContext, char* buffer) {
return;
}
pContext->routine_current = saved;
return;
}
int ink_can_run(struct context* pContext) {
int it = 0;
for(;it < pContext->routines_top; ++it) {
if(pContext->routines[it].panic == 0) {
return 1;
}
}
return 0;
}
int ink_step_everyone(struct context* pContext) {
int out;
do {
pContext->routine_current = -1;
for(;;) {
do{
++(pContext->routine_current);
} while(pContext->routine_current < pContext->routines_top && pContext->routines[pContext->routine_current].panic != 0);
if(pContext->routine_current >= pContext->routines_top) break;
if(pContext->routines[pContext->routine_current].panic == INK_ROUTINE_SUCCESS) {
ink_kill_routine(pContext, pContext->routine_current);
}
out = ink_step(pContext);
} while(out > 0);
if(out == 0) {
pContext->routines[pContext->routine_current].panic = INK_ROUTINE_SUCCESS;
} else if(out < 0) {
pContext->routines[pContext->routine_current].panic = out;
}
}
return 0;
}
/**********************************************************************************************************************/
static void print_stacktrace(struct context* _) {
int i = 0;
for(; i < _->function_stack_top; ++i) {
struct ink_routine* currentRoutine = _->routines + _->routine_current;
for(; i < currentRoutine->function_stack_top; ++i) {
struct elem thing;
thing = _->function_stack[i].executing;
thing = currentRoutine->function_stack[i].executing;
switch(thing.type) {
case INK_NATIVE_FUNCTION: {
char *n = _->native_words[thing.value].name;
@ -691,7 +812,7 @@ static void print_stacktrace(struct context* _) {
++n;
}
_->putchar(':');
n = ink_itoa(_, _->function_stack[i].index);
n = ink_itoa(_, currentRoutine->function_stack[i].index);
while (*n) {
_->putchar(*n);
++n;
@ -707,104 +828,111 @@ static void print_stacktrace(struct context* _) {
}
static void add_int(struct context* ctx) {
if(ctx->top < 2) {
ctx->panic = 1;
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = ctx->stack[ctx->top-1];
b = ctx->stack[ctx->top-2];
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
ctx->panic = 1;
return;
}
ink_pop(ctx);
ctx->stack[ctx->top-1].value = a.value + b.value;
currentRoutine->stack[currentRoutine->top-1].value = a.value + b.value;
}
static void sub_int(struct context* ctx) {
if(ctx->top < 2) {
ctx->panic = 1;
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = ctx->stack[ctx->top-1];
b = ctx->stack[ctx->top-2];
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
ctx->panic = 1;
currentRoutine->panic = 1;
return;
}
ink_pop(ctx);
ctx->stack[ctx->top-1].value = b.value - a.value;
currentRoutine->stack[currentRoutine->top-1].value = b.value - a.value;
}
static void mult_int(struct context* ctx) {
if(ctx->top < 2) {
ctx->panic = 1;
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = ctx->stack[ctx->top-1];
b = ctx->stack[ctx->top-2];
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
ctx->panic = 1;
currentRoutine->panic = 1;
return;
}
ink_pop(ctx);
ctx->stack[ctx->top-1].value = b.value * a.value;
currentRoutine->stack[currentRoutine->top-1].value = b.value * a.value;
}
static void div_int(struct context* ctx) {
if(ctx->top < 2) {
ctx->panic = 1;
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = ctx->stack[ctx->top-1];
b = ctx->stack[ctx->top-2];
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
ctx->panic = 1;
currentRoutine->panic = 1;
return;
}
ink_pop(ctx);
ctx->stack[ctx->top-1].value = b.value / a.value;
currentRoutine->stack[currentRoutine->top-1].value = b.value / a.value;
}
static void rem_int(struct context* ctx) {
if(ctx->top < 2) {
ctx->panic = 1;
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = ctx->stack[ctx->top-1];
b = ctx->stack[ctx->top-2];
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
if(!(a.type == INK_INTEGER && b.type == INK_INTEGER)) {
ctx->panic = 1;
currentRoutine->panic = 1;
return;
}
ink_pop(ctx);
ctx->stack[ctx->top-1].value = b.value % a.value;
currentRoutine->stack[currentRoutine->top-1].value = b.value % a.value;
}
static void dupe_elem(struct context* ctx) {
if(ctx->top < 1) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
ctx->panic = 1;
return;
}
struct elem a;
a = ctx->stack[ctx->top-1];
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) {
if(ctx->top < 1) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
ctx->panic = 1;
return;
}
@ -812,47 +940,50 @@ static void drop_elem(struct context* ctx) {
}
static void pluck_elem(struct context* ctx) {
if(ctx->top < 1) {
ctx->panic = 1;
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
currentRoutine->panic = 1;
return;
}
struct elem a;
a = ctx->stack[ctx->top-1];
a = currentRoutine->stack[currentRoutine->top-1];
if(a.type != INK_INTEGER) {
ctx->panic = 1;
return;
}
int position = ctx->top - (a.value + 1);
if(position >= ctx->top || position < 0) {
int 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, ctx->stack[position]);
err = ink_push(ctx, currentRoutine->stack[position]);
if(err < 0) ctx->panic;
}
static void swap_elem(struct context* ctx) {
if(ctx->top < 2) {
ctx->panic = 1;
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 2) {
currentRoutine->panic = 1;
return;
}
struct elem a;
struct elem b;
a = ctx->stack[ctx->top-1];
b = ctx->stack[ctx->top-2];
ctx->stack[ctx->top-2] = a;
ctx->stack[ctx->top-1] = b;
a = currentRoutine->stack[currentRoutine->top-1];
b = currentRoutine->stack[currentRoutine->top-2];
currentRoutine->stack[currentRoutine->top-2] = a;
currentRoutine->stack[currentRoutine->top-1] = b;
}
static void return_if(struct context* ctx) {
if(ctx->top < 1) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
ctx->panic = 1;
return;
}
struct elem a;
a = ctx->stack[ctx->top-1];
a = currentRoutine->stack[currentRoutine->top-1];
if(a.type != INK_INTEGER) {
ctx->panic = 1;
return;
@ -866,12 +997,13 @@ static void return_if(struct context* ctx) {
}
static void jump_if(struct context* ctx) {
if(ctx->top < 1) {
struct ink_routine* currentRoutine = ctx->routines + ctx->routine_current;
if(currentRoutine->top < 1) {
ctx->panic = 1;
return;
}
struct elem a;
a = ctx->stack[ctx->top-1];
a = currentRoutine->stack[currentRoutine->top-1];
if(a.type != INK_INTEGER) {
ctx->panic = 1;
return;
@ -879,21 +1011,21 @@ static void jump_if(struct context* ctx) {
ink_pop(ctx);
if(a.value) {
ink_pop_fn(ctx);
a = ctx->stack[ctx->top-1];
ctx->function_stack[ctx->function_stack_top - 1].index += a.value - 3;
ink_pop(ctx);
//printf("\t*%d\n", ctx->function_stack[ctx->function_stack_top - 1].index);
a = currentRoutine->stack[currentRoutine->top-1];
currentRoutine->function_stack[currentRoutine->function_stack_top - 1].index += a.value - 3;
}
ink_pop(ctx);
return;
}
static void print_int(struct context* ctx) {
if(ctx->top < 1 || ctx->stack[ctx->top-1].type != INK_INTEGER) {
ctx->panic = 1;
struct ink_routine* 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 = ctx->stack[ctx->top-1];
a = currentRoutine->stack[currentRoutine->top-1];
ink_pop(ctx);
char* n = ink_itoa(ctx, a.value);
char* str = n;
@ -905,12 +1037,13 @@ static void print_int(struct context* ctx) {
}
static void print_as_utf8(struct context* ctx) {
if(ctx->top < 1 || ctx->stack[ctx->top-1].type != INK_INTEGER) {
struct ink_routine* 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 = ctx->stack[ctx->top-1];
a = currentRoutine->stack[currentRoutine->top-1];
if(a.value <= 0x7F) {
ctx->putchar(a.value);
} else if(a.value <= 0x7FF) {
@ -934,6 +1067,7 @@ static void print_as_utf8(struct context* ctx) {
int ink_std_library(struct context* ctx) {
int v;
v = 0;
v += ink_add_native(ctx, "trace", print_stacktrace);
v += ink_add_native(ctx, "print_int", print_int);
v += ink_add_native(ctx, "print_utf8", print_as_utf8);

+ 6
- 2
main.c View File

@ -12,14 +12,18 @@ int main(int argc, char** argv) {
}
read_buffer[cnt] = 0;
ink_run(ctx, read_buffer);
ink_compile(ctx, read_buffer);
if(ctx->panic) {
perror("Panicked !!");
fprintf(stderr, "Panicked !! -> %d\n", ctx->panic);
}
fclose(file);
}
while(ink_can_run(ctx)) {
ink_step_everyone(ctx);
}
printf("\nExecuted in %u steps\n", ctx->steps);
return ctx->panic;
}

+ 5
- 0
report.csv View File

@ -0,0 +1,5 @@
date | ns per tick | Hz
05/14/24 05:42:51 | 10.705865 | 93406742.537313
05/14/24 05:43:36 | 9.227817 | 108367995.670996
05/14/24 05:43:39 | 9.227817 | 108367995.670996
05/14/24 05:43:42 | 9.547395 | 104740615.062762

+ 6
- 0
test/bench01.nk View File

@ -0,0 +1,6 @@
fn potato do
start:
-1 + dup
65 print_utf8 10 print_utf8
start swap jump_if
end

+ 7
- 0
test/bench02.nk View File

@ -0,0 +1,7 @@
fn potato2 do
start:
-1 + dup
1000 potato drop
65 print_utf8 10 print_utf8
start swap jump_if
end

+ 1
- 0
test/bench03.nk View File

@ -0,0 +1 @@
1000 potato2

+ 7
- 0
test/test01.nk View File

@ -13,4 +13,11 @@ fn potato2 do
-1 + dup
65 print_utf8 10 print_utf8
start swap jump_if
end
fn potato3 do
start:
-1 + dup
66 print_utf8 10 print_utf8
start swap jump_if
end

+ 1
- 1
test/test03.nk View File

@ -1 +1 @@
100 108 114 111 119 32 111 108 108 101 72 11 print_n_utf8
4 potato2

+ 1
- 0
test/test04.nk View File

@ -0,0 +1 @@
4 potato3

Write Preview
Loading…
Cancel
Save