DEFINITION MODULE FOR "C" libc ;
FROM SYSTEM IMPORT ADDRESS, CSIZE_T, CSSIZE_T ;
EXPORT UNQUALIFIED time_t, timeb, tm, ptrToTM,
write, read,
system, abort,
malloc, free,
exit, isatty,
getenv, putenv, getpid,
dup, close, open, lseek,
readv, writev,
perror, creat,
getcwd, chown, strlen, strcpy, strncpy,
unlink, setenv,
memcpy, memset, memmove, printf, realloc,
rand, srand,
time, localtime, ftime,
shutdown, rename, setjmp, longjmp, atexit,
ttyname, sleep, execv ;
TYPE
time_t (type)
time_t = LONGINT ;
ptrToTM (type)
ptrToTM = POINTER TO tm ;
tm (type)
tm = RECORD
tm_sec: INTEGER ; (* Seconds. [0-60] (1 leap second) *)
tm_min: INTEGER ; (* Minutes. [0-59] *)
tm_hour: INTEGER ; (* Hours. [0-23] *)
tm_mday: INTEGER ; (* Day. [1-31] *)
tm_mon: INTEGER ; (* Month. [0-11] *)
tm_year: INTEGER ; (* Year - 1900. *)
tm_wday: INTEGER ; (* Day of week. [0-6] *)
tm_yday: INTEGER ; (* Days in year.[0-365] *)
tm_isdst: INTEGER ; (* DST. [-1/0/1] *)
tm_gmtoff: LONGINT ; (* Seconds east of UTC. *)
tm_zone: ADDRESS ; (* char * zone name *)
END (type)
END ;
timeb (type)
timeb = RECORD
time : time_t ;
millitm : SHORTCARD ;
timezone: SHORTCARD ;
dstflag : SHORTCARD ;
END (type)
END ;
exitP (type)
exitP = PROCEDURE () : INTEGER ;
(*
ssize_t write (int d, void *buf, size_t nbytes)
*)
write
PROCEDURE write (d: INTEGER; buf: ADDRESS; nbytes: CSIZE_T) : [ CSSIZE_T ] ;
(*
ssize_t read (int d, void *buf, size_t nbytes)
*)
read
PROCEDURE read (d: INTEGER; buf: ADDRESS; nbytes: CSIZE_T) : [ CSSIZE_T ] ;
(*
int system(string)
char *string;
*)
system
PROCEDURE system (a: ADDRESS) : [ INTEGER ] ;
(*
abort - generate a fault
abort() first closes all open files if possible, then sends
an IOT signal to the process. This signal usually results
in termination with a core dump, which may be used for
debugging.
It is possible for abort() to return control if is caught or
ignored, in which case the value returned is that of the
kill(2V) system call.
*)
abort
PROCEDURE abort <* noreturn *> ;
(*
malloc - memory allocator.
void *malloc(size_t size);
malloc() returns a pointer to a block of at least size
bytes, which is appropriately aligned. If size is zero,
malloc() returns a non-NULL pointer, but this pointer should
not be dereferenced.
*)
malloc
PROCEDURE malloc (size: CSIZE_T) : ADDRESS ;
(*
free - memory deallocator.
free (void *ptr);
free() releases a previously allocated block. Its argument
is a pointer to a block previously allocated by malloc,
calloc, realloc, malloc, or memalign.
*)
free
PROCEDURE free (ptr: ADDRESS) ;
(*
void *realloc (void *ptr, size_t size);
realloc changes the size of the memory block pointed to
by ptr to size bytes. The contents will be unchanged to
the minimum of the old and new sizes; newly allocated memory
will be uninitialized. If ptr is NIL, the call is
equivalent to malloc(size); if size is equal to zero, the
call is equivalent to free(ptr). Unless ptr is NIL, it
must have been returned by an earlier call to malloc(),
realloc.
*)
realloc
PROCEDURE realloc (ptr: ADDRESS; size: CSIZE_T) : ADDRESS ;
(*
isatty - does this descriptor refer to a terminal.
*)
isatty
PROCEDURE isatty (fd: INTEGER) : INTEGER ;
(*
exit - returns control to the invoking process. Result, r, is
returned.
*)
exit
PROCEDURE exit (r: INTEGER) <* noreturn *> ;
(*
getenv - returns the C string for the equivalent C environment
variable.
*)
getenv
PROCEDURE getenv (s: ADDRESS) : ADDRESS ;
(*
putenv - change or add an environment variable.
*)
putenv
PROCEDURE putenv (s: ADDRESS) : INTEGER ;
(*
getpid - returns the UNIX process identification number.
*)
getpid
PROCEDURE getpid () : INTEGER ;
(*
dup - duplicates the file descriptor, d.
*)
dup
PROCEDURE dup (d: INTEGER) : INTEGER ;
(*
close - closes the file descriptor, d.
*)
close
PROCEDURE close (d: INTEGER) : [ INTEGER ] ;
(*
open - open the file, filename with flag and mode.
*)
open
PROCEDURE open (filename: ADDRESS; oflag: INTEGER; ...) : INTEGER ;
(*
creat - creates a new file
*)
creat
PROCEDURE creat (filename: ADDRESS; mode: CARDINAL) : INTEGER;
(*
lseek - calls unix lseek:
off_t lseek(int fildes, off_t offset, int whence);
*)
lseek
PROCEDURE lseek (fd: INTEGER; offset: LONGINT; whence: INTEGER) : LONGINT ;
(*
perror - writes errno and string. (ARRAY OF CHAR is translated onto ADDRESS).
*)
perror
PROCEDURE perror (string: ARRAY OF CHAR);
(*
readv - reads an io vector of bytes.
*)
readv
PROCEDURE readv (fd: INTEGER; v: ADDRESS; n: INTEGER) : [ INTEGER ] ;
(*
writev - writes an io vector of bytes.
*)
writev
PROCEDURE writev (fd: INTEGER; v: ADDRESS; n: INTEGER) : [ INTEGER ] ;
(*
getcwd - copies the absolute pathname of the
current working directory to the array pointed to by buf,
which is of length size.
If the current absolute path name would require a buffer
longer than size elements, NULL is returned, and errno is
set to ERANGE; an application should check for this error,
and allocate a larger buffer if necessary.
*)
getcwd
PROCEDURE getcwd (buf: ADDRESS; size: CSIZE_T) : ADDRESS ;
(*
chown - The owner of the file specified by path or by fd is
changed. Only the super-user may change the owner of a
file. The owner of a file may change the group of the
file to any group of which that owner is a member. The
super-user may change the group arbitrarily.
If the owner or group is specified as -1, then that ID is
not changed.
On success, zero is returned. On error, -1 is returned,
and errno is set appropriately.
*)
chown
PROCEDURE chown (filename: ADDRESS; uid, gid: INTEGER) : [ INTEGER ] ;
(*
strlen - returns the length of string, a.
*)
strlen
PROCEDURE strlen (a: ADDRESS) : CSIZE_T ;
(*
strcpy - copies string, src, into, dest.
It returns dest.
*)
strcpy
PROCEDURE strcpy (dest, src: ADDRESS) : [ ADDRESS ] ;
(*
strncpy - copies string, src, into, dest, copying at most, n, bytes.
It returns dest.
*)
strncpy
PROCEDURE strncpy (dest, src: ADDRESS; n: CARDINAL) : [ ADDRESS ] ;
(*
unlink - removes file and returns 0 if successful.
*)
unlink
PROCEDURE unlink (file: ADDRESS) : [ INTEGER ] ;
(*
memcpy - copy memory area
SYNOPSIS
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);
It returns dest.
*)
memcpy
PROCEDURE memcpy (dest, src: ADDRESS; size: CSIZE_T) : [ ADDRESS ] ;
(*
memset - fill memory with a constant byte
SYNOPSIS
#include <string.h>
void *memset(void *s, int c, size_t n);
It returns s.
*)
memset
PROCEDURE memset (s: ADDRESS; c: INTEGER; size: CSIZE_T) : [ ADDRESS ] ;
(*
memmove - copy memory areas which may overlap
SYNOPSIS
#include <string.h>
void *memmove(void *dest, const void *src, size_t n);
It returns dest.
*)
memmove
PROCEDURE memmove (dest, src: ADDRESS; size: CSIZE_T) : [ ADDRESS ] ;
(*
int printf(const char *format, ...);
*)
printf
PROCEDURE printf (format: ARRAY OF CHAR; ...) : [ INTEGER ] ;
(*
setenv - sets environment variable, name, to value.
It will overwrite an existing value if, overwrite,
is true. It returns 0 on success and -1 for an error.
*)
setenv
PROCEDURE setenv (name: ADDRESS; value: ADDRESS; overwrite: INTEGER) : [ INTEGER ] ;
(*
srand - initialize the random number seed.
*)
srand
PROCEDURE srand (seed: INTEGER) ;
(*
rand - return a random integer.
*)
rand
PROCEDURE rand () : INTEGER ;
(*
time - returns a pointer to the time_t value. If, a,
is not NIL then the libc value is copied into
memory at address, a.
*)
time
PROCEDURE time (a: ADDRESS) : time_t ;
(*
localtime - returns a pointer to the libc copy of the tm
structure.
*)
localtime
PROCEDURE localtime (VAR t: time_t) : ADDRESS ;
(*
ftime - return date and time.
*)
ftime
PROCEDURE ftime (VAR t: timeb) : [ INTEGER ] ;
(*
shutdown - shutdown a socket, s.
if how = 0, then no more reads are allowed.
if how = 1, then no more writes are allowed.
if how = 2, then mo more reads or writes are allowed.
*)
shutdown
PROCEDURE shutdown (s: INTEGER; how: INTEGER) : [ INTEGER ] ;
(*
rename - change the name or location of a file
*)
rename
PROCEDURE rename (oldpath, newpath: ADDRESS) : [ INTEGER ] ;
(*
setjmp - returns 0 if returning directly, and non-zero
when returning from longjmp using the saved
context.
*)
setjmp
PROCEDURE setjmp (env: ADDRESS) : INTEGER ;
(*
longjmp - restores the environment saved by the last call
of setjmp with the corresponding env argument.
After longjmp is completed, program execution
continues as if the corresponding call of setjmp
had just returned the value val. The value of
val must not be zero.
*)
longjmp
PROCEDURE longjmp (env: ADDRESS; val: INTEGER) ;
(*
atexit - execute, proc, when the function exit is called.
*)
atexit
PROCEDURE atexit (proc: exitP) : [ INTEGER ] ;
(*
ttyname - returns a pointer to a string determining the ttyname.
*)
ttyname
PROCEDURE ttyname (filedes: INTEGER) : ADDRESS ;
(*
sleep - calling thread sleeps for seconds.
*)
sleep
PROCEDURE sleep (seconds: CARDINAL) : [ CARDINAL ] ;
(*
execv - execute a file.
*)
execv
PROCEDURE execv (pathname: ADDRESS; argv: ADDRESS) : [ INTEGER ] ;
END libc.