A2osX/.Docs/KERNEL.md

*** Auto generated by docgen.cmd ***  

# GetArg  

## ASM  
**In:**  
A = argument index.  
**Out:**   
CC : success  
Y,A = PTR To Arg[A]  
CS : Out Of Bound  

# LoadDrv  

## ASM  
**In:**  
 Y,A = PTR to "NAME.DRV [PARAM]" C-String  
**Out:**  
none  

# InsDrv  

## C  
`void * insdrv (void * src, void * crvcsstart, void * drvcsend, void * drvend);`  

## ASM  
**In:**  
`>PUSHW DRV.END`  
`>PUSHW DRV.CS.END`  
`>PUSHW DRV.CS.START`  
`>LDYA L.SRC`  
`SYSCALL insdrv`  
**Out:**  
Y,A = Ptr to installed driver  

# GetDevByID  
**In:**   
A = DevID  
**Out:**  
CC = OK, CS = ERROR  
Y,A = FD  
X = hFD  

# GetDevByName  
**In:**   
 Y,A = Ptr to device name (C-String)  
**Out:**  
CC = OK, CS = ERROR  
Y,A = FD  
X = DevID  

# GetDevStatus  

## C   
`int getdevstatus(short int hFD, S.DIB* dstat);`  

## ASM  
**In:**   
`>PUSHWI S.DIB`  
`lda DevID`  
`>SYSCALL GetDevStatus`  
**Out:**  

# MKDev  
**In:**   
 Y,A = Ptr to FD.DEV  
**Out:**  
 A = DEVID  

# OpenDir  

## C  
`int hDIR opendir (const char * dirpath);`  

## ASM  
**In:**  
`>LDYA dirpath`  
`>SYSCALL opendir`   
**Out:**   
 CC : success  
  A = hDIR  
 CS : error  
  A = EC  

# ReadDir  

## C  
`int readdir (int hDIR, S.DIRENT * dirent);`  

## ASM  
**In:**  
`>PUSHW dirent`  
`lda hDIR`  
`>SYSCALL readdir`  
**Out:**   
 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  
**In:**   
`lda hDIR`  
`>SYSCALL closedir`  
**Out:**  
 none, always succeed.   

# ExpandStr  
**In:**  
 Y,A = PTR to String to Expand (C-String)  
**Out:**  
 X = hMem to Expanded String (C-String)  
 Y,A = PTR to Expanded String   

# 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  
**In:**  
`>PUSHWI filestat`  
`>PUSHWI fullpath`  
`>PUSHWI searchpath`  
`>LDYAI filename`  
**Out:**  
CC : success  
DstBuf = FilePath  
DstStat = S.STAT  
CS : not found  

# PutEnv  
Change or add an environment variable, string is 'NAME=VALUE'  

## C  
`int putenv(char *string);`  

## ASM  
**In:**  
`>LDYA string`  
`>SYSCALL putenv`  
**Out:**  

# SetEnv  
Change or add an environment variable  

## C  
`int setenv(const char *name, const char *value);`  

## ASM  
**In:**  
`>PUSHW value`  
`>LDYA name`  
`>SYSCALL setenv`  
**Out:**  

# GetEnv  
searches the environment list to find the environment variable name,   
and returns a pointer to the corresponding value string.  

## C  
`char *getenv(const char *name);`  

## ASM  
**In:**  
`>LDYA name`  
`>SYSCALL gerenv`  
**Out:**  
 CC : Y,A = PTR to VALUE (C-String)  
 CS : not found  

# UnsetEnv  
Remove an environment variable  

## C  
`int unsetenv(const char *name);`  

## ASM  
**In:**  
`>LDYA name`  
`>SYSCALL unsetenv`  
**Out:**  

# LoadTxtFile  
Load TXT a file in memory (with ending 0)  
**In:**  
 Y,A = File Path  
**Out:**  
 Y,A = File Length (without ending 0)  
 X = hMem of Loaded File  

# LoadFile  
Load a file in memory  
**In:**  
 PUSHW = AUXTYPE (Handled by....  
 PUSHB = TYPE  ...  
 PUSHB = MODE  ...  
 LDYA = PATH ...FOpen)  
**Out:**  
 Y,A = File Length  
 X = hMem of Loaded File  

# ChTyp  
Change The type of a ProDOS File  

## C  
`int chtyp(const char *filepath, const char filetype);`  

## ASM  
**In:**  
`>PUSHBI filetype`  
`>LDYA filepath`  
`>SYSCALL chtyp`  
**Out:**  

# ChMod  
**In:**  
 PUSHW = UID  
 PUSHW = PATH  

# ChOwn  
**In:**  
 PUSHW = mod  
 PUSHW = PATH  

# ChGrp  
**In:**  
 PUSHW = GID  
 PUSHW = PATH  

# open  

## C  
`hFD open(const char *pathname, int flags);`  

## ASM  
**In:**  
`>PUSHB flags`  
`>LDYA pathname`  
`>SYSCALL open`  
**Out:**  
A = hFD  
note : if file is created on ProDOS : T=TXT,X=$0000  

# close  

## C  
`int close(hFD fd);`  

## ASM  
**In:**  
`lda fd`  
`>SYSCALL close`  

# read  

## C  
`int read(hFD fd, void *buf, int count);`  

## ASM  
**In:**  
`>PUSHWI count`  
`>PUSHW buf`  
`lda fd`  
`>SYSCALL read`  
**Out:**  
CC: Y,A = bytes read  
CS: A = EC  

# write  

## C  
`int write(hFD fd, const void *buf, int count);`  

## ASM  
**In:**  
`>PUSHWI count`  
`>PUSHW buf`  
`lda fd`  
`>SYSCALL write`  
**Out:**  
CC: Y,A = bytes written  
CS: A = EC  

# IOCTL  

## C  
`int ioctl(short int hFD, int request, void * param );`  

## ASM  
**In:**   
`PUSHWI param`  
`PUSHBI request`  
`lda hFD`  
`>SYSCALL IOCTL`  
**Out:**  
 Y,A = ...  

# pipe  

## C  
`int pipe(int pipefd[2]);`  

## ASM  
**In:**   

# FAdd,FSub,FMult,FDiv,FPwr  
Return X+Y, X-Y, X*Y, X/Y, X^Y  

## ASM  
**In:**  
`>PUSHF X (float)`  
`>PUSHF Y (float)`  
`>SYSCALL fadd`  
`>SYSCALL fsub`  
`>SYSCALL fmult`  
`>SYSCALL fdiv`  
`>SYSCALL fpwr`  
**Out:**  
 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  
**In:**  
`>PUSHF x (Float)`  
`>SYSCALL log`  
**Out:**  
 On stack (Float)  

# float  
Return 'floated' long  

## C  
`float f = (float)12345678;  

## ASM  
**In:**  
 `>PUSHL X` (long)  
**Out:**  
 On stack (float)  

# lrintf  
Return float rounded into a long  

## C  
`long int lrintf (float x);`  

## ASM  
**In:**  
`>PUSHF x`  
`>SYSCALL lrintf`  
**Out:**  
 On stack (long)  

# GetMem0  
**In:**   
 Y,A = Size Requested  
**Out:**  
 CC : success  
  YA = PTR to Mem (ZERO Initialised)  
*	X = hMem  
 CS :  
  A = EC  

# GetMem  
**In:**   
 Y,A = Size Requested  
**Out:**  
 CC : success  
  YA = PTR to Mem (Uninitialised)  
*	X = hMem  
 CS :  
  A = EC  

# FreeMem  
**In:**  
 A = hMem To Free  
**Out:**  
 none.  
 (X unmodified)  

# GetMemPtr  
**In:**  
A = hMem  
**Out:**  
Y,A = PTR to MemBlock  
(X unmodified)  

# GetMemByID  
**In:**  
A = hMem  
**Out:**  
Y,A = ZPMemMgrSPtr = PTR to S.MEM  
(X unmodified)  

# NewStr  
Create a new copy of this C-String  
**In:**  
Y,A = Ptr to source C-String  
**Out:**  
CC : success   
 Y,A = PTR to String  
 X = hMem (PSTR)  
CS : error  
 A = SYS error code  

# SListGetByID  
**In:**  
 PUSHB = hSList  
 PUSHW = KeyID  
 PUSHW = Data Ptr  
 PUSHW = Key Ptr  
**Out:**  
 X,Y = Next KeyID  

# SListUpdateByID  
**In:**  
 PUSHB = hSList  
 PUSHW = KeyID  
 PUSHW = Data Ptr  
**Out:**  
 A = Key Length  
 X,Y = KeyID  

# SListAdd  
**In:**  
 PUSHB = hSList  
 PUSHW = Key Ptr  
 PUSHW = Data Ptr  
**Out:**  
 A = Key Length  
 X,Y = KeyID  

# SListLookup  
**In:**  
 PUSHB = hSList  
 PUSHW = Key Ptr  
 PUSHW = Data Ptr  
**Out:**  
 A = Key Length  
 X,Y = KeyID  

# SListNew  
**In:**  
**Out:**  
 A=hSList  

# SListFree  
**In:**  
 A=hSList  
**Out:**  

# GetStkObjProp  
**In:**  
 A = hObject (AUX Memory)  
 Y = Property Index  
**Out:**  
 Y,A = Property Value  

# NewStkObj  
**In:**   
 Y,A = Size Requested  
**Out:**  
 CC : success  
  YA = PTR to Mem (Uninitialised)  
*	X = hMem  
 CS :  
  A = EC  

# FreeStkObj  
**In:**  
 A = hMem To Free (AUX Memory)  
**Out:**  
 none.  
 (X,Y unmodified)  

# LoadStkObj  
Load a file in AUX memory (Stock Objects)  
**In:**  
 PUSHW = AUXTYPE (Handled by....  
 PUSHB = TYPE  ...  
 PUSHB = MODE  ...  
 PUSHW = PATH ...FOpen)  
**Out:**  
 Y,A = File Length  
 X = hMem of Loaded Object in AUX mem  

# ExecPSNewEnv  

# ExecPS (Blocking Parent PID)  

# CreatePSNewEnv   

# CreatePS (Non Blocking)  
**In:**  
  Y,A = PTR To Cmd Line  
**Out:**  
  A = Child PSID  

# GetMemStat  
**In:**  
 Y,A = Ptr to 24 bytes buffer  
**Out:**  
 Buffer filled with memory stats  

# GetPSStatus  
**In:**  
 A = PID  
**Out:**  
 A = Status Byte  

# GetPSStat  
**In:**  
 Y,A = Ptr to 24 bytes buffer  
**Out:**  
 Buffer filled with PS stats  

# Stat  
Return information about a file  

## C  
`int stat(const char *pathname, struct stat *statbuf);`  

## ASM  
**In:**  
`>PUSHW statbuf`  
`>LDYA pathname`  
`>SYSCALL stat`  
**Out:**  

# MKDir  
create a directory  

## C  
`int mkdir(const char *pathname, int mode);`  

## ASM  
**In:**   
`>PUSHW mode`  
`>LDYA pathname`  
`>SYSCALL mkdir`  
**Out:**  
CC : success  
CS : error  
A = EC  

# MkNod  
return a hFile for a given file descriptor.  
(CDEV, BDEV, DSOCKS, SSOCK, PIPE)  

## C  
`hFILE mknod(const char *pathname, int mode, hFD fd);`  

## ASM  
**In:**   
`>PUSHB fd`  
`>PUSHW mode`  
`>LDYA pathname`  
`>SYSCALL mknod`  
**Out:**  
CC = OK, CS = ERROR  
A = hFILE  

# MKFIFO  
return a hFILE to a new FIFO  

## C  
`hFILE mkfifo(const char *pathname, int mode);`  

## ASM  
**In:**   
`>PUSHW mode`  
`>LDYA pathname`  
`>SYSCALL mkfifo`  
**Out:**  
CC = OK, CS = ERROR  
A = hFILE  

# FPutC  
Print A (char) to hFILE  

## C  
`int fputc ( hFILE stream , int character );`  

## ASM  
**In:**  
A : character  
Y : stream  
**Out:**   
CC = success  

# PutChar  

## C  
`int putchar ( int character );`  

## ASM  
Print A (char) to StdOut  
**In:**  
A : char to print  
**Out:**   
CC = success  

# PutS  
Write Str to StdOut, appends '\r\n'  

## C  
`int puts ( const char * str );`  
**In:**  

## ASM  
`>LDYAI str`  
`>SYSCALL puts`  
**Out:**   
CC = success  

# FPutS  
Write Str to FILE  

## C  
`int fputs (hFILE stream, const char * str );`  

## ASM  
**In:**  
`>PUSHW str`  
`lda stream`  
`>SYSCALL fputs`  
**Out:**   
CC = success  

# PrintF/SPrintF/FPrintF  
Prints C-Style String  

## C  
`int printf ( const char * format, ... );`  
`int sprintf ( char * str, const char * format, ... );`  
`int fprintf ( hFILE stream, const char * format, ... );`  

## ASM  
**In:**  
PrintF : (example is for printing Y,A as integer : format="Y,A= %I", 2 bytes)    
`>PUSHYA`  
`...`  
`>PUSHBI bytecount`  
`>LDYAI format`  
`>SYSCALL printf`  
SPrintF :   
`>PUSHYA`  
`...`  
`>PUSHBI bytecount`  
`>PUSHWI format`  
`>LDYAI str`  
`>SYSCALL sprintf`  
FPrintF :   
`>PUSHYA`  
`...`  
`>PUSHBI bytecount`  
`>PUSHWI format`  
`lda hFILE`  
`>SYSCALL fprintf`  
**Out:**  
CC : success, Y,A = bytes sent  
CS : error, A = code from Output  
Specifiers :  
+ %b : pull 1 byte to Print BIN   
+ %B : pull 2 bytes 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  
+ %n : pull 1 byte to Print low Nibble HEX  
+ %N : pull 1 byte to Print high Nibble HEX  
+ %s : pull 2 bytes ptr to C-Style String  
+ %S : pull 2 bytes ptr to P-Style String  
+ \b : Print 'BS' (08)  
+ \e : Print 'ESC' ($1B,27)  
+ \f : Print 'FF' ($0C,12)  
+ \n : Print 'LF' ($0A,10)  
+ \r : Print 'CR' ($0D,13)  
+ \\\\ : Print \  
+ \\% : Print %  

Modifiers for len and padding :   
+ %d	  : '9'  '12'  
+ %2d	  : ' 9' '12'   				  
+ %02d  : '09' '12'  
+ %11s  : 'ABCDEFGH   '	  
+ %011s : 'ABCDEFGH000'  
+ %2f	  :	'3.14'  


# FGetS  
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  
**In:**  
`>PUSHW n`  
`>PUSHW s`  
`lda hFILE`  
`>SYSCALL fgets`  
**Out:**   
 Y,A: s   
CC = success  

# GetChar  
Get char from StdIn  
**In:**  
 none.  
**Out:**   
 CC = success  
  A = char  

# GetC  
Get char from Node  

## C  
`int getc ( FILE * stream );`  

## ASM  
**In:**  
 A = hNODE  
**Out:**   
 CC = success  
  A = char  

# SScanF  
Read formatted data from string  

## C  
`int sscanf ( const char * s, const char * format, ... );`  

## ASM  
**In:**  
`>PUSHW ptr`  
`...`  
`>PUSHBI bytecount`  
`>PUSHWI format`  
+ %i : short int  
+ %d : byte  
+ %I : int  
+ %D : word  
+ %L : long int  
+ %U : dword  
+ %h : HEX byte  
+ %H : HEX word  
+ %s : string  

TODO : %10s  
`>LDYA s`  
`>SYSCALL sscanf`  
**Out:**  
A = Number of arguments filled.  

# FOpen  
Open a file  

## C  
`hFILE fopen ( const char * filename, short int mode, short int ftype, int auxtype );`  
**In:**  

## ASM  
`>PUSHWI auxtype`  
`>PUSHBI ftype`  
`>PUSHBI mode`  
 + SYS.FOpen.R : if R and exists -> ERROR  
 + SYS.FOpen.W : if W and exists -> CREATE  
 + SYS.FOpen.A : Append  
 + SYS.FOpen.T : Open/Append in Text mode  
 + SYS.FOpen.X : Create if not exists  
http://man7.org/linux/man-pages/man3/fopen.3.html  
r  = O_RDONLY  
w  = O_WRONLY | O_CREAT | O_TRUNC  
a  = O_WRONLY | O_CREAT | O_APPEND  
r+ = O_RDWR  
w+ = O_RDWR | O_CREAT | O_TRUNC  
a+ = O_RDWR | O_CREAT | O_APPEND  
*  
TODO: mode="w+t=TYP,x=AUXTYPE"  
`>LDYAI filename`  
**Out:**   
 CC : A = hFILE  
 CS : A = EC  

# FClose  
Close a file  

## C  
int fclose ( hFILE stream );  

## ASM  
**In:**  
 A = hFILE  
**Out:**  

# FRead  
int fread (hFILE stream, void * ptr, int count );  
Read bytes from file  
**In:**  
`>PUSHWI count`  
`>PUSHW ptr`  
`lda hFILE`  
`>SYSCALL fread`  
**Out:**  
 Y,A = Bytes Read  

# FWrite  
Write bytes to file  

## C  
`int fwrite (hFILE stream, const void * ptr, int count );`  

## ASM  
**In:**  
`>PUSHWI count`  
`>PUSHW ptr`  
`lda hFILE`  
`>SYSCALL fwrite`  
**Out:**  
 Y,A = Bytes Written  

# FFlush  

## C  
int fflush(hFILE stream);  

## ASM  
**In:**  
 A = hFILE  

# FSeek  
Set the file-position indicator for hFILE  

## C  
`int fseek(hFILE stream, long offset, short int whence);`  

## ASM  
**In:**  
`>PUSHBI whence`  
`>PUSHL offset`  
`lda stream`  
`>SYSCALL fseek`  

# FEOF  
Test the end-of-file indicator for hFILE  
**In:**  
 A = hFILE  
**Out:**  
 CC :   
  A=0 EOF  
  A =0 NOT EOF  
 CS :  

# FTell  
Return the current value of the file-position indicator  

## C  
`long ftell(hFILE stream);`  

## ASM  
**In:**  
`lda stream`  
`>SYSCALL ftell`  
**Out:**  
On stack (long)  

# Remove  

# Rename  
Rename a file  

## C  
`int rename(const char *oldpath, const char *newpath);`  

## ASM  
**In:**  
`>PUSHW newpath`  
`>LDYA oldpath`  
`>SYSCALL rename`  
**Out:**  

# strtof  
Convert String to 40 bits Float  

##C  
`float strtof (const char* str, char** endptr);`  

##ASM  
**In:**  
`>PUSHWI EndPtr`  
`>LDYA str`  
`>SYSCALL strtof`  
**Out:**  
On stack (float)  

# AToF  
Convert String to 40 bits Float  

## C  
`float atof (const char* str);`  

## ASM  
**In:**  
`>LDYA str`  
`>SYSCALL atof`  
**Out:**  
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  
**In:**  
`>PUSHB Base`  
`>PUSHWI EndPtr`  
`>LDYAI str`  
`>SYSCALL strtol`  
**Out:**  
On stack (long)  

# atol  
Convert String to 32 bits long  

## C  
`long atol ( const char * str );`  

## ASM  
**In:**  
`>LDYA str`  
`>SYSCALL atol`  
**Out:**  
On stack (long)  

# atoi  
Convert String to 16 bits int  

## C  
`int atoi ( const char * str );`  

## ASM  
**In:**  
`>LDYAI str`  
`>SYSCALL atoi`  
**Out:**  
 Y,A = int  

# RealPath  
Return the canonicalized absolute pathname  

## C  
`unsigned short int realpath (const char* str);`  

## ASM  
**In:**  
`>LDYA str`  
`>SYSCALL realpath`  
**Out:**  
CC : success  
 Y,A = Ptr to Full Path (C-String)  
 X = hMem of Full Path  
CS : A = Error Code  

# StrLen  
Returns Length of C-String  

## C  
`int strlen ( char * str);`  

## ASM  
**In:**   
`>LDYAI str`  
`>SYSCALL strlen`  
**Out:**   
Y,A = String length  

# StrCat  
Concatenate strings  

## C  
`char * strcat ( char * destination, const char * source );`  

## ASM  
**In:**   
`>PUSHWI source`  
`>LDYAI destination`  
`>SYSCALL strcat`  
**Out:**   
Y,A = destination  

# StrCpy  
Copy string  

## C  
`char * strcpy ( char * destination, const char * source );`  

## ASM  
**In:**   
`>PUSHWI source`  
`>LDYAI destination`  
`>SYSCALL strcpy`  
**Out:**   
Y,A = destination  

# StrMatch  
Compare a String against pattern (e.g. '*test?.txt')  

## C  
`int * strmatch ( char * s, const char * pattern );`  

## ASM  
**In:**   
`>PUSHWI pattern`  
`>LDYAI s`  
`>SYSCALL strmatch`  
**Out:**   
CC : match  
CS : no match  

# StrUpr/StrLwr  
Convert string to UPPERCASE/lowercase  

## C  
`int strupr ( char * str);`  
`int strlwr ( char * str);`  

## ASM  
**In:**   
`>LDYAI str`  
`>SYSCALL strupr`  
`>SYSCALL strlwr`  
**Out:**   
Uppercased/lowercased String in Buffer  
Y,A = str  

# StrCmp  
Compare 2 strings  

## C  
`int strcmp(const char *s1, const char *s2);`  

## ASM  
**In:**   
`>PUSHWI s2`  
`>LDYAI s1`  
`>SYSCALL strcmp`  
**Out:**   
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  
**In:**   
`>PUSHWI s2`  
`>LDYAI s1`  
`>SYSCALL strcasecmp`  
**Out:**   
CC : match  
CS : no match  
 CC, Y,A=0  
 CS, Y,A > 0 or < 0  

# Time  
Get System Time in Buffer  

## C  
`time_t time (S.TIME* timer);`  

##ASM  
**In:**  
Y,A = PTR to S.TIME  
**Out:**  
S.TIME filled with System date/time  

# PTime2Time  
 Convert ProDOS Time To S.TIME  

## C  
`int PTime2Time (long* ptime, S.TIME* timer);`  

##ASM  
**In :**   
`>PUSHW timer`  
`>LDYA ptime`  
`>SYSCALL PTime2Time`  
**Out:**  

# CTime2Time  
 Convert CTime Time To S.TIME  

## C  
`int CTime2Time (long* ctime, S.TIME* timer);`  

##ASM  
**In :**   
`>PUSHW timer`  
`>LDYA ctime`  
`>SYSCALL CTime2Time`  
**Out:**  

# StrFTime  

## C  
Convert S.TIME struct to CSTR  
`size_t strftime (char* ptr, size_t maxsize, const char* format, const struct tm* timeptr );`  

## ASM  
**In:**  
PUSHW = Dst PTR To CSTR Buf  
PUSHW = Src PTR To Format String  
+ %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 = Src PTR To S.Time  
**Out:**  
  none. always succeed.