From 841d00e9d08aaf55705ce81ab868ec3465844265 Mon Sep 17 00:00:00 2001 From: Norayr Chilingarian Date: Tue, 29 Oct 2013 16:23:31 +0400 Subject: [PATCH] ported SysIO, modified ulmSYSTEM for that as a wrapper to Unix.Mod ulmSYSTEM.UNIXCALLs are wrapped to Unix.Mod functions. Added Pipe to Unix.Mod --- makefile | 4 +- ocat | Bin 209462 -> 209462 bytes showdef | Bin 433254 -> 433254 bytes src/lib/system/gnuc/armv6j/Unix.Mod | 3 + src/lib/system/gnuc/armv6j_hardfp/Unix.Mod | 3 + src/lib/system/gnuc/armv7a_hardfp/Unix.Mod | 3 + src/lib/system/gnuc/x86/Unix.Mod | 3 + src/lib/system/gnuc/x86_64/Unix.Mod | 3 + src/lib/ulm/gnuc/ulmSYSTEM.Mod | 67 ---- src/lib/ulm/ulmSYSTEM.Mod | 97 ++++++ src/lib/ulm/ulmSysErrors.Mod | 10 +- src/lib/ulm/ulmSysIO.Mod | 343 +++++++++++++++++++++ src/lib/ulm/ulmSysTypes.Mod | 2 +- voc | Bin 1324849 -> 1324849 bytes 14 files changed, 464 insertions(+), 74 deletions(-) delete mode 100644 src/lib/ulm/gnuc/ulmSYSTEM.Mod create mode 100644 src/lib/ulm/ulmSYSTEM.Mod create mode 100644 src/lib/ulm/ulmSysIO.Mod diff --git a/makefile b/makefile index 32b9c1ae..0119f235 100644 --- a/makefile +++ b/makefile @@ -152,6 +152,7 @@ stage6: $(VOCSTATIC) -sP oocwrapperlibc.Mod #Ulm's Oberon system libs + $(VOCSTATIC) -sP ulmSys.Mod $(VOCSTATIC) -sP ulmSYSTEM.Mod $(VOCSTATIC) -sP ulmASCII.Mod ulmSets.Mod $(VOCSTATIC) -sP ulmObjects.Mod ulmDisciplines.Mod @@ -161,15 +162,16 @@ stage6: $(VOCSTATIC) -sP ulmIndirectDisciplines.Mod ulmStreamDisciplines.Mod $(VOCSTATIC) -sP ulmIEEE.Mod ulmMC68881.Mod ulmReals.Mod $(VOCSTATIC) -sP ulmPrint.Mod + $(VOCSTATIC) -sP ulmWrite.Mod $(VOCSTATIC) -sP ulmTexts.Mod $(VOCSTATIC) -sP ulmStrings.Mod ulmConstStrings.Mod $(VOCSTATIC) -sP ulmConstStrings.Mod $(VOCSTATIC) -sP ulmPlotters.Mod $(VOCSTATIC) -sP ulmSysTypes.Mod - $(VOCSTATIC) -sP ulmSys.Mod $(VOCSTATIC) -sP ulmSysConversions.Mod $(VOCSTATIC) -sP ulmErrors.Mod $(VOCSTATIC) -sP ulmSysErrors.Mod + $(VOCSTATIC) -sP ulmSysIO.Mod #pow32 libs diff --git a/ocat b/ocat index 07389ef150433aafb465788a129ecff581332014..277a42b4a9fae60b97596120d7833d9eeacdd87a 100755 GIT binary patch delta 889 zcmZ`%O=uHA6y7)6B(pV^CMFP3NHmu~L=cNYr4mmqSg_!sJ!xxE+Zr|0T(yA^y;MS4 zVU&94!Hbt*vCSIO#Hf(gQ4u*3I#?|t*l%*(XwnU+1a z2>PO0UQosK63mGHCFoHr@ir02z$~w|D@ub^z2ajAo@fv4gw}EvF|4ClmvDVh{L)eU zEz!n~RXlwIv)Yw|RJ)n9iLNZxUOqsu78K&aGWd zyvU)^V_CaB*DgZKFf(P%%YB+>k>-guMPbba75{$479F{X=!`;$^Ik@pfjW7NYE0ze z&V8DX*PW!jmo5Q*SbA0^3h@amX+J?xRDTh8()G7f^{;|05}ia@d|HMmycFm2;DfZd zng{=-^hL^%8ge|>a81h`sR4%zW3zMs&%jcBj%T!{ztLW)P{-u;dkTAHRE{YYehqi+ zgwuE(Oc&KW96zTU;*epZ8#V)mjc(ZV88+EH8z(%#+hqlDvH;%h!d|Kh7L(mI fNg7nP?cSBFFJiJZuB@qhiZDM7NAzqzyZ`+U4-n2v delta 889 zcmZ`%QAkr!7(V~Gx}7_h=yI?kaCILN7C{&VMzIJ|C`jl*pE8rm)M}WoXjSJJ=T90(HVxEAw(x9%|=ZkisdyF5Wam{P*i-Rtx$#0CJrgj zqC#OYEHBN$Wo<21Cl_X6(&H+77_0I^YrUM9gDLUU zOR%^okDKs9uP9XNami06ihmSb-<5r76mOt$m2V{6@^>1h^y>`-H$y_coX6UW3YPP- zJ%hE=>XyoYE(;kHtUEPaGwcq=bh5QLQM zv%t8Px}KNj-4}YvDdaSZJTb}#i;5lmf+}#ucy&g*8=f=Jn``# zp*dFlxB*>@-mzK#2m0hSd1@J2LWLOSN7urGjz&M97hCIz4Bm4{$^b9P2sVtb_h7_y z?c0!}Q3UwLt|GI;4oN}an+Z2n&Wt!D#etVYg2?E7hon^SN?wsSA2=jsgI5Re&*Eec g9g-r#xBPpG4MrT6lESysfh^2Sz~OY}Du4XrFILUY2mk;8 diff --git a/showdef b/showdef index 29d896a275b93de22ad542e451c4fd63e78b393e..af2514a8aa2a2c1b4d24cf77214f36265162340c 100755 GIT binary patch delta 885 zcmZ`%OK1~O6n*n@tihueh26 zzmnjmauDcAoX0)l{qAzJcqil@@vwVaoJtd|2T<#B4~ko8;w#RIhnyp~?h*RNsJuh0 zY*0*fDZj8r<1cd1d{#5We#1sHY{G_(X4rHYHt+Uq8kJ5Qnc_cl;A>CqZS_=qRhlxl za*89;9dh5hhm{Lh{{f-m!3A81b$&4qfp-0$etlnm_P_l}?BC|E^Ke4>!i#zE2J>EV zvI^sUF)@V@?|t#hY2lkBqY;zD?9n237r+xN`NVfu!GForFnYASAW3rBBr$<>g@;AM z*lNv&4e2YUhWVpwQz9=a%w07}j3HeQGP%n&lf*F6N=A~=>n4erq#H321{FdBCW*+r6PtLNV-wE0Hy~GO$!`~t zJe%a*M-Z0h#rHgWp-xM*5~&k$9YkHi%C2ZFfY|KD(ABs@=mj>Z9(N&J3vv-#gjlD9 z>$>>82(hjtp?M&lNWGqi9S!I3BE}=w?x?U35w8U%OTV{J^f%qlV5N)iI8jP&O<_H%*cDh z&ii3XZsixoq{J(OHJwSBVxMV~GHt@9P0F`TBqJXEDDfW{T{D@>!IN%o{Yk z@MM*Z_Qs$JA>KzYYg+s&$!NqPaqF}sJSEl`Ec@Y5R2H~wX}EN{GA~JT#UgR_v?9Wg zFtWN^hY8uMmWG?BYjL=5l}%r>NZdbN4|3Vdb&JF^pc}d*qc= 0 THEN RETURN TRUE ELSE RETURN FALSE END + (*NEW(pch); + pch := SYSTEM.VAL(pchar, arg2); + ch := pch^[0]; + n := read(ch); + IF n # 1 THEN + ch := 0X; + RETURN FALSE + ELSE + pch^[0] := ch; + RETURN TRUE + END; + *) + ELSIF syscall = Sys.write THEN + d0 := Unix.Write(arg1, arg2, arg3); + IF d0 >= 0 THEN RETURN TRUE ELSE RETURN FALSE END + (*NEW(pch); + pch := SYSTEM.VAL(pchar, arg2); + n := Write(SYSTEM.VAL(LONGINT, pch), 1); + IF n # 1 THEN RETURN FALSE ELSE RETURN TRUE END + *) + ELSIF syscall = Sys.open THEN + pstr := SYSTEM.VAL(pstring, arg1); + d0 := Unix.Open(pstr^, SYSTEM.VAL(SET, arg3), SYSTEM.VAL(SET, arg2)); + IF d0 >= 0 THEN RETURN TRUE ELSE RETURN FALSE END + ELSIF syscall = Sys.close THEN + d0 := Unix.Close(arg1); + IF d0 = 0 THEN RETURN TRUE ELSE RETURN FALSE END + ELSIF syscall = Sys.lseek THEN + d0 := Unix.Lseek(arg1, arg2, arg3); + IF d0 >= 0 THEN RETURN TRUE ELSE RETURN FALSE END + ELSIF syscall = Sys.ioctl THEN + d0 := Unix.Ioctl(arg1, arg2, arg3); + RETURN d0 >= 0; + ELSIF syscall = Sys.fcntl THEN + d0 := Unix.Fcntl (arg1, arg2, arg3); + RETURN d0 >= 0; + ELSIF syscall = Sys.dup THEN + d0 := Unix.Dup(arg1); + RETURN d0 > 0; + ELSIF syscall = Sys.pipe THEN + d0 := Unix.Pipe(arg1); + RETURN d0 >= 0; + END + + END UNIXCALL; + + + PROCEDURE UNIXFORK(VAR pid: LONGINT) : BOOLEAN; + BEGIN + + END UNIXFORK; + + PROCEDURE UNIXSIGNAL(signo: INTEGER; p: PROCEDURE; + VAR old: PROCEDURE; VAR error: INTEGER) : BOOLEAN; + BEGIN + + END UNIXSIGNAL; + + PROCEDURE WMOVE*(from, to, n : LONGINT); + VAR l : LONGINT; + BEGIN + SYSTEM.MOVE(from, to, n); + END WMOVE; +END ulmSYSTEM. diff --git a/src/lib/ulm/ulmSysErrors.Mod b/src/lib/ulm/ulmSysErrors.Mod index 9f33df30..0e81818d 100644 --- a/src/lib/ulm/ulmSysErrors.Mod +++ b/src/lib/ulm/ulmSysErrors.Mod @@ -138,8 +138,8 @@ MODULE ulmSysErrors; EventRec* = RECORD (Events.EventRec) - errno*: INTEGER; - syscall*: INTEGER; (* number of system call *) + errno*: (*INTEGER*)LONGINT; + syscall*: (*INTEGER*)LONGINT; (* number of system call *) text*: ARRAY textlen OF CHAR; END; @@ -150,7 +150,7 @@ MODULE ulmSysErrors; syserror*: ARRAY ncodes OF Events.EventType; PROCEDURE Raise*(errors: RelatedEvents.Object; - errno, syscall: INTEGER; text: ARRAY OF CHAR); + errno, syscall: (*INTEGER*)LONGINT; text: ARRAY OF CHAR); (* in ulm's system INTEGER and LONGINT have the same size *) (* raises the events syserrors and syserrors[syscall]; `text' contains additional information (e.g. filenames); further, the syserrors[syscall] event is passed to @@ -192,9 +192,9 @@ MODULE ulmSysErrors; IF ~Streams.WriteByte(s, ch) THEN END; END Write; - PROCEDURE WriteInt(intval: INTEGER); + PROCEDURE WriteInt(intval: LONGINT); VAR - rest: INTEGER; + rest: LONGINT; BEGIN rest := intval DIV 10; IF rest > 0 THEN diff --git a/src/lib/ulm/ulmSysIO.Mod b/src/lib/ulm/ulmSysIO.Mod new file mode 100644 index 00000000..33959006 --- /dev/null +++ b/src/lib/ulm/ulmSysIO.Mod @@ -0,0 +1,343 @@ +(* Ulm's Oberon Library + Copyright (C) 1989-1994 by University of Ulm, SAI, D-89069 Ulm, Germany + ---------------------------------------------------------------------------- + Ulm's Oberon Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either version + 2 of the License, or (at your option) any later version. + + Ulm's Oberon Library 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 + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + ---------------------------------------------------------------------------- + E-mail contact: oberon@mathematik.uni-ulm.de + ---------------------------------------------------------------------------- + $Id: SysIO.om,v 1.1 1994/02/23 07:59:15 borchert Exp $ + ---------------------------------------------------------------------------- + $Log: SysIO.om,v $ + Revision 1.1 1994/02/23 07:59:15 borchert + Initial revision + + ---------------------------------------------------------------------------- + AFB 6/89 + ---------------------------------------------------------------------------- +*) + +MODULE ulmSysIO; + + IMPORT RelatedEvents := ulmRelatedEvents, Sys := ulmSys, SYS := SYSTEM, ulmSYSTEM, SysErrors := ulmSysErrors, SysTypes := ulmSysTypes; + + CONST + (* file control options: arguments of Fcntl and Open *) + rdonly* = {}; + wronly* = { 0 }; + rdwr* = { 1 }; + append* = { 10 }; + ndelay* = { 11 }; (* O_NONBLOCK that works like former O_NDELAY *) + creat* = { 6 }; + trunc* = { 9 }; + excl* = { 7 }; + noctty* = { 8 }; + sync* = { 12 }; + fasync* = { 13 }; + direct* = { 14 }; + largefile* = { 15 }; + directory* = { 16 }; + nofollow* = { 17 }; + + (* Whence = (fromStart, fromPos, fromEnd); *) + fromStart* = 0; + fromPos* = 1; + fromEnd* = 2; + + (* file descriptor flags *) + closeonexec* = { 0 }; + + (* Fcntl requests *) + dupfd* = 0; (* duplicate file descriptor *) + getfd* = 1; (* get file desc flags (close-on-exec) *) + setfd* = 2; (* set file desc flags (close-on-exec) *) + getfl* = 3; (* get file flags *) + setfl* = 4; (* set file flags (ndelay, append) *) + getlk* = 5; (* get file lock *) + setlk* = 6; (* set file lock *) + setlkw* = 7; (* set file lock and wait *) + setown* = 8; (* set owner (async IO) *) + getown* = 9; (* get owner (async IO) *) + setsig* = 10; (* set SIGIO replacement *) + getsig* = 11; (* get SIGIO replacement *) + + TYPE + File* = SysTypes.File; (* file descriptor *) + Address* = SysTypes.Address; + Count* = SysTypes.Count; + Protection* = LONGINT; + Whence* = LONGINT; + + PROCEDURE OpenCreat*(VAR fd: File; + filename: ARRAY OF CHAR; options: SET; + protection: Protection; + errors: RelatedEvents.Object; + retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; + (* the filename must be 0X-terminated *) + VAR + d0, d1: (*INTEGER*)LONGINT; + BEGIN + interrupted := FALSE; + LOOP + IF ulmSYSTEM.UNIXCALL(Sys.open, d0, d1, + SYS.ADR(filename), SYS.VAL(LONGINT, options), protection) THEN + fd := d0; + RETURN TRUE + ELSE + IF d0 = SysErrors.intr THEN + interrupted := TRUE; + END; + IF (d0 # SysErrors.intr) OR ~retry THEN + SysErrors.Raise(errors, d0, Sys.open, filename); + RETURN FALSE + END; + END; + END; + END OpenCreat; + + PROCEDURE Open*(VAR fd: File; + filename: ARRAY OF CHAR; options: SET; + errors: RelatedEvents.Object; + retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; + (* the filename must be 0X-terminated *) + BEGIN + RETURN OpenCreat(fd, filename, options, 0, errors, retry, interrupted) + END Open; + + PROCEDURE Close*(fd: File; + errors: RelatedEvents.Object; + retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; + VAR + d0, d1: LONGINT; + a0, a1 : LONGINT; (* just to match UNIXCALL interface *) + BEGIN + interrupted := FALSE; + LOOP + IF ulmSYSTEM.UNIXCALL(Sys.close, d0, d1, fd, a0, a1) THEN + (*IF ulmSYSTEM.UNIXCALL(Sys.close, d0, d1, fd) THEN*) + RETURN TRUE + ELSE + IF d0 = SysErrors.intr THEN + interrupted := TRUE; + END; + IF (d0 # SysErrors.intr) OR ~retry THEN + SysErrors.Raise(errors, d0, Sys.close, ""); + RETURN FALSE + END; + END; + END; + END Close; + + PROCEDURE Read*(fd: File; buf: Address; cnt: Count; + errors: RelatedEvents.Object; + retry: BOOLEAN; VAR interrupted: BOOLEAN) : Count; + (* return value of 0: EOF + -1: I/O error + >0: number of bytes read + *) + VAR + d0, d1: LONGINT; + BEGIN + interrupted := FALSE; + LOOP + IF ulmSYSTEM.UNIXCALL(Sys.read, d0, d1, fd, buf, cnt) THEN + RETURN d0 + ELSE + IF d0 = SysErrors.intr THEN + interrupted := TRUE; + END; + IF (d0 # SysErrors.intr) OR ~retry THEN + SysErrors.Raise(errors, d0, Sys.read, ""); + RETURN -1 + END; + END; + END; + END Read; + + PROCEDURE Write*(fd: File; buf: Address; cnt: Count; + errors: RelatedEvents.Object; + retry: BOOLEAN; VAR interrupted: BOOLEAN) : Count; + (* return value of -1: I/O error + >=0: number of bytes written + *) + VAR + d0, d1: LONGINT; + BEGIN + interrupted := FALSE; + LOOP + IF ulmSYSTEM.UNIXCALL(Sys.write, d0, d1, fd, buf, cnt) THEN + RETURN d0 + ELSE + IF d0 = SysErrors.intr THEN + interrupted := TRUE; + END; + IF (d0 # SysErrors.intr) OR ~retry THEN + SysErrors.Raise(errors, d0, Sys.write, ""); + RETURN -1 + END; + END; + END; + END Write; + + PROCEDURE Seek*(fd: File; offset: Count; whence: Whence; + errors: RelatedEvents.Object) : BOOLEAN; + VAR + d0, d1: LONGINT; + BEGIN + IF ulmSYSTEM.UNIXCALL(Sys.lseek, d0, d1, fd, offset, whence) THEN + RETURN TRUE + ELSE + SysErrors.Raise(errors, d0, Sys.lseek, ""); + RETURN FALSE + END; + END Seek; + + PROCEDURE Tell*(fd: File; VAR offset: Count; + errors: RelatedEvents.Object) : BOOLEAN; + VAR + d0, d1: LONGINT; + BEGIN + IF ulmSYSTEM.UNIXCALL(Sys.lseek, d0, d1, fd, 0, fromPos) THEN + offset := d0; + RETURN TRUE + ELSE + SysErrors.Raise(errors, d0, Sys.lseek, ""); + RETURN FALSE + END; + END Tell; + + PROCEDURE Isatty*(fd: File) : BOOLEAN; + CONST + sizeofStructTermIO = 18; + tcgeta = 00005405H; + VAR + d0, d1: LONGINT; + buf: ARRAY 32 OF SYS.BYTE; (* Should be more than sufficient *) + BEGIN + (* following system call fails for non-tty's *) + RETURN ulmSYSTEM.UNIXCALL(Sys.ioctl, d0, d1, fd, tcgeta, SYS.ADR(buf)) + END Isatty; + + PROCEDURE Fcntl*(fd: File; request: INTEGER; VAR arg: LONGINT; + errors: RelatedEvents.Object; + retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; + VAR + d0, d1: LONGINT; + BEGIN + interrupted := FALSE; + LOOP + IF ulmSYSTEM.UNIXCALL(Sys.fcntl, d0, d1, fd, request, arg) THEN + arg := d0; + RETURN TRUE + ELSE + IF d0 = SysErrors.intr THEN + interrupted := TRUE; + END; + IF (d0 # SysErrors.intr) OR ~retry THEN + SysErrors.Raise(errors, d0, Sys.fcntl, ""); + RETURN FALSE + END; + END; + END; + END Fcntl; + + PROCEDURE FcntlSet*(fd: File; request: INTEGER; flags: SET; + errors: RelatedEvents.Object; + retry: BOOLEAN; VAR interrupted: BOOLEAN) : BOOLEAN; + VAR + d0, d1: LONGINT; + BEGIN + interrupted := FALSE; + LOOP + IF ulmSYSTEM.UNIXCALL(Sys.fcntl, d0, d1, fd, request, SYS.VAL(LONGINT, flags)) THEN + RETURN TRUE + ELSE + IF d0 = SysErrors.intr THEN + interrupted := TRUE; + END; + IF (d0 # SysErrors.intr) OR ~retry THEN + SysErrors.Raise(errors, d0, Sys.fcntl, ""); + RETURN FALSE + END; + END; + END; + END FcntlSet; + + PROCEDURE FcntlGet*(fd: File; request: INTEGER; VAR flags: SET; + errors: RelatedEvents.Object) : BOOLEAN; + VAR + d0, d1: LONGINT; + BEGIN + IF ulmSYSTEM.UNIXCALL(Sys.fcntl, d0, d1, fd, request, 0) THEN + ulmSYSTEM.WMOVE(SYS.ADR(d0), SYS.ADR(flags), 1); + RETURN TRUE + ELSE + SysErrors.Raise(errors, d0, Sys.fcntl, ""); + RETURN FALSE + END; + END FcntlGet; + + PROCEDURE Dup*(fd: File; VAR newfd: File; + errors: RelatedEvents.Object) : BOOLEAN; + VAR + d0, d1: LONGINT; + a0, a1: LONGINT; + BEGIN + IF ulmSYSTEM.UNIXCALL(Sys.dup, d0, d1, fd, a0, a1) THEN + newfd := d0; + RETURN TRUE + ELSE + SysErrors.Raise(errors, d0, Sys.dup, ""); + RETURN FALSE + END; + END Dup; + + PROCEDURE Dup2*(fd, newfd: File; errors: RelatedEvents.Object) : BOOLEAN; + VAR + d0, d1: LONGINT; + a0, a1: LONGINT; + fd2: File; + interrupted: BOOLEAN; + BEGIN + fd2 := newfd; + (* handmade close to avoid unnecessary events *) + IF ~ulmSYSTEM.UNIXCALL(Sys.close, d0, d1, newfd, a0, a1) THEN END; + IF Fcntl(fd, dupfd, fd2, errors, TRUE, interrupted) THEN + IF fd2 = newfd THEN + RETURN TRUE + ELSE + RETURN Close(fd2, errors, TRUE, interrupted) & FALSE + END; + ELSE + RETURN FALSE + END; + END Dup2; + + PROCEDURE Pipe*(VAR readfd, writefd: File; + errors: RelatedEvents.Object) : BOOLEAN; + VAR + d0, d1: LONGINT; + a0, a1: LONGINT; + fds : ARRAY 2 OF (*File*)INTEGER; (* it needs int pipefd[2], and int is 4 bytes long on x86_64 -- noch *) + BEGIN + IF ulmSYSTEM.UNIXCALL(Sys.pipe, d0, d1, SYS.ADR (fds), a0, a1) THEN + readfd := fds[0]; writefd := fds[1]; + RETURN TRUE + ELSE + SysErrors.Raise(errors, d0, Sys.pipe, ""); + RETURN FALSE + END; + END Pipe; + +END ulmSysIO. diff --git a/src/lib/ulm/ulmSysTypes.Mod b/src/lib/ulm/ulmSysTypes.Mod index b7a0fedf..a614c67b 100644 --- a/src/lib/ulm/ulmSysTypes.Mod +++ b/src/lib/ulm/ulmSysTypes.Mod @@ -39,7 +39,7 @@ MODULE ulmSysTypes; Size* = Types.Size; Byte* = Types.Byte; - File* = INTEGER; + File* = (*INTEGER*)LONGINT; (* in ulm's system both INTEGER and LONGINT are 4 bytes long *) Offset* = LONGINT; Device* = INTEGER; Inode* = LONGINT; diff --git a/voc b/voc index 5a61e0f70e28eb3c5eb604cf506a2f9a18c3355c..781786d67da699b419a4f4ae42b31c6cd1506ee8 100755 GIT binary patch delta 947 zcmZ`%T}YEr7(UlJDWNPg0?k?i4b1&1C})iLMUhush66DT?EA(^mC)&p_!(0 zGdMvP6?D_hau9rkVXKSfMWFL%PDiK^NL~mb)J)~)DVMxB3bo&rQK?C8 zjY91gg;qW?DIS7&M!|BA42*#oQJt%MhI~5)M$NTowDzQ0c8>GRfU`@TQ#n~f2s`T} zgjRAo{KLeR=yzFS?4?4iMvBTDaEZ&Idy>f}LSH}?*6^gP$4ABpb z5IvmNSYN|$S3Nwdxo#!mAj{2hp3q*(_7o3lS$R9f! zhg%B&^cVi>pZ#zDDEfVtKPPx-VEq`_8v5hQH(`g*{|?1DKfHjU2b~t{Z-)fX`7K2f zmrY_6X>kbN-_SSqNlYYN2sn_;GrJOVNf)OT`OL6Mj3>Ra)B%Yx^ucPI#gx+JT}5`) z*d%6^mQpUPjJjDrzm^V}veytI;R b&Tz9i<6S?e9ZY&lURXX@b*8seAL{-EYXH`1 delta 947 zcmZ`%O-NKx6u$31XXd^cojao=M2lwZL5vK9i+;d<6ao=kG!UuKMw2ioC`LhQqc9i8 zGMgWR8?>mPMVr9}VkR(A7h;R>-*FTvgP?LDgixEn&bjXm)uIRQ=li~MzI)!`%k4#T zd(k1G2`Y3^AsoUfT!INhxP?bliYnoK%@>CU7jilwtjS3TRiD%(uKw;`K&J?BCS$=0 z)GXv<$HRZnA+`(6Wi7;F^@wJXGsA4+B%)=7n%NPC=%+@AZq8_|*EX#}{7!S-?vH^i zuOxVjz8J5NE5khFcHXHZq(qm34*4R%$637>;qs(x8sU$Oy9%vzIOX;Th|d*V-IoLR zK-4&vt|eVEaG#GGKa|mWgvnO`*=Gfd^RjIeYR@aQ(PPN3qacP=Yw1A7AAr~Z6PD=a z6SoYFfl-$_W$Uy@z8&Kkx%-gc&|b>+BoAp>IgsS$#cUhyE#2vVZ^ApP_Lh$N3vdX{ zhVhwh^`8YBn*D^kNjH0A*ZK&Zuqv+;2fGSe@@Yk^$;)p^e)LS<5<4xMyk!%$Z1R>( zt7Y@1Y*Ve(;bBvj69`pQgCk zIQLKg++Y3k|Lq?|zis&|#p?z?oB&%xe|+f{yy2>yMscAQHel!>r^VK`!|Lhc7ex}6 zO=1Y>QXB$f=sRT+qd=E~4kTxoU5SaHE0ccIFAQ2`lNcGgA-|`2AX4fvP}}j^8YYHr9w>5#+a%_OZY3Hr aywH&GeY~I@PWXyGxczWf7ktH