akkartik
/
mu
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

7157

This commit is contained in:
Kartik Agaram 2020-11-01 22:17:40 -08:00
parent 34063288c9
commit c8e41a470f
6 changed files with 96 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
apps/arith.mu
View File

@ -31,7 +31,7 @@
#
# Error handling is non-existent. This is just a prototype.
fn main -> exit-status/ebx: int {
fn main -> _/ebx: int {
enable-keyboard-immediate-mode
var look/esi: grapheme <- copy 0 # lookahead
var n/eax: int <- copy 0 # result of each expression
@ -52,19 +52,22 @@ fn main -> exit-status/ebx: int {
loop
}
enable-keyboard-type-mode
exit-status <- copy 0
return 0
}
fn simplify -> result/eax: int, look/esi: grapheme {
fn simplify -> _/eax: int, _2/esi: grapheme {
# prime the pump
look <- get-char
var look/esi: grapheme <- get-char
# do it
var result/eax: int <- copy 0
result, look <- expression look
return result, look
}
fn expression _look: grapheme -> result/eax: int, look/esi: grapheme {
look <- copy _look # should be a no-op
fn expression _look: grapheme -> _/eax: int, _2/esi: grapheme {
var look/esi: grapheme <- copy _look
# read arg
var result/eax: int <- copy 0
result, look <- term look
$expression:loop: {
# while next non-space char in ['+', '-']
@ -103,12 +106,14 @@ fn expression _look: grapheme -> result/eax: int, look/esi: grapheme {
loop
}
look <- skip-spaces look
return result, look
}
fn term _look: grapheme -> result/eax: int, look/esi: grapheme {
look <- copy _look # should be a no-op
fn term _look: grapheme -> _/eax: int, _2/esi: grapheme {
var look/esi: grapheme <- copy _look
# read arg
look <- skip-spaces look
var result/eax: int <- copy 0
result, look <- factor look
$term:loop: {
# while next non-space char in ['*', '/']
@ -146,74 +151,69 @@ fn term _look: grapheme -> result/eax: int, look/esi: grapheme {
}
loop
}
return result, look
}
fn factor _look: grapheme -> result/eax: int, look/esi: grapheme {
$factor:body: {
look <- copy _look # should be a no-op
fn factor _look: grapheme -> _/eax: int, _2/esi: grapheme {
var look/esi: grapheme <- copy _look # should be a no-op
look <- skip-spaces look
# if next char is not '(', parse a number
compare look, 0x28 # '('
{
break-if-=
var result/eax: int <- copy 0
result, look <- num look
break $factor:body
return result, look
}
# otherwise recurse
look <- get-char # '('
var result/eax: int <- copy 0
result, look <- expression look
look <- skip-spaces look
look <- get-char # ')'
} # $factor:body
return result, look
}
fn is-mul-or-div? c: grapheme -> result/eax: boolean {
$is-mul-or-div?:body: {
fn is-mul-or-div? c: grapheme -> _/eax: boolean {
compare c, 0x2a # '*'
{
break-if-!=
result <- copy 1 # true
break $is-mul-or-div?:body
return 1 # true
}
compare c, 0x2f # '/'
{
break-if-!=
result <- copy 1 # true
break $is-mul-or-div?:body
return 1 # true
}
result <- copy 0 # false
} # $is-mul-or-div?:body
return 0 # false
}
fn is-add-or-sub? c: grapheme -> result/eax: boolean {
$is-add-or-sub?:body: {
fn is-add-or-sub? c: grapheme -> _/eax: boolean {
compare c, 0x2b # '+'
{
break-if-!=
result <- copy 1 # true
break $is-add-or-sub?:body
return 1 # true
}
compare c, 0x2d # '-'
{
break-if-!=
result <- copy 1 # true
break $is-add-or-sub?:body
return 1 # true
}
result <- copy 0 # false
} # $is-add-or-sub?:body
return 0 # false
}
fn operator _look: grapheme -> op/ecx: byte, look/esi: grapheme {
op <- copy _look
look <- get-char
fn operator _look: grapheme -> _/ecx: byte, _2/esi: grapheme {
var op/ecx: byte <- copy _look
var look/esi: grapheme <- get-char
return op, look
}
fn num _look: grapheme -> result/eax: int, look/esi: grapheme {
look <- copy _look # should be a no-op
var out/edi: int <- copy 0
fn num _look: grapheme -> _/eax: int, _2/esi: grapheme {
var look/esi: grapheme <- copy _look
var result/edi: int <- copy 0
{
var first-digit/eax: int <- to-decimal-digit look
out <- copy first-digit
result <- copy first-digit
}
{
look <- get-char
@ -221,37 +221,38 @@ fn num _look: grapheme -> result/eax: int, look/esi: grapheme {
var digit?/eax: boolean <- is-decimal-digit? look
compare digit?, 0 # false
break-if-=
# out *= 10
# result *= 10
{
var ten/eax: int <- copy 0xa
out <- multiply ten
result <- multiply ten
}
# out += digit(look)
# result += digit(look)
var digit/eax: int <- to-decimal-digit look
out <- add digit
result <- add digit
loop
}
result <- copy out
return result, look
}
fn skip-spaces _look: grapheme -> look/esi: grapheme {
look <- copy _look # should be a no-op
fn skip-spaces _look: grapheme -> _/esi: grapheme {
var look/esi: grapheme <- copy _look # should be a no-op
{
compare look, 0x20
break-if-!=
look <- get-char
loop
}
return look
}
fn get-char -> look/esi: grapheme {
var tmp/eax: grapheme <- read-key-from-real-keyboard
print-grapheme-to-real-screen tmp
look <- copy tmp
fn get-char -> _/esi: grapheme {
var look/eax: grapheme <- read-key-from-real-keyboard
print-grapheme-to-real-screen look
compare look, 4
{
break-if-!=
print-string 0, "^D\n"
syscall_exit
}
return look
}

27
apps/parse-int.mu
View File

@ -6,8 +6,7 @@
# $ echo $?
# 123
fn main _args: (addr array addr array byte) -> exit-status/ebx: int {
$main-body: {
fn main _args: (addr array addr array byte) -> _/ebx: int {
# if no args, print a message and exit
var args/esi: (addr array addr array byte) <- copy _args
var n/ecx: int <- length args
@ -15,36 +14,34 @@ $main-body: {
{
break-if->
print-string 0, "usage: parse-int <integer>\n"
exit-status <- copy 1
break $main-body
return 1
}
# otherwise parse the first arg as an integer
var in/ecx: (addr addr array byte) <- index args, 1
var out/eax: int <- parse-int *in
exit-status <- copy out
}
return out
}
fn parse-int _in: (addr array byte) -> result/eax: int {
fn parse-int _in: (addr array byte) -> _/eax: int {
var in/esi: (addr array byte) <- copy _in
var len/edx: int <- length in
var i/ecx: int <- copy 0
var out/edi: int <- copy 0
var result/edi: int <- copy 0
{
compare i, len
break-if->=
# out *= 10
# result *= 10
var ten/eax: int <- copy 0xa
out <- multiply ten
result <- multiply ten
# c = in[i]
var tmp/ebx: (addr byte) <- index in, i
var c/eax: byte <- copy 0
c <- copy-byte *tmp
var c/eax: byte <- copy-byte *tmp
#
var digit/eax: int <- to-decimal-digit c
out <- add digit
var g/eax: grapheme <- copy c
var digit/eax: int <- to-decimal-digit g
result <- add digit
i <- increment
loop
}
result <- copy out
return result
}

48
apps/print-file.mu
View File

@ -7,35 +7,33 @@
# $ ./a.elf x
# abc
fn main _args: (addr array addr array byte) -> exit-status/ebx: int {
fn main _args: (addr array addr array byte) -> _/ebx: int {
var args/eax: (addr array addr array byte) <- copy _args
$main-body: {
var n/ecx: int <- length args
compare n, 1
var n/ecx: int <- length args
compare n, 1
{
break-if->
print-string 0, "usage: cat <filename>\n"
return 0
}
{
break-if-<=
var filename/edx: (addr addr array byte) <- index args 1
var in: (handle buffered-file)
{
break-if->
print-string 0, "usage: cat <filename>\n"
break $main-body
var addr-in/eax: (addr handle buffered-file) <- address in
open *filename, 0, addr-in
}
var _in-addr/eax: (addr buffered-file) <- lookup in
var in-addr/ecx: (addr buffered-file) <- copy _in-addr
{
break-if-<=
var filename/edx: (addr addr array byte) <- index args 1
var in: (handle buffered-file)
{
var addr-in/eax: (addr handle buffered-file) <- address in
open *filename, 0, addr-in
}
var _in-addr/eax: (addr buffered-file) <- lookup in
var in-addr/ecx: (addr buffered-file) <- copy _in-addr
{
var c/eax: byte <- read-byte-buffered in-addr
compare c, 0xffffffff # EOF marker
break-if-=
var g/eax: grapheme <- copy c
print-grapheme 0, g
loop
}
var c/eax: byte <- read-byte-buffered in-addr
compare c, 0xffffffff # EOF marker
break-if-=
var g/eax: grapheme <- copy c
print-grapheme 0, g
loop
}
}
exit-status <- copy 0
return 0
}

19
apps/rpn.mu
View File

@ -26,7 +26,7 @@
#
# Error handling is non-existent. This is just a prototype.
fn main -> exit-status/ebx: int {
fn main -> _/ebx: int {
var in-storage: (stream byte 0x100)
var in/esi: (addr stream byte) <- address in-storage
print-string 0, "press ctrl-c or ctrl-d to exit\n"
@ -48,7 +48,7 @@ fn main -> exit-status/ebx: int {
#
loop
}
exit-status <- copy 0
return 0
}
type int-stack {
@ -56,7 +56,7 @@ type int-stack {
top: int
}
fn simplify in: (addr stream byte) -> result/eax: int {
fn simplify in: (addr stream byte) -> _/eax: int {
var word-storage: slice
var word/ecx: (addr slice) <- address word-storage
var stack-storage: int-stack
@ -106,7 +106,8 @@ fn simplify in: (addr stream byte) -> result/eax: int {
push-int-stack stack, n
loop
}
result <- pop-int-stack stack
var result/eax: int <- pop-int-stack stack
return result
}
fn initialize-int-stack _self: (addr int-stack), n: int {
@ -129,21 +130,19 @@ fn push-int-stack _self: (addr int-stack), _val: int {
add-to *top-addr, 1
}
fn pop-int-stack _self: (addr int-stack) -> val/eax: int {
$pop-int-stack:body: {
fn pop-int-stack _self: (addr int-stack) -> _/eax: int {
var self/esi: (addr int-stack) <- copy _self
var top-addr/ecx: (addr int) <- get self, top
{
compare *top-addr, 0
break-if->
val <- copy 0
break $pop-int-stack:body
return 0
}
subtract-from *top-addr, 1
var data-ah/edx: (addr handle array int) <- get self, data
var data/eax: (addr array int) <- lookup *data-ah
var top/edx: int <- copy *top-addr
var result-addr/eax: (addr int) <- index data, top
val <- copy *result-addr
}
var val/eax: int <- copy *result-addr
return val
}

4
apps/texture.mu
View File

@ -6,7 +6,7 @@
# $ ./translate_mu apps/texture.mu
# $ ./a.elf > a.ppm
fn main -> exit-status/ebx: int {
fn main -> _/ebx: int {
#? var width/esi: int <- copy 0x190 # 400
#? var height/edi: int <- copy 0xe1 # 225; aspect ratio 16:9
var width/esi: int <- copy 0xff
@ -54,5 +54,5 @@ fn main -> exit-status/ebx: int {
row <- increment
loop
}
exit-status <- copy 0
return 0
}

4
apps/tui.mu
View File

@ -4,7 +4,7 @@
# $ ./translate_mu apps/tui.mu
# $ ./a.elf
fn main -> exit-status/ebx: int {
fn main -> _/ebx: int {
var nrows/eax: int <- copy 0
var ncols/ecx: int <- copy 0
nrows, ncols <- screen-size 0
@ -30,5 +30,5 @@ fn main -> exit-status/ebx: int {
var x-int/eax: int <- copy x
print-int32-hex 0, x-int
print-string 0, "\n"
exit-status <- copy 0
return 0
}