mbess/langatator
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Activity

feat: failed attempt to make emscripten work

Browse source
This commit is contained in:
Matthieu Bessat 2022-05-21 18:38:26 +02:00
parent bb52b98ae7
commit 110eab7a1a
43 changed files with 700 additions and 148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
.vscode/launch.json vendored Normal file
View file

@ -0,0 +1,29 @@
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "gcc build and debug active file",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/bin/test",
"args": [],
"stopAtEntry": true,
"cwd": "${workspaceFolder}",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
],
"preLaunchTask": "tasks",
"miDebuggerPath": "/usr/bin/gdb"
}
]
}

11
.vscode/settings.json vendored Normal file
View file

@ -0,0 +1,11 @@
{
"files.associations": {
"*.ts": "typescript",
"*.asm": "python",
"stdio.h": "c",
"string_view": "c",
"state.h": "c",
"stack.h": "c",
"var_store.h": "c"
}
}

16
.vscode/tasks.json vendored Normal file
View file

@ -0,0 +1,16 @@
{
// See https://go.microsoft.com/fwlink/?LinkId=733558
// for the documentation about the tasks.json format
"version": "2.0.0",
"tasks": [
{
"label": "tasks",
"type": "shell",
"command": "make test-debug",
"group": {
"kind": "build",
"isDefault": true
}
}
]
}

6
Dockerfile Normal file
View file

@ -0,0 +1,6 @@
FROM alpine:3.14
RUN apk add gcc
RUN apk add make
RUN mkdir /app
COPY ./ /app
ENTRYPOINT ["sleep", "infinity"]

12
Makefile
View file

@ -6,12 +6,22 @@ TEST_SRCS_ENC := $(foreach DIR,src,$(patsubst $(DIR)/%,%,$(wildcard ./src/*.c)))
TEST_SRCS_ENC := $(filter-out %main.c, $(TEST_SRCS_ENC)) TEST_SRCS_ENC := $(filter-out %main.c, $(TEST_SRCS_ENC))
build: build:
cp src/config_env_main.h src/config_env.h
gcc src/* -o ./bin/main ${CXXFLAGS_WITHOUT_PKGS} gcc src/* -o ./bin/main ${CXXFLAGS_WITHOUT_PKGS}
test: test:
cp src/config_env_main.h src/config_env.h
gcc ${TEST_SRCS_ENC} ./tests/* -o ./bin/test ${CXXFLAGS_WITHOUT_PKGS} gcc ${TEST_SRCS_ENC} ./tests/* -o ./bin/test ${CXXFLAGS_WITHOUT_PKGS}
./bin/test ./bin/test
test-no-run: test-no-run: ./tests/*
cp src/config_env_main.h src/config_env.h
gcc ${TEST_SRCS_ENC} ./tests/* -o ./bin/test ${CXXFLAGS_WITHOUT_PKGS} gcc ${TEST_SRCS_ENC} ./tests/* -o ./bin/test ${CXXFLAGS_WITHOUT_PKGS}
test-debug: ./tests/*
cp src/config_env_main.h src/config_env.h
gcc -g ${TEST_SRCS_ENC} ./tests/* -o ./bin/test ${CXXFLAGS_WITHOUT_PKGS}
emscripten:
cp wasm/config_env_wasm.h src/config_env.h
emcc -O3 -s WASM=1 -s EXPORTED_RUNTIME_METHODS=ccall,cwrap,getValue,setValue \
./wasm/emscripten.c ${TEST_SRCS_ENC} -o wasm/langatator_adapter.js
sandbox: sandbox:
gcc ${TEST_SRCS_ENC} ./sandbox.c -o ./bin/sandbox ${CXXFLAGS_WITHOUT_PKGS} gcc ${TEST_SRCS_ENC} ./sandbox.c -o ./bin/sandbox ${CXXFLAGS_WITHOUT_PKGS}
./bin/sandbox ./bin/sandbox

11
README.md
View file

@ -47,6 +47,7 @@ ToDo List:
- [ ] feat: basic number list support - [ ] feat: basic number list support
- [ ] feat: fully features strings support - [ ] feat: fully features strings support
- [ ] feat: function to access to environment variables - [ ] feat: function to access to environment variables
- [ ] feat: hexadecimal and binary constants
- [X] feat: REPL environment - [X] feat: REPL environment
- [ ] feat: add history to REPL - [ ] feat: add history to REPL
@ -72,6 +73,14 @@ You will need to compile the code from source.
I use GNU Make with GCC, but I'm sure you can use any C compilers though you may need to edit some part of the code to cope with other compilers (eg. binary constants). I use GNU Make with GCC, but I'm sure you can use any C compilers though you may need to edit some part of the code to cope with other compilers (eg. binary constants).
## Build to Web assembly
I use emscripten.org
It would be great if I'm not using emscripten.
I have to find implementation for stdlib
## Unit testing ## Unit testing
I try to have some sort of code coverage, you can run the unit tests by issuing `make test` I try to have some sort of code coverage, you can run the unit tests by issuing `make test`
@ -171,3 +180,5 @@ print_string(str)
print_newline() print_newline()
print_ascii(nb) print_ascii(nb)
``` ```

8
docker-compose.yml Normal file
View file

@ -0,0 +1,8 @@
version: "3.9"
services:
app:
build:
context: ./
volumes:
- ./:/app

3
examples/sandbox2.ltor Normal file
View file

@ -0,0 +1,3 @@
print_number(2)
print_number(3)

92
sandbox.c
View file

@ -1,22 +1,36 @@
// #include <stdio.h>
// #include "./src/types.h"
// #include "./src/list.h"
// #include "./src/number_parsing.h"
// #include "./src/funcs.h"
// #include "./src/utils.h"
// #include "./src/var_store.h"
// #include "./src/line_processing.h"
// #include "./src/state.h"
// #include <stdlib.h>
// #include <sys/time.h>
// #include <stddef.h>
#include <stdio.h> #include <stdio.h>
#include "./src/types.h"
#include "./src/list.h" // #define printf_wrap(f_, ...) \
#include "./src/number_parsing.h" // { \
#include "./src/funcs.h" // printf_wrap("T=%d \t", (unsigned) time(NULL)); \
#include "./src/utils.h" // printf_wrap((f_), ##__VA_ARGS__); \
#include "./src/var_store.h" // };
#include "./src/line_processing.h"
#include "./src/state.h" #define eprintf_wrap(template, ...) printf_wrap(template, ##__VA_ARGS__);
#include <stdlib.h>
int main () { int main () {
struct VariableStore* store = var_store_init();
printf("%d", var_store_hash_name(store, "print_number index"));
int i = -1; eprintf_wrap("Hello %d %s \n", 13, "World");
if (i < 0) { // struct VariableStore* store = var_store_init();
printf("lol jpp \n"); // printf_wrap("%d", var_store_hash_name(store, "print_number index"));
}
// int i = -1;
// if (i < 0) {
// printf_wrap("lol jpp \n");
// }
return 0; return 0;
//struct List l1; //struct List l1;
@ -30,32 +44,32 @@ int main () {
// int yes = 1234; // int yes = 1234;
// int dst = 0; // int dst = 0;
// memcpy(&dst, &yes, 4); // memcpy(&dst, &yes, 4);
// printf("yes: %d \n", dst); // printf_wrap("yes: %d \n", dst);
//struct VariableStore* store = var_store_init(); //struct VariableStore* store = var_store_init();
// int hashRes = var_store_hash_name(store, "HelloWorld++"); // int hashRes = var_store_hash_name(store, "HelloWorld++");
// printf("hashRes: %d \n", hashRes); // printf_wrap("hashRes: %d \n", hashRes);
// int val = 1234; // int val = 1234;
// var_store_set(store, "foo", TYPE_INT, &val); // var_store_set(store, "foo", TYPE_INT, &val);
// var_store_get_key(store, "while i < 10 then"); // var_store_get_key(store, "while i < 10 then");
//printf("Pos of var: %d \n", var_store_get_pos(store, "foo")); //printf_wrap("Pos of var: %d \n", var_store_get_pos(store, "foo"));
//byte type = var_store_get_type(store, "foo"); //byte type = var_store_get_type(store, "foo");
//printf("Type of var: %d \n", type); //printf_wrap("Type of var: %d \n", type);
//int key = var_store_get_pos(store, "foo"); //int key = var_store_get_pos(store, "foo");
//printf("size of type %d \n", get_size_of_type(store->container[key].type)); //printf_wrap("size of type %d \n", get_size_of_type(store->container[key].type));
//printf("%d \n", *((int*) store->container[key].dataPtr)); //printf_wrap("%d \n", *((int*) store->container[key].dataPtr));
// int val2 = 0; // int val2 = 0;
// var_store_copy(store, "foo", &val2); // var_store_copy(store, "foo", &val2);
// printf("Value of var: %d \n", val2); // printf_wrap("Value of var: %d \n", val2);
// printf("==== \n"); // printf_wrap("==== \n");
// printf("==== \n"); // printf_wrap("==== \n");
// char* lines = "# hello world\n" // char* lines = "# hello world\n"
// "set x to 5\n" // "set x to 5\n"
@ -65,17 +79,17 @@ int main () {
// "end\n" // "end\n"
// "\n"; // "\n";
char* lines1 = "set x to 5\n" // char* lines1 = "set x to 5\n"
"set y to 1\n" // "set y to 1\n"
"if !(x+y = 6) then\n" // "if !(x+y = 6) then\n"
" print_number(x+y)\n" // " print_number(x+y)\n"
"end\n" // "end\n"
"\n"; // "\n";
printf("%s", lines1); // printf_wrap("%s", lines1);
struct StateContainer* state = state_init(); // struct StateContainer* state = state_init();
process_script(state, lines1); // process_script(state, lines1);
// struct List l1; // struct List l1;
@ -97,20 +111,20 @@ int main () {
// void* ptr = &res; // void* ptr = &res;
// printf("%d\n", sizeof(ptr)); // printf_wrap("%d\n", sizeof(ptr));
// int found = identify_func_name("ABS"); // int found = identify_func_name("ABS");
// printf("found: %d \n", found); // printf_wrap("found: %d \n", found);
// unsigned char argsType[1] = { TYPE_FLOAT }; // unsigned char argsType[1] = { TYPE_FLOAT };
// int argsVals[1] = { get_int_rep_from_float(-3.145) }; // int argsVals[1] = { get_int_rep_from_float(-3.145) };
// int resVal = 0; // int resVal = 0;
// unsigned char resType = 0; // unsigned char resType = 0;
// execute_func(found, 1, argsType, argsVals, &resVal, &resType); // execute_func(found, 1, argsType, argsVals, &resVal, &resType);
// printf("func res type: %d \n", resType); // printf_wrap("func res type: %d \n", resType);
// printf("func res: %f \n", get_float_from_int_rep(resVal)); // printf_wrap("func res: %f \n", get_float_from_int_rep(resVal));
// int stat = parse_float("1052.254", &res); // int stat = parse_float("1052.254", &res);
// printf("float parsing stat: %d \n", stat); // printf_wrap("float parsing stat: %d \n", stat);
// printf("final float: %f \n", res); // printf_wrap("final float: %f \n", res);
} }

10
src/config.h
View file

@ -1,12 +1,20 @@
#include "./config_env.h"
//#define printf_wrap(template,...) printf_wrap(template, ##__VA_ARGS__);
#define getline_wrap(...) getline(__VA_ARGS__);
#ifndef G_CONFIG_H_ #ifndef G_CONFIG_H_
#define G_CONFIG_H_ #define G_CONFIG_H_
#define PRINT_METHOD_CLASSIC 0
#define PRINT_METHOD_WASM 1
// #define CONFIG_PRINT_METHOD
#define PRESET_ENGLISH 0 #define PRESET_ENGLISH 0
#define PRESET_FRENCH 1 #define PRESET_FRENCH 1
// 0: no logs; 1: medium debug; 2: full debug // 0: no logs; 1: medium debug; 2: full debug
#define G_DEBUG_LEVEL 0 #define G_DEBUG_LEVEL 2
#define SYNTAX_PRESET PRESET_ENGLISH #define SYNTAX_PRESET PRESET_ENGLISH
// Define your own custom syntax here // Define your own custom syntax here

2
src/config_env.h Normal file
View file

@ -0,0 +1,2 @@
// the config file for main and test
#define PRINT_MODE 0

2
src/config_env_main.h Normal file
View file

@ -0,0 +1,2 @@
// the config file for main and test
#define PRINT_MODE 0

64
src/evaluator.c
View file

@ -49,7 +49,7 @@ int evaluator_reduce_operator_pattern(struct List* evalList) {
if (operateStatus != 0) { if (operateStatus != 0) {
// the pattern that matched, did not worked as expected // the pattern that matched, did not worked as expected
// this is a failure // this is a failure
printf("ERR Evaluator: cannot operate \n"); printf_wrap("ERR Evaluator: cannot operate \n");
return 400; return 400;
} }
@ -64,7 +64,7 @@ int evaluator_reduce_operator_pattern(struct List* evalList) {
list_delete(evalList, patternPos+1); list_delete(evalList, patternPos+1);
list_delete(evalList, patternPos+1); list_delete(evalList, patternPos+1);
//printf("END OF THE FIRST OPERATION \n"); //printf_wrap("END OF THE FIRST OPERATION \n");
//list_print(&evalList); //list_print(&evalList);
// so we reduced an expression, return 0 // so we reduced an expression, return 0
@ -105,7 +105,7 @@ int evaluator_reduce_minus_pattern(struct List* evalList) {
unsigned char typeRes = 0; unsigned char typeRes = 0;
int operateStatus = operate('*', TYPE_INT, -1, type, val, &typeRes, &res); int operateStatus = operate('*', TYPE_INT, -1, type, val, &typeRes, &res);
if (operateStatus != 0) { if (operateStatus != 0) {
printf("ERR Evaluator: cannot operate \n"); printf_wrap("ERR Evaluator: cannot operate \n");
return 400; return 400;
} }
@ -148,7 +148,7 @@ int evaluator_reduce_not_pattern(struct List* evalList) {
byte typeRes = 0; byte typeRes = 0;
int operateStatus = operate('!', 0, 0, type, val, &typeRes, &res); int operateStatus = operate('!', 0, 0, type, val, &typeRes, &res);
if (operateStatus != 0) { if (operateStatus != 0) {
printf("ERR Evaluator: cannot operate \n"); printf_wrap("ERR Evaluator: cannot operate \n");
return 400; return 400;
} }
@ -208,7 +208,7 @@ int evaluator_reduce_var(struct StateContainer* state, struct List* evalList) {
byte type = var_store_get_type_from_key(state->varStore, varKey); byte type = var_store_get_type_from_key(state->varStore, varKey);
if (EVALUATOR_DEBUG_LEVEL >= 2) printf("Going to reduce var key %d at pos %d\n", varKey, patternPos); if (EVALUATOR_DEBUG_LEVEL >= 2) printf_wrap("Going to reduce var key %d at pos %d\n", varKey, patternPos);
byte varVal[get_size_of_type(type)]; byte varVal[get_size_of_type(type)];
var_store_copy_from_key(state->varStore, varKey, &varVal); var_store_copy_from_key(state->varStore, varKey, &varVal);
@ -268,7 +268,7 @@ int evaluator_reduce_function_call(struct List* evalList, int initialPosition) {
// two case: either we have another arguments or we have a closing parenthesis // two case: either we have another arguments or we have a closing parenthesis
while (1) { while (1) {
if (argsLen > 16) { if (argsLen > 16) {
printf("ERR Evaluator: too many arguments passed to func (max out the limit) \n"); printf_wrap("ERR Evaluator: too many arguments passed to func (max out the limit) \n");
return 100; return 100;
} }
if ( if (
@ -335,16 +335,16 @@ int evaluator_reduce_function_call(struct List* evalList, int initialPosition) {
// now we can delete in the list from pos+1 patternPos to pos // now we can delete in the list from pos+1 patternPos to pos
// just delete N-1 times where N is the number of components in the func call // just delete N-1 times where N is the number of components in the func call
//printf("start: %d, end: %d \n", patternPos, pos); //printf_wrap("start: %d, end: %d \n", patternPos, pos);
//printf("patternPos: %d, pos: %d \n", patternPos, pos); //printf_wrap("patternPos: %d, pos: %d \n", patternPos, pos);
for (int j = 0; j < (pos-patternPos); j++) { for (int j = 0; j < (pos-patternPos); j++) {
list_delete(evalList, patternPos); list_delete(evalList, patternPos);
} }
//printf("list report after deleting after applying a func \n"); //printf_wrap("list report after deleting after applying a func \n");
//list_print(evalList); //list_print(evalList);
//printf("patternPos: %d, resType: %d \n", patternPos, resType); //printf_wrap("patternPos: %d, resType: %d \n", patternPos, resType);
list_set(evalList, patternPos, resType, &resVal); list_set(evalList, patternPos, resType, &resVal);
@ -402,12 +402,12 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
// display the partition // display the partition
if (EVALUATOR_DEBUG_LEVEL >= 2) { if (EVALUATOR_DEBUG_LEVEL >= 2) {
printf("partitionPtr: %d \n", partitionPtr); printf_wrap("partitionPtr: %d \n", partitionPtr);
} }
for (int j = 0; j < partitionPtr; j++) { for (int j = 0; j < partitionPtr; j++) {
if (EVALUATOR_DEBUG_LEVEL >= 2) { if (EVALUATOR_DEBUG_LEVEL >= 2) {
printf("start %d ", partitionStartPos[j]); printf_wrap("start %d ", partitionStartPos[j]);
printf("stop %d ", partitionStopPos[j]); printf_wrap("stop %d ", partitionStopPos[j]);
} }
int len = partitionStopPos[j] - partitionStartPos[j]; int len = partitionStopPos[j] - partitionStartPos[j];
@ -419,7 +419,7 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
} }
buff[len] = 0; buff[len] = 0;
if (EVALUATOR_DEBUG_LEVEL >= 2) { if (EVALUATOR_DEBUG_LEVEL >= 2) {
printf("content %s \n", buff); printf_wrap("content %s \n", buff);
} }
} }
@ -441,29 +441,29 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
parenthesisCount--; parenthesisCount--;
} }
if (parenthesisCount < 0) { if (parenthesisCount < 0) {
printf("ERR Evaluator: bad parenthesizing \n"); printf_wrap("ERR Evaluator: bad parenthesizing \n");
return 100; return 100;
} }
} }
if (parenthesisCount > 0) { if (parenthesisCount > 0) {
// there is an open parenthesis, so it's an error // there is an open parenthesis, so it's an error
printf("ERR Evaluator: invalid parenthesis stack \n"); printf_wrap("ERR Evaluator: invalid parenthesis stack \n");
return 100; return 100;
} }
struct List evalList; struct List evalList;
// NOTICE: for some reason the struct don't reset after a usage // NOTICE: for some reason the struct don't reset after a usage
list_reset(&evalList); list_reset(&evalList);
if (EVALUATOR_DEBUG_LEVEL >= 2) printf("\n - constructing list \n"); if (EVALUATOR_DEBUG_LEVEL >= 2) printf_wrap("\n - constructing list \n");
// initializing the evaluation list // initializing the evaluation list
for (int j = 0; j < partitionPtr; j++) { for (int j = 0; j < partitionPtr; j++) {
int startPos = partitionStartPos[j]; int startPos = partitionStartPos[j];
int stopPos = partitionStopPos[j]; int stopPos = partitionStopPos[j];
if (EVALUATOR_DEBUG_LEVEL >= 2) { if (EVALUATOR_DEBUG_LEVEL >= 2) {
printf("=== %d\n", j); printf_wrap("=== %d\n", j);
printf("startPos %d, stopPos %d\n", startPos, stopPos); printf_wrap("startPos %d, stopPos %d\n", startPos, stopPos);
} }
int len = stopPos - startPos; int len = stopPos - startPos;
@ -492,7 +492,7 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
buff[len] = 0; // terminate the buff buff[len] = 0; // terminate the buff
// TODO: SPLIT INTO A FUNCTION "identify_token(char* str)" // TODO: SPLIT INTO A FUNCTION "identify_token(char* str)"
if (EVALUATOR_DEBUG_LEVEL >= 2) printf("buff: '%s' \n", buff); if (EVALUATOR_DEBUG_LEVEL >= 2) printf_wrap("buff: '%s' \n", buff);
char dumbValue = (char) 0; char dumbValue = (char) 0;
@ -510,7 +510,7 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
continue; continue;
} }
if (len == 1 && is_operator(buff[0])) { if (len == 1 && is_operator(buff[0])) {
if (EVALUATOR_DEBUG_LEVEL >= 2) printf("found op\n"); if (EVALUATOR_DEBUG_LEVEL >= 2) printf_wrap("found op\n");
char opValue = buff[0]; char opValue = buff[0];
list_set(&evalList, evalList.num_elements, TYPE_OPERATOR, &opValue); list_set(&evalList, evalList.num_elements, TYPE_OPERATOR, &opValue);
continue; continue;
@ -520,7 +520,7 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
int st = parse_int(buff, &res); int st = parse_int(buff, &res);
if (st == 0) { if (st == 0) {
// parse int success // parse int success
//printf("Content aftr parsing %d %d \n", st, res); //printf_wrap("Content aftr parsing %d %d \n", st, res);
list_set(&evalList, evalList.num_elements, TYPE_INT, &res); list_set(&evalList, evalList.num_elements, TYPE_INT, &res);
} }
if (st != 0) { if (st != 0) {
@ -537,18 +537,18 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
// identify token // identify token
// first try a variable then a func name // first try a variable then a func name
// not a float, check if this is a common function name // not a float, check if this is a common function name
if (EVALUATOR_DEBUG_LEVEL >= 2) printf("now going to identify token '%s' \n", buff); if (EVALUATOR_DEBUG_LEVEL >= 2) printf_wrap("now going to identify token '%s' \n", buff);
if (EVALUATOR_DEBUG_LEVEL >= 2) var_store_print(state->varStore); if (EVALUATOR_DEBUG_LEVEL >= 2) var_store_print(state->varStore);
int varKey = (int) var_store_get_key(state->varStore, buff); int varKey = (int) var_store_get_key(state->varStore, buff);
if (EVALUATOR_DEBUG_LEVEL >= 2) printf("got var key '%d' \n", varKey); if (EVALUATOR_DEBUG_LEVEL >= 2) printf_wrap("got var key '%d' \n", varKey);
if (varKey == -1) { if (varKey == -1) {
// did not find the var name // did not find the var name
short funcID = identify_func_name(buff); short funcID = identify_func_name(buff);
if (funcID == -1) { if (funcID == -1) {
// did not find the func name // did not find the func name
printf("ERR Evaluator: could not identify token \"%s\" \n", buff); printf_wrap("ERR Evaluator: could not identify token \"%s\" \n", buff);
return 200; return 200;
} }
if (funcID >= 0) { if (funcID >= 0) {
@ -559,13 +559,13 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
list_set(&evalList, evalList.num_elements, TYPE_VAR_NAME, &varKey); list_set(&evalList, evalList.num_elements, TYPE_VAR_NAME, &varKey);
} }
} }
if (EVALUATOR_DEBUG_LEVEL >= 2) printf("end of a token identification\n"); if (EVALUATOR_DEBUG_LEVEL >= 2) printf_wrap("end of a token identification\n");
} }
// check the content of this thing // check the content of this thing
if (EVALUATOR_DEBUG_LEVEL >= 2) { if (EVALUATOR_DEBUG_LEVEL >= 2) {
list_print(&evalList); list_print(&evalList);
printf("Now going to actually evaluate...\n"); printf_wrap("Now going to actually evaluate...\n");
} }
while (evalList.num_elements > 1 || !is_type_literal(list_get_type(&evalList, 0))) { while (evalList.num_elements > 1 || !is_type_literal(list_get_type(&evalList, 0))) {
@ -595,9 +595,9 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
if (m == 4) stat = evaluator_reduce_operator_pattern(&evalList); if (m == 4) stat = evaluator_reduce_operator_pattern(&evalList);
if (m == 5) stat = evaluator_reduce_parenthesis_pattern(&evalList); if (m == 5) stat = evaluator_reduce_parenthesis_pattern(&evalList);
if (stat > 0) { if (stat > 0) {
printf("ERR Evaluator: mode %d reducing failed \n", m); printf_wrap("ERR Evaluator: mode %d reducing failed \n", m);
if (EVALUATOR_DEBUG_LEVEL >= 2) { if (EVALUATOR_DEBUG_LEVEL >= 2) {
printf("dumping evalList: \n"); printf_wrap("dumping evalList: \n");
list_print(&evalList); list_print(&evalList);
} }
} }
@ -607,9 +607,9 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
if (!didReduced) { if (!didReduced) {
// all scans failed to find things to reduce // all scans failed to find things to reduce
// this is actually a failure because we can't do anything to get down to 1 element in the eval list // this is actually a failure because we can't do anything to get down to 1 element in the eval list
printf("ERR Evaluator: could not reduce more \n"); printf_wrap("ERR Evaluator: could not reduce more \n");
if (EVALUATOR_DEBUG_LEVEL >= 2) { if (EVALUATOR_DEBUG_LEVEL >= 2) {
printf("dumping evalList: \n"); printf_wrap("dumping evalList: \n");
list_print(&evalList); list_print(&evalList);
} }
return 400; return 400;
@ -620,7 +620,7 @@ int evaluate(struct StateContainer* state, char* inputStr, int* resultPtr, unsig
*typePtr = typeRes; *typePtr = typeRes;
list_get(&evalList, 0, resultPtr); list_get(&evalList, 0, resultPtr);
if (EVALUATOR_DEBUG_LEVEL >= 2) { if (EVALUATOR_DEBUG_LEVEL >= 2) {
printf("End of evaluation, dumping evalList: \n"); printf_wrap("End of evaluation, dumping evalList: \n");
list_print(&evalList); list_print(&evalList);
} }

28
src/funcs.c
View file

@ -92,15 +92,15 @@ int print_number_impl(int* res, unsigned char* resType, unsigned char* types, in
return 1; return 1;
} }
if (G_DEBUG_LEVEL >= 1) { if (G_DEBUG_LEVEL >= 1) {
printf("REAL_PRINT: "); printf_wrap("REAL_PRINT: ");
} }
if (types[0] == TYPE_INT) { if (types[0] == TYPE_INT) {
int val = args[0]; int val = args[0];
printf("%d\n", val); printf_wrap("%d\n", val);
} }
if (types[0] == TYPE_FLOAT) { if (types[0] == TYPE_FLOAT) {
float val = get_float_from_int_rep(args[0]); float val = get_float_from_int_rep(args[0]);
printf("%f\n", val); printf_wrap("%f\n", val);
} }
*res = 1; *res = 1;
return 0; return 0;
@ -122,7 +122,7 @@ int print_ascii_impl(int* res, unsigned char* resType, unsigned char* types, int
charVal = (int) get_float_from_int_rep(args[0]); charVal = (int) get_float_from_int_rep(args[0]);
} }
printf("%c", *((char*) &charVal)); printf_wrap("%c", *((char*) &charVal));
*res = 1; *res = 1;
return 0; return 0;
} }
@ -134,7 +134,7 @@ int print_newline_impl(int* res, unsigned char* resType, unsigned char* types, i
*resType = TYPE_INT; *resType = TYPE_INT;
*res = 1; *res = 1;
printf("\n"); printf_wrap("\n");
return 0; return 0;
} }
@ -143,15 +143,15 @@ int input_number_impl(int* res, unsigned char* resType, unsigned char* types, in
{ {
UNUSED(types); UNUSED(types);
UNUSED(args); UNUSED(args);
printf("? "); printf_wrap("? ");
char* line; char* line;
size_t len = 0; size_t len = 0;
size_t lineSize = 0; size_t lineSize = 0;
lineSize = getline(&line, &len, stdin); lineSize = getline_wrap(&line, &len, stdin);
// printf("len=%d, lineSize=%d '%s' \n", len, lineSize, line); // printf_wrap("len=%d, lineSize=%d '%s' \n", len, lineSize, line);
char toParse[lineSize+1]; char toParse[lineSize+1];
str_extract((char*) toParse, line, 0, lineSize-1); str_extract((char*) toParse, line, 0, lineSize-1);
@ -377,22 +377,22 @@ short identify_func_name(char* candidate)
int execute_func(short funcID, short argsLen, unsigned char* argsTypes, int* argsValues, int* resPtr, unsigned char* resTypePtr) int execute_func(short funcID, short argsLen, unsigned char* argsTypes, int* argsValues, int* resPtr, unsigned char* resTypePtr)
{ {
if (funcID >= nbOfFuncs) { if (funcID >= nbOfFuncs) {
printf("ERR: Invalid func with index: %d \n", funcID); printf_wrap("ERR: Invalid func with index: %d \n", funcID);
return 1; return 1;
} }
int (*impl)(int*, unsigned char*, unsigned char*, int*) = intros[funcID].implementation; int (*impl)(int*, unsigned char*, unsigned char*, int*) = intros[funcID].implementation;
if (impl == 0) { if (impl == 0) {
printf("ERR: No implementation for func with index: %d \n", funcID); printf_wrap("ERR: No implementation for func with index: %d \n", funcID);
return 1; return 1;
} }
char* name = intros[funcID].name; char* name = intros[funcID].name;
if (G_DEBUG_LEVEL >= 2) printf("Executing func '%s' \n", name); if (G_DEBUG_LEVEL >= 2) printf_wrap("Executing func '%s' \n", name);
if (argsLen < intros[funcID].nbArgs) { if (argsLen < intros[funcID].nbArgs) {
printf("ERR: Too few arguments for func call '%s' \n", name); printf_wrap("ERR: Too few arguments for func call '%s' \n", name);
return 1; return 1;
} }
if (argsLen > intros[funcID].nbArgs) { if (argsLen > intros[funcID].nbArgs) {
printf("ERR: Too many arguments for func call '%s' \n", name); printf_wrap("ERR: Too many arguments for func call '%s' \n", name);
return 1; return 1;
} }
@ -400,7 +400,7 @@ int execute_func(short funcID, short argsLen, unsigned char* argsTypes, int* arg
// first cast the function ptr // first cast the function ptr
impl(resPtr, resTypePtr, argsTypes, argsValues); impl(resPtr, resTypePtr, argsTypes, argsValues);
if (G_DEBUG_LEVEL >= 2) printf("Got %s \n", get_repr(*resTypePtr, resPtr)); if (G_DEBUG_LEVEL >= 2) printf_wrap("Got %s \n", get_repr(*resTypePtr, resPtr));
return 0; return 0;
} }

13
src/line_processing.c
View file

@ -326,8 +326,8 @@ int process_line(struct StateContainer* state, char* str)
} }
if (recognize_word(str, SYNTAX_END)) { if (recognize_word(str, SYNTAX_END)) {
byte lastBlockType; int lastBlockType;
int_stack_pop(state->blockStack, (int*) &lastBlockType); // FIXME: use a stack with size byte instead of int int_stack_pop(state->blockStack, &lastBlockType); // FIXME: use a stack with size byte instead of int
if (!state->skipping && lastBlockType == BLOCK_WHILE) { if (!state->skipping && lastBlockType == BLOCK_WHILE) {
int lastLoopLine; int lastLoopLine;
int_stack_pop(state->loopStack, &lastLoopLine); int_stack_pop(state->loopStack, &lastLoopLine);
@ -441,7 +441,7 @@ int process_line(struct StateContainer* state, char* str)
state->linePtr = lastLoopLine; state->linePtr = lastLoopLine;
// find the last while if the block stack and pop blocks up to that point // find the last while if the block stack and pop blocks up to that point
byte lastBlockType; int lastBlockType;
while (lastBlockType != BLOCK_WHILE) { while (lastBlockType != BLOCK_WHILE) {
if (!int_stack_pop(state->blockStack, &lastBlockType)) { if (!int_stack_pop(state->blockStack, &lastBlockType)) {
printf("Syntax error: unexpected continue.\n"); printf("Syntax error: unexpected continue.\n");
@ -588,5 +588,12 @@ int process_script(struct StateContainer* state, char* script)
} }
} }
if (LINE_PROCESSING_DEBUG_LEVEL >= 1) {
// end of run
printf("End of run dumping var_store \n");
var_store_print(state->varStore);
printf("=== end of dump\n");
}
return 1; return 1;
} }

8
src/list.c
View file

@ -185,15 +185,15 @@ int list_append_char(struct List* list, char value)
void list_print(struct List* list) void list_print(struct List* list)
{ {
printf("=== LIST REPORT === \n"); printf_wrap("=== LIST REPORT === \n");
printf("num of elements: %d \n", list->num_elements); printf_wrap("num of elements: %d \n", list->num_elements);
for (int i = 0; i < list->num_elements; i++) { for (int i = 0; i < list->num_elements; i++) {
int type = list_get_type(list, i); int type = list_get_type(list, i);
int data = 0; int data = 0;
list_get(list, i, &data); list_get(list, i, &data);
printf("- i: %d, %s \n", i, get_repr(type, (void*) &data)); printf_wrap("- i: %d, %s \n", i, get_repr(type, (void*) &data));
} }
printf("=== END === \n"); printf_wrap("=== END === \n");
} }

18
src/main.c
View file

@ -5,8 +5,8 @@
#include <signal.h> #include <signal.h>
#include <string.h> #include <string.h>
#include "./config.h" #include "./config.h"
#include "./types.h"
#include "./utils.h" #include "./utils.h"
#include "./types.h"
#include "./stack.h" #include "./stack.h"
#include "./list.h" #include "./list.h"
#include "./number_parsing.h" #include "./number_parsing.h"
@ -31,13 +31,13 @@ int help_mode(char* cmdName) {
" -v --version print version information and exit\n" " -v --version print version information and exit\n"
" -i --interactive force interactive mode\n" " -i --interactive force interactive mode\n"
" -e --stdin-expression evaluate expression from stdin\n"; " -e --stdin-expression evaluate expression from stdin\n";
printf(helpStr, cmdName); printf_wrap(helpStr, cmdName);
return 0; return 0;
} }
int version_mode() { int version_mode() {
char* helpStr = "Langatator 0.0.1\n"; char* helpStr = "Langatator 0.0.1\n";
printf(helpStr); printf_wrap(helpStr);
return 0; return 0;
} }
@ -45,7 +45,7 @@ int interactive_mode() {
struct StateContainer* state = state_init(); struct StateContainer* state = state_init();
while (state->running) { while (state->running) {
printf("? "); printf_wrap("? ");
char* line; char* line;
size_t len = 0; size_t len = 0;
@ -54,7 +54,7 @@ int interactive_mode() {
lineSize = getline(&line, &len, stdin); lineSize = getline(&line, &len, stdin);
if (lineSize == (size_t) -1) { if (lineSize == (size_t) -1) {
// we received some kind of interrupt? // we received some kind of interrupt?
printf("\n"); printf_wrap("\n");
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
@ -64,10 +64,10 @@ int interactive_mode() {
int stat = process_line(state, toEvaluate); int stat = process_line(state, toEvaluate);
if (!stat) { if (!stat) {
printf("Processing that line failed.\n"); printf_wrap("Processing that line failed.\n");
} }
if (state->lastEvaluationType != TYPE_NULL) { if (state->lastEvaluationType != TYPE_NULL) {
printf("%s\n", get_repr(state->lastEvaluationType, &state->lastEvaluationResult)); printf_wrap("%s\n", get_repr(state->lastEvaluationType, &state->lastEvaluationResult));
} }
} }
@ -75,7 +75,7 @@ int interactive_mode() {
} }
int stdin_expression_mode() { int stdin_expression_mode() {
printf("This mode is not implemented yet ¯\\_(ツ)_/¯ \n"); printf_wrap("This mode is not implemented yet ¯\\_(ツ)_/¯ \n");
return 1; return 1;
} }
@ -116,7 +116,7 @@ error:
} }
int file_mode(char* fileName) { int file_mode(char* fileName) {
// printf("Open file mode...\n"); // printf_wrap("Open file mode...\n");
size_t size; size_t size;
char* buff = slurp_file(fileName, &size); char* buff = slurp_file(fileName, &size);

14
src/number_parsing.c
View file

@ -22,7 +22,7 @@ int parse_clean_positive_integer(int inputStrLen, char* inputStr, int* result) {
); );
i++; i++;
} }
//printf("parseclean %d \n", value); //printf_wrap("parseclean %d \n", value);
*result = value; *result = value;
@ -58,13 +58,13 @@ int parse_int(char* inputStr, int* resultPtr) {
i++; i++;
} }
cleanStr[cleanStrLen] = 0; cleanStr[cleanStrLen] = 0;
//printf("clean str: %s/ \n", cleanStr); //printf_wrap("clean str: %s/ \n", cleanStr);
int inter = 0; int inter = 0;
byte stat = parse_clean_positive_integer(cleanStrLen, cleanStr, &inter); byte stat = parse_clean_positive_integer(cleanStrLen, cleanStr, &inter);
if (NB_PARSING_DEBUG_LEVEL >= 2) { if (NB_PARSING_DEBUG_LEVEL >= 2) {
printf("Parse clean positive integer stat: %d\n", stat); printf_wrap("Parse clean positive integer stat: %d\n", stat);
printf("Got value: %d\n", inter); printf_wrap("Got value: %d\n", inter);
} }
*resultPtr = inter; *resultPtr = inter;
@ -76,7 +76,7 @@ int parse_int(char* inputStr, int* resultPtr) {
} }
int parse_float(char* inputStr, float* resultPtr) { int parse_float(char* inputStr, float* resultPtr) {
if (NB_PARSING_DEBUG_LEVEL >= 2) printf("Parsing as float: '%s'\n", inputStr); if (NB_PARSING_DEBUG_LEVEL >= 2) printf_wrap("Parsing as float: '%s'\n", inputStr);
int i = 0; int i = 0;
char cleanStrIntPart[strlen(inputStr)+1]; char cleanStrIntPart[strlen(inputStr)+1];
int cleanStrIntPartLen = 0; int cleanStrIntPartLen = 0;
@ -135,8 +135,8 @@ int parse_float(char* inputStr, float* resultPtr) {
} }
cleanStrIntPart[cleanStrIntPartLen] = 0; cleanStrIntPart[cleanStrIntPartLen] = 0;
cleanStrFloatPart[cleanStrFloatPartLen] = 0; cleanStrFloatPart[cleanStrFloatPartLen] = 0;
// printf("clean str int part: /%s/ \n", cleanStrIntPart); // printf_wrap("clean str int part: /%s/ \n", cleanStrIntPart);
// printf("clean str float part: /%s/ \n", cleanStrFloatPart); // printf_wrap("clean str float part: /%s/ \n", cleanStrFloatPart);
int intPart = 0; int intPart = 0;
parse_clean_positive_integer(cleanStrIntPartLen, cleanStrIntPart, &intPart); parse_clean_positive_integer(cleanStrIntPartLen, cleanStrIntPart, &intPart);

6
src/operate.c
View file

@ -72,7 +72,7 @@ int operate(
a = convert_to_float(typeA, aRepr); a = convert_to_float(typeA, aRepr);
b = convert_to_float(typeB, bRepr); b = convert_to_float(typeB, bRepr);
if (OPERATE_DEBUG_LEVEL) printf("Appling operation: %f %c %f \n", a, operator, b); if (OPERATE_DEBUG_LEVEL) printf_wrap("Appling operation: %f %c %f \n", a, operator, b);
if (operator == '+') { if (operator == '+') {
res = a+b; res = a+b;
@ -95,13 +95,13 @@ int operate(
} else { } else {
return 2; return 2;
} }
if (OPERATE_DEBUG_LEVEL) printf("Got float: %f \n", res); if (OPERATE_DEBUG_LEVEL) printf_wrap("Got float: %f \n", res);
// get int representation of float // get int representation of float
*resPtr = *(int *)(&res); *resPtr = *(int *)(&res);
return 0; return 0;
} }
if (typeA == TYPE_INT && typeB == TYPE_INT) { if (typeA == TYPE_INT && typeB == TYPE_INT) {
if (OPERATE_DEBUG_LEVEL) printf("Appling operation %d %c %d \n", aRepr, operator, bRepr); if (OPERATE_DEBUG_LEVEL) printf_wrap("Appling operation %d %c %d \n", aRepr, operator, bRepr);
*typeRes = TYPE_INT; *typeRes = TYPE_INT;
int res = 0; int res = 0;
if (operator == '+') { if (operator == '+') {

61
src/stack.c
View file

@ -1,3 +1,63 @@
/*
#include "./utils.h"
#include "./stack.h"
#include <stdio.h>
#include <stdlib.h>
struct Stack* int_stack_init(byte unitSize)
{
struct Stack* stack = (struct Stack*) malloc(sizeof(struct Stack));
stack->unitSize = unitSize;
stack->length = 0;
stack->allocated = 8;
stack->data = (int*) malloc(stack->allocated * stack->unitSize);
return stack;
}
byte stack_push(struct Stack* stack, void* valueToPush)
{
if (stack->length == stack->allocated) {
stack->allocated *= 2;
stack->data = realloc(stack->data, stack->allocated * stack->unitSize);
}
memcpy(stack->data[stack->length], valueToPush, stack->unitSize);
stack->length++;
return 1;
}
byte stack_pop(struct Stack* stack, void* valuePtr)
{
if (stack->length == 0) {
// error, nothing to pop
return 0;
}
memcpy(valuePtr, stack->data[stack->length-1], stack->unitSize);
stack->length--;
return 1;
}
int int_stack_length(struct Stack* stack)
{
return stack->length;
}
void int_stack_print(struct Stack* stack)
{
printf_wrap("= STACK REPORT \n");
for (int i = 0; i < stack->length; i++) {
printf_wrap("%d; ", stack->data[i]);
}
printf_wrap("\n");
}
*/
#include "./utils.h" #include "./utils.h"
#include "./stack.h" #include "./stack.h"
#include <stdio.h> #include <stdio.h>
@ -53,3 +113,4 @@ void int_stack_print(struct IntStack* stack)
} }
printf("\n"); printf("\n");
} }

19
src/stack.h
View file

@ -2,6 +2,24 @@
#ifndef STACK_H_ #ifndef STACK_H_
#define STACK_H_ #define STACK_H_
// struct Stack {
// byte unitSize;
// int length;
// int allocated;
// int* data;
// };
// struct Stack* stack_init();
// byte stack_push(struct Stack* stack, void* valueToPush);
// byte stack_pop(struct Stack* stack, void* valuePtr);
// byte stack_get(struct Stack* stack, int index, void* valuePtr);
// int stack_length(struct Stack* stack);
// void stack_print(struct Stack* stack);
struct IntStack { struct IntStack {
int length; int length;
int allocated; int allocated;
@ -18,4 +36,5 @@ int int_stack_length(struct IntStack* stack);
void int_stack_print(struct IntStack* stack); void int_stack_print(struct IntStack* stack);
#endif #endif

15
src/utils.c
View file

@ -2,6 +2,17 @@
#include <string.h> #include <string.h>
#include "./utils.h" #include "./utils.h"
#include <stdarg.h>
#if PRINT_MODE == 0
int printf_wrap(const char* format, ...) {
va_list args;
va_start(args, format);
vprintf(format, args);
va_end( args );
}
#endif
int get_int_rep_from_float(float ft) int get_int_rep_from_float(float ft)
{ {
return *(int *)(&ft); return *(int *)(&ft);
@ -21,7 +32,7 @@ float get_float_from_int_rep(int representation)
int get_int_rep_from_char(char c) int get_int_rep_from_char(char c)
{ {
return *(int *)(&c); return (int) c;
} }
int is_char_numeral(char candidate) int is_char_numeral(char candidate)
@ -217,7 +228,7 @@ int m_newton_method(float (*func)(float, float), float param, float startsAt, fl
return 0; return 0;
} }
if (runs > 100) { if (runs > 100) {
printf("ERR: newton methods failed, coup dur pour newton \n"); printf_wrap("ERR: newton methods failed, coup dur pour newton \n");
return 100; return 100;
} }
cursor = newCursor; cursor = newCursor;

2
src/utils.h
View file

@ -3,6 +3,8 @@
#ifndef UTILS_H_ #ifndef UTILS_H_
#define UTILS_H_ #define UTILS_H_
int printf_wrap(const char* format, ...);
// useful to silent warning of gcc of uunused parameters in functions // useful to silent warning of gcc of uunused parameters in functions
#define UNUSED(x) (void)(x) #define UNUSED(x) (void)(x)

45
src/var_store.c
View file

@ -10,14 +10,14 @@ struct VariableStore* var_store_init()
{ {
struct VariableStore* store = (struct VariableStore*) malloc(sizeof(struct VariableStore)); struct VariableStore* store = (struct VariableStore*) malloc(sizeof(struct VariableStore));
if (store == NULL) { if (store == NULL) {
printf("[ERR] VARSTORE: malloc failed for variable store \n"); printf_wrap("[ERR] VARSTORE: malloc failed for variable store \n");
return NULL; return NULL;
} }
store->allocatedLength = VAR_STORE_INITIAL_ALLOC_LENGTH; store->allocatedLength = VAR_STORE_INITIAL_ALLOC_LENGTH;
store->length = 0; store->length = 0;
store->container = (struct VariableContainer*) malloc(sizeof(struct VariableContainer) * store->allocatedLength); store->container = (struct VariableContainer*) malloc(sizeof(struct VariableContainer) * store->allocatedLength);
if (store->container == NULL) { if (store->container == NULL) {
printf("[ERR] VARSTORE: malloc failed for first variable container \n"); printf_wrap("[ERR] VARSTORE: malloc failed for first variable container \n");
return NULL; return NULL;
} }
for (int i = 0; i < store->allocatedLength; i++) { for (int i = 0; i < store->allocatedLength; i++) {
@ -39,27 +39,29 @@ int var_store_hash_name(struct VariableStore* store, char* varName)
int hash = 0; int hash = 0;
int i = 0; int i = 0;
while (varName[i] != '\0') { while (varName[i] != '\0') {
int num = get_int_rep_from_char(varName[i])*integer_pow(9, i); int num = get_int_rep_from_char(varName[i])|integer_pow(9, i);
hash = abs(hash + abs(num)); hash += num;
i++; i++;
} }
// FIXME: when reallocating, we should copy all variables to their new key // FIXME: when reallocating, we should copy all variables to their new key
// because we use modulus operator, the hash will change whenever we reallocated the table // because we use modulus operator, the hash will change whenever we reallocated the table
return hash % store->allocatedLength; hash = (hash < 0 ? -hash : hash) % store->allocatedLength;
//printf_wrap("Compute a hash for '%s' , allocatd: %d; %d\n", varName, store->allocatedLength, hash);
return hash;
} }
byte var_store_set(struct VariableStore* store, char* varName, byte type, void* valuePtr) byte var_store_set(struct VariableStore* store, char* varName, byte type, void* valuePtr)
{ {
//printf("set variable at var name: '%s' \n", varName); //printf_wrap("set variable at var name: '%s' \n", varName);
if (!(type == TYPE_FLOAT || type == TYPE_INT || type == TYPE_NULL)) { if (!(type == TYPE_FLOAT || type == TYPE_INT || type == TYPE_NULL)) {
printf("[ERR] VARSTORE: unsupported type, cannot store type %d\n", type); printf_wrap("[ERR] VARSTORE: unsupported type, cannot store type %d\n", type);
return 0; return 0;
} }
void* dataPtr; void* dataPtr;
if (type == TYPE_FLOAT || type == TYPE_INT) { if (type == TYPE_FLOAT || type == TYPE_INT) {
dataPtr = malloc(sizeof(int)); dataPtr = malloc(sizeof(int));
if (dataPtr == NULL) { if (dataPtr == NULL) {
printf("[ERR] VARSTORE: malloc failed for data\n"); printf_wrap("[ERR] VARSTORE: malloc failed for data\n");
return 1; return 1;
} }
@ -70,7 +72,7 @@ byte var_store_set(struct VariableStore* store, char* varName, byte type, void*
char* namePtr = (char*) malloc(strlen(varName)); char* namePtr = (char*) malloc(strlen(varName));
if (namePtr == NULL) { if (namePtr == NULL) {
printf("[ERR] VARSTORE: malloc failed for var name\n"); printf_wrap("[ERR] VARSTORE: malloc failed for var name\n");
return 1; return 1;
} }
strcpy(namePtr, varName); strcpy(namePtr, varName);
@ -82,7 +84,7 @@ byte var_store_set(struct VariableStore* store, char* varName, byte type, void*
{ {
if (store->container[key].type == 0) { if (store->container[key].type == 0) {
// we finally found an empty space, but we didn't found a variable with the same name // we finally found an empty space, but we didn't found a variable with the same name
// we have a new variable // so we have a new variable
store->length++; store->length++;
break; break;
} }
@ -93,24 +95,25 @@ byte var_store_set(struct VariableStore* store, char* varName, byte type, void*
key = (key+1) % store->allocatedLength; key = (key+1) % store->allocatedLength;
if (key == originalKey) { if (key == originalKey) {
// end the search to avoid endless loop // end the search to avoid endless loop
printf("[ERR] VARSTORE: cannot set variable, not enough containers \n"); printf_wrap("[ERR] VARSTORE: cannot set variable, not enough containers \n");
return 1; return 1;
} }
} }
//printf("set variable at key: %d \n", key); //printf_wrap("set variable at key: %d \n", key);
store->container[key].type = type; store->container[key].type = type;
store->container[key].namePtr = namePtr; store->container[key].namePtr = namePtr;
store->container[key].dataPtr = dataPtr; store->container[key].dataPtr = dataPtr;
if (2*store->length >= store->allocatedLength) { if (2*store->length >= store->allocatedLength) {
printf_wrap("REALLOCATING THE FUCKING VAR STORE\n");
// do smth to double the store->allocatedLength // do smth to double the store->allocatedLength
// e.g reallocate the store->container // e.g reallocate the store->container
// FIXME: copy all variables to their new keys // FIXME: copy all variables to their new keys
store->allocatedLength = 2*store->allocatedLength; store->allocatedLength = 2*store->allocatedLength;
store->container = (struct VariableContainer*) realloc(store->container, sizeof(struct VariableContainer) * store->allocatedLength); store->container = (struct VariableContainer*) realloc(store->container, sizeof(struct VariableContainer) * store->allocatedLength);
if (store->container == NULL) { if (store->container == NULL) {
printf("[ERR] VARSTORE: relloc failed for container \n"); printf_wrap("[ERR] VARSTORE: relloc failed for container \n");
return 1; return 1;
} }
} }
@ -122,15 +125,15 @@ byte var_store_set(struct VariableStore* store, char* varName, byte type, void*
// return -1 if no pos are found // return -1 if no pos are found
int var_store_get_key(struct VariableStore* store, char* varName) int var_store_get_key(struct VariableStore* store, char* varName)
{ {
//printf("get key for %s \n", varName); //printf_wrap("get key for %s \n", varName);
int originalKey = var_store_hash_name(store, varName); int originalKey = var_store_hash_name(store, varName);
//printf_wrap("got hash for get key: %d\n", originalKey);
int key = originalKey; int key = originalKey;
// handle collision, walk along the array // handle collision, walk along the array
while (1) { while (1) {
//printf("inter key: %d %d \n", key, store->container[key].type); //printf_wrap("inter key: %d %d \n", key, store->container[key].type);
if (store->container[key].type == 0) return -1; if (store->container[key].type == 0) return -1;
// check if we found the position // check if we found the position
if (strcmp(store->container[key].namePtr, varName) == 0) return key; if (strcmp(store->container[key].namePtr, varName) == 0) return key;
@ -165,13 +168,15 @@ byte var_store_copy_from_key(struct VariableStore* store, int key, void* dst)
if (key < 0) { if (key < 0) {
return 1; return 1;
} }
//printf_wrap("Var store: copy from key %d \n", key);
memcpy(dst, store->container[key].dataPtr, (size_t) get_size_of_type(store->container[key].type)); memcpy(dst, store->container[key].dataPtr, (size_t) get_size_of_type(store->container[key].type));
return 0; return 0;
} }
byte var_store_copy(struct VariableStore* store, char* varName, void* dst) byte var_store_copy(struct VariableStore* store, char* varName, void* dst)
{ {
return var_store_copy_from_key(store, var_store_get_key(store, varName), dst); int key = var_store_get_key(store, varName);
return var_store_copy_from_key(store, key, dst);
} }
int var_store_get_int(struct VariableStore* store, char* varName) int var_store_get_int(struct VariableStore* store, char* varName)
@ -196,10 +201,10 @@ float var_store_get_float(struct VariableStore* store, char* varName)
void var_store_print(struct VariableStore* store) void var_store_print(struct VariableStore* store)
{ {
printf("== VarStore report (%d items) ==\n", store->length); printf_wrap("== VarStore report (%d items) ==\n", store->length);
for (int i = 0; i < store->allocatedLength; i++) { for (int i = 0; i < store->allocatedLength; i++) {
if (store->container[i].type != 0) { if (store->container[i].type != 0) {
printf( printf_wrap(
"key: %d, '%s' = %s; ", "key: %d, '%s' = %s; ",
i, i,
store->container[i].namePtr, store->container[i].namePtr,
@ -207,5 +212,5 @@ void var_store_print(struct VariableStore* store)
); );
} }
} }
printf("== end of report\n"); printf_wrap("== end of report\n");
} }

2
src/var_store.h
View file

@ -4,7 +4,7 @@
#define VAR_STORE_H_ #define VAR_STORE_H_
#define VAR_STORE_DEBUG_LEVEL (G_DEBUG_LEVEL) #define VAR_STORE_DEBUG_LEVEL (G_DEBUG_LEVEL)
#define VAR_STORE_INITIAL_ALLOC_LENGTH 32 #define VAR_STORE_INITIAL_ALLOC_LENGTH 64
/** /**

6
tests/test.c
View file

@ -1,3 +1,5 @@
#include "../src/config.h"
#include "../src/utils.h"
#include "./test_utils.h" #include "./test_utils.h"
#include "./test_evaluation.h" #include "./test_evaluation.h"
#include "./test_line_processing.h" #include "./test_line_processing.h"
@ -7,8 +9,10 @@
int main() int main()
{ {
printf("== UNIT TESTS == \n"); int var1 = 0x34;
printf_wrap("== UNIT TESTS == \n");
test_utils(); test_utils();
printf_wrap("ça commence à faire chier jpp\n");
test_var_store(); test_var_store();
test_stack(); test_stack();
test_evaluation(); test_evaluation();

6
tests/test_evaluation.c
View file

@ -9,7 +9,7 @@
void test_evaluation() void test_evaluation()
{ {
printf("== test evaluation == \n"); printf_wrap("== test evaluation == \n");
struct StateContainer* state = state_init(); struct StateContainer* state = state_init();
@ -93,7 +93,7 @@ void test_evaluation()
evaluate(state, "random_int(1, 100)", &resVal, &resType); evaluate(state, "random_int(1, 100)", &resVal, &resType);
assert(resType == TYPE_INT); assert(resType == TYPE_INT);
printf(" - random int: %d \n", resVal); printf_wrap(" - random int: %d \n", resVal);
evaluate(state, "abs(2)+abs(-2)", &resVal, &resType); evaluate(state, "abs(2)+abs(-2)", &resVal, &resType);
assert(resType == TYPE_INT); assert(resType == TYPE_INT);
@ -201,7 +201,7 @@ void test_evaluation()
evaluate(state, "abs((var2^2)-((var-41)^2))+2", &resVal, &resType); evaluate(state, "abs((var2^2)-((var-41)^2))+2", &resVal, &resType);
assert(resType == TYPE_INT); assert(resType == TYPE_INT);
printf("actually got: %d \n", resVal); printf_wrap("actually got: %d \n", resVal);
assert(7 == resVal); assert(7 == resVal);
/* TYPE FUNCS */ /* TYPE FUNCS */

8
tests/test_line_processing.c
View file

@ -11,7 +11,7 @@
void test_line_processing() void test_line_processing()
{ {
printf("== test line processing == \n"); printf_wrap("== test line processing == \n");
// test string manipulation // test string manipulation
assert(!recognize_word("", "hello")); assert(!recognize_word("", "hello"));
@ -49,7 +49,7 @@ void test_line_processing()
assert(process_line(state1, "#")); assert(process_line(state1, "#"));
assert(process_line(state1, "# some random comment")); assert(process_line(state1, "# some random comment"));
assert(process_line(state1, "set VAR_A to 8.5")); assert(process_line(state1, "set VAR_A to 8.5"));
printf("%d \n", var_store_get_int(state1->varStore, "VAR_A")); printf_wrap("%d \n", var_store_get_int(state1->varStore, "VAR_A"));
assert(float_almost_equal(8.5, var_store_get_float(state1->varStore, "VAR_A"))); assert(float_almost_equal(8.5, var_store_get_float(state1->varStore, "VAR_A")));
assert(process_line(state1, "set VAR_B to 1.5")); assert(process_line(state1, "set VAR_B to 1.5"));
@ -113,7 +113,7 @@ void test_line_processing()
process_script(state2, lines4); process_script(state2, lines4);
assert(!state2->skipping); assert(!state2->skipping);
printf("got i: %d \n", var_store_get_int(state2->varStore, "i")); printf_wrap("got i: %d \n", var_store_get_int(state2->varStore, "i"));
assert(9 == var_store_get_int(state2->varStore, "i")); assert(9 == var_store_get_int(state2->varStore, "i"));
// test break keyword // test break keyword
@ -127,7 +127,7 @@ void test_line_processing()
process_script(state2, lines5); process_script(state2, lines5);
assert(!state2->skipping); assert(!state2->skipping);
printf("got i: %d \n", var_store_get_int(state2->varStore, "i")); printf_wrap("got i: %d \n", var_store_get_int(state2->varStore, "i"));
assert(10 == var_store_get_int(state2->varStore, "i")); assert(10 == var_store_get_int(state2->varStore, "i"));
// test continue keyword // test continue keyword

4
tests/test_stack.c
View file

@ -6,7 +6,7 @@
void test_stack() void test_stack()
{ {
printf("== test stack == \n"); printf_wrap("== test stack == \n");
int res; int res;
struct IntStack* stack1 = int_stack_init(); struct IntStack* stack1 = int_stack_init();
@ -28,7 +28,7 @@ void test_stack()
assert(int_stack_push(stack1, 2025)); assert(int_stack_push(stack1, 2025));
assert(int_stack_push(stack1, 2026)); assert(int_stack_push(stack1, 2026));
assert(16 == stack1->allocated); assert(16 == stack1->allocated);
printf("%d \n", int_stack_length(stack1)); printf_wrap("%d \n", int_stack_length(stack1));
assert(9 == int_stack_length(stack1)); assert(9 == int_stack_length(stack1));
int_stack_print(stack1); int_stack_print(stack1);

2
tests/test_utils.c
View file

@ -6,7 +6,7 @@
void test_utils() void test_utils()
{ {
printf("== test utils == \n"); printf_wrap("== test utils == \n");
// test int parsing // test int parsing
char test1[] = "151087"; char test1[] = "151087";

32
tests/test_var_store.c
View file

@ -5,10 +5,40 @@
void test_var_store() void test_var_store()
{ {
printf("== test var store == \n"); printf_wrap("== test var store == \n");
struct VariableStore* store = var_store_init(); struct VariableStore* store = var_store_init();
// hash function test
int hash1, hash2, hash3 = 0;
hash1 = var_store_hash_name(store, "a");
hash2 = var_store_hash_name(store, "a");
hash3 = var_store_hash_name(store, "a");
assert(hash1 == hash2);
assert(hash2 == hash3);
assert(hash1 == hash3);
hash1 = var_store_hash_name(store, "i");
hash2 = var_store_hash_name(store, "i");
hash3 = var_store_hash_name(store, "i");
assert(hash1 == hash2);
assert(hash2 == hash3);
assert(hash1 == hash3);
var_store_print(store);
int originalLength = store->length;
int varEx = 42;
int originalHash = var_store_hash_name(store, "i");
var_store_set(store, "i", TYPE_INT, &varEx);
assert(originalHash == var_store_hash_name(store, "i"));
assert(TYPE_INT == var_store_get_type(store, "i"));
assert(originalLength+1 == store->length);
assert(42 == var_store_get_int(store, "i"));
// sequential assignement
int iDest = 0; int iDest = 0;
for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
var_store_set(store, "i", TYPE_INT, &i); var_store_set(store, "i", TYPE_INT, &i);

1
wasm.sh Normal file
View file

@ -0,0 +1 @@
clang -Os -fno-builtin -Wall -Wextra -Wswitch-enum --target=wasm32 --no-standard-libraries -Wl,--export=wasm_info -Wl,--no-entry -Wl,--allow-undefined -o wasm/langatator.wasm ./wasm/wasm.c

2
wasm/config_env_wasm.h Normal file
View file

@ -0,0 +1,2 @@
// the config file for wasm
#define PRINT_MODE 1

81
wasm/emscripten.c Normal file
View file

@ -0,0 +1,81 @@
#include "emscripten.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
EM_JS(void, log_to_js, (char* buff, size_t len), {
log_intake(buff, len);
});
int printf_wrap(const char* format, ...) {
va_list args;
va_start(args, format);
char* out;
vsprintf(out, format, args);
char* sharedPos = (char*) malloc(strlen(out) * sizeof(char));
strcpy(sharedPos, out);
log_to_js((void*) sharedPos, strlen(out));
va_end(args);
return 1;
}
#include "../src/config.h"
#include "../src/utils.h"
#include "../src/types.h"
#include "../src/state.h"
#include "../src/line_processing.h"
struct Result {
byte type;
int data;
};
EMSCRIPTEN_KEEPALIVE
void* wasm_init_state()
{
struct StateContainer* ptr = state_init();
return (void*) ptr;
}
EMSCRIPTEN_KEEPALIVE
void* wasm_process_line(void* state, char* line)
{
struct Result* res = malloc(sizeof(struct Result));
process_line(state, line);
res->type = ((struct StateContainer*) state)->lastEvaluationType;
res->data = ((struct StateContainer*) state)->lastEvaluationResult;
return (void*) res;
}
EMSCRIPTEN_KEEPALIVE
void wasm_process_script(char* scriptLines)
{
printf_wrap("Will process script \"%s\" \n", scriptLines);
struct StateContainer* state = state_init();
process_script(state, scriptLines);
}
// very dangerous indeed
EMSCRIPTEN_KEEPALIVE
int wasm_get_type_from_ref(void* ref) {
return ((struct Result*) ref)->type;
}
EMSCRIPTEN_KEEPALIVE
int wasm_get_int_from_ref(void* ref) {
return ((struct Result*) ref)->data;
}
// EMSCRIPTEN_KEEPALIVE
// int wasm_info(char* lines)
// {
// struct StateContainer* state = state_init();
// process_script(state, lines);
// return state->lastEvaluationResult;
// }

1
wasm/emscripten_raw.html Normal file
View file

File diff suppressed because one or more lines are too long

1
wasm/emscripten_raw.js Normal file
View file

File diff suppressed because one or more lines are too long

BIN
wasm/emscripten_raw.wasm Executable file
View file

Binary file not shown.

69
wasm/index.html Normal file
View file

@ -0,0 +1,69 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Langatator demo</title>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/normalize/7.0.0/normalize.min.css">
<style>
* {
box-sizing: border-box;
}
.container {
width: 90%;
margin: 0 auto;
}
.form {
width: 100%;
margin-top: 1em;
}
#script-input {
width: 100%;
min-width: 100%;
max-width: 100%;
display: block;
min-height: 20em;
}
.submit-btn {
margin-top: 1em;
}
</style>
</head>
<body>
<div class="container">
<h1>Langatator demo</h1>
<a href="https://gitlab.com/lefuturiste/langatator">The git repository</a>
<div class="form">
<textarea id="script-input"></textarea>
<button
class="submit-btn"
onclick="submitScript()"
>
Process script!
</button>
</div>
<div class="console">
<pre id="console-output">
</pre>
</div>
</div>
<script>
// const oldLog = console.log;
// console.log = function (message) {
// oldLog.apply(console, ['captured', ...arguments]);
// };
</script>
<script src="./langatator_adapter.js"></script>
<script src="./script.js"></script>
</body>
</html>

1
wasm/langatator_adapter.js Normal file
View file

File diff suppressed because one or more lines are too long

BIN
wasm/langatator_adapter.wasm Executable file
View file

Binary file not shown.

93
wasm/script.js Normal file
View file

@ -0,0 +1,93 @@
'use strict';
// let app = document.getElementById("app");
// let wasm = null;
// let iota = 0;
// function cstrlen(mem, ptr) {
// let len = 0;
// while (mem[ptr] != 0) {
// len++;
// ptr++;
// }
// return len;
// }
// function cstr_by_ptr(mem_buffer, ptr) {
// const mem = new Uint8Array(mem_buffer);
// const len = cstrlen(mem, ptr);
// const bytes = new Uint8Array(mem_buffer, ptr, len);
// return new TextDecoder().decode(bytes);
// }
// function platform_panic(file_path_ptr, line, message_ptr) {
// const buffer = wasm.instance.exports.memory.buffer;
// const file_path = cstr_by_ptr(buffer, file_path_ptr);
// const message = cstr_by_ptr(buffer, message_ptr);
// console.error(file_path+":"+line+": "+message);
// }
// function platform_log(message_ptr) {
// const buffer = wasm.instance.exports.memory.buffer;
// const message = cstr_by_ptr(buffer, message_ptr);
// console.log(message);
// }
// WebAssembly.instantiateStreaming(fetch('langatator.wasm'), {
// env: {
// platform_panic,
// platform_log
// }
// }).then((w) => {
// wasm = w;
// console.log(wasm.instance.exports.wasm_info());
// //const buffer = wasm.instance.exports.memory.buffer;
// });
const consoleOutput = document.getElementById('console-output')
function log_intake(ptr, len) {
let line = ""
for (var i = 0; i < len; i++) {
let val = Module.getValue(ptr+i, 'i8')
line = line + String.fromCharCode(val)
}
console.log('Got line', line)
// const pre= document.createElement('pre')
// consoleOutput.appendChild(pre)
}
Module.onRuntimeInitialized = async _ => {
const api = {
init: Module.cwrap('wasm_init_state', 'number', []),
processLine: Module.cwrap('wasm_process_line', 'number', ['number', 'string']),
getTypeFromRef: Module.cwrap('wasm_get_type_from_ref', 'number', ['number']),
getIntFromRef: Module.cwrap('wasm_get_int_from_ref', 'number', ['number']),
// standalone (integrated state initialization)
processScript: Module.cwrap('wasm_process_script', 'number', ['string']),
};
console.log(api);
// const ref = api.init();
// console.log(`Got ref: ${ref}`);
window.processLine = (line) => {
const resultRef = api.processLine(ref, line);
console.log(`Got result ref: ${resultRef}`);
console.log(api.getTypeFromRef(resultRef));
console.log(api.getIntFromRef(resultRef));
}
window.submitScript = () => {
const textarea = document.getElementById('script-input')
api.processScript(textarea.value)
}
};

0
wasm/style.css Normal file
View file

44
wasm/wasm.c Normal file
View file

@ -0,0 +1,44 @@
#include <stdlib.h>
#include "../src/config.h"
#define CONFIG_PRINT_METHOD PRINT_METHOD_WASM
#include "../src/utils.h"
#include "../src/types.h"
#include "../src/state.h"
#include "../src/line_processing.h"
void* wasm_init_state()
{
struct StateContainer* ptr = state_init();
return (void*) ptr;
}
void* wasm_process_line(void* state, char* line)
{
struct Result* res = malloc(sizeof(struct Result));
process_line(state, line);
res->type = ((struct StateContainer*) state)->lastEvaluationType;
res->data = ((struct StateContainer*) state)->lastEvaluationResult;
return (void*) res;
}
// very dangerous indeed
int wasm_get_type_from_ref(void* ref) {
return ((struct Result*) ref)->type;
}
int wasm_get_int_from_ref(void* ref) {
return ((struct Result*) ref)->data;
}
// EMSCRIPTEN_KEEPALIVE
// int wasm_info(char* lines)
// {
// struct StateContainer* state = state_init();
// process_script(state, lines);
// return state->lastEvaluationResult;
// }