From fbc4544ff81141980619cd40ed000b746f07e3d0 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Sun, 28 Jun 2020 08:49:08 -0700 Subject: 6581 --- apps/mu | Bin 325809 -> 329706 bytes apps/mu.subx | 265 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 259 insertions(+), 6 deletions(-) diff --git a/apps/mu b/apps/mu index ce04f14c..f024b58b 100755 Binary files a/apps/mu and b/apps/mu differ diff --git a/apps/mu.subx b/apps/mu.subx index 571c9faf..46709fba 100644 --- a/apps/mu.subx +++ b/apps/mu.subx @@ -4925,6 +4925,199 @@ test-get-with-wrong-offset-type: 5d/pop-to-ebp c3/return +test-get-with-too-few-inouts: + # . prologue + 55/push-ebp + 89/<- %ebp 4/r32/esp + # setup + (clear-stream _test-input-stream) + (clear-stream $_test-input-buffered-file->buffer) + (clear-stream _test-output-stream) + (clear-stream $_test-output-buffered-file->buffer) + (clear-stream _test-error-stream) + (clear-stream $_test-error-buffered-file->buffer) + # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 68/push 0/imm32 + 68/push 0/imm32 + 89/<- %edx 4/r32/esp + (tailor-exit-descriptor %edx 0x10) + # + (write _test-input-stream "fn foo {\n") + (write _test-input-stream " var a: t\n") + (write _test-input-stream " var c/ecx: (addr int) <- get a\n") + (write _test-input-stream "}\n") + (write _test-input-stream "type t {\n") + (write _test-input-stream " x: int\n") + (write _test-input-stream "}\n") + # convert + (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + # registers except esp clobbered at this point + # restore ed + 89/<- %edx 4/r32/esp + (flush _test-output-buffered-file) + (flush _test-error-buffered-file) +#? # dump _test-error-stream {{{ +#? (write 2 "^") +#? (write-stream 2 _test-error-stream) +#? (write 2 "$\n") +#? (rewind-stream _test-error-stream) +#? # }}} + # check output + (check-stream-equal _test-output-stream "" "F - test-get-with-too-few-inouts: output should be empty") + (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too few inouts (2 required)" "F - test-get-with-too-few-inouts: error message") + # check that stop(1) was called + (check-ints-equal *(edx+4) 2 "F - test-get-with-too-few-inouts: exit status") + # don't restore from ebp + 81 0/subop/add %esp 8/imm32 + # . epilogue + 5d/pop-to-ebp + c3/return + +test-get-with-too-many-inouts: + # . prologue + 55/push-ebp + 89/<- %ebp 4/r32/esp + # setup + (clear-stream _test-input-stream) + (clear-stream $_test-input-buffered-file->buffer) + (clear-stream _test-output-stream) + (clear-stream $_test-output-buffered-file->buffer) + (clear-stream _test-error-stream) + (clear-stream $_test-error-buffered-file->buffer) + # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 68/push 0/imm32 + 68/push 0/imm32 + 89/<- %edx 4/r32/esp + (tailor-exit-descriptor %edx 0x10) + # + (write _test-input-stream "fn foo {\n") + (write _test-input-stream " var a: t\n") + (write _test-input-stream " var c/ecx: (addr int) <- get a, x, 0\n") + (write _test-input-stream "}\n") + (write _test-input-stream "type t {\n") + (write _test-input-stream " x: int\n") + (write _test-input-stream "}\n") + # convert + (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + # registers except esp clobbered at this point + # restore ed + 89/<- %edx 4/r32/esp + (flush _test-output-buffered-file) + (flush _test-error-buffered-file) +#? # dump _test-error-stream {{{ +#? (write 2 "^") +#? (write-stream 2 _test-error-stream) +#? (write 2 "$\n") +#? (rewind-stream _test-error-stream) +#? # }}} + # check output + (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-inouts: output should be empty") + (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many inouts (2 required)" "F - test-get-with-too-many-inouts: error message") + # check that stop(1) was called + (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-inouts: exit status") + # don't restore from ebp + 81 0/subop/add %esp 8/imm32 + # . epilogue + 5d/pop-to-ebp + c3/return + +test-get-with-no-output: + # . prologue + 55/push-ebp + 89/<- %ebp 4/r32/esp + # setup + (clear-stream _test-input-stream) + (clear-stream $_test-input-buffered-file->buffer) + (clear-stream _test-output-stream) + (clear-stream $_test-output-buffered-file->buffer) + (clear-stream _test-error-stream) + (clear-stream $_test-error-buffered-file->buffer) + # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 68/push 0/imm32 + 68/push 0/imm32 + 89/<- %edx 4/r32/esp + (tailor-exit-descriptor %edx 0x10) + # + (write _test-input-stream "fn foo {\n") + (write _test-input-stream " var a: t\n") + (write _test-input-stream " get a, x\n") + (write _test-input-stream "}\n") + (write _test-input-stream "type t {\n") + (write _test-input-stream " x: int\n") + (write _test-input-stream "}\n") + # convert + (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + # registers except esp clobbered at this point + # restore ed + 89/<- %edx 4/r32/esp + (flush _test-output-buffered-file) + (flush _test-error-buffered-file) +#? # dump _test-error-stream {{{ +#? (write 2 "^") +#? (write-stream 2 _test-error-stream) +#? (write 2 "$\n") +#? (rewind-stream _test-error-stream) +#? # }}} + # check output + (check-stream-equal _test-output-stream "" "F - test-get-with-no-output: output should be empty") + (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: must have an output" "F - test-get-with-no-output: error message") + # check that stop(1) was called + (check-ints-equal *(edx+4) 2 "F - test-get-with-no-output: exit status") + # don't restore from ebp + 81 0/subop/add %esp 8/imm32 + # . epilogue + 5d/pop-to-ebp + c3/return + +test-get-with-too-many-outputs: + # . prologue + 55/push-ebp + 89/<- %ebp 4/r32/esp + # setup + (clear-stream _test-input-stream) + (clear-stream $_test-input-buffered-file->buffer) + (clear-stream _test-output-stream) + (clear-stream $_test-output-buffered-file->buffer) + (clear-stream _test-error-stream) + (clear-stream $_test-error-buffered-file->buffer) + # var ed/edx: exit-descriptor = tailor-exit-descriptor(16) + 68/push 0/imm32 + 68/push 0/imm32 + 89/<- %edx 4/r32/esp + (tailor-exit-descriptor %edx 0x10) + # + (write _test-input-stream "fn foo {\n") + (write _test-input-stream " var a: t\n") + (write _test-input-stream " var b: int\n") + (write _test-input-stream " a, b <- get a, x\n") + (write _test-input-stream "}\n") + (write _test-input-stream "type t {\n") + (write _test-input-stream " x: int\n") + (write _test-input-stream "}\n") + # convert + (convert-mu _test-input-buffered-file _test-output-buffered-file _test-error-buffered-file %edx) + # registers except esp clobbered at this point + # restore ed + 89/<- %edx 4/r32/esp + (flush _test-output-buffered-file) + (flush _test-error-buffered-file) +#? # dump _test-error-stream {{{ +#? (write 2 "^") +#? (write-stream 2 _test-error-stream) +#? (write 2 "$\n") +#? (rewind-stream _test-error-stream) +#? # }}} + # check output + (check-stream-equal _test-output-stream "" "F - test-get-with-too-many-outputs: output should be empty") + (check-next-stream-line-equal _test-error-stream "fn foo: stmt get: too many outputs (1 required)" "F - test-get-with-too-many-outputs: error message") + # check that stop(1) was called + (check-ints-equal *(edx+4) 2 "F - test-get-with-too-many-outputs: exit status") + # don't restore from ebp + 81 0/subop/add %esp 8/imm32 + # . epilogue + 5d/pop-to-ebp + c3/return + test-convert-array-of-user-defined-types: # . prologue 55/push-ebp @@ -9493,7 +9686,7 @@ populate-mu-type-offsets: # in: (addr typeinfo), err: (addr buffered-file), ed: { $populate-mu-type-offsets:loop: 39/compare %ebx 2/r32/edx - 7d/jump-if->= break/disp8 + 0f 8d/jump-if->= break/disp32 #? (write-buffered Stderr "looking up index ") #? (print-int32-buffered Stderr %ebx) #? (write-buffered Stderr " in ") @@ -9503,6 +9696,9 @@ $populate-mu-type-offsets:loop: # var v/esi: (addr typeinfo-entry) (locate-typeinfo-entry-with-index %ecx %ebx *(ebp+0xc) *(ebp+0x10)) # => eax 89/<- %esi 0/r32/eax + # if v is null, silently move on; we'll emit a nice error message while type-checking + 81 7/subop/compare %esi 0/imm32 # Typeinfo-entry-input-var + 74/jump-if-= $populate-mu-type-offsets:end/disp8 # if (v->input-var == 0) silently ignore v; we'll emit a nice error message while type-checking 81 7/subop/compare *esi 0/imm32 # Typeinfo-entry-input-var 74/jump-if-= $populate-mu-type-offsets:end/disp8 @@ -9516,7 +9712,7 @@ $populate-mu-type-offsets:loop: 01/add-to %edi 0/r32/eax # ++i 43/increment-ebx - eb/jump loop/disp8 + e9/jump loop/disp32 } $populate-mu-type-offsets:end: # . restore registers @@ -10063,29 +10259,46 @@ check-mu-get-stmt: # stmt: (addr stmt), fn: (addr function), err: (addr buffere 57/push-edi # esi = stmt 8b/-> *(ebp+8) 6/r32/esi - # TODO: check >0 inouts + # - check for 0 inouts # var base/ebx: (addr stmt-var) = stmt->inouts->value (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax 89/<- %ebx 0/r32/eax - # if base is a non-container, error + 3d/compare-eax-and 0/imm32/false + 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 + # - check base type (container-type %ebx) # => eax (is-container? %eax) # => eax 3d/compare-eax-and 0/imm32/false 0f 84/jump-if-= $check-mu-get-stmt:error-bad-base/disp32 - # TODO: check >1 inouts # var offset/ecx: (addr var) = stmt->inouts->next->value (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax + # - check for 1 inout + 3d/compare-eax-and 0/imm32/false + 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-inouts/disp32 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax 89/<- %ecx 0/r32/eax 81 7/subop/compare *(ecx+0x14) -1/imm32/uninitialized # Var-offset 0f 84/jump-if-= $check-mu-get-stmt:error-bad-field/disp32 - # TODO: check >0 outputs + # - check for too many inouts + (lookup *(esi+0xc) *(esi+0x10)) # Stmt1-inouts Stmt1-inouts => eax + (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax + (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax + 3d/compare-eax-and 0/imm32/false + 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-inouts/disp32 # var output/edi: (addr var) = stmt->outputs->value (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax + # - check for 0 outputs + 3d/compare-eax-and 0/imm32/false + 0f 84/jump-if-= $check-mu-get-stmt:error-too-few-outputs/disp32 (lookup *eax *(eax+4)) # Stmt-var-value Stmt-var-value => eax 89/<- %edi 0/r32/eax # TODO: check output type + # - check for too many outputs + (lookup *(esi+0x14) *(esi+0x18)) # Stmt1-outputs Stmt1-outputs => eax + (lookup *(eax+8) *(eax+0xc)) # Stmt-var-next Stmt-var-next => eax + 3d/compare-eax-and 0/imm32/false + 0f 85/jump-if-!= $check-mu-get-stmt:error-too-many-outputs/disp32 $check-mu-get-stmt:end: # . restore registers 5f/pop-to-edi @@ -10098,6 +10311,46 @@ $check-mu-get-stmt:end: 5d/pop-to-ebp c3/return +$check-mu-get-stmt:error-too-few-inouts: + (write-buffered *(ebp+0x10) "fn ") + 8b/-> *(ebp+0xc) 0/r32/eax + (lookup *eax *(eax+4)) # Function-name Function-name => eax + (write-buffered *(ebp+0x10) %eax) + (write-buffered *(ebp+0x10) ": stmt get: too few inouts (2 required)\n") + (flush *(ebp+0x10)) + (stop *(ebp+0x14) 1) + # never gets here + +$check-mu-get-stmt:error-too-many-inouts: + (write-buffered *(ebp+0x10) "fn ") + 8b/-> *(ebp+0xc) 0/r32/eax + (lookup *eax *(eax+4)) # Function-name Function-name => eax + (write-buffered *(ebp+0x10) %eax) + (write-buffered *(ebp+0x10) ": stmt get: too many inouts (2 required)\n") + (flush *(ebp+0x10)) + (stop *(ebp+0x14) 1) + # never gets here + +$check-mu-get-stmt:error-too-few-outputs: + (write-buffered *(ebp+0x10) "fn ") + 8b/-> *(ebp+0xc) 0/r32/eax + (lookup *eax *(eax+4)) # Function-name Function-name => eax + (write-buffered *(ebp+0x10) %eax) + (write-buffered *(ebp+0x10) ": stmt get: must have an output\n") + (flush *(ebp+0x10)) + (stop *(ebp+0x14) 1) + # never gets here + +$check-mu-get-stmt:error-too-many-outputs: + (write-buffered *(ebp+0x10) "fn ") + 8b/-> *(ebp+0xc) 0/r32/eax + (lookup *eax *(eax+4)) # Function-name Function-name => eax + (write-buffered *(ebp+0x10) %eax) + (write-buffered *(ebp+0x10) ": stmt get: too many outputs (1 required)\n") + (flush *(ebp+0x10)) + (stop *(ebp+0x14) 1) + # never gets here + $check-mu-get-stmt:error-bad-base: # error("fn " fn ": stmt get: var '" base->name "' must have a 'type' definition\n") (write-buffered *(ebp+0x10) "fn ") -- cgit 1.4.1-2-gfad0