Generic.Solaris.AMD64.Unix.Mod 35 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157
  1. (* ETH Oberon, Copyright 2000 ETH Zuerich Institut fuer Computersysteme, ETH Zentrum, CH-8092 Zuerich.
  2. Refer to the "General ETH Oberon System Source License" contract available at: http://www.oberon.ethz.ch/ *)
  3. MODULE Unix; (* Josef Templ, 5.3.90 SVR4 system calls *) (** Solaris x86 version, non portable *)
  4. (* Linux PPC version g.f. 18.04.98 *)
  5. (* Linux x86 version g.f 10.11.99 *)
  6. (* Solaris x86 version g.f 16.11.99 *)
  7. (* 2000.12.17 g.f. [C] - flag for new ompiler *)
  8. (* 2002.06.27 g.f. TmDesc fixed, new: Utime, Mktime *)
  9. (* 2006.07.31 g.f. shared memory support added *)
  10. (* 2007.04.13 g.f. Thread priorities added *)
  11. (* 2008.04.25 g.f. Trap handling unified *)
  12. IMPORT S := SYSTEM, Glue, Trace;
  13. CONST
  14. Version* = "Solaris";
  15. libcname* = "libc.so.1";
  16. libX11name* = "libX11.so.4";
  17. libpthreadname = "libpthread.so.1";
  18. LittleEndian* = TRUE; (** byte order of basic types *)
  19. LsbIs0* = TRUE; (** bit order of SET type *)
  20. PageSize* = 4096; (* least MMU page size *)
  21. stdin* = 0; stdout* = 1; stderr* = 2;
  22. (** Unix error codes: *)
  23. EPERM* = 1; (* Not super-user *)
  24. ENOENT* = 2; (* No such file or directory *)
  25. ESRCH* = 3; (* No such process *)
  26. EINTR* = 4; (* interrupted system call *)
  27. EIO* = 5; (* I/O error *)
  28. ENXIO* = 6; (* No such device or address *)
  29. E2BIG* = 7; (* Arg list too long *)
  30. ENOEXEC* = 8; (* Exec format error *)
  31. EBADF* = 9; (* Bad file number *)
  32. ECHILD* = 10; (* No children *)
  33. EAGAIN* = 11; (* No more processes *)
  34. ENOMEM* = 12; (* Not enough core *)
  35. EACCES* = 13; (* Permission denied *)
  36. EFAULT* = 14; (* Bad address *)
  37. ENOTBLK* = 15; (* Block device required *)
  38. EBUSY* = 16; (* Mount device busy *)
  39. EEXIST* = 17; (* File exists *)
  40. EXDEV* = 18; (* Cross-device link *)
  41. ENODEV* = 19; (* No such device *)
  42. ENOTDIR* = 20; (* Not a directory *)
  43. EISDIR* = 21; (* Is a directory *)
  44. EINVAL* = 22; (* Invalid argument *)
  45. ENFILE* = 23; (* File table overflow *)
  46. EMFILE* = 24; (* Too many open files *)
  47. ENOTTY* = 25; (* Inappropriate ioctl for device *)
  48. ETXTBSY* = 26; (* Text file busy *)
  49. EFBIG* = 27; (* File too large *)
  50. ENOSPC* = 28; (* No space left on device *)
  51. ESPIPE* = 29; (* Illegal seek *)
  52. EROFS* = 30; (* Read only file system *)
  53. EMLINK* = 31; (* Too many links *)
  54. EPIPE* = 32; (* Broken pipe *)
  55. EDOM* = 33; (* Math arg out of domain of func *)
  56. ERANGE* = 34; (* Math result not representable *)
  57. ENOMSG* = 42; (* No message of desired type *)
  58. EIDRM* = 43; (* Identifier removed *)
  59. ECHRNG* = 44; (* Channel number out of range *)
  60. EL2NSYNC* = 45; (* Level 2 not synchronized *)
  61. EL3HLT* = 46; (* Level 3 halted *)
  62. EL3RST* = 47; (* Level 3 reset *)
  63. ELNRNG* = 48; (* Link number out of range *)
  64. EUNATCH* = 49; (* Protocol driver not attached *)
  65. ENOCSI* = 50; (* No CSI structure available *)
  66. EL2HLT* = 51; (* Level 2 halted *)
  67. EDEADLK* = 35; (* Deadlock condition. *)
  68. ENOLCK* = 37; (* No record locks available. *)
  69. (* Unix signals *)
  70. SIGHUP* = 1; (* hangup *)
  71. SIGINT* = 2; (* interrupt (rubout) *)
  72. SIGQUIT* = 3; (* quit (ASCII FS) *)
  73. SIGILL* = 4; (* illegal instruction (not reset when caught) *)
  74. SIGTRAP* = 5; (* trace trap (not reset when caught) *)
  75. SIGIOT* = 6; (* IOT instruction *)
  76. SIGABRT* = 6; (* used by abort, replace SIGIOT in the future *)
  77. SIGEMT* = 7; (* EMT instruction *)
  78. SIGFPE* = 8; (* floating point exception *)
  79. SIGKILL* = 9; (* kill (cannot be caught or ignored) *)
  80. SIGBUS* = 10; (* bus error *)
  81. SIGSEGV* = 11; (* segmentation violation *)
  82. SIGSYS* = 12; (* bad argument to system call *)
  83. SIGPIPE* = 13; (* write on a pipe with no one to read it *)
  84. SIGALRM* = 14; (* alarm clock *)
  85. SIGTERM * = 15; (* software termination signal from kill *)
  86. SIGUSR1* = 16; (* user defined signal 1 *)
  87. SIGUSR2* = 17; (* user defined signal 2 *)
  88. SIGCLD* = 18; (* child status change *)
  89. SIGCHLD* = 18; (* child status change alias (POSIX) *)
  90. SIGPWR* = 19; (* power-fail restart *)
  91. SIGWINCH* = 20; (* window size change *)
  92. SIGURG* = 21; (* urgent socket condition *)
  93. SIGPOLL* = 22; (* pollable event occured *)
  94. SIGIO* = SIGPOLL; (* socket I/O possible (SIGPOLL alias) *)
  95. SIGSTOP* = 23; (* stop (cannot be caught or ignored) *)
  96. SIGTSTP* = 24; (* user stop requested from tty *)
  97. SIGCONT* = 25; (* stopped process has been continued *)
  98. SIGTTIN* = 26; (* background tty read attempted *)
  99. SIGTTOU* = 27; (* background tty write attempted *)
  100. SIGVTALRM*= 28; (* virtual timer expired *)
  101. SIGPROF* = 29; (* profiling timer expired *)
  102. SIGXCPU* = 30; (* exceeded cpu limit *)
  103. SIGXFSZ* = 31; (* exceeded file size limit *)
  104. SIGWAITING* = 32; (* reserved signal no longer used by threading code *)
  105. SIGAIOCANCEL* = 33; (* reserved signal for aio cancellation *)
  106. SIGFREEZE* = 34; (* special signal used by CPR *)
  107. SIGTHAW* = 35; (* special signal used by CPR *)
  108. SIGCANCEL* = 36; (* reserved signal for thread cancellation *)
  109. SIGLOST* = 37; (* resource lost (eg, record-lock lost) *)
  110. SIGXRES* = 38; (* resource control exceeded *)
  111. SIGJVM1* = 39; (* reserved signal for Java Virtual Machine *)
  112. SIGJVM2* = 40; (* reserved signal for Java Virtual Machine *)
  113. SIG_BLOCK = 1;
  114. SIG_UNBLOCK=2;
  115. SIG_SETMASK=3;
  116. SCHED_OTHER = 0; (* scheduling policy *)
  117. SA_NOCLDSTOP = 0x00020000; (* don't send job control SIGCLD's *)
  118. SA_ONSTACK = 0x00000001;
  119. SA_RESETHAND = 0x00000002;
  120. SA_RESTART = 0x00000004;
  121. SA_SIGINFO = 0x00000008;
  122. SA_NODEFER = 0x00000010;
  123. SA_NOCLDWAIT = 0x00010000; (* don't save zombie children *)
  124. PTHREAD_CANCEL_ENABLE = 0;
  125. PTHREAD_CANCEL_DISABLE = 1;
  126. PTHREAD_CANCEL_ASYNCHRONOUS = 2;
  127. PTHREAD_CANCEL_DEFERRED = 0;
  128. PTHREAD_SCOPE_PROCESS = 0;
  129. PTHREAD_SCOPE_SYSTEM = 1;
  130. PTHREAD_CREATE_DETACHED = 40H;
  131. (* open flags *)
  132. rdonly* = SET32({}); rdwr* = SET32({1}); creat* = SET32({8}); trunc* = SET32({9});
  133. (* access modes *)
  134. (* rwrwr* = {2, 4, 5, 7, 8}; rwxrwxrwx* = {0..8}; *)
  135. rwrwr* = 1B4H; rwxrwxrwx* = 1FFH;
  136. F_OK* = {}; X_Ok* = {0}; W_OK* = {1}; R_OK* = {2};
  137. (*--------------------------- Threads -------------------------------*)
  138. TYPE
  139. Thread_t* = LONGINT;
  140. PthreadAttributeDesc = RECORD attr: ADDRESS END;
  141. Key_t* = ADDRESS;
  142. Mutex_t* = ADDRESS;
  143. MutexDesc = ARRAY 24 OF CHAR;
  144. MutexAttributeDesc = RECORD attr: ADDRESS END;
  145. Condition_t* = ADDRESS;
  146. ConditionDesc = ARRAY 16 OF CHAR;
  147. ConditionAttributeDesc = RECORD attr: ADDRESS END;
  148. CONST
  149. (* Thread priorities *)
  150. ThreadLow* = 0; ThreadNormal* = 20; ThreadHigh* = 100;
  151. NumPriorities* = 101; (* number of priority levels *)
  152. (*---------------------------- IP -----------------------------------*)
  153. CONST
  154. (* domain *)
  155. AFINET* = 2;
  156. AFINET6* = 26;
  157. PFINET* = AFINET;
  158. PFINET6* = AFINET6;
  159. (* types of connection *)
  160. SockStream* = 2;
  161. SockDGram* = 1;
  162. (* protocols *)
  163. IpProtoUDP* = 17;
  164. IpProtoTCP* = 6;
  165. (* setsockopt *)
  166. SoLSocket* = 0FFFFH; (* socket option level *)
  167. SoLinger* = 80H; (* linger (gracefully close the connection)*)
  168. SoKeepAlive* = 8; (* keep connection alive *)
  169. SoNoDelay* = 1; (* no delay *)
  170. (* ioctl *)
  171. FioNRead* = 4004667FH; (* something to read ? *)
  172. (* recv *)
  173. MsgPeek* = 2;
  174. MsgDontWait* = 80H; (* non blocking read *)
  175. (* shutdown *)
  176. ShutRDWR* = 2;
  177. SockAddrSizeV4* = 16;
  178. SockAddrSizeV6* = 32;
  179. (*---------------------------- serial line -----------------------------*)
  180. FIONREAD* = 4004667FH;
  181. TIOCMGET* = 0741DH;
  182. TIOCMSET* = 0741AH;
  183. (* Speeds *)
  184. B0* = 0;
  185. B50* = 1;
  186. B75* = 2;
  187. B110* = 3;
  188. B134* = 4;
  189. B150* = 5;
  190. B200* = 6;
  191. B300* = 7;
  192. B600* = 8;
  193. B1200* = 9;
  194. B1800* = 10;
  195. B2400* = 11;
  196. B4800* = 12;
  197. B9600* = 13;
  198. B19200* = 14;
  199. B38400* = 15;
  200. B57600* = 16;
  201. B115200* = 18;
  202. B230400* = 20;
  203. (* tio.cflag bits *)
  204. CSIZE* = {4,5};
  205. CS5* = {};
  206. CS6* = {4};
  207. CS7* = {5};
  208. CS8* = {4,5};
  209. CSTOPB* = {6};
  210. CREAD* = {7};
  211. PARENB* = {8};
  212. PARODD* = {9};
  213. HUPCL* = {10};
  214. CLOCAL* = {11};
  215. TYPE
  216. Termios* = RECORD
  217. iflags*, oflags*, cflags*, lflags*: SET32;
  218. cc*: ARRAY 19 OF CHAR;
  219. dummy-: ARRAY 2 OF LONGINT
  220. END;
  221. (*------------------------------------------------------------------*)
  222. TYPE
  223. dev_t* = HUGEINT;
  224. ino_t* = HUGEINT;
  225. nlink_t* = LONGINT;
  226. mode_t* = LONGINT;
  227. off_t* = HUGEINT;
  228. blksize_t*= LONGINT;
  229. blkcnt_t* = HUGEINT;
  230. uid_t* = LONGINT;
  231. gid_t* = LONGINT;
  232. pid_t* = LONGINT;
  233. Status* = RECORD
  234. dev- : dev_t;
  235. ino- : ino_t;
  236. mode- : WORD;
  237. nlink- : WORD;
  238. uid- : WORD;
  239. gid- : WORD;
  240. rdev- : dev_t;
  241. size- : LONGWORD;
  242. atime- : Timeval;
  243. mtime- : Timeval;
  244. ctime- : Timeval;
  245. blksize- : WORD;
  246. pad0- : WORD;
  247. blocks- : LONGWORD;
  248. fstype- : ARRAY 16 OF CHAR;
  249. END;
  250. Timeval* = RECORD
  251. sec* : LONGWORD;
  252. usec* : LONGWORD
  253. END;
  254. TmPtr* = POINTER TO Tm;
  255. Tm* = RECORD
  256. sec*, min*, hour*, mday*, mon*, year*, wday*, yday*, isdst*: LONGINT;
  257. gmtoff*, tmzone*: LONGINT;
  258. END;
  259. Tms* = RECORD
  260. utime*, stime*, cutime*, cstime*: LONGINT
  261. END;
  262. Timezone* = RECORD
  263. minuteswest*, dsttime*: LONGINT
  264. END;
  265. Itimerval* = RECORD
  266. interval*, value*: Timeval
  267. END;
  268. CONST
  269. FdSetLen* = 32;
  270. TYPE
  271. FdSet* = ARRAY FdSetLen OF SET;
  272. Dirent* = POINTER TO RECORD
  273. ino- : ino_t;
  274. off- : off_t;
  275. reclen- : INTEGER;
  276. name- : (*array of*) CHAR;
  277. END;
  278. Sigset = ARRAY 4 OF SET32;
  279. SignalTrap = PROCEDURE ( sig: LONGINT; mc: Mcontext );
  280. Stack* = RECORD
  281. sp* : ADDRESS;
  282. size* : SIZE;
  283. flags* : SET;
  284. END;
  285. Ucontext* = POINTER TO UcontextDesc;
  286. UcontextDesc* = RECORD
  287. flags- : LONGWORD;
  288. link- : ADDRESS;
  289. sigmask- : Sigset;
  290. stack- : Stack;
  291. filler : LONGWORD; (* to make 'mc' 16 byte aligned *)
  292. mc- : McontextDesc;
  293. END;
  294. Mcontext* = POINTER TO McontextDesc;
  295. McontextDesc* = RECORD
  296. r_15 : HUGEINT;
  297. r_14 : HUGEINT;
  298. r_13 : HUGEINT;
  299. r_12 : HUGEINT;
  300. r_11 : HUGEINT;
  301. r_10 : HUGEINT;
  302. r_9 : HUGEINT;
  303. r_8 : HUGEINT;
  304. r_di : HUGEINT;
  305. r_si : HUGEINT;
  306. r_bp- : HUGEINT;
  307. r_bx : HUGEINT;
  308. r_dx : HUGEINT;
  309. r_cx : HUGEINT;
  310. r_ax : HUGEINT;
  311. r_trapno- : HUGEINT;
  312. r_err- : HUGEINT;
  313. r_pc- : HUGEINT;
  314. r_cs : HUGEINT;
  315. r_fl : HUGEINT;
  316. r_sp- : HUGEINT;
  317. r_ss : HUGEINT;
  318. r_fs : HUGEINT;
  319. r_gs : HUGEINT;
  320. r_es : HUGEINT;
  321. r_ds : HUGEINT;
  322. r_fsbase : HUGEINT;
  323. r_gsbase : HUGEINT;
  324. END;
  325. Sigaction = RECORD
  326. sa_flags: LONGINT;
  327. sa_handler: ADDRESS;
  328. sa_mask: Sigset;
  329. u1, u2: LONGINT
  330. END;
  331. Sched_param = RECORD
  332. sched_priority: LONGINT;
  333. unused: ARRAY 8 OF LONGINT;
  334. END;
  335. OberonXErrorHandler* = PROCEDURE ( disp, err: ADDRESS ): LONGINT;
  336. OberonXIOErrorHandler* = PROCEDURE ( disp: ADDRESS ): LONGINT;
  337. VAR
  338. handler_done: BOOLEAN;
  339. mainthread: Thread_t;
  340. sasuspend: Sigaction;
  341. argc-: LONGINT; argv-: ADDRESS; environ: ADDRESS;
  342. trap: SignalTrap;
  343. oberonXErrorHandler: OberonXErrorHandler;
  344. oberonXIOErrorHandler: OberonXIOErrorHandler;
  345. sysinfo-: RECORD
  346. sysname-, nodename-, release-, version-, machine-: ARRAY 65 OF CHAR;
  347. END;
  348. sigstack-: ARRAY 32*4096 OF CHAR;
  349. sysconf : PROCEDURE {C} ( name: LONGINT ): WORD;
  350. pthread_mutex_init : PROCEDURE {C} ( mutex: ADDRESS; mutexattr: ADDRESS ): WORD;
  351. pthread_mutex_destroy : PROCEDURE {C} ( mutex: ADDRESS ): WORD;
  352. pthread_mutex_lock : PROCEDURE {C} ( mutex: ADDRESS ): WORD;
  353. pthread_mutex_unlock : PROCEDURE {C} ( mutex: ADDRESS ): WORD;
  354. pthread_mutexattr_init : PROCEDURE {C} ( mutexattr: ADDRESS ): WORD;
  355. pthread_mutexattr_settype : PROCEDURE {C} ( mutexattr: ADDRESS; type: WORD ): WORD;
  356. pthread_cond_init : PROCEDURE {C} ( cond: ADDRESS; condAttr: ADDRESS ): WORD;
  357. pthread_cond_destroy : PROCEDURE {C} ( cond: ADDRESS ): WORD;
  358. pthread_cond_wait : PROCEDURE {C} ( cond: ADDRESS; mutex: ADDRESS ): WORD;
  359. pthread_cond_signal : PROCEDURE {C} ( cond: ADDRESS ): WORD;
  360. pthread_create : PROCEDURE {C} ( newthread: ADDRESS; attr: ADDRESS; start_routine: PROCEDURE {C} (arg: PROCEDURE):ADDRESS; arg:PROCEDURE): Thread_t;
  361. pthread_exit : PROCEDURE {C} ( thr: ADDRESS );
  362. pthread_detach : PROCEDURE {C} ( thr: Thread_t );
  363. pthread_kill : PROCEDURE {C} ( thr: Thread_t; sigid: LONGINT ): LONGINT;
  364. pthread_cancel : PROCEDURE {C} ( thr: Thread_t );
  365. pthread_self : PROCEDURE {C} ( ): Thread_t;
  366. pthread_key_create: PROCEDURE {C} ( key: ADDRESS; destructor: PROCEDURE {C} ( param: ADDRESS ) ): WORD;
  367. pthread_setspecific: PROCEDURE {C} ( key: Key_t; value: ADDRESS ): WORD;
  368. pthread_getspecific: PROCEDURE {C} ( key: Key_t ): ADDRESS;
  369. pthread_attr_init: PROCEDURE {C} ( attr: ADDRESS );
  370. pthread_attr_setscope: PROCEDURE {C} ( attr: ADDRESS; set: WORD );
  371. pthread_attr_setdetachstate: PROCEDURE {C} ( attr: ADDRESS; set: WORD );
  372. pthread_attr_setstacksize: PROCEDURE {C} ( attr: ADDRESS; stackSize: SIZE );
  373. sched_get_priority_max : PROCEDURE {C} ( policy: LONGINT ): LONGINT;
  374. sched_get_priority_min : PROCEDURE {C} ( policy: LONGINT ): LONGINT;
  375. pthread_setschedparam : PROCEDURE {C} ( thread: Thread_t; policy: LONGINT; param: ADDRESS ): WORD;
  376. pthread_getschedparam : PROCEDURE {C} ( thread: Thread_t; policy: ADDRESS; param: ADDRESS ): WORD;
  377. pthread_setcancelstate : PROCEDURE {C} ( state: LONGINT; oldstate: ADDRESS ): LONGINT;
  378. pthread_setcanceltype : PROCEDURE {C} ( type: LONGINT; oldtype: ADDRESS ): LONGINT;
  379. thr_suspend : PROCEDURE {C} ( thread: Thread_t ): LONGINT;
  380. thr_continue : PROCEDURE {C} ( thread: Thread_t ): LONGINT;
  381. sigaction : PROCEDURE {C} ( signum: LONGINT; CONST act, oldact: ADDRESS ): LONGINT;
  382. sigemptyset : PROCEDURE {C} ( set: ADDRESS );
  383. sigfillset : PROCEDURE {C} ( set: ADDRESS ): LONGINT;
  384. sigsuspend : PROCEDURE {C} ( set: ADDRESS ): LONGINT;
  385. sigaddset : PROCEDURE {C} ( set: ADDRESS; signo: LONGINT );
  386. sigdelset : PROCEDURE {C} ( set: ADDRESS; signo: LONGINT );
  387. nanosleep : PROCEDURE {C} ( req, rem: ADDRESS ): LONGINT;
  388. sigaltstack : PROCEDURE {C} ( ss, oss: ADDRESS ): LONGINT;
  389. pthread_sigmask : PROCEDURE {C} ( how: LONGINT; set: ADDRESS; oldset: ADDRESS ): LONGINT;
  390. (*pid: return param for process id. Only set if initialized non-null. path: pointer to string denoting the executable. file_actions: modify which files are open for the new process, if NIL it inherits open files from parent process. attrp: sets process groups, scheduler, signals etc, leave NIL. argv, evp: char** to the arguments and env. variables*)
  391. posix_spawnp- : PROCEDURE {C} ( pid: ADDRESS; path: ADDRESS; file_actions: ADDRESS; attrp: ADDRESS; argv: ADDRESS ; envp: ADDRESS ): LONGINT;
  392. (*more restrictive than spawnp*)
  393. posix_spawn- : PROCEDURE {C} ( pid: ADDRESS; path: ADDRESS; file_actions: ADDRESS; attrp: ADDRESS; argv: ADDRESS ; envp: ADDRESS ): LONGINT;
  394. waitpid- : PROCEDURE {C} ( pid: pid_t; status: ADDRESS; options: LONGINT ): pid_t;
  395. pipe- : PROCEDURE {C} ( pipefd: ADDRESS ): LONGINT; (*pipefd is assumed to be a pointer to a C array of 2 elements, after pipe creation the array will contain file descriptors for the input and output end of the pipe. returns 0 on success, or -1 on fail*)
  396. dup2- : PROCEDURE {C} ( oldfd,newfd: LONGINT ): LONGINT; (*overwrites file descriptor newfd with a copy of oldfd. useful for redirecting pipes.*)
  397. dup- : PROCEDURE {C} ( oldfd: LONGINT ): LONGINT;
  398. read- : PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): SIZE;
  399. write- : PROCEDURE {C} ( fd: LONGINT; buf: ADDRESS; n: SIZE ): SIZE;
  400. open- : PROCEDURE {C} ( name: ADDRESS; flags: SET32; mode: mode_t ): LONGINT;
  401. close- : PROCEDURE {C} ( fd: LONGINT ): LONGINT;
  402. lseek- : PROCEDURE {C} ( fd: LONGINT; offset: off_t; origin: WORD ): off_t;
  403. fsync- : PROCEDURE {C} ( fd: LONGINT ): LONGINT;
  404. ioctl- : PROCEDURE {C} ( fd: LONGINT; request: LONGINT; arg: ADDRESS ): LONGINT;
  405. unlink- : PROCEDURE {C} ( name: ADDRESS ): LONGINT;
  406. rename- : PROCEDURE {C} ( oldname, newname: ADDRESS ): LONGINT;
  407. ftruncate- : PROCEDURE {C} ( fd: LONGINT; length: SIZE ): LONGINT;
  408. chmod- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  409. utime- : PROCEDURE {C} ( name: ADDRESS; tb: ADDRESS ): LONGINT;
  410. access- : PROCEDURE {C} ( name: ADDRESS; mode: SET ): LONGINT;
  411. select- : PROCEDURE {C} ( width: LONGINT; rd, wr, ex: ADDRESS; VAR timeout: Timeval ): LONGINT;
  412. realpath- : PROCEDURE {C} ( file_name: ADDRESS; resolved_name: ADDRESS ): ADDRESS;
  413. chdir- : PROCEDURE {C} ( name: ADDRESS ): LONGINT;
  414. mkdir- : PROCEDURE {C} ( name: ADDRESS; mode: mode_t ): LONGINT;
  415. rmdir- : PROCEDURE {C} ( path: ADDRESS ): LONGINT;
  416. stat- : PROCEDURE {C} ( name: ADDRESS; VAR buf: Status ): LONGINT;
  417. lstat- : PROCEDURE {C} ( name: ADDRESS; VAR buf: Status ): LONGINT;
  418. fstat- : PROCEDURE {C} ( fd: LONGINT; VAR buf: Status ): LONGINT;
  419. getpid- : PROCEDURE {C} ( ): LONGINT;
  420. getuid- : PROCEDURE {C} ( ): LONGINT;
  421. malloc- : PROCEDURE {C} ( size: SIZE ): ADDRESS;
  422. posix_memalign- : PROCEDURE {C} ( VAR p: ADDRESS; alignment, size: SIZE ): LONGINT;
  423. free- : PROCEDURE {C} ( p: ADDRESS );
  424. mprotect- : PROCEDURE {C} ( p: ADDRESS; len: SIZE; prot: LONGINT ): LONGINT;
  425. alarm- : PROCEDURE {C} ( ms: LONGINT ): LONGINT;
  426. setitimer- : PROCEDURE {C} ( which: LONGINT; VAR value, ovalue: Itimerval ): LONGINT;
  427. getitimer- : PROCEDURE {C} ( which: LONGINT; VAR value: Itimerval ): LONGINT;
  428. gettimeofday- : PROCEDURE {C} ( VAR tv: Timeval; VAR tz: Timezone ): LONGINT;
  429. mktime- : PROCEDURE {C} ( VAR tm: Tm ): LONGINT;
  430. localtime- : PROCEDURE {C} ( CONST tv: Timeval ): TmPtr;
  431. time- : PROCEDURE {C} ( VAR tv: Timeval ): LONGINT;
  432. times- : PROCEDURE {C} ( VAR tms: Tms ): LONGINT;
  433. system- : PROCEDURE {C} ( cmd: ADDRESS );
  434. uname- : PROCEDURE {C} ( utsname: ADDRESS ): LONGINT;
  435. getcwd- : PROCEDURE {C} ( buf: ADDRESS; len: SIZE ): ADDRESS;
  436. getenv- : PROCEDURE {C} ( name: ADDRESS ): ADDRESS;
  437. opendir- : PROCEDURE {C} ( name: ADDRESS ): ADDRESS;
  438. readdir- : PROCEDURE {C} ( dir: ADDRESS ): Dirent;
  439. closedir- : PROCEDURE {C} ( dir: ADDRESS );
  440. sigsetjmp- : PROCEDURE {C} ( env: ADDRESS; savemask: LONGINT ): LONGINT;
  441. siglongjmp- : PROCEDURE {C} ( env: ADDRESS; val: LONGINT );
  442. kill- : PROCEDURE {C} ( pid, sig: LONGINT ): LONGINT;
  443. exit- : PROCEDURE {C} ( status: LONGINT );
  444. perror- : PROCEDURE {C} ( msg: ADDRESS );
  445. errno_location : PROCEDURE {C} ( ): ADDRESS;
  446. xSetErrorHandler : PROCEDURE {C} ( h: ADDRESS ): WORD;
  447. xSetIOErrorHandler : PROCEDURE {C} ( h: ADDRESS ): WORD;
  448. libc-: ADDRESS;
  449. libp-: ADDRESS;
  450. libx-: ADDRESS;
  451. libraryPaths: ARRAY 7 OF ARRAY 32 OF CHAR;
  452. noPaths: LONGINT;
  453. PROCEDURE ModifyContext*( cont: Mcontext; pc, bp, sp: ADDRESS );
  454. BEGIN
  455. cont.r_pc := pc;
  456. cont.r_bp := bp;
  457. cont.r_sp := sp;
  458. END ModifyContext;
  459. PROCEDURE CopyContext*( CONST from: McontextDesc; VAR to: McontextDesc );
  460. BEGIN
  461. S.MOVE( ADDRESSOF( from ), ADDRESSOF( to ), SIZEOF( McontextDesc ) );
  462. END CopyContext;
  463. PROCEDURE Perror*( CONST msg: ARRAY OF CHAR );
  464. BEGIN
  465. perror( ADDRESSOF( msg ) )
  466. END Perror;
  467. PROCEDURE errno*(): LONGINT;
  468. VAR loc: ADDRESS;
  469. BEGIN
  470. loc := errno_location();
  471. RETURN S.GET32( loc );
  472. END errno;
  473. PROCEDURE getnprocs* ( ): LONGINT;
  474. BEGIN
  475. RETURN sysconf( 15 ); (* 14 for number of processors configured, 15 for number of processors online *)
  476. END getnprocs;
  477. PROCEDURE NewKey*( ): Key_t;
  478. VAR
  479. key: Key_t;
  480. BEGIN
  481. ASSERT(pthread_key_create(ADDRESSOF(key), NIL) = 0);
  482. RETURN key;
  483. END NewKey;
  484. PROCEDURE ReadKey* (key: Key_t): ADDRESS;
  485. BEGIN
  486. RETURN pthread_getspecific(key);
  487. END ReadKey;
  488. PROCEDURE WriteKey* (key: Key_t; value: ADDRESS);
  489. BEGIN
  490. ASSERT(pthread_setspecific(key, value) = 0);
  491. END WriteKey;
  492. (*------------------------------------------------------------------------------------------------------*)
  493. VAR suspendHandler*: PROCEDURE( c: Ucontext );
  494. PROCEDURE {C} SigHandler( sig: LONGINT; scp: ADDRESS; ucp: Ucontext ); (* reversed arguments !! *)
  495. BEGIN
  496. IF sig = SIGUSR1 THEN
  497. suspendHandler( ucp );
  498. handler_done := TRUE;
  499. ELSIF trap # NIL THEN
  500. trap( sig, S.VAL( Mcontext, ADDRESSOF( ucp.mc ) ) );
  501. ELSE
  502. Trace.String( "Unix.SigHandler: sig = " ); Trace.Int( sig, 0 ); Trace.Ln; exit( -1 );
  503. END;
  504. END SigHandler;
  505. PROCEDURE InstallTrap* ( h: SignalTrap );
  506. BEGIN
  507. trap := h;
  508. END InstallTrap;
  509. PROCEDURE InstallHandler( sig: LONGINT );
  510. VAR
  511. act: Sigaction;
  512. mask: Sigset;
  513. BEGIN
  514. sigemptyset( ADDRESSOF( mask ) );
  515. act.sa_mask := mask;
  516. IF sig = SIGSEGV THEN (* segmentation violation *)
  517. act.sa_flags := SA_SIGINFO + SA_ONSTACK + SA_NODEFER;
  518. ELSE
  519. act.sa_flags := SA_SIGINFO + SA_NODEFER;
  520. END;
  521. act.sa_handler := ADDRESSOF( SigHandler );
  522. IF sigaction( sig, ADDRESSOF( act ), 0 ) # 0 THEN
  523. Perror( "sigaction" );
  524. END
  525. END InstallHandler;
  526. PROCEDURE HandleSignal*( sig: LONGINT );
  527. BEGIN
  528. InstallHandler( sig )
  529. END HandleSignal;
  530. (*-------------------------------------------------------------------------------------------------------------*)
  531. PROCEDURE ThrInitialize*( VAR low, high: LONGINT ): BOOLEAN;
  532. BEGIN
  533. mainthread := pthread_self();
  534. high := sched_get_priority_max( SCHED_OTHER );
  535. low := sched_get_priority_min( SCHED_OTHER );
  536. RETURN TRUE;
  537. END ThrInitialize;
  538. PROCEDURE ThrResume*( thr: Thread_t );
  539. VAR r: LONGINT;
  540. BEGIN
  541. r := thr_continue( thr )
  542. END ThrResume;
  543. PROCEDURE ThrSuspend*( thr: Thread_t; saveContext: BOOLEAN );
  544. VAR r: LONGINT;
  545. BEGIN
  546. IF saveContext THEN
  547. handler_done := FALSE;
  548. r := pthread_kill( thr, SIGUSR1 );
  549. (* not working in Solaris when the thread is stalled in a mutex.
  550. handler gets arrived but has bad side effects,
  551. yields traps and locks the system *)
  552. WHILE ~handler_done DO ThrSleep( 1 ) END;
  553. END;
  554. r := thr_suspend( thr )
  555. END ThrSuspend;
  556. PROCEDURE SetSigaltstack;
  557. VAR sigstk: Stack;
  558. BEGIN
  559. sigstk.sp := ADDRESSOF( sigstack );
  560. sigstk.size := LEN( sigstack );
  561. sigstk.flags := {};
  562. IF sigaltstack( ADDRESSOF( sigstk ), NIL) < 0 THEN
  563. Perror("sigaltstack")
  564. END;
  565. END SetSigaltstack;
  566. PROCEDURE {C} Starter( proc: PROCEDURE ): ADDRESS;
  567. VAR
  568. me: Thread_t;
  569. old, new: Sigset;
  570. param: Sched_param;
  571. r: LONGINT;
  572. BEGIN
  573. me := pthread_self();
  574. SetSigaltstack();
  575. IF sigfillset( ADDRESS OF new ) < 0 THEN
  576. Perror("sigfillset");
  577. END;
  578. sigdelset( ADDRESSOF( new ), SIGILL );
  579. sigdelset( ADDRESSOF( new ), SIGTRAP );
  580. sigdelset( ADDRESSOF( new ), SIGFPE );
  581. sigdelset( ADDRESSOF( new ), SIGBUS );
  582. sigdelset( ADDRESSOF( new ), SIGSEGV );
  583. sigdelset( ADDRESSOF( new ), SIGTERM );
  584. sigdelset( ADDRESSOF( new ), SIGUSR1 );
  585. sigdelset( ADDRESSOF( new ), SIGUSR2 );
  586. r := pthread_sigmask( SIG_SETMASK, ADDRESSOF( new ), ADDRESSOF( old ) );
  587. r := pthread_setcancelstate( PTHREAD_CANCEL_ENABLE, NIL );
  588. r := pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, NIL );
  589. param.sched_priority := 0;
  590. r := pthread_setschedparam( me, SCHED_OTHER, ADDRESSOF( param ) );
  591. proc();
  592. pthread_exit( NIL );
  593. RETURN NIL;
  594. END Starter;
  595. PROCEDURE ThrStart*( p: PROCEDURE; stackSize: SIZE ): Thread_t;
  596. VAR
  597. attr: PthreadAttributeDesc;
  598. id: Thread_t;
  599. res: LONGINT;
  600. BEGIN
  601. pthread_attr_init( ADDRESSOF( attr ) );
  602. pthread_attr_setscope( ADDRESSOF( attr ), PTHREAD_SCOPE_SYSTEM);
  603. pthread_attr_setdetachstate( ADDRESSOF( attr ), PTHREAD_CREATE_DETACHED);
  604. pthread_attr_setstacksize( ADDRESSOF( attr ), stackSize);
  605. res := pthread_create( ADDRESSOF( id ), ADDRESSOF( attr ), Starter, p);
  606. RETURN id;
  607. END ThrStart;
  608. PROCEDURE ThrSleep*( ms: LONGINT );
  609. VAR
  610. sltime, rem: RECORD
  611. tv_sec: LONGWORD; (* seconds *)
  612. tv_nsec: LONGWORD; (* nanoseconds *)
  613. END;
  614. BEGIN
  615. sltime.tv_sec := ms DIV 1000;
  616. sltime.tv_nsec := 1000000*(ms MOD 1000);
  617. WHILE (nanosleep( ADDRESSOF( sltime ), ADDRESSOF( rem ) ) < 0) DO
  618. (* check error ! *)
  619. sltime := rem;
  620. END;
  621. END ThrSleep;
  622. PROCEDURE ThrKill*( thr: Thread_t );
  623. BEGIN
  624. IF (thr # mainthread) THEN
  625. pthread_detach( thr );
  626. IF (thr = pthread_self( )) THEN
  627. pthread_exit( 0 );
  628. ELSE
  629. pthread_cancel( thr );
  630. END
  631. END;
  632. END ThrKill;
  633. PROCEDURE ThrThis*( ): Thread_t;
  634. BEGIN
  635. RETURN pthread_self( );
  636. END ThrThis;
  637. PROCEDURE ThrYield*( );
  638. BEGIN
  639. ThrSleep( 1 );
  640. END ThrYield;
  641. PROCEDURE ThrExit*( );
  642. BEGIN
  643. pthread_exit( 0 );
  644. END ThrExit;
  645. PROCEDURE ThrSetPriority*( thr: Thread_t; prio: LONGINT );
  646. VAR
  647. param: Sched_param;
  648. policy, r: LONGINT;
  649. BEGIN
  650. (* r := pthread_getschedparam( thr, ADDRESSOF( policy ), ADDRESSOF( param ) );
  651. param.sched_priority := prio;
  652. IF pthread_setschedparam( thr, SCHED_OTHER, ADDRESSOF( param ) ) # 0 THEN
  653. Perror( "pthread_setschedparam" );
  654. END *)
  655. END ThrSetPriority;
  656. PROCEDURE ThrGetPriority*( thr: Thread_t ):LONGINT;
  657. VAR
  658. param: Sched_param;
  659. policy, r: LONGINT;
  660. BEGIN
  661. r := pthread_getschedparam( thr, ADDRESSOF( policy ), ADDRESSOF( param ) );
  662. RETURN param.sched_priority;
  663. END ThrGetPriority;
  664. PROCEDURE NewMtx*( ): Mutex_t;
  665. VAR
  666. mtx: Mutex_t;
  667. BEGIN
  668. mtx := malloc(SIZEOF(MutexDesc));
  669. ASSERT(mtx # 0);
  670. ASSERT(pthread_mutex_init(mtx, NIL) = 0);
  671. RETURN mtx;
  672. END NewMtx;
  673. PROCEDURE NewRecursiveMtx*( ): Mutex_t;
  674. VAR
  675. mtx: Mutex_t;
  676. attr: MutexAttributeDesc;
  677. r: LONGINT;
  678. CONST
  679. PTHREAD_MUTEX_RECURSIVE = 4;
  680. BEGIN
  681. mtx := malloc( SIZEOF( MutexDesc ) );
  682. r := pthread_mutexattr_init( ADDRESSOF( attr ) );
  683. r := pthread_mutexattr_settype( ADDRESSOF( attr ), PTHREAD_MUTEX_RECURSIVE );
  684. ASSERT( mtx # 0 );
  685. ASSERT( pthread_mutex_init( mtx, ADDRESSOF( attr ) ) = 0);
  686. RETURN mtx;
  687. END NewRecursiveMtx;
  688. PROCEDURE MtxDestroy*( mtx: Mutex_t );
  689. BEGIN
  690. ASSERT( pthread_mutex_destroy( mtx ) = 0 );
  691. END MtxDestroy;
  692. PROCEDURE MtxLock*( mtx: Mutex_t );
  693. BEGIN
  694. ASSERT( pthread_mutex_lock( mtx ) = 0 );
  695. END MtxLock;
  696. PROCEDURE MtxUnlock*( mtx: Mutex_t );
  697. BEGIN
  698. ASSERT( pthread_mutex_unlock( mtx ) = 0 );
  699. END MtxUnlock;
  700. PROCEDURE NewCond* ( ): Condition_t;
  701. VAR cond: Condition_t;
  702. BEGIN
  703. cond := malloc( SIZEOF( ConditionDesc ) );
  704. ASSERT( cond # 0 );
  705. ASSERT( pthread_cond_init( cond, NIL ) = 0 );
  706. RETURN cond;
  707. END NewCond;
  708. PROCEDURE CondDestroy*( con: Condition_t );
  709. BEGIN
  710. ASSERT( pthread_cond_destroy( con ) = 0 );
  711. END CondDestroy;
  712. PROCEDURE CondWait*( con: Condition_t; mtx: Mutex_t );
  713. BEGIN
  714. ASSERT( pthread_cond_wait( con, mtx ) = 0 );
  715. END CondWait;
  716. PROCEDURE CondSignal*( cond: Condition_t );
  717. BEGIN
  718. ASSERT( pthread_cond_signal( cond ) = 0 );
  719. END CondSignal;
  720. (*-------------------------------------------------------------------------------------------------------------*)
  721. PROCEDURE {C} X11ErrorHandler( d: ADDRESS; err: ADDRESS ): WORD;
  722. VAR res: LONGINT;
  723. BEGIN
  724. IF oberonXErrorHandler # NIL THEN
  725. res := oberonXErrorHandler( d, err );
  726. END;
  727. RETURN 0;
  728. END X11ErrorHandler;
  729. PROCEDURE {C} X11IOErrorHandler( d: ADDRESS ): WORD;
  730. VAR res: LONGINT;
  731. BEGIN
  732. IF oberonXIOErrorHandler # NIL THEN
  733. res := oberonXIOErrorHandler( d );
  734. END;
  735. RETURN 0;
  736. END X11IOErrorHandler;
  737. PROCEDURE InitXErrorHandlers*( xErrorHandler: OberonXErrorHandler; xIOErrorHandler: OberonXIOErrorHandler );
  738. VAR res: WORD;
  739. BEGIN
  740. oberonXErrorHandler := xErrorHandler;
  741. oberonXIOErrorHandler := xIOErrorHandler;
  742. res := xSetErrorHandler( ADDRESSOF( X11ErrorHandler ) );
  743. res := xSetIOErrorHandler( ADDRESSOF( X11IOErrorHandler ) );
  744. END InitXErrorHandlers;
  745. (*-------------------------------------------------------------------------------------------------------------*)
  746. PROCEDURE Dlsym*( lib: ADDRESS; CONST sym: ARRAY OF CHAR; objAddr: ADDRESS );
  747. VAR val: LONGINT;
  748. BEGIN
  749. Glue.Dlsym( lib, sym, objAddr );
  750. S.GET( objAddr, val );
  751. IF val = 0 THEN
  752. Trace.String( "Unix.Dlsym: entry '" ); Trace.String( sym ); Trace.String( "' not found" );
  753. Trace.Ln;
  754. END
  755. END Dlsym;
  756. PROCEDURE Dlopen*( CONST libname: ARRAY OF CHAR; mode: LONGINT ): ADDRESS;
  757. VAR h: ADDRESS; i, j, k: INTEGER;
  758. p: ARRAY 256 OF CHAR;
  759. BEGIN
  760. IF libname[0] = '/' THEN h := Glue.dlopen( ADDRESSOF( libname ), mode );
  761. ELSE
  762. i := 0; h := 0;
  763. WHILE (h = 0) & (i < noPaths) DO
  764. COPY( libraryPaths[i], p ); j := 0;
  765. WHILE p[j] # 0X DO INC( j ) END;
  766. p[j] := '/'; k := 0;
  767. REPEAT INC( j ); p[j] := libname[k]; INC( k ) UNTIL p[j] = 0X;
  768. h := Glue.dlopen( ADDRESSOF( p ), mode ); INC( i )
  769. END
  770. END;
  771. IF h = 0 THEN
  772. Trace.String( "Unix.Dlopen: loading library " );
  773. Trace.String( libname ); Trace.String( " failed" ); Trace.Ln
  774. END;
  775. RETURN h
  776. END Dlopen;
  777. PROCEDURE Dlclose*( lib: ADDRESS );
  778. BEGIN
  779. Glue.dlclose( lib )
  780. END Dlclose;
  781. PROCEDURE GetArg*( no: LONGINT; VAR val: ARRAY OF CHAR );
  782. VAR ch: CHAR; adr: ADDRESS; i: LONGINT;
  783. BEGIN
  784. IF no >= argc THEN val[0] := 0X
  785. ELSE
  786. S.GET( argv + SIZEOF(ADDRESS)*no, adr ); i := 0;
  787. REPEAT S.GET( adr, ch ); val[i] := ch; INC( adr ); INC( i ); UNTIL (ch = 0X) OR (i >= LEN( val ));
  788. END
  789. END GetArg;
  790. PROCEDURE GetArgval*( CONST argName: ARRAY OF CHAR; VAR val: ARRAY OF CHAR );
  791. VAR i: INTEGER;
  792. buf: ARRAY 40 OF CHAR;
  793. BEGIN
  794. i := 1;
  795. WHILE i < argc - 1 DO
  796. GetArg( i, buf );
  797. IF buf = argName THEN GetArg( i + 1, val ); RETURN END;
  798. INC( i )
  799. END;
  800. val[0] := 0X
  801. END GetArgval;
  802. PROCEDURE getSysinfo;
  803. VAR res: LONGINT; p: INTEGER;
  804. buf: ARRAY 4096 OF CHAR;
  805. PROCEDURE copy( VAR p: INTEGER; VAR dest: ARRAY OF CHAR );
  806. VAR i: INTEGER;
  807. BEGIN
  808. WHILE buf[p] <= ' ' DO INC( p ) END;
  809. i := 0;
  810. REPEAT dest[i] := buf[p]; INC( i ); INC( p ) UNTIL (buf[p - 1] = 0X) OR (i >= LEN( dest ));
  811. dest[i - 1] := 0X
  812. END copy;
  813. BEGIN
  814. FOR p := 0 TO 4096 - 1 DO buf[p] := 0X END;
  815. res := uname( ADDRESSOF( buf ) );
  816. p := 0;
  817. copy( p, sysinfo.sysname );
  818. copy( p, sysinfo.nodename );
  819. copy( p, sysinfo.release );
  820. copy( p, sysinfo.version );
  821. copy( p, sysinfo.machine );
  822. END getSysinfo;
  823. PROCEDURE Init;
  824. BEGIN
  825. argc := Glue.argc;
  826. argv := Glue.argv;
  827. environ := Glue.environ;
  828. libraryPaths[0] := "/usr/lib/64";
  829. libraryPaths[1] := "/lib/64";
  830. noPaths := 2;
  831. libc := Dlopen( libcname, 2 );
  832. libp := Dlopen( libpthreadname, 2 );
  833. Dlsym( libc, "exit", ADDRESSOF( exit ) );
  834. Dlsym( libc, "sysconf", ADDRESSOF( sysconf ) );
  835. Dlsym( libc, "pthread_mutex_init", ADDRESSOF( pthread_mutex_init ) );
  836. Dlsym( libc, "pthread_mutex_destroy", ADDRESSOF( pthread_mutex_destroy ) );
  837. Dlsym( libc, "pthread_mutex_lock", ADDRESSOF( pthread_mutex_lock ) );
  838. Dlsym( libc, "pthread_mutex_unlock", ADDRESSOF( pthread_mutex_unlock ) );
  839. Dlsym( libp, "pthread_mutexattr_init", ADDRESSOF( pthread_mutexattr_init ) );
  840. Dlsym( libp, "pthread_mutexattr_settype", ADDRESSOF( pthread_mutexattr_settype ) );
  841. Dlsym( libc, "pthread_cond_init", ADDRESSOF( pthread_cond_init ) );
  842. Dlsym( libc, "pthread_cond_destroy", ADDRESSOF( pthread_cond_destroy ) );
  843. Dlsym( libc, "pthread_cond_wait", ADDRESSOF( pthread_cond_wait ) );
  844. Dlsym( libc, "pthread_cond_signal", ADDRESSOF( pthread_cond_signal ) );
  845. Dlsym( libp, "pthread_create", ADDRESSOF( pthread_create ) );
  846. Dlsym( libp, "pthread_exit", ADDRESSOF( pthread_exit ) );
  847. Dlsym( libp, "pthread_detach", ADDRESSOF( pthread_detach ) );
  848. Dlsym( libp, "pthread_cancel", ADDRESSOF( pthread_cancel ) );
  849. Dlsym( libp, "pthread_kill", ADDRESSOF( pthread_kill ) );
  850. Dlsym( libp, "pthread_key_create", ADDRESSOF( pthread_key_create ) );
  851. Dlsym( libp, "pthread_getspecific", ADDRESSOF( pthread_getspecific ) );
  852. Dlsym( libp, "pthread_setspecific", ADDRESSOF( pthread_setspecific ) );
  853. Dlsym( libp, "pthread_sigmask", ADDRESSOF( pthread_sigmask ) );
  854. Dlsym( libp, "pthread_setcancelstate", ADDRESSOF( pthread_setcancelstate ) );
  855. Dlsym( libp, "pthread_setcanceltype", ADDRESSOF( pthread_setcanceltype ) );
  856. Dlsym( libp, "pthread_attr_init", ADDRESSOF( pthread_attr_init ) );
  857. Dlsym( libp, "pthread_attr_setscope", ADDRESSOF( pthread_attr_setscope ) );
  858. Dlsym( libp, "pthread_attr_setdetachstate", ADDRESSOF( pthread_attr_setdetachstate ) );
  859. Dlsym( libp, "pthread_attr_setstacksize", ADDRESSOF( pthread_attr_setstacksize ) );
  860. Dlsym( libp, "pthread_self", ADDRESSOF( pthread_self ) );
  861. Dlsym( libc, "thr_suspend", ADDRESSOF( thr_suspend ) );
  862. Dlsym( libc, "thr_continue", ADDRESSOF( thr_continue ) );
  863. Dlsym( libc, "posix_spawnp", ADDRESSOF( posix_spawnp ) );
  864. Dlsym( libc, "posix_spawn", ADDRESSOF( posix_spawn ) );
  865. Dlsym( libc, "waitpid", ADDRESSOF( waitpid ) );
  866. Dlsym( libc, "pipe", ADDRESSOF( pipe ) );
  867. Dlsym( libc, "dup2", ADDRESSOF( dup2 ) );
  868. Dlsym( libc, "dup", ADDRESSOF( dup ) );
  869. Dlsym( libc, "sched_get_priority_max", ADDRESSOF( sched_get_priority_max ) );
  870. Dlsym( libc, "sched_get_priority_min", ADDRESSOF( sched_get_priority_min ) );
  871. Dlsym( libc, "pthread_setschedparam", ADDRESSOF( pthread_setschedparam ) );
  872. Dlsym( libc, "pthread_getschedparam", ADDRESSOF( pthread_getschedparam ) );
  873. Dlsym( libc, "sigaction", ADDRESSOF( sigaction ) );
  874. Dlsym( libc, "sigemptyset", ADDRESSOF( sigemptyset ) );
  875. Dlsym( libc, "sigfillset", ADDRESSOF( sigfillset ) );
  876. Dlsym( libc, "sigaddset", ADDRESSOF( sigaddset ) );
  877. Dlsym( libc, "sigdelset", ADDRESSOF( sigdelset ) );
  878. Dlsym( libc, "nanosleep", ADDRESSOF( nanosleep ) );
  879. Dlsym( libc, "sigaltstack", ADDRESSOF( sigaltstack ) );
  880. Dlsym( libc, "sigsuspend", ADDRESSOF( sigsuspend ) );
  881. Dlsym( libc, "read", ADDRESSOF( read ) );
  882. Dlsym( libc, "write", ADDRESSOF( write ) );
  883. Dlsym( libc, "open", ADDRESSOF( open ) );
  884. Dlsym( libc, "close", ADDRESSOF( close ) );
  885. Dlsym( libc, "lseek", ADDRESSOF( lseek ) );
  886. Dlsym( libc, "fsync", ADDRESSOF( fsync ) );
  887. Dlsym( libc, "ioctl", ADDRESSOF( ioctl ) );
  888. Dlsym( libc, "unlink", ADDRESSOF( unlink ) );
  889. Dlsym( libc, "rename", ADDRESSOF( rename ) );
  890. Dlsym( libc, "ftruncate", ADDRESSOF( ftruncate ) );
  891. Dlsym( libc, "chmod", ADDRESSOF( chmod ) );
  892. Dlsym( libc, "utime", ADDRESSOF( utime ) );
  893. Dlsym( libc, "access", ADDRESSOF( access ) );
  894. Dlsym( libc, "select", ADDRESSOF( select ) );
  895. Dlsym( libc, "realpath", ADDRESSOF( realpath ) );
  896. Dlsym( libc, "chdir", ADDRESSOF( chdir ) );
  897. Dlsym( libc, "mkdir", ADDRESSOF( mkdir ) );
  898. Dlsym( libc, "rmdir", ADDRESSOF( rmdir ) );
  899. Dlsym( libc, "stat", ADDRESSOF( stat ) );
  900. Dlsym( libc, "lstat", ADDRESSOF( lstat ) );
  901. Dlsym( libc, "fstat", ADDRESSOF( fstat ) );
  902. Dlsym( libc, "getpid", ADDRESSOF( getpid ) );
  903. Dlsym( libc, "getuid", ADDRESSOF( getuid ) );
  904. Dlsym( libc, "alarm", ADDRESSOF( alarm ) );
  905. Dlsym( libc, "setitimer", ADDRESSOF( setitimer ) );
  906. Dlsym( libc, "getitimer", ADDRESSOF( getitimer ) );
  907. Dlsym( libc, "gettimeofday", ADDRESSOF( gettimeofday ) );
  908. Dlsym( libc, "mktime", ADDRESSOF( mktime ) );
  909. Dlsym( libc, "localtime", ADDRESSOF( localtime ) );
  910. Dlsym( libc, "time", ADDRESSOF( time ) );
  911. Dlsym( libc, "times", ADDRESSOF( times ) );
  912. Dlsym( libc, "getcwd", ADDRESSOF( getcwd ) );
  913. Dlsym( libc, "getenv", ADDRESSOF( getenv ) );
  914. Dlsym( libc, "opendir", ADDRESSOF( opendir ) );
  915. Dlsym( libc, "readdir", ADDRESSOF( readdir ) );
  916. Dlsym( libc, "closedir", ADDRESSOF( closedir ) );
  917. Dlsym( libc, "sigsetjmp", ADDRESSOF( sigsetjmp ) );
  918. Dlsym( libc, "siglongjmp", ADDRESSOF( siglongjmp ) );
  919. Dlsym( libc, "malloc", ADDRESSOF( malloc ) );
  920. Dlsym( libc, "posix_memalign", ADDRESSOF( posix_memalign ) );
  921. Dlsym( libc, "free", ADDRESSOF( free ) );
  922. Dlsym( libc, "mprotect", ADDRESSOF( mprotect ) );
  923. Dlsym( libc, "system", ADDRESSOF( system ) );
  924. Dlsym( libc, "uname", ADDRESSOF( uname ) );
  925. Dlsym( libc, "kill", ADDRESSOF( kill ) );
  926. Dlsym( libc, "exit", ADDRESSOF( exit ) );
  927. Dlsym( libc, "perror", ADDRESSOF( perror ) );
  928. Dlsym( libc, "___errno", ADDRESSOF( errno_location ) );
  929. getSysinfo;
  930. InstallHandler( SIGUSR1 )
  931. END Init;
  932. (* load X11 related libaries only on demand *)
  933. PROCEDURE LinkToX*;
  934. BEGIN
  935. libx := Dlopen( libX11name, 2 );
  936. Dlsym( libx, "XSetErrorHandler", ADDRESSOF( xSetErrorHandler ) );
  937. Dlsym( libx, "XSetIOErrorHandler", ADDRESSOF( xSetIOErrorHandler ) );
  938. END LinkToX;
  939. PROCEDURE {INITIAL} Init0;
  940. BEGIN
  941. Init;
  942. END Init0;
  943. END Unix.