( 54K . POP-2 )

|10 @Console &vector $2 &read $1 &pad $4 &type $1 &write $1 &error $1
|00 @token/buf

|100

@on-reset ( -> )
	;meta #06 DEO2
	token/<bind>
	BRK

@meta $1
	( name ) "POP-2 0a
	( desc ) "A 20 "POP-2 20 "Compiler 0a
	( auth ) "By 20 "Devine 20 "Lu 20 "Linvega 0a
	( date ) "5 20 "Aug 20 "2026 0000

@token/<bind> ( -- )
	/<reset>
	;&on-console .Console/vector DEO2
	JMP2r

@token/on-console ( -> )
	.Console/read DEI
	( | handlers )
	DUP #20 GTH ?{ POP /<parse>
		BRK }
	/<push>
	BRK

@token/<push> ( c -- )
	[ LIT2 00 &ptr -&buf ] INCk ,&ptr STR
	STZ2
	JMP2r

@token/<push-str> ( str* -- )
	&>wps
		LDAk DUP ?{ POP POP2 JMP2r }
		/<push>
		INC2 !/>wps

@token/push-label ( str* -- next* buf* )
	&>wpl
		LDAk DUP chr/is-label ?{ POP ;&buf JMP2r }
		/<push>
		INC2 !/>wpl

@token/push-operand ( str* -- next* buf* )
	&>wpo
		LDAk DUP chr/is-operand ?{ POP ;&buf JMP2r }
		/<push>
		INC2 !/>wpo

@token/<parse> ( -- )
	.&buf LDZ ?{ JMP2r }
	;&buf /<route-keyword>
	( >> )

@token/<reset> ( -- )
	[ LIT2 00 -&buf ] STZ
	[ LIT2 -&buf _&ptr ] STR
	JMP2r

@token/<route-keyword> ( token* -- )
	DUP2 keywords/find INC2k ORA ?{
		POP2
		( label: ) /is-label ?label/<bind>
		!expr/<bind-token> }
	NIP2 INC2 INC2 LDA2 JMP2

@token/is-label ( -- t )
	[ LIT2 ff _&ptr ] LDR ADD LDZ LIT ": EQU JMP2r

(
@|BlockComment )

@comment/<bind> ( -- )
	;&on-console .Console/vector DEO2
	;&a !str/<print-ws>

	&a 0a "( 00

@comment/on-console ( -> )
	.Console/read DEI
	( | handlers )
	chr/not-sc ?{
		POP ;&b str/<print>
		token/<bind>
		BRK }
	#18 DEO
	BRK

	&b 20 ") 0a 00

(
@|BlockFunction )

@<bind> ( vector* -- )
	dict/<reset>
	stack/<reset>
	expr/<reset>
	.Console/vector DEO2
	JMP2r

@function/<bind> ( -- )
	;&on-console <bind>
	;dict/anon-jump str/<print-ws>
	LIT2 "@ 18 DEO
	;dict/fn-prefix !str/<print>

@function/on-console ( -> )
	.Console/read DEI
	( | handlers )
	chr/not-sc ?{
		POP
		( | print name )
		;expr/buf str/walk-ws str/print-word chr/<ws>
		vars/<parse>
		lambda/<emit-bindings>
		token/<bind>
		BRK }
	expr/<push>
	BRK

(
@|BlockVars )

@vars/<bind> ( -- )
	;&on-console !<bind>

@vars/on-console ( -> )
	.Console/read DEI
	( | handlers )
	chr/not-sc ?{
		POP ;expr/buf /<parse>
		token/<bind>
		BRK }
	expr/<push>
	BRK

@vars/<parse> ( expr* -- )
	token/<reset>
	;dict/anon-jump str/<print-ws>
	&>w
		LDAk DUP ?{
			POP POP2 /<parse-token>
			LIT2 "} 18 DEO !chr/<lb> }
		DUP LIT "" NEQ ?{ token/<push>
			INC2 /<parse-string> !/resume }
		DUP #20 GTH ?{ POP /<parse-token> !/resume }
		token/<push> &resume INC2 !/>w

@vars/<parse-string> ( str* -- str* )
	&>wps
		LDAk
		( | handlers )
		DUP ?{ POP JMP2r }
		DUP LIT "" NEQ ?{ !token/<push> }
		token/<push>
		INC2 !/>wps

@vars/<parse-token> ( -- )
	;token/buf LDAk ?{ POP2 JMP2r }
	&>wpt
		LDAk DUP ?{
			POP POP2 ;token/buf DUP2 dict/alloc stack/<push>
			prefab-sublab/<emit>
			#0002 prefab-pad/<emit> !token/<reset> }
		LIT ": NEQ ?{
			STH2k #00 STH2r STA
			;token/buf DUP2 dict/alloc stack/<push>
			prefab-sublab/<emit>
			INC2 LDAk LIT "" NEQ ?{ prefab-string/<emit> !token/<reset> }
			str/dec prefab-pad/<emit> !token/<reset> }
		INC2 !/>wpt

(
@|BlockLambda )

@lambda/<bind> ( -- )
	;&on-console <bind>

@lambda/on-console ( -> )
	.Console/read DEI
	( | handlers )
	chr/not-sc ?{
		POP ;expr/buf vars/<parse>
		/<emit-bindings>
		token/<bind>
		BRK }
	expr/<push>
	BRK

@lambda/<emit-bindings> ( -- )
	&>web
		stack/depth ?{ !chr/<lb> }
		stack/pop prefab-binding/<emit> !/>web

(
@|BlockEnd )

@end/<bind> ( -- )
	;dict/jmp2r str/<print-ws>
	LIT2 "} 18 DEO
	chr/<lb> !token/<bind>

(
@|BlockGoto )

@goto/<bind> ( -- )
	;&on-console .Console/vector DEO2 !token/<reset>

@goto/on-console ( -> )
	.Console/read DEI
	( | handlers )
	DUP chr/is-an ?{ POP /<parse>
		BRK }
	token/<push>
	BRK

@goto/<parse> ( -- )
	;token/buf LDAk ?{ POP2 JMP2r }
	str/walk-ws prefab-jump/<emit> !token/<bind>

(
@|BlockLabel )

@label/<bind> ( token* -- )
	chr/<lb>
	LIT2 "& 18 DEO
	LIT ": str/<print-until>
	chr/<ws> !token/<bind>

(
@|BlockIfElse )

@if/<bind> ( -- )
	;&on-console <bind>
	#00 ;&case STA
	/<push-nesting> !expr/<reset>

@if/on-console ( -> )
	.Console/read DEI
	( end ) chr/not-sc ?{ POP /<parse>
		BRK }
	expr/push-until-keyword ?{ BRK }
	expr/realloc-keyword /<parse>
	token/<push-str>
	token/<parse>
	BRK

@if/<parse> ( -- )
	expr/<parse>
	;dict/ora str/<print-ws>
	;&a str/<print>
	/<print-nest>
	chr/<ws>
	;&b str/<print>
	/<print-nest>
	chr/<ws> !token/<bind>

	&a "?/if- 00
	&b "!{ 20 "&if- 00

@if/<push-nesting> ( -- )
	[ LIT &nest ff ] INC ,&nest STR
	JMP2r

@if/<print-nest> ( -- v )
	,&nest LDR !chr/<lc>

@if/<print-case> ( -- )
	,&case LDR chr/<lc> !chr/<ws>

@if/case-push ( -- )
	[ LIT &case $1 ] INC ,&case STR
	JMP2r

@elseif/<bind> ( -- )
	;&on-console <bind> !expr/<reset>

@elseif/on-console ( -> )
	.Console/read DEI
	( end ) chr/not-sc ?{ POP /<parse>
		BRK }
	expr/push-until-keyword ?{ BRK }
	expr/realloc-keyword /<parse>
	token/<push-str>
	token/<parse>
	BRK

@elseif/<parse> ( -- )
	expr/<parse>
	;dict/ora str/<print-ws>
	;if/a str/<print>
	if/<print-nest>
	if/<print-case>
	;if/b str/<print>
	if/<print-nest>
	if/<print-case>
	token/<bind> !if/case-push

@then/<bind> ( -- )
	;&on-console !<bind>

@then/on-console ( -> )
	.Console/read DEI
	( end ) chr/not-sc ?{ POP /<parse>
		BRK }
	expr/push-until-keyword ?{ BRK }
	expr/get-last-word ;dict/goto str/cmp ?{ expr/realloc-keyword /<parse>
		token/<push-str>
		token/<parse> }
	BRK

@then/<parse> ( -- )
	expr/<parse>
	token/<bind>
	LIT2 "! 18 DEO
	LIT2 "/ 18 DEO
	;dict/if-prefix str/<print>
	if/<print-nest>
	;dict/close str/<print-ws>
	LIT2 "} 18 DEO !chr/<lb>

@else/<bind> ( -- )
	;&on-console !<bind>

@else/on-console ( -> )
	.Console/read DEI
	( end ) chr/not-sc ?{ POP /<parse>
		BRK }
	expr/push-until-keyword ?{ BRK }
	expr/realloc-keyword /<parse>
	token/<push-str>
	token/<parse>
	BRK

@else/<parse> ( -- )
	expr/<parse> !token/<bind>

@close/<bind> ( -- )
	chr/<lb>
	LIT2 "& 18 DEO
	;dict/if-prefix str/<print>
	if/<print-nest>
	;dict/close str/<print-ws> !token/<bind>

(
@|BlockExpr )

@expr/<bind-token> ( token* -- )
	/<reset>
	stack/<reset>
	dict/<reset>
	;&on-console .Console/vector DEO2
	/<push-str>
	#20 !/<push>

@expr/on-console ( -> )
	.Console/read DEI
	( end ) chr/not-sc ?{ POP /<parse>
		BRK }
	/<push>
	BRK

@expr/<parse> ( -- )
	;&buf
	&>wp
		str/walk-ws LDAk ?{ POP2 !token/<bind> }
		/walk-fragment !/>wp

@expr/walk-fragment ( str* -- str* )
	str/walk-ws LDAk ?{ JMP2r }
	( | Main )
	LDAk chr/is-label ?/walk-label
	LDAk chr/is-operand ?/walk-operator
	( | Special )
	LDAk LIT "{ NEQ ?{
		INC2 ;dict/backarrow stack/<push>
		;&nil !stack/<push> }
	LDAk LIT "} NEQ ?{ INC2 stack/pop !/<parse-postfix> }
	LDAk LIT "( NEQ ?{ INC2 ;&nil !stack/<push> }
	LDAk LIT ") NEQ ?{
		INC2 stack/pop /<parse-postfix>
		stack/pop !/<parse-postfix> }
	JMP2r

@expr/walk-label ( str* -- str* )
	/walk-label-core
	( | Post label )
	stack/depth ?{ JMP2r }
	stack/pop !/<parse-postfix>

@expr/walk-label-core ( str* -- str* )
	str/walk-ws LDAk ?{ JMP2r }
	token/<reset>
	token/push-label
	( | handlers )
	DUP2 ;dict/goto str/cmp ?/<parse-goto>
	DUP2 str/is-dec ?/<parse-value-dec>
	DUP2 str/is-hex ?/<parse-value-hex>
	LDAk LIT "# NEQ ?{ INC2 !prefab-refrel/<emit> }
	LDAk LIT "@ NEQ ?{ INC2 !prefab-refabs/<emit> }
	( | function )
	OVR2 LDA LIT "( NEQ ?{ dict/alloc stack/<push>
		;&nil !stack/<push> }
	prefab-refrel/<emit>
	stack/is-allocator ?{ ;dict/lda2 !str/<print-ws> }
	JMP2r

@expr/<parse-goto> ( str* token* -- str* )
	( pop goto ) POP2
	( walk to label ) str/walk-ws
	( write jump ) token/<reset>
	token/push-label !prefab-jump/<emit>

@expr/walk-operator ( str* -- str* )
	str/walk-ws LDAk ?{ JMP2r }
	LDAk LIT ", NEQ ?{ INC2 JMP2r }
	token/<reset>
	token/push-operand dict/alloc !stack/<push>

@expr/<parse-value-dec> ( str* -- )
	str/dec !prefab-lithex/<emit>

@expr/<parse-value-hex> ( str* -- )
	INC2 INC2 str/hex !prefab-lithex/<emit>

@expr/<parse-postfix> ( str* -- )
	LDAk ?{ POP2 JMP2r }
	LDA2k LIT2 "-> NEQ2 ?{ POP2 ;dict/sta2 !str/<print-ws> }
	LDA2k LIT2 "<- NEQ2 ?{ POP2 ;dict/lda2 !str/<print-ws> }
	LDA2k LIT2 "=> NEQ2 ?{ POP2 ;dict/deo2 !str/<print-ws> }
	LDA2k LIT2 "<> NEQ2 ?{ POP2 ;dict/jsr2 !str/<print-ws> }
	LDAk operators/find INC2k ORA ?{
		POP2
		( call ) ;dict/fn-prefix str/<print> !str/<print-ws> }
	INC2 LDA2 NIP2 !str/<print-ws>

	&nil 00

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

@expr/<push-str> ( str* -- )
	&>w
		LDAk DUP ?{ POP POP2 JMP2r }
		chr/not-sc ?{ POP POP2 !/<parse> }
		/<push>
		INC2 !/>w

@expr/<push> ( c -- )
	#00 [ LIT2 &ptr =&buf ] INC2k ,&ptr STR2
	STA2
	JMP2r

@expr/push-until-keyword ( c -- reached )
	/<push>
	/get-last-word keywords/find INC2 ORA JMP2r

@expr/realloc-keyword ( -- dict* )
	/get-last-word STH2k dict/alloc
	( cap ) #0000 STH2r STA2
	JMP2r

@expr/get-last-word ( -- str* )
	;&buf ,&ptr LDR2
	&>l
		NEQ2k ?{ POP2 JMP2r }
		#0001 SUB2 LDAk #20 GTH ?/>l
	NIP2 INC2 JMP2r

(
@|Prefabs )

@prefab-sublab/<emit> ( str* -- )
	LIT2 "& 18 DEO !str/<print-ws>

@prefab-binding/<emit> ( str* -- )
	LIT2 ", 18 DEO
	prefab-sublab/<emit>
	;dict/str2 !str/<print-ws>

@prefab-jump/<emit> ( str* -- )
	;&a str/<print> !str/<print-ws>

	&a "!/ 00

@prefab-pad/<emit> ( length* -- )
	LIT2 "$ 18 DEO !u16/<print-ws>

@prefab-string/<emit> ( str* -- )
	INC2
	&>w
		LDAk LIT "" NEQ ?{ INC2 }
		LDAk ?{ POP2 #00 !u8/<print-ws> }
		LDAk LIT "\ EQU ?/<emit-escape>
		LDAk u8/<print-ws> &resume INC2 !/>w

@prefab-string/<emit-escape> ( str* -- str* )
	INC2 LDAk
	( | handlers )
	DUP LIT "0 NEQ ?{ #00 u8/<print-ws> }
	DUP LIT "n NEQ ?{ #0a u8/<print-ws> }
	DUP LIT "t NEQ ?{ #09 u8/<print-ws> }
	DUP LIT "s NEQ ?{ #20 u8/<print-ws> }
	POP !/resume

@prefab-refrel/<emit> ( str* -- )
	[ LIT2 "; 18 ] DEO
	[ LIT2 "& 18 ] DEO !str/<print-ws>

@prefab-refabs/<emit> ( str* -- )
	[ LIT2 "; 18 ] DEO
	;dict/fn-prefix str/<print> !str/<print-ws>

@prefab-lithex/<emit> ( u16* -- )
	LIT2 "# 18 DEO !u16/<print-ws>

(
@|Dict )

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

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

(
@|Stack )

@stack/depth ( -- depth )
	,&ptr LDR2 ;&buf SUB2 #01 SFT2 NIP JMP2r

@stack/<reset> ( -- )
	;&buf ,&ptr STR2
	JMP2r

@stack/<push> ( addr* -- )
	[ LIT2 &ptr =&buf ] INC2k INC2 ,&ptr STR2
	STA2
	JMP2r

@stack/pop ( -- addr* )
	,&ptr LDR2
	( | clamp )
	DUP2 ;&buf NEQ2 ?{ POP2 #ffff JMP2r }
	#0002 SUB2 DUP2 ,&ptr STR2
	LDA2 JMP2r

@stack/is-allocator ( -- t )
	,&ptr LDR2 #0002 SUB2 LDA2 LDA2 LIT2 "-> EQU2 JMP2r

(
@|Stdlib )

@chr/hex ( c -- val )
	( dec ) [ LIT "0 ] SUB DUP #09 GTH [ JMP JMP2r ]
	( hex ) #27 SUB DUP #0a SUB #05 GTH [ JMP JMP2r ]
	( nil ) POP #ff JMP2r

@chr/not-sc ( c -- c t )
	DUP LIT "; NEQ JMP2r

@chr/is-num ( c -- t )
	LIT "0 SUB #0a LTH JMP2r

@chr/is-operand ( c -- t )
	operators/find INC2 ORA JMP2r

@chr/is-lc ( c -- lowercase )
	LIT "A SUB #1a LTH JMP2r

@chr/is-uc ( c -- uppercase )
	LIT "a SUB #1a LTH JMP2r

@chr/is-label ( c -- t )
	DUP LIT "_ EQU ?/pt
	DUP LIT "# EQU ?/pt
	DUP LIT "@ EQU ?/pt
	DUP LIT ". EQU ?/pt
	( >> )

@chr/is-an ( c -- t )
	DUP /is-num ?/pt
	DUP /is-lc ?/pt
	DUP /is-uc ?/pt
	POP #00 JMP2r
	&pt POP #01 JMP2r

%chr/is-dec ( c -- t ) {
	LIT "0 SUB #0a LTH }

@chr/<lc> ( num -- )
	LIT "a ADD #18 DEO
	JMP2r

@chr/<lb> ( -- )
	#0a18 DEO
	JMP2r

@chr/<ws> ( -- )
	#2018 DEO
	JMP2r

@str/walk-ws ( str* -- str* )
	&>ww
		LDAk DUP ?{ POP JMP2r }
		#21 LTH ?{ JMP2r }
		INC2 !/>ww

@str/is-dec ( str* -- t )
	LDAk ?{ POP2 #00 JMP2r }
	LDAk [ LIT "- ] NEQ ?{
		INC2 LDAk chr/is-dec ?{ POP2 #00 JMP2r } }
	&>wid
		LDAk DUP ?{ POP POP2 #01 JMP2r }
		chr/is-dec ?{ POP2 #00 JMP2r }
		INC2 !/>wid

@str/is-hex ( str* -- t )
	LDA2 LIT2 "0x EQU2 JMP2r

@str/hex ( str* -- value* )
	[ LIT2r 0000 ]
	&>wh
		[ LITr 40 ] SFT2r LDAk chr/hex [ LITr 00 ] STH
		ADD2r INC2 LDAk ?/>wh
	POP2 STH2r JMP2r

@str/dec ( str* -- val* )
	[ LIT2r 0000 ] !{

	&>ldec
		[ LITr 00 ] STH
		MUL2r [ LITr 00 ] STH
		ADD2r INC2 }
	( str* . val* ) LDAk [ LIT "0 ] SUB #0a LTHk ?/>ldec
	POP2 POP2 STH2r JMP2r

@str/<print-until> ( str* c -- )
	STH
	&>wpu
		LDAk DUP ?{ POP POPr POP2 JMP2r }
		DUP STHkr NEQ ?{ POP POPr POP2 JMP2r }
		#18 DEO
		INC2 !/>wpu

@str/<print-ws> ( str* -- )
	/<print> !chr/<ws>

@str/<print> ( str* -- )
	LDAk DUP ?{ POP POP2 JMP2r }
	#18 DEO
	INC2 !/<print>

@str/<p> ( str* -- )
	LIT2 "[ 18 DEO
	/<print>
	LIT2 "] 18 DEO !chr/<lb>

@str/print-word ( str* -- end* )
	&>wpw
		LDAk DUP #20 GTH ?{ POP JMP2r }
		#18 DEO
		INC2 !/>wpw

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

@u16/<print> ( u16* -- )
	SWP u8/<print>
	( >> )

@u8/<print> ( byte -- )
	DUP #04 SFT /<print-nibble>
	( >> )
	&<print-nibble> ( byte -- )
	#0f AND DUP #09 GTH #27 MUL ADD
	( >> )
	&<print-digit> ( d -- )
	[ LIT "0 ] ADD #18 DEO
	JMP2r

@u8/<print-ws> ( byte -- )
	/<print> !chr/<ws>

@u16/<print-ws> ( byte -- )
	/<print> !chr/<ws>

(
@|LUTs )

@keywords/find ( token* -- ffff|addr* )
	STH2
	;&lutend ;&lut
	&>l
		LDA2k STH2kr str/cmp ?{
			#0004 ADD2 GTH2k ?/>l
		POP2 #ffff }
	NIP2 POP2r JMP2r

@keywords/lut [4
	=dict/function =function/<bind> =dict/end =end/<bind>
	=dict/lambda =lambda/<bind> =dict/vars =vars/<bind>
	=dict/comment =comment/<bind> =dict/goto =goto/<bind>
	=dict/if =if/<bind> =dict/then =then/<bind>
	=dict/elseif =elseif/<bind> =dict/else =else/<bind>
	=dict/close =close/<bind> &lutend ]

@operators/find ( c -- ffff|addr* )
	STH
	;&lutend ;&lut
	&>l
		LDAk STHkr EQU ?{
			#0003 ADD2 GTH2k ?/>l
		POP2 #ffff }
	NIP2 POPr JMP2r

@operators/lut [4
	"+ =dict/add2 "- =dict/sub2
	"* =dict/mul2 "/ =dict/div2
	"% =dict/mod2 "| =dict/ora2
	"& =dict/and2 "^ =dict/eor2
	"~ =dict/jsr2 "= =dict/equ2-s
	"! =dict/neq2-s "> =dict/gth2-s
	"< =dict/lth2-s ", =&nil
	&lutend ]
	&nil 00

(
@|Assets )

@dict/comment "comment 00
	&function "function 00
	&lambda "lambda 00
	&vars "vars 00
	&goto "goto 00
	&end "end 00
	&if "if 00
	&elseif "elseif 00
	&then "then 00
	&else "else 00
	&close "close 00
	&if-prefix "if- 00
	&fn-prefix "fn- 00
	&anon-jump "!{ 00
	&backarrow "<- 00
	&ora "ORA 00
	&jmp2r "JMP2r 00
	&deo2 "NIP 20 "DEO2 00
	&mod2 "DIV2k 20 "MUL2 20 "SUB2 00
	&equ2-s "EQU2 20 "#00 20 "SWP 00
	&neq2-s "NEQ2 20 "#00 20 "SWP 00
	&gth2-s "GTH2 20 "#00 20 "SWP 00
	&lth2-s "LTH2 20 "#00 20 "SWP 00 [6
	&str2 "STR2 00 &sta2 "STA2 00
	&lda2 "LDA2 00 &add2 "ADD2 00
	&sub2 "SUB2 00 &mul2 "MUL2 00
	&div2 "DIV2 00 &ora2 "ORA2 00
	&and2 "AND2 00 &eor2 "EOR2 00
	&jsr2 "JSR2 00 ]

@stack/buf $400

@dict/buf $1000

@expr/buf