Mercurial > repos > tabletprog

annotate modules/array.tp @ 331:61f5b794d939

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Breaking change: method call syntax now always uses the syntactic receiver as the actual receiver. This makes its behavior different from function call syntax, but solves some problems with methods being shadowed by local variables and the like.
author Michael Pavone <pavone@retrodev.com>
date Sat, 28 Mar 2015 14:21:04 -0700
parents eef8a5cea812
children 884cd5d54c0f
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
1 #{
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
2 llProperty: size withType: uint32_t
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
3 llProperty: storage withType: uint32_t
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
4 llProperty: data withType: ((object ptr) ptr)
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
5 llMessage: get withVars: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
6 index <- obj_int32 ptr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
7 } andCode: :index {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
8 if: (index num) >= 0 && (index num) < size {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
9 (self data) get: (index num)
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
10 } else: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
11 false
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
12 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
13 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
14
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
15 llMessage: set withVars: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
16 index <- obj_int32 ptr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
17 value <- object ptr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
18 } andCode: :index value {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
19 if: (index num) >= 0 && (index num) < size {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
20 data set: (index num) value
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
21 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
22 self
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
23 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
24
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
25 llMessage: foreach withVars: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
26 clos <- lambda ptr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
27 i <- uint32_t
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
28 index <- obj_int32 ptr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
29 } andCode: :clos {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
30 i <- 0
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
31 while: { i < size } do: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
32 index <- make_object: (addr_of: obj_int32_meta) NULL 0
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
33 index num!: i
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
34 ccall: clos 2 index (data get: i)
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
35 i <- i + 1
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
36 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
37 self
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
38 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
39
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
40 llMessage: append withVars: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
41 value <- object ptr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
42 tmp <- (object ptr) ptr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
43 } andCode: :value {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
44 if: storage = size {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
45 storage <- storage * 2
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
46 tmp <- GC_REALLOC: data storage * (sizeof: (object ptr))
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
47 if: (not: tmp) {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
48 fputs: "Failed to increase array size\n" stderr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
49 exit: 1
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
50 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
51 data <- tmp
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
52 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
53 data set: size value
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
54 size <- size + 1
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
55 self
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
56 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
57
249
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
58 llMessage: resize withVars: {
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
59 newsize <- obj_uint32 ptr
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
60 tmp <- (object ptr) ptr
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
61 } andCode: :newsize {
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
62 self storage!: (newsize num)
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
63 tmp <- GC_REALLOC: data storage * (sizeof: (object ptr))
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
64 if: (not: tmp) {
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
65 fputs: "Failed to adjust array size\n" stderr
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
66 exit: 1
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
67 }
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
68 data <- tmp
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
69 if: size > storage {
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
70 size <- storage
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
71 }
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
72 self
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
73 }
fd9005253861 Added resize method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 191
diff changeset
74
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
75 llMessage: length withVars: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
76 intret <- obj_int32 ptr
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
77 } andCode: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
78 intret <- make_object: (addr_of: obj_int32_meta) NULL 0
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
79 intret num!: size
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
80 intret
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
81 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
82
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
83 fold:with <- :acc :fun {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
84 foreach: self :idx el {
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
85 acc <- fun: acc el
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
86 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
87 acc
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
88 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
89
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
90 foldr:with <- :acc :fun {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
91 idx <- length - 1
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
92 while: {idx >= 0} do: {
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
93 acc <- fun: acc (get: idx)
323
eb5f1fca9b78 Fix infinite loop in foldr:with
Michael Pavone <pavone@retrodev.com>
parents: 322
diff changeset
94 idx <- idx - 1
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
95 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
96 acc
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
97 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
98
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
99 map <- :fun {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
100 new <- #[]
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
101 foreach: self :idx el {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
102 new append: (fun: el)
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
103 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
104 new
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
105 }
144
547153211389 Fix fold:with foldr:with and map in the array module
Mike Pavone <pavone@retrodev.com>
parents: 84
diff changeset
106
260
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
107 filter <- :fun {
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
108 new <- #[]
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
109 foreach: self :idx el {
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
110 if: (fun: el) {
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
111 new append: el
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
112 }
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
113 }
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
114 new
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
115 }
56409de95f55 Untested implementation of filter for arrays
Michael Pavone <pavone@retrodev.com>
parents: 249
diff changeset
116
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
117 find:withDefault <- :pred :default{
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
118 idx <- 0
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
119 l <- length
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
120 ret <- default
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
121 while: {idx < l} do: {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
122 v <- get: idx
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
123 if: (pred: v) {
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
124 ret <- #{
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
125 key <- idx
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
126 value <- v
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
127 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
128 idx <- l
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
129 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
130 }
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
131 ret
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
132 }
322
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
133
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
134 sort <- {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
135 n <- length
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
136 tmp <- #[]
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
137 tmp resize: n
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
138 while: { (tmp length) < n} do: {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
139 tmp append: false
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
140 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
141 src <- self
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
142 dst <- tmp
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
143
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
144 merge <- :lStart rStart rEnd {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
145 dstIdx <- lStart
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
146 left <- lStart
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
147 right <- rStart
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
148
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
149 while: { dstIdx < rEnd } do: {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
150 if: left < rStart && (right >= rEnd || (src get: left) <= (src get: right)) {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
151 dst set: dstIdx (src get: left)
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
152 left <- left + 1
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
153 } else: {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
154 dst set: dstIdx (src get: right)
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
155 right <- right + 1
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
156 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
157 dstIdx <- dstIdx + 1
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
158 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
159 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
160
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
161 needsCopy? <- false
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
162 subSize <- 1
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
163 while: { subSize < n} do: {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
164 group <- subSize * 2
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
165 i <- 0
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
166 while: { i < n} do: {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
167 right <- i + subSize
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
168 end <- i + group
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
169 if: right > n {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
170 right <- n
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
171 end <- n
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
172 } else: {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
173 if: end > n {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
174 end <- n
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
175 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
176 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
177 merge: i right end
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
178 i <- i + group
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
179 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
180 tmp <- dst
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
181 dst <- src
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
182 src <- tmp
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
183 needsCopy? <- not: needsCopy?
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
184
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
185 subSize <- subSize + subSize
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
186 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
187 if: needsCopy? {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
188 foreach: src :index val {
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
189 self set: index val
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
190 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
191 }
fb54a3af9c86 Add sort method to arrays
Michael Pavone <pavone@retrodev.com>
parents: 271
diff changeset
192 }
184
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
193
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
194 join <- :sep {
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
195 if: length > 0 {
186
35d2cc193d99 Add string conversion inside array join so callers don't need to worry about doing string conversions themselves
Mike Pavone <pavone@retrodev.com>
parents: 184
diff changeset
196 str <- string: (get: 0)
184
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
197 idx <- 1
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
198 l <- length
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
199 while: { idx < l } do: {
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
200 str <- str . sep . (get: idx)
191
abde5d2918cf Fix infinite loop in array join
Mike Pavone <pavone@retrodev.com>
parents: 186
diff changeset
201 idx <- idx + 1
184
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
202 }
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
203 str
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
204 } else: {
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
205 ""
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
206 }
ca249978ae96 Add join method to array
Mike Pavone <pavone@retrodev.com>
parents: 144
diff changeset
207 }
271
bb4723fec05e Support for encoding objects, dictionaries, lists and arrays to JSON in json module
Michael Pavone <pavone@retrodev.com>
parents: 260
diff changeset
208
bb4723fec05e Support for encoding objects, dictionaries, lists and arrays to JSON in json module
Michael Pavone <pavone@retrodev.com>
parents: 260
diff changeset
209 jsonEncode <- {
329
eef8a5cea812 Use a smarter algorithm for calculating module init order and break some circular module dependencies in the standard library
Michael Pavone <pavone@retrodev.com>
parents: 323
diff changeset
210 parts <- map: :el { jsonEncoder encode: el }
271
bb4723fec05e Support for encoding objects, dictionaries, lists and arrays to JSON in json module
Michael Pavone <pavone@retrodev.com>
parents: 260
diff changeset
211 "[" . (parts join: ",") . "]"
bb4723fec05e Support for encoding objects, dictionaries, lists and arrays to JSON in json module
Michael Pavone <pavone@retrodev.com>
parents: 260
diff changeset
212 }
84
9811040704ac Add support for llMessage:withVars:andCode and llProperty:withType for specifying low level code without having to stick C inside the compiler. Redo array built-in type to use this feature.
Mike Pavone <pavone@retrodev.com>
parents:
diff changeset
213 }