zongor
/
undar-lang
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

more advanced array stuff, hacked in read/write literals for uxn

This commit is contained in:
zongor 2026-06-28 23:51:58 -07:00
parent 74f5c58f23
commit 0449d9b84e
14 changed files with 745 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
arch/linux/main.c
View File

@ -77,14 +77,14 @@ main(int argc, char **argv)
Node *curr = code->head; Node *curr = code->head;
while (curr) { while (curr) {
char* tmp_str = node_value(curr); char* tmp_str = node_value(curr);
write(STDOUT_FILENO, tmp_str, curr->size); printf("%.*s", curr->size, tmp_str);
curr = curr->next; curr = curr->next;
} }
curr = memory->head; curr = memory->head;
while (curr) { while (curr) {
char* tmp_str = node_value(curr); char* tmp_str = node_value(curr);
write(STDOUT_FILENO, tmp_str, curr->size); printf("%.*s", curr->size, tmp_str);
curr = curr->next; curr = curr->next;
} }

78
compiler.c
View File

@ -371,21 +371,6 @@ void declaration();
ParseRule *get_rule(TokenType type); ParseRule *get_rule(TokenType type);
void parse_precedence(Precedence precedence); void parse_precedence(Precedence precedence);
/**
FIXME: we need to move the string to be on the heap instead of the stack
so we need special handling in variable_dec
During the first pass we need to append the string label @variable
and then the hexed out literal.
every time we reference the string we should reference the global ptr.
If the string gets appended then we should copy and use the local varaiable
but for string conts or array conts we should use the global ref '@'
*/
u32 u32
variable_declaration(Symbol *def) variable_declaration(Symbol *def)
{ {
@ -422,10 +407,15 @@ variable_declaration(Symbol *def)
if(match(TOKEN_RBRACKET)) break; if(match(TOKEN_RBRACKET)) break;
expect(TOKEN_COMMA); expect(TOKEN_COMMA);
} }
}
expect(TOKEN_SEMICOLON); expect(TOKEN_SEMICOLON);
emitter.emit_array(arena, memory, variable, array_literal); emitter.emit_array(arena, memory, variable, array_literal);
} else {
expect(TOKEN_SEMICOLON);
emitter.emit_array(arena, memory, variable, nil);
emitter.emit_zero_block(arena, memory, variable->size * emitter.get_size(variable->secondary_type));
}
return variable->size; return variable->size;
} }
@ -574,12 +564,22 @@ variable()
if (match(TOKEN_LBRACKET)) { if (match(TOKEN_LBRACKET)) {
expression(); expression();
emitter.emit_address(arena, code, emitter.get_size(sym->secondary_type)); emitter.emit_address(arena, code, emitter.get_size(sym->secondary_type));
emitter.emit_mul(arena, code); emitter.emit_mul(arena, code);
emitter.emit_add(arena, code); emitter.emit_add(arena, code);
/* add offset of "length"*/
emitter.emit_nat(arena, code, "2", 1);
emitter.emit_add(arena, code);
emitter.emit_deref(arena, code); emitter.emit_deref(arena, code);
while (!match(TOKEN_RBRACKET)) { while (!match(TOKEN_RBRACKET)) {
} }
} else if (match(TOKEN_DOT)) {
if (sleq("length", parser.current.start, parser.current.length)) {
emitter.emit_deref(arena, code);
} else {
emitter.error("arrays currently can only get their length, don't do anything fancy yet...", 75, parser.current.line);
}
advance();
} }
return; return;
} }
@ -729,13 +729,14 @@ if_statement()
void void
while_statement() while_statement()
{ {
emitter.emit_while(arena, code, emitter.loops); u32 this_while = emitter.loops++;
emitter.emit_while(arena, code, this_while);
consume(TOKEN_LPAREN); consume(TOKEN_LPAREN);
expression(); expression();
consume(TOKEN_RPAREN); consume(TOKEN_RPAREN);
emitter.emit_while_postfix(arena, code); emitter.emit_while_postfix(arena, code);
statement(); statement();
emitter.emit_patch_while(arena, code, emitter.loops++); emitter.emit_patch_while(arena, code, this_while);
} }
void void
@ -835,6 +836,12 @@ string()
emitter.emit_str(arena, code, parser.previous.start, parser.previous.length); emitter.emit_str(arena, code, parser.previous.start, parser.previous.length);
} }
void
character()
{
emitter.emit_char(arena, code, parser.previous.start, parser.previous.length);
}
void void
unary() unary()
{ {
@ -853,6 +860,21 @@ unary()
} }
} }
void
read()
{
emitter.emit_read(arena, code);
}
void
write()
{
consume(TOKEN_EQ);
advance();
variable();
emitter.emit_write(arena, code);
}
ParseRule rules[] = { ParseRule rules[] = {
/* TOKEN_ERROR */ {nil, nil, PREC_NONE}, /* TOKEN_ERROR */ {nil, nil, PREC_NONE},
/* TOKEN_EOF */ {nil, nil, PREC_NONE}, /* TOKEN_EOF */ {nil, nil, PREC_NONE},
@ -893,8 +915,8 @@ ParseRule rules[] = {
/* TOKEN_KEYWORD_INIT */ {nil, nil, PREC_NONE}, /* TOKEN_KEYWORD_INIT */ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_THIS */ {nil, nil, PREC_NONE}, /* TOKEN_KEYWORD_THIS */ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_OPEN */ {nil, nil, PREC_NONE}, /* TOKEN_KEYWORD_OPEN */ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_READ */ {nil, nil, PREC_NONE}, /* TOKEN_KEYWORD_READ */ {read, nil, PREC_NONE},
/* TOKEN_KEYWORD_WRITE */ {nil, nil, PREC_NONE}, /* TOKEN_KEYWORD_WRITE */ { write, nil, PREC_NONE},
/* TOKEN_KEYWORD_STAT */ {nil, nil, PREC_NONE}, /* TOKEN_KEYWORD_STAT */ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_CLOSE */ {nil, nil, PREC_NONE}, /* TOKEN_KEYWORD_CLOSE */ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_LOOP */ {nil, nil, PREC_NONE}, /* TOKEN_KEYWORD_LOOP */ {nil, nil, PREC_NONE},
@ -934,7 +956,13 @@ ParseRule rules[] = {
/* TOKEN_ARROW_RIGHT */ {nil, nil, PREC_NONE}, /* TOKEN_ARROW_RIGHT */ {nil, nil, PREC_NONE},
/* TOKEN_SLL */ {nil, binary, PREC_NONE}, /* TOKEN_SLL */ {nil, binary, PREC_NONE},
/* TOKEN_SRL */ {nil, binary, PREC_NONE}, /* TOKEN_SRL */ {nil, binary, PREC_NONE},
/* TOKEN_KEYWORD_PRINT*/ {nil, binary, PREC_NONE}}; /* TOKEN_KEYWORD_PRINT*/ {nil, binary, PREC_NONE},
/* TOKEN_KEYWORD_TRAIT*/ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_HALT*/ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_DEVMAP*/ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_BYTE*/ {nil, nil, PREC_NONE},
/* TOKEN_KEYWORD_CHAR*/ {character, nil, PREC_NONE},
};
void void
parse_precedence(Precedence precedence) parse_precedence(Precedence precedence)

2
emit.h
View File

@ -105,6 +105,8 @@ struct emitter_s {
VoidArgEmit emit_deref; VoidArgEmit emit_deref;
VoidArgEmit emit_ref; VoidArgEmit emit_ref;
U32ArgEmit emit_address; U32ArgEmit emit_address;
U32ArgEmit emit_zero_block;
StrArgEmit emit_char;
}; };
Emitter rer_emitter(); Emitter rer_emitter();

2
emit/rer/emit.c
View File

@ -773,5 +773,7 @@ rer_emitter()
nil, nil,
nil, nil,
nil, nil,
nil,
nil,
}; };
} }

31
emit/uxn/emit.c
View File

@ -783,6 +783,14 @@ uxn_emit_byte(Arena *a, List *out, const char *str, i32 length)
USED(length); USED(length);
} }
void
uxn_emit_char(Arena *a, List *out, const char *str, i32 length)
{
sprintf(uxn_temp_strbuf, "#%04x ", (char)str[0]);
StrBuf_append(a, out, uxn_temp_strbuf);
USED(length);
}
void void
uxn_emit_str(Arena *a, List *out, const char *str, i32 length) uxn_emit_str(Arena *a, List *out, const char *str, i32 length)
{ {
@ -844,8 +852,10 @@ uxn_emit_array(Arena *a, List *out, Symbol *sym, List *in)
sprintf(uxn_temp_strbuf, "@%.*s ", sym->name_length, sym->name); sprintf(uxn_temp_strbuf, "@%.*s ", sym->name_length, sym->name);
StrBuf_append(a, out, uxn_temp_strbuf); StrBuf_append(a, out, uxn_temp_strbuf);
//sprintf(uxn_temp_strbuf, "%04x ", in->count); if (!in) return;
//StrBuf_append(a, out, uxn_temp_strbuf);
sprintf(uxn_temp_strbuf, "%04x ", in->count);
StrBuf_append(a, out, uxn_temp_strbuf);
switch(t) { switch(t) {
case SYMBOL_BOOL: { case SYMBOL_BOOL: {
@ -1098,15 +1108,13 @@ uxn_emit_set_variable(Arena *a, List *out, Symbol *sym, bool local)
void void
uxn_emit_write(Arena *a, List *out) uxn_emit_write(Arena *a, List *out)
{ {
USED(a); StrBuf_append(a, out, "#18 DEO ");
USED(out);
} }
void void
uxn_emit_read(Arena *a, List *out) uxn_emit_read(Arena *a, List *out)
{ {
USED(a); StrBuf_append(a, out, "#12 DEI ");
USED(out);
} }
void void
@ -1365,6 +1373,13 @@ uxn_emit_address(Arena *a, List *out, u32 ptr)
StrBuf_append(a, out, uxn_temp_strbuf); StrBuf_append(a, out, uxn_temp_strbuf);
} }
void
uxn_emit_zero_block(Arena *a, List *out, u32 ptr)
{
sprintf(uxn_temp_strbuf, "$%d ", ptr);
StrBuf_append(a, out, uxn_temp_strbuf);
}
Emitter Emitter
uxn_emitter() uxn_emitter()
{ {
@ -1456,6 +1471,8 @@ uxn_emitter()
uxn_emit_deref_prolog, uxn_emit_deref_prolog,
uxn_emit_deref, uxn_emit_deref,
nil, nil,
uxn_emit_address uxn_emit_address,
uxn_emit_zero_block,
uxn_emit_char,
}; };
} }

17
lexer.c
View File

@ -382,6 +382,21 @@ string()
return make_token(TOKEN_LITERAL_STR); return make_token(TOKEN_LITERAL_STR);
} }
static Token
character()
{
advance();
if(peek() != '\'' && !is_at_end()) {
advance();
}
if(is_at_end()) return error_token("Unterminated string.");
/* The closing quote. */
advance();
return make_token(TOKEN_LITERAL_CHAR);
}
Token Token
next_token() next_token()
{ {
@ -444,6 +459,8 @@ next_token()
: TOKEN_GT); : TOKEN_GT);
case '"': case '"':
return string(); return string();
case '\'':
return character();
} }
return error_token("Unexpected character."); return error_token("Unexpected character.");

4
lexer.h
View File

@ -87,7 +87,9 @@ typedef enum {
TOKEN_KEYWORD_PRINT, TOKEN_KEYWORD_PRINT,
TOKEN_KEYWORD_TRAIT, TOKEN_KEYWORD_TRAIT,
TOKEN_KEYWORD_HALT, TOKEN_KEYWORD_HALT,
TOKEN_KEYWORD_DEVMAP /* device memory map */ TOKEN_KEYWORD_DEVMAP, /* device memory map */
TOKEN_LITERAL_BYTE,
TOKEN_LITERAL_CHAR
} TokenType; } TokenType;
typedef struct token_s Token; typedef struct token_s Token;

3
test/array.ul
View File

@ -2,8 +2,7 @@
nat[6] fixed_size = [1, 2, 3, 4, 5, 6]; nat[6] fixed_size = [1, 2, 3, 4, 5, 6];
nat i = 0; nat i = 0;
//while (i < fixed_size.length) { while (i < fixed_size.length) {
while (i < 6) {
print(fixed_size[i] as str); print(fixed_size[i] as str);
print(" "); print(" ");
i = i + 1; i = i + 1;

44
test/bf.ul
View File

@ -1,20 +1,20 @@
plex Console //plex Console
{ //{
ref function vector(void):void; // ref function vector(void):void;
byte read; // byte read;
u32 pad; // u32 pad;
byte type; // byte type;
byte write; // byte write;
byte error; // byte error;
u16 pad2; // u16 pad2;
ref byte[] addr; // ref byte[] addr;
byte mode; // byte mode;
byte exec; // byte exec;
} //}
//
//Console console = devmap(0x10, Console);
Console console = devmap(0x10, Console); byte[10000] memory;
byte memory[10000];
str code = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++."; str code = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.";
bf(code); bf(code);
halt; halt;
@ -23,8 +23,10 @@ function bf(str code)
{ {
nat mp; // memory pointer nat mp; // memory pointer
nat ip = 0; // instruction pointer nat ip = 0; // instruction pointer
while (ip < code.length) { // while (ip < code.length) {
if (ip > code.length) { return; } // if (ip > code.length) { return; }
while (ip < 106) {
if (ip < 0 or ip > 106) { return; }
if (mp > memory.length) { return; } if (mp > memory.length) { return; }
if (code[ip] == '>') { if (code[ip] == '>') {
mp = mp + 1; mp = mp + 1;
@ -35,9 +37,11 @@ function bf(str code)
} else if (code[ip] == '-') { } else if (code[ip] == '-') {
memory[mp] = memory[mp] - 1; memory[mp] = memory[mp] - 1;
} else if (code[ip] == '.') { } else if (code[ip] == '.') {
console.write = memory[mp]; // console.write = memory[mp];
write = memory[mp];
} else if (code[ip] == ',') { } else if (code[ip] == ',') {
memory[mp] = console.read; // memory[mp] = console.read;
memory[mp] = read;
} else if (code[ip] == '[') { } else if (code[ip] == '[') {
if(!memory[mp]) { if(!memory[mp]) {
nat nc = 1; nat nc = 1;

4
test/rw.ul Normal file
View File

@ -0,0 +1,4 @@
byte t = read;
write = t;
halt;

6
test/tal/array.tal
View File

@ -2,8 +2,8 @@
LIT2r 0000 LIT2r 0000
!{ @i $2 } #0000 ;i STA2 !{ @i $2 } #0000 ;i STA2
&while.0 ;i LDA2 #0006 LTH2 #03 JCN !{ &while.0 ;i LDA2 ;fixed_size LDA2 LTH2 #03 JCN !{
;fixed_size ;i LDA2 #0002 MUL2 ADD2 LDA2 nat_to_str_ str/<print> ;fixed_size ;i LDA2 #0002 MUL2 ADD2 #0002 ADD2 LDA2 nat_to_str_ str/<print>
;{ #0002 ADD2 } !{ 20 00 } str/<print> ;{ #0002 ADD2 } !{ 20 00 } str/<print>
;i LDA2 #0001 ADD2 ;i STA2 !&while.0 } ;i LDA2 #0001 ADD2 ;i STA2 !&while.0 }
;{ #0002 ADD2 } !{ 0a 00 } str/<print> ;{ #0002 ADD2 } !{ 0a 00 } str/<print>
@ -276,5 +276,5 @@ POP2r BRK @sext
INC2 !/<print> INC2 !/<print>
@mem_length_ #0000 @mem_length_ #0000
@mem_ @fixed_size 0001 0002 0003 0004 0005 0006 @mem_ @fixed_size 0006 0001 0002 0003 0004 0005 0006

330
test/tal/bf.tal Normal file
View File

@ -0,0 +1,330 @@
|100
LIT2r 0000
!{ @code $2 } ;{ #0002 ADD2 } !{ 2b 2b 2b 2b 2b 2b 2b 2b 5b 3e 2b 2b 2b 2b 5b 3e 2b 2b 3e 2b 2b 2b 3e 2b 2b 2b 3e 2b 3c 3c 3c 3c 2d 5d 3e 2b 3e 2b 3e 2d 3e 3e 2b 5b 3c 5d 3c 2d 5d 3e 3e 2e 3e 2d 2d 2d 2e 2b 2b 2b 2b 2b 2b 2b 2e 2e 2b 2b 2b 2e 3e 3e 2e 3c 2d 2e 3c 2e 2b 2b 2b 2e 2d 2d 2d 2d 2d 2d 2e 2d 2d 2d 2d 2d 2d 2d 2d 2e 3e 3e 2b 2e 3e 2b 2b 2e 00 } ;code STA2
;code LDA2 bf_ POP2r BRK @bf_ ( code -- )
OVR2r LIT2r 000a SUB2r
STH2kr STA2
STH2kr #2712 ADD2 LDA2
STH2kr #2714 ADD2 LDA2
#0000 STH2kr #2714 ADD2 STA2
&while.0 STH2kr #2714 ADD2 LDA2 #006a LTH2 #03 JCN !{
STH2kr #0004 ADD2 LDA2 #0000 LTH2 #03 JCN !{
!&if_end.0 } &if_end.0
STH2kr #0004 ADD2 LDA2 #006a GTH2 !&return STH2kr #0002 ADD2 LDA2 ;memory LDA2 GTH2 #03 JCN !{
!&return !&if_end.1 } &if_end.1
STH2kr LDA2 #03 JCN !{
!&if_end.2 } &if_end.2
STH2kr #0004 ADD2 LDA2 #0027 STH2kr #0002 ADD2 LDA2 #0001 ADD2 STH2kr #0002 ADD2 STA2 STH2kr LDA2 #03 JCN !{
!&if_end.3 } &if_end.3
STH2kr #0004 ADD2 LDA2 #0027 STH2kr #0002 ADD2 LDA2 #0001 SUB2 STH2kr #0002 ADD2 STA2 STH2kr LDA2 #03 JCN !{
!&if_end.4 } &if_end.4
STH2kr #0004 ADD2 LDA2 #0027 ;memory STH2kr #0002 ADD2 LDA2 #0001 MUL2 ADD2 #0002 ADD2 LDA2 ;memory STH2kr #0002 ADD2 LDA2 #0001 MUL2 ADD2 #0002 ADD2 LDA2 #0001 ADD2 STH2kr LDA2 #03 JCN !{
!&if_end.5 } &if_end.5
STH2kr #0004 ADD2 LDA2 #0027 ;memory STH2kr #0002 ADD2 LDA2 #0001 MUL2 ADD2 #0002 ADD2 LDA2 ;memory STH2kr #0002 ADD2 LDA2 #0001 MUL2 ADD2 #0002 ADD2 LDA2 #0001 SUB2 STH2kr LDA2 #03 JCN !{
!&if_end.6 } &if_end.6
STH2kr #0004 ADD2 LDA2 #0027 ;memory STH2kr #0002 ADD2 LDA2 #0001 MUL2 ADD2 #0002 ADD2 LDA2 #18 DEO STH2kr LDA2 #03 JCN !{
!&if_end.7 } &if_end.7
STH2kr #0004 ADD2 LDA2 #0027 ;memory STH2kr #0002 ADD2 LDA2 #0001 MUL2 ADD2 #0002 ADD2 LDA2 #12 DEI STH2kr LDA2 #03 JCN !{
!&if_end.8 } &if_end.8
STH2kr #0004 ADD2 LDA2 #0027 ;memory STH2kr #0002 ADD2 LDA2 #0001 MUL2 ADD2 #0002 ADD2 LDA2 #0000 EQU2 #03 JCN !{
STH2kr LDA2
#0001 STH2kr STA2
&while.1 STH2kr LDA2 #0000 GTH2 #03 JCN !{
STH2kr #0004 ADD2 LDA2 #0001 ADD2 STH2kr #0004 ADD2 STA2 STH2kr LDA2 #03 JCN !{
!&if_end.9 } &if_end.9
STH2kr #0004 ADD2 LDA2 #0027 STH2kr LDA2 #0001 ADD2 STH2kr STA2 STH2kr LDA2 #03 JCN !{
!&if_end.10 } &if_end.10
STH2kr #0004 ADD2 LDA2 #0027 STH2kr LDA2 #0001 SUB2 STH2kr STA2 !&while.1 }
!&if_end.11 } &if_end.11
STH2kr LDA2 #03 JCN !{
!&if_end.12 } &if_end.12
STH2kr #0004 ADD2 LDA2 #0027 ;memory STH2kr #0002 ADD2 LDA2 #0001 MUL2 ADD2 #0002 ADD2 LDA2 #03 JCN !{
STH2kr LDA2
#0001 STH2kr STA2
&while.2 STH2kr LDA2 #0000 GTH2 #03 JCN !{
STH2kr #0004 ADD2 LDA2 #0001 SUB2 STH2kr #0004 ADD2 STA2 STH2kr LDA2 #03 JCN !{
!&if_end.13 } &if_end.13
STH2kr #0004 ADD2 LDA2 #0027 STH2kr LDA2 #0001 ADD2 STH2kr STA2 STH2kr LDA2 #03 JCN !{
!&if_end.14 } &if_end.14
STH2kr #0004 ADD2 LDA2 #0027 STH2kr LDA2 #0001 SUB2 STH2kr STA2 !&while.2 }
!&if_end.15 } &if_end.15
STH2kr #0004 ADD2 LDA2 #0001 ADD2 STH2kr #0004 ADD2 STA2 !&while.0 }
&return
POP2r JMP2r
@sext
#80 ANDk EQU #ff MUL SWP JMP2r
@sdiv
OVR #80 AND ?&b_neg &b_pos OVR2 POP #80 AND ?&a_neg_b_pos DIV2 JMP2r &a_neg_b_pos SWP2 #0000 SWP2 SUB2 SWP2 DIV2 #0000 SWP2 SUB2 JMP2r
&b_neg #0000 SWP2 SUB2 OVR2 POP #80 AND ?&a_neg_b_neg DIV2 #0000 SWP2 SUB2 JMP2r
&a_neg_b_neg #0000 ROT2 SUB2 SWP2 DIV2 JMP2r
@aalloc_ ( size* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
;mem_length_ LDA2 STH2kr STA2
;mem_length_ LDA2k STH2kr INC2 INC2 LDA2 ADD2 SWP2 STA2
;mem_ STH2kr LDA2 ADD2 !&return
#0000
&return
POP2r JMP2r
@areturn_ ( size* src* checkpoint* -- result* )
OVR2r LIT2r 000a SUB2r STH2kr #0008 ADD2 STA2
STH2kr #0006 ADD2 STA2
STH2kr #0004 ADD2 STA2
;mem_ STH2kr #0008 ADD2 LDA2 ADD2 STH2kr INC2 INC2 STA2
STH2kr #0006 ADD2 LDA2 STH2kr INC2 INC2 LDA2 NEQ2 ?&end.1
STH2kr #0006 ADD2 LDA2 !&return
&end.1
#0000 STH2kr STA2
&begin.2
STH2kr LDA2 STH2kr #0004 ADD2 LDA2 LTH2 #00 EQU ?&break.2
STH2kr #0006 ADD2 LDA2 STH2kr LDA2 ADD2 LDA sext
STH2kr INC2 INC2 LDA2 STH2kr LDA2 ADD2 STA
POP
&continue.2
STH2kr LDA2k INC2k ROT2 STA2
POP2 !&begin.2
&break.2
STH2kr #0008 ADD2 LDA2 STH2kr #0004 ADD2 LDA2 ADD2 ;mem_length_ STA2
#0000 ;mem_ ;mem_length_ LDA2 ADD2 STA
POP STH2kr INC2 INC2 LDA2 !&return
#0000
&return
POP2r JMP2r
@afree_ ( -- result* )
OVR2r #0000 ;mem_length_ STA2
#0000
&return
POP2r JMP2r
@amcpy_ ( length* from* -- result* )
OVR2r LIT2r 0008 SUB2r STH2kr #0006 ADD2 STA2
STH2kr #0004 ADD2 STA2
STH2kr #0004 ADD2 LDA2 aalloc_
STH2kr INC2 INC2 STA2
#0000 STH2kr STA2
&begin.1
STH2kr LDA2 STH2kr #0004 ADD2 LDA2 LTH2 #00 EQU ?&break.1
STH2kr #0006 ADD2 LDA2 STH2kr LDA2 ADD2 LDA sext
STH2kr INC2 INC2 LDA2 STH2kr LDA2 ADD2 STA
POP
&continue.1
STH2kr LDA2k INC2k ROT2 STA2
POP2 !&begin.1
&break.1
STH2kr INC2 INC2 LDA2 !&return
#0000
&return
POP2r JMP2r
@nat_to_str_ ( n* -- result* )
OVR2r LIT2r 000a SUB2r STH2kr #0008 ADD2 STA2
#0005 STH2kr STA2
&begin.1
STH2kr #0008 ADD2 LDA2 #000a OVR2 OVR2 DIV2 MUL2 SUB2 #0030 ADD2 STH2kr INC2 INC2 STH2kr LDA2k #0001 SUB2 SWP2 STA2k
POP2 ADD2 STA
POP STH2kr #0008 ADD2 LDA2k #000a DIV2 SWP2 STA2
&continue.1
#0000 STH2kr #0008 ADD2 LDA2 LTH2 ?&begin.1
&break.1
#0005 STH2kr LDA2 SUB2 STH2kr INC2 INC2 STH2kr LDA2 ADD2 amcpy_
!&return
#0000
&return
POP2r JMP2r
@int_to_str_ ( n* -- result* )
OVR2r LIT2r 000c SUB2r STH2kr #000a ADD2 STA2
#0006 STH2kr INC2 INC2 STA2
STH2kr #000a ADD2 LDA2 #8000 EOR2 #8000 LTH2 #00 SWP #0000 NEQ2 #00 SWP STH2kr STA
POP LDAkr STHr sext
#0000 EQU2 ?&end.1
#0000 STH2kr #000a ADD2 LDA2 SUB2 STH2kr #000a ADD2 STA2
&end.1
&begin.2
STH2kr #000a ADD2 LDA2 #000a OVR2 OVR2 sdiv/b_pos
MUL2 SUB2 #0030 ADD2 STH2kr #0004 ADD2 STH2kr INC2 INC2 LDA2k #0001 SUB2 SWP2 STA2k
POP2 ADD2 STA
POP STH2kr #000a ADD2 LDA2k #000a sdiv/b_pos
SWP2 STA2
&continue.2
#8000 STH2kr #000a ADD2 LDA2 #8000 EOR2 LTH2 ?&begin.2
&break.2
LDAkr STHr sext
#0000 EQU2 ?&end.3
#002d STH2kr #0004 ADD2 STH2kr INC2 INC2 LDA2k #0001 SUB2 SWP2 STA2k
POP2 ADD2 STA
POP
&end.3
#0006 STH2kr INC2 INC2 LDA2 SUB2 STH2kr #0004 ADD2 STH2kr INC2 INC2 LDA2 ADD2 amcpy_
!&return
#0000
&return
POP2r JMP2r
@int_to_nat_ ( n* -- result* )
OVR2r LIT2r 0002 SUB2r STH2kr STA2
STH2kr LDA2 !&return
#0000
&return
POP2r JMP2r
@nat_to_int_ ( n* -- result* )
OVR2r LIT2r 0002 SUB2r STH2kr STA2
STH2kr LDA2 !&return
#0000
&return
POP2r JMP2r
@int_add_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 ADD2 !&return
#0000
&return
POP2r JMP2r
@int_sub_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 SUB2 !&return
#0000
&return
POP2r JMP2r
@int_mul_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 MUL2 !&return
#0000
&return
POP2r JMP2r
@int_div_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 sdiv
!&return
#0000
&return
POP2r JMP2r
@int_eq_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 EQU2 #00 SWP !&return
#0000
&return
POP2r JMP2r
@int_ne_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 NEQ2 #00 SWP !&return
#0000
&return
POP2r JMP2r
@int_lt_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 #8000 EOR2 STH2kr LDA2 #8000 EOR2 LTH2 #00 SWP !&return
#0000
&return
POP2r JMP2r
@int_le_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 #8000 EOR2 STH2kr LDA2 #8000 EOR2 GTH2 #00 SWP #01 EOR !&return
#0000
&return
POP2r JMP2r
@int_gt_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr LDA2 #8000 EOR2 STH2kr INC2 INC2 LDA2 #8000 EOR2 LTH2 #00 SWP !&return
#0000
&return
POP2r JMP2r
@int_ge_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr LDA2 #8000 EOR2 STH2kr INC2 INC2 LDA2 #8000 EOR2 GTH2 #00 SWP #01 EOR !&return
#0000
&return
POP2r JMP2r
@int_neg_ ( f* -- result* )
OVR2r LIT2r 0002 SUB2r STH2kr STA2
#0000 STH2kr LDA2 SUB2 !&return
#0000
&return
POP2r JMP2r
@int_abs_ ( f* -- result* )
OVR2r LIT2r 0002 SUB2r STH2kr STA2
STH2kr LDA2 #8000 EOR2 #8000 LTH2 ?&then.1
STH2kr LDA2 !&end.1
&then.1
#0000 STH2kr LDA2 SUB2
&end.1
!&return
#0000
&return
POP2r JMP2r
@str/<print> ( str* -- )
LDAk DUP ?{ POP POP2 JMP2r }
#18 DEO
INC2 !/<print>
@mem_length_ #0000
@mem_ @memory $10000

279
test/tal/rw.tal Normal file
View File

@ -0,0 +1,279 @@
|10 @Console/vector $2 &read $5 &type $1 &write $1 &error $1
|100
;on-console .Console/vector DEO2
BRK
@on-console ( -> )
LIT2r 0000
!{ @t $1 } #12 DEI ;t STA2
;t LDA2 #18 DEO POP2r BRK @sext
#80 ANDk EQU #ff MUL SWP JMP2r
@sdiv
OVR #80 AND ?&b_neg &b_pos OVR2 POP #80 AND ?&a_neg_b_pos DIV2 JMP2r &a_neg_b_pos SWP2 #0000 SWP2 SUB2 SWP2 DIV2 #0000 SWP2 SUB2 JMP2r
&b_neg #0000 SWP2 SUB2 OVR2 POP #80 AND ?&a_neg_b_neg DIV2 #0000 SWP2 SUB2 JMP2r
&a_neg_b_neg #0000 ROT2 SUB2 SWP2 DIV2 JMP2r
@aalloc_ ( size* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
;mem_length_ LDA2 STH2kr STA2
;mem_length_ LDA2k STH2kr INC2 INC2 LDA2 ADD2 SWP2 STA2
;mem_ STH2kr LDA2 ADD2 !&return
#0000
&return
POP2r JMP2r
@areturn_ ( size* src* checkpoint* -- result* )
OVR2r LIT2r 000a SUB2r STH2kr #0008 ADD2 STA2
STH2kr #0006 ADD2 STA2
STH2kr #0004 ADD2 STA2
;mem_ STH2kr #0008 ADD2 LDA2 ADD2 STH2kr INC2 INC2 STA2
STH2kr #0006 ADD2 LDA2 STH2kr INC2 INC2 LDA2 NEQ2 ?&end.1
STH2kr #0006 ADD2 LDA2 !&return
&end.1
#0000 STH2kr STA2
&begin.2
STH2kr LDA2 STH2kr #0004 ADD2 LDA2 LTH2 #00 EQU ?&break.2
STH2kr #0006 ADD2 LDA2 STH2kr LDA2 ADD2 LDA sext
STH2kr INC2 INC2 LDA2 STH2kr LDA2 ADD2 STA
POP
&continue.2
STH2kr LDA2k INC2k ROT2 STA2
POP2 !&begin.2
&break.2
STH2kr #0008 ADD2 LDA2 STH2kr #0004 ADD2 LDA2 ADD2 ;mem_length_ STA2
#0000 ;mem_ ;mem_length_ LDA2 ADD2 STA
POP STH2kr INC2 INC2 LDA2 !&return
#0000
&return
POP2r JMP2r
@afree_ ( -- result* )
OVR2r #0000 ;mem_length_ STA2
#0000
&return
POP2r JMP2r
@amcpy_ ( length* from* -- result* )
OVR2r LIT2r 0008 SUB2r STH2kr #0006 ADD2 STA2
STH2kr #0004 ADD2 STA2
STH2kr #0004 ADD2 LDA2 aalloc_
STH2kr INC2 INC2 STA2
#0000 STH2kr STA2
&begin.1
STH2kr LDA2 STH2kr #0004 ADD2 LDA2 LTH2 #00 EQU ?&break.1
STH2kr #0006 ADD2 LDA2 STH2kr LDA2 ADD2 LDA sext
STH2kr INC2 INC2 LDA2 STH2kr LDA2 ADD2 STA
POP
&continue.1
STH2kr LDA2k INC2k ROT2 STA2
POP2 !&begin.1
&break.1
STH2kr INC2 INC2 LDA2 !&return
#0000
&return
POP2r JMP2r
@nat_to_str_ ( n* -- result* )
OVR2r LIT2r 000a SUB2r STH2kr #0008 ADD2 STA2
#0005 STH2kr STA2
&begin.1
STH2kr #0008 ADD2 LDA2 #000a OVR2 OVR2 DIV2 MUL2 SUB2 #0030 ADD2 STH2kr INC2 INC2 STH2kr LDA2k #0001 SUB2 SWP2 STA2k
POP2 ADD2 STA
POP STH2kr #0008 ADD2 LDA2k #000a DIV2 SWP2 STA2
&continue.1
#0000 STH2kr #0008 ADD2 LDA2 LTH2 ?&begin.1
&break.1
#0005 STH2kr LDA2 SUB2 STH2kr INC2 INC2 STH2kr LDA2 ADD2 amcpy_
!&return
#0000
&return
POP2r JMP2r
@int_to_str_ ( n* -- result* )
OVR2r LIT2r 000c SUB2r STH2kr #000a ADD2 STA2
#0006 STH2kr INC2 INC2 STA2
STH2kr #000a ADD2 LDA2 #8000 EOR2 #8000 LTH2 #00 SWP #0000 NEQ2 #00 SWP STH2kr STA
POP LDAkr STHr sext
#0000 EQU2 ?&end.1
#0000 STH2kr #000a ADD2 LDA2 SUB2 STH2kr #000a ADD2 STA2
&end.1
&begin.2
STH2kr #000a ADD2 LDA2 #000a OVR2 OVR2 sdiv/b_pos
MUL2 SUB2 #0030 ADD2 STH2kr #0004 ADD2 STH2kr INC2 INC2 LDA2k #0001 SUB2 SWP2 STA2k
POP2 ADD2 STA
POP STH2kr #000a ADD2 LDA2k #000a sdiv/b_pos
SWP2 STA2
&continue.2
#8000 STH2kr #000a ADD2 LDA2 #8000 EOR2 LTH2 ?&begin.2
&break.2
LDAkr STHr sext
#0000 EQU2 ?&end.3
#002d STH2kr #0004 ADD2 STH2kr INC2 INC2 LDA2k #0001 SUB2 SWP2 STA2k
POP2 ADD2 STA
POP
&end.3
#0006 STH2kr INC2 INC2 LDA2 SUB2 STH2kr #0004 ADD2 STH2kr INC2 INC2 LDA2 ADD2 amcpy_
!&return
#0000
&return
POP2r JMP2r
@int_to_nat_ ( n* -- result* )
OVR2r LIT2r 0002 SUB2r STH2kr STA2
STH2kr LDA2 !&return
#0000
&return
POP2r JMP2r
@nat_to_int_ ( n* -- result* )
OVR2r LIT2r 0002 SUB2r STH2kr STA2
STH2kr LDA2 !&return
#0000
&return
POP2r JMP2r
@int_add_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 ADD2 !&return
#0000
&return
POP2r JMP2r
@int_sub_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 SUB2 !&return
#0000
&return
POP2r JMP2r
@int_mul_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 MUL2 !&return
#0000
&return
POP2r JMP2r
@int_div_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 sdiv
!&return
#0000
&return
POP2r JMP2r
@int_eq_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 EQU2 #00 SWP !&return
#0000
&return
POP2r JMP2r
@int_ne_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 STH2kr LDA2 NEQ2 #00 SWP !&return
#0000
&return
POP2r JMP2r
@int_lt_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 #8000 EOR2 STH2kr LDA2 #8000 EOR2 LTH2 #00 SWP !&return
#0000
&return
POP2r JMP2r
@int_le_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr INC2 INC2 LDA2 #8000 EOR2 STH2kr LDA2 #8000 EOR2 GTH2 #00 SWP #01 EOR !&return
#0000
&return
POP2r JMP2r
@int_gt_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr LDA2 #8000 EOR2 STH2kr INC2 INC2 LDA2 #8000 EOR2 LTH2 #00 SWP !&return
#0000
&return
POP2r JMP2r
@int_ge_ ( b* a* -- result* )
OVR2r LIT2r 0004 SUB2r STH2kr INC2 INC2 STA2
STH2kr STA2
STH2kr LDA2 #8000 EOR2 STH2kr INC2 INC2 LDA2 #8000 EOR2 GTH2 #00 SWP #01 EOR !&return
#0000
&return
POP2r JMP2r
@int_neg_ ( f* -- result* )
OVR2r LIT2r 0002 SUB2r STH2kr STA2
#0000 STH2kr LDA2 SUB2 !&return
#0000
&return
POP2r JMP2r
@int_abs_ ( f* -- result* )
OVR2r LIT2r 0002 SUB2r STH2kr STA2
STH2kr LDA2 #8000 EOR2 #8000 LTH2 ?&then.1
STH2kr LDA2 !&end.1
&then.1
#0000 STH2kr LDA2 SUB2
&end.1
!&return
#0000
&return
POP2r JMP2r
@str/<print> ( str* -- )
LDAk DUP ?{ POP POP2 JMP2r }
#18 DEO
INC2 !/<print>
@mem_length_ #0000
@mem_

1
tests
View File

@ -36,3 +36,4 @@ tests "if.ul" "x is 20" ./cli ./test/if.ul
tests "while.ul" "0123456789" ./cli ./test/while.ul tests "while.ul" "0123456789" ./cli ./test/while.ul
tests "fib.ul" "28657" ./cli ./test/fib.ul tests "fib.ul" "28657" ./cli ./test/fib.ul
tests "attack.ul" "102 damage inflicted!" ./cli ./test/attack.ul tests "attack.ul" "102 damage inflicted!" ./cli ./test/attack.ul
tests "array.ul" "1 2 3 4 5 6 " ./cli ./test/array.ul