lassik
/
upscheme
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
upscheme/flisp.boot

470 lines
39 KiB
Plaintext
Raw Normal View History

adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
(*banner* "; _\n; |_ _ _ |_ _ | . _ _\n; | (-||||_(_)|__|_)|_)\n;-------------------|----------------------------------------------------------\n\n"
porting over some improvements: now fl_applyn can handle any function (lambda wrappers for opcodes) faster separate
2010-05-05 01:31:46 -04:00
*builtins* [0 0 0 0 0 0 0 0 0 0 0 0 #fn("7000r2|}<;" [])
#fn("7000r2|}=;" [])
#fn("7000r2|}>;" [])
#fn("6000r1|?;" [])
#fn("6000r1|@;" [])
#fn("6000r1|A;" [])
#fn("6000r1|B;" [])
#fn("6000r1|C;" [])
#fn("6000r1|D;" [])
#fn("6000r1|E;" [])
#fn("6000r1|F;" [])
#fn("6000r1|G;" [])
#fn("6000r1|H;" [])
#fn("6000r1|I;" [])
#fn("6000r1|J;" [])
#fn("7000r2|}K;" [])
simpler proxy function for list builtin
2013-06-11 17:58:15 -04:00
#fn("8000s0|;" []) #fn("6000r1|M;" [])
porting over some improvements: now fl_applyn can handle any function (lambda wrappers for opcodes) faster separate
2010-05-05 01:31:46 -04:00
#fn("6000r1|N;" [])
#fn("7000r2|}O;" [])
#fn("7000r2|}P;" [])
#fn("9000s0c0|v2;" [#.apply])
#fn("9000s0c0|v2;" [#.+])
#fn("9000s0c0|v2;" [#.-])
#fn("9000s0c0|v2;" [#.*])
#fn("9000s0c0|v2;" [#./])
#fn("9000s0c0|v2;" [#.div0])
#fn("7000r2|}W;" [])
#fn("7000r2|}X;" [])
#fn("7000r2|}Y;" [])
#fn("9000s0c0|v2;" [#.vector])
#fn("7000r2|}[;" [])
#fn("8000r3|}g2\\;" [])]
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
*interactive* #f *syntax-environment*
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#table(with-bindings #fn(">000s1c0qc1c2|32c1e3|32c1c4|3243;" [#fn("B000r3c0c1L1c2c3g2|33L1c4c2c5|}3331c6c0c7L1c4\x7f3132c0c7L1c4c2c8|g2333132L3L144;" [#fn(nconc)
let #fn(map) #.list #fn(copy-list) #fn("8000r2c0|}L3;" [set!]) unwind-protect
begin #fn("8000r2c0|}L3;" [set!])]) #fn(map) #.car cadr #fn("6000r1c040;" [#fn(gensym)])]) letrec #fn("?000s1c0c0c1L1c2c3|32L1c2c4|32c5}3134L1c2c6|3242;" [#fn(nconc)
lambda #fn(map) #.car #fn("9000r1c0c1L1c2|3142;" [#fn(nconc) set! #fn(copy-list)])
#fn(copy-list) #fn("6000r1e040;" [void])]) assert #fn("<000r1c0|]c1c2c3|L2L2L2L4;" [if
raise quote assert-failed]) do #fn("A000s2c0qc130}Mc2c3|32c2e4|32c2c5|3245;" [#fn("B000r5c0|c1g2c2}c3c4L1c5\x7fN3132c3c4L1c5i0231c3|L1g432L133L4L3L2L1c3|L1g332L3;" [letrec
lambda if #fn(nconc) begin #fn(copy-list)])
#fn(gensym) #fn(map) #.car cadr #fn("7000r1e0|31F680e1|41;|M;" [cddr caddr])]) quasiquote #fn("8000r1e0|`42;" [bq-process]) when #fn("<000s1c0|c1}K^L4;" [if
begin]) with-input-from #fn("=000s1c0c1L1c2|L2L1L1c3}3143;" [#fn(nconc)
porting over some improvements: now fl_applyn can handle any function (lambda wrappers for opcodes) faster separate
2010-05-05 01:31:46 -04:00
with-bindings
*input-stream*
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn(copy-list)]) unwind-protect #fn("8000r2c0qc130c13042;" [#fn("@000r2c0}c1_\x7fL3L2L1c2c3~c1|L1c4}L1c5|L2L3L3L3}L1L3L3;" [let
lambda prog1 trycatch begin raise]) #fn(gensym)]) dotimes #fn(";000s1c0q|M|\x8442;" [#fn("=000r2c0`c1}aL3c2c3L1|L1L1c4\x7f3133L4;" [for
- #fn(nconc) lambda #fn(copy-list)])]) define-macro #fn("?000s1c0c1|ML2c2c3L1|NL1c4}3133L3;" [set-syntax!
quote #fn(nconc) lambda #fn(copy-list)]) receive #fn("@000s2c0c1_}L3c2c1L1|L1c3g23133L3;" [call-with-values
lambda #fn(nconc) #fn(copy-list)]) unless #fn("=000s1c0|^c1}KL4;" [if begin]) let #fn(":000s1c0q^41;" [#fn("<000r1~C6D0~m02\x7fMo002\x7fNo01530]2c0qc1c2L1c3c4~32L1c5\x7f3133c3c6~3242;" [#fn("8000r2~6@0c0~|L2L1~L3530|}K;" [letrec])
#fn(nconc) lambda #fn(map) #fn("6000r1|F650|M;|;" [])
#fn(copy-list) #fn("6000r1|F650|\x84;e040;" [void])])]) cond #fn("9000s0c0q]41;" [#fn("7000r1c0qm02|~41;" [#fn("7000r1|?640^;c0q|M41;" [#fn(":000r1|Mc0<17702|M]<6@0|N\x8550|M;c1|NK;|N\x85@0c2|Mi10~N31L3;|\x84c3\x82W0e4e5|31316A0c6qe7e5|313141;c8qc93041;c:|Mc1|NKi10~N31L4;" [else
adding => form of cond clauses adding path.exists? R6RS psyntax simple example now works
2009-08-13 23:17:21 -04:00
begin or => 1arg-lambda? caddr #fn("=000r1c0|~ML2L1c1|c2e3e4~3131Ki20i10N31L4L3;" [let
if begin cddr caddr]) caadr #fn("<000r1c0|~ML2L1c1|e2~31|L2i20i10N31L4L3;" [let
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
if caddr]) #fn(gensym) if])] cond-clauses->if)])]) throw #fn(":000r2c0c1c2c3L2|}L4L2;" [raise
list quote thrown-value]) time #fn("7000r1c0qc13041;" [#fn(">000r1c0|c1L1L2L1c2~c3c4c5c1L1|L3c6L4L3L3;" [let
time.now prog1 princ "Elapsed time: " - " seconds\n"])
#fn(gensym)]) let* #fn("A000s1|?6E0c0c1L1_L1c2}3133L1;c0c1L1e3|31L1L1c2|NF6H0c0c4L1|NL1c2}3133L1530}3133e5|31L2;" [#fn(nconc)
lambda #fn(copy-list) caar let* cadar]) case #fn(":000s1c0q]41;" [#fn("7000r1c0m02c1qc23041;" [#fn("9000r2}c0\x8250c0;}\x8540^;}C6=0c1|e2}31L3;}?6=0c3|e2}31L3;}N\x85>0c3|e2}M31L3;e4c5}326=0c6|c7}L2L3;c8|c7}L2L3;" [else
porting over some improvements: now fl_applyn can handle any function (lambda wrappers for opcodes) faster separate
2010-05-05 01:31:46 -04:00
eq? quote-value eqv? every #.symbol? memq quote memv] vals->cond)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("<000r1c0|i10L2L1c1c2L1c3c4qi113232L3;" [let #fn(nconc) cond #fn(map)
#fn("8000r1i10~|M32|NK;" [])])
#fn(gensym)])]) with-output-to #fn("=000s1c0c1L1c2|L2L1L1c3}3143;" [#fn(nconc)
with-bindings *output-stream* #fn(copy-list)]) catch #fn("7000r2c0qc13041;" [#fn("@000r1c0\x7fc1|L1c2c3c4|L2c5c6|L2c7c8L2L3c5c9|L2~L3L4c:|L2c;|L2L4L3L3;" [trycatch
lambda if and pair? eq car quote thrown-value cadr caddr raise])
#fn(gensym)]))
making os name symbols non-constant, so they aren't evaluated at compile time more aliases
2009-10-21 23:32:12 -04:00
*whitespace* "\t\n\v\f\r \u0085  ᠎           \u2028\u2029  　" 1+
#fn("7000r1|aw;" [] 1+) 1- #fn("7000r1|ax;" [] 1-) 1arg-lambda?
#fn("8000r1|F16T02|Mc0<16J02|NF16B02|\x84F16:02e1|\x84a42;" [lambda
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
length=] 1arg-lambda?)
fix #24, make `<=` and `>=` work on strings
2016-09-17 14:30:05 -04:00
<= #fn("7000r2}|X17B02e0|3116802e0}31@;" [nan?] <=) >
#fn("7000r2}|X;" [] >) >= #fn("7000r2|}X17B02e0|3116802e0}31@;" [nan?] >=)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
Instructions #table(not 16 vargc 67 load1 49 = 39 setc.l 64 sub2 72 brne.l 83 largc 74 brnn 85 loadc.l 58 loadi8 50 < 40 nop 0 set-cdr! 32 loada 55 bound? 21 / 37 neg 73 brn.l 88 lvargc 75 brt 7 trycatch 68 null? 17 load0 48 jmp.l 8 loadv 51 seta 61 keyargs 91 * 36 function? 26 builtin? 23 aref 43 optargs 89 vector? 24 loadt 45 brf 6 symbol? 19 cdr 30 for 69 loadc00 78 pop 2 pair? 22 cadr 84 closure 65 loadf 46 compare 41 loadv.l 52 setg.l 60 brn 87 eqv? 13 aset! 44 eq? 12 atom? 15 boolean? 18 brt.l 10 tapply 70 dummy_nil 94 loada0 76 brbound 90 list 28 dup 1 apply 33 loadc 57 loadc01 79 dummy_t 92 setg 59 loada1 77 tcall.l 81 jmp 5 fixnum? 25 cons 27 loadg.l 54 tcall 4 call 3 - 35 brf.l 9 + 34 dummy_f 93 add2 71 seta.l 62 loadnil 47 brnn.l 86 setc 63 set-car! 31 vector 42 loadg 53 loada.l 56 argc 66 div0 38 ret 11 number? 20 equal? 14 car 29 call.l 80 brne 82)
fixing char comparison bug accepting more numeric types in vector.alloc adding more aliases
2009-11-18 12:38:16 -05:00
__init_globals #fn("7000r0e0c1<17B02e0c2<17802e0c3<6>0c4k52c6k75;0c8k52c9k72e:k;2e<k=2e>k?;" [*os-name*
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
win32 win64 windows "\\" *directory-separator* "\r\n" *linefeed* "/" "\n"
*stdout* *output-stream* *stdin* *input-stream* *stderr* *error-stream*] __init_globals)
__script #fn("7000r1c0qc1t;" [#fn("7000r0e0~41;" [load])
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("7000r1e0|312c1a41;" [top-level-exception-handler
#fn(exit)])] __script)
__start #fn("8000r1e0302|NF6D0|Nk12^k22e3|\x84315E0|k12]k22e4e5312e6302c7`41;" [__init_globals
*argv* *interactive* __script princ *banner* repl #fn(exit)] __start)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
abs #fn("7000r1|`X650|y;|;" [] abs) any
fix a bug in map faster delete-duplicates for long lists
2013-02-11 04:48:21 -05:00
#fn("8000r2}F16D02|}M3117:02e0|}N42;" [any] any) arg-counts #table(#.equal? 2 #.atom? 1 #.set-cdr! 2 #.symbol? 1 #.car 1 #.eq? 2 #.aref 2 #.boolean? 1 #.not 1 #.null? 1 #.eqv? 2 #.number? 1 #.pair? 1 #.builtin? 1 #.aset! 3 #.div0 2 #.= 2 #.bound? 1 #.compare 2 #.vector? 1 #.cdr 1 #.set-car! 2 #.< 2 #.fixnum? 1 #.cons 2)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
argc-error #fn("<000r2e0c1|c2}}aW670c3540c445;" [error "compile error: "
" expects " " argument."
" arguments."] argc-error)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
array? #fn("8000r1|H17<02c0c1|3141;" [#fn("7000r1|F16802|Mc0<;" [array])
#fn(typeof)] array?)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
assoc #fn("8000r2}?640^;e0}31|>650}M;e1|}N42;" [caar assoc] assoc)
assv #fn("8000r2}?640^;e0}31|=650}M;e1|}N42;" [caar assv] assv)
bcode:cdepth #fn(":000r2|b3e0|b3[}32\\;" [min] bcode:cdepth)
bcode:code #fn("7000r1|`[;" [] bcode:code) bcode:ctable
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("7000r1|a[;" [] bcode:ctable) bcode:indexfor #fn("9000r2c0qe1|31e2|3142;" [#fn(":000r2c0|\x7f32690c1|\x7f42;c2|\x7f}332}~b2}aw\\2;" [#fn(has?)
#fn(get) #fn(put!)]) bcode:ctable bcode:nconst] bcode:indexfor)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
bcode:nconst #fn("7000r1|b2[;" [] bcode:nconst) bq-bracket
improved implementation of backquote
2011-04-10 23:24:30 -04:00
#fn("<000r2|?6=0c0e1|}32L2;|Mc2\x82R0}`W680c0|NK;c0c3c4e1|N}ax32L3L2;|Mc5\x82S0}`W690c6|\x84L2;c0c0c7e1|\x84}ax32L3L2;|Mc8\x82O0}`W650|\x84;c0c0c9e1|\x84}ax32L3L2;c0e1|}32L2;" [#.list
bq-process unquote #.cons 'unquote unquote-splicing copy-list 'unquote-splicing
unquote-nsplicing 'unquote-nsplicing] bq-bracket)
bq-bracket1 #fn(";000r2|F16802|Mc0<6K0}`W650|\x84;c1c2e3|N}ax32L3;e3|}42;" [unquote
#.cons 'unquote bq-process] bq-bracket1)
fix a small bug in quasiquote
2015-02-15 17:09:40 -05:00
bq-process #fn(";000r2|C680c0|L2;|H6A0c1e2e3|31}3241;|?640|;|Mc4\x82B0c5c6e2|\x84}aw32L3;|Mc7\x82W0}`W16:02e8|b232650|\x84;c9c:e2|N}ax32L3;e;e<|327E0c=qe>|31c?c@q|3242;cAq]31|_42;" [quote
improved implementation of backquote
2011-04-10 23:24:30 -04:00
#fn("8000r1|Mc0\x8280c1|NK;c2c1|L3;" [#.list #.vector #.apply]) bq-process
fix a small bug in quasiquote
2015-02-15 17:09:40 -05:00
vector->list quasiquote #.list 'quasiquote unquote length= #.cons 'unquote
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
any splice-form? #fn(":000r2|\x8570c0}K;}N\x85?0c1}Me2|\x7f32L3;c3c4}Ke2|\x7f32L142;" [#.list
#.cons bq-process #fn(nconc) #fn(list*)]) lastcdr #fn(map)
#fn("8000r1e0|\x7f42;" [bq-bracket1]) #fn("6000r1c0qm02|;" [#fn(">000r2|\x85;0c0e1}31K;|F6s0|Mc2\x82[0c0e3}i11`W670|N5E0c4c5L2e6|Ni11ax32L232K;~|Ne7|Mi1132}K42;c0e1e6|i1132}K31K;" [nconc
improved implementation of backquote
2011-04-10 23:24:30 -04:00
reverse! unquote nreconc #.list 'unquote bq-process bq-bracket])])] bq-process)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
builtin->instruction #fn("9000r1c0~|^43;" [#fn(get)] [#table(#.equal? equal? #.* * #.car car #.apply apply #.aref aref #.- - #.boolean? boolean? #.builtin? builtin? #.null? null? #.eqv? eqv? #.function? function? #.bound? bound? #.cdr cdr #.list list #.set-car! set-car! #.cons cons #.atom? atom? #.set-cdr! set-cdr! #.symbol? symbol? #.eq? eq? #.vector vector #.not not #.pair? pair? #.number? number? #.div0 div0 #.aset! aset! #.+ + #.= = #.compare compare #.vector? vector? #./ / #.< < #.fixnum? fixnum?)
()])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
caaaar #fn("6000r1|MMMM;" [] caaaar) caaadr
#fn("6000r1|\x84MM;" [] caaadr) caaar #fn("6000r1|MMM;" [] caaar)
caadar #fn("6000r1|M\x84M;" [] caadar) caaddr
#fn("6000r1|N\x84M;" [] caaddr) caadr #fn("6000r1|\x84M;" [] caadr)
caar #fn("6000r1|MM;" [] caar) cadaar
#fn("6000r1|MM\x84;" [] cadaar) cadadr #fn("6000r1|\x84\x84;" [] cadadr)
cadar #fn("6000r1|M\x84;" [] cadar) caddar
#fn("6000r1|MN\x84;" [] caddar) cadddr #fn("6000r1|NN\x84;" [] cadddr)
caddr #fn("6000r1|N\x84;" [] caddr) cadr
some critical bug fixes
2010-05-04 14:17:55 -04:00
#fn("6000r1|\x84;" [] cadr) call-with-values #fn("7000r2c0q|3041;" [#fn("7000r1|F16902i10|M<680\x7f|Nv2;\x7f|41;" [])] #2=[(*values*)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
()])
cdaaar #fn("6000r1|MMMN;" [] cdaaar) cdaadr
#fn("6000r1|\x84MN;" [] cdaadr) cdaar #fn("6000r1|MMN;" [] cdaar)
cdadar #fn("6000r1|M\x84N;" [] cdadar) cdaddr
#fn("6000r1|N\x84N;" [] cdaddr) cdadr #fn("6000r1|\x84N;" [] cdadr)
cdar #fn("6000r1|MN;" [] cdar) cddaar
#fn("6000r1|MMNN;" [] cddaar) cddadr #fn("6000r1|\x84NN;" [] cddadr)
cddar #fn("6000r1|MNN;" [] cddar) cdddar
#fn("6000r1|MNNN;" [] cdddar) cddddr #fn("6000r1|NNNN;" [] cddddr)
cdddr #fn("6000r1|NNN;" [] cdddr) cddr
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("6000r1|NN;" [] cddr) char? #fn("7000r1c0|31c1<;" [#fn(typeof)
wchar] char?)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
closure? #fn("7000r1|J16602|G@;" [] closure?) compile
#fn("8000r1e0_|42;" [compile-f] compile) compile-and #fn("<000r4e0|}g2g3]c146;" [compile-short-circuit
brf] compile-and)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
compile-app #fn("7000r4c0qg3M41;" [#fn("9000r1c0q|C16V02e1|\x7f32@16J02|E16C02c2|3116902c3|31G6:0c3|31530|41;" [#fn(":000r1e0i13Nc1326S0e2i10i11^|342c3qe4i10i11i13N3341;c5q|G16802e6|3141;" [length>
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
255 compile-in #fn(":000r1e0i20i22670c1540c2|43;" [emit tcall.l call.l])
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
compile-arglist #fn(";000r1~c0<16X02e1~i2132@16J02c2c031e0>16<02e3i23b2326L0e4i20i21^i23\x84342e5i20c042;|7A0e4i20i21^~34530]2c6qe7i20i21i23N3341;" [cadr
in-env? #fn(top-level-value) length= compile-in emit #fn("=000r1~6H0e0i30i31i32i33i10~|47;e1i30i32670c2540c3|43;" [compile-builtin-call
emit tcall call]) compile-arglist]) builtin->instruction]) in-env? #fn(constant?)
#fn(top-level-value)])] compile-app)
compile-arglist #fn("8000r3e0c1qg2322c2g241;" [for-each #fn(":000r1e0~\x7f^|44;" [compile-in])
#fn(length)] compile-arglist)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
compile-begin #fn(":000r4g3?6?0e0|}g2e13044;g3N?6>0e0|}g2g3M44;e0|}^g3M342e2|c3322e4|}g2g3N44;" [compile-in
void emit pop compile-begin] compile-begin)
fix lack of error when calling builtins with the wrong number of args
2013-08-26 16:55:17 -04:00
compile-builtin-call #fn(":000r7c0qc1e2g4^3341;" [#fn("8000r1|16=02e0i03N|32@6=0e1i05|32530]2c2qi0541;" [length=
argc-error #fn(":000r1|c0\x82R0i16`W6<0e1i10c242;e1i10i15i1643;|c3\x82e0i16`W6<0e1i10c442;i16b2W6<0e1i10c542;e1i10i15i1643;|c6\x82v0i16`W6;0e7i15a42;i16aW6<0e1i10c842;i16b2W6<0e1i10c942;e1i10i15i1643;|c:\x82R0i16`W6<0e1i10c;42;e1i10i15i1643;|c<\x82Q0i16`W6;0e7i15a42;e1i10i15i1643;|c=\x82T0i16`W6>0e1i10c>c?43;e1i10i15i1643;|c@\x82]0i16b2X6<0e7i15b242;e1i10i12670cA540c@i1643;e1i10i1542;" [list
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
emit loadnil + load0 add2 - argc-error neg sub2 * load1 / vector loadv []
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
apply tapply])]) #fn(get) arg-counts] compile-builtin-call)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
compile-f #fn("8000r2e0c1qc242;" [call-with-values #fn("8000r0e0~\x7f42;" [compile-f-])
#fn("6000r2|;" [])] compile-f)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
compile-f- #fn("8000r2c0q]]42;" [#fn(">000r2c0qm02c1qm12c2qe330\x7f\x84e4\x7f\x8431e5\x7f\x8431e6c7\x7f\x8432e4\x7f31i10\x8270c8570e4\x7f3146;" [#fn("9000r1c0qe1|31F6N0e2|31F6=0c3e1|31K570e4|31560e53041;" [#fn("8000r1c0qe1|3141;" [#fn(":000r1|\x8540~;c0c1|~i4034c2c3|32K;" [#fn(list*)
lambda #fn(map) #fn("6000r1e040;" [void])]) get-defined-vars]) cddr cdddr
begin caddr void] lambda-body) #fn("7000r1e0|31i20\x8280e1|41;~|41;" [lastcdr
caddr] lam:body) #fn("9000r6c0q}?660`570c1}3141;" [#fn("9000r1c0q|c1i0431x41;" [#fn("9000r1c0qe1e2i143241;" [#fn("C000r1i24\x87\xa90|\x85O0e0i20c1~i22\x8580i10560i10y345s0e2i20e3c4c5c4c6|32e7c8|31313331322e0i20c9~c8|31i22\x8580i10560i10y352e:i20i40i24i23~35530]2e;i10c<326L0e0i20i22\x8570c=540c>i10335]0i22\x87A0e0i20c?i10335H0i24\x85A0e0i20c@i1033530^2eAi20i23i40K]i31i4131342e0i20cB322eCcDeEeFi203131eGi2031i2533i20b3[42;" [emit
optargs bcode:indexfor make-perfect-hash-table
#fn(map) #.cons #.car iota #fn(length) keyargs emit-optional-arg-inits > 255
largc lvargc vargc argc compile-in ret values #fn(function) encode-byte-code
bcode:code const-to-idx-vec]) filter keyword-arg?])
#fn(length)]) #fn(length)]) make-code-emitter lastcdr lambda-vars filter #.pair?
fix #24, make `<=` and `>=` work on strings
2016-09-17 14:30:05 -04:00
lambda])] #0=[#:g717 ()])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
compile-for #fn(":000r5e0g4316X0e1|}^g2342e1|}^g3342e1|}^g4342e2|c342;e4c541;" [1arg-lambda?
compile-in emit for error "for: third form must be a 1-argument lambda"] compile-for)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
compile-if #fn("<000r4c0qe1|31e1|31g3\x84e2g331e3g331F6;0e4g331560e53045;" [#fn(";000r5g2]\x82>0e0~\x7fi02g344;g2^\x82>0e0~\x7fi02g444;e0~\x7f^g2342e1~c2|332e0~\x7fi02g3342i026<0e1~c3325:0e1~c4}332e5~|322e0~\x7fi02g4342e5~}42;" [compile-in
emit brf ret jmp mark-label]) make-label caddr cdddr cadddr void] compile-if)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
compile-in #fn(";000r4g3C6=0e0|}g3c144;g3?6\xaf0g3`\x82:0e2|c342;g3a\x82:0e2|c442;g3]\x82:0e2|c542;g3^\x82:0e2|c642;g3_\x82:0e2|c742;e8g3316<0e2|c9g343;c:g3316C0e;|}g2c<c=31L144;e2|c>g343;g3MC@17D02g3ME17;02e?g3M}326=0e@|}g2g344;cAqg3M41;" [compile-sym
[loada loadc loadg] emit load0 load1 loadt loadf loadnil fits-i8 loadi8 #fn(eof-object?)
compile-in #fn(top-level-value) eof-object loadv in-env? compile-app #fn("<000r1|c0\x82W0e1i03\x84316@0e2~\x7fi02i03\x8444;e3~c4i03\x8443;|c5\x82?0e6~\x7fi02i0344;|c7\x82@0e8~\x7fi02i03N44;|c9\x82<0e:~\x7fi0343;|c;\x82=0e<c=qc>q42;|c?\x82@0e@~\x7fi02i03N44;|cA\x82@0eB~\x7fi02i03N44;|cC\x82G0eD~\x7fi03\x84c7eEi0331K44;|cF\x82K0eG~\x7fi03\x84eHi0331eIi033145;|cJ\x82F0e2~\x7f]i03\x84342e3~cK42;|cL\x82N0e2~\x7f^eHi0331342eM~\x7fi03\x84cN44;|cO\x82C0e2~\x7fi02ePi033144;|cQ\x82s0e2~\x7f^c;_i03\x84L3342eReHi033131660^580eScT312e2~\x7f^eHi0331342e3~cQ42;eU~\x7fi02i0344;" [quote
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
self-evaluating? compile-in emit loadv if compile-if begin compile-begin
prog1 compile-prog1 lambda call-with-values #fn("8000r0e0i11i1342;" [compile-f-])
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
#fn("9000r2e0i10c1|332e2i10}322}e3i1131X6<0e0i10c442;];" [emit loadv
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
bcode:cdepth nnn
closure]) and
compile-and or compile-or while compile-while cddr for compile-for caddr
cadddr return ret set! compile-sym [seta setc setg] define expand-define
trycatch 1arg-lambda? error "trycatch: second form must be a 1-argument lambda"
compile-app])] compile-in)
compile-or #fn("<000r4e0|}g2g3^c146;" [compile-short-circuit brt] compile-or)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
compile-prog1 #fn(";000r3e0|}^g2\x84342e1g231F6H0e2|}^e1g231342e3|c442;];" [compile-in
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
cddr compile-begin emit pop] compile-prog1)
compile-short-circuit #fn(":000r6g3?6=0e0|}g2g444;g3N?6>0e0|}g2g3M44;c1qe2|3141;" [compile-in
#fn("<000r1e0~\x7f^i03M342e1~c2322e1~i05|332e1~c3322e4~\x7fi02i03Ni04i05362e5~|42;" [compile-in
emit dup pop compile-short-circuit mark-label]) make-label] compile-short-circuit)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
compile-sym #fn(";000r4c0qe1g2}`]3441;" [#fn(":000r1|D6>0e0~i03`[|43;|MD6R0e0~i03a[|M|N342e1~e2\x7fN31a|MS342;c3i023116>02e4c5i0231316A0e0~c6c5i023143;e0~i03b2[i0243;" [emit
bcode:cdepth nnn #fn(constant?) printable? #fn(top-level-value) loadv])
lookup-sym] compile-sym)
compile-thunk #fn(";000r1e0c1c2L1_L1|L1~3441;" [compile #fn(nconc)
lambda] #0#)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
compile-while #fn("9000r4c0qe1|31e1|3142;" [#fn(":000r2e0~\x7f^e130342e2~|322e0~\x7f^i02342e3~c4}332e3~c5322e0~\x7f^i03342e3~c6|332e2~}42;" [compile-in
void mark-label emit brf pop jmp]) make-label] compile-while)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
const-to-idx-vec #fn("9000r1c0qc1e2|313141;" [#fn("9000r1e0c1qe2~31322|;" [table.foreach
#fn("8000r2~}|\\;" []) bcode:ctable]) #fn(vector.alloc) bcode:nconst] const-to-idx-vec)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
copy-tree #fn("8000r1|?640|;e0|M31e0|N31K;" [copy-tree] copy-tree)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
count #fn("7000r2c0q]41;" [#fn("9000r1c0qm02|~\x7f`43;" [#fn(":000r3}\x8550g2;~|}N|}M31690g2aw540g243;" [] count-)])] count)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
delete-duplicates #fn("8000r1e0|bD326<0c1qc23041;|?640|;c3|M|N42;" [length>
#fn("8000r1c0q]31~_42;" [#fn("6000r1c0qm02|;" [#fn("9000r2|?680e0}41;c1i10|M32690~|N}42;c2i10|M]332~|N|M}K42;" [reverse!
#fn(has?) #fn(put!)])])]) #fn(table) #fn("8000r2e0|}32680e1}41;|e1}31K;" [member
delete-duplicates])] delete-duplicates)
disassemble #fn("=000s1}\x85C0e0|`322e1302];530]2c2}Mc3|31c4|3143;" [disassemble
newline #fn("7000r3c0q]41;" [#fn(":000r1c0qm02`~axc1u2e2c3e4\x7f`32c5332c6qb4c7\x7f3142;" [#fn("9000r1|J16602|G@6D0e0c1312e2|i10aw42;e3|41;" [princ
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
"\n" disassemble print] print-val) #fn("7000r1e0c141;" [princ "\t"]) princ "maxstack "
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
ref-int32-LE "\n" #fn(":000r2]|}X6E02c0qc1c2q^e333315\x19/;" [#fn(";000r1e0~b432690e130530]2`i20axc2u2e3e4~b4x31c5c6|31c7342~awo002c8q|41;" [>
newline #fn("7000r1e0c141;" [princ "\t"]) princ hex5 ": " #fn(string) "\t"
#fn("=000r1c0|c1326P0i20i32e2i31i1032[312i10b4wo10;c0|c3326L0i20i32i31i10[[312i10awo10;c0|c4326K0e5c6i31i10[31312i10awo10;c0|c7326O0e5c6e2i31i103231312i10b4wo10;c0|c8326f0e5c6i31i10[31c9322i10awo102e5c6i31i10[31312i10awo10;c0|c:326\x9c0e5c6e2i31i103231c9322i10b4wo102e5c6e2i31i103231312i10b4wo102~c;\x82X0e5c9312e5c6e2i31i103231c9322i10b4wo10;];|c<=6Q0e5c6e2i31i103231c9322i10b4wo10;c0|c=326X0e5c>e?i10b,e@i31i1032R331322i10b2wo10;c0|cA326X0e5c>e?i10b,e2i31i1032R331322i10b4wo10;^;" [#fn(memq)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
(loadv.l loadg.l setg.l) ref-int32-LE (loadv loadg setg)
(loada seta call tcall list + - * / vector argc vargc loadi8 apply tapply)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
princ #fn(number->string) (loada.l seta.l largc lvargc call.l tcall.l) (loadc
setc) " " (loadc.l setc.l optargs keyargs) keyargs brbound (jmp brf brt brne
brnn brn) "@"
hex5 ref-int16-LE (jmp.l brf.l brt.l brne.l brnn.l brn.l)])])
#fn(table.foldl)
#fn("8000r3g217@02}i21~[<16402|;" [])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
Instructions])
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn(length)])]) #fn(function:code) #fn(function:vals)] disassemble)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
div #fn("8000r2|}V|`X16C02}`X16402a17502b/17402`w;" [] div) emit
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("G000s2g2\x85b0}c0<16C02|`[F16:02|`[Mc1<6;0|`[c2O5:0|`}|`[K\\5\xe20c3}c4326A0e5|g2M32L1m2530]2c6qc7}c832312c9qc7}c:32312}c;\x82\\0g2c<>6=0c=m12_m25F0g2c>>6=0c?m12_m2530^530]2}c@\x82\\0g2cA>6=0cBm12_m25F0g2cC>6=0cDm12_m2530^530]2cEq|`[F690|`[M530_|`[322|;" [car
cdr cadr #fn(memq) (loadv loadg setg) bcode:indexfor #fn("8000r1|16=02e0i02Mc132680|\x84o01;];" [>
255]) #fn(assq) ((loadv loadv.l) (loadg loadg.l) (setg setg.l) (loada loada.l)
(seta seta.l))
#fn("8000r1|16L02e0i02Mc13217=02e0i02\x84c132680|\x84o01;];" [> 255])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
((loadc loadc.l) (setc setc.l)) loada (0) loada0 (1) loada1 loadc (0 0)
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
loadc00 (0 1) loadc01 #fn(">000r2\x7fc0<16\x9a02|c1<16802}\x84c2<6E0~`i02Mc3e4}31KK\\5u0|c1\x82B0~`i02Mc5}NKK\\5_0|c6\x82B0~`i02Mc7}NKK\\5I0|c2\x82B0~`i02Mc8}NKK\\530^17^02\x7fc5<16702|c2<6@0~`i02Mc3}NKK\\;~`e9\x7fi02K}32\\;" [brf
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
not null? brn cddr brt eq? brne brnn nreconc])] emit)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
emit-optional-arg-inits #fn("8000r5g2F6=0c0qe1|3141;];" [#fn("<000r1e0~c1i04332e0~c2|332e3~e4i03i0432\x7fK^e5i0231342e0~c6i04332e0~c7322e8~|322e9~\x7fi02Ni03i04aw45;" [emit
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
brbound brt compile-in list-head cadar seta pop mark-label
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
emit-optional-arg-inits]) make-label] emit-optional-arg-inits)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
encode-byte-code #fn("8000r1c0e1|3141;" [#fn("8000r1c0e1|3141;" [#fn(";000r1c0qe1c2|31b3c2|31b2VT2wc33241;" [#fn("=000r1c0qc1~31`c230c230c330^^47;" [#fn("?000r7c0g4c1322]}|X6\xff02i10}[m52g5c2\x82O0c3g2i10}aw[c4g431332}b2wm15\xcf0c0g4e5c6e7~6<0c8qg531540g53231322}awm12}|X6:0i10}[530^m62c9g5c:326^0c3g3c4g431g6332c0g4~670e;540e<`31322}awm15_0g5c=\x82G0c0g4e;g631322}awm15C0g6D6<0c>qg531530^5_/2e?c@qg3322cAg441;" [#fn(io.write)
#int32(0) label #fn(put!) #fn(sizeof) byte #fn(get) Instructions #fn("7000r1|c0\x8250c1;|c2\x8250c3;|c4\x8250c5;|c6\x8250c7;|c8\x8250c9;|c:\x8250c;;i05;" [jmp
jmp.l brt brt.l brf brf.l brne brne.l brnn brnn.l brn brn.l])
#fn(memq) (jmp brf brt brne brnn brn) int32 int16 brbound #fn(":000r1c0|c1326H0c2i04e3i0631322\x7fawo01;c0|c4326`0c2i04e5i0631322\x7fawo012c2i04e5i20\x7f[31322\x7fawo01;c0|c6326\x820c2i04e3i0631322\x7fawo012c2i04e3i20\x7f[31322\x7fawo012i05c7\x82J0c2i04e3i20\x7f[31322\x7fawo01;];c2i04e5i0631322\x7fawo01;" [#fn(memq)
(loadv.l loadg.l setg.l loada.l seta.l largc lvargc call.l tcall.l)
#fn(io.write) int32 (loadc setc) uint8 (loadc.l setc.l optargs keyargs)
keyargs]) table.foreach #fn("<000r2c0i04|322c1i04i10670e2540e3c4i02}32|x3142;" [#fn(io.seek)
#fn(io.write) int32 int16 #fn(get)]) #fn(io.tostring!)])
#fn(length) #fn(table) #fn(buffer)]) >= #fn(length) 65536]) list->vector])
reverse!] encode-byte-code)
error #fn(":000s0c0c1|K41;" [#fn(raise) error] error) eval
#fn("8000r1e0e1|313140;" [compile-thunk expand] eval) even? #fn("8000r1c0|a32`W;" [#fn(logand)] even?)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
every #fn("8000r2}?17D02|}M3116:02e0|}N42;" [every] every) expand
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("A000r1c0q]]]]]]]]]]]4;;" [#fn("8000r;c0m02c1qm12c2L1m22c3qm32c4qm42c5qm52c6qm62c7qm72c8qm82c9m92c:qm:2g:~_42;" [#fn("8000r2|E17902c0|}32@;" [#fn(assq)] top?)
#fn("9000r1|?640|;|c0>640|;|MF16;02e1|31c2<6D0c3\x7fe4|3131\x7f|N3142;|M\x7f|N31K;" [((begin))
caar begin #fn(append) cdar] splice-begin) *expanded* #fn("9000r2|?640|;c0q~c1}32690\x7f|31530|41;" [#fn("9000r1c0qi10c1\x7f3241;" [#fn("8000r1c0q|6:0e1~31530_41;" [#fn(":000r1c0qc1c2c3|32i213241;" [#fn("8000r1i107=0c0c1qi2042;c2qc3q]31i203141;" [#fn(map)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
#fn("8000r1i5:|~42;" []) #fn("7000r1c0q|41;" [#fn("9000r1]|F6]02i62e0|31<7A0|i6:|Mi1032O590|e1|31O2|Nm05\x02/2~;" [caar
getting rid of label adding optional, faster built-in map checking in soon-to-be code for quasiquote a couple library bug fixes
2010-12-23 01:49:37 -05:00
cdar])]) #fn("6000r1c0qm02|;" [#fn("9000r1|?640|;|MF16;02c0e1|31<6;0|M~|N31K;c2qi6:|Mi103241;" [define
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
caar #fn(":000r1c0c1c2e3|3132i2032o202i72|Ki10~N31K;" [#fn(nconc)
#fn(map) #.list
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
get-defined-vars])])])])
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn(nconc) #fn(map) #.list]) get-defined-vars]) define]) begin] expand-body)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
#fn(":000r2|?640|;|MF16702|MNF6G0e0|31i0:e1|31}32L2540|Mi04|N}32K;" [caar
cadar] expand-lambda-list) #fn("8000r1|?660|L1;|MF6@0e0|31i05|N31K;|Mi05|N31K;" [caar] l-vars)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn(";000r2c0q|\x84e1|31e2|31i05|\x843144;" [#fn(":000r4c0qc1c2c3g332\x7f3241;" [#fn(";000r1c0c1L1i24~|32L1i23i02|32\x7f44;" [#fn(nconc)
lambda]) #fn(nconc) #fn(map) #.list]) lastcdr cddr] expand-lambda)
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
#fn("<000r2|NA17602|\x84?6N0e0|31\x8540|;c1|\x84i0:e2|31}32L3;c3qe4|31e5|31e0|31i05e4|313144;" [cddr
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
define caddr #fn(":000r4c0qc1c2c3g332\x7f3241;" [#fn(";000r1c0c1L1\x7fi24~|32KL1i23i02|3243;" [#fn(nconc)
define]) #fn(nconc) #fn(map) #.list]) cdadr caadr] expand-define)
#fn("7000r2c0q|\x8441;" [#fn("<000r1c0i13e1~31c2c3c4q|32\x7f3232K;" [begin
cddr #fn(nconc) #fn(map) #fn(":000r1|Me0i2:|\x84i11323130i11L3;" [compile-thunk])])] expand-let-syntax)
#fn("6000r2|;" [] local-expansion-env) #fn("7000r2|?640|;c0q|M41;" [#fn("9000r1c0qc1|\x7f3241;" [#fn("7000r1c0qc1q41;" [#fn(":000r1~16602~NF6M0i3:~\x84i20NQ2i39e0~31i213242;~17A02i10C@17702i10E660|40;c1qe2i203141;" [caddr
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
#fn("8000r1|6B0i4:|i30NQ2i3142;i20c0\x8260i30;i20c1\x82>0i46i30i3142;i20c2\x82>0i47i30i3142;i20c3\x82>0i48i30i3142;~40;" [quote
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
lambda define let-syntax]) macrocall?])
getting rid of label adding optional, faster built-in map checking in soon-to-be code for quasiquote a couple library bug fixes
2010-12-23 01:49:37 -05:00
#fn("7000r0c0q]31i2041;" [#fn("6000r1c0qm02|;" [#fn("9000r1|?640|;|M?670|M5<0i4:|Mi3132~|N31K;" [])])])])
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn(assq)])] expand-in)])] expand)
expand-define #fn("=000r1c0|\x84e1|31F6:0e1|315L0|\x84C6;0e230L15=0e3c4e5|313242;" [#fn("<000r2|C6:0c0|}ML3;c0|Mc1c2L1|NL1c3}31|M34L3;" [set!
#fn(nconc) lambda #fn(copy-list)]) cddr void error "compile error: invalid syntax "
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
print-to-string] expand-define)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
filter #fn("7000r2c0q]41;" [#fn("9000r1c0qm02|~\x7f_L143;" [#fn("9000r3g2]}F6S02i10}M316?0g2}M_KPNm2530]2}Nm15\f/2N;" [] filter-)])] filter)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
fits-i8 #fn("8000r1|I16F02e0|b\xb03216:02e1|b\xaf42;" [>= <=] fits-i8)
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
foldl #fn(":000r3g2\x8540};e0||g2M}32g2N43;" [foldl] foldl) foldr
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn(";000r3g2\x8540};|g2Me0|}g2N3342;" [foldr] foldr) for-each #fn(";000s2c0q]41;" [#fn(":000r1c0qm02i02\x85J0]\x7fF6A02~\x7fM312\x7fNo015\x1e/5;0|~\x7fi02K322];" [#fn(":000r2}MF6I0|c0c1}32Q22~|c0c2}3242;];" [#fn(map)
renaming backquote-related symbols to scheme style adding multi-arg for-each now R6RS psyntax can be fully bootstrapped interpreter maintenance
2009-08-17 23:46:09 -04:00
#.car #.cdr] for-each-n)])] for-each)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
get-defined-vars #fn("8000r1e0~|3141;" [delete-duplicates] #1=[#fn("9000r1|?640_;|Mc0<16602|NF6d0|\x84C16702|\x84L117S02|\x84F16E02e1|31C16:02e1|31L117402_;|Mc2\x82>0c3c4~|N32v2;_;" [define
caadr begin #fn(nconc) #fn(map)] #1#) ()])
hex5 #fn("9000r1e0c1|b@32b5c243;" [string.lpad #fn(number->string)
#\0] hex5)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
identity #fn("6000r1|;" [] identity) in-env?
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("8000r2}F16F02c0|}M3217:02e1|}N42;" [#fn(memq) in-env?] in-env?)
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
index-of #fn(":000r3}\x8540^;|}M\x8250g2;e0|}Ng2aw43;" [index-of] index-of)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
io.readall #fn("7000r1c0qc13041;" [#fn("8000r1c0|~322c1qc2|3141;" [#fn(io.copy)
#fn("7000r1|c0>16:02c1i1031670c240;|;" ["" #fn(io.eof?)
#fn(eof-object)])
#fn(io.tostring!)]) #fn(buffer)] io.readall)
io.readline #fn("8000r1c0|c142;" [#fn(io.readuntil)
#\linefeed] io.readline)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
io.readlines #fn("8000r1e0e1|42;" [read-all-of io.readline] io.readlines)
iota #fn("8000r1e0e1|42;" [map-int identity] iota) keyword->symbol
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("9000r1c0|316@0c1c2c3|313141;|;" [#fn(keyword?)
#fn(symbol)
#fn("<000r1c0|`c1|c2|313243;" [#fn(string.sub)
#fn(string.dec) #fn(length)]) #fn(string)] keyword->symbol)
keyword-arg? #fn("7000r1|F16902c0|M41;" [#fn(keyword?)] keyword-arg?)
fixing a 64-bit issue and a nan issue
2010-05-08 20:42:37 -04:00
lambda-arg-names #fn("9000r1e0c1e2|3142;" [map! #fn("7000r1|F690e0|M41;|;" [keyword->symbol])
to-proper] lambda-arg-names)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
lambda-vars #fn("7000r1c0q]41;" [#fn(":000r1c0qm02|~~^^342e1~41;" [#fn(";000r4|A17502|C640];|F16602|MC6S0g217502g36<0e0c1}c243;~|N}g2g344;|F16602|MF6\x870e3|Mb23216902e4|31C660^5=0e0c5|Mc6}342c7e4|31316<0~|N}g2]44;g36<0e0c1}c843;~|N}]g344;|F6>0e0c9|Mc6}44;|}\x82:0e0c1}42;e0c9|c6}44;" [error
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
"compile error: invalid argument list "
". optional arguments must come after required." length= caar "compile error: invalid optional argument "
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
" in list " #fn(keyword?) ". keyword arguments must come last."
fixing a 64-bit issue and a nan issue
2010-05-08 20:42:37 -04:00
"compile error: invalid formal argument "] check-formals) lambda-arg-names])] lambda-vars)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
last-pair #fn("7000r1|N?640|;e0|N41;" [last-pair] last-pair) lastcdr
#fn("7000r1|?640|;e0|31N;" [last-pair] lastcdr) length= #fn("9000r2}`X640^;}`W650|?;|?660}`W;e0|N}ax42;" [length=] length=)
length> #fn("9000r2}`X640|;}`W6;0|F16402|;|?660}`X;e0|N}ax42;" [length>] length>)
list->vector #fn("7000r1c0|v2;" [#.vector] list->vector) list-head
#fn(":000r2e0}`32640_;|Me1|N}ax32K;" [<= list-head] list-head)
list-ref #fn("8000r2e0|}32M;" [list-tail] list-ref) list-tail
#fn("9000r2e0}`32640|;e1|N}ax42;" [<= list-tail] list-tail) list? #fn("7000r1|A17@02|F16902e0|N41;" [list?] list?)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
load #fn("9000r1c0qc1|c23241;" [#fn("7000r1c0qc1qt;" [#fn("9000r0c0q]31]]]43;" [#fn("6000r1c0qm02|;" [#fn(":000r3c0i10317C0~c1i1031|e2}3143;c3i10312e2}41;" [#fn(io.eof?)
#fn(read) load-process #fn(io.close)])])])
#fn("9000r1c0~312c1c2i10|L341;" [#fn(io.close)
#fn(raise) load-error])]) #fn(file) :read] load)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
load-process #fn("7000r1e0|41;" [eval] load-process) lookup-sym
#fn("7000r4}\x8550c0;c1q}M41;" [(global)
#fn(":000r1c0qe1~|`3341;" [#fn(";000r1|6@0i13640|;i12|K;e0i10i11Ni1317502~A680i12570i12aw^44;" [lookup-sym])
index-of])] lookup-sym)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
macrocall? #fn("7000r1|MC16902e0|M41;" [symbol-syntax] macrocall?)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
macroexpand-1 #fn("8000r1|?640|;c0qe1|3141;" [#fn("7000r1|680|~Nv2;~;" [])
macrocall?] macroexpand-1)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
make-code-emitter #fn("9000r0_c030`c1Z4;" [#fn(table) +inf.0] make-code-emitter)
make-label #fn("6000r1c040;" [#fn(gensym)] make-label)
make-perfect-hash-table #fn("7000r1c0q]41;" [#fn("8000r1c0m02c1q]31c2~3141;" [#fn("9000r2e0e1c2|3131}42;" [mod0
abs #fn(hash)] $hash-keyword) #fn("6000r1c0qm02|;" [#fn("9000r1c0qc1b2|T2^3241;" [#fn("7000r1c0q]31i3041;" [#fn("6000r1c0qm02|;" [#fn("8000r1|F6=0c0qe1|3141;i10;" [#fn(":000r1c0qb2i50|i3032T241;" [#fn("9000r1i30|[6=0i50i40aw41;i30|~\\2i30|awe0i1031\\2i20i10N41;" [cdar])])
caar])])]) #fn(vector.alloc)])]) #fn(length)])] make-perfect-hash-table)
make-system-image #fn(";000r1c0c1|c2c3c434c542;" [#fn("8000r2c0qe1e242;" [#fn("7000r2]k02]k12c2qc3q41;" [*print-pretty*
*print-readably* #fn("7000r1c0qc1qt|302;" [#fn(":000r0c0qe1c2qe3c4303132312c5i2041;" [#fn("=000r1c0c1c2c3|c2c4|3233Q2i20322c5i20e642;" [#fn(write)
#fn(nconc) #fn(map) #.list #fn(top-level-value)
#fn(io.write) *linefeed*]) filter #fn("9000r1|E16w02c0|31@16l02c1|31G@17C02c2|31c2c1|3131>@16K02c3|i2132@16=02c4c1|3131@;" [#fn(constant?)
#fn(top-level-value) #fn(string) #fn(memq)
#fn(iostream?)]) simple-sort #fn(environment)
#fn(io.close)]) #fn("7000r1~302c0|41;" [#fn(raise)])])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
#fn("6000r0~k02\x7fk1;" [*print-pretty* *print-readably*])]) *print-pretty*
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
*print-readably*]) #fn(file) :write :create :truncate (*linefeed*
*directory-separator*
*argv* that
*print-pretty*
*print-width*
*print-readably*
*print-level*
*print-length*
*os-name*)] make-system-image)
getting rid of label adding optional, faster built-in map checking in soon-to-be code for quasiquote a couple library bug fixes
2010-12-23 01:49:37 -05:00
map! #fn("9000r2}]}F6B02}|}M31O2}Nm15\x1d/2;" [] map!) map-int
#fn("8000r2e0}`32640_;c1q|`31_K_42;" [<= #fn(":000r2|m12a\x7faxc0qu2|;" [#fn("8000r1\x7fi10|31_KP2\x7fNo01;" [])])] map-int)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
mark-label #fn("9000r2e0|c1}43;" [emit label] mark-label) max
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
#fn("<000s1}\x8540|;e0c1|}43;" [foldl #fn("7000r2|}X640};|;" [])] max)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
member #fn("8000r2}?640^;}M|>640};e0|}N42;" [member] member) memv
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
#fn("8000r2}?640^;}M|=640};e0|}N42;" [memv] memv) min #fn("<000s1}\x8540|;e0c1|}43;" [foldl
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
#fn("7000r2|}X640|;};" [])] min)
mod #fn("9000r2|e0|}32}T2x;" [div] mod) mod0
fix #24, make `<=` and `>=` work on strings
2016-09-17 14:30:05 -04:00
#fn("8000r2||}V}T2x;" [] mod0) nan? #fn("7000r1|c0>17702|c1>;" [+nan.0
-nan.0] nan?)
negative? #fn("7000r1|`X;" [] negative?) nestlist
#fn(";000r3e0g2`32640_;}e1||}31g2ax33K;" [<= nestlist] nestlist)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
newline #fn("9000\x8900001000\x8a0000770e0m02c1|e2322];" [*output-stream*
#fn(io.write)
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
*linefeed*] newline)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
nnn #fn("8000r1e0c1|42;" [count #fn("6000r1|A@;" [])] nnn) nreconc
improved implementation of backquote
2011-04-10 23:24:30 -04:00
#fn("8000r2e0}|42;" [reverse!-] nreconc) odd? #fn("7000r1e0|31@;" [even?] odd?)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
positive? #fn("8000r1e0|`42;" [>] positive?) princ
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("9000s0c0qe141;" [#fn("7000r1^k02c1qc2q41;" [*print-readably* #fn("7000r1c0qc1qt|302;" [#fn("8000r0e0c1i2042;" [for-each
#fn(write)]) #fn("7000r1~302c0|41;" [#fn(raise)])])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
#fn("6000r0~k0;" [*print-readably*])])
*print-readably*] princ)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
print #fn(":000s0e0c1|42;" [for-each #fn(write)] print)
print-exception #fn("=000r1|F16D02|Mc0<16:02e1|b4326P0e2c3|\x84c4e5|31c6352e7e8|31315\x070|F16D02|Mc9<16:02e1|b4326N0e2|\x84c:e8|31c;342e7e5|31315\xd00|F16@02|Mc<<16602|NF6?0e2c=|\x84c>335\xac0|F16802|Mc?<6B0e2c@312e2|NQ25\x8d0|F16802|McA<6G0eBe5|31312e2cC|\x84325i0eD|3116:02e1|b2326I0e7|M312e2cE312cF|\x84315>0e2cG312e7|312e2eH41;" [type-error
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
length= princ "type error: " ": expected " caddr ", got " print cadddr
bounds-error ": index " " out of bounds for " unbound-error "eval: variable "
" has no value" error "error: " load-error print-exception "in file " list?
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
": " #fn("8000r1c0|3117502|C670e1540e2|41;" [#fn(string?) princ print])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
"*** Unhandled exception: " *linefeed*] print-exception)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
print-stack-trace #fn("8000r1c0q]]42;" [#fn("=000r2c0qm02c1qm12c2qe3e4~e5670b5540b43231e6e7c8c9c:303232`43;" [#fn("8000r3c0qc1|31g2K41;" [#fn("9000r1c0~31c0\x7f31\x82>0c1c2c3|L341;c4qc5~3141;" [#fn(function:code)
#fn(raise) thrown-value ffound #fn(":000r1`e0c1|3131c2qu;" [1- #fn(length)
#fn("9000r1e0~|[316A0i30~|[i21i1043;];" [closure?])])
#fn(function:vals)]) #fn(function:name)] find-in-f)
#fn("8000r2c0c1qc2t41;" [#fn(";000r1|6H0c0e1c2c3e4|3132c53241;c6;" [#fn(symbol)
string.join #fn(map) #fn(string) reverse! "/" lambda])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
#fn("8000r0e0c1q\x7f322^;" [for-each #fn("9000r1i10|~_43;" [])])
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("7000r1|F16B02|Mc0<16802|\x84c1<680e2|41;c3|41;" [thrown-value
ffound caddr #fn(raise)])] fn-name) #fn("8000r3e0c1q|42;" [for-each #fn("9000r1e0c1i02c2332e3i11|`[\x7f32e4|31NK312e5302i02awo02;" [princ
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
"#" " " print vector->list newline])]) reverse! list-tail *interactive*
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
filter closure? #fn(map) #fn("7000r1|E16802c0|41;" [#fn(top-level-value)])
#fn(environment)])] print-stack-trace)
print-to-string #fn("7000r1c0qc13041;" [#fn("8000r1c0~|322c1|41;" [#fn(write)
#fn(io.tostring!)]) #fn(buffer)] print-to-string)
printable? #fn("7000r1c0|3117802c1|31@;" [#fn(iostream?)
#fn(eof-object?)] printable?)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
quote-value #fn("7000r1e0|31640|;c1|L2;" [self-evaluating? quote] quote-value)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
random #fn("8000r1c0|316<0e1c230|42;c330|T2;" [#fn(integer?) mod #fn(rand)
#fn(rand.double)] random)
read-all #fn("8000r1e0c1|42;" [read-all-of #fn(read)] read-all)
read-all-of #fn("9000r2c0q]31_|}3142;" [#fn("6000r1c0qm02|;" [#fn("9000r2c0i1131680e1|41;~}|Ki10i113142;" [#fn(io.eof?)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
reverse!])])] read-all-of)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
ref-int16-LE #fn(";000r2e0c1|}`w[`32c1|}aw[b832w41;" [int16 #fn(ash)] ref-int16-LE)
ref-int32-LE #fn("=000r2e0c1|}`w[`32c1|}aw[b832c1|}b2w[b@32c1|}b3w[bH32R441;" [int32
#fn(ash)] ref-int32-LE)
repl #fn("8000r0c0]]42;" [#fn("6000r2c0m02c1qm12}302e240;" [#fn("8000r0e0c1312c2e3312c4c5c6t41;" [princ
"> " #fn(io.flush) *output-stream* #fn("8000r1c0e131@16<02c2e3|3141;" [#fn(io.eof?)
*input-stream* #fn("7000r1e0|312|k12];" [print that]) load-process])
#fn("6000r0c040;" [#fn(read)]) #fn("7000r1c0e1312c2|41;" [#fn(io.discardbuffer)
*input-stream* #fn(raise)])] prompt)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
#fn("7000r0c0qc1t6;0e2302\x7f40;^;" [#fn("7000r0~3016702e040;" [newline])
#fn("7000r1e0|312];" [top-level-exception-handler])
newline] reploop) newline])] repl)
improved implementation of backquote
2011-04-10 23:24:30 -04:00
revappend #fn("8000r2e0}|42;" [reverse-] revappend) reverse
#fn("8000r1e0_|42;" [reverse-] reverse) reverse! #fn("8000r1e0_|42;" [reverse!-] reverse!)
reverse!- #fn("9000r2]}F6B02}N}|}m02P2m15\x1d/2|;" [] reverse!-)
getting rid of label adding optional, faster built-in map checking in soon-to-be code for quasiquote a couple library bug fixes
2010-12-23 01:49:37 -05:00
reverse- #fn("8000r2}\x8540|;e0}M|K}N42;" [reverse-] reverse-)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
self-evaluating? #fn("8000r1|?16602|C@17K02c0|3116A02|C16:02|c1|31<;" [#fn(constant?)
#fn(top-level-value)] self-evaluating?)
porting over some improvements: now fl_applyn can handle any function (lambda wrappers for opcodes) faster separate
2010-05-05 01:31:46 -04:00
separate #fn("7000r2c0q]41;" [#fn(":000r1c0m02|~\x7f_L1_L144;" [#fn(";000r4c0g2g3K]}F6Z02|}M316?0g2}M_KPNm25<0g3}M_KPNm32}Nm15\x05/241;" [#fn("8000r1e0|MN|NN42;" [values])] separate-)])] separate)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
set-syntax! #fn("9000r2c0e1|}43;" [#fn(put!)
*syntax-environment*] set-syntax!)
some critical bug fixes
2010-05-04 14:17:55 -04:00
simple-sort #fn("7000r1|A17602|NA640|;c0q|M41;" [#fn("8000r1e0c1qc2q42;" [call-with-values
#fn("8000r0e0c1qi10N42;" [separate #fn("7000r1|~X;" [])])
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn(":000r2c0e1|31~L1e1}3143;" [#fn(nconc) simple-sort])])] simple-sort)
improved implementation of backquote
2011-04-10 23:24:30 -04:00
splice-form? #fn("8000r1|F16X02|Mc0<17N02|Mc1<17D02|Mc2<16:02e3|b23217702|c2<;" [unquote-splicing
unquote-nsplicing unquote length>] splice-form?)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
string.join #fn("7000r2|\x8550c0;c1qc23041;" ["" #fn("8000r1c0|~M322e1c2q~N322c3|41;" [#fn(io.write)
for-each #fn("8000r1c0~i11322c0~|42;" [#fn(io.write)])
#fn(io.tostring!)]) #fn(buffer)] string.join)
string.lpad #fn(";000r3c0e1g2}c2|31x32|42;" [#fn(string) string.rep
#fn(string.count)] string.lpad)
string.map #fn("9000r2c0qc130c2}3142;" [#fn("7000r2c0q`312c1|41;" [#fn(";000r1]|\x7fX6S02c0~i10c1i11|3231322c2i11|32m05\v/;" [#fn(io.putc)
#fn(string.char) #fn(string.inc)]) #fn(io.tostring!)])
#fn(buffer)
#fn(length)] string.map)
string.rep #fn(";000r2}b4X6`0e0}`32650c1;}aW680c2|41;}b2W690c2||42;c2|||43;e3}316@0c2|e4|}ax3242;e4c2||32}b2U242;" [<=
"" #fn(string) odd? string.rep] string.rep)
string.rpad #fn("<000r3c0|e1g2}c2|31x3242;" [#fn(string) string.rep
#fn(string.count)] string.rpad)
string.tail #fn(";000r2c0|c1|`}3342;" [#fn(string.sub)
#fn(string.inc)] string.tail)
string.trim #fn("8000r3c0q]]42;" [#fn("8000r2c0qm02c1qm12c2qc3~3141;" [#fn(";000r4g2g3X16?02c0}c1|g232326A0~|}c2|g232g344;g2;" [#fn(string.find)
#fn(string.char) #fn(string.inc)] trim-start)
#fn("<000r3e0g2`3216D02c1}c2|c3|g23232326?0\x7f|}c3|g23243;g2;" [> #fn(string.find)
#fn(string.char)
#fn(string.dec)] trim-end)
#fn("<000r1c0i10~i10i11`|34\x7fi10i12|3343;" [#fn(string.sub)])
#fn(length)])] string.trim)
symbol-syntax #fn("9000r1c0e1|^43;" [#fn(get)
*syntax-environment*] symbol-syntax)
table.clone #fn("7000r1c0qc13041;" [#fn("9000r1c0c1q_~332|;" [#fn(table.foldl)
#fn("9000r3c0~|}43;" [#fn(put!)])]) #fn(table)] table.clone)
table.foreach #fn("9000r2c0c1q_}43;" [#fn(table.foldl)
#fn("8000r3~|}322];" [])] table.foreach)
table.invert #fn("7000r1c0qc13041;" [#fn("9000r1c0c1q_~332|;" [#fn(table.foldl)
#fn("9000r3c0~}|43;" [#fn(put!)])]) #fn(table)] table.invert)
table.keys #fn("9000r1c0c1_|43;" [#fn(table.foldl)
#fn("7000r3|g2K;" [])] table.keys)
table.pairs #fn("9000r1c0c1_|43;" [#fn(table.foldl)
#fn("7000r3|}Kg2K;" [])] table.pairs)
table.values #fn("9000r1c0c1_|43;" [#fn(table.foldl)
#fn("7000r3}g2K;" [])] table.values)
improving portability to Mac OS fixes for big endian architectures (PowerPC) renaming exported symbol raise to fl_raise fixing some bugs and oversights discovered in the process
2009-08-28 20:54:51 -04:00
to-proper #fn("8000r1|\x8540|;|?660|L1;|Me0|N31K;" [to-proper] to-proper)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
top-level-exception-handler #fn("7000r1c0qe141;" [#fn("7000r1e0k12c2qc3q41;" [*stderr*
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
*output-stream* #fn("7000r1c0qc1qt|302;" [#fn("7000r0e0i20312e1c23041;" [print-exception
print-stack-trace #fn(stacktrace)]) #fn("7000r1~302c0|41;" [#fn(raise)])])
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
#fn("6000r0~k0;" [*output-stream*])]) *output-stream*] top-level-exception-handler)
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
trace #fn("8000r1c0qc1|31312c2;" [#fn("7000r1c0qc13041;" [#fn("@000r1e0~317e0c1i10e2c3|c4c5c6c7i10L2|L3L2c8L1c9c7~L2|L3L4L33142;];" [traced?
#fn(set-top-level-value!) eval lambda begin write cons quote newline apply])
#fn(gensym)])
#fn(top-level-value) ok] trace)
traced? #fn("8000r1e0|3116>02c1|31c1~31>;" [closure? #fn(function:code)] [#fn(":000s0c0c1|K312e2302c3|v2;" [#fn(write)
adding *print-level* and *print-length* fixing open-string-output-port (R6RS) making io.tostring! more consistent adding newlines to boot file; wastes space but will allow more efficient diffing
2009-08-13 00:09:35 -04:00
x newline #.apply]) ()])
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
untrace #fn("8000r1c0qc1|3141;" [#fn("9000r1e0|316@0c1~c2|31b2[42;];" [traced?
#fn(set-top-level-value!) #fn(function:vals)])
#fn(top-level-value)] untrace)
some critical bug fixes
2010-05-04 14:17:55 -04:00
values #fn("9000s0|F16602|NA650|M;~|K;" [] #2#) vector->list
several minor changes and additions: - add io.ungetc and string.isutf8 - maintain input order in delete-duplicates - error for unicode escapes greater than 0x10ffff - make more builtins constant (use setc instead of set) - use prog1 in begin0 macro - array-ref was incorrectly called array-ref! in aliases.scm - use (void) instead of () in 0-arg C functions - don't do arithmetic with void*
2013-06-08 19:29:15 -04:00
#fn("8000r1c0qc1|31_42;" [#fn(":000r2a|c0qu2};" [#fn("8000r1i10~|x[\x7fKo01;" [])])
#fn(length)] vector->list)
vector.map #fn("8000r2c0qc1}3141;" [#fn("8000r1c0qc1|3141;" [#fn(":000r1`~axc0qu2|;" [#fn(":000r1~|i20i21|[31\\;" [])])
#fn(vector.alloc)]) #fn(length)] vector.map)
clarifying which values are unspecified, and making the unspecified value true, since only #f should be false. removing not-really-used definitions of true and false, which just seem to be asking for conflicts
2010-01-06 13:27:28 -05:00
void #fn("6000r0];" [] void) zero?
#fn("7000r1|`W;" [] zero?))