mirror of
https://github.com/A2osX/A2osX.git
synced 2024-11-24 14:31:05 +00:00
1663 lines
27 KiB
Markdown
1663 lines
27 KiB
Markdown
*** Auto generated by docgen.cmd ***
|
|
|
|
## Copyright
|
|
Copyright 2015 - 2020, Remy Gibert and the A2osX contributors.
|
|
|
|
# Shift
|
|
|
|
## ASM
|
|
A = argument index.
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
Y,A = PTR To Arg[A]
|
|
CS : Out Of Bound
|
|
|
|
# ArgV
|
|
|
|
## ASM
|
|
A = argument index.
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
Y,A = PTR To Arg[A]
|
|
CS : Out Of Bound
|
|
|
|
# Arg2ArgV
|
|
Expand String and convert to StrV List
|
|
|
|
## C
|
|
short int arg2argv(char* args, char* argv[])
|
|
|
|
## ASM
|
|
`>PUSHW args`
|
|
`>PUSHW argv`
|
|
`>SYSCALL Arg2ArgV`
|
|
|
|
## RETURN VALUE
|
|
A = Arg count
|
|
|
|
# ArgVDup
|
|
|
|
## ASM
|
|
Y,A = Src StrV
|
|
|
|
## RETURN VALUE
|
|
X = hMem of new StrV
|
|
A = Str Count
|
|
|
|
# LoadDrv
|
|
|
|
## ASM
|
|
Y,A = PTR to "NAME.DRV [PARAM]" C-String
|
|
|
|
## RETURN VALUE
|
|
none
|
|
|
|
# InsDrv
|
|
|
|
## C
|
|
`void * insdrv (void * src, void * crvcsstart, void * drvcssize, void * drvend);`
|
|
|
|
## ASM
|
|
`>PUSHW DRV.END`
|
|
`>PUSHW DRV.CS.SIZE`
|
|
`>PUSHW DRV.CS.START`
|
|
`>LDYA L.SRC`
|
|
`>SYSCALL insdrv`
|
|
|
|
## RETURN VALUE
|
|
Y,A = Ptr to installed driver
|
|
|
|
# GetDevByName
|
|
Y,A = Ptr to device name (C-String)
|
|
|
|
## RETURN VALUE
|
|
CC = OK, CS = ERROR
|
|
Y,A = FD
|
|
X = hFD
|
|
|
|
# MkFD
|
|
|
|
## C
|
|
`short int mkfd(short int type, );`
|
|
|
|
## ASM
|
|
`>PUSHB DevID`
|
|
`>PUSHW S.DIB`
|
|
`>SYSCALL MkFD`
|
|
|
|
## RETURN VALUE
|
|
|
|
# MKDev
|
|
Create a hDEV
|
|
|
|
## C
|
|
`hDEV mkdev (S.FD *fd, const char *devname)`
|
|
|
|
## ASM
|
|
`>PUSHW fd`
|
|
`>PUSHW devname`
|
|
`>SYSCALL mkdev`
|
|
|
|
## RETURN VALUE
|
|
A = hDEV
|
|
|
|
# IOCTL
|
|
|
|
## C
|
|
`int ioctl(short int hFD, short int request, void *param);`
|
|
|
|
## ASM
|
|
`>PUSHB hDEV`
|
|
`>PUSHB request`
|
|
`>PUSHW param`
|
|
`>SYSCALL IOCTL`
|
|
|
|
## RETURN VALUE
|
|
Y,A = ...
|
|
|
|
# OpenDir
|
|
|
|
## C
|
|
`short int hDIR opendir (const char * dirpath);`
|
|
|
|
## ASM
|
|
`>LDYA dirpath`
|
|
`>SYSCALL opendir`
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
A = hDIR
|
|
CS : error
|
|
A = EC
|
|
|
|
# ReadDir
|
|
|
|
## C
|
|
`struct dirent *readdir (short int hDIR);`
|
|
|
|
## ASM
|
|
`lda hDIR`
|
|
`>SYSCALL readdir`
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
X = hDIRENT
|
|
Y,A = PTR to S.DIRENT
|
|
CS : error
|
|
A = EC
|
|
note : A = 0 means no more entry
|
|
|
|
# CloseDir
|
|
|
|
## C
|
|
`void closedir(hDIR);`
|
|
|
|
## ASM
|
|
`lda hDIR`
|
|
`>SYSCALL closedir`
|
|
|
|
## RETURN VALUE
|
|
none, always succeed.
|
|
|
|
# SetEnv
|
|
Change or add an environment variable
|
|
|
|
## C / CSH
|
|
`int setenv(const char *name, const char *value);`
|
|
|
|
## ASM
|
|
`>PUSHW name`
|
|
`>PUSHW value`
|
|
`>SYSCALL setenv`
|
|
|
|
## RETURN VALUE
|
|
|
|
# GetEnv
|
|
searches the environment list to find the environment variable name,
|
|
and returns a pointer to the corresponding value string.
|
|
|
|
## C / CSH
|
|
`char *getenv(const char *name, char *value);`
|
|
|
|
## ASM
|
|
`>PUSHW name`
|
|
`>PUSHW value`
|
|
`>SYSCALL getenv`
|
|
|
|
## RETURN VALUE
|
|
CC : Y,A = PTR to VALUE (C-String)
|
|
CS : not found
|
|
|
|
# PutEnv
|
|
Change or add an environment variable, string is 'NAME=VALUE'
|
|
|
|
## C / CSH
|
|
`int putenv(char *string);`
|
|
|
|
## ASM
|
|
`>PUSHW string`
|
|
`>SYSCALL putenv`
|
|
|
|
## RETURN VALUE
|
|
|
|
# UnsetEnv
|
|
Remove an environment variable
|
|
|
|
## C / CSH
|
|
`int unsetenv(const char *name);`
|
|
|
|
## ASM
|
|
`>PUSHW name`
|
|
`>SYSCALL unsetenv`
|
|
|
|
## RETURN VALUE
|
|
|
|
# Add32,Sub32,Mul32,IMul32,Div32,IDiv32,Mod32,IMod32,Cmp32,ICmp32
|
|
Return X+Y, X-Y, X*Y, X/Y, X mod Y....
|
|
|
|
## ASM
|
|
`>PUSHL X (long)`
|
|
`>PUSHL Y (long)`
|
|
`>FPU add32`
|
|
`...`
|
|
|
|
## RETURN VALUE
|
|
On stack (long)
|
|
|
|
# FAdd,FSub,FMul,FDiv,FPwr
|
|
Return X*Y, X/Y, X+Y, X-Y
|
|
|
|
## C
|
|
`float pwr ( float x, float y);`
|
|
|
|
## ASM
|
|
`>PUSHF X (float)`
|
|
`>PUSHF Y (float)`
|
|
`>FPU fmul`
|
|
`>FPU fdiv`
|
|
`>FPU fmod` TODO
|
|
`>FPU fadd`
|
|
`>FPU fsub`
|
|
`>FPU fpwr`
|
|
|
|
## RETURN VALUE
|
|
On stack (float)
|
|
|
|
# Log,Sqr,Exp,Cos,Sin,Tan,ATan
|
|
Return Log(x), Sqr(x), E^X, Cos(x), Sin(X), Tan(x), ATan(x)
|
|
|
|
## C
|
|
`float log ( float x);`
|
|
`float sqr ( float x);`
|
|
`float exp ( float x);`
|
|
`float cos ( float x);`
|
|
`float sin ( float x);`
|
|
`float tan ( float x);`
|
|
`float atan ( float x);`
|
|
|
|
## ASM
|
|
`>PUSHF x (Float)`
|
|
`>FPU log`
|
|
|
|
## RETURN VALUE
|
|
On stack (Float)
|
|
|
|
# float
|
|
Return 'floated' long
|
|
|
|
## C
|
|
`float f = (float)l;
|
|
|
|
## ASM
|
|
`>PUSHL l` (long)
|
|
`>FPU float`
|
|
|
|
## RETURN VALUE
|
|
On stack (float)
|
|
|
|
# lrintf
|
|
Return float rounded into a long
|
|
|
|
## C
|
|
`long int lrintf (float x);`
|
|
|
|
## ASM
|
|
`>PUSHF x`
|
|
`>FPU lrintf`
|
|
|
|
## RETURN VALUE
|
|
On stack (long)
|
|
|
|
## MD5
|
|
Return MD5 Hash for input String
|
|
|
|
# C
|
|
`void md5 (const char* str, char* digest);`
|
|
|
|
# ASM
|
|
`>PUSHW str`
|
|
`>PUSHW digest`
|
|
`>SYSCALL md5`
|
|
|
|
## RETURN VALUE
|
|
CC
|
|
|
|
## MD5Init
|
|
Initialize a MD5 computation
|
|
|
|
# C
|
|
`short int md5init();`
|
|
|
|
# ASM
|
|
`>SYSCALL MD5Init`
|
|
|
|
## RETURN VALUE
|
|
A = hMem To S.MD5
|
|
|
|
## MD5Update
|
|
Add Data to MD5 computation
|
|
|
|
# C
|
|
`void md5update (short int md5, char* data, int len);`
|
|
|
|
# ASM
|
|
`>PUSHB md5`
|
|
`>PUSHW data`
|
|
`>PUSHW len`
|
|
`>SYSCALL MD5Update`
|
|
|
|
## RETURN VALUE
|
|
|
|
## MD5Finalize
|
|
|
|
# C
|
|
`void md5finalize (short int md5, char* digest);`
|
|
|
|
# ASM
|
|
`>PUSHB md5`
|
|
`>PUSHW digest`
|
|
`>SYSCALL MD5Finalize`
|
|
|
|
## RETURN VALUE
|
|
|
|
# Realloc
|
|
|
|
## C
|
|
`void *realloc(short int hMem, int size);`
|
|
|
|
## ASM
|
|
`>PUSHB hMem`
|
|
`>PUSHW size`
|
|
`>SYSCALL realloc`
|
|
|
|
## RETURN VALUE
|
|
YA = ptr
|
|
X = hMem
|
|
|
|
# GetMem
|
|
Y,A = Size Requested
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
YA = PTR to Mem (Uninitialised)
|
|
* X = hMem
|
|
CS :
|
|
A = EC
|
|
|
|
# Free
|
|
Y,A = Ptr To Free
|
|
|
|
## RETURN VALUE
|
|
none.
|
|
(X unmodified)
|
|
|
|
# FreeMem
|
|
A = hMem To Free
|
|
|
|
## RETURN VALUE
|
|
none.
|
|
(X unmodified)
|
|
|
|
# GetMemPtr
|
|
A = hMem
|
|
|
|
## RETURN VALUE
|
|
Y,A = PTR to MemBlock
|
|
(X unmodified)
|
|
|
|
# NewStkObj
|
|
Y,A = Size Requested
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
YA = PTR to Mem (Uninitialised)
|
|
* X = hMem
|
|
CS :
|
|
A = EC
|
|
|
|
# GetStkObjPtr
|
|
|
|
## ASM
|
|
`lda hStkObj`
|
|
`>SYSCALL GetStkObjPtr`
|
|
|
|
## RETURN VALUE
|
|
|
|
# FreeStkObj
|
|
A = hMem To Free (AUX Memory)
|
|
|
|
## RETURN VALUE
|
|
none.
|
|
(X,Y unmodified)
|
|
|
|
# Online
|
|
Get ProDOS Volume Info
|
|
|
|
## C
|
|
`int online(short int volid, void *buf);`
|
|
|
|
## ASM
|
|
`>PUSHB volid`
|
|
`>PUSHW buf`
|
|
`>SYSCALL Online`
|
|
|
|
## RETURN VALUE
|
|
|
|
# ChTyp
|
|
Change Type of a ProDOS File
|
|
|
|
## C
|
|
`int chtyp(const char *filepath, short int filetype);`
|
|
|
|
## ASM
|
|
`>PUSHW filepath`
|
|
`>PUSHB filetype`
|
|
`>SYSCALL ChTyp`
|
|
|
|
## RETURN VALUE
|
|
|
|
# ChAux
|
|
Change AuxType of a ProDOS File
|
|
|
|
## C
|
|
`int chaux(const char *filepath, int auxtype);`
|
|
|
|
## ASM
|
|
`>PUSHW filepath`
|
|
`>PUSHW auxtype`
|
|
`>SYSCALL ChAux`
|
|
|
|
## RETURN VALUE
|
|
|
|
# SetAttr
|
|
Change Attributes of a ProDOS File
|
|
|
|
## C
|
|
`int setattr(const char *filepath, short int attributes);`
|
|
|
|
## ASM
|
|
`>PUSHW filepath`
|
|
`>PUSHB attributes`
|
|
`>SYSCALL setattr`
|
|
|
|
## RETURN VALUE
|
|
|
|
# ExecL
|
|
|
|
## C / CSH
|
|
`short int execl(const char *cmdline, short int flags);`
|
|
|
|
## ASM
|
|
`>PUSHW cmdline`
|
|
`>PUSHB flags`
|
|
`>SYSCALL execl`
|
|
|
|
## RETURN VALUE
|
|
A = Child PSID
|
|
|
|
# ExecV
|
|
|
|
## C / CSH
|
|
`short int execv(const char* argv[], short int flags);`
|
|
|
|
## ASM
|
|
`>PUSHW argv`
|
|
`>PUSHB flags`
|
|
`>SYSCALL execv`
|
|
|
|
## RETURN VALUE
|
|
A = Child PSID
|
|
|
|
# Fork
|
|
|
|
## C
|
|
`short int fork();`
|
|
|
|
## ASM
|
|
`>SYSCALL fork`
|
|
|
|
## RETURN VALUE
|
|
A = Child PSID
|
|
|
|
# Kill
|
|
|
|
## C
|
|
`int kill(short int pid, short int sig);`
|
|
|
|
## ASM
|
|
`>PUSHB pid`
|
|
`>PUSHB sig`
|
|
`>SYSCALL kill`
|
|
|
|
## RETURN VALUE
|
|
|
|
# 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
|
|
|
|
# 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
|
|
|
|
# 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
|
|
|
|
# GetMemStat
|
|
Y,A = Ptr to 24 bytes buffer
|
|
|
|
## RETURN VALUE
|
|
Buffer filled with memory stats
|
|
|
|
# GetPWUID
|
|
|
|
## C
|
|
`int getpwuid(short int uid, S.PW *passwd);`
|
|
|
|
## ASM
|
|
`PUSHB uid`
|
|
`>PUSHW passwd`
|
|
`>SYSCALL getpwuid`
|
|
|
|
## RETURN VALUE
|
|
|
|
# GetGRGID
|
|
|
|
## C
|
|
`int getgrgid(short int gid, S.GRP *group);`
|
|
|
|
## ASM
|
|
`>PUSHB gid`
|
|
`>PUSHW group`
|
|
`>SYSCALL getpwname`
|
|
|
|
## RETURN VALUE
|
|
|
|
# CloseSession
|
|
|
|
## C
|
|
`int closesession(short int hSID);`
|
|
|
|
## ASM
|
|
`>PUSHB hSID`
|
|
`>SYSCALL CloseSession`
|
|
|
|
## RETURN VALUE
|
|
|
|
# OpenSession
|
|
|
|
## C
|
|
`short int hSID opensession(const char *name, const char *passwd);`
|
|
|
|
## ASM
|
|
`>PUSHW name`
|
|
`>PUSHW passwd`
|
|
`>SYSCALL OpenSession`
|
|
|
|
## RETURN VALUE
|
|
|
|
# GetPWName
|
|
|
|
## C
|
|
`int getpwname(const char* name, S.PW *passwd);`
|
|
|
|
## ASM
|
|
`>PUSHW name`
|
|
`>PUSHW passwd`
|
|
`>SYSCALL getpwname`
|
|
|
|
## RETURN VALUE
|
|
|
|
# GetGRName
|
|
|
|
## C
|
|
`int getgrgid(const char* name, S.GRP *group);`
|
|
|
|
## ASM
|
|
`>PUSHW name`
|
|
`>PUSHW group`
|
|
`>SYSCALL getpwname`
|
|
|
|
## RETURN VALUE
|
|
|
|
# PutPW
|
|
|
|
## C
|
|
`int putpw(S.PW* passwd);`
|
|
|
|
## ASM
|
|
`>PUSHW passwd`
|
|
`>SYSCALL putpw`
|
|
|
|
## RETURN VALUE
|
|
|
|
# PutGR
|
|
|
|
## C
|
|
`int putgr(S.GRP *group);`
|
|
|
|
## ASM
|
|
`>PUSHW group`
|
|
`>SYSCALL putgr`
|
|
|
|
## RETURN VALUE
|
|
|
|
# SListGetData
|
|
|
|
## ASM
|
|
`>PUSHB hSList`
|
|
`>PUSHW KeyID`
|
|
`>PUSHW DataPtr` (0 if KERNEL should allocate a buffer)
|
|
`>PUSHW DataLen` (Data bytes to return, 0 if String mode)
|
|
`>PUSHW DataOfs` (Start offset in Data)
|
|
`>SYSCALL SListGetData`
|
|
|
|
## RETURN VALUE
|
|
Y,A = Byte Count
|
|
X = hMem (if DataPtr = 0)
|
|
|
|
# SListAddData
|
|
|
|
## ASM
|
|
`>PUSHB hSList`
|
|
`>PUSHW KeyID`
|
|
`>PUSHW DataPtr`
|
|
`>PUSHW DataLen` (Data bytes to add, 0 if String mode)
|
|
`>SYSCALL SListAddData`
|
|
|
|
## RETURN VALUE
|
|
|
|
# SListSetData
|
|
|
|
## ASM
|
|
`>PUSHB hSList`
|
|
`>PUSHW KeyID`
|
|
`>PUSHW DataPtr`
|
|
`>PUSHW DataLen` (Data bytes to set, 0 if String mode)
|
|
`>SYSCALL SListSetData`
|
|
|
|
## RETURN VALUE
|
|
|
|
# SListGetByID
|
|
|
|
## ASM
|
|
`>PUSHB hSList`
|
|
`>PUSHW KeyID`
|
|
`>PUSHW KeyPtr`
|
|
`>SYSCALL SListGetByID`
|
|
|
|
## RETURN VALUE
|
|
Y,A = Next KeyID
|
|
|
|
# SListNewKey
|
|
|
|
## ASM
|
|
`>PUSHB hSList`
|
|
`>PUSHW KeyPtr`
|
|
`>PUSHW ScopeID`
|
|
`>SYSCALL SListNewKey`
|
|
|
|
## RETURN VALUE
|
|
Y,A = KeyID
|
|
X = KeyLen
|
|
|
|
# SListLookup
|
|
|
|
## ASM
|
|
`>PUSHB hSList`
|
|
`>PUSHW KeyPtr`
|
|
`>PUSHW ScopeID`
|
|
`>SYSCALL SListLookup`
|
|
|
|
## RETURN VALUE
|
|
Y,A = KeyID
|
|
X = Key Length
|
|
|
|
# SListFree
|
|
|
|
## ASM
|
|
`lda hSList`
|
|
`>SYSCALL SListFree`
|
|
|
|
## RETURN VALUE
|
|
|
|
# SListNew
|
|
|
|
## ASM
|
|
`lda Opt`
|
|
`>SYSCALL SListNew`
|
|
|
|
## RETURN VALUE
|
|
A=hSList
|
|
|
|
# ChMod
|
|
change permissions of a file
|
|
|
|
## C
|
|
`int chmod(const char *pathname, int mode);`
|
|
|
|
## ASM
|
|
`>PUSHW pathname`
|
|
`>PUSHW mode`
|
|
`>SYSCALL chmod`
|
|
|
|
## RETURN VALUE
|
|
|
|
# FStat
|
|
Return information about a hFILE
|
|
|
|
## C
|
|
`int fstat(short int hFILE, struct stat *statbuf);`
|
|
|
|
## ASM
|
|
`>PUSHB hFILE`
|
|
`>PUSHW statbuf`
|
|
`>SYSCALL fstat`
|
|
|
|
## RETURN VALUE
|
|
|
|
# Stat
|
|
Return information about a file
|
|
|
|
## C
|
|
`int stat(const char *pathname, struct stat *statbuf);`
|
|
|
|
## ASM
|
|
`>PUSHW pathname`
|
|
`>PUSHW statbuf`
|
|
`>SYSCALL stat`
|
|
|
|
## RETURN VALUE
|
|
|
|
# MKDir
|
|
create a directory
|
|
|
|
## C
|
|
`int mkdir(const char *pathname, int mode);`
|
|
|
|
## ASM
|
|
`>PUSHW pathname`
|
|
`>PUSHW mode`
|
|
`>SYSCALL mkdir`
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
CS : error
|
|
A = EC
|
|
|
|
# MKFIFO
|
|
return a pathname to a new FIFO
|
|
|
|
## C
|
|
`hFILE mkfifo(const char *pathname, int mode);`
|
|
|
|
## ASM
|
|
`>PUSHW pathname`
|
|
`>PUSHW mode`
|
|
`>SYSCALL mkfifo`
|
|
|
|
## RETURN VALUE
|
|
CC = OK, CS = ERROR
|
|
A = hFILE
|
|
|
|
# MkNod
|
|
Create a special or ordinary file.
|
|
(CDEV, BDEV, DSOCK, SSOCK, PIPE)
|
|
|
|
## C
|
|
`hFILE mknod(const char *pathname, int mode, hFD fd);`
|
|
|
|
## ASM
|
|
`>PUSHW pathname`
|
|
`>PUSHW mode`
|
|
`>PUSHB fd`
|
|
`>SYSCALL mknod`
|
|
|
|
## RETURN VALUE
|
|
CC = OK, CS = ERROR
|
|
A = hFILE
|
|
|
|
# pipe
|
|
|
|
## C
|
|
`hFD pipe(int size);`
|
|
|
|
## ASM
|
|
`>LDYA size`
|
|
`>SYSCALL pipe`
|
|
|
|
## RETURN VALUE
|
|
CC = OK, CS = ERROR
|
|
A = hFD
|
|
|
|
# fputc (BLOCKING)
|
|
Print A (char) to hFILE
|
|
|
|
## C
|
|
`int fputc ( hFILE stream , short int character );`
|
|
|
|
## ASM
|
|
`>PUSHB stream`
|
|
`>PUSHB character`
|
|
`>SYSCALL fputc`
|
|
|
|
## RETURN VALUE
|
|
CC = success
|
|
|
|
# putchar (BLOCKING)
|
|
Print A (char) to StdOut
|
|
|
|
## C
|
|
`int putchar ( short int character );`
|
|
|
|
## ASM
|
|
`lda character`
|
|
`>SYSCALL putchar`
|
|
|
|
## RETURN VALUE
|
|
CC = success
|
|
|
|
# puts (BLOCKING)
|
|
Write Str to StdOut, appends '\r\n'
|
|
|
|
## C
|
|
`int puts ( const char * str );`
|
|
|
|
## ASM
|
|
`>LDYAI str`
|
|
`>SYSCALL PutS`
|
|
|
|
## RETURN VALUE
|
|
CC = success
|
|
|
|
# fputs (BLOCKING)
|
|
Write Str to hFILE
|
|
|
|
## C
|
|
`int fputs (hFILE stream, const char * str );`
|
|
|
|
## ASM
|
|
`>PUSHB stream`
|
|
`>PUSHW str`
|
|
`>SYSCALL fputs`
|
|
|
|
## RETURN VALUE
|
|
CC = success
|
|
|
|
# fgets (BLOCKING)
|
|
read bytes from stream into the array
|
|
pointed to by s, until n-1 bytes are read, or a <newline> is read and
|
|
transferred to s, or an end-of-file condition is encountered. The
|
|
string is then terminated with a null byte.
|
|
|
|
## C
|
|
`char *fgets(hFILE stream, char * s, int n);`
|
|
|
|
## ASM
|
|
`>PUSHB hFILE`
|
|
`>PUSHW s`
|
|
`>PUSHW n`
|
|
`>SYSCALL fgets`
|
|
|
|
## RETURN VALUE
|
|
Y,A: s
|
|
CC = success
|
|
|
|
# getchar (BLOCKING)
|
|
Get char from StdIn
|
|
|
|
## C
|
|
`short int getchar ( );`
|
|
|
|
## ASM
|
|
`>SYSCALL getchar`
|
|
|
|
## RETURN VALUE
|
|
CC = success
|
|
A = char
|
|
|
|
# getc (BLOCKING)
|
|
Get char from Node
|
|
|
|
## C
|
|
`short int getc ( short int stream );`
|
|
|
|
## ASM
|
|
`lda stream`
|
|
`>SYSCALL getc`
|
|
|
|
## RETURN VALUE
|
|
CC = success
|
|
A = char
|
|
|
|
# ungetc
|
|
push byte back into input stream
|
|
|
|
## C
|
|
`short int ungetc(short int c, short int stream);`
|
|
|
|
## ASM
|
|
`>PUSHB c`
|
|
`>PUSHB stream`
|
|
`>SYSCALL ungetc`
|
|
|
|
## RETURN VALUE
|
|
CC = success
|
|
A = char
|
|
|
|
# FOpen
|
|
Open a file
|
|
|
|
## C
|
|
`short int fopen ( const char *filename, short int flags, short int ftype, int auxtype );`
|
|
|
|
## ASM
|
|
`>PUSHW filename`
|
|
`>PUSHB flags`
|
|
+ O.RDONLY : if R and exists -> ERROR
|
|
+ O.WRONLY : if W and exists -> CREATE
|
|
+ O.TRUNC : Reset Size To 0
|
|
+ O.APPEND : Append
|
|
+ O.TEXT : Open/Append in Text mode
|
|
+ O.CREATE : Create if not exists
|
|
`>PUSHB ftype`
|
|
`>PUSHW auxtype`
|
|
TODO: replace flags/ftype/auxtype with mode="w+,t=TYP,x=AUXTYPE"
|
|
+ r = O_RDONLY
|
|
+ r+ = O_RDWR
|
|
+ w = O_WRONLY | O_CREAT | O_TRUNC
|
|
+ w+ = O_RDWR | O_CREAT | O_TRUNC
|
|
+ a = O_WRONLY | O_CREAT | O_APPEND
|
|
+ a+ = O_RDWR | O_CREAT | O_APPEND
|
|
+ ,t=123 or t=$ff or t=TXT
|
|
+ ,x=12345 or x=$ffff
|
|
|
|
## RETURN VALUE
|
|
CC : A = hFILE
|
|
CS : A = EC
|
|
|
|
# FClose
|
|
Close a file
|
|
|
|
## C
|
|
`int fclose ( short int stream );`
|
|
|
|
## ASM
|
|
`lda stream`
|
|
`>SYSCALL FClose`
|
|
|
|
## RETURN VALUE
|
|
|
|
# FRead (BLOCKING)
|
|
Read bytes from file
|
|
|
|
## C
|
|
`int fread (short int stream, void * ptr, int count );`
|
|
|
|
## ASM
|
|
`>PUSHB stream`
|
|
`>PUSHW ptr`
|
|
`>PUSHW count`
|
|
`>SYSCALL fread`
|
|
|
|
## RETURN VALUE
|
|
Y,A = Bytes Read
|
|
|
|
# FWrite (BLOCKING)
|
|
Write bytes to file
|
|
|
|
## C
|
|
`int fwrite ( short int stream, const void * ptr, int count );`
|
|
|
|
## ASM
|
|
`>PUSHB stream`
|
|
`>PUSHW ptr`
|
|
`>PUSHW count`
|
|
`>SYSCALL fwrite`
|
|
|
|
## RETURN VALUE
|
|
Y,A = Bytes Written
|
|
|
|
# FFlush
|
|
|
|
## C
|
|
`int fflush( short int stream );`
|
|
|
|
## ASM
|
|
`lda stream`
|
|
`>SYSCALL fflush`
|
|
|
|
# FSeek
|
|
Set the file-position indicator for hFILE
|
|
|
|
## C
|
|
`int fseek( short int stream, long offset, short int whence );`
|
|
|
|
## ASM
|
|
`>PUSHB stream`
|
|
`>PUSHL offset`
|
|
`>PUSHB whence`
|
|
`>SYSCALL fseek`
|
|
|
|
# FEOF
|
|
Test the end-of-file indicator for hFILE
|
|
|
|
## C
|
|
`short int feof( short int stream );`
|
|
|
|
## ASM
|
|
`lda stream`
|
|
`>SYSCALL feof`
|
|
|
|
## RETURN VALUE
|
|
CC :
|
|
A = $ff EOF
|
|
A = 0 NOT EOF
|
|
CS :
|
|
|
|
# FTell
|
|
Return the current value of the file-position indicator
|
|
|
|
## C
|
|
`long ftell( short int stream );`
|
|
|
|
## ASM
|
|
`lda stream`
|
|
`>SYSCALL ftell`
|
|
|
|
## RETURN VALUE
|
|
On stack (long)
|
|
|
|
# Remove
|
|
Remove a file or directory
|
|
|
|
## C
|
|
`int remove ( const char *pathname );`
|
|
|
|
## ASM
|
|
`>LDYA pathname`
|
|
`>SYSCALL remove`
|
|
|
|
## RETURN VALUE
|
|
|
|
# Rename
|
|
Rename a file
|
|
|
|
## C
|
|
`int rename ( const char * oldpath, const char * newpath );`
|
|
|
|
## ASM
|
|
`>PUSHW oldpath`
|
|
`>PUSHW newpath`
|
|
`>SYSCALL rename`
|
|
|
|
## RETURN VALUE
|
|
|
|
# PrintF (BLOCKING)
|
|
|
|
# FPrintF (BLOCKING)
|
|
|
|
# SPrintF
|
|
Prints C-Style String
|
|
|
|
## C
|
|
`int printf ( const char *format, ... );`
|
|
`int fprintf ( short int stream, const char *format, ... );`
|
|
`int sprintf ( char *str, const char *format, ... );`
|
|
|
|
## ASM
|
|
PrintF : (example is for printing Y,A as integer : format="%I", 2 bytes)
|
|
`>PUSHW format`
|
|
`>PUSHW i`
|
|
`...`
|
|
`>PUSHBI 2` #bytecount
|
|
`>SYSCALL PrintF`
|
|
FPrintF :
|
|
`>PUSHB hFILE`
|
|
`>PUSHW format`
|
|
`>PUSHW i`
|
|
`...`
|
|
`>PUSHBI 2` #bytecount
|
|
`>SYSCALL fprintf`
|
|
SPrintF :
|
|
`>PUSHW str`
|
|
`>PUSHW format`
|
|
`>PUSHW i`
|
|
`...`
|
|
`>PUSHBI 2` #bytecount
|
|
`>SYSCALL sprintf`
|
|
|
|
## RETURN VALUE
|
|
CC : success, Y,A = bytes sent
|
|
CS : error, A = code from Output
|
|
Specifiers :
|
|
+ %b : pull 1 byte to Print BIN
|
|
+ %d : pull 1 byte unsigned DEC 0..255
|
|
+ %D : pull 2 bytes unsigned DEC 0..65535
|
|
+ %u : pull 4 bytes long unsigned DEC 0..4294967295
|
|
+ %e : pull 5 Bytes float (-)1.23456789e+12
|
|
+ %f : pull 5 Bytes float (-)3.1415
|
|
+ %h : pull 1 byte to Print HEX
|
|
+ %H : pull 2 bytes to Print HEX
|
|
+ %i : pull 1 byte to Print signed DEC -128..127
|
|
+ %I : pull 2 bytes to Print signed DEC -32768..32767
|
|
+ %L : pull 4 bytes signed DEC -2147483648..2147483647
|
|
+ %s : pull 2 bytes ptr to C-Style String
|
|
+ %S : pull 2 bytes ptr to P-Style String
|
|
|
|
Modifiers for len and padding :
|
|
+ %d : '9' '12'
|
|
+ %2d : ' 9' '12'
|
|
+ %02d : '09' '12'
|
|
+ %11s : 'ABCDEFGH '
|
|
+ %011s : 'ABCDEFGH000'
|
|
+ %2f : '3.14'
|
|
|
|
|
|
# ScanF (BLOCKING)
|
|
|
|
# FScanF (BLOCKING)
|
|
|
|
# SScanF
|
|
Read formatted data from string
|
|
|
|
## C
|
|
`int scanf( const char *format, ... );`
|
|
`int fscanf( short int stream, const char *format, ... );`
|
|
`int sscanf ( const char *s, const char *format, ... );`
|
|
|
|
## ASM
|
|
ScanF :
|
|
`>PUSHW format`
|
|
`>PUSHW ptr`
|
|
`...`
|
|
`>PUSHB bytecount`
|
|
`>SYSCALL scanf`
|
|
FScanF :
|
|
`>PUSHB stream`
|
|
`>PUSHW format`
|
|
`>PUSHW ptr`
|
|
`...`
|
|
`>PUSHB bytecount`
|
|
`>SYSCALL fscanf`
|
|
SScanF :
|
|
`>PUSHW s`
|
|
`>PUSHW format`
|
|
`>PUSHW ptr`
|
|
`...`
|
|
`>PUSHB bytecount`
|
|
`>SYSCALL sscanf`
|
|
Specifiers :
|
|
+ %i : short int
|
|
+ %d : byte
|
|
+ %I : int
|
|
+ %D : word
|
|
+ %L : long int
|
|
+ %U : dword
|
|
+ %h : HEX byte
|
|
+ %H : HEX word
|
|
+ %s : string
|
|
|
|
TODO : %10s
|
|
|
|
## RETURN VALUE
|
|
A = Number of arguments filled.
|
|
|
|
# StrToF
|
|
Convert String to 40 bits Float
|
|
|
|
## C
|
|
`float strtof (const char* str, char** endptr );`
|
|
|
|
## ASM
|
|
`>PUSHW str`
|
|
`>PUSHWI EndPtr`
|
|
`>SYSCALL StrToF`
|
|
|
|
## RETURN VALUE
|
|
On stack (float)
|
|
|
|
# AToF
|
|
Convert String to 40 bits Float
|
|
|
|
## C
|
|
`float atof ( const char* str );`
|
|
|
|
## ASM
|
|
`>LDYA str`
|
|
`>SYSCALL atof`
|
|
|
|
## RETURN VALUE
|
|
On stack (float)
|
|
|
|
# StrToL/StrToUL
|
|
Convert String to 32 bits (unsigned) int
|
|
|
|
## C
|
|
`long strtol (const char* str, char** endptr, int base);`
|
|
`unsigned long strtoul (const char* str, char** endptr, int base);`
|
|
|
|
## ASM
|
|
`>PUSHW str`
|
|
`>PUSHW EndPtr`
|
|
`>PUSHB Base`
|
|
`>SYSCALL StrToL`
|
|
|
|
## RETURN VALUE
|
|
On stack (long)
|
|
|
|
# atol
|
|
Convert String to 32 bits long
|
|
|
|
## C
|
|
`long atol ( const char * str );`
|
|
|
|
## ASM
|
|
`>LDYA str`
|
|
`>SYSCALL atol`
|
|
|
|
## RETURN VALUE
|
|
On stack (long)
|
|
|
|
# atoi
|
|
Convert String to 16 bits int
|
|
|
|
## C
|
|
`int atoi ( const char * str );`
|
|
|
|
## ASM
|
|
`>LDYAI str`
|
|
`>SYSCALL atoi`
|
|
|
|
## RETURN VALUE
|
|
Y,A = int
|
|
|
|
# RealPath
|
|
Return the canonicalized absolute pathname
|
|
|
|
## C / CSH
|
|
`char *realpath(const char *path, char *resolvedpath);`
|
|
|
|
## ASM
|
|
`>PUSHW path`
|
|
`>PUSHW resolvedpath`
|
|
`>SYSCALL realpath`
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
Y,A = Ptr to Full Path (C-String Buffer, MLI.MAXPATH+1)
|
|
X = hMem of Full Path
|
|
CS : A = Error Code
|
|
|
|
# Expand
|
|
|
|
## C
|
|
`char *expand(const char *str, char *expanded);`
|
|
|
|
## ASM
|
|
`>PUSHW str`
|
|
`>PUSHW expanded`
|
|
`>SYSCALL expand`
|
|
|
|
## RETURN VALUE
|
|
if expanded == null
|
|
Y,A = PTR to Expanded String
|
|
X = hMem to Expanded String
|
|
if expanded = null
|
|
Y,A = strlen
|
|
|
|
# LoadStkObj
|
|
Load a file in AUX memory (Stock Objects)
|
|
PUSHW = PATH (Handled by....
|
|
PUSHB = MODE ...
|
|
PUSHB = TYPE ...
|
|
PUSHW = AUXTYPE ...FOpen)
|
|
|
|
## RETURN VALUE
|
|
Y,A = File Length
|
|
X = hMem of Loaded Object in AUX mem
|
|
|
|
# GetStkObj
|
|
|
|
## C
|
|
`int *ptr getstkobj (short int hStkObj);`
|
|
|
|
## ASM
|
|
`lda hStkObj`
|
|
`>SYSCALL GetStkObj`
|
|
|
|
## RETURN VALUE
|
|
CC : success
|
|
X = hMem
|
|
Y,A = ptr
|
|
CS : error
|
|
A = EC
|
|
|
|
# StrLen
|
|
Returns Length of C-String
|
|
|
|
## C
|
|
`int strlen ( char * str);`
|
|
|
|
## ASM
|
|
`>LDYAI str`
|
|
`>SYSCALL strlen`
|
|
|
|
## RETURN VALUE
|
|
Y,A = String length
|
|
|
|
# StrCat
|
|
Concatenate strings
|
|
|
|
## C
|
|
`char * strcat ( char * destination, const char * source );`
|
|
|
|
## ASM
|
|
`>PUSHWI destination`
|
|
`>PUSHWI source`
|
|
`>SYSCALL strcat`
|
|
|
|
## RETURN VALUE
|
|
Y,A = destination
|
|
|
|
# StrCpy
|
|
Copy string
|
|
|
|
## C
|
|
`char * strcpy ( char * destination, const char * source );`
|
|
|
|
## ASM
|
|
`>PUSHWI destination`
|
|
`>PUSHWI source`
|
|
`>SYSCALL strcpy`
|
|
|
|
## RETURN VALUE
|
|
Y,A = destination
|
|
|
|
# StrDup
|
|
Create a new copy of this C-String
|
|
|
|
## C
|
|
`char * strdup ( char * str);`
|
|
|
|
## ASM
|
|
Y,A = Ptr to source C-String
|
|
CC : success
|
|
Y,A = PTR to String
|
|
X = hMem (C-String)
|
|
CS : error
|
|
A = SYS error code
|
|
|
|
# StrUpr/StrLwr
|
|
Convert string to UPPERCASE/lowercase
|
|
|
|
## C
|
|
`int strupr ( char * str);`
|
|
`int strlwr ( char * str);`
|
|
|
|
## ASM
|
|
`>LDYAI str`
|
|
`>SYSCALL strupr`
|
|
`>SYSCALL strlwr`
|
|
|
|
## RETURN VALUE
|
|
Uppercased/lowercased String in Buffer
|
|
Y,A = str
|
|
|
|
# StrCmp
|
|
Compare 2 strings
|
|
|
|
## C
|
|
`int strcmp(const char *s1, const char *s2);`
|
|
|
|
## ASM
|
|
`>PUSHWI s1`
|
|
`>PUSHWI s2`
|
|
`>SYSCALL strcmp`
|
|
|
|
## RETURN VALUE
|
|
CC : match
|
|
CS : no match
|
|
CC, Y,A=0
|
|
CS, Y,A > 0 or < 0
|
|
|
|
# StrCaseCmp
|
|
Compare 2 strings, ignoring case
|
|
|
|
## C
|
|
`int strcasecmp(const char *s1, const char *s2);`
|
|
|
|
## ASM
|
|
`>PUSHWI s1`
|
|
`>PUSHWI s2`
|
|
`>SYSCALL strcasecmp`
|
|
|
|
## RETURN VALUE
|
|
CC : match
|
|
CS : no match
|
|
CC, Y,A=0
|
|
CS, Y,A > 0 or < 0
|
|
|
|
# StrVSet
|
|
|
|
## ASM
|
|
`>PUSHB hSTRV`
|
|
`>PUSHW id`
|
|
`>PUSHW ptr`
|
|
`>SYSCALL StrVSet`
|
|
|
|
## RETURN VALUE
|
|
|
|
# StrVGet
|
|
|
|
## ASM
|
|
`>PUSHB hSTRV`
|
|
`>PUSHW id`
|
|
`>PUSHW ptr`
|
|
`>SYSCALL StrVGet`
|
|
|
|
## RETURN VALUE
|
|
CC: Y,A = Ptr
|
|
CS: Y,A = NULL
|
|
|
|
# StrVNew
|
|
|
|
## ASM
|
|
`>LDYA size`
|
|
`>SYSCALL StrVNew`
|
|
|
|
## RETURN VALUE
|
|
|
|
# StrVFree
|
|
|
|
## ASM
|
|
`lda hSTRV`
|
|
`>SYSCALL StrVFree`
|
|
|
|
## RETURN VALUE
|
|
|
|
# Time
|
|
Get System Time in Buffer
|
|
|
|
## C
|
|
`void time (struct tm* timeptr);`
|
|
|
|
## ASM
|
|
`>PUSHW timer`
|
|
`>SYSCALL time`
|
|
|
|
## RETURN VALUE
|
|
S.TIME filled with System date/time
|
|
|
|
# StrFTime
|
|
|
|
## C
|
|
Convert S.TIME struct to CSTR
|
|
`void strftime (char* str, const char* format, const struct tm* timeptr );`
|
|
|
|
## ASM
|
|
`>PUSHW str`
|
|
`>PUSHW format`
|
|
+ %a : Abbreviated weekday name : Thu
|
|
+ %A : Full weekday name : Thursday
|
|
+ %b : Abbreviated month name : Aug
|
|
+ %B : Full month name : August
|
|
+ %d : Day of the month, zero-padded (01-31)
|
|
+ %H : Hour in 24h format (00-23) 14
|
|
+ %I : Hour in 12h format (01-12) 02
|
|
+ %m : Month as a decimal number (01-12) 08
|
|
+ %M : Minute (00-59) 55
|
|
+ %p : AM or PM designation PM
|
|
+ %S : Second (00-61) 02
|
|
+ %w : Weekday as a decimal number with Sunday as 0 (0-6)
|
|
+ %y : Year, last two digits (00-99)
|
|
+ %Y : Year four digits 2001
|
|
|
|
`>PUSHW timeptr`
|
|
`>SYSCALL strftime`
|
|
|
|
## RETURN VALUE
|
|
none. always succeed.
|
|
|
|
# PTime2Time
|
|
Convert ProDOS Time To S.TIME
|
|
|
|
## C
|
|
`void PTime2Time (long* ptime, const struct tm* timeptr );`
|
|
|
|
## ASM
|
|
`>PUSHW ptime`
|
|
`>PUSHW timer`
|
|
`>SYSCALL PTime2Time`
|
|
|
|
## RETURN VALUE
|
|
|
|
# CTime2Time
|
|
Convert CTime Time To S.TIME
|
|
|
|
## C
|
|
`void CTime2Time (long* ctime, const struct tm* timeptr );`
|
|
|
|
## ASM
|
|
`>PUSHW ctime`
|
|
`>PUSHW timer`
|
|
`>SYSCALL CTime2Time`
|
|
|
|
## RETURN VALUE
|
|
|
|
# open
|
|
|
|
## C
|
|
`hFD open(const char *pathname, short int flags);`
|
|
|
|
## ASM
|
|
`>PUSHW pathname`
|
|
`>PUSHB flags`
|
|
`>SYSCALL open`
|
|
|
|
## RETURN VALUE
|
|
A = hFD
|
|
REG File created on ProDOS : T=TXT,X=$0000
|
|
|
|
# close
|
|
|
|
## C
|
|
`int close(hFD fd);`
|
|
|
|
## ASM
|
|
`lda fd`
|
|
`>SYSCALL close`
|
|
|
|
# read
|
|
|
|
## C
|
|
`int read(hFD fd, void *buf, int count);`
|
|
|
|
## ASM
|
|
`>PUSHB fd`
|
|
`>PUSHW buf`
|
|
`>PUSHW count`
|
|
`>SYSCALL read`
|
|
|
|
## RETURN VALUE
|
|
CC: Y,A = bytes read
|
|
CS: A = EC
|
|
|
|
# write
|
|
|
|
## C
|
|
`int write(hFD fd, const void *buf, int count);`
|
|
|
|
## ASM
|
|
`>PUSHB fd`
|
|
`>PUSHW buf`
|
|
`>PUSHW count`
|
|
`>SYSCALL write`
|
|
|
|
## RETURN VALUE
|
|
CC: Y,A = bytes written
|
|
CS: A = EC
|
|
|
|
# LSeek
|
|
Set the file-position indicator for hFD
|
|
|
|
## C
|
|
`int lseek( short int hFD, long offset, short int whence );`
|
|
|
|
## ASM
|
|
`>PUSHB hFD`
|
|
`>PUSHL offset`
|
|
`>PUSHB whence`
|
|
`>SYSCALL fseek`
|
|
|
|
# ChOwn
|
|
|
|
## C
|
|
`short int chown(const char *pathname, short int owner, short int group);`
|
|
|
|
## ASM
|
|
`>PUSHW pathname`
|
|
`>PUSHB owner`
|
|
`>PUSHB group`
|
|
`>SYSCALL chown`
|
|
|
|
## RETURN VALUE
|
|
|
|
## License
|
|
A2osX is licensed under the GNU General Public License.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
The full A2osX license can be found **[Here](../LICENSE)**.
|
|
|
|
*** End of Auto generated file ***
|