Process.h.in 22.2 KB
Newer Older
1 2
/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
3 4 5
#ifndef @KWSYS_NAMESPACE@_Process_h
#define @KWSYS_NAMESPACE@_Process_h

Brad King's avatar
Brad King committed
6 7
#include <@KWSYS_NAMESPACE@/Configure.h>

8 9 10 11
/* Redefine all public interface symbol names to be in the proper
   namespace.  These macros are used internally to kwsys only, and are
   not visible to user code.  Use kwsysHeaderDump.pl to reproduce
   these macros after making changes to the interface.  */
12
#if !defined(KWSYS_NAMESPACE)
13 14
#  define kwsys_ns(x) @KWSYS_NAMESPACE@##x
#  define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
15
#endif
16
#if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85
#  define kwsysProcess kwsys_ns(Process)
#  define kwsysProcess_s kwsys_ns(Process_s)
#  define kwsysProcess_New kwsys_ns(Process_New)
#  define kwsysProcess_Delete kwsys_ns(Process_Delete)
#  define kwsysProcess_SetCommand kwsys_ns(Process_SetCommand)
#  define kwsysProcess_AddCommand kwsys_ns(Process_AddCommand)
#  define kwsysProcess_SetTimeout kwsys_ns(Process_SetTimeout)
#  define kwsysProcess_SetWorkingDirectory                                    \
    kwsys_ns(Process_SetWorkingDirectory)
#  define kwsysProcess_SetPipeFile kwsys_ns(Process_SetPipeFile)
#  define kwsysProcess_SetPipeNative kwsys_ns(Process_SetPipeNative)
#  define kwsysProcess_SetPipeShared kwsys_ns(Process_SetPipeShared)
#  define kwsysProcess_Option_Detach kwsys_ns(Process_Option_Detach)
#  define kwsysProcess_Option_HideWindow kwsys_ns(Process_Option_HideWindow)
#  define kwsysProcess_Option_MergeOutput kwsys_ns(Process_Option_MergeOutput)
#  define kwsysProcess_Option_Verbatim kwsys_ns(Process_Option_Verbatim)
#  define kwsysProcess_Option_CreateProcessGroup                              \
    kwsys_ns(Process_Option_CreateProcessGroup)
#  define kwsysProcess_GetOption kwsys_ns(Process_GetOption)
#  define kwsysProcess_SetOption kwsys_ns(Process_SetOption)
#  define kwsysProcess_Option_e kwsys_ns(Process_Option_e)
#  define kwsysProcess_State_Starting kwsys_ns(Process_State_Starting)
#  define kwsysProcess_State_Error kwsys_ns(Process_State_Error)
#  define kwsysProcess_State_Exception kwsys_ns(Process_State_Exception)
#  define kwsysProcess_State_Executing kwsys_ns(Process_State_Executing)
#  define kwsysProcess_State_Exited kwsys_ns(Process_State_Exited)
#  define kwsysProcess_State_Expired kwsys_ns(Process_State_Expired)
#  define kwsysProcess_State_Killed kwsys_ns(Process_State_Killed)
#  define kwsysProcess_State_Disowned kwsys_ns(Process_State_Disowned)
#  define kwsysProcess_State_e kwsys_ns(Process_State_e)
#  define kwsysProcess_Exception_None kwsys_ns(Process_Exception_None)
#  define kwsysProcess_Exception_Fault kwsys_ns(Process_Exception_Fault)
#  define kwsysProcess_Exception_Illegal kwsys_ns(Process_Exception_Illegal)
#  define kwsysProcess_Exception_Interrupt                                    \
    kwsys_ns(Process_Exception_Interrupt)
#  define kwsysProcess_Exception_Numerical                                    \
    kwsys_ns(Process_Exception_Numerical)
#  define kwsysProcess_Exception_Other kwsys_ns(Process_Exception_Other)
#  define kwsysProcess_Exception_e kwsys_ns(Process_Exception_e)
#  define kwsysProcess_GetState kwsys_ns(Process_GetState)
#  define kwsysProcess_GetExitException kwsys_ns(Process_GetExitException)
#  define kwsysProcess_GetExitCode kwsys_ns(Process_GetExitCode)
#  define kwsysProcess_GetExitValue kwsys_ns(Process_GetExitValue)
#  define kwsysProcess_GetErrorString kwsys_ns(Process_GetErrorString)
#  define kwsysProcess_GetExceptionString kwsys_ns(Process_GetExceptionString)
#  define kwsysProcess_GetStateByIndex kwsys_ns(Process_GetStateByIndex)
#  define kwsysProcess_GetExitExceptionByIndex                                \
    kwsys_ns(Process_GetExitExceptionByIndex)
#  define kwsysProcess_GetExitCodeByIndex kwsys_ns(Process_GetExitCodeByIndex)
#  define kwsysProcess_GetExitValueByIndex                                    \
    kwsys_ns(Process_GetExitValueByIndex)
#  define kwsysProcess_GetExceptionStringByIndex                              \
    kwsys_ns(Process_GetExceptionStringByIndex)
#  define kwsysProcess_GetExitCodeByIndex kwsys_ns(Process_GetExitCodeByIndex)
#  define kwsysProcess_Execute kwsys_ns(Process_Execute)
#  define kwsysProcess_Disown kwsys_ns(Process_Disown)
#  define kwsysProcess_WaitForData kwsys_ns(Process_WaitForData)
#  define kwsysProcess_Pipes_e kwsys_ns(Process_Pipes_e)
#  define kwsysProcess_Pipe_None kwsys_ns(Process_Pipe_None)
#  define kwsysProcess_Pipe_STDIN kwsys_ns(Process_Pipe_STDIN)
#  define kwsysProcess_Pipe_STDOUT kwsys_ns(Process_Pipe_STDOUT)
#  define kwsysProcess_Pipe_STDERR kwsys_ns(Process_Pipe_STDERR)
#  define kwsysProcess_Pipe_Timeout kwsys_ns(Process_Pipe_Timeout)
#  define kwsysProcess_Pipe_Handle kwsys_ns(Process_Pipe_Handle)
#  define kwsysProcess_WaitForExit kwsys_ns(Process_WaitForExit)
#  define kwsysProcess_Interrupt kwsys_ns(Process_Interrupt)
#  define kwsysProcess_Kill kwsys_ns(Process_Kill)
#  define kwsysProcess_KillPID kwsys_ns(Process_KillPID)
#  define kwsysProcess_ResetStartTime kwsys_ns(Process_ResetStartTime)
86
#endif
87 88

#if defined(__cplusplus)
89
extern "C" {
90 91
#endif

92 93 94
/**
 * Process control data structure.
 */
95 96
typedef struct kwsysProcess_s kwsysProcess;

97 98 99 100 101 102 103
/* Platform-specific pipe handle type.  */
#if defined(_WIN32) && !defined(__CYGWIN__)
typedef void* kwsysProcess_Pipe_Handle;
#else
typedef int kwsysProcess_Pipe_Handle;
#endif

104 105 106
/**
 * Create a new Process instance.
 */
107
kwsysEXPORT kwsysProcess* kwsysProcess_New(void);
108

109 110 111 112
/**
 * Delete an existing Process instance.  If the instance is currently
 * executing a process, this blocks until the process terminates.
 */
Brad King's avatar
Brad King committed
113
kwsysEXPORT void kwsysProcess_Delete(kwsysProcess* cp);
114

115 116
/**
 * Set the command line to be executed.  Argument is an array of
Mathieu Malaterre's avatar
Mathieu Malaterre committed
117
 * pointers to the command and each argument.  The array must end with
118 119
 * a NULL pointer.  Any previous command lines are removed.  Returns
 * 1 for success and 0 otherwise.
120
 */
121 122 123 124 125
kwsysEXPORT int kwsysProcess_SetCommand(kwsysProcess* cp,
                                        char const* const* command);

/**
 * Add a command line to be executed.  Argument is an array of
Mathieu Malaterre's avatar
Mathieu Malaterre committed
126
 * pointers to the command and each argument.  The array must end with
127 128 129 130 131 132
 * a NULL pointer.  If this is not the first command added, its
 * standard input will be connected to the standard output of the
 * previous command.  Returns 1 for success and 0 otherwise.
 */
kwsysEXPORT int kwsysProcess_AddCommand(kwsysProcess* cp,
                                        char const* const* command);
133

134
/**
135 136 137 138
 * Set the timeout in seconds for the child process.  The timeout
 * period begins when the child is executed.  If the child has not
 * terminated when the timeout expires, it will be killed.  A
 * non-positive (<= 0) value will disable the timeout.
139
 */
Brad King's avatar
Brad King committed
140
kwsysEXPORT void kwsysProcess_SetTimeout(kwsysProcess* cp, double timeout);
141

142
/**
143 144
 * Set the working directory for the child process.  The working
 * directory can be absolute or relative to the current directory.
145
 * Returns 1 for success and 0 for failure.
146
 */
147 148 149 150 151 152 153 154 155
kwsysEXPORT int kwsysProcess_SetWorkingDirectory(kwsysProcess* cp,
                                                 const char* dir);

/**
 * Set the name of a file to be attached to the given pipe.  Returns 1
 * for success and 0 for failure.
 */
kwsysEXPORT int kwsysProcess_SetPipeFile(kwsysProcess* cp, int pipe,
                                         const char* file);
156

157 158 159 160 161 162 163 164
/**
 * Set whether the given pipe in the child is shared with the parent
 * process.  The default is no for Pipe_STDOUT and Pipe_STDERR and yes
 * for Pipe_STDIN.
 */
kwsysEXPORT void kwsysProcess_SetPipeShared(kwsysProcess* cp, int pipe,
                                            int shared);

165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
/**
 * Specify a platform-specific native pipe for use as one of the child
 * interface pipes.  The native pipe is specified by an array of two
 * descriptors or handles.  The first entry in the array (index 0)
 * should be the read end of the pipe.  The second entry in the array
 * (index 1) should be the write end of the pipe.  If a null pointer
 * is given the option will be disabled.
 *
 * For Pipe_STDIN the native pipe is connected to the first child in
 * the pipeline as its stdin.  After the children are created the
 * write end of the pipe will be closed in the child process and the
 * read end will be closed in the parent process.
 *
 * For Pipe_STDOUT and Pipe_STDERR the pipe is connected to the last
 * child as its stdout or stderr.  After the children are created the
 * write end of the pipe will be closed in the parent process and the
 * read end will be closed in the child process.
 */
kwsysEXPORT void kwsysProcess_SetPipeNative(kwsysProcess* cp, int pipe,
                                            kwsysProcess_Pipe_Handle p[2]);

186
/**
187 188 189 190 191
 * Get/Set a possibly platform-specific option.  Possible options are:
 *
 *  kwsysProcess_Option_Detach = Whether to detach the process.
 *         0 = No (default)
 *         1 = Yes
192 193 194 195
 *
 *  kwsysProcess_Option_HideWindow = Whether to hide window on Windows.
 *         0 = No (default)
 *         1 = Yes
196
 *
197 198 199 200 201 202
 *  kwsysProcess_Option_MergeOutput = Whether to merge stdout/stderr.
 *                                    No content will be returned as stderr.
 *                                    Any actual stderr will be on stdout.
 *         0 = No (default)
 *         1 = Yes
 *
203 204 205 206 207 208
 *  kwsysProcess_Option_Verbatim = Whether SetCommand and AddCommand
 *                                 should treat the first argument
 *                                 as a verbatim command line
 *                                 and ignore the rest of the arguments.
 *         0 = No (default)
 *         1 = Yes
209 210 211 212 213 214 215 216 217
 *
 *  kwsysProcess_Option_CreateProcessGroup = Whether to place the process in a
 *                                           new process group.  This is
 *                                           useful if you want to send Ctrl+C
 *                                           to the process.  On UNIX, also
 *                                           places the process in a new
 *                                           session.
 *         0 = No (default)
 *         1 = Yes
218 219 220 221 222 223
 */
kwsysEXPORT int kwsysProcess_GetOption(kwsysProcess* cp, int optionId);
kwsysEXPORT void kwsysProcess_SetOption(kwsysProcess* cp, int optionId,
                                        int value);
enum kwsysProcess_Option_e
{
224
  kwsysProcess_Option_HideWindow,
225
  kwsysProcess_Option_Detach,
226
  kwsysProcess_Option_MergeOutput,
227 228
  kwsysProcess_Option_Verbatim,
  kwsysProcess_Option_CreateProcessGroup
229 230
};

231 232 233 234 235 236 237 238 239 240
/**
 * Get the current state of the Process instance.  Possible states are:
 *
 *  kwsysProcess_State_Starting  = Execute has not yet been called.
 *  kwsysProcess_State_Error     = Error administrating the child process.
 *  kwsysProcess_State_Exception = Child process exited abnormally.
 *  kwsysProcess_State_Executing = Child process is currently running.
 *  kwsysProcess_State_Exited    = Child process exited normally.
 *  kwsysProcess_State_Expired   = Child process's timeout expired.
 *  kwsysProcess_State_Killed    = Child process terminated by Kill method.
241
 *  kwsysProcess_State_Disowned  = Child is no longer managed by this object.
242
 */
Brad King's avatar
Brad King committed
243
kwsysEXPORT int kwsysProcess_GetState(kwsysProcess* cp);
244
enum kwsysProcess_State_e
245 246 247 248 249 250 251
{
  kwsysProcess_State_Starting,
  kwsysProcess_State_Error,
  kwsysProcess_State_Exception,
  kwsysProcess_State_Executing,
  kwsysProcess_State_Exited,
  kwsysProcess_State_Expired,
252 253
  kwsysProcess_State_Killed,
  kwsysProcess_State_Disowned
254 255 256 257 258 259 260 261 262
};

/**
 * When GetState returns "Exception", this method returns a
 * platform-independent description of the exceptional behavior that
 * caused the child to terminate abnormally.  Possible exceptions are:
 *
 *  kwsysProcess_Exception_None      = No exceptional behavior occurred.
 *  kwsysProcess_Exception_Fault     = Child crashed with a memory fault.
263 264 265 266 267 268
 *  kwsysProcess_Exception_Illegal   = Child crashed with an illegal
 * instruction.
 *  kwsysProcess_Exception_Interrupt = Child was interrupted by user
 * (Cntl-C/Break).
 *  kwsysProcess_Exception_Numerical = Child crashed with a numerical
 * exception.
269 270
 *  kwsysProcess_Exception_Other     = Child terminated for another reason.
 */
Brad King's avatar
Brad King committed
271
kwsysEXPORT int kwsysProcess_GetExitException(kwsysProcess* cp);
272
enum kwsysProcess_Exception_e
273 274 275 276 277 278 279 280
{
  kwsysProcess_Exception_None,
  kwsysProcess_Exception_Fault,
  kwsysProcess_Exception_Illegal,
  kwsysProcess_Exception_Interrupt,
  kwsysProcess_Exception_Numerical,
  kwsysProcess_Exception_Other
};
281

282 283 284 285 286 287 288 289 290
/**
 * When GetState returns "Exited" or "Exception", this method returns
 * the platform-specific raw exit code of the process.  UNIX platforms
 * should use WIFEXITED/WEXITSTATUS and WIFSIGNALED/WTERMSIG to access
 * this value.  Windows users should compare the value to the various
 * EXCEPTION_* values.
 *
 * If GetState returns "Exited", use GetExitValue to get the
 * platform-independent child return value.
291
 */
Brad King's avatar
Brad King committed
292
kwsysEXPORT int kwsysProcess_GetExitCode(kwsysProcess* cp);
293

294 295 296 297 298
/**
 * When GetState returns "Exited", this method returns the child's
 * platform-independent exit code (such as the value returned by the
 * child's main).
 */
Brad King's avatar
Brad King committed
299
kwsysEXPORT int kwsysProcess_GetExitValue(kwsysProcess* cp);
300 301 302 303

/**
 * When GetState returns "Error", this method returns a string
 * describing the problem.  Otherwise, it returns NULL.
304
 */
Brad King's avatar
Brad King committed
305
kwsysEXPORT const char* kwsysProcess_GetErrorString(kwsysProcess* cp);
306

307 308 309 310 311 312
/**
 * When GetState returns "Exception", this method returns a string
 * describing the problem.  Otherwise, it returns NULL.
 */
kwsysEXPORT const char* kwsysProcess_GetExceptionString(kwsysProcess* cp);

313
/**
314 315 316 317 318 319 320
 * Get the current state of the Process instance.  Possible states are:
 *
 *  kwsysProcess_StateByIndex_Starting  = Execute has not yet been called.
 *  kwsysProcess_StateByIndex_Exception = Child process exited abnormally.
 *  kwsysProcess_StateByIndex_Exited    = Child process exited normally.
 *  kwsysProcess_StateByIndex_Error     = Error getting the child return code.
 */
321 322 323 324 325 326 327 328 329 330
kwsysEXPORT int kwsysProcess_GetStateByIndex(kwsysProcess* cp, int idx);
enum kwsysProcess_StateByIndex_e
{
  kwsysProcess_StateByIndex_Starting = kwsysProcess_State_Starting,
  kwsysProcess_StateByIndex_Exception = kwsysProcess_State_Exception,
  kwsysProcess_StateByIndex_Exited = kwsysProcess_State_Exited,
  kwsysProcess_StateByIndex_Error = kwsysProcess_State_Error
};

/**
331 332 333 334 335 336 337 338 339 340 341 342 343 344
 * When GetState returns "Exception", this method returns a
 * platform-independent description of the exceptional behavior that
 * caused the child to terminate abnormally.  Possible exceptions are:
 *
 *  kwsysProcess_Exception_None      = No exceptional behavior occurred.
 *  kwsysProcess_Exception_Fault     = Child crashed with a memory fault.
 *  kwsysProcess_Exception_Illegal   = Child crashed with an illegal
 *                                     instruction.
 *  kwsysProcess_Exception_Interrupt = Child was interrupted by user
 *                                     (Cntl-C/Break).
 *  kwsysProcess_Exception_Numerical = Child crashed with a numerical
 *                                     exception.
 *  kwsysProcess_Exception_Other     = Child terminated for another reason.
 */
345 346 347 348
kwsysEXPORT int kwsysProcess_GetExitExceptionByIndex(kwsysProcess* cp,
                                                     int idx);

/**
349 350 351 352 353 354 355 356 357
 * When GetState returns "Exited" or "Exception", this method returns
 * the platform-specific raw exit code of the process.  UNIX platforms
 * should use WIFEXITED/WEXITSTATUS and WIFSIGNALED/WTERMSIG to access
 * this value.  Windows users should compare the value to the various
 * EXCEPTION_* values.
 *
 * If GetState returns "Exited", use GetExitValue to get the
 * platform-independent child return value.
 */
358 359 360
kwsysEXPORT int kwsysProcess_GetExitCodeByIndex(kwsysProcess* cp, int idx);

/**
361 362 363 364
 * When GetState returns "Exited", this method returns the child's
 * platform-independent exit code (such as the value returned by the
 * child's main).
 */
365 366 367
kwsysEXPORT int kwsysProcess_GetExitValueByIndex(kwsysProcess* cp, int idx);

/**
368 369 370
 * When GetState returns "Exception", this method returns a string
 * describing the problem.  Otherwise, it returns NULL.
 */
371 372 373
kwsysEXPORT const char* kwsysProcess_GetExceptionStringByIndex(
  kwsysProcess* cp, int idx);

374 375 376
/**
 * Start executing the child process.
 */
Brad King's avatar
Brad King committed
377
kwsysEXPORT void kwsysProcess_Execute(kwsysProcess* cp);
378

379 380 381 382 383 384 385 386 387
/**
 * Stop management of a detached child process.  This closes any pipes
 * being read.  If the child was not created with the
 * kwsysProcess_Option_Detach option, this method does nothing.  This
 * is because disowning a non-detached process will cause the child
 * exit signal to be left unhandled until this process exits.
 */
kwsysEXPORT void kwsysProcess_Disown(kwsysProcess* cp);

388
/**
389 390
 * Block until data are available on a pipe, a timeout expires, or the
 * child process terminates.  Arguments are as follows:
391 392 393 394 395 396 397 398 399
 *
 *  data    = If data are read, the pointer to which this points is
 *            set to point to the data.
 *  length  = If data are read, the integer to which this points is
 *            set to the length of the data read.
 *  timeout = Specifies the maximum time this call may block.  Upon
 *            return after reading data, the time elapsed is subtracted
 *            from the timeout value.  If this timeout expires, the
 *            value is set to 0.  A NULL pointer passed for this argument
400 401 402
 *            indicates no timeout for the call.  A negative or zero
 *            value passed for this argument may be used for polling
 *            and will always return immediately.
403 404 405
 *
 * Return value will be one of:
 *
Brad King's avatar
Brad King committed
406 407
 *   Pipe_None    = No more data will be available from the child process,
 *    ( == 0)       or no process has been executed.  WaitForExit should
408 409 410 411 412 413 414
 *                  be called to wait for the process to terminate.
 *   Pipe_STDOUT  = Data have been read from the child's stdout pipe.
 *   Pipe_STDERR  = Data have been read from the child's stderr pipe.
 *   Pipe_Timeout = No data available within timeout specified for the
 *                  call.  Time elapsed has been subtracted from timeout
 *                  argument.
 */
415 416
kwsysEXPORT int kwsysProcess_WaitForData(kwsysProcess* cp, char** data,
                                         int* length, double* timeout);
417
enum kwsysProcess_Pipes_e
418
{
Brad King's avatar
Brad King committed
419
  kwsysProcess_Pipe_None,
420
  kwsysProcess_Pipe_STDIN,
Brad King's avatar
Brad King committed
421 422
  kwsysProcess_Pipe_STDOUT,
  kwsysProcess_Pipe_STDERR,
423
  kwsysProcess_Pipe_Timeout = 255
424 425 426 427
};

/**
 * Block until the child process terminates or the given timeout
luz.paz's avatar
luz.paz committed
428
 * expires.  If no process is running, returns immediately.  The
429
 * argument is:
430
 *
431 432 433 434 435
 *  timeout = Specifies the maximum time this call may block.  Upon
 *            returning due to child termination, the elapsed time
 *            is subtracted from the given value.  A NULL pointer
 *            passed for this argument indicates no timeout for the
 *            call.
436
 *
437
 * Return value will be one of:
438
 *
439 440 441 442
 *    0 = Child did not terminate within timeout specified for
 *        the call.  Time elapsed has been subtracted from timeout
 *        argument.
 *    1 = Child has terminated or was not running.
443
 */
Brad King's avatar
Brad King committed
444
kwsysEXPORT int kwsysProcess_WaitForExit(kwsysProcess* cp, double* timeout);
445

446 447 448 449 450 451 452 453 454 455 456
/**
 * Interrupt the process group for the child process that is currently
 * running by sending it the appropriate operating-system specific signal.
 * The caller should call WaitForExit after this returns to wait for the
 * child to terminate.
 *
 * WARNING:  If you didn't specify kwsysProcess_Option_CreateProcessGroup,
 * you will interrupt your own process group.
 */
kwsysEXPORT void kwsysProcess_Interrupt(kwsysProcess* cp);

457 458 459 460
/**
 * Forcefully terminate the child process that is currently running.
 * The caller should call WaitForExit after this returns to wait for
 * the child to terminate.
461
 */
Brad King's avatar
Brad King committed
462
kwsysEXPORT void kwsysProcess_Kill(kwsysProcess* cp);
463

464 465 466 467 468 469 470
/**
 * Same as kwsysProcess_Kill using process ID to locate process to
 * terminate.
 * @see kwsysProcess_Kill(kwsysProcess* cp)
 */
kwsysEXPORT void kwsysProcess_KillPID(unsigned long);

471 472 473 474 475
/**
 * Reset the start time of the child process to the current time.
 */
kwsysEXPORT void kwsysProcess_ResetStartTime(kwsysProcess* cp);

476 477 478 479
#if defined(__cplusplus)
} /* extern "C" */
#endif

480
/* If we are building a kwsys .c or .cxx file, let it use these macros.
481
   Otherwise, undefine them to keep the namespace clean.  */
482
#if !defined(KWSYS_NAMESPACE)
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
#  undef kwsys_ns
#  undef kwsysEXPORT
#  if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
#    undef kwsysProcess
#    undef kwsysProcess_s
#    undef kwsysProcess_New
#    undef kwsysProcess_Delete
#    undef kwsysProcess_SetCommand
#    undef kwsysProcess_AddCommand
#    undef kwsysProcess_SetTimeout
#    undef kwsysProcess_SetWorkingDirectory
#    undef kwsysProcess_SetPipeFile
#    undef kwsysProcess_SetPipeNative
#    undef kwsysProcess_SetPipeShared
#    undef kwsysProcess_Option_Detach
#    undef kwsysProcess_Option_HideWindow
#    undef kwsysProcess_Option_MergeOutput
#    undef kwsysProcess_Option_Verbatim
#    undef kwsysProcess_Option_CreateProcessGroup
#    undef kwsysProcess_GetOption
#    undef kwsysProcess_SetOption
#    undef kwsysProcess_Option_e
#    undef kwsysProcess_State_Starting
#    undef kwsysProcess_State_Error
#    undef kwsysProcess_State_Exception
#    undef kwsysProcess_State_Executing
#    undef kwsysProcess_State_Exited
#    undef kwsysProcess_State_Expired
#    undef kwsysProcess_State_Killed
#    undef kwsysProcess_State_Disowned
#    undef kwsysProcess_GetState
#    undef kwsysProcess_State_e
#    undef kwsysProcess_Exception_None
#    undef kwsysProcess_Exception_Fault
#    undef kwsysProcess_Exception_Illegal
#    undef kwsysProcess_Exception_Interrupt
#    undef kwsysProcess_Exception_Numerical
#    undef kwsysProcess_Exception_Other
#    undef kwsysProcess_GetExitException
#    undef kwsysProcess_Exception_e
#    undef kwsysProcess_GetExitCode
#    undef kwsysProcess_GetExitValue
#    undef kwsysProcess_GetErrorString
#    undef kwsysProcess_GetExceptionString
#    undef kwsysProcess_Execute
#    undef kwsysProcess_Disown
#    undef kwsysProcess_WaitForData
#    undef kwsysProcess_Pipes_e
#    undef kwsysProcess_Pipe_None
#    undef kwsysProcess_Pipe_STDIN
#    undef kwsysProcess_Pipe_STDOUT
#    undef kwsysProcess_Pipe_STDERR
#    undef kwsysProcess_Pipe_Timeout
#    undef kwsysProcess_Pipe_Handle
#    undef kwsysProcess_WaitForExit
#    undef kwsysProcess_Interrupt
#    undef kwsysProcess_Kill
#    undef kwsysProcess_ResetStartTime
#  endif
542 543 544
#endif

#endif