Unix.UnixFiles.Mod 33 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147
  1. (* Aos, Copyright 2001, Pieter Muller, ETH Zurich *)
  2. MODULE UnixFiles; (** AUTHOR "gf"; PURPOSE "Unix file systems" *)
  3. (* derived fron (SPARCOberon) Files.Mod by J. Templ 1.12. 89/14.05.93 *)
  4. IMPORT S := SYSTEM, Unix, Kernel, Modules, Log := KernelLog, Files;
  5. CONST
  6. NBufs = 4; Bufsize = 4096; NoDesc = -1;
  7. Open = 0; Create = 1; Closed = 2; (* file states *)
  8. NoKey = -1;
  9. CreateFlags = Unix.rdwr + Unix.creat + Unix.trunc;
  10. TraceCollection = 0;
  11. Trace = {};
  12. VAR
  13. tempno: INTEGER;
  14. openfiles: LONGINT;
  15. searchPath: ARRAY 1024 OF CHAR;
  16. cwd: ARRAY 256 OF CHAR;
  17. unixFS: UnixFileSystem; (* must be unique *)
  18. collection: Collection; (* must be unique *)
  19. TYPE
  20. Filename = ARRAY 256 OF CHAR;
  21. NameSet = OBJECT
  22. VAR
  23. name: ARRAY 64 OF CHAR;
  24. left, right: NameSet;
  25. PROCEDURE Add( CONST filename: ARRAY OF CHAR ): BOOLEAN;
  26. (* add filename if it not already exists. else return false *)
  27. BEGIN
  28. IF filename = name THEN RETURN FALSE END;
  29. IF filename < name THEN
  30. IF left = NIL THEN NEW( left, filename ); RETURN TRUE
  31. ELSE RETURN left.Add( filename )
  32. END
  33. ELSE
  34. IF right = NIL THEN NEW( right, filename ); RETURN TRUE
  35. ELSE RETURN right.Add( filename )
  36. END
  37. END
  38. END Add;
  39. PROCEDURE & Init( CONST filename: ARRAY OF CHAR );
  40. BEGIN
  41. COPY( filename, name );
  42. left := NIL; right := NIL
  43. END Init;
  44. END NameSet;
  45. AliasFileSystem = OBJECT (Files.FileSystem)
  46. VAR
  47. fs: UnixFileSystem;
  48. PROCEDURE & Init*( realFS: UnixFileSystem);
  49. BEGIN
  50. SELF.fs := realFS;
  51. END Init;
  52. PROCEDURE New0( name: ARRAY OF CHAR ): Files.File;
  53. VAR f: Files.File;
  54. BEGIN
  55. f := fs.New0( name );
  56. IF f # NIL THEN f.fs := SELF END;
  57. RETURN f;
  58. END New0;
  59. PROCEDURE Old0( name: ARRAY OF CHAR ): Files.File;
  60. VAR f: Files.File;
  61. BEGIN
  62. f := fs.Old0( name );
  63. IF f # NIL THEN f.fs := SELF END;
  64. RETURN f;
  65. END Old0;
  66. PROCEDURE Delete0( name: ARRAY OF CHAR; VAR key, res: LONGINT );
  67. BEGIN
  68. fs.Delete0( name, key, res );
  69. END Delete0;
  70. PROCEDURE Rename0( old, new: ARRAY OF CHAR; fold: Files.File; VAR res: LONGINT );
  71. BEGIN
  72. fs.Rename0( old, new, fold, res );
  73. END Rename0;
  74. PROCEDURE Enumerate0( mask: ARRAY OF CHAR; flags: SET; enum: Files.Enumerator );
  75. BEGIN
  76. fs.Enumerate0( mask, flags, enum );
  77. END Enumerate0;
  78. PROCEDURE FileKey( name: ARRAY OF CHAR ): LONGINT;
  79. VAR
  80. BEGIN
  81. RETURN fs.FileKey( name );
  82. END FileKey;
  83. PROCEDURE CreateDirectory0( name: ARRAY OF CHAR; VAR res: LONGINT );
  84. BEGIN
  85. fs.CreateDirectory0( name, res );
  86. END CreateDirectory0;
  87. PROCEDURE RemoveDirectory0( name: ARRAY OF CHAR; force: BOOLEAN; VAR key, res: LONGINT );
  88. BEGIN
  89. fs.RemoveDirectory0( name, force, key, res );
  90. END RemoveDirectory0;
  91. PROCEDURE Has(CONST name: ARRAY OF CHAR; VAR fullName: ARRAY OF CHAR; VAR flags: SET): BOOLEAN;
  92. BEGIN
  93. RETURN fs.Has(name, fullName, flags);
  94. END Has;
  95. END AliasFileSystem;
  96. FinalizeFiles = OBJECT
  97. PROCEDURE EnumFile( f: ANY; VAR cont: BOOLEAN );
  98. VAR F: File;
  99. BEGIN
  100. F := f( File ); F.Finalize(); cont := TRUE
  101. END EnumFile;
  102. END FinalizeFiles;
  103. SearchByFstat = OBJECT
  104. VAR
  105. found: File;
  106. stat: Unix.Status;
  107. PROCEDURE Init( s: Unix.Status );
  108. BEGIN
  109. found := NIL;
  110. stat := s;
  111. END Init;
  112. PROCEDURE EnumFile( f: ANY; VAR cont: BOOLEAN );
  113. BEGIN
  114. WITH f: File DO
  115. IF (stat.ino = f.ino) & (stat.dev = f.dev) THEN
  116. (* possible different name but same file! *)
  117. ResetBuffers( f, stat );
  118. found := f; cont := FALSE;
  119. END;
  120. END;
  121. END EnumFile;
  122. END SearchByFstat;
  123. Collection = OBJECT (* methods in Collection shared by objects Filesystem and File *)
  124. VAR oldFiles, newFiles: Kernel.FinalizedCollection;
  125. ssearch: SearchByFstat;
  126. fileKey: LONGINT;
  127. PROCEDURE & Init*;
  128. BEGIN
  129. NEW( oldFiles ); NEW( newFiles ); NEW(ssearch); fileKey := -1;
  130. END Init;
  131. PROCEDURE AddNew( F: File );
  132. BEGIN {EXCLUSIVE}
  133. IF TraceCollection IN Trace THEN Log.String( "Collections.AddNew: " ); Log.String( F.workName ); Log.Ln; END;
  134. newFiles.Add( F, FinalizeFile );
  135. END AddNew;
  136. PROCEDURE AddOld( F: File );
  137. BEGIN {EXCLUSIVE}
  138. IF TraceCollection IN Trace THEN Log.String( "Collections.AddOld: " ); Log.String( F.workName ); Log.Ln; END;
  139. oldFiles.Add( F, FinalizeFile );
  140. END AddOld;
  141. PROCEDURE ByStat(CONST stat: Unix.Status): File;
  142. BEGIN{EXCLUSIVE}
  143. ssearch.Init(stat);
  144. oldFiles.EnumerateN(ssearch.EnumFile);
  145. IF ssearch.found = NIL THEN
  146. newFiles.EnumerateN(ssearch.EnumFile)
  147. END;
  148. IF TraceCollection IN Trace THEN
  149. Log.String( "Collections.ByStatus: " ); Log.Ln;
  150. IF ssearch.found = NIL THEN Log.String("not found") ELSE Log.String("found") END;
  151. END;
  152. RETURN ssearch.found;
  153. END ByStat;
  154. PROCEDURE Finalize;
  155. VAR fin: FinalizeFiles;
  156. BEGIN {EXCLUSIVE}
  157. IF TraceCollection IN Trace THEN Log.String( "Collections.Finalize " ); Log.Ln; END;
  158. NEW( fin ); newFiles.Enumerate( fin.EnumFile ); newFiles.Clear(); oldFiles.Enumerate( fin.EnumFile ); oldFiles.Clear();
  159. END Finalize;
  160. PROCEDURE FinalizeFile( obj: ANY );
  161. VAR F: File;
  162. BEGIN
  163. F := obj( File );
  164. IF TraceCollection IN Trace THEN Log.String( "Collections.FinalizeFile " ); Log.String( F.workName ); Log.Ln; END;
  165. F.Finalize()
  166. END FinalizeFile;
  167. END Collection;
  168. UnixFileSystem* = OBJECT (Files.FileSystem)
  169. PROCEDURE & Init;
  170. BEGIN
  171. prefix := ""; vol := NIL; desc := "UnixFS"
  172. END Init;
  173. PROCEDURE New0*( name: ARRAY OF CHAR ): Files.File;
  174. VAR f: File; stat: Unix.Status;
  175. res,err: LONGINT;
  176. path,nameonly: ARRAY 512 OF CHAR;
  177. BEGIN {EXCLUSIVE}
  178. (*AwaitFinalizingDone;*)
  179. (*first check if the path actually exits first using fstat. fstat returns -1 and sets erno to ENOENT when a component of the path doesn't exist or the entire path is empty*)
  180. Files.SplitPath(name,path, nameonly);
  181. res:=Unix.stat( ADDRESSOF( path ), stat ) ;
  182. err:=Unix.errno();
  183. IF (name="") OR (path="") OR (res>=0) OR (err#Unix.ENOENT) THEN
  184. NEW( f, SELF );
  185. f.workName := ""; COPY( name, f.registerName );
  186. f.fd := NoDesc; f.state := Create; f.fsize := 0; f.fpos := 0;
  187. f.swapper := -1; (*all f.buf[i] = NIL*)
  188. f.key := NoKey; f.fs := SELF;
  189. RETURN f;
  190. ELSE
  191. Log.String( "UnixFileSystem.New0: file allocation failed. Probably a nonexistent path." ); Log.Ln;
  192. RETURN NIL;
  193. END;
  194. END New0;
  195. PROCEDURE IsDirectory( VAR stat: Unix.Status ): BOOLEAN;
  196. VAR mode: LONGINT;
  197. BEGIN
  198. mode := stat.mode;
  199. RETURN ODD( mode DIV 4000H )
  200. END IsDirectory;
  201. PROCEDURE Old0*( name: ARRAY OF CHAR ): Files.File;
  202. VAR f: File; stat: Unix.Status; fd, r, errno, pos: LONGINT;
  203. oflags: SET; nextdir, path: Filename; fo: LONGINT;
  204. BEGIN {EXCLUSIVE}
  205. IF name = "" THEN RETURN NIL END;
  206. IF IsFullName( name ) THEN
  207. COPY( name, path ); nextdir := "";
  208. ELSE
  209. pos := 0; ScanPath( pos, nextdir ); MakePath( nextdir, name, path );
  210. ScanPath( pos, nextdir )
  211. END;
  212. LOOP
  213. r := Unix.access( ADDRESSOF( path ), Unix.R_OK );
  214. IF r >= 0 THEN
  215. r := Unix.access( ADDRESSOF( path ), Unix.W_OK );
  216. IF r < 0 THEN oflags := Unix.rdonly ELSE oflags := Unix.rdwr END;
  217. fd := Unix.open( ADDRESSOF( path ), oflags, {} ); errno := Unix.errno();
  218. IF ((fd < 0) & (errno IN {Unix.ENFILE, Unix.EMFILE, Unix.EINVAL})) THEN
  219. REPEAT
  220. fo := openfiles; Kernel.GC; WaitClose( fo );
  221. fd := Unix.open( ADDRESSOF( path ), oflags, {} ); errno := Unix.errno();
  222. UNTIL (fd >= 0) OR ~ (errno IN {Unix.ENFILE, Unix.EMFILE, Unix.EINVAL})
  223. END;
  224. IF fd >= 0 THEN
  225. r := Unix.fstat( fd, stat );
  226. f := collection.ByStat(stat);
  227. IF f # NIL THEN
  228. (* use the file already cached *) r := Unix.close( fd ); EXIT
  229. ELSE
  230. NEW( f, SELF );
  231. f.fd := fd; f.dev := stat.dev; f.ino := stat.ino;
  232. f.mtime := stat.mtime.sec; f.fsize := stat.size; f.fpos := 0;
  233. f.state := Open; f.swapper := -1; (*all f.buf[i] = NIL*)
  234. COPY( path, f.workName ); f.registerName := "";
  235. f.tempFile := FALSE;
  236. IF IsDirectory( stat ) THEN
  237. f.flags := {Files.Directory, Files.ReadOnly}
  238. ELSIF oflags = Unix.rdonly THEN
  239. f.flags := {Files.ReadOnly}
  240. END;
  241. f.key := NoKey; f.fs := SELF;
  242. IncOpenFiles();
  243. collection.AddOld(f);
  244. EXIT
  245. END
  246. END
  247. ELSIF nextdir # "" THEN
  248. MakePath( nextdir, name, path ); ScanPath( pos, nextdir );
  249. ELSE
  250. f := NIL; EXIT
  251. END;
  252. END; (* loop *)
  253. RETURN f
  254. END Old0;
  255. (** Return the unique non-zero key of the named file, if it exists. *)
  256. PROCEDURE FileKey*( name: ARRAY OF CHAR ): LONGINT;
  257. (* Can not be used for Unix files as LONGINT is too small.
  258. In the Unix filesystem a file is identified by
  259. - dev (64 bit (Linux), 32 bit (Solaris, Darwin)) +
  260. - ino (32 bit)
  261. *)
  262. BEGIN
  263. RETURN 0
  264. END FileKey;
  265. PROCEDURE Delete0*( name: ARRAY OF CHAR; VAR key, res: LONGINT );
  266. VAR r: LONGINT;
  267. BEGIN {EXCLUSIVE}
  268. r := Unix.unlink( ADDRESSOF( name ) );
  269. IF r = 0 THEN res := Files.Ok
  270. ELSE res := Unix.errno( )
  271. END;
  272. key := 0;
  273. END Delete0;
  274. (* return remaining old file, if any *)
  275. PROCEDURE TryRename*( old, new: ARRAY OF CHAR; f: Files.File; VAR res: LONGINT ): LONGINT;
  276. CONST Bufsize = 4096;
  277. VAR fdold, fdnew, fo, n, r: LONGINT; ostat, nstat: Unix.Status;
  278. buf: ARRAY Bufsize OF CHAR;
  279. BEGIN {EXCLUSIVE}
  280. fo := NoDesc;
  281. r:= Unix.stat( ADDRESSOF( old ), ostat );
  282. IF r >= 0 THEN
  283. r := Unix.stat( ADDRESSOF( new ), nstat );
  284. IF (r >= 0) & ((ostat.dev # nstat.dev) OR (ostat.ino # nstat.ino)) THEN
  285. r := Unix.unlink( ADDRESSOF( new ) ) (* work around stale nfs handles *);
  286. END;
  287. r := Unix.rename( ADDRESSOF( old ), ADDRESSOF( new ) );
  288. IF r < 0 THEN (* could not rename, try copy *)
  289. res := Unix.errno( );
  290. IF (res = Unix.EXDEV) OR (res = Unix.ETXTBSY) THEN (* cross device link, move the file / file busy frequently happens in VirtualBox *)
  291. fdold := Unix.open( ADDRESSOF( old ), Unix.rdonly, {} );
  292. fo := fdold;
  293. IF fdold < 0 THEN
  294. res := Unix.errno( );
  295. RETURN NoDesc;
  296. END;
  297. fdnew := Unix.open( ADDRESSOF( new ), Unix.rdwr + Unix.creat + Unix.trunc, Unix.rwrwr );
  298. IF fdnew < 0 THEN
  299. res := Unix.errno( );
  300. RETURN NoDesc;
  301. END;
  302. n := Unix.read( fdold, ADDRESSOF( buf ), Bufsize );
  303. WHILE n > 0 DO
  304. r := Unix.write( fdnew, ADDRESSOF( buf ), n );
  305. IF r < 0 THEN
  306. res := Unix.errno();
  307. r := Unix.close( fdold );
  308. r := Unix.close( fdnew );
  309. RETURN NoDesc;
  310. END;
  311. n := Unix.read( fdold, ADDRESSOF( buf ), Bufsize )
  312. END;
  313. r := Unix.unlink( ADDRESSOF( old ) );
  314. r := Unix.close( fdold );
  315. r := Unix.close( fdnew );
  316. res := Files.Ok
  317. ELSE
  318. RETURN NoDesc (* res is Unix.rename return code *)
  319. END
  320. END;
  321. res := Files.Ok
  322. ELSE
  323. res := Unix.errno();
  324. END;
  325. RETURN fo;
  326. END TryRename;
  327. PROCEDURE Rename0*( old, new: ARRAY OF CHAR; f: Files.File; VAR res: LONGINT );
  328. VAR of: LONGINT;
  329. BEGIN
  330. of := TryRename(old, new, f, res);
  331. END Rename0;
  332. PROCEDURE CreateDirectory0*( path: ARRAY OF CHAR; VAR res: LONGINT );
  333. VAR r: LONGINT;
  334. BEGIN {EXCLUSIVE}
  335. r := Unix.mkdir( ADDRESSOF( path ), Unix.rwxrwxrwx );
  336. IF r = 0 THEN res := Files.Ok
  337. ELSE res := Unix.errno( )
  338. END
  339. END CreateDirectory0;
  340. PROCEDURE RemoveDirectory0*( path: ARRAY OF CHAR; force: BOOLEAN; VAR key, res: LONGINT );
  341. VAR r: LONGINT;
  342. BEGIN {EXCLUSIVE}
  343. r := Unix.rmdir( ADDRESSOF( path ) );
  344. IF r = 0 THEN res := Files.Ok
  345. ELSE res := Unix.errno( )
  346. END
  347. END RemoveDirectory0;
  348. PROCEDURE Enumerate0*( mask: ARRAY OF CHAR; flags: SET; enum: Files.Enumerator );
  349. VAR
  350. path, filemask: Filename;
  351. isPath: BOOLEAN;
  352. i, j: INTEGER; dirName, fileName, fullName, xName: Filename;
  353. checkSet: NameSet; ent: Unix.Dirent;
  354. PROCEDURE GetEntryName;
  355. VAR i: INTEGER; adr: ADDRESS;
  356. BEGIN
  357. i := -1; adr := ADDRESSOF( ent.name );
  358. REPEAT INC( i ); S.GET( adr, fileName[i] ); INC( adr ) UNTIL fileName[i] = 0X
  359. END GetEntryName;
  360. PROCEDURE EnumDir( CONST dirName: ARRAY OF CHAR );
  361. VAR
  362. dir: ADDRESS;
  363. tm: Unix.TmPtr; date, time: LONGINT;
  364. stat: Unix.Status; r: LONGINT;
  365. BEGIN
  366. dir := Unix.opendir( ADDRESSOF( dirName ) );
  367. IF dir # 0 THEN
  368. ent := Unix.readdir( dir );
  369. WHILE ent # NIL DO
  370. COPY( dirName, fullName );
  371. GetEntryName; AppendName( fullName, fileName );
  372. IF (fileName[0] # '.') & Match( fileName, filemask, 0, 0 ) THEN
  373. IF checkSet.Add( fileName ) THEN (* not a covered name *)
  374. r := Unix.stat( ADDRESSOF( fullName ), stat );
  375. tm := Unix.localtime( stat.mtime );
  376. date := tm.year*200H + (tm.mon + 1)*20H + tm.mday;
  377. time := tm.hour*1000H + tm.min*40H + tm.sec;
  378. flags := {};
  379. IF IsDirectory( stat ) THEN
  380. flags := {Files.ReadOnly, Files.Directory}
  381. ELSE
  382. r := Unix.access( ADDRESSOF( fullName ), Unix.W_OK );
  383. IF r < 0 THEN flags := {Files.ReadOnly} END
  384. END;
  385. r := Unix.realpath(ADDRESSOF(fullName), ADDRESSOF(xName));
  386. IF (r # 0) THEN COPY(xName, fullName) END;
  387. enum.PutEntry( fullName, flags, time, date, stat.size );
  388. END
  389. END;
  390. ent := Unix.readdir( dir );
  391. END;
  392. Unix.closedir( dir )
  393. END;
  394. END EnumDir;
  395. BEGIN {EXCLUSIVE}
  396. Files.SplitName( mask, prefix, fullName );
  397. Files.SplitPath( fullName, path, filemask );
  398. NEW( checkSet, "M###N" );
  399. isPath:= path#"";
  400. IF isPath THEN
  401. CleanPath(path); (*get rid of xxx/../xxx and xxx/./xxx in the path string*)
  402. END;
  403. IF isPath & (path[0] = '/') THEN (*check for absolute path*)
  404. EnumDir( path);
  405. ELSE (*no path or relative path*)
  406. i := 0; j := 0;
  407. LOOP (*go through the search paths, every time a complete search path has been traversed, look for the element there*)
  408. IF (searchPath[i] = " ") OR (searchPath[i] = 0X) THEN
  409. dirName[j] := 0X;
  410. IF isPath THEN (*if relative path: add relative path to the current search path*)
  411. Files.JoinPath(dirName, path, dirName);
  412. END;
  413. EnumDir( dirName );
  414. IF searchPath[i] = 0X THEN EXIT
  415. ELSE INC( i ); j := 0
  416. END
  417. ELSE
  418. dirName[j] := searchPath[i]; INC( j ); INC( i )
  419. END
  420. END
  421. END;
  422. checkSet := NIL;
  423. END Enumerate0;
  424. PROCEDURE Has(CONST name: ARRAY OF CHAR; VAR fullName: ARRAY OF CHAR; VAR flags: SET): BOOLEAN;
  425. VAR r: LONGINT;stat: Unix.Status;
  426. BEGIN
  427. r := Unix.stat( ADDRESSOF( name ), stat );
  428. TRACE(r);
  429. IF r # 0 THEN RETURN FALSE END;
  430. flags := {};
  431. IF IsDirectory( stat ) THEN
  432. flags := {Files.ReadOnly, Files.Directory}
  433. ELSE
  434. r := Unix.access( ADDRESSOF( name ), Unix.W_OK );
  435. IF r < 0 THEN flags := {Files.ReadOnly} END
  436. END;
  437. r := Unix.realpath(ADDRESSOF(name), ADDRESSOF(fullName));
  438. TRACE(r,name,fullName);
  439. IF (r = 0) THEN COPY(name, fullName) END; (* no success *)
  440. RETURN TRUE;
  441. END Has;
  442. END UnixFileSystem;
  443. Buffer = POINTER TO RECORD (Files.Hint)
  444. chg: BOOLEAN;
  445. org, size: LONGINT;
  446. data: ARRAY Bufsize OF CHAR;
  447. END;
  448. File* = OBJECT (Files.File)
  449. VAR
  450. fd: LONGINT;
  451. workName, registerName: Filename;
  452. tempFile: BOOLEAN;
  453. dev: Unix.DevT;
  454. ino: LONGINT;
  455. mtime: HUGEINT;
  456. fsize, fpos: SIZE;
  457. bufs: ARRAY NBufs OF Buffer;
  458. swapper, state: LONGINT;
  459. PROCEDURE & Init( fs: Files.FileSystem );
  460. BEGIN
  461. SELF.fs := fs; flags := {};
  462. END Init;
  463. PROCEDURE CreateUnixFile;
  464. VAR
  465. stat: Unix.Status; done: BOOLEAN; errno,fo: LONGINT;
  466. BEGIN
  467. IF state = Create THEN
  468. GetTempName( registerName, workName ); tempFile := TRUE
  469. ELSIF state = Closed THEN
  470. IF registerName # "" THEN
  471. workName := registerName; registerName := ""; tempFile := FALSE;
  472. ELSE
  473. RETURN;
  474. END;
  475. END;
  476. errno := Unix.unlink( ADDRESSOF( workName ) );
  477. (*unlink first to avoid stale NFS handles and to avoid reuse of inodes*)
  478. fd := Unix.open( ADDRESSOF( workName ), CreateFlags, Unix.rwrwr );
  479. done := fd >= 0; errno := Unix.errno();
  480. IF ( (~done) & (errno IN {Unix.ENFILE, Unix.EMFILE, Unix.EINVAL})) THEN
  481. REPEAT
  482. fo := openfiles; Kernel.GC; WaitClose( fo );
  483. fd := Unix.open( ADDRESSOF( workName ), CreateFlags, Unix.rwrwr); errno := Unix.errno();
  484. UNTIL (fd >= 0) OR ~ (errno IN {Unix.ENFILE, Unix.EMFILE, Unix.EINVAL});
  485. done := fd >= 0
  486. END;
  487. IF done THEN
  488. errno := Unix.fstat( fd, stat );
  489. dev := stat.dev; ino := stat.ino; mtime := stat.mtime.sec;
  490. state := Open; fpos := 0;
  491. IncOpenFiles();
  492. collection.AddNew(SELF);
  493. ELSE
  494. Halt( SELF, TRUE, "UnixFiles.File.Create: open failed" );
  495. END
  496. END CreateUnixFile;
  497. PROCEDURE Flush( buf: Buffer );
  498. VAR res: LONGINT; stat: Unix.Status;
  499. BEGIN
  500. IF buf.chg THEN
  501. IF fd = NoDesc THEN CreateUnixFile END;
  502. IF buf.org # fpos THEN res := Unix.lseek( fd, buf.org, 0 ) END;
  503. res := Unix.write( fd, ADDRESSOF( buf.data ), buf.size );
  504. IF res < 0 THEN Halt( SELF, TRUE, "UnixFiles.File.Flush: write failed" ) END;
  505. fpos := buf.org + buf.size; buf.chg := FALSE;
  506. res := Unix.fstat( fd, stat ); mtime := stat.mtime.sec
  507. END
  508. END Flush;
  509. PROCEDURE Set*( VAR r: Files.Rider; pos: LONGINT );
  510. BEGIN {EXCLUSIVE}
  511. SetX( r, pos )
  512. END Set;
  513. PROCEDURE SetX( VAR r: Files.Rider; p: LONGINT );
  514. VAR org, offset, i, n, res: LONGINT; buf: Buffer;
  515. BEGIN
  516. IF p > fsize THEN p := LONGINT(fsize)
  517. ELSIF p < 0 THEN p := 0
  518. END;
  519. offset := p MOD Bufsize; org := p - offset;
  520. i := 0;
  521. WHILE (i < NBufs) & (bufs[i] # NIL) & (org # bufs[i].org) DO INC( i ) END;
  522. IF i < NBufs THEN
  523. IF bufs[i] = NIL THEN
  524. NEW( buf ); buf.chg := FALSE; buf.org := -1;
  525. bufs[i] := buf
  526. ELSE
  527. swapper := i;
  528. buf := bufs[swapper]; Flush( buf )
  529. END
  530. ELSE
  531. swapper := (swapper + 1) MOD NBufs;
  532. buf := bufs[swapper]; Flush( buf )
  533. END;
  534. IF buf.org # org THEN
  535. IF org = fsize THEN
  536. buf.size := 0
  537. ELSE
  538. IF fd = NoDesc THEN CreateUnixFile END;
  539. IF fpos # org THEN res := Unix.lseek( fd, org, 0 ) END;
  540. IF res < 0 THEN Halt( SELF, TRUE, "UnixFiles.File.Set: lseek failed" ) END;
  541. n := Unix.read( fd, ADDRESSOF( buf.data ), Bufsize );
  542. IF n < 0 THEN
  543. IF p < fsize THEN Halt( SELF, TRUE, "UnixFiles.File.Set: read failed" )
  544. ELSE n := 0
  545. END
  546. END;
  547. fpos := org + n; buf.size := n
  548. END;
  549. buf.org := org; buf.chg := FALSE
  550. ELSE
  551. org := buf.org
  552. END;
  553. r.hint := buf; r.apos := org; r.bpos := offset;
  554. r.res := 0; r.eof := FALSE;
  555. r.file := SELF; r.fs := fs
  556. END SetX;
  557. PROCEDURE Pos*( VAR r: Files.Rider ): LONGINT;
  558. BEGIN
  559. RETURN r.apos + r.bpos
  560. END Pos;
  561. PROCEDURE Read*( VAR r: Files.Rider; VAR x: CHAR );
  562. VAR offset: LONGINT; buf: Buffer;
  563. BEGIN {EXCLUSIVE}
  564. buf := r.hint(Buffer); offset := r.bpos;
  565. IF r.apos # buf.org THEN
  566. SetX( r, r.apos + offset );
  567. buf := r.hint(Buffer); offset := r.bpos
  568. END;
  569. IF (offset < buf.size) THEN
  570. x := buf.data[offset]; r.bpos := offset + 1
  571. ELSIF r.apos + offset < fsize THEN
  572. SetX( r, r.apos + offset );
  573. x := r.hint(Buffer).data[0]; r.bpos := 1
  574. ELSE
  575. x := 0X; r.eof := TRUE
  576. END
  577. END Read;
  578. PROCEDURE ReadBytes*( VAR r: Files.Rider; VAR x: ARRAY OF CHAR; ofs, len: LONGINT );
  579. VAR xpos, min, restInBuf, offset: LONGINT; buf: Buffer;
  580. BEGIN {EXCLUSIVE}
  581. x[ofs] := 0X; xpos := ofs;
  582. buf := r.hint(Buffer); offset := r.bpos;
  583. WHILE len > 0 DO
  584. IF (r.apos # buf.org) OR (offset >= Bufsize) THEN
  585. SetX( r, r.apos + offset );
  586. buf := r.hint(Buffer); offset := r.bpos
  587. END;
  588. restInBuf := buf.size - offset;
  589. IF restInBuf = 0 THEN r.res := len; r.eof := TRUE; RETURN
  590. ELSIF len > restInBuf THEN min := restInBuf
  591. ELSE min := len
  592. END;
  593. S.MOVE( ADDRESSOF( buf.data ) + offset, ADDRESSOF( x ) + xpos, min );
  594. INC( offset, min ); r.bpos := offset;
  595. INC( xpos, min ); DEC( len, min )
  596. END;
  597. r.res := 0; r.eof := FALSE;
  598. END ReadBytes;
  599. PROCEDURE Write*( VAR r: Files.Rider; x: CHAR );
  600. VAR buf: Buffer; offset: LONGINT;
  601. BEGIN {EXCLUSIVE}
  602. buf := r.hint(Buffer); offset := r.bpos;
  603. IF (r.apos # buf.org) OR (offset >= Bufsize) THEN
  604. SetX( r, r.apos + offset );
  605. buf := r.hint(Buffer); offset := r.bpos
  606. END;
  607. buf.data[offset] := x; buf.chg := TRUE;
  608. IF offset = buf.size THEN INC( buf.size ); INC( fsize ) END;
  609. r.bpos := offset + 1; r.res := Files.Ok
  610. END Write;
  611. PROCEDURE WriteBytes*( VAR r: Files.Rider; CONST x: ARRAY OF CHAR; ofs, len: LONGINT );
  612. VAR xpos, min, restInBuf, offset: LONGINT; buf: Buffer;
  613. BEGIN {EXCLUSIVE}
  614. xpos := ofs; buf := r.hint(Buffer); offset := r.bpos;
  615. WHILE len > 0 DO
  616. IF (r.apos # buf.org) OR (offset >= Bufsize) THEN
  617. SetX( r, r.apos + offset );
  618. buf := r.hint(Buffer); offset := r.bpos
  619. END;
  620. restInBuf := Bufsize - offset;
  621. IF len > restInBuf THEN min := restInBuf ELSE min := len END;
  622. S.MOVE( ADDRESSOF( x ) + xpos, ADDRESSOF( buf.data ) + offset, min );
  623. INC( offset, min ); r.bpos := offset;
  624. IF offset > buf.size THEN
  625. INC( fsize, offset - buf.size ); buf.size := offset
  626. END;
  627. INC( xpos, min ); DEC( len, min ); buf.chg := TRUE
  628. END;
  629. r.res := Files.Ok
  630. END WriteBytes;
  631. PROCEDURE Length*( ): LONGINT;
  632. BEGIN
  633. RETURN LONGINT(fsize)
  634. END Length;
  635. PROCEDURE GetDate*( VAR t, d: LONGINT );
  636. VAR stat: Unix.Status; r: LONGINT; time: Unix.TmPtr;
  637. BEGIN {EXCLUSIVE}
  638. IF fd = NoDesc THEN CreateUnixFile END;
  639. r := Unix.fstat( fd, stat );
  640. time := Unix.localtime( stat.mtime );
  641. t := time.sec + ASH( time.min, 6 ) + ASH( time.hour, 12 );
  642. d := time.mday + ASH( time.mon + 1, 5 ) + ASH( time.year, 9 );
  643. END GetDate;
  644. PROCEDURE SetDate*( t, d: LONGINT );
  645. TYPE
  646. Time = RECORD actime, modtime: LONGINT END;
  647. VAR
  648. tm: Unix.Tm; buf: Time; r: LONGINT; path: Filename;
  649. BEGIN {EXCLUSIVE}
  650. IF registerName # "" THEN COPY( registerName, path )
  651. ELSE COPY( workName, path )
  652. END;
  653. (* get year and timezone *)
  654. (* fill in new date *)
  655. tm.isdst := -1; tm.sec := t MOD 64; tm.min := t DIV 64 MOD 64;
  656. tm.hour := t DIV 4096 MOD 32;
  657. tm.mday := d MOD 32; tm.mon := d DIV 32 MOD 16 - 1; tm.year := d DIV 512;
  658. tm.wday := 0; tm.yday := 0;
  659. buf.actime := Unix.mktime( tm ); buf.modtime := buf.actime;
  660. r := Unix.utime( ADDRESSOF( path ), ADDRESSOF( buf ) );
  661. END SetDate;
  662. PROCEDURE GetAttributes*( ): SET;
  663. BEGIN {EXCLUSIVE}
  664. RETURN flags
  665. END GetAttributes;
  666. PROCEDURE SetAttributes*( attr: SET );
  667. BEGIN {EXCLUSIVE}
  668. (* flags := attr *)
  669. END SetAttributes;
  670. PROCEDURE Register0*( VAR res: LONGINT );
  671. VAR fo: LONGINT;
  672. BEGIN {EXCLUSIVE}
  673. IF (state = Create) & (registerName # "") THEN
  674. state := Closed (* shortcut renaming *) ;
  675. END;
  676. FlushBuffers;
  677. IF registerName # "" THEN
  678. fo := unixFS.TryRename( workName, registerName, SELF, res );
  679. IF res # Files.Ok THEN
  680. Halt( SELF, FALSE, "UnixFiles.File.Register: rename failed" )
  681. END;
  682. IF fo # NoDesc THEN (* SELF still refers to old file *)
  683. res := Unix.close(fd);
  684. res := Unix.unlink(ADDRESSOF(workName)); (* VirtualBox ! Can only delete file when closed. *)
  685. fd := Unix.open( ADDRESSOF( registerName ), Unix.rdwr, Unix.rwrwr );
  686. END;
  687. workName := registerName; registerName := ""; tempFile := FALSE;
  688. END;
  689. (*collection.Register(SELF);*)
  690. END Register0;
  691. PROCEDURE Update*;
  692. BEGIN {EXCLUSIVE}
  693. FlushBuffers
  694. END Update;
  695. PROCEDURE FlushBuffers;
  696. VAR i: LONGINT;
  697. BEGIN
  698. IF fd = NoDesc THEN CreateUnixFile END;
  699. FOR i := 0 TO NBufs - 1 DO
  700. IF bufs[i] # NIL THEN Flush( bufs[i] ) END
  701. END;
  702. END FlushBuffers;
  703. PROCEDURE Finalize*;
  704. VAR r: LONGINT;
  705. BEGIN {EXCLUSIVE}
  706. IF tempFile THEN
  707. IF fd # NoDesc THEN r := Unix.close(fd) END;
  708. r := Unix.unlink( ADDRESSOF( registerName ) );
  709. fd := NoDesc;
  710. ELSE
  711. FlushBuffers;
  712. IF fd # NoDesc THEN
  713. r := Unix.close( fd );
  714. fd := NoDesc;
  715. END;
  716. END;
  717. DecOpenFiles();
  718. state := Closed;
  719. END Finalize;
  720. PROCEDURE Close;
  721. BEGIN
  722. Finalize;
  723. collection.oldFiles.Remove(SELF);
  724. END Close;
  725. PROCEDURE GetName*( VAR name: ARRAY OF CHAR );
  726. BEGIN {EXCLUSIVE}
  727. IF registerName = "" THEN COPY( workName, name ) ;
  728. ELSE COPY( registerName, name )
  729. END;
  730. CleanPath( name )
  731. END GetName;
  732. END File;
  733. (*===================================================================*)
  734. (** Get the current directory. *)
  735. PROCEDURE GetWorkingDirectory*( VAR path: ARRAY OF CHAR );
  736. BEGIN
  737. COPY( cwd, path )
  738. END GetWorkingDirectory;
  739. (** Change to directory path. *)
  740. PROCEDURE ChangeDirectory*( CONST path: ARRAY OF CHAR; VAR done: BOOLEAN );
  741. VAR r: LONGINT; newdir: Filename;
  742. BEGIN
  743. IF path[0] # '/' THEN
  744. COPY( cwd, newdir ); AppendName( newdir, path );
  745. CleanPath( newdir )
  746. ELSE
  747. COPY( path, newdir );
  748. END;
  749. r := Unix.chdir( ADDRESSOF( newdir ) );
  750. IF r = 0 THEN COPY( newdir, cwd ); done := TRUE ELSE done := FALSE END
  751. END ChangeDirectory;
  752. (*===================================================================*)
  753. PROCEDURE StripPath*( CONST path: ARRAY OF CHAR; VAR name: ARRAY OF CHAR );
  754. VAR i, p: INTEGER; c: CHAR;
  755. BEGIN
  756. i := 0; p := 0;
  757. REPEAT
  758. IF path[i] = '/' THEN p := i + 1 END;
  759. INC( i )
  760. UNTIL path[i] = 0X;
  761. i := 0;
  762. REPEAT c := path[p]; name[i] := c; INC( i ); INC( p ) UNTIL c = 0X
  763. END StripPath;
  764. PROCEDURE CleanPath*( VAR path: ARRAY OF CHAR );
  765. (*
  766. /aaa/../bbb/./ccc/../ddd/. ==> /bbb/ddd
  767. ../aaa ==> CWD/../aaa ==> . . .
  768. *)
  769. VAR
  770. i, prevNameStart, nameStart: INTEGER;
  771. c1, c2, c3: CHAR;
  772. PROCEDURE prependCWD;
  773. VAR tmp: ARRAY 256 OF CHAR;
  774. BEGIN
  775. COPY( cwd, tmp ); AppendName( tmp, path ); COPY( tmp, path )
  776. END prependCWD;
  777. PROCEDURE restart;
  778. BEGIN
  779. IF path[0] = '/' THEN nameStart := 1 ELSE nameStart := 0 END;
  780. i := -1; prevNameStart := -1;
  781. END restart;
  782. PROCEDURE shift( p0, p1: INTEGER );
  783. VAR c: CHAR;
  784. BEGIN
  785. REPEAT c := path[p1]; path[p0] := c; INC( p0 ); INC( p1 ) UNTIL c = 0X;
  786. IF p0 > 1 THEN restart ELSE i := 0 END
  787. END shift;
  788. BEGIN
  789. restart;
  790. REPEAT
  791. INC( i );
  792. IF i = nameStart THEN
  793. c1 := path[i]; c2 := path[i + 1]; c3 := path[i + 2];
  794. IF c1 = '/' THEN shift( i, i + 1 ) (* // *)
  795. ELSIF c1 = '.' THEN
  796. IF c2 = 0X THEN
  797. IF i > 1 THEN DEC( i ) END;
  798. path[i] := 0X
  799. ELSIF c2 = '/' THEN shift( i, i + 2 ); (* ./ *)
  800. ELSIF (c2 = '.') & ((c3 = 0X) OR (c3 = '/')) THEN (* .. *)
  801. IF i = 0 THEN prependCWD; restart
  802. ELSIF c3 = 0X THEN DEC( i ); path[i] := 0X
  803. ELSIF c3 = '/' THEN (* ../ *)
  804. IF prevNameStart >= 0 THEN shift( prevNameStart, i + 3 ) END
  805. END
  806. END
  807. END
  808. ELSIF path[i] = '/' THEN
  809. IF i > 0 THEN prevNameStart := nameStart END;
  810. nameStart := i + 1
  811. END;
  812. UNTIL (i >= 0) & (path[i] = 0X);
  813. IF (i > 1) & (path[i - 1] = '/') THEN path[i - 1] := 0X END;
  814. IF path = "" THEN path := "." END;
  815. END CleanPath;
  816. PROCEDURE Match( CONST name, pat: ARRAY OF CHAR; i, j: INTEGER ): BOOLEAN;
  817. BEGIN
  818. IF (name[i] = 0X) & (pat[j] = 0X) THEN RETURN TRUE
  819. ELSIF pat[j] # "*" THEN RETURN (name[i] = pat[j]) & Match( name, pat, i + 1, j + 1 )
  820. ELSE (* pat[j] = "*", name[i] may be 0X *)
  821. RETURN Match( name, pat, i, j + 1 ) OR ((name[i] # 0X) & Match( name, pat, i + 1, j ))
  822. END
  823. END Match;
  824. PROCEDURE Append( VAR a: Filename; CONST this: ARRAY OF CHAR );
  825. VAR i, j: LONGINT;
  826. BEGIN
  827. i := 0; j := 0;
  828. WHILE a[i] # 0X DO INC( i ) END;
  829. WHILE (i < LEN( a ) - 1) & (this[j] # 0X) DO a[i] := this[j]; INC( i ); INC( j ) END;
  830. a[i] := 0X
  831. END Append;
  832. PROCEDURE AppendName( VAR path: Filename; CONST filename: ARRAY OF CHAR );
  833. VAR i, j, max: LONGINT;
  834. BEGIN
  835. i := 0; j := 0; max := LEN( path ) - 1;
  836. WHILE path[i] # 0X DO INC( i ) END;
  837. IF (i > 0) & (path[i - 1] # "/") THEN path[i] := "/"; INC( i ); path[i] := 0X END;
  838. Append( path, filename );
  839. END AppendName;
  840. PROCEDURE AppendInt( VAR str: Filename; n: LONGINT );
  841. VAR i: LONGINT;
  842. BEGIN
  843. i := 0;
  844. WHILE str[i] # 0X DO INC(i) END;
  845. WHILE n > 0 DO str[i] := CHR( n MOD 10 + ORD('0') ); n := n DIV 10; INC(i) END;
  846. str[i] := 0X
  847. END AppendInt;
  848. PROCEDURE IsFullName( CONST name: ARRAY OF CHAR ): BOOLEAN;
  849. VAR i: INTEGER; ch: CHAR;
  850. BEGIN
  851. i := 0; ch := name[0];
  852. WHILE (ch # 0X) & (ch # "/") DO INC( i ); ch := name[i] END;
  853. RETURN ch = "/"
  854. END IsFullName;
  855. PROCEDURE Halt( f: File; unixError: BOOLEAN; CONST msg: ARRAY OF CHAR );
  856. VAR fd, errno: LONGINT;
  857. workName, registerName: Filename;
  858. BEGIN
  859. IF f = NIL THEN
  860. workName := "???"; registerName := "???"
  861. ELSE
  862. workName := f.workName; registerName := f.registerName; fd := f.fd
  863. END;
  864. IF unixError THEN errno := Unix.errno( ); Unix.Perror( msg ) END;
  865. HALT( 99 )
  866. END Halt;
  867. PROCEDURE ResetBuffers( f: File; VAR stat: Unix.Status );
  868. VAR i: INTEGER;
  869. BEGIN
  870. f.fsize := stat.size;
  871. IF (f.mtime # stat.mtime.sec) THEN
  872. FOR i := 0 TO NBufs - 1 DO
  873. IF f.bufs[i] # NIL THEN f.bufs[i].org := -1; f.bufs[i] := NIL END;
  874. END;
  875. f.swapper := -1; f.mtime := stat.mtime.sec
  876. END
  877. END ResetBuffers;
  878. PROCEDURE MakePath( CONST dir, name: ARRAY OF CHAR; VAR dest: ARRAY OF CHAR );
  879. VAR i, j: INTEGER;
  880. BEGIN
  881. i := 0; j := 0;
  882. WHILE dir[i] # 0X DO dest[i] := dir[i]; INC( i ) END;
  883. IF (i>0) & (dest[i - 1] # "/") THEN dest[i] := "/"; INC( i ) END;
  884. WHILE name[j] # 0X DO dest[i] := name[j]; INC( i ); INC( j ) END;
  885. dest[i] := 0X
  886. END MakePath;
  887. PROCEDURE ScanPath( VAR pos: LONGINT; VAR dir: ARRAY OF CHAR );
  888. VAR i: LONGINT; ch: CHAR;
  889. BEGIN
  890. i := 0; ch := searchPath[pos];
  891. WHILE ch = " " DO INC( pos ); ch := searchPath[pos] END;
  892. WHILE ch > " " DO dir[i] := ch; INC( i ); INC( pos ); ch := searchPath[pos] END;
  893. dir[i] := 0X
  894. END ScanPath;
  895. PROCEDURE GetTempName( CONST finalName: ARRAY OF CHAR; VAR tempName: Filename );
  896. VAR n, i, j, pe, pid: LONGINT;
  897. BEGIN
  898. INC(tempno); n := tempno; i := 0; j := 0; pe := 1;
  899. WHILE finalName[j] = ' ' DO INC(j) END; (* skip leading spaces *)
  900. IF finalName[j] # "/" THEN (* relative pathname *)
  901. WHILE cwd[i] # 0X DO tempName[i] := cwd[i]; INC(i) END;
  902. IF tempName[i - 1] # '/' THEN tempName[i] := '/'; INC(i) END;
  903. pe := i - 1
  904. END;
  905. WHILE finalName[j] # 0X DO tempName[i] := finalName[j]; INC(i); INC(j) END;
  906. WHILE (i > pe) & (tempName[i-1] # '/') DO DEC(i) END; (* remove filename *)
  907. tempName[i] := 0X;
  908. Append( tempName, ".tmp." );
  909. AppendInt( tempName, n ); Append( tempName, "." );
  910. pid := Unix.getpid();
  911. AppendInt( tempName, pid )
  912. END GetTempName;
  913. PROCEDURE Install;
  914. VAR aliasFS: AliasFileSystem;
  915. BEGIN
  916. NEW(collection);
  917. NEW( unixFS ); (* Files.Add( unixFS, "" ); *)
  918. NEW( aliasFS, unixFS ); Files.Add( aliasFS, "searcher" )
  919. END Install;
  920. PROCEDURE Initialize;
  921. VAR a: ADDRESS; i: INTEGER; ch: CHAR;
  922. BEGIN
  923. (* get current working directory *)
  924. a := Unix.getenv( ADDRESSOF( "PWD" ) );
  925. IF a > 0 THEN
  926. i := 0;
  927. REPEAT S.GET( a, ch ); INC( a ); cwd[i] := ch; INC( i ) UNTIL ch = 0X;
  928. ELSE
  929. (* $PWD not set *)
  930. a := Unix.getcwd( ADDRESSOF( cwd ), LEN( cwd ) )
  931. END;
  932. i := 0;
  933. WHILE cwd[i] # 0X DO INC( i ) END;
  934. DEC( i );
  935. IF (i > 0) & (cwd[i] = '/') THEN cwd[i] := 0X END;
  936. (* get search pathes *)
  937. a := Unix.getenv( ADDRESSOF( "AOSPATH" ) ); i := 0;
  938. IF a = 0 THEN
  939. Log.String( "UnixFiles.Initialize: environment variable AOSPATH not defined" ); Log.Ln;
  940. ELSE
  941. REPEAT
  942. S.GET( a, ch ); INC( a );
  943. IF ch = ":" THEN ch := " " END;
  944. searchPath[i] := ch; INC( i )
  945. UNTIL ch = 0X;
  946. END;
  947. tempno := 1; openfiles := 0;
  948. Modules.InstallTermHandler( Finalization )
  949. END Initialize;
  950. PROCEDURE Finalization;
  951. VAR ft: Files.FileSystemTable; i: LONGINT;
  952. BEGIN
  953. Files.GetList( ft );
  954. IF ft # NIL THEN
  955. FOR i := 0 TO LEN( ft^ ) - 1 DO
  956. IF ft[i] IS AliasFileSystem THEN Files.Remove( ft[i] ) END
  957. END
  958. END;
  959. collection.Finalize;
  960. unixFS.Finalize;
  961. END Finalization;
  962. PROCEDURE DecOpenFiles;
  963. BEGIN{EXCLUSIVE}
  964. DEC(openfiles);
  965. END DecOpenFiles;
  966. PROCEDURE IncOpenFiles;
  967. BEGIN{EXCLUSIVE}
  968. INC(openfiles);
  969. END IncOpenFiles;
  970. PROCEDURE WaitClose(no: LONGINT);
  971. BEGIN{EXCLUSIVE}
  972. AWAIT(openfiles < no);
  973. END WaitClose;
  974. BEGIN
  975. Initialize;
  976. Install
  977. END UnixFiles.