( Of, or relating to structure, as opposed to substance. )

@on-reset ( -> )
	;token/on-console .Console/vector DEO2
	BRK

(
@|Compiler )

@token/on-console ( -> )
	.Console/read DEI DUP ?{ POP <eval>
		POP2 BRK }
	/<push>
	BRK

@token/<push> ( c -- )
	DUP [ LIT "( ] NEQ ?{ /<store>
		;dict/sym-a !body/<push-cell> }
	DUP [ LIT ") ] NEQ ?{ /<store>
		;dict/sym-b !body/<push-cell> }
	DUP #21 LTH ?/<store>
	( | push )
	[ LIT2 00 &ptr -&buf ] INCk ,&ptr STR
	STZ2
	JMP2r

@token/<store> ( c -- )
	POP ;&buf
	( ) LDZk ?{ POP2 JMP2r }
	( ) DUP2 dec/valid ?/<store-number>
	( ) dict/find-alloc body/<push-cell>
	( ) DUP ,&ptr STR
	STZ
	JMP2r

@token/<store-number> ( str* -- )
	DUP2 str/to-dec body/<push-number>
	( ) DUP ,&ptr STR
	STZ
	JMP2r

@dict/find-alloc ( src* -- src* ptr* )
	STH2k ,&ptr LDR2 ;&buf-prefabs
	&>lf
		DUP2 STH2kr str/compare ?{
			INC2 GTH2k ?&>lf
		POP2 STH2r !/alloc }
	NIP2 POP2r JMP2r

@dict/alloc ( ptr* str* -- ptr* )
	LDAk DUP [ LIT2 &ptr =&buf ] INC2k ,&ptr STR2
	STA
	?{ POP2 JMP2r }
	INC2 !&alloc

(
@|Runtime )

%NEXT ( addr* -- next* ) {
	INC2 INC2 }

%is-wildcard ( addr* -- bool ) {
	LDA2k LDA [ LIT "? ] EQU }

@<eval> ( -- count* )
	#0000
	&>w
		rewrite/<step>
		body/<print>
		wildcards/<print>
		?{ #800f DEO
			JMP2r }
		INC2 ORAk ?&>w
	#010f DEO
	;&err !err/<print>

@rewrite/<step> ( -- rew )
	[ LITr 00 ] body/get-bounds
	&>l
		LDA2k ;dict/sym-a NEQ2 ?{
			DUP2 rules/find [ INC2k ORA ?/<match> POP2 ] }
		LDA2k ;dict/sym-rule EQU2 ?/<rule>
		body/push-cell-at NEXT GTH2k ?&>l
	( >> )

@rewrite/<tail> ( to* from* . rew -- rew )
	NEQ2k ?{
		POP2 #0000 SWP2 STA2
		STHr JMP2r }
	body/push-cell-at NEXT !/<tail>

@rewrite/<match> ( to* from* . rew -- rew )
	INCr
	( rewrite ) tuple/walk ;&do-cell tuple/<foreach>
	( advance ) tuple/walk !/<tail>

@rewrite/<rule> ( to* from* . rew -- rew )
	INCr NEXT rules/<push> !/<tail>

@rewrite/do-cell ( cell* -- cell* )
	is-wildcard ?{ LDA2k !body/<push-cell> }
	LDA2k wildcards/find INC2k ORA ?{ POP2 JMP2r }
	NEXT LDA2 ;body/push-cell-at !tuple/<foreach>

(
@|Rules )

@rules/compare ( rule* cell* -- a* bool cell* )
	STH2
	is-wildcard ?{
		( compare ) LDA2k STH2kr LDA2 EQU2 STH
		( advance ) NEXT STHr STH2r NEXT JMP2r }
	( | check wildcard )
	STH2kr LDA2 ;dict/sym-b NEQ2 ?{ #00 STH2r JMP2r }
	( | find wildcard )
	LDA2k wildcards/find INC2k ORA ?{
		( makenew ) POP2 STH2kr OVR2 LDA2 wildcards/<push>
		( advance ) NEXT #01 STH2r !tuple/walk }
	( compare ) NEXT LDA2 STH2kr tuple/compare STH
	( advance ) NEXT STHr STH2r !tuple/walk

@rules/match ( rule* tuple* -- bool )
	wildcards/<reset>
	STH2
	tuple/get-bounds
	&>lmn
		STH2r /compare STH2
		?{
			POP2 POP2 #00 POP2r JMP2r }
		GTH2k ?&>lmn
	EQU2 POP2r JMP2r

@rules/find ( tuple* -- rule* )
	STH2
	,&ptr LDR2 ;&buf
	&>lm
		DUP2 STH2kr /match ?{
			tuple/walk tuple/walk GTH2k ?&>lm
		POP2 #ffff }
	NIP2 POP2r JMP2r

@rules/<push> ( addr* -- addr* )
	DUP2 tuple/walk
	( | no rhs )
	LDA2k ORA ?{ NIP2 JMP2r }
	LDA2k ;dict/sym-rule NEQ2 ?{ NIP2 JMP2r }
	tuple/walk SWP2
	&>l
		LDA2k [ LIT2 &ptr =&buf ] INC2k INC2 ,&ptr STR2
		STA2
		NEXT GTH2k ?&>l
	POP2 JMP2r

(
@|Body )

@body/push-cell-at ( addr* -- addr* )
	LDA2k
	( >> )

@body/<push-cell> ( cell* -- )
	[ LIT2 &ptr =&a ] INC2k INC2 ,&ptr STR2
	STA2
	JMP2r

@body/<push-number> ( num* -- )
	DUP2
	( a ) ;dict/sym-a body/<push-times>
	( 0 ) ;dict/sym-zero body/<push-cell>
	( b ) ;dict/sym-b
	( >> )

@body/<push-times> ( times* sym* -- )
	STH2
	#0000 SWP2 SUB2
	&>w
		ORAk ?{ POP2 POP2r JMP2r }
		STH2kr /<push-cell>
		INC2 !&>w

@body/get-bounds ( -- to* from* )
	;&ptr LDA2 ;&b ;&a
	( | flip )
	[ LIT2 01 &bank $1 ] INCk ,&bank STR
	AND ?{ SWP2 }
	;&ptr STA2
	DUP2 ,&origin STR2
	JMP2r

@body/<print> ( -- )
	[ LIT2 &origin $2 ] LDA2k ;dict/sym-rule NEQ2 ?{ POP2 JMP2r }
	!tuple/<pretty-print>

(
@|Wildcards )

@wildcards/find ( name* -- wildcard* )
	STH2
	,&ptr LDR2 ;&buf
	&>lf
		LDA2k STH2kr EQU2 ?{
			#0004 ADD2 GTH2k ?&>lf
		POP2 #ffff }
	NIP2 POP2r JMP2r

@wildcards/<push> ( addr* name* -- )
	[ LIT2 &ptr =&buf ] STA2k
	( ) NIP2 NEXT STA2k
	( ) NEXT ,&ptr STR2
	POP2 JMP2r

@wildcards/<reset> ( -- )
	;&buf ,&ptr STR2
	#0000 ;&buf STA2
	JMP2r

@wildcards/<print> ( -- )
	;dict/sym-print /find INC2k ORA ?{ POP2 JMP2r }
	NEXT LDA2k LDA2 ;dict/sym-a EQU2 ?{ LDA2 LDA2 !str/<print> }
	tuple/count-depth !dec/<print>

(
@|Utilities )

@tuple/walk ( tuple* -- end* )
	[ LITr 00 ]
	&>w
		LDA2k ORA ?{ POPr JMP2r }
		LDA2k ;dict/sym-a NEQ2 ?{ INCr }
		LDA2k ;dict/sym-b NEQ2 ?{
			[ LITr 01 ] SUBr STHkr ?{ POPr NEXT JMP2r } }
		NEXT STHkr ?&>w
	POPr JMP2r

@tuple/compare ( a* b* -- bool )
	STH2
	/get-bounds
	&>lc
		LDA2k STH2kr LDA2 EQU2 ?{
			POP2 POP2 #00 POP2r JMP2r }
		NEXT INC2r INC2r GTH2k ?&>lc
	EQU2 POP2r JMP2r

@tuple/<foreach> ( fn* -- )
	STH2
	/get-bounds
	&>l
		STH2kr JSR2 NEXT GTH2k ?&>l
	POP2 POP2 POP2r JMP2r

@tuple/get-bounds ( tuple* -- to* from* )
	DUP2 /walk SWP2 JMP2r

@tuple/count-depth ( tuple* -- depth* )
	[ LIT2r 0000 ] LDA2 /get-bounds
	&>le
		LDA2k ;dict/sym-a NEQ2 ?{ INC2r }
		NEXT GTH2k ?&>le
	POP2 POP2 STH2r JMP2r

@tuple/<pretty-print> ( tuple* -- )
	[ LIT2 "( _&last ] STR
	&>lp
		LDA2k ORAk ?{
			POP2 POP2 [ LIT2 0a -Console/error ] DEO
			JMP2r }
		LDAk [ LIT ") ] EQU [ LIT2 &last $1 "( ] EQU ORA ?{
			[ LIT2 20 -Console/error ] DEO }
		LDAk ,&last STR
		err/<print>
		NEXT !&>lp

@str/compare ( a* b* -- bool )
	STH2
	&>wc
		LDAk ?{ &d LDA LDAr STHr EQU JMP2r }
		LDAk LDAkr STHr NEQ ?&d
		INC2 INC2r !&>wc

@str/<print> ( str* -- )
	&>wp
		LDAk DUP ?{ POP POP2 JMP2r }
		DUP [ LIT "\ ] NEQ ?{ POP INC2 LDAk chr/escape }
		.Console/write DEO
		INC2 !&>wp

@str/to-dec ( str* -- val* )
	[ LIT2r 0000 ]
	&>w
		( -- ) ( acc ) [ LIT2r 000a ] MUL2r
		( add ) LDAk [ LIT "0 ] SUB [ LITr 00 ] STH
		ADD2r
		( next ) INC2 LDAk ?&>w
	POP2 STH2r JMP2r

@err/<print> ( str* -- )
	LDAk DUP ?{ POP POP2 JMP2r }
	.Console/error DEO
	INC2 !err/<print>

@dec/<print> ( short* -- )
	#000a SWP2 [ LITr ff ]
	&>get
		SWP2k DIV2k MUL2 SUB2 STH
		POP OVR2 DIV2 ORAk ?&>get
	POP2 POP2
	&>put
		STHr INCk ?{ POP JMP2r }
		[ LIT "0 ] ADD .Console/write DEO !&>put

@dec/valid ( str* -- f )
	&>wv
		LDAk LIT "0 SUB #0a LTH ?{ POP2 #00 JMP2r }
		INC2 LDAk ?&>wv
	POP2 #01 JMP2r

@chr/escape ( byte -- byte )
	DUP [ LIT "t ] NEQ ?{ POP #09 JMP2r }
	[ LIT "n ] NEQ ?{ #0a JMP2r }
	#20 JMP2r

(
@|Assets )

@<eval>/err "Cycles 20 "exhausted. 0a00

@dict
	&sym-a "( $1
	&sym-b ") $1 &buf-prefabs
	&sym-rule "<> $1
	&sym-print "?: $1
	&sym-zero "0 $1 &buf $1000

@wildcards/buf $100

@rules/buf $1000

@body/a $6000 &b $6000
|10 @Console/vector $2 &read $5 &type $1 &write $1 &error $1
|00 @token/buf