Mercurial > repos > rhope

comparison string.rhope @ 100:f51c4c17457c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Broken port of parser to compiler
author Mike Pavone <pavone@retrodev.com>
date Mon, 09 Aug 2010 02:03:57 -0400
parents e09c2d1d6d5b
children 2d2da148d844 43cc42df26cc
comparison
equal deleted inserted replaced
99:e09c2d1d6d5b 100:f51c4c17457c
104 read[0, [Array[]]Set[0, 0u8], 1i64] 104 read[0, [Array[]]Set[0, 0u8], 1i64]
105 {} 105 {}
106 { out <- String[~] } 106 { out <- String[~] }
107 } 107 }
108 108
109 _String to Int32[current,index,array:out] 109 _String to Int[current,index,array,ten,conv:out]
110 { 110 {
111 char <- [array]Index[index] 111 char <- [array]Index[index]
112 { 112 {
113 If[[char]<[48u8]] 113 If[[char]<[48u8]]
114 { 114 {
116 }{ 116 }{
117 If[[char]>[57u8]] 117 If[[char]>[57u8]]
118 { 118 {
119 out <- Val[current] 119 out <- Val[current]
120 }{ 120 }{
121 out <- _String to Int32[[[current]*[10i32]]+[Int32[[char]-[48u8]]], [index]+[1], array] 121 out <- _String to Int[[[current]*[ten]]+[[conv]Call[[char]-[48u8]]], [index]+[1], array, ten, conv]
122 } 122 }
123 } 123 }
124 124
125 }{ 125 }{
126 out <- Val[current] 126 out <- Val[current]
127 } 127 }
128 } 128 }
129 129
130 Int32@String[string:out] 130 U8toI8[val:out]
131 {
132 out <- Trunc Int8[Int16[val]]
133 }
134
135 Int8@String[string:out]
131 { 136 {
132 buf <- [string]Buffer >> 137 buf <- [string]Buffer >>
133 [buf]Index[0] 138 [buf]Index[0]
134 { 139 {
135 If[[~]=[45u8]] 140 If[[~]=[45u8]]
136 { 141 {
137 out <- [0i32]-[_String to Int32[0i32, 1, buf]] 142 out <- [0i8]-[_String to Int[0i8, 1, buf, 10i8, U8toI8[?]]]
138 }{ 143 }{
139 out <- _String to Int32[0i32, 0, buf] 144 out <- _String to Int[0i8, 0, buf, 10i8, U8toI8[?]]
145 }
146 }{
147 out <- 0i8
148 }
149
150 }
151
152
153 Int16@String[string:out]
154 {
155 buf <- [string]Buffer >>
156 [buf]Index[0]
157 {
158 If[[~]=[45u8]]
159 {
160 out <- [0i16]-[_String to Int[0i16, 1, buf, 10i16, Int16[?]]]
161 }{
162 out <- _String to Int[0i16, 0, buf, 10i16, Int16[?]]
163 }
164 }{
165 out <- 0i16
166 }
167
168 }
169
170 Int32@String[string:out]
171 {
172 buf <- [string]Buffer >>
173 [buf]Index[0]
174 {
175 If[[~]=[45u8]]
176 {
177 out <- [0i32]-[_String to Int[0i32, 1, buf, 10i32, Int32[?]]]
178 }{
179 out <- _String to Int[0i32, 0, buf, 10i32, Int32[?]]
140 } 180 }
141 }{ 181 }{
142 out <- 0i32 182 out <- 0i32
143 } 183 }
144 184
145 } 185 }
146 186
187 _Hex Int32[str,cur,idx:out]
188 {
189 char <- [str]Byte[idx]
190 {
191 //0-9
192 [char]Between[47u8, 58u8]
193 {
194 adjust <- 48u8
195 }{
196 //A-F
197 [char]Between[64u8, 71u8]
198 {
199 adjust <- 55u8
200 }{
201 //a-f
202 [char]Between[96u8, 103u8]
203 {
204 adjust <- 87u8
205 }{
206 out <- cur
207 }
208 }
209 }
210 Val[adjust]
211 {
212 out <- _Hex Int32[str, [[cur]*[16i32]]+[Int32[[char]-[adjust]]], [idx]+[1]]
213 }
214 }{
215 out <- cur
216 }
217 }
218
219 Hex Int32[str:out]
220 {
221 out <- _Hex Int32[str, 0i32, 0]
222 }
223
224 Int64@String[string:out]
225 {
226 buf <- [string]Buffer >>
227 [buf]Index[0]
228 {
229 If[[~]=[45u8]]
230 {
231 out <- [0i64]-[_String to Int[0i64, 1, buf, 10i64, Int64[?]]]
232 }{
233 out <- _String to Int[0i64, 0, buf, 10i64, Int64[?]]
234 }
235 }{
236 out <- 0i64
237 }
238
239 }
240
241 UInt8@String[string:out]
242 {
243 out <- _String to Int[0u8, 0, [string]Buffer >>, 10u8, Val[?]]
244 }
245
246
247 UInt16@String[string:out]
248 {
249 out <- _String to Int[0u16, 0, [string]Buffer >>, 10u16, UInt16[?]]
250
251 }
252
253 UInt32@String[string:out]
254 {
255 out <- _String to Int[0u32, 0, [string]Buffer >>, 10u32, UInt32[?]]
256
257 }
258
259 UInt64@String[string:out]
260 {
261 out <- _String to Int[0u64, 0, [string]Buffer >>, 10u64, UInt64[?]]
262 }
263
264 Int8@String Slice[string:out]
265 {
266 out <- Int8[[string]Flatten]
267 }
268
269 Int8@String Cat[string:out]
270 {
271 out <- Int8[[string]Flatten]
272 }
273
274 Int16@String Slice[string:out]
275 {
276 out <- Int16[[string]Flatten]
277 }
278
279 Int16@String Cat[string:out]
280 {
281 out <- Int16[[string]Flatten]
282 }
283
147 Int32@String Slice[string:out] 284 Int32@String Slice[string:out]
148 { 285 {
149 out <- Int32[[string]Flatten] 286 out <- Int32[[string]Flatten]
150 } 287 }
151 288
152 Int32@String Cat[string:out] 289 Int32@String Cat[string:out]
153 { 290 {
154 out <- Int32[[string]Flatten] 291 out <- Int32[[string]Flatten]
292 }
293
294 Int64@String Slice[string:out]
295 {
296 out <- Int64[[string]Flatten]
297 }
298
299 Int64@String Cat[string:out]
300 {
301 out <- Int64[[string]Flatten]
302 }
303
304 UInt8@String Slice[string:out]
305 {
306 out <- UInt8[[string]Flatten]
307 }
308
309 UInt8@String Cat[string:out]
310 {
311 out <- UInt8[[string]Flatten]
312 }
313
314 UInt16@String Slice[string:out]
315 {
316 out <- UInt16[[string]Flatten]
317 }
318
319 UInt16@String Cat[string:out]
320 {
321 out <- UInt16[[string]Flatten]
322 }
323
324 UInt32@String Slice[string:out]
325 {
326 out <- UInt32[[string]Flatten]
327 }
328
329 UInt32@String Cat[string:out]
330 {
331 out <- UInt32[[string]Flatten]
332 }
333
334 UInt64@String Slice[string:out]
335 {
336 out <- UInt64[[string]Flatten]
337 }
338
339 UInt64@String Cat[string:out]
340 {
341 out <- UInt64[[string]Flatten]
342 }
343
344 //TODO: Implement me once Real64 support is added
345 Real64[string:out]
346 {
347 out <- string
155 } 348 }
156 349
157 Flatten@String[string:out] 350 Flatten@String[string:out]
158 { 351 {
159 out <- string 352 out <- string
234 } 427 }
235 } 428 }
236 429
237 Slice@String[string,slicepoint:left,right] 430 Slice@String[string,slicepoint:left,right]
238 { 431 {
239 //TODO: Handle invalid slicepoints 432 If[[slicepoint]>=[[string]Length]]
240 sliceoffset <- CPOff to BOff[[string]Buffer >>, 0i32, 0i32, slicepoint] 433 {
241 left <- String Slice[string, 0i32, slicepoint, sliceoffset] 434 left <- string
242 right <- String Slice[string, sliceoffset, [[string]Length >>]-[slicepoint], [[[string]Buffer >>]Length]-[sliceoffset]] 435 right <- ""
436 }{
437 If[[slicepoint]<=[0]]
438 {
439 left <- ""
440 right <- string
441 }{
442 sliceoffset <- CPOff to BOff[[string]Buffer >>, 0i32, 0i32, slicepoint]
443 left <- String Slice[string, 0i32, slicepoint, sliceoffset]
444 right <- String Slice[string, sliceoffset, [[string]Length >>]-[slicepoint], [[[string]Buffer >>]Length]-[sliceoffset]]
445 }
446 }
243 } 447 }
244 448
245 Byte@String[string,index:out,invalid] 449 Byte@String[string,index:out,invalid]
246 { 450 {
247 out,invalid <- [[string]Buffer >>]Index[index] 451 out,invalid <- [[string]Buffer >>]Index[index]
371 out <- String Cat[left,right] 575 out <- String Cat[left,right]
372 } 576 }
373 577
374 Slice@String Slice[string,slicepoint:left,right] 578 Slice@String Slice[string,slicepoint:left,right]
375 { 579 {
376 //TODO: Handle invalid slicepoints 580 If[[slicepoint]>=[[string]Length]]
377 sliceoffset <- CPOff to BOff[[[string]Source >>]Buffer >>, 0i32, [string]Offset >>, slicepoint] 581 {
378 left <- String Slice[[string]Source >>, [string]Offset >>, slicepoint, [sliceoffset]-[[string]Offset >>]] 582 left <- string
379 right <- String Slice[[string]Source >>, sliceoffset, [[string]Length >>]-[slicepoint], [[string]Byte Length]-[[sliceoffset]-[[string]Offset >>]]] 583 right <- ""
584 }{
585 If[[slicepoint]<=[0]]
586 {
587 left <- ""
588 right <- string
589 }{
590 sliceoffset <- CPOff to BOff[[[string]Source >>]Buffer >>, 0i32, [string]Offset >>, slicepoint]
591 left <- String Slice[[string]Source >>, [string]Offset >>, slicepoint, [sliceoffset]-[[string]Offset >>]]
592 right <- String Slice[[string]Source >>, sliceoffset, [[string]Length >>]-[slicepoint], [[string]Byte Length]-[[sliceoffset]-[[string]Offset >>]]]
593 }
594 }
380 } 595 }
381 596
382 Blueprint String Cat 597 Blueprint String Cat
383 { 598 {
384 Left 599 Left
677 If[string] 892 If[string]
678 { out <- _Split[(),string,delim] } 893 { out <- _Split[(),string,delim] }
679 { out <- () } 894 { out <- () }
680 } 895 }
681 896
897 In[needle,haystack:out]
898 {
899 If[haystack]
900 {
901 out <- If[[[haystack]Slice[Length[needle]]]=[needle]] {}
902 {
903 [haystack]Slice[1] {}
904 { out <- [needle]In[~] }
905 }
906 }{
907 out <- No
908 }
909 }
910
911 Left Trim[string,trim:trimmed]
912 {
913 If[ [[string]Length] > [0] ]
914 {
915 first,rest <- [string]Slice[1]
916 If[ [first]In[trim] ]
917 {
918 trimmed <- Left Trim[rest, trim]
919 }{
920 trimmed <- string
921 }
922 }{
923 trimmed <- string
924 }
925 }
926
927 Right Trim[string,trim:trimmed]
928 {
929 If[ [[string]Length] > [0] ]
930 {
931 rest,last <- [string]Slice[ [[string]Length] - [1]]
932 If[ [last]In[trim] ]
933 {
934 trimmed <- Right Trim[rest, trim]
935 }{
936 trimmed <- string
937 }
938 }{
939 trimmed <- string
940 }
941 }
942
943 Trim[string,trim:trimmed]
944 {
945 left <- Left Trim[string, trim]
946 trimmed <- Right Trim[left, trim]
947 }
948
949 Contains[haystack,needle:out]
950 {
951 [haystack]Partition[needle]
952 {
953 out <- Yes
954 } {} {} {
955 out <- No
956 }
957 }
958