Apple-2-SW/A2osX

Fork 0

mirror of https://github.com/A2osX/A2osX.git synced 2024-11-26 13:49:18 +00:00

Rémy GIBERT f3853fec17 Kernel 0.93++

2020-01-24 15:21:08 +01:00

24 KiB

Raw Blame History

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

Copyright

ArgV

ASM

In:
A = argument index.

RETURN VALUE

CC : success
Y,A = PTR To Arg[A]
CS : Out Of Bound

LoadDrv

ASM

In:
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

In:
>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 = hDev

GetDevStatus

C

int getdevstatus(short int DevID, S.DIB* dstat);

ASM

>PUSHWI S.DIB
lda DevID
>SYSCALL GetDevStatus

RETURN VALUE

MKDev

Create a hDEV

C

hDEV mkdev (S.FD * fd, const char *devname)

ASM

>PUSHW devname
>LDYA fd
`>SYSCALL mkdev

RETURN VALUE

A = hDEV

OpenDir

C

int hDIR opendir (const char * dirpath);

ASM

>LDYA dirpath
>SYSCALL opendir

RETURN VALUE

CC : success
A = hDIR
CS : error
A = EC

ReadDir

C

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

ASM

>PUSHW dirent
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.

Expand

C

char *expand(const char *str, char *expanded);

ASM

In:
>PUSHW str
>PUSHW expanded
>SYSCALL expand

RETURN VALUE

Y,A = PTR to Expanded String
X = hMem to Expanded String (C-String)

PutEnv

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

C

int putenv(char *string);

ASM

In:
>PUSHW string
>SYSCALL putenv

RETURN VALUE

SetEnv

Change or add an environment variable

C

int setenv(const char *name, const char *value);

ASM

In:
>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

char *getenv(const char *name, char *value);

ASM

In:
>PUSHW name
>PUSHW value
>SYSCALL getenv

RETURN VALUE

CC : Y,A = PTR to VALUE (C-String)
CS : not found

UnsetEnv

Remove an environment variable

C

int unsetenv(const char *name);

ASM

In:
>PUSHW name
>SYSCALL unsetenv

RETURN VALUE

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

RETURN VALUE

ChOwn

In:
PUSHW = mod
PUSHW = PATH

ChGrp

In:
PUSHW = GID
PUSHW = PATH

Add32,Sub32,Mul32,IMul32,Div32,IDiv32,Mod32,IMod32,Cmp32,ICmp32

Return X+Y, X-Y, X*Y, X/Y, X mod Y....

ASM

In:
>PUSHF X (long)
>PUSHF Y (long)
>FPU add32
...

RETURN VALUE

On stack (long)

FAdd,FSub,FMult,FDiv,FPwr

Return X+Y, X-Y, X*Y, X/Y, X^Y

ASM

In:
>PUSHF X (float)
>PUSHF Y (float)
>FPU fadd
>FPU fsub
>FPU fmult
>FPU fdiv
>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

In:
>PUSHF x (Float)
>FPU log

RETURN VALUE

On stack (Float)

float

Return 'floated' long

C

`float f = (float)l;

ASM

In:
>PUSHL l (long)
>FPU float

RETURN VALUE

On stack (float)

lrintf

Return float rounded into a long

C

long int lrintf (float x);

ASM

In:
>PUSHF x
>FPU lrintf

RETURN VALUE

On stack (long)

IOCTL

C

int ioctl(short int DevID, int request, void * param );

ASM

PUSHWI param
PUSHBI request
lda hDEV
>SYSCALL IOCTL

RETURN VALUE

Y,A = ...

MD5

Return MD5 Hash for input String

C

void md5 (const char* str, char* digest);

ASM

>PUSHW str
>PUSHW digest
>SYSCALL md5

RETURN VALUE

MD5Init

Initialize a MD5 computation

C

hMD5 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

GetMem0

Y,A = Size Requested

RETURN VALUE

CC : success
YA = PTR to Mem (ZERO Initialised)

X = hMem
CS :
A = EC

GetMem

Y,A = Size Requested

RETURN VALUE

CC : success
YA = PTR to Mem (Uninitialised)

X = hMem
CS :
A = EC

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

LoadStkObj

Load a file in AUX memory (Stock Objects)
PUSHW = AUXTYPE (Handled by....
PUSHB = TYPE ...
PUSHB = MODE ...
LDYA = PATH ...FOpen)

RETURN VALUE

Y,A = File Length
X = hMem of Loaded Object in AUX mem

GetStkObjPtr

ASM

lda hStkObj
>SYSCALL GetStkObjPtr

RETURN VALUE

FreeStkObj

A = hMem To Free (AUX Memory)

RETURN VALUE

none.
(X,Y unmodified)

ExecL

C

int execl(const char* cmdline, short int flags);

ASM

>PUSHW cmdline
>PUSHB flags
>SYSCALL execl

RETURN VALUE

A = Child PSID

ExecV

C

int execv(const char* argv[], short int flags);

ASM

>PUSHB flags
>LDYA argv
>SYSCALL execv

RETURN VALUE

A = Child PSID

Kill

C

int kill(short int pid, short int sig);

ASM

>PUSHB sig
lda pid
>SYSCALL kill

RETURN VALUE

A = Child PSID

LoadTxtFile

Load TXT a file in memory (with ending 0)

C

int loadtxtfile ( const char * filename, short int flags, short int ftype, int auxtype );

ASM

In:
>PUSHW auxtype
>PUSHB ftype
>PUSHB flags
>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

In:
>PUSHW auxtype
>PUSHB ftype
>PUSHB flags
>LDYA filename
>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

In:
>PUSHWI filename
>PUSHWI fullpath
>PUSHWI searchpath
>PUSHWI filestat

RETURN VALUE

CC : success
DstBuf = FilePath
DstStat = S.STAT
CS : not found

GetMemStat

In:
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

>PUSHW passwd
lda uid
>SYSCALL getpwuid

RETURN VALUE

GetPWName

C

int getpwname(const char* name, S.PW* passwd );

ASM

>PUSHW passwd
>LDYA name
>SYSCALL getpwname

RETURN VALUE

PutPW

C

int putpw( S.PW* passwd );

ASM

>LDYA passwd
>SYSCALL putpw

RETURN VALUE

SListGetData

ASM

PUSHW DataOfs (Start offset in Data)
PUSHW DataLen (Data bytes to return, 0 if String mode)
PUSHW DataPtr (0 if KERNEL should allocate a buffer)
PUSHW KeyID
lda hSList
>SYSCALL SListGetData

RETURN VALUE

Y,A = Byte Count
X = hMem (if DataPtr = 0)

SListAddData

ASM

PUSHW DataLen
PUSHW DataPtr
PUSHW KeyID
lda hSList
>SYSCALL SListAddData

RETURN VALUE

SListSetData

ASM

PUSHW DataLen
PUSHW DataPtr
PUSHW KeyID
lda hSList
>SYSCALL SListSetData

RETURN VALUE

SListGetByID

ASM

PUSHW KeyPtr
PUSHW KeyID
lda hSList
>SYSCALL SListGetByID

RETURN VALUE

Y,A = Next KeyID

SListNewKey

ASM

PUSHW KeyPtr
lda hSList
>SYSCALL SListNewKey

RETURN VALUE

Y,A = KeyID
X = KeyLen

SListLookup

ASM

PUSHW KeyPtr
lda hSList
>SYSCALL SListLookup

RETURN VALUE

Y,A = KeyID
X = Key Length

SListNew

ASM

>SYSCALL SListNew

RETURN VALUE

A=hSList

SListFree

ASM

lda hSList
>SYSCALL SListFree

RETURN VALUE

Stat

Return information about a file

C

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

ASM

In:
>PUSHW statbuf
>LDYA pathname
>SYSCALL stat

RETURN VALUE

MKDir

create a directory

C

int mkdir(const char *pathname, int mode);

ASM

In:
>PUSHW mode
>LDYA pathname
>SYSCALL mkdir

RETURN VALUE

CC : success
CS : error
A = EC

MKFIFO

return a pathname to a new FIFO

C

int mkfifo( char *pathname, int mode );

ASM

In:
>PUSHW mode
>LDYA pathname
>SYSCALL mkfifo

RETURN VALUE

CC = OK, CS = ERROR
A = hFD

MkNod

Create a special or ordinary file.
(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

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

putchar (BLOCKING)

Print A (char) to StdOut

C

int putchar ( int character );

ASM

In:
lda character
>SYSCALL putchar

RETURN VALUE

CC = success

fputc (BLOCKING)

Print A (char) to hFILE

C

int fputc ( hFILE stream , int character );

ASM

In:
>PUSHB character
lda stream
>SYSCALL fputc

RETURN VALUE

CC = success

puts (BLOCKING)

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

C

int puts ( const char * str );
In:

ASM

>LDYAI str
>SYSCALL puts

RETURN VALUE

CC = success

fputs (BLOCKING)

Write Str to hFILE

C

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

ASM

In:
>PUSHW str
lda stream
>SYSCALL fputs

RETURN VALUE

CC = success

PrintF (BLOCKING)

FPrintF (BLOCKING)

SPrintF

Prints C-Style String

C

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

ASM

In:
PrintF : (example is for printing Y,A as integer : format="%I", 2 bytes)
>PUSHYA #I
>PUSHBI 2 #bytecount
...
>LDYAI format
>SYSCALL printf
FPrintF :
>PUSHYA #I
>PUSHBI 2 #bytecount
...
>PUSHWI format
lda hFILE
>SYSCALL fprintf
SPrintF :
>PUSHYA #I
>PUSHBI 2 #bytecount
...
>PUSHWI format
>LDYAI str
>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
\b : Print 'BS' (08)
\e : Print 'ESC' ($1B,27)
\f : Print 'FF' ($0C,12)
\n : Print 'LF' ($0A,10)
\r : Print 'CR' ($0D,13)
\t : Print 'TAB' ($09,09)
\v : Print 'VT' ($0B,11)
\xHH : Print byte with hexadecimal value HH (1 to 2 digits)
\\ : Print \
\% : Print %

Modifiers for len and padding :

%d : '9' '12'
%2d : ' 9' '12'
%02d : '09' '12'
%11s : 'ABCDEFGH '
%011s : 'ABCDEFGH000'
%2f : '3.14'

fgets (BLOCKING)

read bytes from stream into the array
pointed to by s, until n-1 bytes are read, or a 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

RETURN VALUE

Y,A: s
CC = success

getchar (BLOCKING)

Get char from StdIn

C

int getchar ();

ASM

In:
>SYSCALL getchar

RETURN VALUE

CC = success
A = char

getc (BLOCKING)

Get char from Node

C

int getc ( hFILE stream );

ASM

In:
lda stream
>SYSCALL getc

RETURN VALUE

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

RETURN VALUE

A = Number of arguments filled.

FOpen

Open a file

C

hFILE fopen ( const char * filename, short int flags, short int ftype, int auxtype );
In:

ASM

>PUSHWI auxtype
>PUSHBI ftype
>PUSHBI 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
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
>LDYAI filename

RETURN VALUE

CC : A = hFILE
CS : A = EC

FClose

Close a file

C

int fclose ( hFILE stream );

ASM

In:
lda stream
>SYSCALL fclose

RETURN VALUE

FRead (BLOCKING)

Read bytes from file

C

int fread (hFILE stream, void * ptr, int count );

ASM

In:
>PUSHWI count
>PUSHW ptr
lda stream
>SYSCALL fread

RETURN VALUE

Y,A = Bytes Read

FWrite (BLOCKING)

Write bytes to file

C

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

ASM

In:
>PUSHWI count
>PUSHW ptr
lda stream
>SYSCALL fwrite

RETURN VALUE

Y,A = Bytes Written

FFlush

C

int fflush(hFILE stream);

ASM

In:
lda stream
>SYSCALL fflush

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

C

int feof(hFILE stream);

ASM

In:
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(hFILE stream);

ASM

In:
lda stream
>SYSCALL ftell

RETURN VALUE

On stack (long)

Remove

Remove a file or directory

C

int remove(const char *pathname);

ASM

In:
>LDYA pathname
>SYSCALL remove

RETURN VALUE

Rename

Rename a file

C

int rename(const char *oldpath, const char *newpath);

ASM

In:
>PUSHW newpath
>LDYA oldpath
>SYSCALL rename

RETURN VALUE

strtof

Convert String to 40 bits Float

C

float strtof (const char* str, char** endptr);

ASM

In:
>PUSHWI EndPtr
>LDYA str
>SYSCALL strtof

RETURN VALUE

On stack (float)

AToF

Convert String to 40 bits Float

C

float atof (const char* str);

ASM

In:
>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

In:
>PUSHB Base
>PUSHWI EndPtr
>LDYAI str
>SYSCALL strtol

RETURN VALUE

On stack (long)

atol

Convert String to 32 bits long

C

long atol ( const char * str );

ASM

In:
>LDYA str
>SYSCALL atol

RETURN VALUE

On stack (long)

atoi

Convert String to 16 bits int

C

int atoi ( const char * str );

ASM

In:
>LDYAI str
>SYSCALL atoi

RETURN VALUE

Y,A = int

RealPath

Return the canonicalized absolute pathname

C

unsigned short int realpath (const char* str, char *resolvedpath);

ASM

In:
>PUSHWI resolvedpath
>LDYA str
>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

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

In:
>PUSHWI source
>LDYAI destination
>SYSCALL strcat

RETURN VALUE

Y,A = destination

StrCpy

Copy string

C

char * strcpy ( char * destination, const char * source );

ASM

In:
>PUSHWI source
>LDYAI destination
>SYSCALL strcpy

RETURN VALUE

Y,A = destination

StrDup

Create a new copy of this C-String
Y,A = Ptr to source C-String

RETURN VALUE

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

In:
>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

In:
>PUSHWI s2
>LDYAI s1
>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

In:
>PUSHWI s2
>LDYAI s1
>SYSCALL strcasecmp

RETURN VALUE

CC : match
CS : no match
CC, Y,A=0
CS, Y,A > 0 or < 0

NewStrV

In:
A = Initial Size (Page)

RETURN VALUE

X = hStrV
Y,A = Ptr

StrVGet

In:
A = hStrV
X = index

RETURN VALUE

Y,A = Ptr

StrVDup

In:
Y,A = Src StrV

RETURN VALUE

X = hMem of new StrV
A = Str Count

Str2StrV

Expand String and convert to ArgV List

C

short int str2strv(char* args, char* argv[])

ASM

>PUSHW argv
>LDYA args
>SYSCALL Str2StrV

RETURN VALUE

A = Arg count

Time

Get System Time in Buffer

C

int time (S.TIME* timer);

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 S.TIME* 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

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

ASM

>PUSHW ptime
>PUSHW timer
>SYSCALL PTime2Time

RETURN VALUE

CTime2Time

Convert CTime Time To S.TIME

C

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

ASM

>PUSHW ctime
>PUSHW timer
>SYSCALL CTime2Time

RETURN VALUE

open

C

hFD open(const char *pathname, short int flags);

ASM

In:
>PUSHB flags
>LDYA pathname
>SYSCALL open

RETURN VALUE

A = hFD
REG File 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

RETURN VALUE

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

RETURN VALUE

CC: Y,A = bytes written
CS: A = EC

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.

*** End of Auto generated file ***

24 KiB Raw Blame History

Copyright

ArgV

ASM

RETURN VALUE

LoadDrv

ASM

RETURN VALUE

InsDrv

C

ASM

RETURN VALUE

GetDevByName

RETURN VALUE

GetDevStatus

C

ASM

RETURN VALUE

MKDev

C

ASM

RETURN VALUE

OpenDir

C

ASM

RETURN VALUE

ReadDir

C

ASM

RETURN VALUE

CloseDir

C

ASM

RETURN VALUE

Expand

C

ASM

RETURN VALUE

PutEnv

C

ASM

RETURN VALUE

SetEnv

C

ASM

RETURN VALUE

GetEnv

C

ASM

RETURN VALUE

UnsetEnv

C

ASM

RETURN VALUE

ChTyp

C

ASM

RETURN VALUE

ChOwn

ChGrp

Add32,Sub32,Mul32,IMul32,Div32,IDiv32,Mod32,IMod32,Cmp32,ICmp32

ASM

RETURN VALUE

FAdd,FSub,FMult,FDiv,FPwr

ASM

RETURN VALUE

Log,Sqr,Exp,Cos,Sin,Tan,ATan

C

ASM

RETURN VALUE

float

C

ASM

RETURN VALUE

lrintf

C

ASM

RETURN VALUE

IOCTL

C

24 KiB

Raw Blame History