UnixOperatingSystem.st
changeset 18256 70138be99d04
parent 18226 444c446c1592
child 18261 22bdfc405bca
child 18278 a6bb05f48a1d
equal deleted inserted replaced
18255:aedbc27ea6c0 18256:70138be99d04
  1853 #ifdef SIGINFO
  1853 #ifdef SIGINFO
  1854     if (signalName == @symbol(SIGINFO)) {
  1854     if (signalName == @symbol(SIGINFO)) {
  1855 	RETURN ( __mkSmallInteger(SIGINFO) );
  1855 	RETURN ( __mkSmallInteger(SIGINFO) );
  1856     }
  1856     }
  1857 #endif
  1857 #endif
  1858 
  1858 %}.
  1859     RETURN ( __mkSmallInteger(0) );
  1859     ^ 0
  1860 %}
  1860 
  1861     "
  1861     "
  1862      OperatingSystem signalNamed:#SIGABRT
  1862      OperatingSystem signalNamed:#SIGABRT
  1863      OperatingSystem signalNamed:#SIGCHLD
  1863      OperatingSystem signalNamed:#SIGCHLD
  1864      OperatingSystem signalNamed:#SIGXFSZ
  1864      OperatingSystem signalNamed:#SIGXFSZ
  1865      OperatingSystem signalNamed:#SIGSOUND
  1865      OperatingSystem signalNamed:#SIGSOUND
  5856      systems - use OperatingSystem sigXXX to get the numeric value for
  5856      systems - use OperatingSystem sigXXX to get the numeric value for
  5857      a signal.
  5857      a signal.
  5858      Use only for fully debugged stand alone applications."
  5858      Use only for fully debugged stand alone applications."
  5859 
  5859 
  5860 %{  /* NOCONTEXT */
  5860 %{  /* NOCONTEXT */
  5861 
  5861 #ifdef __SCHTEAM__
       
  5862     if (signalNumber.isSmallInteger()) {
       
  5863 	int sigNo = signalNumber.intValue();
       
  5864 
       
  5865 	if (sigNo != 0) {
       
  5866 	    System.err.println("ignored disable-signal: "+sigNo);
       
  5867 	}
       
  5868 	return context._RETURN(self);
       
  5869     }
       
  5870 #else
  5862     if (__isSmallInteger(signalNumber)) {
  5871     if (__isSmallInteger(signalNumber)) {
  5863 	int sigNo = __intVal(signalNumber);
  5872 	int sigNo = __intVal(signalNumber);
  5864 
  5873 
  5865 	if (sigNo == 0) {
  5874 	if (sigNo == 0) {
  5866 	    RETURN (self);
  5875 	    RETURN (self);
  5867 	}
  5876 	}
  5868 #ifdef SIG_IGN
  5877 # ifdef SIG_IGN
  5869 	signal(sigNo, SIG_IGN);
  5878 	signal(sigNo, SIG_IGN);
  5870 	RETURN (self);
  5879 	RETURN (self);
  5871 #endif
  5880 # endif
  5872     }
  5881     }
       
  5882 #endif
  5873 %}.
  5883 %}.
  5874     "
  5884     "
  5875      this error is triggered on non-integer argument
  5885      this error is triggered on non-integer argument
  5876     "
  5886     "
  5877     ^ self primitiveFailed
  5887     ^ self primitiveFailed
  6041      NOTICE that signal numbers are not portable between unix
  6051      NOTICE that signal numbers are not portable between unix
  6042      systems - use OperatingSystem sigXXX to get the numeric value for
  6052      systems - use OperatingSystem sigXXX to get the numeric value for
  6043      a signal."
  6053      a signal."
  6044 
  6054 
  6045 %{  /* NOCONTEXT */
  6055 %{  /* NOCONTEXT */
  6046 
  6056 #ifdef __SCHTEAM__
  6047 #ifdef NSIG
  6057     if (signalNumber.isSmallInteger()) {
  6048 # define SIG_LIMIT NSIG
  6058 	int sigNo = signalNumber.intValue();
       
  6059 
       
  6060 	if (sigNo != 0) {
       
  6061 	    System.err.println("ignored enable-signal: "+sigNo);
       
  6062 	}
       
  6063 	return context._RETURN(self);
       
  6064     }
  6049 #else
  6065 #else
  6050 # ifdef SIGUSR2
  6066 
  6051 #  define SIG_LIMIT SIGUSR2
  6067 # ifdef NSIG
       
  6068 #  define SIG_LIMIT NSIG
  6052 # else
  6069 # else
  6053 #  ifdef SIGUSR
  6070 #  ifdef SIGUSR2
  6054 #   define SIG_LIMIT SIGUSR
  6071 #   define SIG_LIMIT SIGUSR2
       
  6072 #  else
       
  6073 #   ifdef SIGUSR
       
  6074 #    define SIG_LIMIT SIGUSR
       
  6075 #   endif
  6055 #  endif
  6076 #  endif
  6056 # endif
  6077 # endif
  6057 #endif
  6078 
  6058 
  6079 # if defined(SIGPOLL) && !defined(SIGIO)
  6059 #if defined(SIGPOLL) && !defined(SIGIO)
  6080 #  define SIGIO SIGPOLL
  6060 # define SIGIO SIGPOLL
  6081 # endif
  6061 #endif
  6082 
  6062 
  6083 # ifdef SIGCHLD
  6063 #ifdef SIGCHLD
  6084 #  define CHILD_SIGNAL   SIGCHLD
  6064 # define CHILD_SIGNAL   SIGCHLD
  6085 # else
  6065 #else
  6086 #  ifdef SIGCLD
  6066 # ifdef SIGCLD
  6087 #   define CHILD_SIGNAL  SIGCLD
  6067 #  define CHILD_SIGNAL  SIGCLD
  6088 #  endif
  6068 # endif
  6089 # endif
  6069 #endif
       
  6070 
  6090 
  6071     int sigNr;
  6091     int sigNr;
  6072 #if defined(SIGINT) || defined(SIGQUIT)
  6092 # if defined(SIGINT) || defined(SIGQUIT)
  6073 # ifndef __signalUserInterrupt
  6093 #  ifndef __signalUserInterrupt
  6074     extern void __signalUserInterrupt(SIGHANDLER_ARG);
  6094     extern void __signalUserInterrupt(SIGHANDLER_ARG);
  6075 # endif
  6095 #  endif
  6076 #endif
  6096 # endif
  6077 #ifdef SIGFPE
  6097 # ifdef SIGFPE
  6078 # ifndef __signalFpExceptionInterrupt
  6098 #  ifndef __signalFpExceptionInterrupt
  6079     extern void __signalFpExceptionInterrupt(SIGHANDLER_ARG);
  6099     extern void __signalFpExceptionInterrupt(SIGHANDLER_ARG);
  6080 # endif
  6100 #  endif
  6081 #endif
  6101 # endif
  6082 #ifdef SIGIO
  6102 # ifdef SIGIO
  6083 # ifndef __signalIoInterrupt
  6103 #  ifndef __signalIoInterrupt
  6084     extern void __signalIoInterrupt(SIGHANDLER_ARG);
  6104     extern void __signalIoInterrupt(SIGHANDLER_ARG);
  6085 # endif
  6105 #  endif
  6086 #endif
  6106 # endif
  6087 #ifdef CHILD_SIGNAL
  6107 # ifdef CHILD_SIGNAL
  6088 # ifndef __signalChildInterrupt
  6108 #  ifndef __signalChildInterrupt
  6089     extern void __signalChildInterrupt(SIGHANDLER_ARG);
  6109     extern void __signalChildInterrupt(SIGHANDLER_ARG);
  6090 # endif
  6110 #  endif
  6091 #endif
  6111 # endif
  6092 #ifdef SIGPIPE
  6112 # ifdef SIGPIPE
  6093 # ifndef __signalPIPEInterrupt
  6113 #  ifndef __signalPIPEInterrupt
  6094     extern void __signalPIPEInterrupt(SIGHANDLER_ARG);
  6114     extern void __signalPIPEInterrupt(SIGHANDLER_ARG);
  6095 # endif
  6115 #  endif
  6096 #endif
  6116 # endif
  6097 #ifdef SIGBUS
  6117 # ifdef SIGBUS
  6098 # ifndef __signalBUSInterrupt
  6118 #  ifndef __signalBUSInterrupt
  6099     extern void __signalBUSInterrupt(SIGHANDLER_ARG);
  6119     extern void __signalBUSInterrupt(SIGHANDLER_ARG);
  6100 # endif
  6120 #  endif
  6101 #endif
  6121 # endif
  6102 #ifdef SIGSEGV
  6122 # ifdef SIGSEGV
  6103 # ifndef __signalSEGVInterrupt
  6123 #  ifndef __signalSEGVInterrupt
  6104     extern void __signalSEGVInterrupt(SIGHANDLER_ARG);
  6124     extern void __signalSEGVInterrupt(SIGHANDLER_ARG);
  6105 # endif
  6125 #  endif
  6106 #endif
  6126 # endif
  6107 #if defined(SIGILL) || defined(SIGEMT)
  6127 # if defined(SIGILL) || defined(SIGEMT)
  6108 # ifndef __signalTrapInterrupt
  6128 #  ifndef __signalTrapInterrupt
  6109     extern void __signalTrapInterrupt(SIGHANDLER_ARG);
  6129     extern void __signalTrapInterrupt(SIGHANDLER_ARG);
  6110 # endif
  6130 #  endif
  6111 #endif
  6131 # endif
  6112 #ifdef SIGALRM
  6132 # ifdef SIGALRM
  6113 # ifndef __signalTimerInterrupt
  6133 #  ifndef __signalTimerInterrupt
  6114     extern void __signalTimerInterrupt(SIGHANDLER_ARG);
  6134     extern void __signalTimerInterrupt(SIGHANDLER_ARG);
  6115 # endif
  6135 #  endif
  6116 #endif
  6136 # endif
  6117 #ifdef SIGABRT
  6137 # ifdef SIGABRT
  6118 # ifndef __signalAbortInterrupt
  6138 #  ifndef __signalAbortInterrupt
  6119     extern void __signalAbortInterrupt(SIGHANDLER_ARG);
  6139     extern void __signalAbortInterrupt(SIGHANDLER_ARG);
  6120 # endif
  6140 #  endif
  6121 #endif
  6141 # endif
  6122 #ifndef __signalInterrupt
  6142 # ifndef __signalInterrupt
  6123     extern void __signalInterrupt(SIGHANDLER_ARG);
  6143     extern void __signalInterrupt(SIGHANDLER_ARG);
  6124 #endif
  6144 # endif
  6125     void (*handler)(SIGHANDLER_ARG);
  6145     void (*handler)(SIGHANDLER_ARG);
  6126 
  6146 
  6127     if (__isSmallInteger(signalNumber)
  6147     if (__isSmallInteger(signalNumber)
  6128      && ((sigNr = __intVal(signalNumber)) >= 0)
  6148      && ((sigNr = __intVal(signalNumber)) >= 0)
  6129 #ifdef SIG_LIMIT
  6149 # ifdef SIG_LIMIT
  6130      &&  (sigNr <= SIG_LIMIT)
  6150      &&  (sigNr <= SIG_LIMIT)
  6131 #endif
  6151 # endif
  6132     ) {
  6152     ) {
  6133 	/*
  6153 	/*
  6134 	 * standard signals are forced into standard handlers
  6154 	 * standard signals are forced into standard handlers
  6135 	 * - all others go into general signalInterrupt
  6155 	 * - all others go into general signalInterrupt
  6136 	 */
  6156 	 */
  6137 #if defined(SIGPOLL) && defined(SIGIO)
  6157 # if defined(SIGPOLL) && defined(SIGIO)
  6138 	if (sigNr == SIGPOLL)
  6158 	if (sigNr == SIGPOLL)
  6139 	    sigNr = SIGIO;
  6159 	    sigNr = SIGIO;
  6140 #endif
  6160 # endif
  6141 	switch (sigNr) {
  6161 	switch (sigNr) {
  6142 	    case 0:
  6162 	    case 0:
  6143 		/* enabling a non-supported signal */
  6163 		/* enabling a non-supported signal */
  6144 		RETURN (self);
  6164 		RETURN (self);
  6145 
  6165 
  6146 #ifdef SIGBREAK
  6166 # ifdef SIGBREAK
  6147 	    case SIGBREAK:
  6167 	    case SIGBREAK:
  6148 #endif
  6168 # endif
  6149 #ifdef SIGINT
  6169 # ifdef SIGINT
  6150 	    case SIGINT:
  6170 	    case SIGINT:
  6151 #endif
  6171 # endif
  6152 #ifdef SIGQUIT
  6172 # ifdef SIGQUIT
  6153 	    case SIGQUIT:
  6173 	    case SIGQUIT:
  6154 #endif
  6174 # endif
  6155 #if defined(SIGINT) || defined(SIGQUIT) || defined(SIGBREAK)
  6175 # if defined(SIGINT) || defined(SIGQUIT) || defined(SIGBREAK)
  6156 		handler = __signalUserInterrupt;
  6176 		handler = __signalUserInterrupt;
  6157 		break;
  6177 		break;
  6158 #endif
  6178 # endif
  6159 #ifdef SIGFPE
  6179 # ifdef SIGFPE
  6160 	    case SIGFPE:
  6180 	    case SIGFPE:
  6161 		handler = __signalFpExceptionInterrupt;
  6181 		handler = __signalFpExceptionInterrupt;
  6162 		break;
  6182 		break;
  6163 #endif
  6183 # endif
  6164 
  6184 
  6165 #ifdef SIGPIPE
  6185 # ifdef SIGPIPE
  6166 	    case SIGPIPE:
  6186 	    case SIGPIPE:
  6167 		handler = __signalPIPEInterrupt;
  6187 		handler = __signalPIPEInterrupt;
  6168 		break;
  6188 		break;
  6169 #endif
  6189 # endif
  6170 #ifdef SIGBUS
  6190 # ifdef SIGBUS
  6171 	    case SIGBUS:
  6191 	    case SIGBUS:
  6172 		handler = __signalBUSInterrupt;
  6192 		handler = __signalBUSInterrupt;
  6173 		break;
  6193 		break;
  6174 #endif
  6194 # endif
  6175 #ifdef SIGSEGV
  6195 # ifdef SIGSEGV
  6176 	    case SIGSEGV:
  6196 	    case SIGSEGV:
  6177 		handler = __signalSEGVInterrupt;
  6197 		handler = __signalSEGVInterrupt;
  6178 		break;
  6198 		break;
  6179 #endif
  6199 # endif
  6180 #ifdef SIGABRT
  6200 # ifdef SIGABRT
  6181 	    case SIGABRT:
  6201 	    case SIGABRT:
  6182 		handler = __signalAbortInterrupt;
  6202 		handler = __signalAbortInterrupt;
  6183 		break;
  6203 		break;
  6184 #endif
  6204 # endif
  6185 #ifdef SIGILL
  6205 # ifdef SIGILL
  6186 	    case SIGILL:
  6206 	    case SIGILL:
  6187 		handler = __signalTrapInterrupt;
  6207 		handler = __signalTrapInterrupt;
  6188 		break;
  6208 		break;
  6189 #endif
  6209 # endif
  6190 #ifdef SIGEMT
  6210 # ifdef SIGEMT
  6191 	    case SIGEMT:
  6211 	    case SIGEMT:
  6192 		handler = __signalTrapInterrupt;
  6212 		handler = __signalTrapInterrupt;
  6193 		break;
  6213 		break;
  6194 #endif
  6214 # endif
  6195 #ifdef SIGIO
  6215 # ifdef SIGIO
  6196 	    case SIGIO:
  6216 	    case SIGIO:
  6197 		handler = __signalIoInterrupt;
  6217 		handler = __signalIoInterrupt;
  6198 		break;
  6218 		break;
  6199 #endif
  6219 # endif
  6200 
  6220 
  6201 #ifdef CHILD_SIGNAL
  6221 # ifdef CHILD_SIGNAL
  6202 	    case CHILD_SIGNAL:
  6222 	    case CHILD_SIGNAL:
  6203 		handler = __signalChildInterrupt;
  6223 		handler = __signalChildInterrupt;
  6204 		break;
  6224 		break;
  6205 #endif
  6225 # endif
  6206 #ifdef SIGALRM
  6226 # ifdef SIGALRM
  6207 	    case SIGALRM:
  6227 	    case SIGALRM:
  6208 		handler = __signalTimerInterrupt;
  6228 		handler = __signalTimerInterrupt;
  6209 		break;
  6229 		break;
  6210 #endif
  6230 # endif
  6211 
  6231 
  6212 	    default:
  6232 	    default:
  6213 		handler = __signalInterrupt;
  6233 		handler = __signalInterrupt;
  6214 		break;
  6234 		break;
  6215 	}
  6235 	}
  6216 
  6236 
  6217 	{
  6237 	{
  6218 #ifdef HAS_SIGACTION
  6238 # ifdef HAS_SIGACTION
  6219 	    struct sigaction act;
  6239 	    struct sigaction act;
  6220 
  6240 
  6221 	    /*
  6241 	    /*
  6222 	     * Do not add SA_RESTART here. A signal can cause a
  6242 	     * Do not add SA_RESTART here. A signal can cause a
  6223 	     * thread switch, another thread can do a garbage collect
  6243 	     * thread switch, another thread can do a garbage collect
  6227 
  6247 
  6228 	    act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
  6248 	    act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
  6229 	    sigemptyset(&act.sa_mask);
  6249 	    sigemptyset(&act.sa_mask);
  6230 	    act.sa_handler = handler;
  6250 	    act.sa_handler = handler;
  6231 	    sigaction(sigNr, &act, 0);
  6251 	    sigaction(sigNr, &act, 0);
  6232 #else
  6252 # else
  6233 # ifdef HAS_SIGVEC
  6253 #  ifdef HAS_SIGVEC
  6234 	    struct sigvec vec;
  6254 	    struct sigvec vec;
  6235 
  6255 
  6236 	    vec.sv_flags = SV_INTERRUPT;
  6256 	    vec.sv_flags = SV_INTERRUPT;
  6237 	    sigemptyset(&vec.sv_mask);
  6257 	    sigemptyset(&vec.sv_mask);
  6238 	    vec.sv_handler = handler;
  6258 	    vec.sv_handler = handler;
  6239 	    sigvec(sigNr, &vec, NULL);
  6259 	    sigvec(sigNr, &vec, NULL);
  6240 # else
  6260 #  else
  6241 	    (void) signal(sigNr, handler);
  6261 	    (void) signal(sigNr, handler);
  6242 # endif
  6262 #  endif
  6243 #endif
  6263 # endif
  6244 	}
  6264 	}
  6245 
  6265 
  6246 	/*
  6266 	/*
  6247 	 * maybe, we should ret the old enable-status
  6267 	 * maybe, we should ret the old enable-status
  6248 	 * as boolean here ...
  6268 	 * as boolean here ...
  6249 	 */
  6269 	 */
  6250 	RETURN (self);
  6270 	RETURN (self);
  6251     }
  6271     }
       
  6272 #endif /* not SCHTEAM */
  6252 %}.
  6273 %}.
  6253 
       
  6254     "
  6274     "
  6255      this error is triggered on non-integer argument, or
  6275      this error is triggered on non-integer argument, or
  6256      if the signal number is not in the valid range (1..NSIG)
  6276      if the signal number is not in the valid range (1..NSIG)
  6257     "
  6277     "
  6258     ^ self primitiveFailed
  6278     ^ self primitiveFailed
  6260 
  6280 
  6261 enableTimer:milliSeconds
  6281 enableTimer:milliSeconds
  6262     "setup for a timerInterrupt, to be signalled after some (real) time."
  6282     "setup for a timerInterrupt, to be signalled after some (real) time."
  6263 
  6283 
  6264 %{  /* NOCONTEXT */
  6284 %{  /* NOCONTEXT */
       
  6285 #ifdef __SCHTEAM__
       
  6286     if (milliSeconds.isSmallInteger()) {
       
  6287 	long millis = milliSeconds.longValue();
       
  6288 
       
  6289 	System.err.println("ignored enable-timer");
       
  6290 	return context._RETURN(self);
       
  6291     }
       
  6292 #else
  6265     int millis;
  6293     int millis;
  6266 
  6294 
  6267     millis = __intVal(milliSeconds);
  6295     millis = __intVal(milliSeconds);
  6268 
  6296 
  6269 #ifdef SIGALRM
  6297 # ifdef SIGALRM
  6270     {
  6298     {
  6271 	static int firstCall = 1;
  6299 	static int firstCall = 1;
  6272 # ifndef __signalTimerInterrupt
  6300 #  ifndef __signalTimerInterrupt
  6273 	extern void __signalTimerInterrupt(SIGHANDLER_ARG);
  6301 	extern void __signalTimerInterrupt(SIGHANDLER_ARG);
  6274 # endif
  6302 #  endif
  6275 
  6303 
  6276 	if (firstCall) {
  6304 	if (firstCall) {
  6277 # ifdef HAS_SIGACTION
  6305 #  ifdef HAS_SIGACTION
  6278 	    struct sigaction act;
  6306 	    struct sigaction act;
  6279 
  6307 
  6280 	    act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
  6308 	    act.sa_flags = SA_SIGINFO; /* <- if you add more, remember dummys at the top */
  6281 	    sigemptyset(&act.sa_mask);
  6309 	    sigemptyset(&act.sa_mask);
  6282 	    act.sa_handler = __signalTimerInterrupt;
  6310 	    act.sa_handler = __signalTimerInterrupt;
  6283 	    sigaction(SIGALRM, &act, 0);
  6311 	    sigaction(SIGALRM, &act, 0);
  6284 # else
  6312 #  else
  6285 #  ifdef HAS_SIGVEC
  6313 #   ifdef HAS_SIGVEC
  6286 	    struct sigvec vec;
  6314 	    struct sigvec vec;
  6287 
  6315 
  6288 	    vec.sv_flags = SV_INTERRUPT;
  6316 	    vec.sv_flags = SV_INTERRUPT;
  6289 	    sigemptyset(&vec.sv_mask);
  6317 	    sigemptyset(&vec.sv_mask);
  6290 	    vec.sv_handler = __signalTimerInterrupt;
  6318 	    vec.sv_handler = __signalTimerInterrupt;
  6291 	    sigvec(SIGALRM, &vec, NULL);
  6319 	    sigvec(SIGALRM, &vec, NULL);
  6292 #  else /* neither SIGACTION nor SIGVEC */
  6320 #   else /* neither SIGACTION nor SIGVEC */
  6293 	    signal(SIGALRM, __signalTimerInterrupt);
  6321 	    signal(SIGALRM, __signalTimerInterrupt);
  6294 #  endif /* stupid system  */
  6322 #   endif /* stupid system  */
  6295 # endif
  6323 #  endif
  6296 	    firstCall = 0;
  6324 	    firstCall = 0;
  6297 	}
  6325 	}
  6298     }
  6326     }
  6299 #endif /* SIGALRM */
  6327 # endif /* SIGALRM */
  6300 
  6328 
  6301 
  6329 
  6302 #if defined(ITIMER_REAL) && !defined(NO_SETITIMER)
  6330 # if defined(ITIMER_REAL) && !defined(NO_SETITIMER)
  6303     {
  6331     {
  6304 	struct itimerval dt;
  6332 	struct itimerval dt;
  6305 
  6333 
  6306 	dt.it_interval.tv_sec = 0;
  6334 	dt.it_interval.tv_sec = 0;
  6307 	dt.it_interval.tv_usec = 0;
  6335 	dt.it_interval.tv_usec = 0;
  6308 	dt.it_value.tv_sec = millis / 1000;
  6336 	dt.it_value.tv_sec = millis / 1000;
  6309 	dt.it_value.tv_usec = (millis % 1000) * 1000;
  6337 	dt.it_value.tv_usec = (millis % 1000) * 1000;
  6310 	setitimer(ITIMER_REAL, &dt, 0);
  6338 	setitimer(ITIMER_REAL, &dt, 0);
  6311 	RETURN (true);
  6339 	RETURN (true);
  6312     }
  6340     }
  6313 #else /* no ITIMER_REAL */
  6341 # else /* no ITIMER_REAL */
  6314 
  6342 
  6315 # ifdef USE_SLOW_ALARM
  6343 #  ifdef USE_SLOW_ALARM
  6316     {
  6344     {
  6317 	/*
  6345 	/*
  6318 	 * last fallback - use alarm (which only gives 1 second resolution).
  6346 	 * last fallback - use alarm (which only gives 1 second resolution).
  6319 	 * If the system does not support any of the above, you have to life
  6347 	 * If the system does not support any of the above, you have to life
  6320 	 * with this. The consequence is that pressing CTRL-C processing and
  6348 	 * with this. The consequence is that pressing CTRL-C processing and
  6321 	 * thread switching will take place much delayed.
  6349 	 * thread switching will take place much delayed.
  6322 	 */
  6350 	 */
  6323 	alarm(1);
  6351 	alarm(1);
  6324 	RETURN(true);
  6352 	RETURN(true);
  6325     }
  6353     }
  6326 # endif
  6354 #  endif
  6327 #endif /* ITIMER_REAL */
  6355 # endif /* ITIMER_REAL */
       
  6356 #endif /* not SCHTEAM */
  6328 %}.
  6357 %}.
  6329     ^ false
  6358     ^ false
  6330 !
  6359 !
  6331 
  6360 
  6332 isFatalSignal:aNumber
  6361 isFatalSignal:aNumber
  7055 
  7084 
  7056 getEnvironment:aStringOrSymbol
  7085 getEnvironment:aStringOrSymbol
  7057     "get an environment string"
  7086     "get an environment string"
  7058 
  7087 
  7059 %{  /* NOCONTEXT */
  7088 %{  /* NOCONTEXT */
  7060 
  7089 #ifdef __SCHTEAM__
       
  7090     {
       
  7091 	java.lang.String val = System.getenv( aStringOrSymbol.asString() );
       
  7092 	STObject retVal;
       
  7093 
       
  7094 	if (val == null) {
       
  7095 	    retVal = STObject.Nil;
       
  7096 	} else {
       
  7097 	    retVal = new STString( val );
       
  7098 	}
       
  7099 	return context._RETURN( retVal );
       
  7100 	/* NOTREACHED */
       
  7101     }
       
  7102 #else
  7061     extern char *getenv();
  7103     extern char *getenv();
  7062 
  7104 
  7063     if (__isStringLike(aStringOrSymbol)) {
  7105     if (__isStringLike(aStringOrSymbol)) {
  7064 	char *env =  getenv(__stringVal(aStringOrSymbol));
  7106 	char *env =  getenv(__stringVal(aStringOrSymbol));
  7065 	if (env) {
  7107 	if (env) {
  7066 	    RETURN ( __MKSTRING(env) );
  7108 	    RETURN ( __MKSTRING(env) );
  7067 	}
  7109 	}
  7068 	RETURN ( nil );
  7110 	RETURN ( nil );
  7069     }
  7111     }
       
  7112 #endif /* not SCHTEAM */
  7070 %}.
  7113 %}.
  7071     ^ self primitiveFailed
  7114     ^ self primitiveFailed
  7072 
  7115 
  7073     "
  7116     "
  7074      OperatingSystem getEnvironment:'LANG'
  7117      OperatingSystem getEnvironment:'LANG'
 14200 ! !
 14243 ! !
 14201 
 14244 
 14202 !UnixOperatingSystem class methodsFor:'documentation'!
 14245 !UnixOperatingSystem class methodsFor:'documentation'!
 14203 
 14246 
 14204 version
 14247 version
 14205     ^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.435 2015-04-19 09:43:40 cg Exp $'
 14248     ^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.436 2015-04-21 19:41:36 cg Exp $'
 14206 !
 14249 !
 14207 
 14250 
 14208 version_CVS
 14251 version_CVS
 14209     ^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.435 2015-04-19 09:43:40 cg Exp $'
 14252     ^ '$Header: /cvs/stx/stx/libbasic/UnixOperatingSystem.st,v 1.436 2015-04-21 19:41:36 cg Exp $'
 14210 ! !
 14253 ! !
 14211 
 14254 
 14212 
 14255 
 14213 UnixOperatingSystem initialize!
 14256 UnixOperatingSystem initialize!
 14214 UnixOperatingSystem::ELFConstants initialize!
 14257 UnixOperatingSystem::ELFConstants initialize!