repos/rhope: parser_old_c.rhope annotate

annotate parser_old_c.rhope @ 142:7bbdc034e347

Fix some bugs. Get basic network code working (epoll listener + accept connections). Start porting webserver.

author	Mike Pavone <pavone@retrodev.com>
date	Sun, 21 Nov 2010 16:33:17 -0500
parents	a68e6828d896
children	e769b2e0facc

rev	line source
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1 Import nworker_c.rhope
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	2
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	3 //Rather than rewrite the code that uses this
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	4 //let's implement Get DString using Partition
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	5 Get DString[str,delims:after,before,delim,not found]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	6 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	7 before,delim,after,not found <- [str]Partition[delims] {} {} {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	8 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	9 before <- str
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	10 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	11 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	12
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	13
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	14 Blueprint Parser
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	15 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	16 Arg Begin
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	17 Arg End
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	18 Line Comment
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	19 Comment Begin
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	20 Comment End
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	21 Assign
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	22 Block Begin
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	23 Block End
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	24 Blueprint Type Delim
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	25 Empty Block
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	26 Binary Operator
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	27 String Begin
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	28 String End
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	29 String Escape
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	30 List Begin
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	31 List End
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	32 List Delim
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	33 In Out Delim
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	34 Index Begin
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	35 Index End
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	36 Previous
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	37 Block Val
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	38 Set Field
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	39 Get Field
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	40 Import
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	41 Blueprint
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	42 Global Separator
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	43 Uses
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	44 Hex Escape
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	45 Escape Map
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	46 Foreign
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	47 Globals
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	48 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	49
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	50 Parser[:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	51 {
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	52 out <- [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[Build[Parser()]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	53 ]Arg Begin << ["["]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	54 ]Arg End <<["]"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	55 ]Line Comment <<["//"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	56 ]Comment Begin <<["/*"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	57 ]Comment End <<["*/"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	58 ]Assign <<["<-"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	59 ]Block Begin <<["{"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	60 ]Block End <<["}"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	61 ]Blueprint Type Delim <<[":"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	62 ]Empty Block <<[";"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	63 ]Binary Operator <<["`"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	64 ]String Begin <<["\""]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	65 ]String End <<["\""]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	66 ]String Escape <<["\\"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	67 ]List Begin <<["("]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	68 ]List End <<[")"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	69 ]List Delim <<[","]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	70 ]In Out Delim <<[":"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	71 ]Index Begin <<["("]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	72 ]Index End <<[")"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	73 ]Previous <<["@"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	74 ]Set Field <<["<<"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	75 ]Get Field <<[">>"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	76 ]Import <<["Import"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	77 ]Blueprint <<["Blueprint"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	78 ]Global Separator <<["::"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	79 ]Hex Escape <<["x"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	80 ]Uses <<["uses"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	81 ]Escape Map <<[[[[Dictionary[]]Set["n","\n"]]Set["r","\r"]]Set["t","\t"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	82 ]Foreign <<["Foreign"]
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	83 ]Globals <<["Globals"]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	84 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	85
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	86 Blueprint Output Reference
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	87 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	88 Index
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	89 Output Number
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	90 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	91
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	92 Output Reference[index,num:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	93 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	94 out <- [[Build[Output Reference()]]Index <<[index]]Output Number <<[num]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	95 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	96
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	97 Add Pipe Reference[refs,name,reference:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	98 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	99 reflist <- [refs]Index[name] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	100 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	101 reflist <- ()
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	102 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	103 out <- [refs]Set[name, [reflist]Append[reference]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	104 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	105
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	106 Assignment Save Reference[refs,assignment,output num,parse worker,index:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	107 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	108 [[parse worker]Outputs >>]Find[=[assignment,?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	109 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	110 out <- refs
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	111 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	112 out <- Add Pipe Reference[refs, assignment, Output Reference[index, output num]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	113 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	114 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	115
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	116 Blueprint Foreign Lib
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	117 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	118 Language
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	119 Name
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	120 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	121
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	122 New Foreign Lib[language, library:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	123 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	124 out <- [[Build[Foreign Lib()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	125 ]Language <<[language]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	126 ]Name <<[library]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	127 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	128
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	129 Blueprint Global Store
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	130 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	131 Name
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	132 Vars
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	133 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	134
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	135 Global Store[name:out]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	136 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	137 out <- [[Build[Global Store()]]Name <<[name]]Vars <<[Dictionary[]]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	138 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	139
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	140 Blueprint Parse Program
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	141 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	142 Workers
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	143 Imports
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	144 Blueprints
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	145 Global Stores
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	146 Errors
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	147 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	148
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	149 Parse Program[:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	150 {
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	151 out <- [[[[[Build[Parse Program()]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	152 ]Workers <<[Dictionary[]]
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: 115 diff changeset	153 ]Imports <<[Dictionary[]]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	154 ]Blueprints <<[Dictionary[]]
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	155 ]Global Stores <<[Dictionary[]]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	156 ]Errors <<[()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	157 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	158
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	159 Add Global Store@Parse Program[tree,store:out]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	160 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	161 out <- [tree]Global Stores <<[ [[tree]Global Stores >>]Set[[store]Name >>, store] ]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	162 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	163
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	164 Blueprint Blueprint Definition
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	165 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	166 Name
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	167 Fields
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	168 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	169
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	170 New Blueprint Definition[name,fields:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	171 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	172 out <- [[Build[Blueprint Definition()]]Name << [name]]Fields <<[fields]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	173 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	174
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	175 Blueprint Parse Worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	176 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	177 Name
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	178 Inputs
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	179 Outputs
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	180 Line Number
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	181 Trees
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	182 Uses Stores
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	183 Input Types
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	184 Output Types
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	185 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	186
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	187 Parse Worker[name,inputs,outputs,intypes,outtypes,line:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	188 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	189 out <- [[[[[[[[Build[Parse Worker()]]Name <<[name]]Inputs <<[inputs]]Outputs <<[outputs]]Line Number <<[line]]Trees <<[()]]Uses Stores <<[()]]Input Types <<[intypes]]Output Types <<[outtypes]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	190 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	191
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	192 Blueprint Worker Node
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	193 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	194 Name
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	195 Params
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	196 Assignments
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	197 Blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	198 Index
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	199 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	200
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	201 Worker Node[name,params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	202 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	203 out <- [[[[Build[Worker Node()]]Name <<[name]]Params <<[params]]Assignments <<[()]]Blocks <<[()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	204 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	205
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	206 Add List Helper[inlist,worker,program,key,parse worker,refs:out list,out worker,out refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	207 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	208 ,nextworker,nextrefs <- [[inlist]Index[key]]Add to Worker[worker, program, parse worker, refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	209 { nextlist <- [inlist]Set[key, ~] }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	210 [inlist]Next[key]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	211 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	212 out list,out worker,out refs <- Add List Helper[nextlist, nextworker, program, ~, parse worker, nextrefs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	213 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	214 out list <- Val[nextlist]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	215 out worker <- Val[nextworker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	216 out refs <- Val[nextrefs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	217 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	218 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	219
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	220 Add List to Worker[list,worker,program,parse worker,refs:out list,out worker,out refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	221 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	222 [list]First
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	223 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	224 out list,out worker,out refs <- Add List Helper[list, worker, program, ~, parse worker, refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	225 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	226 out list <- list
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	227 out worker <- worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	228 out refs <- refs
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	229 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	230 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	231
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	232 _Add Blocks to Worker[blocks,worker,program,parse worker,key,refs:out blocks,out worker,out refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	233 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	234 block, next worker, nextrefs <- Add List to Worker[[blocks]Index[key], worker, program, parse worker, refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	235 next blocks <- [blocks]Set[key, block]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	236 [blocks]Next[key]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	237 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	238 out blocks,out worker,out refs <- _Add Blocks to Worker[next blocks, next worker, program, parse worker, ~, nextrefs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	239 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	240 out blocks <- Val[next blocks]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	241 out worker <- Val[next worker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	242 out refs <- Val[nextrefs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	243 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	244 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	245
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	246 Add Blocks to Worker[blocks,worker,program,parse worker,refs:out blocks,out worker,out refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	247 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	248 [blocks]First
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	249 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	250 out blocks, out worker, out refs <- _Add Blocks to Worker[blocks, worker, program, parse worker, ~, refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	251 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	252 out blocks <- blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	253 out worker <- worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	254 out refs <- refs
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	255 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	256 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	257
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	258 Add to Worker@Worker Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	259 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	260 [program]Find Worker[[node]Name >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	261 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	262 after worker <- [worker]Add Worker Call[~] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	263 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	264 //Print[[[[node]Name >>]Append[" has index "]]Append[~]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	265 assignment refs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	266 [node]Index <<[~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	267 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	268 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	269 block list, out worker, out refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	270 out node <- [[~]Params <<[params list]]Blocks <<[block list]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	271 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	272 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	273 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	274 Print[["Error: Could not find a worker named "]Append[[node]Name >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	275 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	276 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	277
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	278 Check Question Mark[params, index:has mark,no mark]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	279 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	280 param,no mark <-[params]Index[index]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	281 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	282 If[[Blueprint Of[param]]=[Named Pipe Node()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	283 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	284 has mark <-If[[[param]Name >>] = ["?"]] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	285 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	286 has mark,no mark <- Check Question Mark[params, [index]+[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	287 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	288 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	289 has mark,no mark <- Check Question Mark[params, [index]+[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	290 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	291 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	292 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	293
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	294 Collect Literal Inputs[literal, params, index, complex inputs:literal out,complex out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	295 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	296 param <- [params]Index[index]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	297 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	298 If[[Blueprint Of[param]]=[Literal Node()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	299 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	300 next literal <- [literal]Set Input[index, [param]Value >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	301 next complex <- Val[complex inputs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	302 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	303 ,doset <- If[[Blueprint Of[param]]=[Named Pipe Node()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	304 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	305 ,doset <- If[[[param]Name >>] = ["?"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	306 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	307 //Question mark indicates unpopulated input
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	308 next complex <- Val[complex inputs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	309 next literal <- Val[literal]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	310 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	311 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	312
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	313 Val[doset]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	314 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	315 next complex <- [complex inputs]Set[index, param]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	316 next literal <- Val[literal]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	317 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	318 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	319 literal out, complex out <- Collect Literal Inputs[next literal, params, [index]+[1], next complex]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	320 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	321 literal out <- literal
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	322 complex out <- complex inputs
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	323 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	324 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	325
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	326 Do Set Input[literal,param,index:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	327 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	328 out <- Worker Node["Set Input", [[[()]Append[literal]]Append[Literal Node[index]]]Append[param]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	329 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	330
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	331 Check Worker Literals@Worker Node[node,program:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	332 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	333 new params <- Map[[node]Params >>, Check Worker Literals[?, program]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	334 Check Question Mark[new params, 0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	335 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	336 base literal, complex inputs <- Collect Literal Inputs[Worker Literal[[node]Name >>], new params, 0, ()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	337 new node <- Fold[Do Set Input[?], Literal Node[base literal], complex inputs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	338 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	339 new node <- [node]Params <<[new params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	340 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	341 out <- [new node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	342 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	343
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	344 Add Multi Wire[worker,ref,junk,end index,input num:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	345 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	346 out <- [worker]Add Wire[[ref]Index >>, [ref]Output Number >>, end index, input num]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	347 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	348
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	349 Add Param Wire[worker,param,input num,end index,blocks,parse worker,assignments:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	350 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	351 param worker, start index, output num <- [param]Add Wires[worker, blocks, parse worker, assignments] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	352 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	353 out <- [param worker]Add Wire[start index, output num, end index, input num]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	354 }{}{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	355 out <- Fold[Add Multi Wire[?, ?, ?, end index, input num], param worker, ~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	356 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	357 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	358
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	359 _Add Block Wire[worker,node,junk,blocks,parse worker,assignments:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	360 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	361 out <- [node]Add Wires[worker, blocks, parse worker, assignments]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	362 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	363
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	364 Add Block Wire[worker,block nodes,output num,parent index,existing blocks,parse worker,assignments:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	365 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	366 blocks <- [existing blocks]Append[Output Reference[parent index, output num]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	367 out <- Fold[_Add Block Wire[?, ?, ?, blocks, parse worker, assignments], worker, block nodes]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	368 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	369
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	370 Assignments Add Wires[worker,assignment,output num,parse worker,start index:out worker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	371 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	372 [[parse worker]Outputs >>]Find[=[assignment,?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	373 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	374 ,output index <- [worker]Add Typed Output[assignment, ~, [[parse worker]Output Types >>]Index[~]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	375 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	376 out worker <- [~]Add Wire[start index, output num, output index, 0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	377 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	378 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	379 //Ugly hack alert!
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	380 If[[assignment]Contains["::"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	381 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	382 parts <- [assignment]Split["::"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	383 ,global index <- [worker]Add Global Set[[parts]Index[0], [parts]Index[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	384 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	385 out worker <- [~]Add Wire[start index, output num, global index, 0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	386 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	387 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	388 out worker <- worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	389 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	390 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	391 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	392
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	393 Has Block@Worker Node[junk:out,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	394 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	395 out <- Yes
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	396 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	397
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	398 _Has Block Params[param list,key:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	399 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	400 param <- [param list]Index[key]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	401 out <- [param]Has Block {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	402 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	403 [param list]Next[key]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	404 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	405 out <- _Has Block Params[param list, ~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	406 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	407 out <- No
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	408 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	409 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	410
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	411 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	412
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	413 Has Block Params[param list:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	414 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	415 [param list]First
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	416 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	417 out <- _Has Block Params[param list, ~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	418 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	419 out <- No
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	420 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	421 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	422
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	423 Add Wires@Worker Node[node,worker,blocks,parse worker,assignments:outworker,index,num,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	424 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	425 outworker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	426 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	427
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	428 Add Wires Worker or Field[node,worker,blocks,parse worker,assignments:outworker,index,num,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	429 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	430 Fold[Assignments Add Wires[?, ?, ?, parse worker, [node]Index >>], worker, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	431 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	432 Fold[Add Block Wire[?, ?, ?, [node]Index >>, blocks, parse worker, assignments], ~, [node]Blocks >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	433 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	434 params worker <- Fold[Add Param Wire[?, ?, ?, [node]Index >>, blocks, parse worker, assignments], ~, [node]Params >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	435 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	436 index <- [node]Index >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	437 num <- 0
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	438 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	439 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	440 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	441 If[Has Block Params[[node]Params >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	442 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	443 outworker <- Val[params worker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	444 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	445 [blocks]Peek
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	446 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	447 outworker <- [params worker]Add Wire[[~]Index >>, [~]Output Number >>, [node]Index >>, [0]-[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	448 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	449 outworker <- Val[params worker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	450 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	451 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	452 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	453
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	454 Blueprint Field Node
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	455 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	456 Name
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	457 Params
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	458 Assignments
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	459 Blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	460 Index
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	461 Set?
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	462 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	463
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	464 Has Block@Field Node[junk:has block,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	465 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	466 has block <- Yes
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	467 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	468
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	469 Field Node[name,params,set:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	470 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	471 out <- [[[[[Build[Field Node()]]Name <<[name]]Assignments <<[()]]Blocks <<[()]]Set? <<[set]]Params <<[params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	472 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	473
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	474 Add to Worker@Field Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	475 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	476 If[[node]Set? >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	477 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	478 after worker,index <- [worker]Add Object Set[[node]Name >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	479 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	480 after worker,index <- [worker]Add Object Get[[node]Name >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	481 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	482 Val[index]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	483 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	484 assignment refs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	485 [node]Index <<[~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	486 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	487 params list, params worker, params refs <- Add List to Worker[[~]Params >>, after worker, program, parse worker, assignment refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	488 block list, out worker, out refs <- Add Blocks to Worker[[~]Blocks >>, params worker, program, parse worker, params refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	489 out node <- [[~]Params <<[params list]]Blocks <<[block list]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	490 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	491 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	492 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	493
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	494 Add Wires@Field Node[node,worker,blocks,parse worker,assignments:outworker,index,num]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	495 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	496 outworker,index,num <- Add Wires Worker or Field[node, worker, blocks, parse worker, assignments]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	497 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	498
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	499 Check Worker Literals@Field Node[node,program:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	500 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	501 new params <- Map[[node]Params >>, Check Worker Literals[?, program]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	502 out <- [[node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	503 ]Params <<[new params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	504 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	505
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	506 Blueprint Named Pipe Node
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	507 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	508 Name
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	509 Assignments
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	510 Blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	511 Index
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	512 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	513
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	514 Has Block@Named Pipe Node[node:has block,no block]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	515 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	516 If[[[node]Index >>] < [0]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	517 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	518 //~ should really be a parser parameter
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	519 If[[[node]Name >>] = ["~"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	520 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	521 has block <- Yes
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	522 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	523 no block <- No
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	524 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	525 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	526 has block <- Yes
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	527 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	528 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	529
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	530 Named Pipe Node[name:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	531 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	532 out <- [[[Build[Named Pipe Node()]]Name <<[name]]Assignments <<[()]]Blocks <<[()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	533 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	534
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	535 Add to Worker@Named Pipe Node[node,worker,program,parse worker,refs:out node,out worker,out refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	536 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	537 [[parse worker]Inputs >>]Find[=[[node]Name >>, ?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	538 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	539 after add <- [worker]Add Typed Input[[node]Name >>, ~, [[parse worker]Input Types>>]Index[~]] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	540 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	541 assign refs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	542 index node <- [node]Index <<[~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	543 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	544 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	545 after add <- worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	546 index node <- [node]Index <<[[0]-[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	547 //TODO: Handle assignments from a named pipe that isn't an input
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	548 assign refs <- refs
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	549 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	550 block list, out worker, out refs <- Add Blocks to Worker[[node]Blocks >>, after add, program, parse worker, assign refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	551 out node <- [index node]Blocks <<[block list]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	552 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	553
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	554 Add Wires@Named Pipe Node[node,worker,blocks,parse worker,assignments:outworker,index,num,reflist]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	555 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	556 reflist <- [assignments]Index[[node]Name >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	557 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	558 //TODO: Fix support for a named pipe with a block
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	559 outworker <- worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	560 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	561 If[[[node]Name >>] = ["~"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	562 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	563 wires worker <- worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	564 [blocks]Peek
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	565 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	566 my index <- [~]Index >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	567 num <- [~]Output Number >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	568 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	569 //TODO: Propagate an error rather than printing it out
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	570 Print["Error, block reference symbol located outside of a block"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	571 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	572 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	573 If[[[node]Index >>] < [0]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	574 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	575 Print[[[["Error, reference to named pipe "]Append[[node]Name >>]]Append[" that was never assigned to in worker "]]Append[[parse worker]Name >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	576 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	577 my index <- [node]Index >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	578 num <- 0
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	579 assignments worker <- Fold[Assignments Add Wires[?, ?, ?, parse worker, [node]Index >>], worker, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	580 [blocks]Peek
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	581 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	582 wires worker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number >>, [node]Index >>, [0]-[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	583 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	584 wires worker <- Val[assignments worker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	585 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	586 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	587 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	588 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	589 index <- Val[my index]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	590
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	591 outworker <- Fold[Add Block Wire[?, ?, ?, my index, blocks, parse worker, assignments], wires worker, [node]Blocks >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	592 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	593
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	594 Check Worker Literals@Named Pipe Node[node,program:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	595 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	596 out <- [node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	597 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	598
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	599 Blueprint Global Node
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	600 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	601 Store
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	602 Name
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	603 Assignments
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	604 Blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	605 Index
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	606 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	607
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	608 Global Node[store,name:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	609 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	610 out <- [[[[Build[Global Node()]]Store <<[store]]Name <<[name]]Assignments <<[()]]Blocks <<[()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	611 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	612
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	613 Add to Worker@Global Node[node,worker,unused,parse worker,refs:out node,out worker,outrefs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	614 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	615 out worker <- [worker]Add Global Get[[node]Store >>, [node]Name >>] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	616 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	617 outrefs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	618 out node <- [node]Index <<[~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	619 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	620 outrefs <- refs
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	621 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	622
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	623 Add Wires@Global Node[node,worker,blocks,parse worker,assignments:outworker,index,num,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	624 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	625 outworker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	626 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	627
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	628 Has Block@Global Node[junk:out,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	629 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	630 out <- Yes
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	631 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	632
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	633 Check Worker Literals@Global Node[node,program:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	634 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	635 out <- [node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	636 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	637
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	638 Blueprint Literal Node
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	639 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	640 Value
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	641 Assignments
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	642 Blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	643 Index
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	644 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	645
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	646 Has Block@Literal Node[junk:out,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	647 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	648 out <- Yes
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	649 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	650
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	651 Literal Node[value:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	652 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	653 out <- [[[Build[Literal Node()]]Value <<[value]]Assignments <<[()]]Blocks <<[()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	654 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	655
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	656 Add to Worker@Literal Node[node,worker,unused,parse worker,refs:out node,out worker,out refs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	657 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	658 out worker <- [worker]Add Constant[[node]Value >>] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	659 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	660 out refs <- Fold[Assignment Save Reference[?, ?, ?, parse worker, ~], refs, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	661 out node <- [node]Index <<[~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	662 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	663 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	664
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	665 Add Wires@Literal Node[node,worker,blocks,parse worker,assignments:outworker,index,num,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	666 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	667 outworker,index,num <- Add Wires Literal or Global[node, worker, blocks, parse worker, assignments]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	668 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	669
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	670 Check Worker Literals@Literal Node[node,program:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	671 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	672 out <- [node]Blocks <<[ Map[[node]Blocks >>, Map[?, Check Worker Literals[?, program]]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	673 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	674
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	675 Add Wires Literal or Global[node,worker,blocks,parse worker,junk:outworker,index,num,unused]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	676 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	677 assignments worker <- Fold[Assignments Add Wires[?, ?, ?, parse worker, [node]Index >>], worker, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	678 [blocks]Peek
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	679 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	680 outworker <- [assignments worker]Add Wire[[~]Index >>, [~]Output Number>>, [node]Index >>, [0]-[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	681 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	682 outworker <- Val[assignments worker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	683 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	684 index <- [node]Index >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	685 num <- 0
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	686 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	687
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	688 Blueprint Block Node
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	689 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	690 Number
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	691 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	692
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	693 Blueprint Parse Error
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	694 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	695 Type
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	696 Text
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	697 Line Number
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	698 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	699
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	700 Parse Error[type,text,number:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	701 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	702 out <- [[[Build[Parse Error()]]Type <<[type]]Text <<[text]]Line Number <<[number]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	703 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	704
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	705 Not Empty[string:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	706 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	707 If[[[string]Length] > [0]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	708 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	709 out <- Yes
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	710 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	711 out <- No
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	712 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	713 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	714
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	715 Blueprint Blueprint Field
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	716 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	717 Name
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	718 Type
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	719 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	720
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	721 New Blueprint Field[name,type:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	722 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	723 out <- [[Build[Blueprint Field()]]Name <<[name]]Type <<[type]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	724 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	725
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	726 Process Blueprint Field[list,field,params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	727 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	728 ,name <- [field]Get DString[[params]List Begin >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	729 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	730 type info <- Parse List[~,params,()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	731 type <- [type info]Index[0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	732 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	733 If[[Blueprint Of[~]] = [Named Pipe Node()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	734 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	735 before variant <- Type Instance[[type]Name >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	736 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	737 before variant <- [type]Params <<[ Map[[type]Params >>, Remove Named Pipe Node[?]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	738 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	739 variant <- [type info]Index[1]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	740 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	741 ,warn <- If[[Blueprint Of[~]] = [Named Pipe Node()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	742 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	743 fieldtype,warn <- [before variant]Set Variant[[variant]Name >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	744 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	745 Val[warn]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	746 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	747 Print[[[["Warning: Invalid variant for type "]Append[[before variant]Name >>]]Append[" on field "]]Append[name]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	748 fieldtype <- Val[before variant]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	749 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	750 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	751 fieldtype <- Val[before variant]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	752 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	753 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	754 fieldtype <- Type Instance["Any Type"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	755 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	756 out <- [list]Append[New Blueprint Field[name, fieldtype]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	757 } {} {} {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	758 out <- [list]Append[New Blueprint Field[name, Type Instance["Any Type"]]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	759 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	760 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	761
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	762 Block Comment[string,begin comment,end comment,block count:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	763 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	764 If[[block count] > [0]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	765 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	766 after, before <- [string]Get DString[[[()]Append[begin comment]]Append[end comment]] {} {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	767 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	768 If[[~] = [begin comment]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	769 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	770 out <- Block Comment[after, begin comment, end comment, [block count]+[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	771 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	772 out <- Block Comment[after, begin comment, end comment, [block count]-[1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	773 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	774 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	775 //No match
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	776 out <- ""
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	777 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	778 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	779 out <- string
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	780 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	781 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	782
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	783 Line Comment[string:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	784 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	785 [string]Get DString["\n"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	786 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	787 out <- ["\n"]Append[~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	788 } {} {} {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	789 out <- ""
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	790 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	791 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	792
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	793 _Get Comment DString[string,delims,line comment,begin comment,end comment,prev before:rest,before,delim,nomatch]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	794 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	795 after,befored,used delim,nomatch <- [string]Get DString[delims]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	796 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	797 If[[used delim] = [line comment]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	798 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	799 after comment <- Line Comment[after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	800 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	801 If[[used delim] = [begin comment]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	802 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	803 after comment <- Block Comment[after, begin comment, end comment, 1]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	804 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	805 rest <- Val[after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	806 before <- [prev before]Append[befored]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	807 delim <- Val[used delim]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	808 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	809 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	810 } {} {} {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	811 before <- [prev before]Append[befored]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	812 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	813
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	814 after comment
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	815 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	816 rest,more before,delim,nomatch <- _Get Comment DString[~, delims, line comment, begin comment, end comment, prev before]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	817 before <- [before]Append[more before]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	818 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	819
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	820 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	821
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	822 As List[val:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	823 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	824 [(List(),List Leaf())]Find[=[Blueprint Of[val], ?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	825 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	826 out <- val
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	827 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	828 out <- [()]Append[val]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	829 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	830 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	831
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	832 Get Comment DString[string,delims,params:rest,before,delim,not found]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	833 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	834 line comment <- [params]Line Comment >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	835 begin comment <- [params]Comment Begin >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	836 end comment <- [params]Comment End >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	837 all delims <- [[[delims]As List]Append[begin comment]]Append[line comment]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	838 rest, before, delim, not found <- _Get Comment DString[string, delims, line comment, begin comment, end comment, ""]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	839 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	840
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	841 Comment Left Trim[string,trim chars,params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	842 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	843 line comment <- [params]Line Comment >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	844
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	845 end comment <- [params]Comment End >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	846 trimmed <- Left Trim[string, trim chars]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	847 If[[trimmed]Starts With[line comment]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	848 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	849 ,after delim <- [trimmed]Slice[[line comment]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	850 out <- Comment Left Trim[Line Comment[after delim], trim chars, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	851 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	852 begin comment <- [params]Comment Begin >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	853 If[[trimmed]Starts With[begin comment]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	854 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	855 ,after delim <- [trimmed]Slice[[line comment]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	856 out <- Comment Left Trim[Block Comment[after delim, begin comment, end comment, 1], trim chars, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	857 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	858 out <- Val[trimmed]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	859 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	860 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	861 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	862
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	863 PBlueprint[string,params,tree,lines:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	864 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	865 ,whitespace name <- [string]Get Comment DString[[params]Block Begin >>, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	866 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	867 ,no blueprint <- [whitespace name]Slice[ [[params]Blueprint >>]Length ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	868 name <- Trim[no blueprint, "\r\n\t "]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	869 name lines <- 0
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	870 ,body <- [~]Get Comment DString[ [params]Block End >>, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	871 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	872 body lines <- [body]Split["\n"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	873 more lines <- [[[body lines]Length] - [1]] + [name lines]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	874 fields <- Fold[Process Blueprint Field[?, ?, params], (), Filter[Map[body lines, Trim[?,"\n\r\t "]], Not Empty[?]]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	875 new tree <- [tree]Blueprints << [ [[tree]Blueprints >>]Set[name, New Blueprint Definition[name, fields]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	876 out <- Null[~, params, new tree, [lines] + [more lines]]
101 f4fc0a98088a Fixed some bugs that were preventing compiled compiler from working correctly. Need to address memory usage Mike Pavone <pavone@retrodev.com> parents: 100 diff changeset	877 } {} {} {
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	878 out <- [tree]Errors <<[ [[tree]Errors >>]Append[Parse Error["Error",[["Blueprint is missing an block close symbol \""]Append[[params]Block End >>]]Append["\""], lines]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	879 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	880
101 f4fc0a98088a Fixed some bugs that were preventing compiled compiler from working correctly. Need to address memory usage Mike Pavone <pavone@retrodev.com> parents: 100 diff changeset	881 } {} {} {
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	882 out <- [tree]Errors <<[ [[tree]Errors >>]Append[Parse Error["Error",[["Blueprint is missing an block open symbol \""]Append[[params]Block Begin >>]]Append["\""], lines]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	883 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	884 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	885
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	886 Parse Import[string,params,tree,lines:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	887 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	888 [line]Slice[ [[params]Import >>]Length ] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	889 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	890 filename <- Trim[~, " \n\r\t"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	891 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	892
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	893 new tree <- [tree]Imports <<[[[tree]Imports >>]Set[filename, Yes]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	894
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	895 ,line <- [string]Get Comment DString["\n", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	896 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	897 out <- Null[~, params, new tree, [lines] + [1]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	898 } {} {} {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	899 out <- Val[new tree]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	900 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	901 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	902
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	903 Get Expression Blocks[string,params,blocks:outblocks,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	904 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	905 check block <- Comment Left Trim[string, "\n\r\t ", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	906 If[[check block]Starts With[[params]Block Begin >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	907 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	908 ,begin block <- [check block]Slice[[[params]Block Begin >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	909 trees, after block <- Worker Body[begin block, params, ()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	910 outblocks, after <- Get Expression Blocks[after block, params, [blocks]Append[trees]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	911 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	912 If[[check block]Starts With[[params]Empty Block >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	913 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	914 outblocks <- blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	915 ,after <- [check block]Slice[[[params]Empty Block >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	916 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	917 outblocks <- blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	918 after <- Val[check block]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	919 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	920 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	921 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	922
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	923 Parse Escape[string,params:char,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	924 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	925 code,rest <- [string]Slice[1]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	926 If[[code] = [[params]Hex Escape >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	927 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	928 hex,after <- [rest]Slice[2]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	929 char <- String[[Array[]]Append[Trunc UInt8[Abs UInt[Hex Int32[hex]]]]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	930 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	931 after <- Val[rest]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	932 char <- [[params]Escape Map >>]Index[code] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	933 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	934 char <- Val[code]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	935 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	936 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	937 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	938
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	939 Parse String[string,params,current:value,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	940 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	941 delims <- [[()]Append[[params]String End >>]]Append[[params]String Escape >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	942 afters, before, delim <- [string]Get Comment DString[delims, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	943 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	944 If[[delim] = [[params]String End >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	945 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	946 value <- [current]Append[before]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	947 after <- Val[afters]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	948 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	949 char,after escape <- Parse Escape[afters, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	950 value,after <- Parse String[after escape, params, [[current]Append[before]]Append[char]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	951 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	952 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	953 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	954
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	955 Parse List[string,params,list:value,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	956 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	957 trimmed <- Comment Left Trim[string, "\r\n\t ", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	958 If[[trimmed]Starts With[[params]List End >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	959 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	960 value <- list
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	961 ,after <- [trimmed]Slice[[[params]List End >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	962 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	963 If[[trimmed]Starts With[[params]List Delim >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	964 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	965 ,el string <- [trimmed]Slice[[[params]List Delim >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	966 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	967 el string <- Val[trimmed]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	968 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	969 element,after el <- Named Pipe or Literal[el string, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	970 value,after <- Parse List[after el, params, [list]Append[[element]Get Value]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	971 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	972 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	973
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	974 Get Value@Literal Node[node:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	975 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	976 out <- [node]Value >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	977 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	978
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	979 Get Value@Named Pipe Node[node:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	980 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	981 out <- node
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	982 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	983
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	984 Machine Integer[val, size, signed?:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	985 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	986 conv <- [[[[[[[[()
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	987 ]Append[UInt8[?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	988 ]Append[Int8[?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	989 ]Append[UInt16[?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	990 ]Append[Int16[?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	991 ]Append[UInt32[?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	992 ]Append[Int32[?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	993 ]Append[UInt64[?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	994 ]Append[Int64[?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	995
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	996 base idx <- [[(8,16,32,64)]Find[=[size,?]]]*[2]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	997
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	998 If[signed?]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	999 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1000 idx <- [base idx]+[1]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1001 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1002 idx <- Val[base idx]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1003 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1004 out <- [[conv]Index[idx]]Call[val]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1005 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1006
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1007 Parse Number[string,params:value,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1008 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1009 delims <- [[[[(" ","\t","\n","\r")]Append[[params]List Delim >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List End >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1010 after delim,valstring <- [string]Get Comment DString[delims, params] {} {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1011 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1012 after <- [~]Append[after delim]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1013 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1014 after <- ""
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1015 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1016 first two,rest <- [valstring]Slice[2]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1017 If[[first two] = ["0x"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1018 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1019 value <- Hex Int32[rest]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1020 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1021 If[[valstring]Contains["."]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1022 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1023 value <- Real64[valstring]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1024 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1025 size, val, type <- [valstring]Get DString[("i","u")]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1026 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1027 value <- Machine Integer[val, Int32[size], [type]=["i"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1028 } {} {} {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1029 value <- Int32[valstring]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1030 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1031 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1032 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1033 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1034
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1035 Parse Params@Type Instance[literal,params,string:out,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1036 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1037 plist,after <- Parse List[string,params,()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1038 out <- [literal]Params <<[plist]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1039 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1040
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1041 Named Pipe or Literal[string,params:out,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1042 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1043 name <- Comment Left Trim[string, "\n\r\t ", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1044 If[[name]Starts With[[params]String Begin >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1045 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1046 ,string begin <- [name]Slice[[[params]String Begin >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1047 value,after <- Parse String[string begin, params, ""]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1048 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1049 If[[name]Starts With[[params]List Begin >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1050 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1051 ,list start <- [name]Slice[[[params]List Begin >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1052 value,after <- Parse List[list start, params, ()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1053 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1054 If[[[name]Slice[1]]In["-0123456789"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1055 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1056 value,after <- Parse Number[name, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1057 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1058 delims <- [[[[[[[("\n")]Append[[params]Block Begin >>]]Append[[params]Block End >>]]Append[[params]Empty Block >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]]Append[[params]List End >>]]Append[[params]List Begin >>]
142 7bbdc034e347 Fix some bugs. Get basic network code working (epoll listener + accept connections). Start porting webserver. Mike Pavone <pavone@retrodev.com> parents: 139 diff changeset	1059 afterdelim,raw before,delim,nodelim <- [name]Get Comment DString[delims, params] {} {} {}
7bbdc034e347 Fix some bugs. Get basic network code working (epoll listener + accept connections). Start porting webserver. Mike Pavone <pavone@retrodev.com> parents: 139 diff changeset	1060 { delim <- "" }
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1061
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1062 before <- Trim[raw before, "\r\n\t "]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1063 If[[delim] = [[params]List Begin >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1064 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1065 value,after <- [Type Instance[before]]Parse Params[params,afterdelim]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1066 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1067 Val[afterdelim]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1068 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1069 after <- [delim]Append[~]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1070 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1071 Val[nodelim]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1072 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1073 after <- ""
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1074 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1075 If[[before] = ["Yes"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1076 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1077 yesno <- Yes
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1078 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1079 If[[before] = ["No"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1080 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1081 yesno <- No
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1082 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1083 If[[before] = [""]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1084 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1085 Print[[["Found "]Append[delim]]Append[" where a named pipe or literal was expected"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1086 { Print[["Near: "]Append[ [afterdelim]Slice[80]]] }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1087 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1088 If[[before]Contains[[params]Global Separator >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1089 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1090 parts <- [before]Split[[params]Global Separator >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1091 out <- Global Node[Right Trim[[parts]Index[0],"\r\n\t "], Trim[[parts]Index[1], "\r\n\t "]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1092 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1093 out <- Named Pipe Node[Right Trim[before,"\r\n\t "]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1094 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1095 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1096 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1097 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1098 out <- Literal Node[yesno]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1099 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1100 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1101 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1102 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1103 out <- Literal Node[value]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1104 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1105
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1106 Parse Arguments[string,params,arglist:args,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1107 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1108 targs <- Comment Left Trim[string, "\r\n\t ", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1109 If[[targs]Starts With[[params]List Delim >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1110 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1111 [targs]Slice[[[params]List Delim >>]Length] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1112 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1113 final args <- Comment Left Trim[~, "\r\n\t ", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1114 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1115 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1116 If[[targs]Starts With[[params]Arg End >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1117 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1118 args <- arglist
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1119 ,after <- [targs]Slice[[[params]Arg End >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1120 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1121 final args <- Val[targs]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1122 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1123 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1124 arg, after arg <- Parse Expression[final args, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1125 args, after <- Parse Arguments[after arg, params, [arglist]Append[arg]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1126 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1127
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1128 Worker or Field[name,args,params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1129 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1130 get field <- [params]Get Field >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1131 If[[name]Ends With[get field]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1132 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1133 field <- Right Trim[[name]Slice[[[name]Length] - [[get field]Length]], "\n\r\t "]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1134 out <- Field Node[field, args, No]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1135 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1136 set field <- [params]Set Field >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1137 If[[name]Ends With[set field]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1138 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1139 field <- Right Trim[[name]Slice[[[name]Length] - [[set field]Length]], "\n\r\t "]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1140 out <- Field Node[field, args, Yes]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1141 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1142 out <- Worker Node[name, args]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1143 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1144 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1145 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1146
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1147 Prefix[string,params,name,existing args:expression,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1148 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1149 //Parse argument list
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1150 more args,after <- Parse Arguments[string, params, existing args]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1151 expression <- Worker or Field[name, more args, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1152 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1153
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1154 Postfix or Infix[string,params:expression,after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1155 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1156 args, after args <- Parse Arguments[string, params, ()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1157 delims <- [[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Empty Block >>]]Append[[params]Block Begin >>]]Append[[params]Arg End >>]]Append[[params]List Delim >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1158 aftere,before,delim <- [after args]Get Comment DString[delims, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1159 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1160 If[[delim] = [[params]Arg Begin >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1161 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1162 expression, after <- Prefix[aftere, params, Trim[before,"\r\n\t "], args]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1163 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1164 If[[delim] = [[params]Empty Block >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1165 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1166 after <- Val[aftere]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1167 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1168 ,after <- [after args]Slice[[before]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1169 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1170 expression <- Worker or Field[Trim[before,"\r\n\t "], args, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1171 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1172 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1173 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1174
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1175 Parse Expression[trimmed,params:final expression,after blocks]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1176 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1177 delims <- [[[[[[[("\n")]Append[[params]Arg Begin >>]]Append[[params]Arg End >>]]Append[[params]Assign >>]]Append["\n"]]Append[[params]Empty Block >>]]Append[[params]Block End >>]]Append[[params]String Begin >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1178 after, before, delim <- [trimmed]Get Comment DString[delims, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1179 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1180 //If we find an arg begin token, we have a worker expression
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1181 If[[delim] = [[params]Arg Begin >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1182 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1183 maybe name <- Right Trim[before, "\r\t "]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1184 //Prefix expressions will have the worker name before the first arg begin token
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1185 If[[maybe name] = [""]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1186 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1187 expression, after expression <- Postfix or Infix[after, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1188 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1189 If[[maybe name]Contains[[params]List Delim >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1190 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1191 after expression <- [after literal]Append[[delim]Append[after]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1192 expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1193 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1194 expression, after expression <- Prefix[after, params, maybe name, ()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1195 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1196 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1197 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1198 If[[delim] = [[params]Assign >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1199 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1200 //Expressions starting with an assignment can be prefix, postfix or infix
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1201 //or they can be a simple literal or named pipe
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1202 assignments <- Map[[before]Split[[params]List Delim >>], Trim[?,"\n\r\t "]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1203 ,after blocks <- Parse Expression[Comment Left Trim[after, " \n\r\t", params], params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1204 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1205 final expression <- [~]Assignments <<[assignments]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1206 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1207 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1208 //If[[delim] = [[params]String Begin >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1209 //{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1210 // If[[Trim[before, "\r\n\t "]] = [""]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1211 // {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1212 // expression, after expression <- Named Pipe or Literal[[delim]Append[after], params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1213 // }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1214 // after expression <- [after literal]Append[[delim]Append[after]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1215 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1216 // }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1217 //}{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1218 // after expression <- [after literal]Append[[delim]Append[after]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1219 // expression, after literal <- Named Pipe or Literal[Right Trim[before, "\r\n\t "], params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1220 //}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1221 expression, after expression <- Named Pipe or Literal[trimmed, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1222 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1223 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1224 //Any expression can be followed by one or more blocks mapping the inputs of other expressions
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1225 //to the outputs of the current one
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1226 blocks,after blocks <- Get Expression Blocks[after expression, params, ()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1227 final expression <- [expression]Blocks <<[blocks]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1228 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1229 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1230
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1231 Worker Body[string,params,trees:outtrees,after end]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1232 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1233 trimmed <- Comment Left Trim[string, "\n\r\t ", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1234 If[[trimmed]Starts With[[params]Block End >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1235 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1236 //We're done with this block, return
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1237 ,after end <- [trimmed]Slice[[[params]Block End >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1238 outtrees <- trees
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1239 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1240 expression, after expression <- Parse Expression[trimmed, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1241 outtrees,after end <- Worker Body[after expression, params, [trees]Append[expression]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1242 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1243 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1244
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1245 Process Modifiers[worker,params,modifiers:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1246 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1247 //Eventually this will need to be more sophisticated to handle more modifiers
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1248 trimmed <- Comment Left Trim[modifiers, "\n\r\t ", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1249 If[[trimmed]Starts With[[params]Uses >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1250 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1251 ,after uses <- [trimmed]Slice[[[params]Uses >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1252 ,stores string <- [after uses]Get Comment DString["\n", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1253 out <- [worker]Uses Stores <<[Map[[stores string]Split[[params]List Delim >>], Trim[?, "\r\n\t "]]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1254 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1255 out <- worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1256 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1257 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1258
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1259 Remove Named Pipe Node[element:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1260 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1261 If[[Blueprint Of[element]] = [Named Pipe Node()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1262 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1263 out <- [element]Name >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1264 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1265 If[[Blueprint Of[element]] = [Type Instance()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1266 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1267 out <- [element]Params <<[ Map[[element]Params >>, Remove Named Pipe Node[?]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1268 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1269 out <- element
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1270 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1271 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1272 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1273
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1274 Parse Param List[text,paramlist,typelist,params:out params,out types]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1275 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1276 delims <- [[()]Append[[params]List Begin >>]]Append[[params]List Delim >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1277 after,param name <-[text]Get DString[delims] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1278 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1279 tname <- Trim[~, "\r\n\t "]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1280 If[[tname] = [""]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1281 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1282 nextlist <- Val[paramlist]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1283 next types <- Val[typelist]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1284 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1285 nextlist <- [paramlist]Append[tname]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1286 next types <- [typelist]Append[paramtype]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1287 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1288 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1289 If[[~] = [[params]List Begin >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1290 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1291 type info,after type <- Parse List[after,params,()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1292 type <- [type info]Index[0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1293 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1294 If[[Blueprint Of[~]] = [Named Pipe Node()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1295 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1296 before variant <- Type Instance[[type]Name >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1297 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1298 before variant <- <- [type]Params <<[ Map[[type]Params >>, Remove Named Pipe Node[?]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1299 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1300 variant <- [type info]Index[1]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1301 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1302 ,warn <- If[[Blueprint Of[~]] = [Named Pipe Node()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1303 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1304 before mutable,warn <- [before variant]Set Variant[[variant]Name >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1305 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1306 Val[warn]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1307 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1308 Print[[[["Warning: Invalid variant for type "]Append[[before variant]Name >>]]Append[" on input "]]Append[param name]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1309 before mutable <- Val[before variant]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1310 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1311 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1312 before mutable <- Val[before variant]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1313 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1314 [type info]Index[2]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1315 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1316 paramtype <- [before mutable]Mutable? <<[ [[~]Name >>] = ["Mutable"] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1317 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1318 paramtype <- Val[before mutable]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1319 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1320 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1321 paramtype <- Type Instance["Any Type"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1322 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1323 [after type]Get DString[","]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1324 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1325 out params,out types <- Parse Param List[~,nextlist,next types,params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1326 } {} {} {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1327 out params <- Val[nextlist]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1328 out types <- Val[next types]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1329 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1330 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1331 paramtype <- Type Instance["Any Type"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1332 out params,out types <- Parse Param List[after,nextlist,next types,params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1333 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1334
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1335 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1336 paramtype <- Type Instance["Any Type"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1337 out params <- Val[nextlist]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1338 out types <- Val[next types]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1339 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1340 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1341
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1342 Worker Declaration[string,params:worker,rest,no match]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1343 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1344 ,whitespace name <- [string]Get Comment DString[[params]Arg Begin >>, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1345 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1346 worker name <- Trim[whitespace name, "\n\r\t "]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1347 in out <- [params]In Out Delim >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1348 arg end <- [params]Arg End >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1349 delims <- [[()]Append[in out]]Append[arg end]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1350 after <- [~]Get Comment DString[delims, params] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1351 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1352 arglist <- Trim[~,"\r\n\t "]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1353 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1354 //check if there is an in/out separator
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1355 //if it isn't present, everything in the arglist is an input
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1356 If[[~] = [in out]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1357 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1358 rest <- [after]Get Comment DString[arg end, params] {}
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1359 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1360 outputs,output types <- Parse Param List[~, (), (), params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1361 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1362 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1363 rest <- Val[after]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1364 outputs <- ()
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1365 output types <- ()
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1366 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1367 inputs,input types <- Parse Param List[arglist, (), (), params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1368 worker <- Parse Worker[worker name, inputs, outputs, input types, output types, 0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1369 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1370 }{}{}{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1371 no match <- string
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1372 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1373 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1374
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1375 Worker Name[string,params,tree,lines:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1376 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1377 ,after arglist <- Worker Declaration[string, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1378 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1379 worker name <- [~]Name >>
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1380 body text, modifiers <- [after arglist]Get Comment DString[[params]Block Begin >>, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1381 modified <- Process Modifiers[~, params, modifiers]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1382 expression trees, after body <- Worker Body[body text, params, ()]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1383 worker <- [modified]Trees <<[expression trees]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1384 new worker dict <- [[tree]Workers >>]Set[worker name, worker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1385 out <- Null[after body, params, [tree]Workers <<[new worker dict], 0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1386 } {} {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1387 out <- tree
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1388 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1389 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1390
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1391 Parse Foreign Worker[tree, string, lib, params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1392 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1393 ,rest <- Worker Declaration[string, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1394 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1395 foreign <- [~]Trees << [lib]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1396 next <- [tree]Workers << [[[tree]Workers >>]Set[[foreign]Name >>, foreign]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1397 out <- Parse Foreign Worker[next, rest, lib, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1398 } {} {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1399 out <- tree
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1400 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1401 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1402
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1403 Parse Foreign[string,params,tree,lines:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1404 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1405 ,after foreign <- [string]Slice[[[params]Foreign >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1406 [after foreign]Get Comment DString[[params]Blueprint Type Delim >>, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1407 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1408 [~]Get Comment DString[[params]Block Begin >>, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1409 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1410 rest, body <- [~]Get Comment DString[[params]Block End >>, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1411 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1412 { lib <- Trim[~, "\r\n\t "] }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1413 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1414 { language <- Trim[~, "\r\n\t "] }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1415 Parse Foreign Worker[tree, body, New Foreign Lib[language, lib], params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1416 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1417 out <- Null[rest, params, ~, 0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1418 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1419 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1420
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1421 Parse Global Vars[string,params,store:out]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1422 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1423 trimmed <- Left Trim[string, "\r\n\t "]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1424 If[trimmed]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1425 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1426 ,,after <- [trimmed]Partition[[params]Assign >>]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1427 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1428 varname <- Right Trim[~, "\r\n\t "]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1429 } {} {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1430 valstring <- [~]Partition["\n"] {} {}
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1431 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1432 out <- Parse Global Vars[~,params,next store]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1433 }{
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1434 valstring <- Val[after]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1435 out <- Val[next store]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1436 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1437 Val[valstring]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1438 {
142 7bbdc034e347 Fix some bugs. Get basic network code working (epoll listener + accept connections). Start porting webserver. Mike Pavone <pavone@retrodev.com> parents: 139 diff changeset	1439 Print[["Parsing initial value: "]Append[valstring]]
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1440 value <- [Named Pipe or Literal[Trim[~, "\r\n\t "], params]]Value >>
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1441 next store <- [store]Vars <<[ [[store]Vars >>]Set[varname, value] ]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1442 }
142 7bbdc034e347 Fix some bugs. Get basic network code working (epoll listener + accept connections). Start porting webserver. Mike Pavone <pavone@retrodev.com> parents: 139 diff changeset	1443 }{
7bbdc034e347 Fix some bugs. Get basic network code working (epoll listener + accept connections). Start porting webserver. Mike Pavone <pavone@retrodev.com> parents: 139 diff changeset	1444 Print[["Expected assignment operator in global var block, found "]Append[trimmed]]
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1445 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1446 }{
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1447 out <- store
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1448 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1449 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1450
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1451 Parse Globals[string,params,tree,lines:out]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1452 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1453 ,after globals <- [string]Slice[[[params]Globals >>]Length]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1454 [after globals]Partition[[params]Block Begin >>]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1455 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1456 store <- Global Store[Trim[~, "\r\n\t "]]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1457 } {} {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1458
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1459 [~]Partition[[params]Block End >>]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1460 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1461 next tree <- [tree]Add Global Store[Parse Global Vars[~, params, store]]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1462 } {} {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1463 out <- Null[~,params,next tree,lines]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1464 }{
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1465 Print["Error: Globals declaration missing block close symbol"]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1466 out <- tree
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1467 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1468 } {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1469 Print["Error: Globals declaration without block"]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1470 out <- tree
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1471 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1472 }
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1473
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1474
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1475 Null[string,params,tree,lines:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1476 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1477 trimmed <- Comment Left Trim[string, " \n\r\t", params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1478 current line <- 0
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1479 If[[trimmed]Starts With[ [params]Blueprint >> ]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1480 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1481 out <- PBlueprint[trimmed, params, tree, current line]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1482 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1483 If[[trimmed]Starts With[ [params]Import >> ]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1484 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1485 out <- Parse Import[trimmed, params, tree, current line]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1486 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1487 If[[trimmed]Starts With[ [params]Foreign >> ]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1488 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1489 out <- Parse Foreign[trimmed, params, tree, current line]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1490 }{
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1491 If[[trimmed]Starts With[[params]Globals >>]]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1492 {
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1493 out <- Parse Globals[trimmed, params, tree, current line]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1494 }{
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1495 If[trimmed]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1496 {
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1497 out <- Worker Name[trimmed, params, tree, current line]
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1498 }{
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1499 out <- tree
a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1500 }
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1501 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1502 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1503 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1504 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1505 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1506
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1507 Check Worker Literals@Parse Worker[worker,program:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1508 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1509 [(List(),List Leaf())]Find[=[Blueprint Of[[worker]Trees >>], ?]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1510 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1511 out <- [worker]Trees <<[ Map[[worker]Trees >>, Check Worker Literals[?, program]] ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1512 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1513 out <- worker
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1514 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1515 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1516
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1517 Register Workers Compile[prog, worker, name:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1518 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1519 //Print[["Registering "]Append[name]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1520 If[[ Blueprint Of[[worker]Trees >>] ] = [Foreign Lib()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1521 { convention <- Val[[[worker]Trees >>]Language >>] }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1522 { convention <- "rhope" }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1523 out <- [prog]Register Worker[name, convention, [[worker]Inputs >>]Length, [[worker]Outputs >>]Length]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1524 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1525
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1526 Add Workers Compile[prog, worker, name:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1527 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1528 Print[["Transforming "]Append[name]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1529 If[[Blueprint Of[[worker]Trees >>]] = [Foreign Lib()]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1530 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1531 //TODO: Handle foreign func
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1532 final nworker <- [[[[[NWorker[[[worker]Trees >>]Language >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1533 ]Inputs <<[ [worker]Inputs >> ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1534 ]Input Types <<[ [worker]Input Types >> ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1535 ]Outputs <<[ [worker]Outputs >> ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1536 ]Output Types <<[ [worker]Output Types >> ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1537 ]Library <<[ [[worker]Trees >>]Name >> ]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1538
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1539 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1540 trees, nworker, refs <- Add List to Worker[[worker]Trees >>, [[NWorker["rhope"]]Uses[[worker]Uses Stores >>]]Outputs <<[ [worker]Outputs >> ], prog, worker, Dictionary[]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1541 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1542 final nworker <- Fold[Add Wires Helper[?, ?, ?, worker, refs], nworker, trees]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1543 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1544
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1545 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1546 out <- [prog]Bind Worker[name, final nworker]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1547 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1548
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1549 Add Wires Helper[worker,node,unused,parse worker,assignments:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1550 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1551 out <- [node]Add Wires[worker, (), parse worker, assignments]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1552 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1553
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1554 Add Blueprint Field[blueprint,field,unused:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1555 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1556 out <- [blueprint]Add Field[[field]Name >>, [field]Type >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1557 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1558
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1559 Add Blueprint Compile[prog,def:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1560 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1561 out <- [prog]Bind Blueprint[[def]Name >>, Fold[Add Blueprint Field[?], NBlueprint[], [def]Fields >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1562 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1563
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: 115 diff changeset	1564 Tree to Program Native[parse tree,number types:out]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1565 {
139 a68e6828d896 Global stores and transactions are working. Definately leaks memory on retries. Probably a fair number of bugs to work out. However, a basic test program works. Mike Pavone <pavone@retrodev.com> parents: 136 diff changeset	1566 registered <- Fold[Register Workers Compile[?], [Fold[Add Blueprint Compile[?], [[NProgram[]]Numtypes <<[number types]]Global Stores <<[[parse tree]Global Stores >>], [parse tree]Blueprints >>]]Register Builtins, [parse tree]Workers >>]
100 f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1567 out <- Fold[Add Workers Compile[?], registered, [parse tree]Workers >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1568 { Print["Transformed AST to dataflow graph "] }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1569 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1570
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1571 Needs Imports[needs import,not imported?,name:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1572 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1573 If[not imported?]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1574 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1575 out <- [needs import]Append[name]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1576 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1577 out <- needs import
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1578 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1579 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1580
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1581 Do Import[tree,file name,unused,params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1582 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1583 Print[["Parsing: "]Append[file name]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1584 file <- [File[file name]]Open["r"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1585 text <- String[[file]Read[[file]Length]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1586 after import <- Null[text, params, tree, 0]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1587
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1588 out <- [after import]Imports <<[[[after import]Imports >>]Set[file name, No]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1589 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1590
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1591 Process Imports[parse tree,params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1592 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1593 needs import <- Fold[Needs Imports[?], (), [parse tree]Imports >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1594 If[[[needs import]Length] > [0]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1595 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1596 import tree <- Fold[Do Import[?, ?, ?, params], parse tree, needs import]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1597 out <- Process Imports[import tree, params]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1598 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1599 out <- parse tree
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1600 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1601 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1602
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1603 Until End[text:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1604 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1605 line <- Get Input[]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1606 If[[line] = ["End"]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1607 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1608 out <- [text]Append["\n"]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1609 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1610 out <- Until End[[[text]Append["\n"]]Append[line]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1611 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1612 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1613
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1614 Add If Store[stores,name,params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1615 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1616 If[[name]Contains[[params]Global Separator >>]]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1617 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1618 parts <- [name]Split[[params]Global Separator >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1619 out <- [stores]Set[[parts]Index[0], Yes]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1620 }{
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1621 out <- stores
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1622 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1623 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1624
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1625 Param Gather Stores[stores,node,params:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1626 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1627 out <- [node]Gather Stores[params, stores]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1628 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1629
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1630 Gather Stores@Named Pipe Node[node,params,stores:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1631 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1632 out <- Fold[Add If Store[?, ?, params], stores, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1633 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1634
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1635 Gather Stores@Global Node[node,params,stores:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1636 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1637 out <- [stores]Set[[node]Store >>, Yes]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1638 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1639
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1640 Gather Stores@Worker Node[node,params,stores:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1641 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1642 //TODO: Handle blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1643 store list <- Fold[Param Gather Stores[?, ?, params], stores, [node]Params >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1644 out <- Fold[Add If Store[?, ?, params], store list, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1645 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1646
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1647 Gather Stores@Field Node[node,params,stores:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1648 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1649 //TODO: Handle blocks
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1650 store list <- Fold[Param Gather Stores[?, ?, params], stores, [node]Params >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1651 out <- Fold[Add If Store[?, ?, params], store list, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1652 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1653
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1654 Gather Stores@Literal Node[node,params,stores:out]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1655 {
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1656 out <- Fold[Add If Store[?, ?, params], stores, [node]Assignments >>]
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1657 }
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1658
f51c4c17457c Broken port of parser to compiler Mike Pavone <pavone@retrodev.com> parents: diff changeset	1659

Mercurial > repos > rhope

annotate parser_old_c.rhope @ 142:7bbdc034e347