A2osX/SYS/KERNEL.S.PS.txt

NEW
  AUTO 3,1
*/--------------------------------------
* # ExecL
* ## C / CSH
* `short int execl(const char *cmdline, short int flags);`
* ## ASM
* `>PUSHW cmdline`
* `>PUSHB flags`
* `>SYSCALL execl`
* ## RETURN VALUE
* A = Child PSID
*\--------------------------------------
K.ExecL			clc
				.HS B0					BCS
*/--------------------------------------
* # ExecV
* ## C / CSH
* `short int execv(const char* argv[], short int flags);`
* ## ASM
* `>PUSHW argv`
* `>PUSHB flags`
* `>SYSCALL execv`
* ## RETURN VALUE
* A = Child PSID
*\--------------------------------------
K.ExecV			sec
				php
				
				>PULLB PS.Flags

				>LDYAI 256
				jsr K.GetMem
				bcs .99

				stx .90+1
				>STYA PS.ArgV

				plp
				bcc .2

				>PULLW ZPPtr1			pull arg[] from stack

				ldy #$FF				copy to target buffer
				
.1				iny
				lda (ZPPtr1),y
				sta (PS.ArgV),y
				bne .1
				
				iny
				lda (ZPPtr1),y
				sta (PS.ArgV),y
				bne .1

				bra .8

.2				>PUSHW PS.ArgV
				jsr K.Arg2ArgV			cmdline on stack, push target buffer
				bcs .9

.8				jsr PS.Exec

.9				php
				pha
.90				lda #$ff				SELF MODIFIED
				jsr K.FreeMem
				pla
				plp
				rts
				
.99				plp
				sec
				>RET 2
*--------------------------------------
PS.Exec			jsr PS.CreateChild		A=PID,Child S.PS at PS.NewPSPtr,PS.Load.hMem
				bcs .9

				sta .8+1

				stz K.IOBuf				If !=0 after PS.Load, it's a script

				jsr PS.Load
				bcs .90

				jsr PS.AddArgV			K.IOBuf= /.../SHELL, K.Buf256=/.../SCRIPT
				bcc .8					or K.IOBuf= 0, K.Buf256=/.../BINFILE

.90				pha						save error code
				>PUSHB .8+1				PID
				>PUSHBI 2				SIG
				jsr K.Kill
				pla						get back error code
				sec
				rts

.8				lda #$ff				SELF MODIFIED
*				clc
.9
				rts
*/--------------------------------------
* # Fork
* ## C
* `short int fork();`
* ## ASM
* `>SYSCALL fork`
* ## RETURN VALUE
* A = Child PSID
*\--------------------------------------
K.Fork			jsr PS.CreateChild		A=PID,Child S.PS at PS.NewPSPtr,PS.Load.hMem
				bcs .99

				sta .8+1

				ldy #S.PS.S
				lda #S.PS.S.RUN
				sta (PS.NewPSPtr),y

				ldy #S.PS.hCS
				lda (ZPPtr1),y
				sta (PS.NewPSPtr),y
				jsr MEM.GetMemByID
				jsr Mem.IncRefCnt

				ldy #S.MEM.PTR+1
				lda (ZPMemMgrSPtr),y
				pha
				dey
				lda (ZPMemMgrSPtr),y
				ldy #S.PS.ZP.CODE+1
				sta (PS.NewPSPtr),y
				dey
				pla
				sta (PS.NewPSPtr),y

				ldy #S.PS.hDS
				lda (ZPPtr1),y
				jsr MEM.Dup
.99				bcs .9

				ldy #S.PS.hDS
				sta (PS.NewPSPtr),y
				jsr K.GetMemPtr
				phy
				ldy #S.PS.ZP.DATA+1
				sta (PS.NewPSPtr),y
				dey
				pla
				sta (PS.NewPSPtr),y

				ldy #S.PS.hSS
				lda (ZPPtr1),y
				jsr MEM.Dup
				bcs .9

				ldy #S.PS.hSS
				sta (PS.NewPSPtr),y
				jsr K.GetMemPtr
				phy
				ldy #S.PS.ZP.STACK+1
				sta (PS.NewPSPtr),y
				dey
				pla
				sta (PS.NewPSPtr),y

				ldy #S.PS.hARGV
				lda (ZPPtr1),y
				jsr MEM.Dup
				bcs .9

				ldy #S.PS.hARGV
				sta (PS.NewPSPtr),y

				dey						S.PS.ARGC

				lda (ZPPtr1),y
				sta (PS.NewPSPtr),y

				ldy #S.PS.A
				lda #0
				sta (PS.NewPSPtr),y		Forked PS will get A=PSID=0
				iny

.1				lda (ZPPtr1),y
				sta (PS.NewPSPtr),y
				iny
				cpy #S.PS.hSession
				bne .1

				ldy #S.PS.ZP.LOCAL

.2				lda (ZPPtr1),y
				sta (PS.NewPSPtr),y
				iny
				cpy #S.PS
				bne .2

.8				lda #$ff				SELF MODIFIED
*				clc
.9				rts
*--------------------------------------
* PS.CreateChild
*  in :
*  out :
*   A = PSID
*--------------------------------------
PS.CreateChild	ldx #0
				bra .2					Skip PS0

.1				lda PSs.PID,x
				beq .4					Found an empty slot

.2				inx
				cpx CORE.PSCount
				bne .1

				cpx #K.PS.MAX
				bne .3

				lda #E.OOH
				sec
				rts

.99				plx
				rts

.3				inc CORE.PSCount

.4				inc CORE.LastPSID		Get a PSID not already running
				beq .4					not = 0

				lda CORE.LastPSID
				jsr CORE.GetPS			Y=PS Index, X,A unmodified
				bcc .4					running...loop

				lda CORE.LastPSID
				sta PSs.PID,x
				phx						save PS Index
				>LDYAI S.PS
				jsr K.GetMem0			Blank Everything in this S.PS
				bcs .99

				>STYA PS.NewPSPtr
				txa
				plx
				sta PSs.hPS,x
				jsr Mem.SetOwner		Set Ownership

				lda PS.Flags
				and #S.PS.F.CLOSEONX
				sta (PS.NewPSPtr)

				lda CORE.LastPSID
				ldy #S.PS.PID
				sta (PS.NewPSPtr),y

				lda #S.PS.F.NOHUP
				bit PS.Flags
				beq .5

				lda PSs.hPS		Select PS0
				jsr K.GetMemPtr
				bra .6

.5				>LDYA pPs

.6				>STYA ZPPtr1			= Parent process
				ldy #S.PS.PID
				lda (ZPPtr1),y
				dey						#S.PS.PPID
				sta (PS.NewPSPtr),y

				ldy #S.PS.hCWD			copy hPREFIX...
				lda (ZPPtr1),y
				jsr K.GetMemPtr

				jsr K.StrDup
				bcs .9

				jsr Mem.SetOwner		Set Ownership

				txa
				ldy #S.PS.hCWD
				sta (PS.NewPSPtr),y

				ldy #S.PS.hENV
				lda (ZPPtr1),y

				jsr MEM.DupX			dup hENV from parent PS
				bcs .9

				ldy #S.PS.hENV
				sta (PS.NewPSPtr),y

				sta IO.SETWRITEAUX
				jsr Mem.SetOwner		Set Ownership
				sta IO.CLRWRITEAUX

				ldy #S.PS.hStdIn

.7				lda (ZPPtr1),y
				sta (PS.NewPSPtr),y
				iny
				cpy #S.PS.hStdErr+1
				bne .7

				ldy #S.PS.hSession
				lda (ZPPtr1),y
				sta (PS.NewPSPtr),y

*				tax
*				lda USRs.hSID-1,x
*				jsr MEM.GetMemByID
*				jsr MEM.IncRefCnt

				lda #S.PS.F.HOLD
				bit PS.Flags
				beq .8

				ora (ZPPtr1)
				sta (ZPPtr1)			HOLD parent PS

				lda CORE.LastPSID
				ldy #S.PS.CPID
				sta (ZPPtr1),y
.8
*				lda #S.PS.S.INIT
*				ldy #S.PS.S
*				sta (PS.NewPSPtr),y		Make this PS Init....

				lda CORE.LastPSID		Exit with A=PSID
				clc
				rts

.9				pha
				>PUSHB CORE.LastPSID
				>PUSHBI 2				SIG
				jsr K.Kill
				pla
				sec
				rts
*--------------------------------------
PS.Load			ldy #$ff

.1				iny
				lda (PS.ArgV),y
				beq .2					no / in path...try search in PATH

				cmp #'/'
				bne .1

				>LDYA PS.ArgV			found /, some path specified, no search
				jsr PS.STAT.YA
				bcc .6					REAL path in K.Buf256
				
				rts						file not found

.2				>LDYA PS.ArgV

				jsr PS.Find.PATH		Get fullpath in K.Buf256
				bcc .6

				>LDYA PS.ArgV
				jsr PS.Find.CWD
				bcs PS.RTS

.6				lda K.S.STAT+S.STAT.P.TYPE
				cmp #S.FI.T.BIN
				beq .8

				cmp #S.FI.T.TXT
				beq PS.Load.SCRIPT

				cmp #S.FI.T.SYS
				bne PS.Load.IPATH

				jsr PS.Buf2IO			.SYSTEM -> IOBUF

*				ldy #$ff

*.8				iny
*				inx
*				lda PS.T,y
*				sta K.IOBuf-1,x
*				bne .8

				>LDYAI PS.SHUTDOWN
				jsr PS.Find.PATH
				bcs PS.RTS

.8				jmp PS.LoadBIN
*--------------------------------------
PS.Load.IPATH	lda #E.BADPATH
				.HS 2C
PS.Load.IBIN	lda #E.IBIN
				sec
PS.RTS			rts
*--------------------------------------
PS.Load.SCRIPT	jsr PS.Buf2IO

				jsr PS.LoadGetHeader
				bcs PS.RTS

				>PUSHWI PS.Load.ROOT
				>PUSHWI K.Buf256		K.Buf256 = "$ROOT"
				>SYSCALL2 GetEnv
				bcs PS.Load.IPATH

				ldx #$ff

.1				inx
				lda K.Buf256,x
				bne .1

				ldy #0

.3				lda K.IOBuf+128,y		Check HEADER= "#!/"
				cmp PS.Load.HEADER,y
				bne PS.Load.IBIN

				iny
				cpy #3
				bne .3

.4				iny
				inx
				lda K.IOBuf+128-1,y
				sta K.Buf256-1,x		K.Buf256 = "${ROOT}BIN/SHELL"
				beq .5

				eor #C.CR
				bne .4

				sta K.Buf256-1,x		K.Buf256 = "${ROOT}BIN/SHELL\0"

.5				jsr PS.STAT.256
				bcs PS.RTS

				lda K.S.STAT+S.STAT.P.TYPE
				cmp #S.FI.T.BIN
				bne PS.Load.IBIN
*--------------------------------------
PS.LoadBIN		jsr BIN.Load			K.Buf256= "${ROOT}BIN/SH\0", K.IOBuf=/.../SCRIPT
				bcs .9

				>STYA ZPPtr4			save PTR to Code Segment

				phy
				ldy #S.PS.ZP.CODE+1
				sta (PS.NewPSPtr),y		save pCode HI...
				dey
				pla
				sta (PS.NewPSPtr),y		save pCode LO...
				txa
				ldy #S.PS.hCS
				sta (PS.NewPSPtr),y		save CS hMem in S.PS

*				jsr MEM.GetMemByID
*				jsr Mem.SetOwner		Set Ownership

				ldy #H.BIN.F			Get Bin S.PS.F
				lda (ZPPtr4),y
				beq .1

				ldy #S.PS.F				update PS S.PS.F
				ora (PS.NewPSPtr),y
				sta (PS.NewPSPtr),y

.1				ldy #H.BIN.DS.SIZE+1
				lda (ZPPtr4),y			Load DS.SIZE HI
				tax
				dey
				ora (ZPPtr4),y
				beq .2					DS.SIZE=0...

				lda (ZPPtr4),y
				tay
				txa						Y,A = DS.SIZE
				ldx #S.MEM.F.INIT0+S.MEM.F.DATA
				jsr MEM.GetMem.YAX
				bcs .9

				phy
				ldy #S.PS.ZP.DATA+1
				sta (PS.NewPSPtr),y		save pData HI...
				dey
				pla
				sta (PS.NewPSPtr),y		save pData LO...

				txa
				ldy #S.PS.hDS
				sta (PS.NewPSPtr),y		save DS hMem in S.PS

				jsr Mem.SetOwner		Set Ownership

.2				ldy #H.BIN.SS.SIZE
				lda (ZPPtr4),y			Load SS.SIZE

				tay
				beq .3					SS.SIZE.LO=0, set as default $100

				lda #$ff				SS.SIZE.HI

.3				inc

				ldx #S.MEM.F.NOCROSS+S.MEM.F.STACK
				jsr MEM.GetMem.YAX
				bcs .9

				phy						save pStack base LO
				ldy #S.PS.ZP.STACK+1
				sta (PS.NewPSPtr),y		save pStack HI...

				ldy #S.PS.ZP.LOCAL+1
				sta (PS.NewPSPtr),y		save pLocal HI...

				pla						make pStack = Base...
				ldy #H.BIN.SS.SIZE		...plus Stack size
*				clc
				adc (ZPPtr4),y

				ldy #S.PS.ZP.STACK
				sta (PS.NewPSPtr),y

				txa
				ldy #S.PS.hSS
				sta (PS.NewPSPtr),y		save SS hMem in S.PS
				clc						Potentially CS from ADC (ZPPtr4),y
				jmp Mem.SetOwner		Set Ownership
.9				rts
*--------------------------------------
PS.LoadGetHeader
				>PUSHWI K.IOBuf
				>PUSHBI	O.RDONLY
				>PUSHBI S.FI.T.TXT
				>PUSHWZ					Aux type
				>SYSCALL2 fopen
				bcs .9

				>PUSHA					a = hFILE
				>PUSHWI K.IOBuf+128
				>PUSHWI 128
				
				>SYSCALL2 fread

				php
				pha
				lda IO.hFILE			set by fopen / fread
				>SYSCALL2 fclose
				pla
				plp

.9				rts
*--------------------------------------
PS.Load.ROOT	.AZ "ROOT"
PS.Load.HEADER	.AZ "#!/"
*--------------------------------------
* K.Buf256= /.../SHELL, K.IOBuf=/.../SCRIPT
* - or -
* K.Buf256=/.../BINFILE,K.IOBuf=0
* Buf256+IOBUF(?)+PS.ArgV[1,...] -> #S.PS.hARGV
*--------------------------------------
PS.AddArgV		ldy #$ff				In both cases, remove ARGV[0]

.60				iny
				lda (PS.ArgV),y
				bne .60

				tya
				sec
				adc PS.ArgV
				sta PS.ArgV
				bcc .70

				inc PS.ArgV+1			Skip old ARGV[0] = scriptename

.70				>LDYAI K.Buf256
				jsr K.strlen

				>STYA PS.ArgSize

				lda K.IOBuf				is there a /BIN/SHELL ?
				beq .10

				>LDYAI K.IOBuf
				jsr K.strlen
				jsr PS.AddYAp12ArgSize

.10				ldx #0					For now, 0 args...
				lda K.IOBuf
				beq .11					+1 for scriptpath

				inx

.11				>LDYA PS.ArgV
				>STYA ZPPtr1

.1				lda (ZPPtr1)
				beq .4

				inx

				ldy #0

.2				iny
				lda (ZPPtr1),y
				bne .2

*				lda #0
				jsr PS.AddYAp12ArgSize
				jsr SHARED.AddYp12P1
				bra .1

.4				txa
				ldy #S.PS.ARGC
				sta (PS.NewPSPtr),y

				lda PS.ArgSize
				clc
				adc #2					Add 2 for ending \0\0
				tay
				
				lda PS.ArgSize+1
				adc #0
				
				jsr K.GetMem
				bcs .9

				>STYA ZPPtr2			Target Buffer
				txa
				ldy #S.PS.hARGV
				sta (PS.NewPSPtr),y

				jsr Mem.SetOwner		Set Ownership

				>LDYAI K.Buf256
				jsr PS.AddYAToStrV
				lda K.IOBuf
				beq .6

				>LDYAI K.IOBuf
				jsr PS.AddYAToStrV

.6				>LDYA PS.ArgV
				>STYA ZPPtr1

.7				lda (ZPPtr1)
				sta (ZPPtr2)
				beq .8					Ending \0

				jsr PS.AddPtr1ToStrV
				bra .7

.8				clc
.9				rts
*--------------------------------------
PS.AddYAToStrV	>STYA ZPPtr1
PS.AddPtr1ToStrV
				ldy #$ff

.2				iny
				lda (ZPPtr1),y
				sta (ZPPtr2),y
				bne .2

				jsr SHARED.AddYp12P1
				jmp SHARED.AddYp12P2
*--------------------------------------
PS.AddYAp12ArgSize
				pha
				tya
				sec						+1 for \0
				adc PS.ArgSize
				sta PS.ArgSize
				pla
				adc PS.ArgSize+1
				sta PS.ArgSize+1
				rts
*/--------------------------------------
* # Kill
* ## C
* `int kill(short int pid, short int sig);`
* ## ASM
* `>PUSHB pid`
* `>PUSHB sig`
* `>SYSCALL kill`
* ## RETURN VALUE
*\--------------------------------------
K.Kill.PID		.BS 1
*--------------------------------------
K.Kill			>PULLB .10+1			SIG
				>PULLA					PID
				cmp #0
				beq .9					CS

				sta K.Kill.PID
				jsr CORE.GetPSByID
				bcs .99

				>STYA ZPPtr1
				
.10				lda #$ff				SELF MODIFIED
				cmp #2+1
				bcs .9

				asl
				tax
				jmp (.1,x)

.1				.DA K.Kill.0
				.DA K.Kill.1
				.DA K.Kill.2

.9				lda #E.SYN
*				sec
.99				rts
*--------------------------------------
K.Kill.1		lda (ZPPtr1)
				and #S.PS.F.SLEEP^$FF
				sta (ZPPtr1)

				ldy #S.PS.S
				lda #S.PS.S.QUIT
				sta (ZPPtr1),y

K.Kill.0		clc
				rts

K.Kill.2		ldy #S.PS.hSession
				lda (ZPPtr1),y
				tax
*				lda USRs.hSID-1,x
*				jsr K.FreeMem

				ldy #S.PS.hENV
				lda (ZPPtr1),y
				>SYSCALL2 FreeStkObj

				ldx #4

.11				ldy .10,x
				lda (ZPPtr1),y
				beq .12

				phx
				jsr K.FreeMem
				plx

.12				dex
				bpl .11

				lda (ZPPtr1)
				bit #S.PS.F.CLOSEONX
				beq .1

				ldy #S.PS.hStdOut
				lda (ZPPtr1),y
				>SYSCALL2 fclose

.1				lda K.Kill.PID

				ldx #0
.2				cmp PSs.PID,x
				beq .3

				inx
				cpx CORE.PSCount
				bne .2

				bra *

.3				stz PSs.PID,x
				lda PSs.hPS,x
				stz PSs.hPS,x
				jmp K.FreeMem

.10				.DA #S.PS.hSS,#S.PS.hDS,#S.PS.hCS
				.DA #S.PS.hARGV,#S.PS.hCWD
*/--------------------------------------
* # LoadTxtFile
* Load TXT a file in memory (with ending 0)
* ## C
* `int loadtxtfile ( const char * filename );`
* ## ASM
* `>LDYA filename`
* `>SYSCALL loadtxtfile`
* ## RETURN VALUE
*  Y,A = File Length (without ending 0)
*  X = hMem of Loaded File
*\--------------------------------------
K.LoadTxtFile	>PUSHYA
				>PUSHBI	O.RDONLY
				>PUSHBI S.FI.T.TXT
				>PUSHWZ					Aux type
				
K.LoadFile0		sec
				.HS 90					BCC
*/--------------------------------------
* # LoadFile
* Load a file in memory
* ## C
* `int loadfile ( const char * filename, short int flags, short int ftype, int auxtype );`
* ## ASM
* `>PUSHW filename`
* `>PUSHB flags`
* `>PUSHB ftype`
* `>PUSHW auxtype`
* `>SYSCALL loadfile`
* ## RETURN VALUE
*  Y,A = File Length
*  X = hMem of Loaded File
*\--------------------------------------
K.LoadFile		clc

				ror PS.bTXT

				>SYSCALL2 FOpen
				bcs .99

				sta PS.hFILE
				>PUSHA
				>PUSHWI K.S.Stat
				>SYSCALL2 FStat
				bcs .98

				lda K.S.Stat+S.STAT.SIZE+3
				ora K.S.Stat+S.STAT.SIZE+2
				bne .97

				>LDYA K.S.Stat+S.STAT.SIZE

				bit PS.bTXT		Add 1 to buffer size for ending 0
				bpl .1

				iny
				bne .1

				inc
				bne .1

.97				lda #E.FTB

.98				pha
				lda PS.hFILE
				>SYSCALL2 FClose
				pla
				sec
.99				rts
*--------------------------------------
.1				jsr K.GetMem
				bcs .96

				>STYA PS.MemPtr
				stx PS.hMem

				>PUSHB PS.hFILE
				>PUSHW PS.MemPtr
				>PUSHWI $ffff
				>SYSCALL2 fread
				bcs .96

				sty .7+1
				sta .8+1
				bit PS.bTXT
				bpl .5

				pha						set ending 0
				tya

*				clc

				adc PS.MemPtr
				sta .4+1
				pla
				adc PS.MemPtr+1
				sta .4+2
.4				stz $ffff				Self Modified

.5				jsr .98					FClose

.7				ldy #$ff				SELFMODIFIED
.8				lda #$ff				SELFMODIFIED
				ldx PS.hMem
				clc
				rts

.96				pha

				jsr .98					FClose

				lda PS.hMem
				jsr K.FreeMem
				pla
				sec
.9				rts
*/--------------------------------------
* # FileSearch
* Search a file in the provided PATH list
* And return, if found, the full path to it.
* ## C
* `int filesearch( char *filename, char *searchpath, char *fullpath, stat *filestat);`
* ## ASM
* `>PUSHW filename`
* `>PUSHW fullpath`
* `>PUSHW searchpath`
* `>PUSHW filestat`
* `>SYSCALL filesearch`
* ## RETURN VALUE
* CC : success
* DstBuf = FilePath
* DstStat = S.STAT
* CS : not found
*\--------------------------------------
K.FileSearch	>PULLW .4+1				DstStat
				>PULLW .2+1				DstBuf
				>PULLW PS.Find.2+1	path to search
				>PULLW PS.Find.4+1	filename to find

				stz PS.Find.98+1

				jsr PS.Find
				bcs .9

				ldx #$ff
.1				inx
				lda K.Buf256,x
.2				sta $ffff,x				Self Modified
				bne .1

				ldx #S.STAT-1
.3				lda K.S.STAT,x
.4				sta $ffff,x				Self Modified
				dex
				bpl .3

*				clc
.9				rts
*--------------------------------------
PS.Find.CWD		>STYA PS.Find.4+1	filename to find
				ldy #S.PS.hCWD
				lda (PS.NewPSPtr),y
				jsr K.GetMemPtr
				>STYA PS.Find.2+1

				stz PS.Find.98+1
				bra PS.Find
*--------------------------------------
PS.Find.LIB		ldx #0
				.HS 2C					BIT ABS
PS.Find.DRV		ldx #2
				.HS 2C					BIT ABS
PS.Find.PATH	ldx #4

				>STYA PS.Find.4+1		filename to find

				>PUSHW PS.VARS,x
				>PUSHWZ					allocate...
				>SYSCALL2 GetEnv		get value for Search Path
				bcs PS.Find.RTS

				>STYA PS.Find.2+1
				stx PS.Find.98+1

PS.Find			stz PS.Find.1+1

PS.Find.1		ldy #0					Self Modified Index in Search list string

				ldx #0

PS.Find.2		lda $ffff,y				SELF MODIFIED

				beq PS.Find.3			end of string, try it....

				iny
				cmp #':'
				beq PS.Find.3

				sta K.Buf256,x
				inx
				bra PS.Find.2

PS.Find.3		txa
				beq PS.Find.98		String is empty....nothing to try

				sty PS.Find.1+1		save current index

				ldy #0

PS.Find.4		lda $ffff,y				Self Modified, Append Filename...
				sta K.Buf256,x
				beq PS.Find.5

				iny
				inx
				bra PS.Find.4

PS.Find.5		jsr PS.STAT.256
				bcs PS.Find.1			Failed...retry next path...

				lda K.S.STAT+S.STAT.MODE+1
				cmp /S.STAT.MODE.DIR	Dir ?
				beq PS.Find.1

				jsr PS.Find.98			Discard Expanded hSrch list

				clc
PS.Find.RTS		rts

PS.Find.98		lda #$ff				SELF MODIFIED : Discard  Search list
				beq .1

				jsr K.FreeMem

.1				lda #MLI.E.FNOTFND
				sec
				rts
*--------------------------------------
PS.Buf2IO		ldx #$ff

.1				inx						Save Script name in IOBuf
				lda K.Buf256,x
				sta K.IOBuf,x
				bne .1

				rts
*--------------------------------------
PS.STAT.256		>LDYAI K.Buf256
				
PS.STAT.YA		>PUSHYA
				>PUSHWI K.S.STAT
				>SYSCALL2 Stat
				rts
*--------------------------------------
PS.SHUTDOWN		.AZ "shutdown"
PS.VARS			.DA .1
				.DA .2
				.DA .3
.1				.AZ "LIB"
.2				.AZ "DRV"
.3				.AZ "PATH"
*/--------------------------------------
* # GetMemStat
*  Y,A = Ptr to 24 bytes buffer
* ## RETURN VALUE
*  Buffer filled with memory stats
*\--------------------------------------
K.GetMemStat	>STYA ZPPtr1

				ldy #23
				ldx #7

.1				lda DevMgr.Stat,x
				sta (ZPPtr1),y
				dey
				dex
				bpl .1

				sta IO.SETREADAUX

				jsr .2

				sta IO.CLRREADAUX

.2				ldx #7

.3				lda Mem.Table,x
				sta (ZPPtr1),y
				dey
				dex
				bpl .3

				clc
				rts
*--------------------------------------
MAN
SAVE usr/src/sys/kernel.s.ps
LOAD usr/src/sys/kernel.s
ASM