Mercurial > repos > rhope
annotate string.rhope @ 185:4580c08fd4e8
Fix an import missed in last commit
author | Mike Pavone <pavone@retrodev.com> |
---|---|
date | Wed, 27 Jul 2011 21:32:40 -0700 |
parents | 64be565a40c6 |
children |
rev | line source |
---|---|
108
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1 |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
2 Import pattern.rhope |
52
079200bc3e75
String literals almost working. Print moved out of C runtime.
Mike Pavone <pavone@retrodev.com>
parents:
51
diff
changeset
|
3 |
51
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
4 UTF8 Expect[num,arr,index,count,consumed:out] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
5 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
6 byte <- [arr]Index[index] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
7 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
8 If[[128u8]>[byte]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
9 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
10 //Error: ASCII byte when we were expecting part of a mutlibyte sequence |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
11 //treat each byte as a separate character |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
12 ncount <- [1i32]+[[count]+[consumed]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
13 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
14 If[[192u8]>[byte]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
15 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
16 If[[num]=[1]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
17 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
18 //Sequence is complete count as single character |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
19 ncount <- [1i32]+[count] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
20 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
21 out <- UTF8 Expect[[num]-[1], arr, [index]+[1], count, [1i32]+[consumed]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
22 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
23 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
24 //Error: too high to be a continuation byte |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
25 ncount <- [1i32]+[[count]+[consumed]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
26 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
27 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
28 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
29 //Error: string ended in the middle of a multi-byte sequence |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
30 out <- [count]+[consumed] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
31 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
32 Val[ncount] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
33 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
34 [arr]Next[index] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
35 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
36 out <- Count UTF8[arr, ~, ncount] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
37 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
38 out <- Val[ncount] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
39 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
40 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
41 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
42 |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
43 Count UTF8[arr,index,count:out] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
44 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
45 byte <- [arr]Index[index] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
46 If[[128u8]>[byte]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
47 { ncount <- [1i32]+[count] } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
48 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
49 If[[192u8]>[byte]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
50 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
51 //Error: Encoding for 2nd,3rd or 4th byte of sequence |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
52 //treat as a single character |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
53 ncount <- [1i32]+[count] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
54 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
55 If[[224u8]>[byte]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
56 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
57 out <- UTF8 Expect[1, arr, [index]+[1], count, 1] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
58 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
59 If[[240u8]>[byte]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
60 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
61 out <- UTF8 Expect[2, arr, [index]+[1], count, 1] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
62 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
63 If[[245u8]>[byte]] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
64 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
65 out <- UTF8 Expect[3, arr, [index]+[1], count, 1] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
66 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
67 //Error: Out of range of Unicode standard |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
68 //treat as a single character |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
69 ncount <- [1i32]+[count] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
70 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
71 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
72 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
73 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
74 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
75 [arr]Next[index] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
76 { |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
77 out <- Count UTF8[arr, ~, ncount] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
78 }{ |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
79 out <- Val[ncount] |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
80 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
81 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
82 |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
83 Blueprint String |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
84 { |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
85 Buffer |
51
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
86 Length(Int32,Naked) |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
87 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
88 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
89 String@Array[in:out(String)] |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
90 { |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
91 [in]First |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
92 { len <- Count UTF8[in, ~, 0i32] } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
93 { len <- 0i32 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
94 out <- [[Build[String()]]Buffer <<[in]]Length <<[len] |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
95 } |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
96 |
136
fc3815b7462f
Javascript backend now produces working code for some simple examples, still more of the standard lib that needs to be ported.
Mike Pavone <pavone@retrodev.com>
parents:
131
diff
changeset
|
97 String@Empty Array[in:out(String)] |
fc3815b7462f
Javascript backend now produces working code for some simple examples, still more of the standard lib that needs to be ported.
Mike Pavone <pavone@retrodev.com>
parents:
131
diff
changeset
|
98 { |
fc3815b7462f
Javascript backend now produces working code for some simple examples, still more of the standard lib that needs to be ported.
Mike Pavone <pavone@retrodev.com>
parents:
131
diff
changeset
|
99 out <- "" |
fc3815b7462f
Javascript backend now produces working code for some simple examples, still more of the standard lib that needs to be ported.
Mike Pavone <pavone@retrodev.com>
parents:
131
diff
changeset
|
100 } |
fc3815b7462f
Javascript backend now produces working code for some simple examples, still more of the standard lib that needs to be ported.
Mike Pavone <pavone@retrodev.com>
parents:
131
diff
changeset
|
101 |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
102 Print@String[string:out] |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
103 { |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
104 //TODO: Sanitize string (remove terminal escapes and replace invalid UTF) |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
105 write[1i32, [string]Buffer >>, Int64[[[string]Buffer >>]Length >>]] |
69
d0ce696786cc
Clean up debug print statements a bit. Fix bug that prevented workers that took no inputs from working. Remove workaround in Array for said bug.
Mike Pavone <pavone@retrodev.com>
parents:
55
diff
changeset
|
106 { out <- write[1i32, [Array[]]Append[10u8], 1i64] } |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
107 } |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
108 |
179
64be565a40c6
Implement If method on List, fix Get Char to handle end of file, fix nested list pretty printing
Mike Pavone <pavone@retrodev.com>
parents:
160
diff
changeset
|
109 Get Char[:out,err] |
71
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
110 { |
179
64be565a40c6
Implement If method on List, fix Get Char to handle end of file, fix nested list pretty printing
Mike Pavone <pavone@retrodev.com>
parents:
160
diff
changeset
|
111 ret,data <- read[0, [Array[]]Set[0, 0u8], 1i64] |
64be565a40c6
Implement If method on List, fix Get Char to handle end of file, fix nested list pretty printing
Mike Pavone <pavone@retrodev.com>
parents:
160
diff
changeset
|
112 If[[ret]<[1i64]] |
64be565a40c6
Implement If method on List, fix Get Char to handle end of file, fix nested list pretty printing
Mike Pavone <pavone@retrodev.com>
parents:
160
diff
changeset
|
113 { err <- Val[ret] } |
64be565a40c6
Implement If method on List, fix Get Char to handle end of file, fix nested list pretty printing
Mike Pavone <pavone@retrodev.com>
parents:
160
diff
changeset
|
114 { out <- String[data] } |
71
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
115 } |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
116 |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
117 _String to Int[current,index,array,ten,conv:out] |
71
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
118 { |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
119 char <- [array]Index[index] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
120 { |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
121 If[[char]<[48u8]] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
122 { |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
123 out <- Val[current] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
124 }{ |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
125 If[[char]>[57u8]] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
126 { |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
127 out <- Val[current] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
128 }{ |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
129 out <- _String to Int[[[current]*[ten]]+[[conv]Call[[char]-[48u8]]], [index]+[1], array, ten, conv] |
71
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
130 } |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
131 } |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
132 |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
133 }{ |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
134 out <- Val[current] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
135 } |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
136 } |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
137 |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
138 U8toI8[val:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
139 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
140 out <- Trunc Int8[Int16[val]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
141 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
142 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
143 Int8@String[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
144 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
145 buf <- [string]Buffer >> |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
146 [buf]Index[0] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
147 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
148 If[[~]=[45u8]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
149 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
150 out <- [0i8]-[_String to Int[0i8, 1, buf, 10i8, U8toI8[?]]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
151 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
152 out <- _String to Int[0i8, 0, buf, 10i8, U8toI8[?]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
153 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
154 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
155 out <- 0i8 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
156 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
157 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
158 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
159 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
160 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
161 Int16@String[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
162 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
163 buf <- [string]Buffer >> |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
164 [buf]Index[0] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
165 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
166 If[[~]=[45u8]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
167 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
168 out <- [0i16]-[_String to Int[0i16, 1, buf, 10i16, Int16[?]]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
169 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
170 out <- _String to Int[0i16, 0, buf, 10i16, Int16[?]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
171 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
172 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
173 out <- 0i16 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
174 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
175 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
176 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
177 |
71
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
178 Int32@String[string:out] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
179 { |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
180 buf <- [string]Buffer >> |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
181 [buf]Index[0] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
182 { |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
183 If[[~]=[45u8]] |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
184 { |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
185 out <- [0i32]-[_String to Int[0i32, 1, buf, 10i32, Int32[?]]] |
71
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
186 }{ |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
187 out <- _String to Int[0i32, 0, buf, 10i32, Int32[?]] |
71
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
188 } |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
189 }{ |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
190 out <- 0i32 |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
191 } |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
192 |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
193 } |
c40c3d399133
Add Int32@String and Get Char. Fix stack bug
Mike Pavone <pavone@retrodev.com>
parents:
69
diff
changeset
|
194 |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
195 _Hex Int32[str,cur,idx:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
196 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
197 char <- [str]Byte[idx] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
198 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
199 //0-9 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
200 [char]Between[47u8, 58u8] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
201 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
202 adjust <- 48u8 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
203 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
204 //A-F |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
205 [char]Between[64u8, 71u8] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
206 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
207 adjust <- 55u8 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
208 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
209 //a-f |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
210 [char]Between[96u8, 103u8] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
211 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
212 adjust <- 87u8 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
213 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
214 out <- cur |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
215 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
216 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
217 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
218 Val[adjust] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
219 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
220 out <- _Hex Int32[str, [[cur]*[16i32]]+[Int32[[char]-[adjust]]], [idx]+[1]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
221 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
222 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
223 out <- cur |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
224 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
225 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
226 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
227 Hex Int32[str:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
228 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
229 out <- _Hex Int32[str, 0i32, 0] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
230 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
231 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
232 Int64@String[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
233 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
234 buf <- [string]Buffer >> |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
235 [buf]Index[0] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
236 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
237 If[[~]=[45u8]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
238 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
239 out <- [0i64]-[_String to Int[0i64, 1, buf, 10i64, Int64[?]]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
240 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
241 out <- _String to Int[0i64, 0, buf, 10i64, Int64[?]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
242 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
243 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
244 out <- 0i64 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
245 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
246 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
247 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
248 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
249 UInt8@String[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
250 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
251 out <- _String to Int[0u8, 0, [string]Buffer >>, 10u8, Val[?]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
252 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
253 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
254 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
255 UInt16@String[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
256 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
257 out <- _String to Int[0u16, 0, [string]Buffer >>, 10u16, UInt16[?]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
258 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
259 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
260 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
261 UInt32@String[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
262 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
263 out <- _String to Int[0u32, 0, [string]Buffer >>, 10u32, UInt32[?]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
264 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
265 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
266 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
267 UInt64@String[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
268 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
269 out <- _String to Int[0u64, 0, [string]Buffer >>, 10u64, UInt64[?]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
270 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
271 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
272 Int8@String Slice[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
273 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
274 out <- Int8[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
275 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
276 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
277 Int8@String Cat[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
278 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
279 out <- Int8[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
280 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
281 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
282 Int16@String Slice[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
283 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
284 out <- Int16[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
285 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
286 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
287 Int16@String Cat[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
288 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
289 out <- Int16[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
290 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
291 |
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
292 Int32@String Slice[string:out] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
293 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
294 out <- Int32[[string]Flatten] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
295 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
296 |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
297 Int32@String Cat[string:out] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
298 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
299 out <- Int32[[string]Flatten] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
300 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
301 |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
302 Int64@String Slice[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
303 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
304 out <- Int64[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
305 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
306 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
307 Int64@String Cat[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
308 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
309 out <- Int64[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
310 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
311 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
312 UInt8@String Slice[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
313 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
314 out <- UInt8[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
315 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
316 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
317 UInt8@String Cat[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
318 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
319 out <- UInt8[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
320 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
321 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
322 UInt16@String Slice[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
323 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
324 out <- UInt16[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
325 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
326 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
327 UInt16@String Cat[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
328 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
329 out <- UInt16[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
330 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
331 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
332 UInt32@String Slice[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
333 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
334 out <- UInt32[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
335 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
336 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
337 UInt32@String Cat[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
338 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
339 out <- UInt32[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
340 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
341 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
342 UInt64@String Slice[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
343 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
344 out <- UInt64[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
345 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
346 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
347 UInt64@String Cat[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
348 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
349 out <- UInt64[[string]Flatten] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
350 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
351 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
352 //TODO: Implement me once Real64 support is added |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
353 Real64[string:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
354 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
355 out <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
356 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
357 |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
358 Flatten@String[string:out] |
51
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
359 { |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
360 out <- string |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
361 } |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
362 |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
363 _CPOff to BOff[buff,cur,boff,cpoff,expected,used:out] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
364 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
365 If[expected] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
366 { |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
367 byte <- [buff]Index[boff] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
368 err <- If[[byte]>[192u8]] {} |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
369 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
370 err <- If[[byte]<[128u8]] {} |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
371 { |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
372 out <- _CPOff to BOff[buff, cur, [boff]+[1i32], cpoff, [expected]-[1i32], [used]+[1i32]] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
373 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
374 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
375 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
376 Val[err] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
377 { |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
378 ncur <- [cur]+[used] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
379 If[[ncur]>[cpoff]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
380 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
381 out <- [boff]-[[cpoff]-[ncur]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
382 }{ |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
383 out <- CPOff to BOff[buff,ncur,boff,cpoff] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
384 } |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
385 } |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
386 }{ |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
387 out <- CPOff to BOff[buff,[cur]+[1i32],boff,cpoff] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
388 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
389 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
390 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
391 CPOff to BOff[buff,cur,boff,cpoff:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
392 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
393 If[[cur]=[cpoff]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
394 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
395 out <- boff |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
396 }{ |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
397 byte <- [buff]Index[boff] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
398 If[[byte] < [128u8]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
399 { |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
400 nboff <- [boff]+[1i32] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
401 ncur <- [cur]+[1i32] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
402 }{ |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
403 If[[byte]<[192u8]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
404 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
405 //Error: Encoding for 2nd,3rd or 4th byte of sequence |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
406 //treat as a single character |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
407 nboff <- [boff]+[1i32] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
408 ncur <- [cur]+[1i32] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
409 }{ |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
410 If[[byte]<[224u8]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
411 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
412 expect <- 1i32 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
413 }{ |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
414 If[[byte]<[240u8]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
415 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
416 expect <- 2i32 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
417 }{ |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
418 If[[byte]<[245u8]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
419 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
420 expect <- 3i32 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
421 }{ |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
422 //Error |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
423 nboff <- [boff]+[1i32] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
424 ncur <- [cur]+[1i32] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
425 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
426 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
427 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
428 Val[expect] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
429 { |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
430 out <- _CPOff to BOff[buff, cur, [boff]+[1i32], cpoff, expect, 1i32] {} |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
431 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
432 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
433 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
434 out <- CPOff to BOff[buff, ncur, cpoff, nboff] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
435 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
436 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
437 |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
438 Slice@String[string,slicepoint:left,right] |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
439 { |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
440 If[[slicepoint]>=[[string]Length]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
441 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
442 left <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
443 right <- "" |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
444 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
445 If[[slicepoint]<=[0]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
446 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
447 left <- "" |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
448 right <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
449 }{ |
153
d86df83402f3
Small performance optimization in string lib
Mike Pavone <pavone@retrodev.com>
parents:
136
diff
changeset
|
450 If[[[string]Length] = [[string]Byte Length]] |
d86df83402f3
Small performance optimization in string lib
Mike Pavone <pavone@retrodev.com>
parents:
136
diff
changeset
|
451 { sliceoffset <- Val[slicepoint] } |
d86df83402f3
Small performance optimization in string lib
Mike Pavone <pavone@retrodev.com>
parents:
136
diff
changeset
|
452 { sliceoffset <- CPOff to BOff[[string]Buffer >>, 0i32, 0i32, slicepoint] } |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
453 left <- String Slice[string, 0i32, slicepoint, sliceoffset] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
454 right <- String Slice[string, sliceoffset, [[string]Length >>]-[slicepoint], [[[string]Buffer >>]Length]-[sliceoffset]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
455 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
456 } |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
457 } |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
458 |
156
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
459 Substring@String[string,start,length:out] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
460 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
461 If[[start]>=[[string]Length]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
462 { out <- "" } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
463 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
464 If[[length]<=[0]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
465 { slength <- [[[string]Length]-[start]]+[length] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
466 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
467 If[[[start]+[length]] > [[string]Length]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
468 { slength <- [[string]Length]-[start] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
469 { slength <- Val[length] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
470 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
471 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
472 If[[[string]Length] = [[string]Byte Length]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
473 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
474 sliceoffset <- Val[start] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
475 sbytelen <- Val[slength] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
476 }{ |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
477 sliceoffset <- CPOff to BOff[[string]Buffer >>, 0i32, 0i32, start] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
478 sbytelen <- CPOff to BOff[[string]Buffer >>, 0i32, sliceoffset, slength] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
479 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
480 out <- String Slice[string, sliceoffset, slength, sbytelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
481 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
482 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
483 |
72
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
484 Byte@String[string,index:out,invalid] |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
485 { |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
486 out,invalid <- [[string]Buffer >>]Index[index] |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
487 } |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
488 |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
489 Length@String[string:out] |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
490 { |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
491 out <- [string]Length >> |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
492 } |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
493 |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
494 _=String[left,right,index:out] |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
495 { |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
496 [left]Byte[index] |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
497 { |
104
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
498 rbyte <- [right]Byte[index] |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
499 ,out <- If[[~]=[rbyte]] |
72
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
500 { |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
501 out <- _=String[left,right,[index]+[1]] |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
502 } |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
503 }{ |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
504 out <- Yes |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
505 } |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
506 } |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
507 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
508 Eq String[left,right:out] |
72
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
509 { |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
510 ,out <- If[[[left]Length] = [[right]Length]] |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
511 { |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
512 out <- _=String[left,right,0] |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
513 } |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
514 } |
f7bcf3db1342
Add =@String, fix bool bug
Mike Pavone <pavone@retrodev.com>
parents:
71
diff
changeset
|
515 |
104
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
516 Foreign C:libc |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
517 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
518 memcmp[a(Array,Raw Pointer),b(Array,Raw Pointer),len(Int64,Naked):out(Int32,Naked)] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
519 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
520 |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
521 Foreign C:runtime |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
522 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
523 _internal_memcmp_offset[left(Array,Raw Pointer),loffset(Int32,Naked),right(Array,Raw Pointer),roffset(Int32,Naked),len(Int32,Naked):out(Int32,Naked)] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
524 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
525 |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
526 _Flat=@String[left,right:out] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
527 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
528 ,out <- If[[[left]Byte Length] = [[right]Byte Length]] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
529 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
530 If[memcmp[[left]Buffer >>, [right]Buffer >>, Int64[[left]Byte Length]]] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
531 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
532 out <- No |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
533 }{ |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
534 out <- Yes |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
535 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
536 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
537 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
538 |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
539 _Flat=@String Slice[left,right:out] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
540 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
541 ,out <- If[[[left]Byte Length] = [[right]Byte Length]] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
542 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
543 If[_internal_memcmp_offset[[[left]Source >>]Buffer >>, [left]Offset >>, [right]Buffer >>, 0i32, [left]Byte Length]] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
544 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
545 out <- No |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
546 }{ |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
547 out <- Yes |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
548 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
549 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
550 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
551 |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
552 _Flat=@String Cat[left,right:out] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
553 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
554 out <- Eq String[left,right] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
555 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
556 |
156
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
557 _Find Memcmp[haybuf,hayoff,haylen,needlebuf,needleoff,needlelen:found,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
558 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
559 not found <- If[[haylen]<[needlelen]] {} |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
560 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
561 If[_internal_memcmp_offset[haybuf, hayoff, needlebuf, needleoff, needlelen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
562 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
563 found,not found <- _Find Memcmp[haybuf, [hayoff]+[1], [haylen]-[1], needlebuf, needleoff, needlelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
564 }{ |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
565 found <- hayoff |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
566 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
567 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
568 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
569 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
570 _Find Flat@String[haystack,needlebuf,off,bytelen:found,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
571 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
572 found,not found <- _Find Memcmp[[haystack]Buffer >>, 0, [haystack]Byte Length, needlebuf, off, bytelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
573 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
574 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
575 _Find Flat@String Slice[haystack,needlebuf,off,bytelen:found,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
576 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
577 ,not found <- _Find Memcmp[[[haystack]Source >>]Buffer >>, [haystack]Offset >>, [haystack]Byte Length, needlebuf, off, bytelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
578 { found <- [~]-[[haystack]Offset >>] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
579 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
580 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
581 _Find Partial Memcmp[haybuf,hayoff,haylen,needlebuf,needleoff,needlelen:found,partial,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
582 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
583 If[[haylen]<[needlelen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
584 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
585 ,not found <- If[haylen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
586 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
587 cont <- If[_internal_memcmp_offset[haybuf, hayoff, needlebuf, needleoff, haylen]] {} |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
588 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
589 partial <- hayoff |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
590 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
591 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
592 }{ |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
593 cont <- If[_internal_memcmp_offset[haybuf, hayoff, needlebuf, needleoff, needlelen]] {} |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
594 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
595 found <- hayoff |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
596 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
597 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
598 Val[cont] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
599 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
600 found,partial,not found <- _Find Partial Memcmp[haybuf, [hayoff]+[1], [haylen]-[1], needlebuf, needleoff, needlelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
601 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
602 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
603 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
604 _Find Partial@String[haystack,hayoff,needlebuf,needleoff,needlelen:found,partial,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
605 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
606 found,partial,not found <- _Find Partial Memcmp[[haystack]Buffer >>, hayoff, [[haystack]Byte Length]-[hayoff], needlebuf, needleoff, needlelen] {} {} |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
607 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
608 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
609 _Check Rest@String[haystack,needlebuf,needleoff,needlelen:found,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
610 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
611 haylen <- [haystack]Byte Length |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
612 ,not found <- If[[haylen]<[needlelen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
613 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
614 not found,found <- If[_internal_memcmp_offset[[haystack]Buffer >>, 0, needlebuf, needleoff, needlelen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
615 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
616 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
617 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
618 _Check Rest@String Slice[haystack,needlebuf,needleoff,needlelen:found,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
619 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
620 haylen <- [haystack]Byte Length |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
621 ,not found <- If[[haylen]<[needlelen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
622 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
623 not found,found <- If[_internal_memcmp_offset[[[haystack]Source >>]Buffer >>, [haystack]Offset >>, needlebuf, needleoff, needlelen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
624 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
625 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
626 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
627 _Check Rest@String Slice[haystack,needlebuf,needleoff,needlelen:found,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
628 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
629 llen <- [[haystack]Left >>]Byte Length |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
630 If[[needlelen]<[llen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
631 { found,not found <- _Check Rest[[haystack]Left >>, needlebuf, needleoff, needlelen] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
632 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
633 ,not found <- _Check Rest[[haystack]Left >>, needlebuf, needleoff, llen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
634 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
635 found,not found <- _Check Rest[[haystack]Right >>, needlebuf, [needleoff]+[llen], [needlelen]-[llen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
636 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
637 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
638 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
639 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
640 _Find Partial@String Slice[haystack,hayoff,needlebuf,needleoff,needlelen:found,partial,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
641 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
642 ,,not found <- _Find Partial Memcmp[[[haystack]Source >>]Buffer >>, [hayoff]+[[haystack]Offset >>], [[haystack]Byte Length]-[hayoff], needlebuf, needleoff, needlelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
643 { found <- [~]-[[haystack]Offset >>] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
644 { partial <- [~]-[[haystack]Offset >>] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
645 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
646 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
647 _Find Partial@String Cat[haystack,hayoff,needlebuf,needleoff,needlelen:found,partial,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
648 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
649 llen <- [[haystack]Left >>]Byte Length |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
650 If[[hayoff] < [llen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
651 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
652 found,p,checkright <- [[haystack]Left >>]_Find Partial[hayoff,needlebuf,needleoff,needlelen] {} |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
653 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
654 partlen <- [llen]-[~] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
655 ,cont <- [[haystack]Right >>]_Check Rest[needlebuf,[needleoff]+[partlen], [needlelen]-[partlen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
656 { found <- Val[p] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
657 { found,partial,not found <- _Find Partial[haystack,[hayoff]+[1],needlebuf,needleoff,needlelen] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
658 }{ |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
659 found,partial,not found <- _Find Partial[haystack,llen,needlebuf,needleoff,needlelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
660 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
661 }{ |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
662 ,,not found <- [[haystack]Right >>]_Find Partial[[hayoff]-[llen],needlebuf,needleoff,needlelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
663 { found <- [~]+[llen] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
664 { partial <- [~]+[llen] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
665 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
666 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
667 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
668 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
669 _Find Flat@String Cat[haystack,needlebuf,off,bytelen:found,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
670 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
671 found,not found,not found <- _Find Partial[haystack, 0, needlebuf, off, bytelen] {} |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
672 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
673 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
674 =@String[left,right:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
675 { |
104
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
676 out <- [right]_Flat=[left] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
677 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
678 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
679 Byte Length@String[string:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
680 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
681 out <- [[string]Buffer >>]Length |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
682 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
683 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
684 Append@String[left,right:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
685 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
686 out <- String Cat[left,right] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
687 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
688 |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
689 Blueprint String Slice |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
690 { |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
691 Source |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
692 Offset(Int32,Naked) |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
693 Length(Int32,Naked) |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
694 ByteLen(Int32,Naked) |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
695 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
696 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
697 String Slice[source,offset,length,bytelen:out(String Slice)] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
698 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
699 out <- [[[[Build[String Slice()]]Source <<[source]]Offset <<[offset]]Length <<[length]]ByteLen <<[bytelen] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
700 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
701 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
702 Byte@String Slice[string,index:out,invalid] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
703 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
704 ,invalid <- If[[index]<[[string]ByteLen >>]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
705 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
706 out,invalid <- [[string]Source >>]Byte[[index]+[[string]Offset >>]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
707 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
708 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
709 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
710 Byte Length@String Slice[string:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
711 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
712 out <- [string]ByteLen >> |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
713 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
714 |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
715 Length@String Slice[string:out] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
716 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
717 out <- [string]Length >> |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
718 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
719 |
104
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
720 _Slice=@String Slice[left,right:out] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
721 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
722 ,out <- If[[[left]Byte Length]=[[right]Byte Length]] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
723 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
724 If[_internal_memcmp_offset[[[left]Source >>]Buffer >>, [left]Offset >>, [[right]Source >>]Buffer >>, [right]Offset >>, [left]Byte Length]] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
725 { out <- No } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
726 { out <- Yes } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
727 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
728 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
729 |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
730 _Slice=@String[left,right:out] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
731 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
732 out <- [right]_Flat=[left] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
733 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
734 |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
735 _Slice=@String Cat[left,right:out] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
736 { |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
737 out <- Eq String[left,right] |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
738 } |
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
739 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
740 =@String Slice[left,right:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
741 { |
104
2d2da148d844
Performance improvement for string comparisons
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
742 out <- [right]_Slice=[left] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
743 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
744 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
745 _Flatten@String[string,dest,offset,count:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
746 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
747 If[count] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
748 { |
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
749 out <- [_internal_array_copychunk[[string]Buffer >>, offset, dest, [dest]Length, count]]Length <<[[[dest]Length]+[count]] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
750 }{ |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
751 out <- dest |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
752 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
753 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
754 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
755 Flatten@String[string:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
756 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
757 out <- string |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
758 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
759 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
760 _Flatten@String Slice[string,dest,offset,count:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
761 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
762 out <- [[string]Source >>]_Flatten[dest, [[string]Offset >>]+[offset], count] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
763 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
764 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
765 Flatten@String Slice[string:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
766 { |
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
767 If[[string]ByteLen >>] |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
768 { |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
769 out <- [[Build[String()]]Buffer <<[ [[string]Source >>]_Flatten[_internal_array_allocnaked[[string]ByteLen >>, UInt8()], [string]Offset >>, [string]ByteLen >>] ] |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
770 ]Length <<[[string]Length >>] |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
771 }{ |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
772 out <- "" |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
773 } |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
774 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
775 |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
776 Print@String Slice[string:out] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
777 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
778 out <- Print[Flatten[string]] |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
779 } |
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
780 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
781 Append@String Slice[left,right:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
782 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
783 out <- String Cat[left,right] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
784 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
785 |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
786 Slice@String Slice[string,slicepoint:left,right] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
787 { |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
788 If[[slicepoint]>=[[string]Length]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
789 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
790 left <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
791 right <- "" |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
792 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
793 If[[slicepoint]<=[0]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
794 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
795 left <- "" |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
796 right <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
797 }{ |
153
d86df83402f3
Small performance optimization in string lib
Mike Pavone <pavone@retrodev.com>
parents:
136
diff
changeset
|
798 If[[[string]Length]=[[string]Byte Length]] |
d86df83402f3
Small performance optimization in string lib
Mike Pavone <pavone@retrodev.com>
parents:
136
diff
changeset
|
799 { sliceoffset <- [[string]Offset >>]+[slicepoint] } |
d86df83402f3
Small performance optimization in string lib
Mike Pavone <pavone@retrodev.com>
parents:
136
diff
changeset
|
800 { sliceoffset <- CPOff to BOff[[[string]Source >>]Buffer >>, 0i32, [string]Offset >>, slicepoint] } |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
801 left <- String Slice[[string]Source >>, [string]Offset >>, slicepoint, [sliceoffset]-[[string]Offset >>]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
802 right <- String Slice[[string]Source >>, sliceoffset, [[string]Length >>]-[slicepoint], [[string]Byte Length]-[[sliceoffset]-[[string]Offset >>]]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
803 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
804 } |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
805 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
806 |
156
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
807 Substring@String Slice[string,start,length:out] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
808 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
809 If[[start]>=[[string]Length]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
810 { out <- "" } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
811 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
812 If[[length]<=[0]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
813 { slength <- [[[string]Length]-[start]]+[length] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
814 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
815 If[[[start]+[length]] > [[string]Length]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
816 { slength <- [[string]Length]-[start] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
817 { slength <- Val[length] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
818 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
819 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
820 If[[[string]Length] = [[string]Byte Length]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
821 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
822 sliceoffset <- [[string]Offset >>]+[start] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
823 sbytelen <- Val[slength] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
824 }{ |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
825 sliceoffset <- CPOff to BOff[[[string]Source >>]Buffer >>, 0i32, [string]Offset >>, start] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
826 sbytelen <- CPOff to BOff[[[string]Source >>]Buffer >>, 0i32, sliceoffset, slength] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
827 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
828 out <- String Slice[[string]Source >>, sliceoffset, slength, sbytelen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
829 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
830 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
831 |
157
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
832 Depth@String[string:out] |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
833 { |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
834 out <- 0 |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
835 } |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
836 |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
837 Depth@String Slice[string:out] |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
838 { |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
839 out <- 0 |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
840 } |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
841 |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
842 Depth@String Cat[string:out] |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
843 { |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
844 out <- Depth >>[string] |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
845 } |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
846 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
847 Blueprint String Cat |
55
048046186d22
Started working on Slice@String
Mike Pavone <pavone@retrodev.com>
parents:
52
diff
changeset
|
848 { |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
849 Left |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
850 Right |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
851 Length |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
852 ByteLen |
157
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
853 Depth |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
854 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
855 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
856 String Cat[left,right:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
857 { |
157
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
858 out <- [[[[[Build[String Cat()] |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
859 ]Left <<[left] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
860 ]Right <<[right] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
861 ]Length <<[ [[left]Length]+[[right]Length] ] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
862 ]ByteLen <<[ [[left]Byte Length]+[[right]Byte Length] ] |
157
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
863 ]Depth <<[ [1]+[Min[[left]Depth, [right]Depth]] ] |
51
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
864 } |
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
865 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
866 Append@String Cat[left,right:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
867 { |
157
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
868 ll <- [left]Left >> |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
869 lr <- [left]Right >> |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
870 If[[[ll]Depth] > [[lr]Depth]] |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
871 { |
158
0e06f29aa83d
Small tweak to String Cat balance
Mike Pavone <pavone@retrodev.com>
parents:
157
diff
changeset
|
872 out <- String Cat[ll, Append[lr,right]] |
157
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
873 }{ |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
874 out <- String Cat[left,right] |
37b999dbd12e
Small change to make String Cat trees a little more balanced
Mike Pavone <pavone@retrodev.com>
parents:
156
diff
changeset
|
875 } |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
876 } |
51
7d6a6906b648
Added integer type conversions and started on the implementation of String
Mike Pavone <pavone@retrodev.com>
parents:
diff
changeset
|
877 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
878 Byte@String Cat[string,index:out,invalid] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
879 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
880 leftlen <- [[string]Left >>]Byte Length |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
881 If[[index]<[leftlen]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
882 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
883 out,invalid <- [[string]Left >>]Byte[index] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
884 }{ |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
885 rindex <- [index]-[leftlen] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
886 ,invalid <- If[[rindex]<[[[string]Right >>]Byte Length]] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
887 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
888 out,invalid <- [[string]Right >>]Byte[rindex] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
889 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
890 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
891 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
892 |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
893 Byte Length@String Cat[string:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
894 { |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
895 out <- [string]ByteLen >> |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
896 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
897 |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
898 Length@String Cat[string:out] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
899 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
900 out <- [string]Length >> |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
901 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
902 |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
903 _Flatten@String Cat[string,dest,offset,count:out] |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
904 { |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
905 left <- [string]Left >> |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
906 If[[offset] < [[left]Byte Length]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
907 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
908 lcount <- Min[[left]Byte Length, count] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
909 ldest <- [left]_Flatten[dest, offset, lcount] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
910 rcount <- [count]-[lcount] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
911 }{ |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
912 ldest <- Val[dest] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
913 rcount <- count |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
914 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
915 If[[[offset]+[count]]>[[left]Byte Length]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
916 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
917 right <- [string]Right >> |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
918 roffset <- Max[0, [offset]-[[left]Byte Length]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
919 out <- [right]_Flatten[ldest, roffset, Min[[right]Byte Length, rcount]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
920 }{ |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
921 out <- Val[ldest] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
922 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
923 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
924 |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
925 Flatten@String Cat[string:out] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
926 { |
105
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
927 If[[string]ByteLen >>] |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
928 { |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
929 out <- [[Build[String()] |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
930 ]Buffer << [ |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
931 [[string]Right >>]_Flatten[ |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
932 [[string]Left >>]_Flatten[_internal_array_allocnaked[[string]ByteLen >>, UInt8()], 0i32, [[string]Left >>]Byte Length], |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
933 0i32, [[string]Right >>]Byte Length]] |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
934 ]Length << [[string]Length >>] |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
935 }{ |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
936 out <- "" |
43cc42df26cc
Various compiler improvements
Mike Pavone <pavone@retrodev.com>
parents:
100
diff
changeset
|
937 } |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
938 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
939 |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
940 Print@String Cat[string:out] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
941 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
942 out <- Print[Flatten[string]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
943 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
944 |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
945 Slice@String Cat[string,slicepoint:left,right] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
946 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
947 llen <- [[string]Left >>]Length |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
948 If[[slicepoint]=[llen]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
949 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
950 left <- [string]Left >> |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
951 right <- [string]Right >> |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
952 }{ |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
953 If[[slicepoint]<[llen]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
954 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
955 left,lright <- [[string]Left >>]Slice[slicepoint] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
956 right <- String Cat[lright,[string]Right >>] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
957 }{ |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
958 rleft,right <- [[string]Right >>]Slice[ [slicepoint]-[llen] ] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
959 left <- String Cat[[string]Left >>, rleft] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
960 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
961 } |
77
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
962 } |
a748300a4143
Some untested progress on String
Mike Pavone <pavone@retrodev.com>
parents:
72
diff
changeset
|
963 |
156
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
964 Substring@String Cat[string,start,length:out] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
965 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
966 llen <- [[string]Left >>]Length |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
967 If[[start] >= [llen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
968 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
969 out <- [[string]Right >>]Substring[[start]-[llen],length] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
970 }{ |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
971 If[[length] <= [0]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
972 { slength <- [[[string]Length]-[start]]+[length] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
973 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
974 If[[[start]+[length]] > [[string]Length]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
975 { slength <- [[string]Length]-[start] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
976 { slength <- Val[length] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
977 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
978 If[[[start]+[slength]]<=[llen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
979 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
980 out <- [[string]Left >>]Substring[start, slength] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
981 }{ |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
982 new end <- [start]+[slength] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
983 If[[new end]=[[string]Length]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
984 { right <- Right >>[string] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
985 { right <- [[string]Right >>]Substring[0, [new end]-[[string]Length]] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
986 If[[start]=[0]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
987 { left <- Left >>[string] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
988 { left <- [[string]Left >>]Substring[start, 0] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
989 out <- String Cat[left, right] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
990 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
991 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
992 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
993 |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
994 =@String Cat[left,right:out] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
995 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
996 out <- Eq String[left,right] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
997 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
998 |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
999 =Delim[string,delims,index:outindex,after,nomatch] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1000 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1001 delim <- [delims]Index[index] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1002 If[[[string]Length]<[[delim]Length]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1003 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1004 try next <- Yes |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1005 }{ |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1006 check,mafter <- [string]Slice[[delim]Length] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1007 ,try next <- If[[check]=[delim]] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1008 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1009 outindex <- index |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1010 after <- Val[mafter] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1011 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1012 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1013 Val[try next] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1014 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1015 ,nomatch <- [delims]Next[index] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1016 { |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1017 outindex,after,nomatch <- =Delim[string,delims,~] |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1018 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1019 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1020 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1021 |
156
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1022 Match@String[string,cmp:num,no match,idx] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1023 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1024 n <- [string]Length |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1025 ,no match <- If[[string]=[[cmp]Substring[0, n]]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1026 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1027 num <- Val[n] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1028 idx <- 0 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1029 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1030 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1031 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1032 Match@String Slice[string,cmp:num,no match,idx] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1033 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1034 n <- [string]Length |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1035 ,no match <- If[[string]=[[cmp]Substring[0, n]]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1036 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1037 num <- Val[n] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1038 idx <- 0 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1039 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1040 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1041 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1042 _Partition@String[delim,string:matched,after,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1043 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1044 ,not found <- [string]_Find Flat[[delim]Buffer >>, 0, [delim]Byte Length] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1045 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1046 //TODO: Translate byte offset to cp offset when necessary |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1047 matched <- delim |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1048 after <- [string]Substring[[~]+[[delim]Length], 0] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1049 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1050 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1051 |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1052 _Partition@String Slice[delim,string:matched,after,not found] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1053 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1054 ,not found <- [string]_Find Flat[[[delim]Source >>]Buffer >>, [delim]Offset >>, [delim]Byte Length] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1055 { |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1056 //TODO: Translate byte offset to cp offset when necessary |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1057 matched <- delim |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1058 after <- [string]Substring[[~]+[[delim]Length], 0] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1059 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1060 } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1061 |
108
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1062 Pattern@String[string:out] |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1063 { |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1064 out <- string |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1065 } |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1066 |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1067 Pattern@String Slice[string:out] |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1068 { |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1069 out <- string |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1070 } |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1071 |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1072 Pattern@String Cat[string:out] |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1073 { |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1074 out <- Flatten[string] |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1075 } |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1076 |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1077 Partition[string,delims:before,matched,after,not found] |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1078 { |
156
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1079 matched,after,not found <- _Partition[Pattern[delims],string] |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1080 { dlen <- Length[~] } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1081 { alen <- Length[~] } |
156
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1082 blen <- [[string]Length]-[[dlen]+[alen]] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1083 If[blen] |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1084 { before <- [string]Substring[0, blen] } |
ed70399a07aa
Add Substring method to string and improve performance of Partition
Mike Pavone <pavone@retrodev.com>
parents:
153
diff
changeset
|
1085 { before <- "" } |
78
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1086 } |
4d5ea487f810
Working String implementation and some basic (but nowhere near exhaustive) tests
Mike Pavone <pavone@retrodev.com>
parents:
77
diff
changeset
|
1087 |
83
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1088 Dict Type ID@String[string:out] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1089 { |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1090 out <- ID[String()] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1091 } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1092 |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1093 Dict Type ID@String Cat[string:out] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1094 { |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1095 out <- ID[String()] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1096 } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1097 |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1098 Dict Type ID@String Slice[string:out] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1099 { |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1100 out <- ID[String()] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1101 } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1102 |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1103 Dict Bits@String[string,index:out,invalid] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1104 { |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1105 ,invalid <- [string]Byte[index] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1106 { out <- UInt32[~] } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1107 } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1108 |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1109 Dict Bits@String Cat[string,index:out,invalid] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1110 { |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1111 ,invalid <- [string]Byte[index] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1112 { out <- UInt32[~] } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1113 } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1114 |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1115 Dict Bits@String Slice[string,index:out,invalid] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1116 { |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1117 ,invalid <- [string]Byte[index] |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1118 { out <- UInt32[~] } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1119 } |
27bb051d631c
Initial implementation of Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
78
diff
changeset
|
1120 |
87
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1121 _From Dict String[arr,el:out] |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1122 { |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1123 out <- [arr]Append[Trunc UInt8[el]] |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1124 } |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1125 |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1126 From Dict Key@String[string,data:out] |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1127 { |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1128 out <- String[Fold[_From Dict String[?], Array[], data]] |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1129 } |
3c4325e6298f
Add First@Dictionary (need to find mem man bug)
Mike Pavone <pavone@retrodev.com>
parents:
83
diff
changeset
|
1130 |
90
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1131 String@String[string:out] |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1132 { |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1133 out <- string |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1134 } |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1135 |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1136 String@String Cat[string:out] |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1137 { |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1138 out <- string |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1139 } |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1140 |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1141 String@String Slice[string:out] |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1142 { |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1143 out <- string |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1144 } |
c25d75c2440b
Implemented Next@Dictionary and Print@Dictionary
Mike Pavone <pavone@retrodev.com>
parents:
87
diff
changeset
|
1145 |
160
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1146 _No Pattern Match[:out,no match] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1147 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1148 no match <- Yes |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1149 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1150 |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1151 _Iter Bytes Buf[buf,offset,first,last,func,if end:out,end,seekfout,seekout] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1152 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1153 [buf]Index[offset] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1154 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1155 out,nextf,no next,seekf,seek <- [func]Call[~] {} |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1156 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1157 If[[offset]<[last]] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1158 { out,end <- _Iter Bytes Buf[buf, [offset]+[1], first, last, nextf, no next] } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1159 { end <- [[()]Append[nextf]]Append[no next] } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1160 }{}{ |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1161 newoff <- [offset]-[seek] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1162 If[[newoff]<[first]] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1163 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1164 seekfout <- Val[seekf] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1165 seekout <- [first]-[newoff] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1166 }{ out,end <- _Iter Bytes Buf[buf, newoff, first, last, seekf, _No Pattern Match[?]] } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1167 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1168 }{ |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1169 end <- [[()]Append[func]]Append[if end] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1170 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1171 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1172 |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1173 _Iter Bytes@String[string,func,start,if end:out,end,seekfunc,seek] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1174 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1175 out,end,seekfunc,seek <- _Iter Bytes Buf[[string]Buffer >>, start, 0, [[string]Byte Length]-[1], func, if end] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1176 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1177 |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1178 _Iter Bytes@String Slice[string,func,start,if end:out,end,seekfunc,seek] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1179 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1180 out,end,seekfunc,seek <- _Iter Bytes Buf[[[string]Source >>]Buffer >>, [[string]Offset >>]+[start], [string]Offset >>, [[[string]Byte Length]-[1]]+[[string]Offset >>], func, if end] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1181 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1182 |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1183 _Iter Bytes@String Cat[string,func,start,if end:out,end,seekfunc,seek] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1184 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1185 llen <- [[string]Left >>]Byte Length |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1186 If[[start]<[llen]] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1187 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1188 out,,seekfunc,seek <- [[string]Left >>]_Iter Bytes[func, start, if end] {} |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1189 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1190 right off <- 0 |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1191 right func <- [~]Index[0] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1192 right if end <- [~]Index[1] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1193 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1194 }{ |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1195 right off <- [start]-[llen] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1196 right func <- Val[func] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1197 right if end <- Val[if end] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1198 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1199 |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1200 Val[right off] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1201 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1202 out,end,,rseek <- [[string]Right >>]_Iter Bytes[right func, ~, right if end] {} {} |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1203 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1204 out,end,seekfunc,seek <- [string]_Iter Bytes[~, [llen]-[rseek], _No Pattern Match[?]] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1205 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1206 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1207 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1208 |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1209 Iter Bytes[string,func,start:out,end] |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1210 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1211 out <- [string]_Iter Bytes[func, start, _No Pattern Match[?]] {} |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1212 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1213 out <- Call[[~]Index[1]] {} |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1214 { |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1215 end <- Yes |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1216 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1217 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1218 { end <- Yes } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1219 } |
f97a7d499182
Optimize _Partition@Pattern using a byte iterator
Mike Pavone <pavone@retrodev.com>
parents:
158
diff
changeset
|
1220 |
112
fd23ab2c1a73
Small changes to make profile data a little cleaner
Mike Pavone <pavone@retrodev.com>
parents:
110
diff
changeset
|
1221 Replace[string,otoreplace,with:out] |
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1222 { |
112
fd23ab2c1a73
Small changes to make profile data a little cleaner
Mike Pavone <pavone@retrodev.com>
parents:
110
diff
changeset
|
1223 toreplace <- Pattern[otoreplace] |
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1224 ,delim,after <-[string]Partition[toreplace] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1225 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1226 wt <- Blueprint Of[with] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1227 If[ [[[wt]=[String()]] Or [[wt]=[String Slice()]]] Or [[wt]=[String Cat()]] ] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1228 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1229 replacement <- with |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1230 }{ |
108
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1231 ,,idx <- [toreplace]Match[delim] |
a7add4db4a25
Improved implementation of Pattern
Mike Pavone <pavone@retrodev.com>
parents:
104
diff
changeset
|
1232 replacement <- [with]Index[idx] |
92
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1233 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1234 out <- [[~]Append[replacement]]Append[Replace[after,toreplace,with]] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1235 } {} {} { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1236 out <- string |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1237 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1238 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1239 |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1240 _Join[list,delim,current,index:out] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1241 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1242 [list]Next[index] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1243 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1244 out <- _Join[list, delim, [[current]Append[delim]]Append[String[[list]Index[~]]], ~] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1245 }{ |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1246 out <- current |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1247 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1248 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1249 |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1250 Join[list,delim:out] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1251 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1252 [list]First |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1253 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1254 out <- _Join[list, delim, String[[list]Index[~]], ~] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1255 }{ |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1256 out <- "" |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1257 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1258 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1259 |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1260 Starts With[thing,starts with:out] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1261 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1262 out <- [[thing]Slice[[starts with]Length]] = [starts with] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1263 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1264 |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1265 Ends With[thing,ends with:out] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1266 { |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1267 ,compare <- [thing]Slice[ [[thing]Length] - [[ends with]Length] ] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1268 out <- [compare] = [ends with] |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1269 } |
e73a93fb5de1
Beginning of port of compiler to itself, some bugfixes and a refcount optimization
Mike Pavone <pavone@retrodev.com>
parents:
90
diff
changeset
|
1270 |
99
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1271 If@String[str:yes,no] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1272 { |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1273 yes,no <- If[[str]Length] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1274 } |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1275 |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1276 If@String Cat[str:yes,no] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1277 { |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1278 yes,no <- If[[str]Length] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1279 } |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1280 |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1281 If@String Slice[str:yes,no] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1282 { |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1283 yes,no <- If[[str]Length] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1284 } |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1285 |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1286 _Split[list,string,delim:out] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1287 { |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1288 ,,rest <- [string]Partition[delim] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1289 { |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1290 out <- _Split[[list]Append[~], rest, delim] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1291 } {} {} { |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1292 out <- [list]Append[string] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1293 } |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1294 } |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1295 |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1296 Split[string,delim:out] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1297 { |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1298 If[string] |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1299 { out <- _Split[(),string,delim] } |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1300 { out <- () } |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1301 } |
e09c2d1d6d5b
Got dataflow graph code working in compiler (nworker_c.rhope)
Mike Pavone <pavone@retrodev.com>
parents:
92
diff
changeset
|
1302 |
100
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1303 In[needle,haystack:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1304 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1305 If[haystack] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1306 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1307 out <- If[[[haystack]Slice[Length[needle]]]=[needle]] {} |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1308 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1309 [haystack]Slice[1] {} |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1310 { out <- [needle]In[~] } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1311 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1312 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1313 out <- No |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1314 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1315 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1316 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1317 Left Trim[string,trim:trimmed] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1318 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1319 If[ [[string]Length] > [0] ] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1320 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1321 first,rest <- [string]Slice[1] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1322 If[ [first]In[trim] ] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1323 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1324 trimmed <- Left Trim[rest, trim] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1325 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1326 trimmed <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1327 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1328 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1329 trimmed <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1330 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1331 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1332 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1333 Right Trim[string,trim:trimmed] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1334 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1335 If[ [[string]Length] > [0] ] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1336 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1337 rest,last <- [string]Slice[ [[string]Length] - [1]] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1338 If[ [last]In[trim] ] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1339 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1340 trimmed <- Right Trim[rest, trim] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1341 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1342 trimmed <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1343 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1344 }{ |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1345 trimmed <- string |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1346 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1347 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1348 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1349 Trim[string,trim:trimmed] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1350 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1351 left <- Left Trim[string, trim] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1352 trimmed <- Right Trim[left, trim] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1353 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1354 |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1355 Contains[haystack,needle:out] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1356 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1357 [haystack]Partition[needle] |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1358 { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1359 out <- Yes |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1360 } {} {} { |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1361 out <- No |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1362 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1363 } |
f51c4c17457c
Broken port of parser to compiler
Mike Pavone <pavone@retrodev.com>
parents:
99
diff
changeset
|
1364 |
131
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1365 After[text,prefix:after,not found] |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1366 { |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1367 If[[text]Starts With[prefix]] |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1368 { |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1369 ,after <- [text]Slice[[prefix]Length] |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1370 }{ |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1371 not found <- text |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1372 } |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1373 } |
0a4682be2db2
Modify lexer and new parser to work in compiler
Mike Pavone <pavone@retrodev.com>
parents:
112
diff
changeset
|
1374 |