DIRECTORY
ProcessorFace USING [GetProcessorType],
UnixSysCalls,
UnixTypes
;

UnixSysCallsImpl: CEDAR PROGRAM
IMPORTS ProcessorFace
EXPORTS UnixSysCalls
~ { OPEN UnixTypes;

Accept: PUBLIC UNSAFE PROC [s: FD, addr: SockAddrPtr, addrLen: INTPtr] RETURNS [FD] ~ UNCHECKED {
accept: UNSAFE PROC [s: FD, addr: SockAddrPtr, addrLen: INTPtr] RETURNS [FD] ~ UNCHECKED MACHINE CODE {
"XR_Accept"
};
RETURN[ accept[s, addr, addrLen] ];
};

Access: PUBLIC PROC [path: CHARPtr, mode: Mode] RETURNS [RES] ~ TRUSTED {
access: PROC [path: CHARPtr, mode: Mode] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Access"
};
RETURN[ access[path, mode] ];
};


Bind: PUBLIC PROC [s: FD, name: SockAddrPtr, nameLen: INT] RETURNS [RES] ~ {
bind: PROC [s: FD, name: SockAddrPtr, nameLen: INT] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Bind"
};
RETURN[ bind[s, name, nameLen] ];
};


ChMod: PUBLIC PROC [path: CHARPtr, mode: Mode] RETURNS [RES] ~ {
chmod: PROC [path: CHARPtr, mode: Mode] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_ChMod"
};
RETURN[ chmod[path, mode] ];
};

FChMod: PUBLIC PROC [fd: FD, mode: Mode] RETURNS [RES] ~ {
fchmod: PROC [fd: FD, mode: Mode] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_FChMod"
};
RETURN[ fchmod[fd, mode] ];
};


Close: PUBLIC PROC [fd: FD] RETURNS [RES] ~ {
close: PROC [fd: FD] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Close"
};
RETURN[ close[fd] ];
};

Connect: PUBLIC PROC [s: FD, name: SockAddrPtr, nameLen: INT] RETURNS [RES] ~ {
connect: PROC [s: FD, name: SockAddrPtr, nameLen: INT] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Connect"
};
RETURN[ connect[s, name, nameLen] ];
};



FCntl: PUBLIC PROC [fd: FD, cmd: INT, arg: INT] RETURNS [RES] ~ {
fcntl: PROC [fd: FD, cmd: INT, arg: INT] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_FCntl"
};
RETURN[ fcntl[fd, cmd, arg] ];
};

FCntl4: PUBLIC PROC [fd: FD, cmd: INT, arg: INT, doInIOP: BOOL] RETURNS [RES] ~ {
fcntl4: PROC [fd: FD, cmd: INT, arg: INT, doInIOP: BOOL] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_FCntl4"
};
RETURN[ fcntl4[fd, cmd, arg, doInIOP] ];
};




FSync: PUBLIC PROC [fd: FD] RETURNS [RES] ~ {
fsync: PROC [fd: FD] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_FSync"
};
RETURN[ fsync[fd] ];
};

GetDEnts: PUBLIC UNSAFE PROC [fd: FD, buf: CHARPtr, nBytes: INT] RETURNS [INT] ~ UNCHECKED {
getdents: UNSAFE PROC [fd: FD, buf: CHARPtr, nBytes: INT] RETURNS [INT] ~ UNCHECKED MACHINE CODE {
"XR_GetDEnts"
};
RETURN[ getdents[fd, buf, nBytes] ];
};


GetDomainName: PUBLIC UNSAFE PROC [name: CHARPtr, nameLen: INT] RETURNS [RES] ~ UNCHECKED {
getdomainname: UNSAFE PROC [name: CHARPtr, nameLen: INT] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_GetDomainName"
};
RETURN[ getdomainname[name, nameLen] ];
};

GetDTableSize: PUBLIC PROC RETURNS [INT] ~ {
getdtablesize: PROC RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_GetDTableSize"
};
RETURN[ getdtablesize[] ];
};

GetGID: PUBLIC PROC RETURNS [GID] ~ {
getgid: PROC RETURNS [GID] ~ TRUSTED MACHINE CODE {
"XR_GetGID"
};
RETURN[ getgid[] ];
};

GetEGID: PUBLIC PROC RETURNS [GID] ~ {
getegid: PROC RETURNS [GID] ~ TRUSTED MACHINE CODE {
"XR_GetEGID"
};
RETURN[ getegid[] ];
};

GetGroups: PUBLIC UNSAFE PROC [gidSetLen: INT, gidSet: GIDsPtr] RETURNS [nGroups: INT] ~ UNCHECKED {
getgroups: UNSAFE PROC [gidSetLen: INT, gidSet: GIDsPtr] RETURNS [INT] ~ UNCHECKED MACHINE CODE {
"XR_GetGroups"
};
RETURN[ getgroups[gidSetLen, gidSet] ];
};


GetHostID: PUBLIC PROC RETURNS [INT] ~ {
gethostid: PROC RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_GetHostID"
};
RETURN[ gethostid[] ];
};

GetHostName: PUBLIC UNSAFE PROC [name: CHARPtr, nameLen: INT] RETURNS [RES] ~ UNCHECKED {
gethostname: UNSAFE PROC [name: CHARPtr, nameLen: INT] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_GetHostName"
};
RETURN[ gethostname[name, nameLen] ];
};


GetMsg: PUBLIC UNSAFE PROC [fd: FD, ctlPtr, dataPtr: StrBufPtr, flags: POINTER TO RSFlags] RETURNS [GetResult] ~ UNCHECKED {
getmsg: UNSAFE PROC [fd: FD, ctlPtr, dataPtr: StrBufPtr, flags: POINTER TO RSFlags] RETURNS [GetResult] ~ UNCHECKED MACHINE CODE {
"XR_GetMsg"
};
RETURN[ getmsg[fd, ctlPtr, dataPtr, flags] ];
};

GetPageSize: PUBLIC PROC RETURNS [INT] ~ {
getpagesize: PROC RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_GetPageSize"
};
RETURN[ getpagesize[] ];
};

GetPeerName: PUBLIC UNSAFE PROC [s: FD, name: SockAddrPtr, nameLen: INTPtr] RETURNS [RES] ~ UNCHECKED {
getpeername: UNSAFE PROC [s: FD, name: SockAddrPtr, nameLen: INTPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_GetPeerName"
};
RETURN[ getpeername[s, name, nameLen] ];
};

GetPID: PUBLIC PROC RETURNS [INT] ~ {
getpid: PROC RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_GetPID"
};
RETURN[ getpid[] ];
};

GetPPID: PUBLIC PROC RETURNS [INT] ~ {
getppid: PROC RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_GetPPID"
};
RETURN[ getppid[] ];
};



RUsagePtr: TYPE = LONG POINTER TO RUsage;

GetRUsage: PUBLIC UNSAFE PROC [who: Who, rusage: RUsagePtr] RETURNS [RES] ~ UNCHECKED {
getrusage: UNSAFE PROC [who: Who, rusage: RUsagePtr] RETURNS [RES] ~ MACHINE CODE {
"XR_GetRUsage"};
RETURN[ getrusage[who, rusage] ];
};

GetSockName: PUBLIC UNSAFE PROC [s: FD, name: SockAddrPtr, nameLen: INTPtr] RETURNS [RES] ~ UNCHECKED {
getsockname: UNSAFE PROC [s: FD, name: SockAddrPtr, nameLen: INTPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_GetSockName"
};
RETURN[ getsockname[s, name, nameLen] ];
};

GetSockOpt: PUBLIC UNSAFE PROC [s: FD, level: INT, optName: INT, optVal: CHARPtr, optLen: INTPtr] RETURNS [RES] ~ UNCHECKED {
getsockopt: UNSAFE PROC [s: FD, level: INT, optName: INT, optVal: CHARPtr, optLen: INTPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_GetSockOpt"
};
RETURN[ getsockopt[s, level, optName, optVal, optLen] ];
};

SetSockOpt: PUBLIC PROC [s: FD, level: INT, optName: INT, optVal: CHARPtr, optLen: INT] RETURNS [RES] ~ {
setsockopt: PROC [s: FD, level: INT, optName: INT, optVal: CHARPtr, optLen: INT] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_SetSockOpt"
};
RETURN[ setsockopt[s, level, optName, optVal, optLen] ];
};


GetTimeOfDay: PUBLIC UNSAFE PROC [tp: TimeValPtr, tzp: TimeZonePtr] RETURNS [RES] ~ UNCHECKED {
gettimeofday: UNSAFE PROC [tp: TimeValPtr, tzp: TimeZonePtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_GetTimeOfDay"
};
RETURN[ gettimeofday[tp, tzp] ];
};


GetUID: PUBLIC PROC RETURNS[UID] ~ {
getuid: PROC RETURNS [UID] ~ TRUSTED MACHINE CODE {
"XR_GetUID"
};
RETURN[ getuid[] ];
};

GetEUID: PUBLIC PROC RETURNS[UID] ~ {
geteuid: PROC RETURNS [UID] ~ TRUSTED MACHINE CODE {
"XR_GetEUID"
};
RETURN[ geteuid[] ];
};

IOCtl: PUBLIC UNSAFE PROC [d: FD, request: INT, argp: CHARPtr] RETURNS [RES] ~ UNCHECKED {
ioctl: UNSAFE PROC [d: FD, request: INT, argp: CHARPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_IOCtl"
};
RETURN[ ioctl[d, request, argp] ];
};

IOCtl4: PUBLIC UNSAFE PROC [d: FD, request: INT, argp: CHARPtr, doInIOP: BOOL] RETURNS [RES] ~ {
ioctl4: PROC [d: FD, request: INT, argp: CHARPtr, doInIOP: BOOL] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_IOCtl4"
};
RETURN[ ioctl4[d, request, argp, doInIOP] ];
};

Kill: PUBLIC PROC [pid: PID, sig: Signal] RETURNS [RES] ~ {
kill: PROC [pid: PID, sig: Signal] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Kill"
};
RETURN[ kill[pid, sig] ];
};

KillPG: PUBLIC PROC [pgrp: PGRP, sig: Signal] RETURNS [RES] ~ {
killpg: PROC [pgrp: PGRP, sig: Signal] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_KillPG"
};
RETURN[ killpg[pgrp, sig] ];
};

Link: PUBLIC PROC [name1, name2: CHARPtr] RETURNS [RES] ~ {
link: PROC [name1, name2: CHARPtr] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Link"
};
RETURN[ link[name1, name2] ];
};

Listen: PUBLIC PROC [s: FD, backlog: INT] RETURNS [RES] ~ {
listen: PROC [s: FD, backlog: INT] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Listen"
};
RETURN[ listen[s, backlog] ];
};

LSeek: PUBLIC PROC [d: FD, offset: INT, whence: Whence] RETURNS [INT] ~ {
lseek: PROC [d: FD, offset: INT, whence: Whence] RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_LSeek"
};
RETURN[ lseek[d, offset, whence] ];
};

MInCore: PUBLIC UNSAFE PROC [addr: CHARPtr, len: INT, vec: CHARPtr] RETURNS [RES] ~ UNCHECKED {
mincore: UNSAFE PROC [addr: CHARPtr, len: INT, vec: CHARPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_MInCore"
};
RETURN[ mincore[addr, len, vec] ];
};

MkDir: PUBLIC PROC [path: CHARPtr, mode: Mode] RETURNS [RES] ~ {
mkdir: PROC [path: CHARPtr, mode: Mode] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_MkDir"
};
RETURN[ mkdir[path, mode] ];
};

MkNod: PUBLIC PROC [path: CHARPtr, mode: Mode, dev: INT] RETURNS [RES] ~ {
mknod: PROC [path: CHARPtr, mode: Mode, dev: INT] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_MkNod"
};
RETURN[ mknod[path, mode, dev] ];
};

MMap: PUBLIC UNSAFE PROC [addr: RawVM, nbytes: CARD, prot: Protections, flags: MMapFlags, d: FD, offset: CARD] RETURNS [RES] ~ {
mmap: PROC [addr: RawVM, nbytes: CARD, prot: Protections, flags: INT, d: FD, offset: CARD] RETURNS [RawVM] ~ TRUSTED MACHINE CODE {
"<sys/mman.h>.XR_MMap" -- the proc is really in <xr/UIO.h>, but the constants we need are in <sys/mman.h>
};
ConstructMMapFlags: PROC [shared, private, fixed: BOOL] RETURNS [INT] ~ TRUSTED MACHINE CODE {
"+#define CONSTRUCT_MMAP_FLAGS(shared, private, fixed) ( ((word)(shared))*((word)(MAP_SHARED)) + ((word)(private))*((word)(MAP_PRIVATE)) + ((word)(fixed))*((word)(MAP_FIXED)))\n";
".CONSTRUCT_MMAP_FLAGS";
};
RETURN[ IF mmap[addr, nbytes, prot, ConstructMMapFlags[shared: flags.shared, private: flags.private, fixed: flags.fixed], d, offset] = addr THEN success ELSE failure ];
};

MUnmap: PUBLIC UNSAFE PROC [addr: RawVM, nbytes: CARD] RETURNS [RES] ~ {
munmap: PROC [addr: RawVM, nbytes: CARD] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_MUnmap"
};
RETURN[ munmap[addr, nbytes] ];
};

MProtect: PUBLIC UNSAFE PROC [addr: RawVM, nbytes: CARD, prot: Protections] RETURNS [RES] ~ {
mprotect: PROC [addr: RawVM, nbytes: CARD, prot: Protections] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_MProtect"
};
RETURN[ mprotect[addr, nbytes, prot] ];
};

MSync: PUBLIC UNSAFE PROC [addr: RawVM, nbytes: CARD, flags: MSyncFlags] RETURNS [RES] ~ {
msync: PROC [addr: RawVM, nbytes: CARD, flags: MSyncFlags] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_MSync"
};
RETURN[ msync[addr, nbytes, flags] ];
};




Open: PUBLIC PROC [path: CHARPtr, flags: FileFlags, mode: Mode] RETURNS [FD] ~ {
open: PROC [path: CHARPtr, flags: FileFlags, mode: Mode] RETURNS [FD] ~ TRUSTED MACHINE CODE {
"XR_Open"
};
RETURN[ open[path, flags, mode] ];
};

Poll: PUBLIC UNSAFE PROC [fds: POINTER TO PollFD, nfds: CARD, timeout: INT] RETURNS [selected: INT]
 ~ UNCHECKED {
poll: UNSAFE PROC [fds: POINTER TO PollFD, nfds: CARD, timeout: INT] RETURNS [INT] ~ UNCHECKED MACHINE CODE {
"XR_Poll"
};
RETURN[ poll[fds, nfds, timeout] ];
};
Profil: PUBLIC UNSAFE PROC[buf: CHARPtr, bufSize: INT, offset: INT, scale: INT] RETURNS [RES]
 ~ UNCHECKED {
profil: UNSAFE PROC [buf: CHARPtr, bufSize: INT, offset: INT, scale: INT] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_Profil"
};
RETURN[ profil[buf, bufSize, offset, scale] ];
};

PutMsg: PUBLIC PROC [fd: FD, ctlPtr, dataPtr: StrBufPtr, flags: RSFlags] RETURNS [RES] ~ {
putmsg: PROC [fd: FD, ctlPtr, dataPtr: StrBufPtr, flags: RSFlags] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_PutMsg"
};
RETURN[ putmsg[fd, ctlPtr, dataPtr, flags] ];
};



Read: PUBLIC UNSAFE PROC [d: FD, buf: CHARPtr, nBytes: INT] RETURNS [INT] ~ UNCHECKED {
read: UNSAFE PROC [d: FD, buf: CHARPtr, nBytes: INT] RETURNS [INT] ~ UNCHECKED MACHINE CODE {
"XR_Read"
};
RETURN[ read[d, buf, nBytes] ];
};

ReadV: PUBLIC UNSAFE PROC [d: FD, iov: IOVecPtr, iovCnt: INT] RETURNS [INT] ~ UNCHECKED {
readv: UNSAFE PROC [d: FD, iov: IOVecPtr, iovCnt: INT] RETURNS [INT] ~ UNCHECKED MACHINE CODE {
"XR_ReadV"
};
RETURN[ readv[d, iov, iovCnt] ];
};

ReadLink: PUBLIC UNSAFE PROC [path: CHARPtr, buf: CHARPtr, bufSize: INT] RETURNS [INT] ~ UNCHECKED {
readlink: UNSAFE PROC [path: CHARPtr, buf: CHARPtr, bufSize: INT] RETURNS [INT] ~ UNCHECKED MACHINE CODE {
"XR_ReadLink"
};
RETURN[ readlink[path, buf, bufSize] ];
};


Recv: PUBLIC UNSAFE PROC [fd: FD, buf: CHARPtr, len: INT, flags: MsgFlags] RETURNS [INT] ~ UNCHECKED {
recv: UNSAFE PROC [fd: FD, buf: CHARPtr, len: INT, flags: MsgFlags] RETURNS [INT] ~ UNCHECKED MACHINE CODE {
"XR_Recv"
};
RETURN[ recv[fd, buf, len, flags] ];
};

RecvFrom: PUBLIC UNSAFE PROC [fd: FD, buf: CHARPtr, len: INT, flags: MsgFlags, from: SockAddrPtr, fromLen: INTPtr] RETURNS [INT] ~ UNCHECKED {
recvfrom: UNSAFE PROC [fd: FD, buf: CHARPtr, len: INT, flags: MsgFlags, from: SockAddrPtr, fromLen: INTPtr] RETURNS [INT] ~ UNCHECKED MACHINE CODE {
"XR_RecvFrom"
};
RETURN[ recvfrom[fd, buf, len, flags, from, fromLen] ];
};


Rename: PUBLIC PROC [from, to: CHARPtr] RETURNS [RES] ~ {
rename: PROC [from, to: CHARPtr] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Rename"
};
RETURN[ rename[from, to] ];
};

RmDir: PUBLIC PROC [path: CHARPtr] RETURNS [RES] ~ {
rmdir: PROC [path: CHARPtr] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_RmDir"
};
RETURN[ rmdir[path] ];
};


Send: PUBLIC PROC [s: FD, msg: CHARPtr, len: INT, flags: MsgFlags] RETURNS [INT] ~ {
send: PROC [s: FD, msg: CHARPtr, len: INT, flags: MsgFlags] RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_Send"
};
RETURN[ send[s, msg, len, flags] ];
};

SendTo: PUBLIC PROC [s: FD, msg: CHARPtr, len: INT, flags: MsgFlags, to: SockAddrPtr, toLen: INT] RETURNS [INT] ~ {
sendto: PROC [s: FD, msg: CHARPtr, len: INT, flags: MsgFlags, to: SockAddrPtr, toLen: INT] RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_SendTo"
};
RETURN[ sendto[s, msg, len, flags, to, toLen] ];
};



GetPGrp: PUBLIC PROC [pid: PID] RETURNS [PGRP] ~ {
getpgrp: PROC [pid: PID] RETURNS [PGRP] ~ TRUSTED MACHINE CODE {
"XR_GetPGrp"
};
RETURN[ getpgrp[pid] ];
};



ShmGet: PUBLIC PROC [key: SharedMemoryKey, size: INT, shmflg: ShmGetFlags] RETURNS [shmId: SharedMemoryIdentifier] = {
shmget: PROC [key: SharedMemoryKey, size: INT, shmflg: ShmGetFlags] RETURNS [shmId: SharedMemoryIdentifier] = TRUSTED MACHINE CODE {
"XR_ShmGet"
};
RETURN [shmget[key, size, shmflg]]
};

ShmCtl: PUBLIC PROC [shmId: SharedMemoryIdentifier, cmd: IPCCtlCmd, buf: POINTER TO ShmIdDs] RETURNS [SysCallResult] = {
shmctl: PROC [shmId: SharedMemoryIdentifier, cmd: IPCCtlCmd, buf: POINTER TO ShmIdDs] RETURNS [SysCallResult] = TRUSTED MACHINE CODE {
"XR_ShmCtl"
};
RETURN[shmctl[shmId, cmd, buf]]
};

ShmAt: PUBLIC UNSAFE PROC [id: SharedMemoryIdentifier, addr: RawVM, flags: ShmAtFlags] RETURNS [INT] = UNCHECKED {
shmat: UNSAFE PROC [id: SharedMemoryIdentifier, addr: RawVM, flags: ShmAtFlags] RETURNS [INT] = MACHINE CODE {
"XR_ShmAt"
};
IF addr = NIL THEN ERROR; -- caller bug - PCR requires an explicit address
RETURN[shmat[id, addr, flags]]
};

ShmDt: PUBLIC UNSAFE PROC [addr: RawVM] RETURNS [SysCallResult] = UNCHECKED {
shmdt: UNSAFE PROC [addr: RawVM] RETURNS [SysCallResult] = MACHINE CODE {
"XR_ShmDt"
};
RETURN[shmdt[addr]]
};

Shutdown: PUBLIC PROC [s: FD, how: SDHow] RETURNS [RES] ~ {
shutdown: PROC [s: FD, how: SDHow] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Shutdown"
};
RETURN[ shutdown[s, how] ];
};


Socket: PUBLIC PROC [af: AddressFamily, type: SocketType, protocol: ProtocolFamily] RETURNS [FD] ~ {
socket: PROC [af: AddressFamily, type: SocketType, protocol: ProtocolFamily] RETURNS [FD] ~ TRUSTED MACHINE CODE {
"XR_Socket"
};
RETURN[ socket[af, type, protocol] ];
};


Stat: PUBLIC UNSAFE PROC [path: CHARPtr, buf: StatPtr] RETURNS [RES] ~ UNCHECKED {
stat4: UNSAFE PROC [path: CHARPtr, buf: StatPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_Stat"
};
stat3: UNSAFE PROC [path: CHARPtr, buf: Stat3Ptr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_Stat"
};
SELECT ProcessorFace.GetProcessorType[] FROM
sun4 => RETURN[ stat4[path, buf] ];
sun3 => {
buf3: Stat3;
res: RES ¬  stat3[path, @buf3];
AssignStat[buf, @buf3];
RETURN[res];
}
ENDCASE => ERROR;
};

LStat: PUBLIC UNSAFE PROC [path: CHARPtr, buf: StatPtr] RETURNS [RES] ~ UNCHECKED {
lstat4: UNSAFE PROC [path: CHARPtr, buf: StatPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_LStat"
};
lstat3: UNSAFE PROC [path: CHARPtr, buf: Stat3Ptr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_LStat"
};
SELECT ProcessorFace.GetProcessorType[] FROM
sun4 => RETURN[ lstat4[path, buf] ];
sun3 => {
buf3: Stat3;
res: RES ¬  lstat3[path, @buf3];
AssignStat[buf, @buf3];
RETURN[res];
}
ENDCASE => ERROR;
};

FStat: PUBLIC UNSAFE PROC [fd: FD, buf: StatPtr] RETURNS [RES] ~ UNCHECKED {
fstat4: UNSAFE PROC [fd: FD, buf: StatPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_FStat"
};
fstat3: UNSAFE PROC [fd: FD, buf: Stat3Ptr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_FStat"
};
SELECT ProcessorFace.GetProcessorType[] FROM
sun4 => RETURN[ fstat4[fd, buf] ];
sun3 => {
buf3: Stat3;
res: RES ¬  fstat3[fd, @buf3];
AssignStat[buf, @buf3];
RETURN[res];
}
ENDCASE => ERROR;
};

StatFS: PUBLIC UNSAFE PROC [path: CHARPtr, buf: StatFSPtr] RETURNS [RES] ~ UNCHECKED {
statfs: UNSAFE PROC [path: CHARPtr, buf: StatFSPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_StatFS"
};
RETURN[ statfs[path, buf] ];
};

FStatFS: PUBLIC UNSAFE PROC [fd: FD, buf: StatFSPtr] RETURNS [RES] ~ UNCHECKED {
fstatfs: UNSAFE PROC [fd: FD, buf: StatFSPtr] RETURNS [RES] ~ UNCHECKED MACHINE CODE {
"XR_FStatFS"
};
RETURN[ fstatfs[fd, buf] ];
};


SymLink: PUBLIC PROC [name1, name2: CHARPtr] RETURNS [RES] ~ {
symlink: PROC [name1, name2: CHARPtr] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_SymLink"
};
RETURN[ symlink[name1, name2] ];
};

Sync: PUBLIC PROC RETURNS [RES] ~ {
sync: PROC RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Sync"
};
RETURN[ sync[] ];
};


Truncate: PUBLIC PROC [path: CHARPtr, length: CARD] RETURNS [RES] ~ {
truncate: PROC [path: CHARPtr, length: CARD] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Truncate"
};
RETURN[ truncate[path, length] ];
};

FTruncate: PUBLIC PROC [fd: FD, length: CARD] RETURNS [RES] ~ {
ftruncate: PROC [fd: FD, length: CARD] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_FTruncate"
};
RETURN[ ftruncate[fd, length] ];
};


Unlink: PUBLIC PROC [path: CHARPtr] RETURNS [RES] ~ {
unlink: PROC [path: CHARPtr] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_Unlink"
};
RETURN[ unlink[path] ];
};


UTimes: PUBLIC PROC [file: CHARPtr, tvp: FileTimesPtr] RETURNS [RES] ~ {
utimes: PROC [file: CHARPtr, tvp: FileTimesPtr] RETURNS [RES] ~ TRUSTED MACHINE CODE {
"XR_UTimes"
};
RETURN[ utimes[file, tvp] ];
};



Write: PUBLIC PROC [d: FD, buf: CHARPtr, nBytes: INT] RETURNS [INT] ~ {
write: PROC [d: FD, buf: CHARPtr, nBytes: INT] RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_Write"
};
RETURN[ write[d, buf, nBytes] ];
};

WriteV: PUBLIC PROC [d: FD, iov: IOVecPtr, iovCnt: INT] RETURNS [INT] ~ {
writev: PROC [d: FD, iov: IOVecPtr, iovCnt: INT] RETURNS [INT] ~ TRUSTED MACHINE CODE {
"XR_WriteV"
};
RETURN[ writev[d, iov, iovCnt] ];
};


Stat3Ptr: TYPE = POINTER TO Stat3;
Stat3: TYPE = WORD16 MACHINE DEPENDENT RECORD [
dev: Dev,		-- device inode resides on
ino: INum,		-- this inode's number
mode: Mode,	-- protection
nlink: INT16,	-- number of hard links to the file
uid: UID,		-- user ID of owner
gid: GID,		-- group ID of owner
rdev: Dev,		-- the device type, for inode that is device
size: CARD32,	-- total size of file, in bytes
atime: Time,		-- file last access time
spare1: INT32, 
mtime: Time,	-- file last modify time
spare2: INT32,
ctime: Time,		-- file last status change time
spare3: INT32,
blksize: CARD32,	-- optimal blocksize for file system i/o ops
blocks: CARD32,	-- actual number of blocks allocated
spare4: ARRAY [0..2) OF INT32
]; 

AssignStat: PRIVATE UNSAFE PROC [s4: StatPtr, s3: Stat3Ptr] RETURNS [] ~ UNCHECKED {
s4.dev ¬ s3.dev;
s4.ino ¬ s3.ino;
s4.mode ¬ s3.mode;
s4.nlink ¬ s3.nlink;
s4.uid ¬ s3.uid;
s4.gid ¬ s3.gid;
s4.rdev ¬ s3.rdev;
s4.size ¬ s3.size;
s4.atime ¬ s3.atime;
s4.spare1 ¬ s3.spare1;
s4.mtime ¬ s3.mtime;
s4.spare2 ¬ s3.spare2;
s4.ctime ¬ s3.ctime;
s4.spare3 ¬ s3.spare3;
s4.blksize ¬ s3.blksize;
s4.blocks ¬ s3.blocks;
s4.spare4 ¬ s3.spare4;
};
}.


œUnixSysCallsImpl.mesa
Copyright Σ 1988, 1989, 1991 by Xerox Corporation.  All rights reserved.
Christian Jacobi, January 24, 1991 5:30 pm PST
CHauser, November 9, 1988 12:45:15 pm PST
Demers, November 9, 1988 5:41:50 pm PST
Carl Hauser, February 16, 1989 2:08:26 pm PST

Unix(tm) system calls for PCedar.
Commented-out names are unimplemented for good reason, and not to be used, except: "????" means we should implement some version of this eventually.
Michael Plass, September 1, 1992 2:40 pm PDT
Acct
AdjTime
Audit
AuditOn
AuditSvc
Brk
SBrk

ChDir
Chown
FChown
Chroot
Creat
Dup
Dup2 ????
ExecVE
Exit
FLock
Fork
GetAUID
SetAUID

GetDirentries
SetGroups
SetHostName
GetITimer
SetITimer
GetPriority
SetPriority
GetRLimit
SetRLimit
SetTimeOfDay
... only a subset of the full Unix capability.  
There were two errors in the definition of MMap in the interface; UnixTypes.MMapFlags is wrong, and the mmap call returns the address, not a return code.  We fix the first problem by translating the bits (this is really the "right way" to do this anayway, if we were not generally so lazy, since it would track changes in mman.h).  The second one we'll ignore for now - clients should check res#failure instead of res=success.
Mount

MsgCtl
MsgGet
MsgOp
NFSSvc
AsyncDaemon
Pipe

PTrace


QuotaCtl
Reboot
RecvMsg
Select
SemCtl
SemGet
SemOp
SendMsg
SetPGRP
SetREGID
SetREUID
SetUserAudit
SigBlock
SigPause
SigSetMask
SigStack
SigVec
SocketPair ????
Swapon
Syscall
UMask
UName
Unmount
VAdvise
VFork
VHangup
Wait
Wait3
Wait4
Stat structures are different on Sun3/Sun4.  We want Cedar code to always use the same stat structure so we transform  Stat3s to Stats here.

pad0:  INT16, 	-- no padding on sun3
pad1: INT16,	-- no padding on sun3
CHauser, February 16, 1989: Remove Dup, add GetSockOpt, SetSockOpt
CHauser, February 22, 1989: Added Poll, GetMsg, PutMsg
Plass, January 29, 1992: Added Access, FCntl, FCntl4, IOCtl4, MMap, MUnmap, MProtect, MSync
Κ%Θ–
(cedarcode) style•NewlineDelimiter

˜
codeš
œ™Kšœ
Οe
œ=™HJ™.Kšœ&Οk™)Kšœ$ž™'Kš
œ-™-K™KšœΟuœ™!KšœKΟbœC™”
K™,K˜—š
ž	˜	Kšœžœ˜'Kš
œ
˜
Kš
œ	˜	K˜
K˜—šΟnœžœ
ž˜Kšžœ˜Kšžœ
˜Kšœžœ˜K˜š‘œžœ
žœ
žœžœ&žœžœž	œ˜aš œžœ
žœžœ&žœžœž	œ
žœ
žœ˜gKš
œ˜Kš
œ˜—Kšžœ˜#Kš
œ˜K˜—š‘œžœ
žœžœžœžœ˜Iš
œžœžœžœžœ
žœ
žœ˜OK˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—K™K™K™K™™K˜—š‘œžœ
žœžœžœžœžœ˜Lš œžœžœžœžœžœžœ
žœ
žœ˜ZKš
œ	˜	Kš
œ˜—Kšžœ˜!Kš
œ˜K˜—K™K™K™™K˜—š
‘œžœ
žœžœžœ˜@š œžœžœžœžœ
žœ
žœ˜NKš
œ
˜
Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœžœžœžœ˜:š œžœžœžœžœžœ
žœ
žœ˜HKš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—K™K™™K˜—š‘œžœ
žœžœžœžœ˜-š œžœžœžœžœžœ
žœ
žœ˜;Kš
œ
˜
Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœžœžœžœžœ˜Oš œžœžœžœžœžœžœ
žœ
žœ˜]Kš
œ˜Kš
œ˜—Kšžœ˜$Kš
œ˜K˜—™K˜—Jš
œ™K™	K™™K˜—š‘œžœ
žœžœžœžœžœžœ˜Aš œžœžœžœžœžœžœžœ
žœ
žœ˜OK˜
Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœžœžœžœžœžœžœ˜Qš œžœžœžœžœžœžœžœžœ
žœ
žœ˜_K˜Kš
œ˜—Kšžœ"˜(Kš
œ˜K˜K˜—š
œ™K˜—™K˜—š‘œžœ
žœžœžœžœ˜-š œžœžœžœžœžœ
žœ
žœ˜;Kš
œ
˜
Kš
œ˜—Kšžœ˜Kš
œ˜K˜—K™K™K™š‘œžœ
žœ
žœžœžœžœžœž	œ˜\š‘œžœ
žœžœžœžœžœž	œ
žœ
žœ˜bKš
œ
˜
Kš
œ˜—Kšžœ˜$Kš
œ˜—K˜™
K˜—š‘
œžœ
žœ
žœžœžœžœž	œ˜[š 
œžœ
žœžœžœžœž	œ
žœ
žœ˜aKš
œ˜Kš
œ˜—Kšžœ!˜'Kš
œ˜K˜—š
‘
œžœ
žœ
žœžœ˜,š 
œžœ
žœžœžœ
žœ
žœ˜:Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š
‘œžœ
žœ
žœžœ˜%š œžœ
žœžœžœ
žœ
žœ˜3Kš
œ˜Kš
œ˜—Kšžœ
˜Kš
œ˜K˜—š
‘œžœ
žœ
žœžœ˜&š œžœ
žœžœžœ
žœ
žœ˜4Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘	œžœ
žœ
žœ
žœžœžœž	œ˜dš 	œžœ
žœ
žœžœžœž	œ
žœ
žœ˜aKš
œ˜Kš
œ˜—Kšžœ!˜'Kš
œ˜K˜—™	K˜—š
‘	œžœ
žœ
žœžœ˜(š 	œžœ
žœžœžœ
žœ
žœ˜6Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœž	œ˜Yš œžœ
žœžœžœžœž	œ
žœ
žœ˜_Kš
œ˜Kš
œ˜—Kšžœ˜%Kš
œ˜K˜—Kš
œ™K™	™	K˜—š‘œžœ
žœ
žœžœ%žœ
žœ
žœž	œ˜|š œžœžœ%žœ
žœ
žœž	œ
žœ
žœ˜‚
Kš
œ˜Kš
œ˜—Kšžœ'˜-Kš
œ˜K˜—š
‘œžœ
žœ
žœžœ˜*š œžœ
žœžœžœ
žœ
žœ˜8Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœ
žœžœ&žœžœž	œ˜gš œžœ
žœžœ&žœžœž	œ
žœ
žœ˜mKš
œ˜Kš
œ˜—Kšžœ"˜(Kš
œ˜K˜—š
‘œžœ
žœ
žœžœ˜%š œžœ
žœžœžœ
žœ
žœ˜3Kš
œ˜Kš
œ˜—Kšžœ
˜Kš
œ˜K˜—š
‘œžœ
žœ
žœžœ˜&š œžœ
žœžœžœ
žœ
žœ˜4Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜K˜—K™K™K™	K™	K˜Kš	œžœžœ
žœ
žœ˜)K˜š‘	œžœ
žœ
žœžœžœž	œ˜Wš 	œžœ
žœžœžœžœ
žœ˜SKš
œ˜—Kšžœ˜!Kš
œ˜K˜—š‘œžœ
žœ
žœžœ&žœžœž	œ˜gš œžœ
žœžœ&žœžœž	œ
žœ
žœ˜mKš
œ˜Kš
œ˜—Kšžœ"˜(Kš
œ˜K˜—š‘
œžœ
žœ
žœžœ	žœžœ#žœžœž	œ˜}š 
œžœ
žœžœ	žœžœ#žœžœž	œ
žœ
žœ˜ƒ
Kš
œ˜Kš
œ˜—Kšžœ2˜8Kš
œ˜K˜—š‘
œžœžœ	žœžœžœžœžœ˜iš 
œžœžœ	žœžœžœžœžœžœ
žœ
žœ˜wKš
œ˜Kš
œ˜—Kšžœ2˜8Kš
œ˜K˜K˜—š‘œžœ
žœ$žœžœž	œ˜_š œžœ
žœ$žœžœž	œ
žœ
žœ˜eKš
œ˜Kš
œ˜—Kšžœ˜ Kš
œ˜K˜—™K˜—š
‘œžœ
žœ
žœ
žœ˜$š œžœ
žœžœžœ
žœ
žœ˜3Kš
œ˜Kš
œ˜—Kšžœ
˜Kš
œ˜K˜—š
‘œžœ
žœ
žœ
žœ˜%š œžœ
žœžœžœ
žœ
žœ˜4Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœžœž	œ˜ZK™0š œžœ
žœžœžœžœžœž	œ
žœ
žœ˜`Kš
œ
˜
Kš
œ˜—Kšžœ˜"Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœžœžœ˜`š œžœžœžœžœžœžœžœ
žœ
žœ˜gK˜Kš
œ˜—Kšžœ&˜,Kš
œ˜K˜—š‘œžœ
žœžœžœžœ˜;š œžœžœžœžœžœ
žœ
žœ˜IKš
œ	˜	Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœžœžœžœ˜?š œžœžœžœžœžœ
žœ
žœ˜MKš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š
‘œžœ
žœžœžœ˜;š œžœžœžœžœ
žœ
žœ˜IKš
œ	˜	Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœžœžœžœžœ˜;š œžœžœžœ
žœžœžœ
žœ
žœ˜IKš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœžœ
žœžœžœ˜Iš œžœžœ
žœžœžœžœ
žœ
žœ˜WKš
œ
˜
Kš
œ˜—Kšžœ˜#Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœž	œ˜_š‘œžœ
žœžœžœžœž	œ
žœ
žœ˜eKš
œ˜Kš
œ˜—Kšžœ˜"Kš
œ˜K˜—š
‘œžœ
žœžœžœ˜@š œžœžœžœžœ
žœ
žœ˜NKš
œ
˜
Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœ"žœžœžœ˜Jš œžœ"žœ
žœžœžœ
žœ
žœ˜XKš
œ
˜
Kš
œ˜—Kšžœ˜!Kš
œ˜K˜—š‘œžœ
žœ
žœžœ*žœ
žœžœžœ˜€
Kšœ+‘œϋ™ͺš œžœžœžœžœ
žœžœžœ
žœ
žœ˜ƒ
KšœΟcR˜iKš
œ˜—š‘œžœžœžœžœžœ
žœ
žœ˜^Iascii˜³
L˜K˜—Kšžœžœ‚
žœ	žœ˜¨
Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœ˜Hš œžœžœžœžœžœ
žœ
žœ˜OK˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—™K™—š‘œžœ
žœ
žœžœžœžœ˜]š œžœžœžœžœžœ
žœ
žœ˜dK˜
Kš
œ˜—Kšžœ!˜'Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœ˜Zš œžœžœžœžœžœ
žœ
žœ˜aK˜
Kš
œ˜—Kšžœ˜%Kš
œ˜K˜K˜—K™K™™K˜—K™™K˜—š
‘œžœ
žœ/žœžœ˜Pš œžœ.žœžœžœ
žœ
žœ˜^Kš
œ	˜	Kš
œ˜—Kšžœ˜"Kš
œ˜K˜—K™Kš‘œžœžœ
žœžœžœžœžœ
˜cšœž	œ˜š œžœ
žœžœ
žœžœžœžœžœž	œ
žœ
žœ˜mKš
œ	˜	Kš
œ˜—Kšžœ˜#Kš
œ˜—K™Kš‘œž
œ
žœžœ
žœ	žœžœžœ
˜]šœž	œ˜š œžœ
žœžœ
žœ	žœžœžœž	œ
žœ
žœ˜rKš
œ˜Kš
œ˜—Kšžœ(˜.Kš
œ˜K˜—K™K™š
‘œžœžœ.žœžœ˜Zš œžœžœ.žœžœžœ
žœ
žœ˜hKš
œ˜Kš
œ˜—Kšžœ'˜-Kš
œ˜K˜K˜—K™™K˜—š‘œžœ
žœ
žœžœžœžœžœž	œ˜Wš œžœ
žœžœžœžœžœž	œ
žœ
žœ˜]Kš
œ	˜	Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœžœž	œ˜Yš œžœ
žœžœžœžœžœž	œ
žœ
žœ˜_Kš
œ
˜
Kš
œ˜—Kšžœ˜ Kš
œ˜K˜—š‘œžœ
žœ
žœ(žœžœžœž	œ˜dš œžœ
žœ(žœžœžœž	œ
žœ
žœ˜jKš
œ
˜
Kš
œ˜—Kšžœ!˜'Kš
œ˜K˜—™K˜—š‘œžœ
žœ
žœžœžœžœžœž	œ˜fš œžœ
žœžœžœžœžœž	œ
žœ
žœ˜lKš
œ	˜	Kš
œ˜—Kšžœ˜$Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœ7žœžœž	œ˜Ž
š œžœ
žœžœžœ7žœžœž	œ
žœ
žœ˜”
Kš
œ
˜
Kš
œ˜—Kšžœ1˜7Kš
œ˜K˜—™K˜—š
‘œžœ
žœžœžœ˜9š œžœžœžœžœ
žœ
žœ˜GKš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š
‘œžœ
žœžœžœ˜4š œžœžœžœžœ
žœ
žœ˜BKš
œ
˜
Kš
œ˜—Kšžœ˜Kš
œ˜K˜—K™K™K™™K˜—š‘œžœ
žœžœžœžœžœ˜Tš œžœžœžœžœžœžœ
žœ
žœ˜bKš
œ	˜	Kš
œ˜—Kšžœ˜#Kš
œ˜K˜—š‘œžœ
žœžœžœ+žœžœžœ˜sš œžœžœžœ+žœ
žœžœžœ
žœ
žœ˜
Kš
œ˜Kš
œ˜—Kšžœ*˜0Kš
œ˜K˜—™K˜—™K˜—š‘œžœ
žœžœžœžœ˜2š œžœžœ
žœžœžœ
žœ
žœ˜@Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—K™™K˜—™K˜—š
‘œžœ
žœžœžœ$˜vš‘œžœžœžœ#žœ
žœ
žœ˜„
Kš
œ˜Kš
œ˜—Kšžœ˜"Kš
œ˜—K˜š‘œžœ
žœ6žœ
žœ
žœ˜xš‘œžœ6žœ
žœ
žœžœ
žœ
žœ˜†
Kš
œ˜K˜—Kšžœ˜K˜K˜—š‘œžœ
žœ
žœ>žœžœž	œ˜rš‘œžœ
žœ>žœžœžœ
žœ˜nKš
œ
˜
K˜—Kš	žœžœ
žœ
žœ’0˜JKšžœ˜K˜K˜—š‘œžœ
žœ
žœžœž	œ˜Mš‘œžœ
žœžœžœ
žœ˜IKš
œ
˜
K˜—Kšžœ
˜K˜K˜—š‘œžœ
žœžœžœžœ˜;š œžœžœ
žœžœžœ
žœ
žœ˜IKš
œ
˜
Kš
œ˜—Kšžœ˜Kš
œ˜K˜—K™K™K™
K™™K˜—š
‘œžœ
žœAžœžœ˜dš‘œžœ@žœžœžœ
žœ
žœ˜rKš
œ˜Kš
œ˜—Kšžœ˜%Kš
œ˜K˜—™K˜—š‘œžœ
žœ
žœžœžœž	œ˜Rš œžœ
žœžœžœž	œ
žœ
žœ˜YKš
œ	˜	Kš
œ˜—š œžœ
žœ žœžœž	œ
žœ
žœ˜ZKš
œ	˜	Kš
œ˜—šžœ"ž˜,Kšœžœ˜#š
œ	˜	Kš
œ˜Kšœžœ˜Kš
œ˜Kšžœ˜K˜
—Kšžœžœ
˜—Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœž	œ˜Sš œžœ
žœžœžœž	œ
žœ
žœ˜ZKš
œ
˜
Kš
œ˜—š œžœ
žœ žœžœž	œ
žœ
žœ˜[Kš
œ
˜
Kš
œ˜—šžœ"ž˜,Kšœžœ˜$š
œ	˜	Kš
œ˜Kšœžœ˜ Kš
œ˜Kšžœ˜K˜
—Kšžœžœ
˜—Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœž	œ˜Lš œžœ
žœžœžœžœž	œ
žœ
žœ˜SKš
œ
˜
Kš
œ˜—š œžœ
žœžœžœžœž	œ
žœ
žœ˜TKš
œ
˜
Kš
œ˜—šžœ"ž˜,Kšœžœ˜"š
œ	˜	Kš
œ˜Kšœžœ˜Kš
œ˜Kšžœ˜K˜
—Kšžœžœ
˜—Kš
œ˜K˜—š‘œžœ
žœ
žœ!žœžœž	œ˜Vš‘œžœ
žœ!žœžœž	œ
žœ
žœ˜\Kš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—š‘œžœ
žœ
žœžœžœžœž	œ˜Pš‘œžœ
žœžœžœžœž	œ
žœ
žœ˜VKš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—™K˜—š
‘œžœ
žœžœžœ˜>š‘œžœžœžœžœ
žœ
žœ˜LKš
œ˜Kš
œ˜—Kšžœ˜ Kš
œ˜K˜—š
‘œžœ
žœ
žœžœ˜#š‘œžœ
žœžœžœ
žœ
žœ˜1Kš
œ	˜	Kš
œ˜—Kšžœ˜Kš
œ˜K˜—™K˜—š‘œžœ
žœžœžœžœ˜Eš‘œžœžœžœžœžœ
žœ
žœ˜SKš
œ
˜
Kš
œ˜—Kšžœ˜!Kš
œ˜K˜—š‘	œžœ
žœžœ
žœžœžœ˜?š‘	œžœžœ
žœžœžœžœ
žœ
žœ˜MKš
œ˜Kš
œ˜—Kšžœ˜ Kš
œ˜K˜—K™™K˜—š
‘œžœ
žœžœžœ˜5š‘œžœžœžœžœ
žœ
žœ˜CKš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—™K˜—š
‘œžœ
žœ$žœžœ˜Hš‘œžœ$žœžœžœ
žœ
žœ˜VKš
œ˜Kš
œ˜—Kšžœ˜Kš
œ˜K˜—K™K™™K˜—K™K™™K˜—š‘œžœ
žœžœžœžœžœ˜Gš‘œžœžœžœžœžœžœ
žœ
žœ˜UKš
œ
˜
Kš
œ˜—Kšžœ˜ Kš
œ˜K˜—š‘œžœ
žœžœžœžœžœ˜Iš‘œžœžœžœžœžœžœ
žœ
žœ˜WKš
œ˜Kš
œ˜—Kšžœ˜!Kš
œ˜K˜K˜—Kš
œŒ
™Œ
K™Kšœ
žœžœ
žœ˜"šœžœžœ
žœ
ž	œ
žœ˜/Kšœ’˜%Kšœžœ™$Kšœ’˜"Kšœ’
˜Kšœžœ’#˜1Kšœžœ’˜Kšœžœ’˜Kšœ’,˜8Kšœžœ™"Kšœžœ’˜-Kšœ’˜&Kšœžœ
’
˜Kšœ
’˜%Kšœžœ
˜Kšœ’˜-Kšœžœ
˜Kšœ	žœ’,˜=Kšœžœ’$˜4Kšœžœžœ
ž˜Kš
œ˜K˜—š‘
œžœ
žœ
žœžœž	œ˜TKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—K˜—K˜K˜J™BJš
œ6™6J™[—…—MvzΪ