Mercurial > repos > rhope
annotate parser.vistxt @ 187:5e752cf2d6b1
Add versions of compile and ctobin scripts that have desktop notifications
| author | Mike Pavone <pavone@retrodev.com> |
|---|---|
| date | Fri, 07 Oct 2011 00:11:30 -0700 |
| parents | 6202b866d72c |
| children |
| rev | line source |
|---|---|
| 0 | 1 Import extendlib.vistxt |
| 2 | |
| 3 | |
| 4 | |
| 5 Company Parser | |
| 6 |: | |
| 7 Arg Begin | |
| 8 Arg End | |
| 9 Line Comment | |
| 10 Comment Begin | |
| 11 Comment End | |
| 12 Assign | |
| 13 Block Begin | |
| 14 Block End | |
| 15 Blueprint Type Delim | |
| 16 Empty Block | |
| 17 Binary Operator | |
| 18 String Begin | |
| 19 String End | |
| 20 String Escape | |
| 21 List Begin | |
| 22 List End | |
| 23 List Delim | |
| 24 In Out Delim | |
| 25 Do Worker | |
| 26 Index Begin | |
| 27 Index End | |
| 28 Previous | |
| 29 Block Val | |
| 30 Set Field | |
| 31 Get Field | |
| 32 Import | |
| 33 Blueprint | |
| 34 Global Separator | |
| 35 Uses | |
| 36 Hex Escape | |
| 37 Escape Map | |
| 38 :| | |
| 39 | |
| 40 New@Parser(0,1) | |
| 41 |: | |
| 42 out(0) <- [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Build["Parser"] | |
| 43 ]Arg Begin << ["["] | |
| 44 ]Arg End <<["]"] | |
| 45 ]Line Comment <<["//"] | |
| 46 ]Comment Begin <<["/*"] | |
| 47 ]Comment End <<["*/"] | |
| 48 ]Assign <<["<-"] | |
| 49 ]Block Begin <<["{"] | |
| 50 ]Block End <<["}"] | |
| 51 ]Blueprint Type Delim <<[":"] | |
| 52 ]Empty Block <<[";"] | |
| 53 ]Binary Operator <<["`"] | |
| 54 ]String Begin <<["\""] | |
| 55 ]String End <<["\""] | |
| 56 ]String Escape <<["\\"] | |
| 57 ]List Begin <<["("] | |
| 58 ]List End <<[")"] | |
| 59 ]List Delim <<[","] | |
| 60 ]In Out Delim <<[":"] | |
| 61 ]Do Worker <<["$"] | |
| 62 ]Index Begin <<["("] | |
| 63 ]Index End <<[")"] | |
| 64 ]Previous <<["@"] | |
| 65 ]Set Field <<["<<"] | |
| 66 ]Get Field <<[">>"] | |
| 67 ]Import <<["Import"] | |
| 68 ]Blueprint <<["Blueprint"] | |
| 69 ]Global Separator <<["::"] | |
| 70 ]Hex Escape <<["x"] | |
| 71 ]Uses <<["uses"] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
72 ]Escape Map <<[[[[Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]] |
| 0 | 73 :| |
| 74 | |
| 75 Company Output Reference | |
| 76 |: | |
| 77 Index | |
| 78 Output Number | |
| 79 :| | |
| 80 | |
| 81 New@Output Reference(2,1) | |
| 82 |: | |
| 83 out(0) <- [[Build["Output Reference"]]Index <<[index(0)]]Output Number <<[num(1)] | |
| 84 :| | |
| 85 | |
| 86 Add Pipe Reference(3,1) | |
| 87 |: | |
| 88 reflist <- [refs(0)]Index[name(1)] |::| | |
| 89 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
90 reflist <- List[] |
| 0 | 91 :| |
| 92 out(0) <- [refs(0)]Set[name(1), [reflist]Append[reference(2)]] | |
| 93 :| | |
| 94 | |
| 95 Assignment Save Reference(5,1) | |
| 96 |: | |
| 97 [[parse worker(3)]Outputs >>]Find[assignment(1)] | |
| 98 |: | |
| 99 out(0) <- refs(0) | |
| 100 :||: | |
| 101 out(0) <- Add Pipe Reference[refs(0), assignment(1), New@Output Reference[index(4), output num(2)]] | |
| 102 :| | |
| 103 :| | |
| 104 | |
| 105 Company Parse Program | |
| 106 |: | |
| 107 Workers | |
| 108 Imports | |
| 109 Blueprints | |
| 110 Errors | |
| 111 :| | |
| 112 | |
| 113 New@Parse Program(0,1) | |
| 114 |: | |
| 115 out(0) <- [[[Build["Parse Program"] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
116 ]Workers <<[Dictionary[]] |
|
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
117 ]Imports <<[Dictionary[]] |
|
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
118 ]Blueprints <<[Dictionary[]] |
| 0 | 119 :| |
| 120 | |
| 121 Company Blueprint Definition | |
| 122 |: | |
| 123 Name | |
| 124 Fields | |
| 125 :| | |
| 126 | |
| 127 New@Blueprint Definition(2,1) | |
| 128 |: | |
| 129 out(0) <- [[Build["Blueprint Definition"]]Name << [name(0)]]Fields <<[fields(1)] | |
| 130 :| | |
| 131 | |
| 132 Company Parse Worker | |
| 133 |: | |
| 134 Name | |
| 135 Inputs | |
| 136 Outputs | |
| 137 Line Number | |
| 138 Trees | |
| 139 Uses Stores | |
| 140 :| | |
| 141 | |
| 142 New@Parse Worker(4,1) | |
| 143 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
144 out(0) <- [[[[[[Build["Parse Worker"]]Name <<[name(0)]]Inputs <<[inputs(1)]]Outputs <<[outputs(2)]]Line Number <<[line(3)]]Trees <<[List[]]]Uses Stores <<[List[]] |
| 0 | 145 :| |
| 146 | |
| 147 Company Worker Node | |
| 148 |: | |
| 149 Name | |
| 150 Params | |
| 151 Assignments | |
| 152 Blocks | |
| 153 Index | |
| 154 :| | |
| 155 | |
| 156 New@Worker Node(2,1) | |
| 157 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
158 out(0) <- [[[[Build["Worker Node"]]Name <<[name(0)]]Params <<[params(1)]]Assignments <<[List[]]]Blocks <<[List[]] |
| 0 | 159 :| |
| 160 | |
| 161 Add List Helper(6,3) | |
| 162 |: | |
| 163 ,nextworker,nextrefs <- [[list(0)]Index[key(3)]]Add to Worker[worker(1), program(2), parse worker(4), refs(5)] | |
| 164 |: nextlist <- [list(0)]Set[key(3), ~] :| | |
| 165 [list(0)]Next[key(3)] | |
| 166 |: | |
| 167 list(0),worker(1),refs(2) <- Add List Helper[nextlist, nextworker, program(2), ~, parse worker(4), nextrefs] | |
| 168 :||: | |
| 169 list(0) <- Val[nextlist] | |
| 170 worker(1) <- Val[nextworker] | |
| 171 refs(2) <- Val[nextrefs] | |
| 172 :| | |
| 173 :| | |
| 174 | |
| 175 Add List to Worker(5,3) | |
| 176 |: | |
| 177 [list(0)]First | |
| 178 |: | |
| 179 list(0),worker(1),refs(2) <- Add List Helper[list(0), worker(1), program(2), ~, parse worker(3), refs(4)] | |
| 180 :||: | |
| 181 list(0) <- list(0) | |
| 182 worker(1) <- worker(1) | |
| 183 refs(2) <- refs(4) | |
| 184 :| | |
| 185 :| | |
| 186 | |
| 187 _Add Blocks to Worker(6,3) | |
| 188 |: | |
| 189 block, next worker, nextrefs <- Add List to Worker[[blocks(0)]Index[key(4)], worker(1), program(2), parse worker(3), refs(5)] | |
| 190 next blocks <- [blocks(0)]Set[key(4), block] | |
| 191 [blocks(0)]Next[key(4)] | |
| 192 |: | |
| 193 blocks(0),worker(1),refs(2) <- _Add Blocks to Worker[next blocks, next worker, program(2), parseworker(3), ~, nextrefs] | |
| 194 :||: | |
| 195 blocks(0) <- Val[next blocks] | |
| 196 worker(1) <- Val[next worker] | |
| 197 refs(2) <- Val[nextrefs] | |
| 198 :| | |
| 199 :| | |
| 200 | |
| 201 Add Blocks to Worker(5,3) | |
| 202 |: | |
| 203 [blocks(0)]First | |
| 204 |: | |
| 205 blocks(0), worker(1), refs(2) <- _Add Blocks to Worker[blocks(0), worker(1), program(2), parse worker(3), ~, refs(4)] | |
| 206 :||: | |
| 207 blocks(0) <- blocks(0) | |
| 208 worker(1) <- worker(1) | |
| 209 refs(2) <- refs(4) | |
| 210 :| | |
| 211 :| | |
| 212 | |
| 213 Add to Worker@Worker Node(5,3) | |
| 214 |: | |
| 215 [program(2)]Find Worker[[node(0)]Name >>] | |
| 216 |: | |
| 217 after worker <- [worker(1)]Add Worker Call[~] |::| | |
| 218 |: | |
| 219 assignment refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>] | |
| 220 [node(0)]Index <<[~] | |
| 221 |: | |
| 222 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program(2), parse worker(3), assignment refs] | |
| 223 block list, worker(1), refs(2) <- Add Blocks to Worker[[~]Blocks >>, params worker, program(2), parse worker(3), params refs] | |
| 224 node(0) <- [[~]Params <<[params list]]Blocks <<[block list] | |
| 225 :| | |
| 226 :| | |
| 227 :||: | |
|
37
640f541e9116
Added support for type declarations on user defined workers and added a few more methods to Int32 in the runtime for the C backend
Mike Pavone <pavone@retrodev.com>
parents:
13
diff
changeset
|
228 Print[[[["Error: Could not find a worker named "]Append[[node(0)]Name >>]]Append[" in worker "]]Append[ [parse worker(3)]Name >> ]] |
| 0 | 229 :| |
| 230 :| | |
| 231 | |
| 232 Add Multi Wire(5,1) | |
| 233 |: | |
| 234 out(0) <- [worker(0)]Add Wire[[ref(1)]Index >>, [ref(1)]Output Number >>, end index(3), input num(4)] | |
| 235 :| | |
| 236 | |
| 237 Add Param Wire(7,1) | |
| 238 |: | |
| 239 param worker, start index, output num <- [param(1)]Add Wires[worker(0), blocks(4), parse worker(5), assignments(6)] |::| | |
| 240 |: | |
| 241 out(0) <- [param worker]Add Wire[start index, output num, end index(3), input num(2)] | |
| 242 :||::||: | |
| 243 out(0) <- Fold[[["Add Multi Wire"]Set Input[3, end index(3)]]Set Input[4, input num(2)], param worker, ~] | |
| 244 :| | |
| 245 :| | |
| 246 | |
| 247 _Add Block Wire(6,1) | |
| 248 |: | |
| 249 out(0) <- [node(1)]Add Wires[worker(0), blocks(3), parse worker(4), assignments(5)] | |
| 250 :| | |
| 251 | |
| 252 Add Block Wire(7,1) | |
| 253 |: | |
| 254 blocks <- [existing blocks(4)]Append[New@Output Reference[parent index(3), output num(2)]] | |
| 255 out(0) <- Fold[[[["_Add Block Wire"]Set Input[3, blocks]]Set Input[4, parse worker(5)]]Set Input[5, assignments(6)], worker(0), block nodes(1)] | |
| 256 //out(0) <- [param(1)]Add Wires[worker(0), blocks] | |
| 257 :| | |
| 258 | |
| 259 Assignments Add Wires(5,1) | |
| 260 |: | |
| 261 [[parse worker(3)]Outputs >>]Find[assignment(1)] | |
| 262 |: | |
| 263 ,output index <- [worker(0)]Add Output[assignment(1), ~] | |
| 264 |: | |
| 265 worker(0) <- [~]Add Wire[start index(4), output num(2), output index, 0] | |
| 266 :| | |
| 267 :||: | |
| 268 //Ugly hack alert! | |
| 269 If[[asignment(1)]Contains["::"]] | |
| 270 |: | |
| 271 parts <- [assignment(1)]Split["::"] | |
| 272 ,global index <- [worker(0)]Add Global Set[[parts]Index[0], [parts]Index[1]] | |
| 273 |: | |
| 274 worker(0) <- [~]Add Wire[start index(4), output num(2), global index, 0] | |
| 275 :| | |
| 276 :||: | |
| 277 worker(0) <- worker(0) | |
| 278 :| | |
| 279 :| | |
| 280 :| | |
| 281 | |
| 282 Has Block@Worker Node(1,2) | |
| 283 |: | |
| 284 out(0) <- Yes | |
| 285 :| | |
| 286 | |
| 287 _Has Block Params(2,1) | |
| 288 |: | |
| 289 param <- [param list(0)]Index[key(1)] | |
| 290 out(0) <- [param]Has Block |::| | |
| 291 |: | |
| 292 [param list(0)]Next[key(1)] | |
| 293 |: | |
| 294 out(0) <- _Has Block Params[param list(0), ~] | |
| 295 :||: | |
| 296 out(0) <- No | |
| 297 :| | |
| 298 :| | |
| 299 | |
| 300 :| | |
| 301 | |
| 302 Has Block Params(1,1) | |
| 303 |: | |
| 304 [param list(0)]First | |
| 305 |: | |
| 306 out(0) <- _Has Block Params[param list(0), ~] | |
| 307 :||: | |
| 308 out(0) <- No | |
| 309 :| | |
| 310 :| | |
| 311 | |
| 312 Add Wires@Worker Node(5,4) | |
| 313 |: | |
| 314 worker(0),index(1),num(2) <- Add Wires Worker or Field[node(0), worker(1), blocks(2), parse worker(3), assignments(4)] | |
| 315 :| | |
| 316 | |
| 317 Add Wires Worker or Field(5,4) | |
| 318 |: | |
| 319 Fold[[["Assignments Add Wires"]Set Input[3, parse worker(3)]]Set Input[4, [node(0)]Index >>], worker(1), [node(0)]Assignments >>] | |
| 320 |: Fold[[[[["Add Block Wire"]Set Input[3, [node(0)]Index >>]]Set Input[4, blocks(2)]]Set Input[5, parse worker(3)]]Set Input[6, assignments(4)], ~, [node(0)]Blocks >>] | |
| 321 |: params worker <- Fold[[[[["Add Param Wire"]Set Input[3, [node(0)]Index >>]]Set Input[4, blocks(2)]]Set Input[5, parse worker(3)]]Set Input[6, assignments(4)], ~, [node(0)]Params >>] :|:| | |
| 322 If[Has Block Params[[node(0)]Params >>]] | |
| 323 |: | |
| 324 worker(0) <- Val[params worker] | |
| 325 :||: | |
| 326 [blocks(2)]Peek | |
| 327 |: | |
| 328 worker(0) <- [params worker]Add Wire[[~]Index >>, [~]Output Number >>, [node(0)]Index >>, [0]-[1]] | |
| 329 :||: | |
| 330 worker(0) <- Val[params worker] | |
| 331 :| | |
| 332 :| | |
| 333 index(1) <- [node(0)]Index >> | |
| 334 num(2) <- 0 | |
| 335 :| | |
| 336 | |
| 337 Company Field Node | |
| 338 |: | |
| 339 Name | |
| 340 Params | |
| 341 Assignments | |
| 342 Blocks | |
| 343 Index | |
| 344 Set? | |
| 345 :| | |
| 346 | |
| 347 Has Block@Field Node(1,2) | |
| 348 |: | |
| 349 has block(0) <- Yes | |
| 350 :| | |
| 351 | |
| 352 New@Field Node(3,1) | |
| 353 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
354 out(0) <- [[[[[Build["Field Node"]]Name <<[name(0)]]Assignments <<[List[]]]Blocks <<[List[]]]Set? <<[set(2)]]Params <<[params(1)] |
| 0 | 355 :| |
| 356 | |
| 357 Add to Worker@Field Node(5,3) | |
| 358 |: | |
| 359 If[[node(0)]Set? >>] | |
| 360 |: | |
| 361 after worker,index <- [worker(1)]Add Object Set[[node(0)]Name >>] | |
| 362 :||: | |
| 363 after worker,index <- [worker(1)]Add Object Get[[node(0)]Name >>] | |
| 364 :| | |
| 365 index | |
| 366 |: | |
| 367 assignment refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>] | |
| 368 [node(0)]Index <<[~] | |
| 369 |: | |
| 370 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program(2), parse worker(3), assignment refs] | |
| 371 block list, worker(1), refs(2) <- Add Blocks to Worker[[~]Blocks >>, params worker, program(2), parse worker(3), params refs] | |
| 372 node(0) <- [[~]Params <<[params list]]Blocks <<[block list] | |
| 373 :| | |
| 374 :| | |
| 375 :| | |
| 376 | |
| 377 Add Wires@Field Node(5,4) | |
| 378 |: | |
| 379 worker(0),index(1),num(2) <- Add Wires Worker or Field[node(0), worker(1), blocks(2), parse worker(3), assignments(4)] | |
| 380 :| | |
| 381 | |
| 382 Company Named Pipe Node | |
| 383 |: | |
| 384 Name | |
| 385 Assignments | |
| 386 Blocks | |
| 387 Index | |
| 388 :| | |
| 389 | |
| 390 Has Block@Named Pipe Node(1,2) | |
| 391 |: | |
| 392 If[[[node(0)]Index >>] < [0]] | |
| 393 |: | |
| 394 //~ should really be a parser parameter | |
| 395 If[[[node(0)]Name >>] = ["~"]] | |
| 396 |: | |
| 397 has block(0) <- Yes | |
| 398 :||: | |
| 399 no block(1) <- No | |
| 400 :| | |
| 401 :||: | |
| 402 has block(0) <- Yes | |
| 403 :| | |
| 404 :| | |
| 405 | |
| 406 New@Named Pipe Node(1,1) | |
| 407 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
408 out(0) <- [[[Build["Named Pipe Node"]]Name <<[name(0)]]Assignments <<[List[]]]Blocks <<[List[]] |
| 0 | 409 :| |
| 410 | |
| 411 Add to Worker@Named Pipe Node(5,3) | |
| 412 |: | |
| 413 [[parse worker(3)]Inputs >>]Find[[node(0)]Name >>] | |
| 414 |: | |
| 415 after add <- [worker(1)]Add Input[[node(0)]Name >>, ~] |::| | |
| 416 |: | |
| 417 assign refs <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>] | |
| 418 index node <- [node(0)]Index <<[~] | |
| 419 :| | |
| 420 :||: | |
| 421 after add <- worker(1) | |
| 422 index node <- [node(0)]Index <<[[0]-[1]] | |
| 423 //TODO: Handle assignments from a named pipe that isn't an input | |
| 424 assign refs <- refs(4) | |
| 425 :| | |
| 426 block list, worker(1), refs(2) <- Add Blocks to Worker[[node(0)]Blocks >>, after add, program(2), parse worker(3), assign refs] | |
| 427 node(0) <- [index node]Blocks <<[block list] | |
| 428 :| | |
| 429 | |
| 430 Add Wires@Named Pipe Node(5,4) | |
| 431 |: | |
| 432 reflist(3) <- [assignments(4)]Index[[node(0)]Name >>] | |
| 433 |: | |
| 434 //TODO: Fix support for a named pipe with a block | |
| 435 worker(0) <- worker (1) | |
| 436 :||: | |
| 437 If[[[node(0)]Name >>] = ["~"]] | |
| 438 |: | |
| 439 wires worker <- worker(1) | |
| 440 [blocks(2)]Peek | |
| 441 |: | |
| 442 my index <- [~]Index >> | |
| 443 num(2) <- [~]Output Number >> | |
| 444 :||: | |
| 445 //TODO: Propagate an error rather than printing it out | |
| 446 Print["Error, block reference symbol (~) located outside of a block"] | |
| 447 :| | |
| 448 :||: | |
| 449 If[[[node(0)]Index >>] < [0]] | |
| 450 |: | |
| 451 Print[[[["Error, reference to named pipe "]Append[[node(0)]Name >>]]Append[" that was never assigned to in worker "]]Append[[parse worker(3)]Name >>]] | |
| 452 :||: | |
| 453 my index <- [node(0)]Index >> | |
| 454 num(2) <- 0 | |
| 455 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker(3)]]Set Input[4, [node(0)]Index >>], worker(1), [node(0)]Assignments >>] | |
| 456 [blocks(2)]Peek | |
| 457 |: | |
| 458 wires worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number >>, [node(0)]Index >>, [0]-[1]] | |
| 459 :||: | |
| 460 wires worker <- Val[assignments worker] | |
| 461 :| | |
| 462 :| | |
| 463 :| | |
| 464 :| | |
| 465 index(1) <- my index | |
| 466 | |
| 467 worker(0) <- Fold[[[[["Add Block Wire"]Set Input[3, my index]]Set Input[4, blocks(2)]]Set Input[5, parse worker(3)]]Set Input[6, assignments(4)], wires worker, [node(0)]Blocks >>] | |
| 468 :| | |
| 469 | |
| 470 Company Global Node | |
| 471 |: | |
| 472 Store | |
| 473 Name | |
| 474 Assignments | |
| 475 Blocks | |
| 476 Index | |
| 477 :| | |
| 478 | |
| 479 New@Global Node(2,1) | |
| 480 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
481 out(0) <- [[[[Build["Global Node"]]Store <<[store(0)]]Name <<[name(1)]]Assignments <<[List[]]]Blocks <<[List[]] |
| 0 | 482 :| |
| 483 | |
| 484 Add to Worker@Global Node(5,3) | |
| 485 |: | |
| 486 out worker(1) <- [worker(1)]Add Global Get[[node(0)]Store >>, [node(0)]Name >>] |::| | |
| 487 |: | |
| 488 refs(2) <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>] | |
| 489 out node(0) <- [node(0)]Index <<[~] | |
| 490 :| | |
| 491 refs(2) <- refs(4) | |
| 492 :| | |
| 493 | |
| 494 Add Wires@Global Node(5,4) | |
| 495 |: | |
| 496 worker(0),index(1),num(2) <- Add Wires Literal or Global[node(0), worker(1), blocks(2), parse worker(3), assignments(4)] | |
| 497 :| | |
| 498 | |
| 499 Has Block@Global Node(1,2) | |
| 500 |: | |
| 501 out(0) <- Yes | |
| 502 :| | |
| 503 | |
| 504 Company Literal Node | |
| 505 |: | |
| 506 Value | |
| 507 Assignments | |
| 508 Blocks | |
| 509 Index | |
| 510 :| | |
| 511 | |
| 512 Has Block@Literal Node(1,2) | |
| 513 |: | |
| 514 out(0) <- Yes | |
| 515 :| | |
| 516 | |
| 517 New@Literal Node(1,1) | |
| 518 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
519 out(0) <- [[[Build["Literal Node"]]Value <<[value(0)]]Assignments <<[List[]]]Blocks <<[List[]] |
| 0 | 520 :| |
| 521 | |
| 522 Add to Worker@Literal Node(5,3) | |
| 523 |: | |
| 524 out worker(1) <- [worker(1)]Add Constant[[node(0)]Value >>] |::| | |
| 525 |: | |
| 526 refs(2) <- Fold[[["Assignment Save Reference"]Set Input[3, parse worker(3)]]Set Input[4, ~], refs(4), [node(0)]Assignments >>] | |
| 527 out node(0) <- [node(0)]Index <<[~] | |
| 528 :| | |
| 529 :| | |
| 530 | |
| 531 Add Wires@Literal Node(5,4) | |
| 532 |: | |
| 533 worker(0),index(1),num(2) <- Add Wires Literal or Global[node(0), worker(1), blocks(2), parse worker(3), assignments(4)] | |
| 534 :| | |
| 535 | |
| 536 Add Wires Literal or Global(5,4) | |
| 537 |: | |
| 538 assignments worker <- Fold[[["Assignments Add Wires"]Set Input[3, parse worker(3)]]Set Input[4, [node(0)]Index >>], worker(1), [node(0)]Assignments >>] | |
| 539 [blocks(2)]Peek | |
| 540 |: | |
| 541 worker(0) <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number>>, [node(0)]Index >>, [0]-[1]] | |
| 542 :||: | |
| 543 worker(0) <- Val[assignments worker] | |
| 544 :| | |
| 545 index(1) <- [node(0)]Index >> | |
| 546 num(2) <- 0 | |
| 547 :| | |
| 548 | |
| 549 Company Block Node | |
| 550 |: | |
| 551 Number | |
| 552 :| | |
| 553 | |
| 554 Company Parse Error | |
| 555 |: | |
| 556 Type | |
| 557 Text | |
| 558 Line Number | |
| 559 :| | |
| 560 | |
| 561 New@Parse Error(3,1) | |
| 562 |: | |
| 563 out(0) <- [[[Build["Parse Error"]]Type <<[type(0)]]Text <<[text(1)]]Line Number <<[number(2)] | |
| 564 :| | |
| 565 | |
| 566 Filter Empty(1,1) | |
| 567 |: | |
| 568 If[[[string(0)]Length] > [0]] | |
| 569 |: | |
| 570 out(0) <- Yes | |
| 571 :||: | |
| 572 out(0) <- No | |
| 573 :| | |
| 574 :| | |
| 575 | |
| 576 Company Blueprint Field | |
| 577 |: | |
| 578 Name | |
| 579 Type | |
| 580 :| | |
| 581 | |
| 582 New@Blueprint Field(2,1) | |
| 583 |: | |
| 584 out(0) <- [[Build["Blueprint Field"]]Name <<[name(0)]]Type <<[type(1)] | |
| 585 :| | |
| 586 | |
| 587 Process Blueprint Field(3,1) | |
| 588 |: | |
| 589 parts <- [field(1)]Split[delim(2)] | |
| 590 If[[[parts]Length] > [1]] | |
| 591 |: | |
| 592 out(0) <- [list(0)]Append[New@Blueprint Field[[parts]Index[1], [parts]Index[0]]] | |
| 593 :||: | |
| 594 out(0) <- [list(0)]Append[New@Blueprint Field[[parts]Index[0], "Any Type"]] | |
| 595 :| | |
| 596 :| | |
| 597 | |
| 598 Block Comment(4,1) | |
| 599 |: | |
| 600 If[[block count(3)] > [0]] | |
| 601 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
602 after, before <- [string(0)]Get DString[[[List[]]Append[begin comment(1)]]Append[end comment(2)]] |::| |::| |
| 0 | 603 |: |
| 604 If[[~] = [begin comment(1)]] | |
| 605 |: | |
| 606 out(0) <- Block Comment[after, begin comment(1), end comment(2), [block count(3)]+[1]] | |
| 607 :||: | |
| 608 out(0) <- Block Comment[after, begin comment(1), end comment(2), [block count(3)]-[1]] | |
| 609 :| | |
| 610 :||: | |
| 611 //No match | |
| 612 out(0) <- "" | |
| 613 :| | |
| 614 :||: | |
| 615 out(0) <- string(0) | |
| 616 :| | |
| 617 :| | |
| 618 | |
| 619 Line Comment(1,1) | |
| 620 |: | |
| 621 [string(0)]Get DString["\n"] | |
| 622 |: | |
| 623 out(0) <- ["\n"]Append[~] | |
| 624 :| |::| |::| |: | |
| 625 out(0) <- "" | |
| 626 :| | |
| 627 :| | |
| 628 | |
| 629 _Get Comment DString(6,4) | |
| 630 |: | |
| 631 after,before,delim,nomatch(3) <- [string(0)]Get DString[delims(1)] | |
| 632 |: | |
| 633 If[[delim] = [line comment(2)]] | |
| 634 |: | |
| 635 after comment <- Line Comment[after] | |
| 636 :||: | |
| 637 If[[delim] = [begin comment(3)]] | |
| 638 |: | |
| 639 after comment <- Block Comment[after, begin comment(3), end comment(4), 1] | |
| 640 :||: | |
| 641 rest(0) <- Val[after] | |
| 642 before(1) <- [prev before(5)]Append[before] | |
| 643 delim(2) <- Val[delim] | |
| 644 :| | |
| 645 :| | |
| 646 :| |::| |::| |: | |
| 647 before(1) <- [prev before(5)]Append[before] | |
| 648 :| | |
| 649 | |
| 650 after comment | |
| 651 |: | |
| 652 rest(0),more before,delim(2),nomatch(3) <- _Get Comment DString[~, delims(1), line comment(2), begin comment(3), end comment(4), prev before(5)] | |
| 653 before(1) <- [before]Append[more before] | |
| 654 :| | |
| 655 | |
| 656 :| | |
| 657 | |
| 658 Get Comment DString(3,4) | |
| 659 |: | |
| 660 line comment <- [params(2)]Line Comment >> | |
| 661 begin comment <- [params(2)]Comment Begin >> | |
| 662 end comment <- [params(2)]Comment End >> | |
| 663 all delims <- [[[delims(1)]As List]Append[begin comment]]Append[line comment] | |
| 664 rest(0), before(1), delim(2), not found(3) <- _Get Comment DString[string(0), delims(1), line comment, begin comment, end comment, ""] | |
| 665 :| | |
| 666 | |
| 667 Comment Left Trim(3,1) | |
| 668 |: | |
| 669 line comment <- [params(2)]Line Comment >> | |
| 670 | |
| 671 end comment <- [params(2)]Comment End >> | |
| 672 trimmed <- Left Trim[string(0), trim chars(1)] | |
| 673 If[[trimmed]Starts With[line comment]] | |
| 674 |: | |
| 675 ,after delim <- [trimmed]Slice[[line comment]Length] | |
| 676 out(0) <- Comment Left Trim[Line Comment[after delim], trim chars(1), params(2)] | |
| 677 :||: | |
| 678 begin comment <- [params(2)]Comment Begin >> | |
| 679 If[[trimmed]Starts With[begin comment]] | |
| 680 |: | |
| 681 ,after delim <- [trimmed]Slice[[line comment]Length] | |
| 682 out(0) <- Comment Left Trim[Block Comment[after delim, begin comment, end comment, 1], trim chars(1), params(2)] | |
| 683 :||: | |
| 684 out(0) <- Val[trimmed] | |
| 685 :| | |
| 686 :| | |
| 687 :| | |
| 688 | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
689 PBlueprint(4,1) |
| 0 | 690 |: |
| 691 ,whitespace name <- [string(0)]Get Comment DString[[params(1)]Block Begin >>, params(1)] | |
| 692 |: | |
| 693 ,no blueprint <- [whitespace name]Slice[ [[params(1)]Blueprint >>]Length ] | |
| 694 name <- Trim[no blueprint, "\r\n\t "] | |
| 695 name lines <- 0//[Count Substring[left, "\n"]] + [Count Substring[right, "\n"]] | |
| 696 ,body <- [~]Get Comment DString[ [params(1)]Block End >>, params(1)] | |
| 697 |: | |
| 698 body lines <- [body]Split["\n"] | |
| 699 more lines <- [[[body lines]Length] - [1]] + [name lines] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
700 fields <- Fold[["Process Blueprint Field"]Set Input[2, [params(1)]Blueprint Type Delim >>], List[], Filter[Map[body lines, ["Trim"]Set Input[1,"\n\r\t "]], "Filter Empty"]] |
| 0 | 701 new tree <- [tree(2)]Blueprints << [ [[tree(2)]Blueprints >>]Set[name, New@Blueprint Definition[name, fields]] ] |
| 702 out(0) <- Null[~, params(1), new tree, [lines(3)] + [more lines]] | |
| 703 :| |::| |: | |
| 704 out(0) <- [tree(2)]Errors <<[ [[tree(2)]Errors >>]Append[New@Parse Error["Error",[["Blueprint is missing an block close symbol \""]Append[[params(1)]Block End >>]]Append["\""], lines(3)]] ] | |
| 705 :| | |
| 706 | |
| 707 :| |::| |: | |
| 708 out(0) <- [tree(2)]Errors <<[ [[tree(2)]Errors >>]Append[New@Parse Error["Error",[["Blueprint is missing an block open symbol \""]Append[[params(1)]Block Begin >>]]Append["\""], lines(3)]] ] | |
| 709 :| | |
| 710 :| | |
| 711 | |
| 712 Parse Import(4,1) | |
| 713 |: | |
| 714 [line]Slice[ [[params(1)]Import >>]Length ] |::| | |
| 715 |: | |
| 716 filename <- Trim[~, " \n\r\t"] | |
| 717 :| | |
| 718 new tree <- [tree(2)]Imports <<[ [[tree(2)]Imports >>]Set[filename, Yes] ] | |
| 719 ,line <- [string(0)]Get Comment DString["\n", params(1)] | |
| 720 |: | |
| 721 out(0) <- Null[~, params(1), new tree, [lines(3)] + [1]] | |
| 722 :| |::| |: | |
| 723 out(0) <- Val[new tree] | |
| 724 :| | |
| 725 :| | |
| 726 | |
| 727 Get Expression Blocks(3,2) | |
| 728 |: | |
| 729 check block <- Comment Left Trim[string(0), "\n\r\t ", params(1)] | |
| 730 If[[check block]Starts With[[params(1)]Block Begin >>]] | |
| 731 |: | |
| 732 ,begin block <- [check block]Slice[[[params(1)]Block Begin >>]Length] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
733 trees, after block <- Worker Body[begin block, params(1), List[]] |
| 0 | 734 blocks(0), after(1) <- Get Expression Blocks[after block, params(1), [blocks(2)]Append[trees]] |
| 735 :||: | |
| 736 If[[check block]Starts With[[params(1)]Empty Block >>]] | |
| 737 |: | |
| 738 blocks(0) <- blocks(2) | |
| 739 ,after(1) <- [check block]Slice[[[params(1)]Empty Block >>]Length] | |
| 740 :||: | |
| 741 blocks(0) <- blocks(2) | |
| 742 after(1) <- Val[check block] | |
| 743 :| | |
| 744 :| | |
| 745 :| | |
| 746 | |
| 747 Parse Escape(2,2) | |
| 748 |: | |
| 749 code,rest <- [string(0)]Slice[1] | |
| 750 If[[code] = [[params(1)]Hex Escape >>]] | |
| 751 |: | |
| 752 hex,after(1) <- [rest]Slice[2] | |
| 753 char(0) <- [""]Put Byte[From Hex@Whole Number[hex]] | |
| 754 :||: | |
| 755 after(1) <- Val[rest] | |
| 756 char(0) <- [[params(1)]Escape Map >>]Index[code] |::| | |
| 757 |: | |
| 758 char(0) <- Val[code] | |
| 759 :| | |
| 760 :| | |
| 761 :| | |
| 762 | |
| 763 Parse String(3,2) | |
| 764 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
765 delims <- [[List[]]Append[[params(1)]String End >>]]Append[[params(1)]String Escape >>] |
| 0 | 766 after, before, delim <- [string(0)]Get Comment DString[delims, params(1)] |
| 767 |: | |
| 768 If[[delim] = [[params(1)]String End >>]] | |
| 769 |: | |
| 770 value(0) <- [current(2)]Append[before] | |
| 771 after(1) <- Val[after] | |
| 772 :||: | |
| 773 char,after escape <- Parse Escape[after, params(1)] | |
| 774 value(0),after(1) <- Parse String[after escape, params(1), [[current(2)]Append[before]]Append[char]] | |
| 775 :| | |
| 776 :| | |
| 777 :| | |
| 778 | |
| 779 Parse List(3,2) | |
| 780 |: | |
| 781 trimmed <- Comment Left Trim[string(0), "\r\n\t ", params(1)] | |
| 782 If[[trimmed]Starts With[[params(1)]List End >>]] | |
| 783 |: | |
| 784 value(0) <- list(2) | |
| 785 ,after(1) <- [trimmed]Slice[[[params(1)]List End >>]Length] | |
| 786 :||: | |
| 787 If[[trimmed]Starts With[[params(1)]List Delim >>]] | |
| 788 |: | |
| 789 ,el string <- [trimmed]Slice[[[params(1)]List Delim >>]Length] | |
| 790 :||: | |
| 791 el string <- Val[trimmed] | |
| 792 :| | |
| 793 element,after el <- Named Pipe or Literal[el string, params(1)] | |
| 794 value(0),after(1) <- Parse List[after el, params(1), [list(2)]Append[[element]Get Value]] | |
| 795 :| | |
| 796 :| | |
| 797 | |
| 798 Get Value@Literal Node(1,1) | |
| 799 |: | |
| 800 out(0) <- [node(0)]Value >> | |
| 801 :| | |
| 802 | |
| 803 Get Value@Named Pipe Node(1,1) | |
| 804 |: | |
| 805 out(0) <- node(0) | |
| 806 :| | |
| 807 | |
| 808 Parse Number(2,2) | |
| 809 |: | |
| 810 delims <- [[[[{" ","\t","\n","\r"}]Append[[params(1)]List Delim >>]]Append[[params(1)]Block Begin >>]]Append[[params(1)]Arg End >>]]Append[[params(1)]List End >>] | |
| 811 after delim,valstring <- [string(0)]Get Comment DString[delims, params(1)] |::| |::| | |
| 812 |: | |
| 813 after(1) <- [~]Append[after delim] | |
| 814 :||: | |
| 815 after(1) <- "" | |
| 816 :| | |
| 817 first two,rest <- [valstring]Slice[2] | |
| 818 If[[first two] = ["0x"]] | |
| 819 |: | |
| 820 value(0) <- From Hex@Whole Number[rest] | |
| 821 :||: | |
| 822 If[[valstring]Contains["."]] | |
| 823 |: | |
| 824 value(0) <- <String@Real Number[valstring] | |
| 825 :||: | |
| 826 value(0) <- <String@Whole Number[valstring] | |
| 827 :| | |
| 828 :| | |
| 829 :| | |
| 830 | |
| 831 Named Pipe or Literal(2,2) | |
| 832 |: | |
| 833 name <- Comment Left Trim[string(0), "\n\r\t ", params(1)] | |
| 834 If[[name]Starts With[[params(1)]String Begin >>]] | |
| 835 |: | |
| 836 ,string begin <- [name]Slice[[[params(1)]String Begin >>]Length] | |
| 837 value,after(1) <- Parse String[string begin, params(1), ""] | |
| 838 :||: | |
| 839 If[[name]Starts With[[params(1)]List Begin >>]] | |
| 840 |: | |
| 841 ,list start <- [name]Slice[[[params(1)]List Begin >>]Length] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
842 value,after(1) <- Parse List[list start, params(1), List[]] |
| 0 | 843 :||: |
| 844 If[[[name]Slice[1]]In["-0123456789"]] | |
| 845 |: | |
| 846 value,after(1) <- Parse Number[name, params(1)] | |
| 847 :||: | |
| 848 delims <- [[[[[[{"\n"}]Append[[params(1)]Block Begin >>]]Append[[params(1)]Block End >>]]Append[[params(1)]Empty Block >>]]Append[[params(1)]Arg End >>]]Append[[params(1)]List Delim >>]]Append[[params(1)]List End >>] | |
|
1
b3f71490858c
Small fixes and enhancements from main windows box
Mike Pavone <pavone@retrodev.com>
parents:
0
diff
changeset
|
849 afterdelim,raw before,delim <- [name]Get Comment DString[delims, params(1)] |
| 0 | 850 |: |
| 851 after(1) <- [delim]Append[~] | |
| 852 :| |::| |::| |: | |
| 853 after(1) <- "" | |
| 854 :| | |
|
1
b3f71490858c
Small fixes and enhancements from main windows box
Mike Pavone <pavone@retrodev.com>
parents:
0
diff
changeset
|
855 before <- Trim[raw before, "\r\n\t "] |
| 0 | 856 If[[before] = ["Yes"]] |
| 857 |: | |
| 858 yesno <- Yes | |
| 859 :||: | |
| 860 If[[before] = ["No"]] | |
| 861 |: | |
| 862 yesno <- No | |
| 863 :||: | |
| 864 If[[before] = [""]] | |
| 865 |: | |
| 866 Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]] | |
| 13 | 867 |: Print[["Near: "]Append[ [afterdelim]Slice[40]]] :| |
| 0 | 868 :||: |
| 869 If[[before]Contains[[params(1)]Global Separator >>]] | |
| 870 |: | |
| 871 parts <- [before]Split[[params(1)]Global Separator >>] | |
| 872 out(0) <- New@Global Node[Right Trim[[parts]Index[0],"\r\n\t "], Trim[[parts]Index[1], "\r\n\t "]] | |
| 873 :||: | |
| 874 out(0) <- New@Named Pipe Node[Right Trim[before,"\r\n\t "]] | |
| 875 :| | |
| 876 :| | |
| 877 :| | |
| 878 :| | |
| 879 out(0) <- New@Literal Node[yesno] | |
| 880 :| | |
| 881 :| | |
| 882 :| | |
| 883 out(0) <- New@Literal Node[value] | |
| 884 :| | |
| 885 | |
| 886 Parse Arguments(3,2) | |
| 887 |: | |
| 888 args <- Comment Left Trim[string(0), "\r\n\t ", params(1)] | |
| 889 If[[args]Starts With[[params(1)]List Delim >>]] | |
| 890 |: | |
| 891 [args]Slice[[[params(1)]List Delim >>]Length] |::| | |
| 892 |: | |
| 893 final args <- Comment Left Trim[~, "\r\n\t ", params(1)] | |
| 894 :| | |
| 895 :||: | |
| 896 If[[args]Starts With[[params(1)]Arg End >>]] | |
| 897 |: | |
| 898 args(0) <- arglist(2) | |
| 899 ,after(1) <- [args]Slice[[[params(1)]Arg End >>]Length] | |
| 900 :||: | |
| 901 final args <- Val[args] | |
| 902 :| | |
| 903 :| | |
| 904 arg, after arg <- Parse Expression[final args, params(1)] | |
| 905 args(0), after(1) <- Parse Arguments[after arg, params(1), [arglist(2)]Append[arg]] | |
| 906 :| | |
| 907 | |
| 908 Worker or Field(3,1) | |
| 909 |: | |
| 910 get field <- [params(2)]Get Field >> | |
| 911 If[[name(0)]Ends With[get field]] | |
| 912 |: | |
| 913 field <- Right Trim[[name(0)]Slice[[[name(0)]Length] - [[get field]Length]], "\n\r\t "] | |
| 914 out(0) <- New@Field Node[field, args(1), No] | |
| 915 :||: | |
| 916 set field <- [params(2)]Set Field >> | |
| 917 If[[name(0)]Ends With[set field]] | |
| 918 |: | |
| 919 field <- Right Trim[[name(0)]Slice[[[name(0)]Length] - [[set field]Length]], "\n\r\t "] | |
| 920 out(0) <- New@Field Node[field, args(1), Yes] | |
| 921 :||: | |
| 922 out(0) <- New@Worker Node[name(0), args(1)] | |
| 923 :| | |
| 924 :| | |
| 925 :| | |
| 926 | |
| 927 Prefix(4,2) | |
| 928 |: | |
| 929 //Parse argument list | |
| 930 more args,after(1) <- Parse Arguments[string(0), params(1), existing args(3)] | |
| 931 expression(0) <- Worker or Field[name(2), more args, params(1)] | |
| 932 :| | |
| 933 | |
| 934 Postfix or Infix(2,2) | |
| 935 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
936 args, after args <- Parse Arguments[string(0), params(1), List[]] |
| 0 | 937 delims <- [[[[[{"\n"}]Append[[params(1)]Arg Begin >>]]Append[[params(1)]Empty Block >>]]Append[[params(1)]Block Begin >>]]Append[[params(1)]Arg End >>]]Append[[params(1)]List Delim >>] |
| 938 after,before,delim <- [after args]Get Comment DString[delims, params(1)] | |
| 939 |: | |
| 940 If[[delim] = [[params(1)]Arg Begin >>]] | |
| 941 |: | |
| 942 expression(0), after(1) <- Prefix[after, params(1), Trim[before,"\r\n\t "], args] | |
| 943 :||: | |
| 944 If[[delim] = [[params(1)]Empty Block >>]] | |
| 945 |: | |
| 946 after expression(1) <- Val[after] | |
| 947 :||: | |
| 948 ,after expression(1) <- [after args]Slice[[before]Length] | |
| 949 :| | |
| 950 expression(0) <- Worker or Field[Trim[before,"\r\n\t "], args, params(1)] | |
| 951 :| | |
| 952 :| | |
| 953 :| | |
| 954 | |
| 955 Parse Expression(2,2) | |
| 956 |: | |
| 957 delims <- [[[[[[[{"\n"}]Append[[params(1)]Arg Begin >>]]Append[[params(1)]Arg End >>]]Append[[params(1)]Assign >>]]Append["\n"]]Append[[params(1)]Empty Block >>]]Append[[params(1)]Block End >>]]Append[[params(1)]String Begin >>] | |
| 958 after, before, delim <- [trimmed(0)]Get Comment DString[delims, params(1)] | |
| 959 |: | |
| 960 //If we find an arg begin token, we have a worker expression | |
| 961 If[[delim] = [[params(1)]Arg Begin >>]] | |
| 962 |: | |
| 963 maybe name <- Right Trim[before, "\r\t "] | |
| 964 //Prefix expressions will have the worker name before the first arg begin token | |
| 965 If[[maybe name] = [""]] | |
| 966 |: | |
| 967 expression, after expression <- Postfix or Infix[after, params(1)] | |
| 968 :||: | |
| 969 If[[maybe name]Contains[[params(1)]List Delim >>]] | |
| 970 |: | |
| 971 after expression <- [after literal]Append[[delim]Append[after]] | |
| 972 expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)] | |
| 973 :||: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
974 expression, after expression <- Prefix[after, params(1), maybe name, List[]] |
| 0 | 975 :| |
| 976 :| | |
| 977 :||: | |
| 978 If[[delim] = [[params(1)]Assign >>]] | |
| 979 |: | |
| 980 //Expressions starting with an assignment can be prefix, postfix or infix | |
| 981 //or they can be a simple literal or named pipe | |
| 982 assignments <- Map[[before]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]] | |
| 983 ,after blocks(1) <- Parse Expression[Comment Left Trim[after, " \n\r\t", params(1)], params(1)] | |
| 984 |: | |
| 985 final expression(0) <- [~]Assignments <<[assignments] | |
| 986 :| | |
| 987 :||: | |
| 988 //If[[delim] = [[params(1)]String Begin >>]] | |
| 989 //|: | |
| 990 // If[[Trim[before, "\r\n\t "]] = [""]] | |
| 991 // |: | |
| 992 // expression, after expression <- Named Pipe or Literal[[delim]Append[after], params(1)] | |
| 993 // :||: | |
| 994 // after expression <- [after literal]Append[[delim]Append[after]] | |
| 995 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)] | |
| 996 // :| | |
| 997 //:||: | |
| 998 // after expression <- [after literal]Append[[delim]Append[after]] | |
| 999 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params(1)] | |
| 1000 //:| | |
| 1001 expression, after expression <- Named Pipe or Literal[trimmed(0), params(1)] | |
| 1002 :| | |
| 1003 :| | |
| 1004 //Any expression can be followed by one or more blocks mapping the inputs of other expressions | |
| 1005 //to the outputs of the current one | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1006 blocks,after blocks(1) <- Get Expression Blocks[after expression, params(1), List[]] |
| 0 | 1007 final expression(0) <- [expression]Blocks <<[blocks] |
| 1008 :| | |
| 1009 :| | |
| 1010 | |
| 1011 Worker Body(3,2) | |
| 1012 |: | |
| 1013 trimmed <- Comment Left Trim[string(0), "\n\r\t ", params(1)] | |
| 1014 If[[trimmed]Starts With[[params(1)]Block End >>]] | |
| 1015 |: | |
| 1016 //We're done with this block, return | |
| 1017 ,after end(1) <- [trimmed]Slice[[[params(1)]Block End >>]Length] | |
| 1018 trees(0) <- trees(2) | |
| 1019 :||: | |
| 1020 expression, after expression <- Parse Expression[trimmed, params(1)] | |
| 1021 trees(0),after end(1) <- Worker Body[after expression, params(1), [trees(2)]Append[expression]] | |
| 1022 :| | |
| 1023 :| | |
| 1024 | |
| 1025 Process Modifiers(3,1) | |
| 1026 |: | |
| 1027 //Eventually this will need to be more sophisticated to handle more modifiers | |
| 1028 trimmed <- Comment Left Trim[modifiers(2), "\n\r\t ", params(1)] | |
| 1029 If[[trimmed]Starts With[[params(1)]Uses >>]] | |
| 1030 |: | |
| 1031 ,after uses <- [trimmed]Slice[[[params(1)]Uses >>]Length] | |
| 1032 ,stores string <- [after uses]Get Comment DString["\n", params(1)] | |
| 1033 out(0) <- [worker(0)]Uses Stores <<[Map[[stores string]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1, "\r\n\t "]]] | |
| 1034 :||: | |
| 1035 out(0) <- worker(0) | |
| 1036 :| | |
| 1037 :| | |
| 1038 | |
| 1039 Worker Name(4,1) | |
| 1040 |: | |
| 1041 ,whitespace name <- [string(0)]Get Comment DString[[params(1)]Arg Begin >>, params(1)] | |
| 1042 |: | |
| 1043 worker name <- Trim[whitespace name, "\n\r\t "] | |
| 1044 in out <- [params(1)]In Out Delim >> | |
| 1045 arg end <- [params(1)]Arg End >> | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1046 delims <- [[List[]]Append[in out]]Append[arg end] |
| 0 | 1047 after <- [~]Get Comment DString[delims, params(1)] |::| |
| 1048 |: | |
| 1049 arglist <- Trim[~,"\r\n\t "] | |
| 1050 :||: | |
| 1051 //check if there is an in/out separator | |
| 1052 //if it isn't present, everything in the arglist is an input | |
| 1053 If[[~] = [in out]] | |
| 1054 |: | |
| 1055 after arglist <- [after]Get Comment DString[arg end, params(1)] |::| | |
| 1056 |: | |
| 1057 output string <- Trim[~,"\n\r\t "] | |
| 1058 :| | |
| 1059 :||: | |
| 1060 after arglist <- Val[after] | |
| 1061 output string <- "" | |
| 1062 :| | |
| 1063 inputs <- Map[[arglist]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]] | |
| 1064 outputs <- Map[[output string]Split[[params(1)]List Delim >>], ["Trim"]Set Input[1,"\n\r\t "]] | |
| 1065 | |
| 1066 New@Parse Worker[worker name, inputs, outputs, 0] | |
| 1067 |: | |
| 1068 body text, modifiers <- [after arglist]Get Comment DString[[params(1)]Block Begin >>, params(1)] | |
| 1069 modified <- Process Modifiers[~, params(1), modifiers] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1070 expression trees, after body <- Worker Body[body text, params(1), List[]] |
| 0 | 1071 worker <- [modified]Trees <<[expression trees] |
| 1072 new worker dict <- [[tree(2)]Workers >>]Set[worker name, worker] | |
| 1073 out(0) <- Null[after body, params(1), [tree(2)]Workers <<[new worker dict], 0] | |
| 1074 :| | |
| 1075 :| | |
| 1076 :||::||::||: | |
| 1077 out(0) <- tree(2) | |
| 1078 :| | |
| 1079 :| | |
| 1080 | |
| 1081 Null(4,1) | |
| 1082 |: | |
| 1083 trimmed <- Comment Left Trim[string(0), " \n\r\t", params(1)] | |
| 1084 current line <- 0//[lines(3)] + [Count Substring[whitespace, "\n"]] | |
| 1085 If[[trimmed]Starts With[ [params(1)]Blueprint >> ]] | |
| 1086 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1087 out(0) <- PBlueprint[trimmed, params(1), tree(2), current line] |
| 0 | 1088 :||: |
| 1089 If[[trimmed]Starts With[ [params(1)]Import >> ]] | |
| 1090 |: | |
| 1091 out(0) <- Parse Import[trimmed, params(1), tree(2), current line] | |
| 1092 :||: | |
| 1093 out(0) <- Worker Name[trimmed, params(1), tree(2), current line] | |
| 1094 :| | |
| 1095 :| | |
| 1096 :| | |
| 1097 | |
| 1098 Add Workers(3,1) | |
| 1099 |: | |
| 1100 prog,worker <- [program(2)]New Worker[name(1)] | |
| 1101 [worker]Set IO Counts[ [[[worker(0)]Index[name(1)]]Inputs >>]Length, [[[worker(0)]Index[name(1)]]Outputs >>]Length] | |
| 1102 [workers(0)]Next[name(1)] | |
| 1103 |: | |
| 1104 out(0) <- Add Workers[workers(0), ~, prog] | |
| 1105 :||: | |
| 1106 out(0) <- Val[prog] | |
| 1107 :| | |
| 1108 :| | |
| 1109 | |
| 1110 Add Wires Helper(5,1) | |
| 1111 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1112 worker(0) <- [node(1)]Add Wires[worker(0), List[], parse worker(3), assignments(4)] |
| 0 | 1113 :| |
| 1114 | |
| 1115 Add Contents(3,2) | |
| 1116 |: | |
| 1117 worker <- [[program(2)]Find Worker[name(1)]]Uses[[parse worker(0)]Uses Stores >>] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1118 trees, contents worker, refs <- Add List to Worker[[parse worker(0)]Trees >>, worker, program(2), parse worker(0), Dictionary[]] |
| 0 | 1119 Fold[[["Add Wires Helper"]Set Input[3, parse worker(0)]]Set Input[4, refs], contents worker, trees] |
| 1120 out(0) <- [parse worker(0)]Trees <<[trees] | |
| 1121 key(1) <- name(1) | |
| 1122 :| | |
| 1123 | |
| 1124 Add Blueprint Field(3,1) | |
| 1125 |: | |
| 1126 out(0) <- [blueprint(0)]Add Field[[field(1)]Name >>, [field(1)]Type >>] | |
| 1127 :| | |
| 1128 | |
| 1129 Add Blueprint(2,1) | |
| 1130 |: | |
| 1131 out(0) <- [prog(0)]New Blueprint[[def(1)]Name >>] |::| | |
| 1132 |: | |
| 1133 Fold["Add Blueprint Field", ~, [def(1)]Fields >>] | |
| 1134 :| | |
| 1135 :| | |
| 1136 | |
| 1137 _Tree to Program(2,1) | |
| 1138 |: | |
| 1139 after blueprint <- Fold["Add Blueprint", program(1), [parse tree(0)]Blueprints >>] | |
| 1140 [[parse tree(0)]Workers >>]First | |
| 1141 |: | |
| 1142 prog <- Add Workers[[parse tree(0)]Workers >>, ~, after blueprint] | |
| 1143 :| | |
| 1144 Key Value Map[[parse tree(0)]Workers >>, ["Add Contents"]Set Input[2, prog]] | |
| 1145 out(0) <- prog | |
| 1146 :| | |
| 1147 | |
| 1148 Tree to Program(1,1) | |
| 1149 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1150 out(0) <- _Tree to Program[parse tree(0), [Program[]]Add Builtins] |
| 0 | 1151 :| |
| 1152 | |
| 1153 Needs Imports(3,1) | |
| 1154 |: | |
| 1155 If[not imported?(1)] | |
| 1156 |: | |
| 1157 out(0) <- [needs import(0)]Append[name(2)] | |
| 1158 :||: | |
| 1159 out(0) <- needs import(0) | |
| 1160 :| | |
| 1161 :| | |
| 1162 | |
| 1163 Do Import(4,1) | |
| 1164 |: | |
| 1165 file <- <String@File[file name(1)] | |
| 1166 ,text <- [file]Get FString[[file]Length] | |
| 1167 after import <- Null[text, params(3), tree(0), 0] | |
| 1168 out(0) <- [after import]Imports <<[ [[after import]Imports >>]Set[file name(1), No] ] | |
| 1169 :| | |
| 1170 | |
| 1171 Process Imports(2,1) | |
| 1172 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1173 needs import <- Fold["Needs Imports", List[], [parse tree(0)]Imports >>] |
| 0 | 1174 If[[[needs import]Length] > [0]] |
| 1175 |: | |
| 1176 import tree <- Fold[["Do Import"]Set Input[3, params(1)], parse tree(0), needs import] | |
| 1177 out(0) <- Process Imports[import tree, params(1)] | |
| 1178 :||: | |
| 1179 out(0) <- parse tree(0) | |
| 1180 :| | |
| 1181 :| | |
| 1182 | |
| 1183 _Init Used Store(2,1) | |
| 1184 |: | |
| 1185 [dict(0)]Index[store name(1)] | |
| 1186 |: | |
| 1187 out(0) <- dict(0) | |
| 1188 :||: | |
| 1189 Init Store[store name(1)] | |
| 1190 out(0) <- [dict(0)]Set[store name(1), Yes] | |
| 1191 :| | |
| 1192 :| | |
| 1193 | |
| 1194 _Init Used Stores(2,1) | |
| 1195 |: | |
| 1196 out(0) <- Fold["_Init Used Store", dict(0), [worker(1)]Uses Stores >>] | |
| 1197 :| | |
| 1198 | |
| 1199 Init Used Stores(1,1) | |
| 1200 |: | |
| 1201 out(0) <- Fold["_Init Used Stores", existing stores(1), [parse tree(0)]Workers >>] | |
| 1202 :| | |
| 1203 | |
| 1204 Until End(1,1) | |
| 1205 |: | |
| 1206 line <- Get Input[] | |
| 1207 If[[line] = ["End"]] | |
| 1208 |: | |
| 1209 out(0) <- [text(0)]Append["\n"] | |
| 1210 :||: | |
| 1211 out(0) <- Until End[[[text(0)]Append["\n"]]Append[line]] | |
| 1212 :| | |
| 1213 :| | |
| 1214 | |
| 1215 _REPL(3,0) | |
| 1216 |: | |
| 1217 line <- Get Input[] | |
| 1218 If[[line] = ["Begin"]] | |
| 1219 |: | |
| 1220 text <- Until End[""] | |
| 1221 Null[text, params(0), New@Parse Program[], 0] | |
| 1222 |: | |
| 1223 define tree <- Process Imports[~, params(0)] | |
| 1224 Init Used Stores[define tree, stores(2)] | |
| 1225 |: _REPL[params(0), _Tree to Program[define tree, prog(1)], ~] :| | |
| 1226 :| | |
| 1227 :||: | |
| 1228 If[[line]Starts With[[params(0)]Import >>]] | |
| 1229 |: | |
| 1230 Parse Import[[line]Append["\n"], params(0), New@Parse Program[], 0] | |
| 1231 |: | |
| 1232 import tree <- Process Imports[~, params(0)] | |
| 1233 Init Used Stores[import tree, stores(2)] | |
| 1234 |: _REPL[params(0), _Tree to Program[import tree, prog(1)], ~] :| | |
| 1235 :| | |
| 1236 :||: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1237 trees <- Worker Body[[line]Append["}"], params(0), List[]] |
|
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1238 tree <- [New@Worker Node["Val", [List[]]Append[[trees]Index[0]]]]Assignments <<[{"__out"}] |
|
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1239 this stores <- [[tree]Gather Stores[params(0), Dictionary[]]]Keys |
| 0 | 1240 next stores <- Fold["_Init Used Store", stores(2), this stores] |
| 1241 |: | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1242 pworker <- [[New@Parse Worker["__Eval", List[], {"__out"}, 0]]Trees <<[[List[]]Append[tree]]]Uses Stores <<[this stores] |
| 0 | 1243 :| |
| 1244 [[prog(1)]Find Worker["__Eval"]]Clear | |
| 1245 |: Add Contents[pworker, "__Eval", prog(1)] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1246 |: Pretty Print[[[[prog(1)]Find Worker["__Eval"]]Do[List[]]]Index[0], ""] |
| 0 | 1247 |: _REPL[params(0), prog(1), next stores] :| :| :| |
| 1248 :| | |
| 1249 :| | |
| 1250 :| | |
| 1251 | |
| 1252 REPL(1,0) | |
| 1253 |: | |
| 1254 Print["Rhope Alpha 2\nCopyright 2008 by Michael Pavone\nEntering interactive mode\n"] | |
| 1255 prog <- Tree to Program[Null["Val[in:out]\n{\n out <- in\n}\n__Eval[:__out]\n{\n}\n", params(0), New@Parse Program[], 0]] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1256 _REPL[params(0), prog, Dictionary[]] |
| 0 | 1257 :| |
| 1258 | |
| 1259 Add If Store(3,1) | |
| 1260 |: | |
| 1261 If[[name(1)]Contains[[params(2)]Global Separator >>]] | |
| 1262 |: | |
| 1263 parts <- [name(1)]Split[[params(2)]Global Separator >>] | |
| 1264 out(0) <- [stores(0)]Set[[parts]Index[0], Yes] | |
| 1265 :||: | |
| 1266 out(0) <- stores(0) | |
| 1267 :| | |
| 1268 :| | |
| 1269 | |
| 1270 Param Gather Stores(3,1) | |
| 1271 |: | |
| 1272 out(0) <- [node(1)]Gather Stores[params(2), stores(0)] | |
| 1273 :| | |
| 1274 | |
| 1275 Gather Stores@Named Pipe Node(3,1) | |
| 1276 |: | |
| 1277 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], stores(2), [node(0)]Assignments >>] | |
| 1278 :| | |
| 1279 | |
| 1280 Gather Stores@Global Node(3,1) | |
| 1281 |: | |
| 1282 out(0) <- [stores(2)]Set[[node(0)]Store >>, Yes] | |
| 1283 :| | |
| 1284 | |
| 1285 Gather Stores@Worker Node(3,1) | |
| 1286 |: | |
| 1287 //TODO: Handle blocks | |
| 1288 store list <- Fold[["Param Gather Stores"]Set Input[2, params(1)], stores(2), [node(0)]Params >>] | |
| 1289 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], store list, [node(0)]Assignments >>] | |
| 1290 :| | |
| 1291 | |
| 1292 Gather Stores@Field Node(3,1) | |
| 1293 |: | |
| 1294 //TODO: Handle blocks | |
| 1295 store list <- Fold[["Param Gather Stores"]Set Input[2, params(1)], stores(2), [node(0)]Params >>] | |
| 1296 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], store list, [node(0)]Assignments >>] | |
| 1297 :| | |
| 1298 | |
| 1299 Gather Stores@Literal Node(3,1) | |
| 1300 |: | |
| 1301 out(0) <- Fold[["Add If Store"]Set Input[2, params(1)], stores(2), [node(0)]Assignments >>] | |
| 1302 :| | |
| 1303 | |
| 1304 | |
| 1305 Main(1,0) | |
| 1306 |: | |
| 1307 | |
| 1308 [args(0)]Index[1] | |
| 1309 |: | |
| 1310 file <- <String@File[~] | |
| 1311 ,text <- [file]Get FString[[file]Length] | |
| 1312 params <- New@Parser[] | |
| 1313 Null[text, params, New@Parse Program[], 0] | |
| 1314 |: | |
| 1315 tree <- Process Imports[~, params] | |
|
47
6202b866d72c
Cleaned up constructor names and merged some other changes in to support the Rhope website
Mike Pavone <pavone@retrodev.com>
parents:
37
diff
changeset
|
1316 Init Used Stores[tree, Dictionary[]] |
| 0 | 1317 |: [Tree to Program[tree]]Run[[args(0)]Tail[1]] :| |
| 1318 :| | |
| 1319 :||: | |
| 1320 REPL[New@Parser[]] | |
| 1321 :| | |
| 1322 :| |