1 karl 1.38 //%2005////////////////////////////////////////////////////////////////////////
|
2 kumpf 1.14 //
|
3 karl 1.36 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 karl 1.29 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.36 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.38 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 mike 1.2 //
12 // Permission is hereby granted, free of charge, to any person obtaining a copy
|
13 kumpf 1.14 // of this software and associated documentation files (the "Software"), to
14 // deal in the Software without restriction, including without limitation the
15 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
16 mike 1.2 // sell copies of the Software, and to permit persons to whom the Software is
17 // furnished to do so, subject to the following conditions:
|
18 david.dillard 1.42 //
|
19 kumpf 1.14 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
|
20 mike 1.2 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
21 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
|
22 kumpf 1.14 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
23 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
24 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
25 mike 1.2 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 //
28 //==============================================================================
29 //
30 // Author: Mike Day (mdday@us.ibm.com)
31 //
32 // Modified By: Markus Mueller
|
33 david.dillard 1.42 // Ramnath Ravindran (Ramnath.Ravindran@compaq.com)
34 // David Eger (dteger@us.ibm.com)
35 // Amit K Arora, IBM (amita@in.ibm.com) for PEP#101
36 // Sean Keenan, Hewlett-Packard Company (sean.keenan@hp.com)
37 // Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
38 // David Dillard, VERITAS Software Corp.
39 // (david.dillard@veritas.com)
|
40 aruran.ms 1.46 // Aruran, IBM (ashanmug@in.ibm.com) for BUG# 3518, 4067
|
41 mike 1.2 //
42 //%/////////////////////////////////////////////////////////////////////////////
43
44 #ifndef Pegasus_IPC_h
45 #define Pegasus_IPC_h
46
47 #include <Pegasus/Common/Config.h>
|
48 kumpf 1.17 #include <Pegasus/Common/Linkage.h>
|
49 a.arora 1.33 #include <Pegasus/Common/AutoPtr.h>
|
50 mike 1.47 #include <Pegasus/Common/IPCTypes.h>
51 #include <Pegasus/Common/Mutex.h>
52 #include <Pegasus/Common/AtomicInt.h>
|
53 mike 1.2
54 #define PEG_SEM_READ 1
55 #define PEG_SEM_WRITE 2
56
57 #include <Pegasus/Common/internal_dq.h>
58
59 PEGASUS_NAMESPACE_BEGIN
60
|
61 david.dillard 1.42 int timeval_subtract (struct timeval *result,
62 struct timeval *x,
63 struct timeval *y);
|
64 mike 1.2
65 //%///////////////// ----- IPC related functions ------- //////////////////////
66 // ----- NOTE - these functions are PRIMITIVES that MUST be implemented
67 // by the platform. e.g., see IPCUnix.cpp
68
|
69 david.dillard 1.42 void PEGASUS_COMMON_LINKAGE disable_cancel();
70 void PEGASUS_COMMON_LINKAGE enable_cancel();
|
71 mike 1.2 //void PEGASUS_COMMON_LINKAGE native_cleanup_push( void (*)(void *), void * );
72 void PEGASUS_COMMON_LINKAGE native_cleanup_pop(Boolean execute);
|
73 mike 1.4
74 #ifdef PEGASUS_NEED_CRITICAL_TYPE
|
75 mike 1.2 void PEGASUS_COMMON_LINKAGE init_crit(PEGASUS_CRIT_TYPE *crit);
76 void PEGASUS_COMMON_LINKAGE enter_crit(PEGASUS_CRIT_TYPE *crit);
77 void PEGASUS_COMMON_LINKAGE try_crit(PEGASUS_CRIT_TYPE *crit);
78 void PEGASUS_COMMON_LINKAGE destroy_crit(PEGASUS_CRIT_TYPE *crit);
79 void PEGASUS_COMMON_LINKAGE exit_crit(PEGASUS_CRIT_TYPE *crit);
|
80 mike 1.4 #endif
81
|
82 david.dillard 1.42 PEGASUS_THREAD_TYPE PEGASUS_COMMON_LINKAGE pegasus_thread_self();
83 void PEGASUS_COMMON_LINKAGE exit_thread(PEGASUS_THREAD_RETURN rc);
|
84 mike 1.2 void PEGASUS_COMMON_LINKAGE pegasus_sleep(int ms);
85 void PEGASUS_COMMON_LINKAGE destroy_thread(PEGASUS_THREAD_TYPE th, PEGASUS_THREAD_RETURN rc);
86
87
88
89 //%//////// -------- IPC Exception Classes -------- ///////////////////////////////
90
91 class PEGASUS_COMMON_LINKAGE IPCException
92 {
|
93 david.dillard 1.42 public:
94 IPCException(PEGASUS_THREAD_TYPE owner): _owner(owner) { }
95 inline PEGASUS_THREAD_TYPE get_owner() { return(_owner); }
96 private:
97 PEGASUS_THREAD_TYPE _owner;
|
98 mike 1.2 };
99
100 class PEGASUS_COMMON_LINKAGE Deadlock: public IPCException
101 {
|
102 david.dillard 1.42 public:
103 Deadlock(PEGASUS_THREAD_TYPE owner) : IPCException(owner) {}
104 private:
105 Deadlock();
|
106 mike 1.2 };
107
108 class PEGASUS_COMMON_LINKAGE AlreadyLocked: public IPCException
109 {
|
110 david.dillard 1.42 public:
111 AlreadyLocked(PEGASUS_THREAD_TYPE owner) : IPCException(owner) {}
112 private:
113 AlreadyLocked();
|
114 mike 1.2 };
115
116 class PEGASUS_COMMON_LINKAGE TimeOut: public IPCException
117 {
|
118 david.dillard 1.42 public:
119 TimeOut(PEGASUS_THREAD_TYPE owner) : IPCException(owner) {}
120 private:
121 TimeOut();
|
122 mike 1.2 };
123
124 class PEGASUS_COMMON_LINKAGE Permission: public IPCException
125 {
|
126 david.dillard 1.42 public:
127 Permission(PEGASUS_THREAD_TYPE owner) : IPCException(owner) {}
128 private:
129 Permission();
130 };
|
131 mike 1.2
132 class PEGASUS_COMMON_LINKAGE WaitFailed: public IPCException
133 {
|
134 david.dillard 1.42 public:
135 WaitFailed(PEGASUS_THREAD_TYPE owner) : IPCException(owner) {}
136 private:
137 WaitFailed();
138 };
|
139 mike 1.2
|
140 konrad.r 1.35 class PEGASUS_COMMON_LINKAGE WaitInterrupted: public IPCException
141 {
|
142 david.dillard 1.42 public:
143 WaitInterrupted(PEGASUS_THREAD_TYPE owner) : IPCException(owner) {}
144 private:
145 WaitInterrupted();
146 };
|
147 konrad.r 1.35
|
148 mike 1.2 class PEGASUS_COMMON_LINKAGE TooManyReaders: public IPCException
149 {
|
150 david.dillard 1.42 public:
151 TooManyReaders(PEGASUS_THREAD_TYPE owner) : IPCException(owner) { }
152 private:
153 TooManyReaders();
|
154 mike 1.2 };
155
156
157 class PEGASUS_COMMON_LINKAGE ListFull: public IPCException
158 {
|
159 david.dillard 1.42 public:
160 ListFull(Uint32 count) : IPCException(pegasus_thread_self())
161 {
162 _capacity = count;
163 }
164
165 Uint32 get_capacity() const throw()
166 {
167 return _capacity;
168 }
169
170 private:
171 ListFull();
172 Uint32 _capacity;
|
173 mike 1.2 };
174
175 class PEGASUS_COMMON_LINKAGE ListClosed: public IPCException
176 {
|
177 david.dillard 1.42 public:
178 ListClosed() : IPCException(pegasus_thread_self())
179 {
180 }
|
181 mike 1.2 };
|
182 david.dillard 1.42
|
183 mday 1.9 class PEGASUS_COMMON_LINKAGE ModuleClosed: public IPCException
184 {
|
185 david.dillard 1.42 public:
186 ModuleClosed() : IPCException(pegasus_thread_self())
187 {
188 }
|
189 mday 1.9 };
|
190 mike 1.2
|
191 mday 1.23 //%//////////////////////////////////////////////////////////////
|
192 kumpf 1.31 // AutoMutex - use when you could lose scope due to an exception
|
193 mday 1.23 /////////////////////////////////////////////////////////////////
194
|
195 kumpf 1.31 class PEGASUS_COMMON_LINKAGE AutoMutex
|
196 mday 1.23 {
|
197 david.dillard 1.42 public:
|
198 kumpf 1.45 AutoMutex(Mutex& mutex, Boolean autoLock = true)
199 : _mutex(mutex),
200 _locked(autoLock)
201 {
202 if (autoLock)
203 {
204 _mutex.lock(pegasus_thread_self());
205 }
206 }
207
208 ~AutoMutex()
209 {
210 try
211 {
|
212 aruran.ms 1.46 if (_locked)
213 {
214 unlock();
215 }
|
216 kumpf 1.45 }
217 catch (...)
218 {
219 // Do not propagate exception from destructor
220 }
221 }
222
223 void lock()
|
224 david.dillard 1.42 {
|
225 kumpf 1.45 if (_locked)
226 {
227 throw AlreadyLocked(pegasus_thread_self());
228 }
229
230 _mutex.lock(pegasus_thread_self());
231 _locked = true;
232 }
233
234 void unlock()
235 {
236 if (!_locked)
237 {
238 throw Permission(pegasus_thread_self());
239 }
240
241 _mutex.unlock();
242 _locked = false;
|
243 david.dillard 1.42 }
|
244 mday 1.23
|
245 kumpf 1.45 Boolean isLocked() const
|
246 david.dillard 1.42 {
|
247 kumpf 1.45 return _locked;
|
248 david.dillard 1.42 }
|
249 kumpf 1.30
|
250 david.dillard 1.42 private:
|
251 kumpf 1.45 AutoMutex(); // Unimplemented
|
252 david.dillard 1.42 AutoMutex(const AutoMutex& x); // Unimplemented
253 AutoMutex& operator=(const AutoMutex& x); // Unimplemented
|
254 kumpf 1.31
|
255 kumpf 1.45 Mutex& _mutex;
256 Boolean _locked;
|
257 mday 1.23 };
258
259
|
260 mike 1.2 //%////////////////////////////////////////////////////////////////////////////
|
261 david.dillard 1.42
|
262 mike 1.2 class PEGASUS_COMMON_LINKAGE Semaphore
263 {
|
264 david.dillard 1.42 public:
|
265 mike 1.2
|
266 kumpf 1.43 /**
267 Creates a semaphore and sets its initial value as specified.
268 @param initial The initial value for the Semaphore (defaults to 1).
269 */
270 Semaphore(Uint32 initial = 1);
|
271 david.dillard 1.42
272 ~Semaphore();
273
|
274 kumpf 1.43 /**
275 Blocks until this Semaphore is in a signalled state.
276 @param ignoreInterrupt Indicates whether the wait operation should
277 continue (true) or an exception should be thrown (false) when an
278 interrupt is received.
279 @exception WaitFailed If unable to block on the semaphore.
280 @exception WaitInterrupted If the operation is interrupted.
281 */
|
282 david.dillard 1.42 void wait(Boolean ignoreInterrupt = true);
283
|
284 kumpf 1.43 /**
285 Checks whether the Semaphore is signalled without waiting. This method
286 returns normally if the Semaphore has a non-zero count.
287 @exception WaitFailed If the wait operation does not immediately
288 succeed.
289 */
|
290 david.dillard 1.42 void try_wait();
291
|
292 kumpf 1.43 /**
293 Waits for the Semaphore to be signalled for a specified time interval.
294 This method returns normally if the Semaphore has a non-zero count or
295 it is signalled during the specified time interval.
296 @param milliseconds The time interval to wait (in milliseconds).
297 @exception TimeOut If the wait operation does not succeed within
298 the specified time interval.
299 */
|
300 david.dillard 1.42 void time_wait(Uint32 milliseconds);
|
301 mike 1.2
|
302 kumpf 1.43 /**
303 Increments the count of the semaphore.
304 */
|
305 david.dillard 1.42 void signal();
|
306 mike 1.2
|
307 kumpf 1.43 /**
308 Return the count of the semaphore.
309 */
|
310 david.dillard 1.42 int count() const;
|
311 mike 1.2
|
312 david.dillard 1.42 private:
|
313 kumpf 1.43
314 Semaphore(const Semaphore& x); // Unimplemented
315 Semaphore& operator=(const Semaphore& x); // Unimplemented
316
317 mutable PEGASUS_SEM_HANDLE _semaphore;
|
318 mike 1.2
|
319 david.dillard 1.42 // may not need to use the _count member on
320 // platforms that allow you to ask the semaphore for
321 // its count
322 mutable int _count;
|
323 mike 1.2
|
324 mike 1.47 //------------------------------------------------------------------------------
325 //
326 // AtomicInt inclusion:
327 //
328 //------------------------------------------------------------------------------
|
329 david.dillard 1.42 friend class Condition;
|
330 mike 1.2 };
331
332
|
333 mike 1.47 PEGASUS_NAMESPACE_END
|
334 mike 1.2
|
335 mike 1.47 #include <Pegasus/Common/AtomicInt.h>
|
336 david.dillard 1.42
|
337 mike 1.47 PEGASUS_NAMESPACE_BEGIN
|
338 mike 1.2
339 //-----------------------------------------------------------------
340 /// Generic definition of read/write semaphore
341 //-----------------------------------------------------------------
342
343 #ifndef PEGASUS_READWRITE_NATIVE
344
345 typedef struct pegasus_rwlock {
|
346 david.dillard 1.42 Semaphore _rlock;
347 Mutex _wlock;
348 Mutex _internal_lock;
349 PEGASUS_THREAD_TYPE _owner;
350 pegasus_rwlock() : _rlock(10), _wlock(), _internal_lock(), _owner(pegasus_thread_self())
351 {
352 }
|
353 mike 1.2 } PEGASUS_RWLOCK_HANDLE;
354
355 #endif
356
357 class PEGASUS_COMMON_LINKAGE ReadWriteSem
358 {
|
359 david.dillard 1.42 public:
360 ReadWriteSem();
361 ~ReadWriteSem();
362
363 // @exception Deadlock
364 // @exception Permission
365 // @exception WaitFailed
366 inline void wait_read(PEGASUS_THREAD_TYPE caller)
367 {
368 wait(PEG_SEM_READ, caller );
369 }
370
371 // @exception Deadlock
372 // @exception Permission
373 // @exception WaitFailed
374 inline void wait_write(PEGASUS_THREAD_TYPE caller)
375 {
376 wait(PEG_SEM_WRITE, caller);
377 }
378
379 // @exception Deadlock
380 david.dillard 1.42 // @exception Permission
381 // @exception AlreadyLocked
382 // @exception WaitFailed
383 inline void try_wait_read(PEGASUS_THREAD_TYPE caller)
384 {
385 try_wait(PEG_SEM_READ, caller);
386 }
387
388 // @exception Deadlock
389 // @exception Permission
390 // @exception AlreadyLocked
391 // @exception WaitFailed
392 inline void try_wait_write(PEGASUS_THREAD_TYPE caller)
393 {
394 try_wait(PEG_SEM_WRITE, caller);
395 }
396
397 // @exception Deadlock
398 // @exception Permission
399 // @exception TimeOut
400 // @exception WaitFailed
401 david.dillard 1.42 inline void timed_wait_read(PEGASUS_THREAD_TYPE caller, int milliseconds)
402 {
403 timed_wait(PEG_SEM_READ, caller, milliseconds);
404 }
405
406 // @exception Deadlock
407 // @exception Permission
408 // @exception TimeOut
409 // @exception WaitFailed
410 inline void timed_wait_write(PEGASUS_THREAD_TYPE caller, int milliseconds)
411 {
412 timed_wait(PEG_SEM_WRITE, caller, milliseconds);
413 }
|
414 mike 1.2
|
415 david.dillard 1.42 // @exception Permission
416 inline void unlock_read(PEGASUS_THREAD_TYPE caller)
417 {
418 unlock(PEG_SEM_READ, caller);
419 }
|
420 mike 1.2
|
421 david.dillard 1.42 // @exception Permission
422 inline void unlock_write(PEGASUS_THREAD_TYPE caller)
423 {
424 unlock(PEG_SEM_WRITE, caller);
425 }
|
426 mike 1.2
|
427 david.dillard 1.42 int read_count() const;
428 int write_count() const;
|
429 mike 1.2
|
430 david.dillard 1.42 // @exception Deadlock
431 // @exception Permission
432 // @exception WaitFailed
433 // @exception TooManyReaders
434 void wait(Uint32 mode, PEGASUS_THREAD_TYPE caller);
435
436 // @exception Deadlock
437 // @exception Permission
438 // @exception WaitFailed
439 // @exception TooManyReaders
440 void try_wait(Uint32 mode, PEGASUS_THREAD_TYPE caller);
441
442 // @exception Timeout
443 // @exception Deadlock
444 // @exception Permission
445 // @exception WaitFailed
446 // @exception TooManyReaders
447 void timed_wait(Uint32 mode, PEGASUS_THREAD_TYPE caller, int milliseconds);
|
448 mike 1.2
|
449 david.dillard 1.42 // @exception Permission
450 void unlock(Uint32 mode, PEGASUS_THREAD_TYPE caller);
|
451 mike 1.2
|
452 david.dillard 1.42 private:
453 AtomicInt _readers;
454 AtomicInt _writers;
455 PEGASUS_RWLOCK_HANDLE _rwlock;
456 friend void extricate_read_write(void *);
457 };
|
458 mike 1.2
|
459 kumpf 1.28
460 // Classes used for safe locking of ReadWriteSem
461
462 class ReadLock
463 {
464 public:
465 ReadLock(ReadWriteSem & rwsem) : _rwsem(rwsem)
466 {
467 _rwsem.wait_read(pegasus_thread_self());
468 }
469
|
470 david.dillard 1.42 ~ReadLock()
|
471 kumpf 1.28 {
472 _rwsem.unlock_read(pegasus_thread_self());
473 }
474
475 private:
476 ReadWriteSem & _rwsem;
477 };
478
479 class WriteLock
480 {
481 public:
482 WriteLock(ReadWriteSem & rwsem) : _rwsem(rwsem)
483 {
484 _rwsem.wait_write(pegasus_thread_self());
485 }
486
|
487 david.dillard 1.42 ~WriteLock()
|
488 kumpf 1.28 {
489 _rwsem.unlock_write(pegasus_thread_self());
490 }
491
492 private:
493 ReadWriteSem & _rwsem;
494 };
495
496
|
497 mike 1.2 //-----------------------------------------------------------------
498 /// Generic definition of conditional semaphore
499 //-----------------------------------------------------------------
500
501
502 #ifndef PEGASUS_CONDITIONAL_NATIVE
503
504 // typedef PEGASUS_SEMAPHORE_TYPE PEGASUS_COND_TYPE;
505
506 class PEGASUS_COMMON_LINKAGE cond_waiter {
|
507 david.dillard 1.42 public:
508 cond_waiter( PEGASUS_THREAD_TYPE caller, Sint32 time = -1)
509 : waiter(caller), signalled(0) { }
510
511 ~cond_waiter()
512 {
513 signalled.signal();
514 }
515
516 inline Boolean operator==(const void *key) const
517 {
518 if((PEGASUS_THREAD_TYPE)key == waiter)
519 return true;
520 return false;
|
521 mike 1.2 }
|
522 david.dillard 1.42
523 inline Boolean operator ==(const cond_waiter & b ) const
524 {
525 return (operator ==(b.waiter)) ;
526 }
527
528 private:
|
529 mike 1.2 cond_waiter();
530 PEGASUS_THREAD_TYPE waiter;
531 Semaphore signalled;
532 friend class Condition;
533 };
534
535 typedef struct peg_condition{
|
536 david.dillard 1.42 internal_dq _waiters;
537 Mutex _spin;
538 peg_condition() : _waiters(true), _spin() { }
|
539 mike 1.2 } PEGASUS_COND_TYPE;
540
|
541 david.dillard 1.42 #endif
|
542 mike 1.2
543 class PEGASUS_COMMON_LINKAGE Condition
|
544 david.dillard 1.42 {
545 public:
546 // create the condition variable
547 Condition();
548 ~Condition();
|
549 aruran.ms 1.44 Condition(Mutex& mutex);
|
550 david.dillard 1.42
551 // signal the condition variable
552 // @exception IPCException
553 void signal(PEGASUS_THREAD_TYPE caller);
554
555 // @exception IPCException
556 void lock_object(PEGASUS_THREAD_TYPE caller);
557
558 // @exception IPCException
559 void try_lock_object(PEGASUS_THREAD_TYPE caller);
560
561 // @exception IPCException
562 void wait_lock_object(PEGASUS_THREAD_TYPE caller, int milliseconds);
563
564 void unlock_object();
565
566 // without pthread_mutex_lock/unlock
567 // @exception IPCException
568 void unlocked_wait(PEGASUS_THREAD_TYPE caller);
569
570 // @exception IPCException
571 david.dillard 1.42 void unlocked_timed_wait(int milliseconds, PEGASUS_THREAD_TYPE caller);
572
573 // @exception IPCException
574 void unlocked_signal(PEGASUS_THREAD_TYPE caller);
575
576 void set_owner(PEGASUS_THREAD_TYPE caller)
577 {
578 _cond_mutex->_set_owner(caller);
579 }
580
581 void disallow()
582 {
583 _disallow++;
584 }
585
586 void reallow()
587 {
|
588 mike 1.47 if(_disallow.get() > 0)
|
589 david.dillard 1.42 _disallow--;
590 }
591
592 Boolean is_shutdown() const
593 {
|
594 mike 1.47 if(_disallow.get() > 0)
|
595 david.dillard 1.42 return true;
596 return false;
597 }
|
598 mike 1.2
|
599 david.dillard 1.42 private:
600 AtomicInt _disallow; // don't allow any further waiters
601 Boolean _destroy_mut;
602 PEGASUS_COND_TYPE _condition; // special type to control execution flow
603 AutoPtr<Mutex> _cond_mutex; // the conditional mutex //PEP101
604 friend void extricate_condition(void *);
605
606 // Hide the assignment operator to avoid implicit use of the default
607 // assignment operator. Do not use this method.
608 Condition& operator=(const Condition& original) {return *this;}
609
610 // Hide the copy constructor to avoid implicit use of the default
611 // copy constructor. Do not use this method.
612 Condition(const Condition& original) {}
|
613 mike 1.2 };
614
615
616 #if defined(PEGASUS_PLATFORM_WIN32_IX86_MSVC)
617 # include "IPCWindows_inline.h"
|
618 david.eger 1.26 #elif defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)
|
619 mike 1.2 # include "IPCUnix_inline.h"
|
620 kumpf 1.19 #elif defined(PEGASUS_PLATFORM_HPUX_ACC)
|
621 mike 1.4 # include "IPCUnix_inline.h"
622 #elif defined(PEGASUS_PLATFORM_SOLARIS_SPARC_GNU)
|
623 keith.petley 1.27 # include "IPCUnix_inline.h"
624 #elif defined(PEGASUS_PLATFORM_SOLARIS_SPARC_CC)
|
625 sage 1.6 # include "IPCUnix_inline.h"
626 #elif defined(PEGASUS_PLATFORM_AIX_RS_IBMCXX)
627 # include "IPCUnix_inline.h"
628 #elif defined(PEGASUS_PLATFORM_ZOS_ZSERIES_IBM)
|
629 ramnath 1.7 # include "IPCUnix_inline.h"
630 #elif defined(PEGASUS_PLATFORM_TRU64_ALPHA_DECCXX)
|
631 chuck 1.18 # include "IPCUnix_inline.h"
632 #elif defined(PEGASUS_PLATFORM_OS400_ISERIES_IBM)
|
633 dudhe.girish 1.32 # include "IPCUnix_inline.h"
634 #elif defined(PEGASUS_PLATFORM_DARWIN_PPC_GNU)
|
635 mike 1.2 # include "IPCUnix_inline.h"
|
636 gs.keenan 1.39 #elif defined(PEGASUS_OS_VMS)
637 # include "IPCVms_inline.h"
|
638 mike 1.2 #endif
639
640 PEGASUS_NAMESPACE_END
641
642 #endif /* Pegasus_IPC_h */
|
Return to
IPC.h
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / Common