← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/System/Program.h

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/include/llvm/System/Program.h
1
 
//===- llvm/System/Program.h ------------------------------------*- C++ -*-===//
2
 
//
3
 
//                     The LLVM Compiler Infrastructure
4
 
//
5
 
// This file is distributed under the University of Illinois Open Source
6
 
// License. See LICENSE.TXT for details.
7
 
//
8
 
//===----------------------------------------------------------------------===//
9
 
//
10
 
// This file declares the llvm::sys::Program class.
11
 
//
12
 
//===----------------------------------------------------------------------===//
13
 
 
14
 
#ifndef LLVM_SYSTEM_PROGRAM_H
15
 
#define LLVM_SYSTEM_PROGRAM_H
16
 
 
17
 
#include "llvm/System/Path.h"
18
 
 
19
 
namespace llvm {
20
 
namespace sys {
21
 
 
22
 
  // TODO: Add operations to communicate with the process, redirect its I/O,
23
 
  // etc.
24
 
 
25
 
  /// This class provides an abstraction for programs that are executable by the
26
 
  /// operating system. It provides a platform generic way to find executable
27
 
  /// programs from the path and to execute them in various ways. The sys::Path
28
 
  /// class is used to specify the location of the Program.
29
 
  /// @since 1.4
30
 
  /// @brief An abstraction for finding and executing programs.
31
 
  class Program {
32
 
    /// Opaque handle for target specific data.
33
 
    void *Data_;
34
 
 
35
 
    // Noncopyable.
36
 
    Program(const Program& other);
37
 
    Program& operator=(const Program& other);
38
 
 
39
 
    /// @name Methods
40
 
    /// @{
41
 
  public:
42
 
 
43
 
    Program();
44
 
    ~Program();
45
 
 
46
 
    /// Return process ID of this program.
47
 
    unsigned GetPid() const;
48
 
 
49
 
    /// This function executes the program using the \p arguments provided.  The
50
 
    /// invoked program will inherit the stdin, stdout, and stderr file
51
 
    /// descriptors, the environment and other configuration settings of the
52
 
    /// invoking program. If Path::executable() does not return true when this
53
 
    /// function is called then a std::string is thrown.
54
 
    /// @returns false in case of error, true otherwise.
55
 
    /// @see FindProgramByName
56
 
    /// @brief Executes the program with the given set of \p args.
57
 
    bool Execute
58
 
    ( const Path& path,  ///< sys::Path object providing the path of the
59
 
      ///< program to be executed. It is presumed this is the result of
60
 
      ///< the FindProgramByName method.
61
 
      const char** args, ///< A vector of strings that are passed to the
62
 
      ///< program.  The first element should be the name of the program.
63
 
      ///< The list *must* be terminated by a null char* entry.
64
 
      const char ** env = 0, ///< An optional vector of strings to use for
65
 
      ///< the program's environment. If not provided, the current program's
66
 
      ///< environment will be used.
67
 
      const sys::Path** redirects = 0, ///< An optional array of pointers to
68
 
      ///< Paths. If the array is null, no redirection is done. The array
69
 
      ///< should have a size of at least three. If the pointer in the array
70
 
      ///< are not null, then the inferior process's stdin(0), stdout(1),
71
 
      ///< and stderr(2) will be redirected to the corresponding Paths.
72
 
      ///< When an empty Path is passed in, the corresponding file
73
 
      ///< descriptor will be disconnected (ie, /dev/null'd) in a portable
74
 
      ///< way.
75
 
      unsigned memoryLimit = 0, ///< If non-zero, this specifies max. amount
76
 
      ///< of memory can be allocated by process. If memory usage will be
77
 
      ///< higher limit, the child is killed and this call returns. If zero
78
 
      ///< - no memory limit.
79
 
      std::string* ErrMsg = 0 ///< If non-zero, provides a pointer to a string
80
 
      ///< instance in which error messages will be returned. If the string
81
 
      ///< is non-empty upon return an error occurred while invoking the
82
 
      ///< program.
83
 
      );
84
 
 
85
 
    /// This function waits for the program to exit. This function will block
86
 
    /// the current program until the invoked program exits.
87
 
    /// @returns an integer result code indicating the status of the program.
88
 
    /// A zero or positive value indicates the result code of the program. A
89
 
    /// negative value is the signal number on which it terminated.
90
 
    /// @see Execute
91
 
    /// @brief Waits for the program to exit.
92
 
    int Wait
93
 
    ( unsigned secondsToWait = 0, ///< If non-zero, this specifies the amount
94
 
      ///< of time to wait for the child process to exit. If the time
95
 
      ///< expires, the child is killed and this call returns. If zero,
96
 
      ///< this function will wait until the child finishes or forever if
97
 
      ///< it doesn't.
98
 
      std::string* ErrMsg = 0 ///< If non-zero, provides a pointer to a string
99
 
      ///< instance in which error messages will be returned. If the string
100
 
      ///< is non-empty upon return an error occurred while waiting.
101
 
      );
102
 
 
103
 
    /// This function terminates the program.
104
 
    /// @returns true if an error occured.
105
 
    /// @see Execute
106
 
    /// @brief Terminates the program.
107
 
    bool Kill
108
 
    ( std::string* ErrMsg = 0 ///< If non-zero, provides a pointer to a string
109
 
      ///< instance in which error messages will be returned. If the string
110
 
      ///< is non-empty upon return an error occurred while killing the
111
 
      ///< program.
112
 
      );
113
 
 
114
 
    /// This static constructor (factory) will attempt to locate a program in
115
 
    /// the operating system's file system using some pre-determined set of
116
 
    /// locations to search (e.g. the PATH on Unix).
117
 
    /// @returns A Path object initialized to the path of the program or a
118
 
    /// Path object that is empty (invalid) if the program could not be found.
119
 
    /// @brief Construct a Program by finding it by name.
120
 
    static Path FindProgramByName(const std::string& name);
121
 
 
122
 
    // These methods change the specified standard stream (stdin,
123
 
    // stdout, or stderr) to binary mode. They return true if an error
124
 
    // occurred
125
 
    static bool ChangeStdinToBinary();
126
 
    static bool ChangeStdoutToBinary();
127
 
    static bool ChangeStderrToBinary();
128
 
 
129
 
    /// A convenience function equivalent to Program prg; prg.Execute(..);
130
 
    /// prg.Wait(..);
131
 
    /// @see Execute, Wait
132
 
    static int ExecuteAndWait(const Path& path,
133
 
                              const char** args,
134
 
                              const char ** env = 0,
135
 
                              const sys::Path** redirects = 0,
136
 
                              unsigned secondsToWait = 0,
137
 
                              unsigned memoryLimit = 0,
138
 
                              std::string* ErrMsg = 0);
139
 
 
140
 
    /// A convenience function equivalent to Program prg; prg.Execute(..);
141
 
    /// @see Execute
142
 
    static void ExecuteNoWait(const Path& path,
143
 
                              const char** args,
144
 
                              const char ** env = 0,
145
 
                              const sys::Path** redirects = 0,
146
 
                              unsigned memoryLimit = 0,
147
 
                              std::string* ErrMsg = 0);
148
 
 
149
 
    /// @}
150
 
 
151
 
  };
152
 
}
153
 
}
154
 
 
155
 
#endif