( 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 ) "11 20 "Aug 20 "2026 0000

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

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

@token/on-console ( -> )
	.Console/read DEI
	( | handlers )
	DUP LIT "" NEQ ?{
		[ LIT2 00 _&string ] LDR EQU ,&string STR }
	[ LIT &string $1 ] ?{
		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>
		expr/<push-str>
		#20 !expr/<push> }
	NIP2 INC2 INC2 LDA2 JMP2

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

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

(
@|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 )

@function/<bind> ( -- )
	;&on-console <bind>
	;dict/anon-jump !str/<print-ws>

@function/on-console ( -> )
	.Console/read DEI
	( | handlers )
	DUP #20 GTH ?{
		POP ;expr/buf prefab-label/<emit>
		vars/<bind-bindings>
		BRK }
	chr/not-sc ?{
		POP ;expr/buf prefab-label/<emit>
		token/<bind>
		BRK }
	expr/<push>
	BRK

(
@|BlockVars )

@vars/<bind> ( -- )
	[ LIT2 01 _&bindings ] STR
	;&on-console !<bind>

@vars/<bind-bindings> ( -- )
	[ LIT2 00 _&bindings ] STR
	;&on-console !<bind>

@vars/on-console ( -> )
	.Console/read DEI
	( | handlers )
	chr/not-sc ?{
		POP ;expr/buf /<parse>
		LIT &bindings $1 ?{ /<emit-bindings> }
		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 token/push-string !/resume }
		DUP #20 GTH ?{ POP /<parse-token> !/resume }
		token/<push> &resume INC2 !/>w

@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 ?{
			LITr 00 STH2k STAr
			;token/buf DUP2 dict/alloc stack/<push>
			prefab-sublab/<emit>
			INC2 LDAk LIT "" NEQ ?{ prefab-string/emit POP2 !token/<reset> }
			str/dec prefab-pad/<emit> !token/<reset> }
		INC2 !/>wpt

@vars/<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
	#00 ;&else STA
	/<push> !expr/<reset>

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

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

@if/<inc-else> ( -- )
	[ LIT &else $1 ] INC ,&else STR
	JMP2r

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

@if/<print-nest> ( -- v )
	,&ptr LDR2 #0001 SUB2 LDA !chr/<lc>

@if/<push> ( -- )
	[ LIT &nest 00 ] INCk ,&nest STR
	[ LIT2 &ptr =&buf ] INC2k ,&ptr STR2
	STA
	JMP2r

@if/<pop> ( -- )
	,&ptr LDR2 #0001 SUB2 ,&ptr STR2
	JMP2r

@if/<emit-case> ( -- )
	;dict/ora str/<print-ws>
	;&a str/<print>
	/<print-nest>
	/<print-case>
	;&b str/<print>
	/<print-nest>
	/<print-case> !/<case-inc>

@if/<emit-jump> ( -- )
	;&c str/<print>
	/<print-nest>
	;dict/close str/<print-ws>
	LIT2 "} 18 DEO !chr/<lb>

@if/<emit-close-label> ( -- )
	chr/<lb>
	;&d str/<print>
	/<print-nest>
	/<pop>
	;dict/close !str/<print-ws>

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

@elseif/<bind> ( -- )
	;&on-console <bind>
	if/<inc-else> !if/<emit-jump>

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

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

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

@else/<bind> ( -- )
	if/<inc-else>
	if/<emit-jump>
	;&on-console !<bind>

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

@close/<bind> ( -- )
	;if/else LDA ?{ if/<emit-jump> }
	if/<emit-close-label> !token/<bind>

(
@|BlockExpr )

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

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

@expr/<parse> ( -- )
	;&buf
	&>wp
		str/walk-ws LDAk ?{ &end POP2 !token/<bind> }
		LDAk LIT "; EQU ?/end
		/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 /<pop-postfix> !/<pop-postfix> }
	LDAk LIT "( NEQ ?{ INC2 ;&nil !stack/<push> }
	LDAk LIT ") NEQ ?{ INC2 /<pop-postfix> !/<pop-postfix> }
	LDAk LIT "" EQU ?/walk-string
	( | Unknown )
	;dict/err-unknown-expr err/<print>
	DUP2 err/<print-lb>
	INC2 JMP2r

@expr/walk-label ( str* -- str* )
	/walk-label-core
	( | Post label )
	!/<pop-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-string ( str* -- str* )
	LIT2 "{ 18 DEO
	chr/<ws>
	prefab-string/emit LIT2 "} 18 DEO
	chr/<ws>
	INC2 ;dict/sth2r str/<print-ws> !/<pop-postfix>

@expr/walk-operator ( str* -- str* )
	str/walk-ws LDAk ?{ 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/<pop-postfix> ( -- )
	stack/pop LDAk ?{ POP2 JMP2r }
	LDA2k LIT2 "<< NEQ2 ?{ POP2 ;dict/sft2-l !str/<print-ws> }
	LDA2k LIT2 ">> NEQ2 ?{ POP2 ;dict/sft2-r !str/<print-ws> }
	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 !prefab-scope/<emit> }
	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 DUP LIT "" NEQ ?{ INC2 POP #00 }
		?{ #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-lithex/<emit> ( u16* -- )
	LIT2 "# 18 DEO !u16/<print-ws>

@prefab-label/<emit> ( str* -- )
	LIT2 "@ 18 DEO !prefab-scope/<emit>

@prefab-refabs/<emit> ( str* -- )
	[ LIT2 "; 18 ] DEO
	( >> )

@prefab-scope/<emit> ( str* -- )
	LIT2 "./ str/swap-chars ;dict/fn-prefix str/<print> !str/<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/swap-chars ( str* a b -- str* )
	,&b STR
	,&a STR
	DUP2
	&>wsc
		LDAk DUP ?{ POP POP2 JMP2r }
		LIT &a $1 NEQ ?{
			LITr &b $1 STH2k STAr }
		INC2 !/>wsc

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

@err/<print-lb> ( str* -- )
	/<print>
	#0a19 DEO
	JMP2r

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

@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/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
	&vars "vars 00
	&goto "goto 00
	&end "end 00
	&if "if 00
	&elseif "elseif 00
	&then "then 00
	&else "else 00
	&close "close 00
	&err-unknown-expr "Unknown 20 "expression: 20 00
	&fn-prefix "fn- 00
	&anon-jump "!{ 00
	&backarrow "<- 00
	&ora "ORA 00
	&sft2-l "NIP 20 "#40 20 "SFT 20 "SFT2 00
	&sft2-r "NIP 20 "SFT2 00
	&jmp2r "JMP2r 00
	&sth2r "STH2r 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 ]

@if/buf $100

@stack/buf $400

@dict/buf $1000

@expr/buf