first commit
This commit is contained in:
Kizarm
parent
50d0a2c3c9
commit
c8d704a06c
18 changed files with 871 additions and 0 deletions
9
.gitignore
vendored
Normal file
9
.gitignore
vendored
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
# kdevelop
|
||||
.kde*
|
||||
*.kdev4
|
||||
# other
|
||||
*.zip
|
||||
*.wasm
|
||||
*.lst
|
||||
*.map
|
||||
*.o
|
||||
33
Makefile
Normal file
33
Makefile
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
CC = clang
|
||||
CX = clang++
|
||||
CODE ?= wasm
|
||||
|
||||
MOBJS = calc.yy.o calc.tab.o calculator.o
|
||||
|
||||
ifeq ($(CODE),wasm)
|
||||
include wasm.mk
|
||||
else
|
||||
include unix.mk
|
||||
endif
|
||||
|
||||
OBJS = $(MOBJS) $(MAIN)
|
||||
CFLAGS += -Wno-unused-function
|
||||
|
||||
all: $(PR)
|
||||
%.o: %.cpp
|
||||
$(CX) -std=c++14 -c $(CFLAGS) -fno-exceptions -fno-rtti $< -o $@
|
||||
%.o: %.c
|
||||
$(CC) -c $(CFLAGS) $< -o $@
|
||||
calc.tab.o: calc.tab.c
|
||||
$(CX) -std=c++14 -c $(CFLAGS) -Wno-deprecated -Wno-writable-strings -fno-exceptions -fno-rtti $< -o $@
|
||||
$(PR): $(OBJS) $(WALIB)
|
||||
$(LD) $(LFLAGS) $(OBJS) -o $(PR) $(LDLIBS)
|
||||
calc.yy.cpp: calc.l calc.tab.h
|
||||
flex calc.l
|
||||
calc.tab.c calc.tab.h: calc.y
|
||||
bison -d calc.y
|
||||
clean:
|
||||
rm -f *.o *.yy.* *.tab.*
|
||||
distclean: clean
|
||||
rm -f $(PR)
|
||||
.PHONY: all clean distclean
|
||||
46
bin/index.html
Normal file
46
bin/index.html
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
<!doctype html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8" http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
||||
<title>CALC</title>
|
||||
<style>
|
||||
tr, td { border-collapse: collapse; }
|
||||
table { width:100%; border-collapse: collapse; text-align: center; }
|
||||
.emscripten { padding-right: 0; margin-left: auto; margin-right: auto; display: block; }
|
||||
textarea.emscripten { font-family: monospace; font-size: 16px; width: 100%; overflow-x: scroll; white-space: pre; background: black; color: rgb(0,255,0);}
|
||||
.frame1 { width: 96%; margin: 0; padding: 10px; background-color: #FFFFC0; border: 10px solid #F0C0F0; }
|
||||
.canvas { width: 100%; height: 65vh; background-color: black; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<script type="module" src="index.js"></script>
|
||||
<div class="frame1"><canvas id="canvas" class="canvas"></canvas></div>
|
||||
<div class="frame1"><input id="buttonTest" type="button" value="Submit"></div>
|
||||
<div class="frame1">
|
||||
<table><tr>
|
||||
<td width="40%"><textarea class="emscripten" id="input" rows="10" spellcheck="false"></textarea></td>
|
||||
<td><textarea readonly class="emscripten" id="stdout" rows="10" spellcheck="false"></textarea></td>
|
||||
</tr></table>
|
||||
</div>
|
||||
<div class="frame1">
|
||||
<h2>Kalkulátor s grafickým výstupem.</h2>
|
||||
<p>Když jsem přepisoval z nudy syntax highlighter pro C++ z pythonu do C++, zjistil jsem, že regulární výrazy
|
||||
jsou kupodivu v tom pythonu efektivnější. V tomto ohledu je STL knihovna asi dost naprd. Ale vzpomněl jsem si
|
||||
na prastarý pár flex a bison, který umí nejen regulární výrazy, ale jde s tím parsovat dost jednoduše gramatika.
|
||||
Mělo by to jít i v C++, ale příklady na webu byly dost zamotané a bylo nutné použít STL, kterou jsem pro tento
|
||||
účel neměl k dispozici. Vyřešilo se to jednoduše - vygenerovaný C-čkový kód se přeloží jako C++, přičemž je
|
||||
nutné povypínat něktetré warningy.
|
||||
</p>
|
||||
<p>Je to tedy jednoduchý kalkulátor, jde napsat výraz s normální notací (+-*/^), obsahující čísla (i desetinná),
|
||||
který to normálně vyhodnotí. Postupně přibyly proměnné (jen písmenkové řetězce), které mohou mít i rozsah ve
|
||||
kterém se pak výraz zobrazí jako funkce. Komentáře jsou ve složených závorkách. Vložené matematické funkce
|
||||
jsou sin(), cos(), exp(), log() (přirozené).<b>Na konci výrazu musí být ENTER.</b>
|
||||
</p>
|
||||
<p>Jsou v tom chyby, celé je to vlasně hloupost, celé by to šlo napsat v javascriptu mnohem jednodušeji,
|
||||
ale v podstatě to funguje a jde si podle toho udělat představu, jak daná funkce vypadá. Zdrojáky v licenci
|
||||
MIT <a href="flex.zip">přikládám</a>. Pro kompilaci je použit jen clang a jím kompilovaná C-čková knihovna
|
||||
<a href="https://sourceware.org/newlib/" target="_blank">newlib</a>.
|
||||
</p>
|
||||
</div>
|
||||
</body>
|
||||
</html>
|
||||
126
bin/index.js
Normal file
126
bin/index.js
Normal file
|
|
@ -0,0 +1,126 @@
|
|||
var gWASM; // globální proměnná + elementy stránky
|
||||
const Outs = document.getElementById('stdout');
|
||||
const Btnt = document.getElementById('buttonTest');
|
||||
const Canvas = document.getElementById('canvas');
|
||||
// async/await z příkladu na webu
|
||||
window.onload = async function() {
|
||||
Btnt.disabled = true;
|
||||
Outs.value = 'Compiling ...¨\n'; // presets
|
||||
// Build WebAssembly instance - WebAssembly.instantiateStreaming problem
|
||||
const memory = new WebAssembly.Memory({ initial: 4 });
|
||||
const importObject = {
|
||||
env: { memory }, // nutné pro práci a pamětí
|
||||
imports: { // importované funkce do wasm
|
||||
printout : (ptr, len) => {
|
||||
// pohled do paměti - ptr je vlastně číslo
|
||||
const view = new Uint8Array (memory.buffer, ptr, len);
|
||||
const utf8decoder = new TextDecoder();
|
||||
Outs.value += utf8decoder.decode(view); // to String
|
||||
},
|
||||
memoryGrow : (len) => {
|
||||
console.log ('Growing the memory by ' + len.toString() + '. 64K blocks');
|
||||
memory.grow (len); // patrně to jde volat přímo z C/C++ kódu, ale tohle funguje
|
||||
},
|
||||
drawPoints : (px, py, len, pj, jl) => {
|
||||
const xview = new Float32Array (memory.buffer, px, len);
|
||||
const yview = new Float32Array (memory.buffer, py, len);
|
||||
const view = new Uint8Array (memory.buffer, pj, jl);
|
||||
const utf8decoder = new TextDecoder();
|
||||
const obj = JSON.parse (utf8decoder.decode(view));
|
||||
// console.log (obj);
|
||||
if (!obj) obj = '{"name":"nothing"}';
|
||||
polyLine (xview, yview, len, obj);
|
||||
},
|
||||
},
|
||||
};
|
||||
const response = await fetch('./module.wasm');
|
||||
const bytes = await response.arrayBuffer();
|
||||
const module = await WebAssembly.instantiate(bytes, importObject);
|
||||
gWASM = {
|
||||
asm : module.instance.exports,
|
||||
mem : memory,
|
||||
};
|
||||
gWASM.asm.init(memory.buffer.byteLength);
|
||||
Btnt.onclick = () => {
|
||||
Outs.value = '';
|
||||
const expression = document.getElementById('input').value;
|
||||
// console.log(expression);
|
||||
stringToModule (expression, gWASM.asm.compute);
|
||||
};
|
||||
Outs.value = 'Module compiled - [insert formula and] press button Submit\n';
|
||||
Btnt.disabled = false;
|
||||
// console.log (gWASM);
|
||||
window.addEventListener('resize', resizeCanvas, false);
|
||||
resizeCanvas();
|
||||
getFile ('test.txt');
|
||||
Splash ();
|
||||
};
|
||||
function stringToModule (str, mfunc) {
|
||||
const utf8EncodeText = new TextEncoder();
|
||||
const bytes = utf8EncodeText.encode(str);
|
||||
// alokovat pamet v modulu je nutne, aby bylo kam kopirovat
|
||||
const cArrayPointer = gWASM.asm.cAlloc(bytes.length);
|
||||
if (!cArrayPointer) return;
|
||||
const cArray = new Uint8Array(gWASM.mem.buffer, cArrayPointer, bytes.length);
|
||||
cArray.set(bytes); // naplnit dekodovanym stringem
|
||||
mfunc (cArrayPointer, cArray.length);
|
||||
}
|
||||
function resizeCanvas () {
|
||||
const width = canvas.clientWidth;
|
||||
const height = canvas.clientHeight;
|
||||
canvas.width = width;
|
||||
canvas.height = height;
|
||||
// console.log (width, height);
|
||||
gWASM.asm.resizeCanvas (width, height);
|
||||
}
|
||||
function drawLine (ctx, line, x, y) {
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(line.b[0], line.b[1]);
|
||||
ctx.lineTo(line.e[0], line.e[1]);
|
||||
ctx.lineWidth = line.w;
|
||||
ctx.strokeStyle = line.color;
|
||||
if (line.lbl) {
|
||||
//console.log (line.lbl);
|
||||
ctx.fillStyle = line.color;
|
||||
ctx.fillText (line.lbl, line.b[0] + x, line.b[1] - y);
|
||||
}
|
||||
ctx.stroke();
|
||||
}
|
||||
function polyLine (ax, ay, len, obj) {
|
||||
// console.log (ax, ay);
|
||||
const ctx = canvas.getContext("2d");
|
||||
ctx.clearRect(0, 0, canvas.width, canvas.height);
|
||||
ctx.font = '16px serif';
|
||||
ctx.textAlign = 'left';
|
||||
if (obj.name === "axes") {
|
||||
drawLine (ctx, obj.x, 0, 0);
|
||||
drawLine (ctx, obj.y, 0, 0);
|
||||
const ndotsx = obj.xdots.length;
|
||||
for (let n=0; n<ndotsx; n++) { drawLine (ctx, obj.xdots[n], 0, 5); }
|
||||
const ndotsy = obj.ydots.length;
|
||||
for (let n=0; n<ndotsy; n++) { drawLine (ctx, obj.ydots[n], 10, 0); }
|
||||
}
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(ax[0], ay[0]);
|
||||
for (let n=1; n<len; n++) {
|
||||
ctx.lineTo(ax[n], ay[n]);
|
||||
}
|
||||
ctx.lineWidth = 3;
|
||||
ctx.strokeStyle = "#00ff00";
|
||||
ctx.stroke();
|
||||
}
|
||||
async function getFile (name) {
|
||||
const response = await fetch (name);
|
||||
if (!response.ok) return;
|
||||
const bytes = await response.arrayBuffer();
|
||||
const array = new Uint8Array(bytes);
|
||||
const decoder = new TextDecoder();
|
||||
document.getElementById('input').value = decoder.decode(bytes);
|
||||
}
|
||||
function Splash () {
|
||||
const content = Canvas.getContext('2d');
|
||||
content.font = '96px serif';
|
||||
content.fillStyle = '#00FF00';
|
||||
content.textAlign = 'center';
|
||||
content.fillText ('Graphic calculator', Canvas.width / 2, Canvas.height / 2);
|
||||
}
|
||||
7
bin/test.txt
Normal file
7
bin/test.txt
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
{vlnový balík}
|
||||
max=10
|
||||
x=-max,max,1000
|
||||
a=1/4
|
||||
omega=2*pi
|
||||
phi=omega/4
|
||||
1.e-8 * sin (omega*x - phi) * exp (-(x*a)^2)
|
||||
31
calc.l
Normal file
31
calc.l
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
%{
|
||||
#include <stdlib.h>
|
||||
#include "calc.tab.h"
|
||||
#include "calculator.h"
|
||||
%}
|
||||
%option outfile="calc.yy.cpp" header-file="calc.yy.h"
|
||||
%option case-sensitive
|
||||
%option array
|
||||
|
||||
D [0-9]
|
||||
E [Ee][+-]?{D}+
|
||||
|
||||
%%
|
||||
pi { return MATHPI; }
|
||||
sin { return FCESIN; }
|
||||
cos { return FCECOS; }
|
||||
exp { return FCEEXP; }
|
||||
log { return FCELOG; }
|
||||
[a-zA-Z]+ { yylval.svalue = strdup (yytext); return IDENT; }
|
||||
{D}+ { yylval.svalue = strdup (yytext); return INTEGER; }
|
||||
{D}*\.{D}+({E})? { yylval.svalue = strdup (yytext); return DOUBLE; }
|
||||
{D}*\.{D}*({E})? { yylval.svalue = strdup (yytext); return DOUBLE; }
|
||||
\{.*\}
|
||||
[ \t]+ /* ignored */
|
||||
\n { return ENDLINE; }
|
||||
. { return yytext[0]; }
|
||||
%%
|
||||
void prevent_unused (void) {
|
||||
(void) yyunput;
|
||||
/* (void) input; */
|
||||
}
|
||||
68
calc.y
Normal file
68
calc.y
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
%{
|
||||
#include <stdio.h>
|
||||
#include "calculator.h"
|
||||
int yylex (void);
|
||||
int yyerror (char *);
|
||||
%}
|
||||
%language "C"
|
||||
%union {
|
||||
char * svalue;
|
||||
double dvalue;
|
||||
class Expression * evalue;
|
||||
}
|
||||
|
||||
%token ENDLINE
|
||||
%token DOUBLE
|
||||
%token INTEGER
|
||||
%token MATHPI
|
||||
%token FCESIN
|
||||
%token FCECOS
|
||||
%token FCEEXP
|
||||
%token FCELOG
|
||||
%token IDENT
|
||||
%token TEXT
|
||||
%left '+' '-'
|
||||
%left '*' '/'
|
||||
%left '^'
|
||||
|
||||
%type <svalue> ENDLINE DOUBLE INTEGER IDENT line lines
|
||||
%type <evalue> expr
|
||||
%type <dvalue> constnt
|
||||
%start input
|
||||
%%
|
||||
|
||||
input: /* empty */
|
||||
| lines
|
||||
;
|
||||
lines: line
|
||||
| lines line
|
||||
;
|
||||
line: ENDLINE
|
||||
| IDENT '=' expr ENDLINE { addVariable ($1, $3->eval()); free ($1); }
|
||||
| IDENT '=' expr ',' expr ',' expr ENDLINE { addRange ($1, $3->eval(), $5->eval(), $7->eval()); free ($1); }
|
||||
| expr ENDLINE { addExpression ($1); }
|
||||
| error ENDLINE { printf ("what:%s\n", $$); }
|
||||
;
|
||||
constnt: DOUBLE { $$ = str_to_double ($1); free ($1); }
|
||||
| INTEGER { $$ = str_to_long ($1); free ($1); }
|
||||
| MATHPI { $$ = 3.14159265359; }
|
||||
;
|
||||
expr: constnt { $$ = new Constant ($1); }
|
||||
| IDENT { $$ = new Variable ($1); free ($1); }
|
||||
| '-' expr { $$ = new Unary ($2, UNARY_MINUS); }
|
||||
| expr '+' expr { $$ = new Binary ($1, $3, BINARY_PLUS); }
|
||||
| expr '-' expr { $$ = new Binary ($1, $3, BINARY_MINUS);}
|
||||
| expr '*' expr { $$ = new Binary ($1, $3, BINARY_MULT); }
|
||||
| expr '/' expr { $$ = new Binary ($1, $3, BINARY_DIV); }
|
||||
| expr '^' expr { $$ = new Binary ($1, $3, BINARY_POW); }
|
||||
| '(' expr ')' { $$ = $2; }
|
||||
| FCESIN '(' expr ')' { $$ = new Unary ($3, UNARY_SIN); }
|
||||
| FCECOS '(' expr ')' { $$ = new Unary ($3, UNARY_COS); }
|
||||
| FCEEXP '(' expr ')' { $$ = new Unary ($3, UNARY_EXP); }
|
||||
| FCELOG '(' expr ')' { $$ = new Unary ($3, UNARY_LOG); }
|
||||
;
|
||||
%%
|
||||
int yyerror(char * err) {
|
||||
printf("Error:\"%s\"\n", err);
|
||||
return 0;
|
||||
}
|
||||
82
calculator.cpp
Normal file
82
calculator.cpp
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "calculator.h"
|
||||
|
||||
double str_to_double (const char * str) {
|
||||
return strtod (str, NULL);
|
||||
}
|
||||
long str_to_long (const char * str) {
|
||||
return strtol (str, NULL, 10);
|
||||
}
|
||||
|
||||
static double u_minus (const double x) { return -x; }
|
||||
const unary_function unary_function_table [UNARY_max] = {
|
||||
u_minus,
|
||||
sin, cos, exp, log,
|
||||
};
|
||||
static double b_plus (const double a, const double b) { return a + b; }
|
||||
static double b_minus (const double a, const double b) { return a - b; }
|
||||
static double b_multiply (const double a, const double b) { return a * b; }
|
||||
static double b_divide (const double a, const double b) { return b !=0.0 ? a / b : 1.0; }
|
||||
const binary_function binary_function_table [BINARY_max] = {
|
||||
b_plus, b_minus, b_multiply, b_divide, pow,
|
||||
};
|
||||
static CommonData * main_data = nullptr;
|
||||
void addVariable (const char * str, const double x) {
|
||||
printf ("\"%s\"\t= %g\n", str, x);
|
||||
if (main_data->list == nullptr) {
|
||||
main_data->list = new VariableList (str, x);
|
||||
return;
|
||||
}
|
||||
main_data->list->add(str, x);
|
||||
}
|
||||
void addRange (const char * str, const double x, const double e, const double s) {
|
||||
printf ("\"%s\"\t= [%g:%g],%g\n", str, x, e, s);
|
||||
if (main_data->list == nullptr) {
|
||||
main_data->list = new VariableList (str, x, e, s);
|
||||
return;
|
||||
}
|
||||
main_data->list->add(str, x, e, s);
|
||||
}
|
||||
static Range zero = {0.0, 0.0, 0.0};
|
||||
Variable::Variable(const char * name) {
|
||||
data = main_data->list->find (name);
|
||||
if (!data) {
|
||||
printf("variable \"%s\" not assigned, zero used\n", name);
|
||||
data = & zero;
|
||||
}
|
||||
}
|
||||
extern void emitData (double * x, double * y, const int len);
|
||||
void addExpression (Expression * e) {
|
||||
if (main_data->root) delete main_data->root;
|
||||
main_data->root = e;
|
||||
|
||||
VariableList * vl = main_data->list->find_ranged();
|
||||
if (!vl) {
|
||||
printf("f() = %g\n", e->eval());
|
||||
return;
|
||||
}
|
||||
Range * r = vl->get();
|
||||
const double x0 = r->value, x1 = r->end, s = fabs (r->step);
|
||||
int n = (x1 - x0) / s;
|
||||
if (n <= 0) return;
|
||||
double * vx = new double [n + 1];
|
||||
double * vy = new double [n + 1];
|
||||
// printf("n=%d\n", n);
|
||||
for (int i=0; i<n+1; i++) {
|
||||
const double x = x0 + (double) i * s;
|
||||
r->value = x;
|
||||
const double y = e->eval();
|
||||
vx[i] = x; vy[i] = y;
|
||||
}
|
||||
emitData (vx, vy, n+1);
|
||||
delete [] vx; delete [] vy;
|
||||
}
|
||||
void initData () {
|
||||
main_data = new CommonData();
|
||||
}
|
||||
void finiData () {
|
||||
delete main_data;
|
||||
}
|
||||
|
||||
121
calculator.h
Normal file
121
calculator.h
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
/* inclusion guard */
|
||||
#ifndef __CALCULATOR_H__
|
||||
#define __CALCULATOR_H__
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
extern double str_to_double (const char * str);
|
||||
extern long str_to_long (const char * str);
|
||||
extern void addVariable (const char * str, const double x);
|
||||
extern void addRange (const char * str, const double x, const double e, const double s);
|
||||
|
||||
extern void initData ();
|
||||
extern void finiData ();
|
||||
|
||||
class Expression {
|
||||
public:
|
||||
virtual double eval () = 0;
|
||||
virtual ~Expression () {}
|
||||
};
|
||||
class Constant : public Expression {
|
||||
double data;
|
||||
public:
|
||||
explicit Constant (const double x) : data (x) {}
|
||||
explicit Constant (const long x) : data (x) {}
|
||||
double eval () override { /*printf("c=%g", data);*/ return data; }
|
||||
virtual ~Constant() {}
|
||||
};
|
||||
extern void addExpression (Expression * e);
|
||||
enum UNARY_FNCS {
|
||||
UNARY_MINUS = 0, UNARY_SIN, UNARY_COS, UNARY_EXP, UNARY_LOG, UNARY_max
|
||||
};
|
||||
enum BINARY_FNCS {
|
||||
BINARY_PLUS = 0, BINARY_MINUS, BINARY_MULT, BINARY_DIV, BINARY_POW, BINARY_max
|
||||
};
|
||||
typedef double (*unary_function) (const double);
|
||||
typedef double (*binary_function) (const double, const double);
|
||||
extern const unary_function unary_function_table [UNARY_max];
|
||||
extern const binary_function binary_function_table [BINARY_max];
|
||||
class Unary : public Expression {
|
||||
Expression * m_expr;
|
||||
unary_function m_f;
|
||||
public:
|
||||
explicit Unary (Expression * e, const UNARY_FNCS nf) : m_expr(e), m_f (unary_function_table[nf]) {}
|
||||
double eval () override { /*printf("(*%p)(%p)", m_f, m_expr);*/ return (m_f (m_expr->eval())); }
|
||||
virtual ~Unary () { delete m_expr; }
|
||||
};
|
||||
class Binary : public Expression {
|
||||
Expression * m_l, * m_r;
|
||||
binary_function m_f;
|
||||
public:
|
||||
explicit Binary (Expression * l, Expression * r, const BINARY_FNCS nf) : m_l(l), m_r(r), m_f(binary_function_table[nf]) {}
|
||||
double eval () override { /*printf("{%p}[%p]{%p}", m_l, m_f, m_r);*/ return (m_f (m_l->eval(), m_r->eval())); }
|
||||
virtual ~Binary() { delete m_l; delete m_r; }
|
||||
};
|
||||
struct Range {
|
||||
double value, end, step;
|
||||
};
|
||||
class VariableList {
|
||||
VariableList * next;
|
||||
char * name;
|
||||
Range data;
|
||||
public:
|
||||
explicit VariableList (const char * _name, const double _value) : next(nullptr) {
|
||||
name = strdup (_name);
|
||||
data.value = _value;
|
||||
data.end = _value;
|
||||
data.step = 0.0;
|
||||
}
|
||||
explicit VariableList (const char * _name, const double _value, const double _end, const double steps) : next(nullptr) {
|
||||
name = strdup (_name);
|
||||
if (_value > _end) {
|
||||
data.value = _end;
|
||||
data.end = _value;
|
||||
} else {
|
||||
data.value = _value;
|
||||
data.end = _end;
|
||||
}
|
||||
if (steps != 0.0) data.step = (data.end - data.value) / steps;
|
||||
else data.step = 1.0;
|
||||
}
|
||||
~VariableList () {
|
||||
if (next) delete next;
|
||||
free (name);
|
||||
}
|
||||
void add (const char * _name, const double _value) {
|
||||
if (!next) next = new VariableList (_name, _value);
|
||||
else next->add (_name, _value);
|
||||
}
|
||||
void add (const char * _name, const double _value, const double _end, const double steps) {
|
||||
if (!next) next = new VariableList (_name, _value, _end, steps);
|
||||
else next->add (_name, _value, _end, steps);
|
||||
}
|
||||
Range * find (const char * _name) {
|
||||
if (!strcmp (name, _name)) return & data;
|
||||
if (next) return next->find (_name);
|
||||
return nullptr;
|
||||
}
|
||||
VariableList * find_ranged () {
|
||||
if (data.step) return this;
|
||||
if (next) return next->find_ranged();
|
||||
return nullptr;
|
||||
}
|
||||
Range * get () { return & data; }
|
||||
};
|
||||
class Variable : public Expression {
|
||||
Range * data;
|
||||
public:
|
||||
explicit Variable (const char * name);
|
||||
double eval() override { return data->value; }
|
||||
virtual ~Variable () {}
|
||||
};
|
||||
struct CommonData {
|
||||
VariableList * list;
|
||||
Expression * root;
|
||||
explicit CommonData() : list(nullptr), root(nullptr) {}
|
||||
~CommonData () {
|
||||
if (list) delete list;
|
||||
if (root) delete root;
|
||||
}
|
||||
};
|
||||
|
||||
#endif /* __CALCULATOR_H__ */
|
||||
46
heap.c
Normal file
46
heap.c
Normal file
|
|
@ -0,0 +1,46 @@
|
|||
#include "heap.h"
|
||||
extern void IMPORT(memoryGrow) (const int block);
|
||||
extern char __heap_base;
|
||||
typedef __SIZE_TYPE__ size_t;
|
||||
|
||||
static const char * _HEAP_START = &__heap_base;
|
||||
char * _HEAP_MAX = &__heap_base;
|
||||
|
||||
void * sbrk (unsigned long size) {
|
||||
static const char * heap_ptr;
|
||||
const char * old_heap_ptr;
|
||||
static unsigned int init_sbrk = 0;
|
||||
/* heap_ptr is initialized to HEAP_START */
|
||||
if (init_sbrk == 0) {
|
||||
heap_ptr = _HEAP_START;
|
||||
init_sbrk = 1;
|
||||
}
|
||||
old_heap_ptr = heap_ptr;
|
||||
/* Tohle je jen zkusmo, uvidíme, zatím se zdá, že to chodí.
|
||||
* Těžko říct, co to udělá, když dojde paměť, ale pár MiB to zvládne.
|
||||
*/
|
||||
if ((heap_ptr + size) > _HEAP_MAX) {
|
||||
const int blocks = (((heap_ptr + size) - _HEAP_MAX) >> 16) + 1;
|
||||
memoryGrow (blocks);
|
||||
_HEAP_MAX += blocks << 16;
|
||||
}
|
||||
heap_ptr += size;
|
||||
return (void *)old_heap_ptr;
|
||||
}
|
||||
/* Následující je někde použito v parseru, ale nemusí to moc fungovat.
|
||||
*/
|
||||
int write(int fd, const void * b, size_t l) {
|
||||
if ((fd == 1) || (fd == 2)) printout(b, l);
|
||||
return l;
|
||||
}
|
||||
// formátování pro long double asi nebudu používat
|
||||
extern void exit (int x)__attribute__((noreturn));
|
||||
void _exit (int x) __attribute__ ((noreturn));
|
||||
void _exit (int x) { exit(x); }
|
||||
double __trunctfdf2(long double a) { return (double)(a); }
|
||||
int isatty () { return 1; }
|
||||
|
||||
void close (int fd) {}
|
||||
int read (int fd, void * b, size_t l) { return l; }
|
||||
size_t lseek(int fd, size_t offset, int whence) { return 0; }
|
||||
int fstat(int fd, void * statbuf) { return 0; }
|
||||
15
heap.h
Normal file
15
heap.h
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
#ifndef _HEAP_H
|
||||
#define _HEAP_H
|
||||
#define EXPORT(name) __attribute__((used, export_name(#name))) name
|
||||
// "imports" odpovídá importObject.imports v JS, default je to importObject.env
|
||||
#define IMPORT(name) __attribute__((import_module("imports"),import_name(#name))) name
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif //__cplusplus
|
||||
extern void IMPORT(printout) (const char * ptr, const int len); // external javascript function
|
||||
extern void * sbrk (unsigned long size);
|
||||
extern char * _HEAP_MAX;
|
||||
#ifdef __cplusplus
|
||||
};
|
||||
#endif //__cplusplus
|
||||
#endif // _HEAP_H
|
||||
23
newdel.cpp
Normal file
23
newdel.cpp
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
#include <stdlib.h>
|
||||
|
||||
|
||||
void* operator new (unsigned long size) {
|
||||
return calloc(1,size);
|
||||
}
|
||||
void operator delete (void* p) {
|
||||
free (p);
|
||||
}
|
||||
|
||||
void* operator new[] (unsigned long size) {
|
||||
return calloc(1,size);
|
||||
}
|
||||
|
||||
void operator delete[] (void* p) {
|
||||
free (p);
|
||||
}
|
||||
|
||||
void operator delete (void* p, unsigned size) {
|
||||
(void) size;
|
||||
free (p);
|
||||
}
|
||||
|
||||
3
symbols.txt
Normal file
3
symbols.txt
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
printout
|
||||
memoryGrow
|
||||
drawPoints
|
||||
3
test.txt
Normal file
3
test.txt
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
x=2,8,20
|
||||
y=1
|
||||
y*x^2 + 5*y*x + 1
|
||||
59
unix.cpp
Normal file
59
unix.cpp
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
#include <sys/stat.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <math.h>
|
||||
#include "calc.yy.h"
|
||||
#include "calculator.h"
|
||||
|
||||
extern void yyparse ();
|
||||
extern "C" int yywrap () {
|
||||
return 1;
|
||||
}
|
||||
|
||||
static char * from_file (const char * filename) {
|
||||
struct stat statbuf;
|
||||
int r = stat (filename, & statbuf);
|
||||
if (r) return nullptr;
|
||||
char * buffer = (char*) malloc (statbuf.st_size + 1);
|
||||
FILE * in = fopen (filename,"r");
|
||||
r = fread (buffer, 1, statbuf.st_size, in);
|
||||
if (r != statbuf.st_size) {
|
||||
free (buffer);
|
||||
fclose (in);
|
||||
return nullptr;
|
||||
}
|
||||
buffer [r] = '\0';
|
||||
fclose (in);
|
||||
return buffer;
|
||||
}
|
||||
void emitData (double * x, double * y, const int len) {
|
||||
for (int n=0; n<len; n++) {
|
||||
printf("f(%g) = %g\n", x[n], y[n]);
|
||||
}
|
||||
}
|
||||
/*
|
||||
static const char * multipliers [] = {"f","p","n","μ","m","","k","M","G","T","P"};
|
||||
static void test () {
|
||||
const int ofs = 5 * 3;
|
||||
for (int n=-15; n<18; n++) {
|
||||
div_t dt = div (n + ofs, 3);
|
||||
printf("n=%d, q=%d, r=%d (%d)\t%g %s\n", n, dt.quot, dt.rem, dt.quot * 3 + dt.rem - ofs,
|
||||
pow(10.0, dt.rem), multipliers[dt.quot]);
|
||||
}
|
||||
}
|
||||
*/
|
||||
int main () {
|
||||
char * buffer = from_file("test.txt");
|
||||
if (!buffer) return 1;
|
||||
|
||||
initData();
|
||||
YY_BUFFER_STATE result = yy_scan_string(buffer);
|
||||
yyparse();
|
||||
yy_delete_buffer(result);
|
||||
free (buffer);
|
||||
finiData();
|
||||
|
||||
//test();
|
||||
return 0;
|
||||
}
|
||||
|
||||
7
unix.mk
Normal file
7
unix.mk
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
MAIN = unix.o
|
||||
LD = clang++
|
||||
PR = test
|
||||
CFLAGS = -Wall -Oz -g -I. -I./lib
|
||||
LFLAGS =
|
||||
LDLIBS =
|
||||
|
||||
172
wasm.cpp
Normal file
172
wasm.cpp
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include "calculator.h"
|
||||
#include "heap.h"
|
||||
extern "C" void EXPORT(init) (const int memlen);
|
||||
extern "C" int EXPORT(cAlloc) (int len);
|
||||
extern "C" void EXPORT(compute) (char * ptr, int len);
|
||||
extern "C" void EXPORT(resizeCanvas)(int x, int y);
|
||||
extern "C" void IMPORT(drawPoints) (float * x, float * y, int len, char * json, int jl);
|
||||
extern "C" void __wasm_call_ctors ();
|
||||
extern "C++" {
|
||||
typedef struct yy_buffer_state * YY_BUFFER_STATE;
|
||||
extern int yyparse();
|
||||
extern YY_BUFFER_STATE yy_scan_string(const char * str);
|
||||
extern void yy_delete_buffer(YY_BUFFER_STATE buffer);
|
||||
};
|
||||
extern "C" int yywrap () {
|
||||
return 1;
|
||||
}
|
||||
void init (const int memlen) {
|
||||
_HEAP_MAX = reinterpret_cast<char*>(memlen);
|
||||
__wasm_call_ctors();
|
||||
printf("Module initialized\n\n");
|
||||
}
|
||||
int cAlloc (int len) {
|
||||
return int (malloc(len + 1));
|
||||
}
|
||||
void compute (char * ptr, int len) {
|
||||
ptr [len] = '\0';
|
||||
|
||||
initData();
|
||||
YY_BUFFER_STATE result = yy_scan_string(ptr);
|
||||
yyparse();
|
||||
yy_delete_buffer(result);
|
||||
free (ptr);
|
||||
finiData();
|
||||
}
|
||||
struct Canvas {
|
||||
double width, height;
|
||||
double xscale, yscale;
|
||||
double xofset, yofset;
|
||||
float xt (const double x) {
|
||||
return float (xscale * (x - xofset));
|
||||
}
|
||||
float yt (const double y) {
|
||||
return float (height - yscale * (y - yofset));
|
||||
}
|
||||
};
|
||||
static const char * multipliers [] = {"f","p","n","μ","m","","k","M","G","T","P"};
|
||||
struct Stepping {
|
||||
double b,e,s;
|
||||
char fmtbuf [16];
|
||||
explicit Stepping (const double from, const double to) {
|
||||
double lp;
|
||||
const double z = log10 (fabs (to - from));
|
||||
const double fp = modf (z, & lp);
|
||||
if (fp < 0.30103) s = 1.0;
|
||||
else if (fp > 0.69897) s = 5.0;
|
||||
else s = 2.0;
|
||||
int ip = int (lp) - 1;
|
||||
if (z < 0.0) ip -= 1;
|
||||
s *= ::pow (10.0, double (ip));
|
||||
do {
|
||||
const int k = int (fabs(to - from) / s);
|
||||
b = round (from / s) * s;
|
||||
e = round (to / s) * s;
|
||||
if (k > 50) s *= 10.0; // prevence přeplnění osy, nevím proč, ale tohle to odstraní
|
||||
else break; // patrně log10() nedává přesně to, co bych čekal
|
||||
} while (true);
|
||||
}
|
||||
void f () {printf("stepping = %g, b = %g, e = %g\n", s, b, e);}
|
||||
char * ing (const double x, int n=0) {
|
||||
if (fabs(x) < 0.5 * s) {
|
||||
fmtbuf[n++] = ' ';
|
||||
fmtbuf[n++] = '\0';
|
||||
return fmtbuf;
|
||||
}
|
||||
if (x < 0.0) {
|
||||
fmtbuf[n++] = '-';
|
||||
return ing (-x, n);
|
||||
}
|
||||
if (x > 0.0) {
|
||||
double ip;
|
||||
const double fp = modf(log10(x), & ip);
|
||||
int pi = ip, ofs = 5 * 3;
|
||||
if (pi < -ofs) pi = -ofs;
|
||||
if (pi > 18 ) pi = 18;
|
||||
const div_t dt = div(pi + ofs, 3);
|
||||
n += snprintf (fmtbuf + n, 16 - n, "%g%s", ::pow (10.0, fp + double (dt.rem)), multipliers [dt.quot]);
|
||||
}
|
||||
return fmtbuf;
|
||||
}
|
||||
protected:
|
||||
};
|
||||
static Canvas canvas;
|
||||
void resizeCanvas (int x, int y) {
|
||||
printf("resizeCanvas: x=%d, y=%d\n", x, y);
|
||||
canvas.width = x;
|
||||
canvas.height = y;
|
||||
}
|
||||
void emitData (double * x, double * y, const int len) {
|
||||
double ymin = 1.0e100, ymax = -1.0e100;
|
||||
for (int n=0; n<len; n++) {
|
||||
if (y[n] < ymin) ymin = y[n];
|
||||
if (y[n] > ymax) ymax = y[n];
|
||||
// printf("f(%g) = %g\n", x[n], y[n]);
|
||||
}
|
||||
const double xmin = x[0];
|
||||
const double xmax = x[len - 1];
|
||||
printf("xmin = %g, xmax = %g, ymin = %g, ymax = %g\n", xmin, xmax, ymin, ymax);
|
||||
const double f = 1.0;
|
||||
ymin *= f;
|
||||
ymax *= f;
|
||||
canvas.xofset = xmin;
|
||||
canvas.yofset = ymin;
|
||||
canvas.xscale = canvas.width / (xmax - xmin);
|
||||
canvas.yscale = canvas.height / (ymax - ymin);
|
||||
Stepping sx (xmin, xmax), sy (ymin, ymax);
|
||||
// sx.f(); sy.f();
|
||||
|
||||
float * ix = new float [len]; // float32 stačí
|
||||
float * iy = new float [len];
|
||||
for (int n=0; n<len; n++) {
|
||||
ix[n] = canvas.xt (x[n]); // přepočteno na velikost canvasu
|
||||
iy[n] = canvas.yt (y[n]);
|
||||
// printf("f(%d) = %d\n", ix[n], iy[n]);
|
||||
}
|
||||
const int json_max = 0x8000; // string bude poměrně dlouhý
|
||||
char * json = new char [json_max];
|
||||
int n = 0;
|
||||
const uint32_t xColor = 0xffff00;
|
||||
const uint32_t yColor = 0x00ffff;
|
||||
const double wd = 4.0; // šířka čárky na osách v px
|
||||
const double pos0x = canvas.xt(0.0) > 0 and canvas.xt(0.0) < canvas.width ? canvas.xt(0.0) : 0.0;
|
||||
const double pos0y = canvas.yt(0.0) > 0 and canvas.yt(0.0) < canvas.height ? canvas.yt(0.0) : canvas.height;
|
||||
n += snprintf(json + n, json_max - n, "{ \"name\":\"axes\", ");
|
||||
n += snprintf(json + n, json_max - n, "\"x\":{ \"color\":\"#%06X\", \"w\":%d, ", xColor, 2);
|
||||
n += snprintf(json + n, json_max - n, "\"b\": [%g,%g], ", 0.0, pos0y);
|
||||
n += snprintf(json + n, json_max - n, "\"e\": [%g,%g] }, ", canvas.width, pos0y);
|
||||
n += snprintf(json + n, json_max - n, "\"y\": { \"color\":\"#%06X\", \"w\":%d, ", yColor, 2);
|
||||
n += snprintf(json + n, json_max - n, "\"b\": [%g,%g], ", pos0x, 0.0);
|
||||
n += snprintf(json + n, json_max - n, "\"e\": [%g,%g] }, \"xdots\": [", pos0x, canvas.height);
|
||||
for (double dx=sx.b; dx<sx.e; dx+=sx.s) {
|
||||
n += snprintf(json + n, json_max - n, "{ \"color\":\"#%06X\", \"w\":%d, \"lbl\":\"%s\", ", xColor, 2, sx.ing(dx));
|
||||
n += snprintf(json + n, json_max - n, "\"b\": [%g,%g], " , canvas.xt(dx), pos0y - wd);
|
||||
n += snprintf(json + n, json_max - n, "\"e\": [%g,%g] }, ", canvas.xt(dx), pos0y + wd);
|
||||
}
|
||||
json [n-2] = ' '; // přepiš poslední čárku, jinak json nefunguje
|
||||
n += snprintf(json + n, json_max - n, "], \"ydots\": [\n");
|
||||
for (double dy=sy.b; dy<sy.e; dy+=sy.s) {
|
||||
n += snprintf(json + n, json_max - n, "{ \"color\":\"#%06X\", \"w\":%d, \"lbl\":\"%s\", ", yColor, 2, sy.ing(dy));
|
||||
n += snprintf(json + n, json_max - n, "\"b\": [%g,%g], " , pos0x - wd, canvas.yt(dy));
|
||||
n += snprintf(json + n, json_max - n, "\"e\": [%g,%g] }, ", pos0x + wd, canvas.yt(dy));
|
||||
}
|
||||
json [n-2] = ' ';
|
||||
n += snprintf(json + n, json_max - n, "] }\n");
|
||||
// printf("%d\n", n);
|
||||
/* Pro kreslení na canvas se používají 2 metody:
|
||||
* 1. Přímé předání dat pomocí ukazatelů.
|
||||
* Ukázalo se, že typ int nestačí, zaokrouhlení je kostrbaté, double je zbytečně velký,
|
||||
* takže stačí float (32.bit), je to normováno na velikost canvas, takže tam nejsou skoky v řádech
|
||||
* 2. Z dat uděláme JSON a ten zpracuje javascript. Není to moc efektivní, ale funguje.
|
||||
* (3. zde nepoužito) Vytvoříme přímo javascript zdroják, který to celé vykreslí
|
||||
* a ten pak spustíme v javascriptu pomocí eval(). Funguje také, ale je to divné.
|
||||
* */
|
||||
drawPoints (ix, iy, len, json, n);
|
||||
delete [] ix; delete [] iy;
|
||||
delete [] json;
|
||||
}
|
||||
20
wasm.mk
Normal file
20
wasm.mk
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
MAIN = wasm.o
|
||||
MOBJS+=heap.o newdel.o
|
||||
LD = wasm-ld-10
|
||||
TARGET = --target=wasm32-unknown-unknown
|
||||
PR = bin/module.wasm
|
||||
# Cesta k newlib
|
||||
LPATH = ${HOME}/local/wasm32-none-eabi
|
||||
CFLAGS = -Wall -Oz -flto -I. -I$(LPATH)/include $(TARGET)
|
||||
#CFLAGS+= --sysroot=${HOME}/local/wasm32-none-eabi
|
||||
CFLAGS+= -ffunction-sections -fdata-sections
|
||||
#CFLAGS+= -Wno-incompatible-library-redeclaration
|
||||
# Pro clang by muselo ještě přibýt -nostartfiles $(TARGET) a LFLAGS by bylo -Wl,
|
||||
LFLAGS = --no-entry --import-memory --lto-O3 --gc-sections
|
||||
# vetsi stack znamena zvetsit i WebAssembly.Memory({ initial: n 64K block })
|
||||
#LFLAGS+= -z stack-size=1048576
|
||||
#LFLAGS+= --print-gc-sections
|
||||
#LFLAGS+= --allow-undefined
|
||||
LFLAGS+= --allow-undefined-file=symbols.txt
|
||||
LDLIBS = -L$(LPATH)/lib -lc -lm
|
||||
|
||||
Loading…
Reference in a new issue