library: libCore #include "TSystem.h"

# TSystem

class description - source file - inheritance tree (.pdf)

## class TSystem : public TNamed

| Inheritance Chart:
`TObject`
| <- | `TNamed`
| <- | `TSystem` |
<- |
`TDCacheSystem` |
`TNetSystem` |
`TRFIOSystem` |
`TUnixSystem` |

        protected:

               virtual Bool_t ConsistentWith(const char* path, void* dirptr = 0)
          virtual const char* ExpandFileName(const char* fname) const
                     TSystem* FindHelper(const char* path, void* dirptr = 0)
          virtual const char* GetLinkedLibraries() const
                 virtual void SigAlarmInterruptsSyscalls(Bool_t)

        public:

                                      TSystem(const char* name = "Generic", const char* title = "Generic System")
                                      TSystem(const TSystem&)
                              virtual ~TSystem()
                         virtual void Abort(int code = 0)
                          virtual int AcceptConnection(int sock)
                       virtual Bool_t AccessPathName(const char* path, EAccessMode mode = kFileExists)
                         virtual void AddFileHandler(TFileHandler* fh)
                         virtual void AddIncludePath(const char* includePath)
                         virtual void AddLinkedLibs(const char* linkedLib)
                         virtual void AddSignalHandler(TSignalHandler* sh)
                         virtual void AddTimer(TTimer* t)
                          virtual int AnnounceTcpService(int port, Bool_t reuse, int backlog, int tcpwindowsize = -1)
                          virtual int AnnounceUnixService(int port, int backlog)
                  virtual const char* BaseName(const char* pathname) const
                               Bool_t cd(const char* path)
                       virtual Bool_t ChangeDirectory(const char* path)
                          virtual int Chmod(const char* file, UInt_t mode)
                       static TClass* Class()
                         virtual void CleanCompiledMacros()
                         virtual void CloseConnection(int sock, Bool_t force = kFALSE)
                         virtual void Closelog()
                          virtual int ClosePipe(FILE* pipe)
                          virtual int CompileMacro(const char* filename, Option_t* opt = "", const char* library_name = "", const char* build_dir = "")
                        virtual char* ConcatFileName(const char* dir, const char* name)
                          virtual int CopyFile(const char* from, const char* to, Bool_t overwrite = kFALSE)
                  virtual const char* DirName(const char* pathname) const
                         virtual void DispatchOneEvent(Bool_t pendingOnly = kFALSE)
                        virtual char* DynamicPathName(const char* lib, Bool_t quiet = kFALSE)
                       virtual Func_t DynFindSymbol(const char* module, const char* entry)
                        virtual Int_t Exec(const char* shellcmd)
                         virtual void Exit(int code, Bool_t mode = kTRUE)
                         virtual void ExitLoop()
                       virtual Bool_t ExpandPathName(TString& path)
                        virtual char* ExpandPathName(const char* path)
                         virtual void FreeDirectory(void* dirp)
          virtual TSystem::EAclicMode GetAclicMode() const
                  virtual const char* GetBuildArch() const
                  virtual const char* GetBuildDir() const
                  virtual const char* GetBuildNode() const
                  virtual const char* GetDirEntry(void* dirp) const
                        virtual void* GetDirPtr() const
                  virtual const char* GetDynamicPath() const
                        virtual Int_t GetEffectiveGid()
                        virtual Int_t GetEffectiveUid()
                  virtual const char* Getenv(const char* env) const
                         static Int_t GetErrno()
                  virtual const char* GetError() const
                          const char* GetErrorStr() const
                  virtual const char* GetFlagsDebug() const
                  virtual const char* GetFlagsOpt() const
                        virtual Int_t GetFPEMask()
                          virtual int GetFsInfo(const char* path, Long_t* id, Long_t* bsize, Long_t* blocks, Long_t* bfree)
                        virtual Int_t GetGid(const char* group = "0")
                 virtual UserGroup_t* GetGroupInfo(Int_t gid)
                 virtual UserGroup_t* GetGroupInfo(const char* group = "0")
                 virtual TInetAddress GetHostByName(const char* server)
                  virtual const char* GetIncludePath() const
                  virtual const char* GetLibraries(const char* regexp = "", const char* option = "", Bool_t isRegexp = kTRUE) const
                  virtual const char* GetLinkdefSuffix() const
                  virtual const char* GetLinkedLibs() const
              virtual TSeqCollection* GetListOfFileHandlers() const
                  virtual const char* GetMakeExe() const
                  virtual const char* GetMakeSharedLib() const
                  virtual const char* GetObjExt() const
                                  int GetPathInfo(const char* path, Long_t* id, Long_t* size, Long_t* flags, Long_t* modtime)
                                  int GetPathInfo(const char* path, Long_t* id, Long64_t* size, Long_t* flags, Long_t* modtime)
                          virtual int GetPathInfo(const char* path, FileStat_t& buf)
                 virtual TInetAddress GetPeerName(int sock)
                          virtual int GetPid()
                          virtual int GetServiceByName(const char* service)
                        virtual char* GetServiceByPort(int port)
                 virtual TInetAddress GetSockName(int sock)
                          virtual int GetSockOpt(int sock, int kind, int* val)
                  virtual const char* GetSoExt() const
                        virtual Int_t GetUid(const char* user = "0")
                 virtual UserGroup_t* GetUserInfo(Int_t uid)
                 virtual UserGroup_t* GetUserInfo(const char* user = "0")
                  virtual const char* HomeDirectory(const char* userName = "0") const
                  virtual const char* HostName() const
                         virtual void IgnoreInterrupt(Bool_t ignore = kTRUE)
                         virtual void IgnoreSignal(ESignals sig, Bool_t ignore = kTRUE)
                               Bool_t InControl() const
                       virtual Bool_t Init()
                         virtual void InnerLoop()
                      virtual TClass* IsA() const
                       virtual Bool_t IsAbsoluteFileName(const char* dir)
                       virtual Bool_t IsFileInIncludePath(const char* name)
                          virtual int Link(const char* from, const char* to)
                         virtual void ListLibraries(const char* regexp = "")
                         virtual void ListSymbols(const char* module, const char* re = "")
                          virtual int Load(const char* module, const char* entry = "", Bool_t system = kFALSE)
                          virtual int MakeDirectory(const char* name)
                          virtual int mkdir(const char* name, Bool_t recursive = kFALSE)
                       virtual Long_t NextTimeOut(Bool_t mode)
                        virtual TTime Now()
                          virtual int OpenConnection(const char* server, int port, int tcpwindowsize = -1)
                        virtual void* OpenDirectory(const char* name)
                         virtual void Openlog(const char* name, Int_t options, ELogFacility facility)
                        virtual FILE* OpenPipe(const char* command, const char* mode)
                             TSystem& operator=(const TSystem&)
                       virtual Bool_t ProcessEvents()
                          const char* pwd() const
                          virtual int RecvBuf(int sock, void* buffer, int length)
                          virtual int RecvRaw(int sock, void* buffer, int length, int flag)
                virtual TFileHandler* RemoveFileHandler(TFileHandler* fh)
                                 void RemoveOnExit(TObject* obj)
              virtual TSignalHandler* RemoveSignalHandler(TSignalHandler* sh)
                      virtual TTimer* RemoveTimer(TTimer* t)
                          virtual int Rename(const char* from, const char* to)
                          static void ResetErrno()
                         virtual void ResetSignal(ESignals sig, Bool_t reset = kTRUE)
                         virtual void ResetTimer(TTimer*)
                         virtual void Run()
                        virtual Int_t Select(TList* active, Long_t timeout)
                        virtual Int_t Select(TFileHandler* fh, Long_t timeout)
                          virtual int SendBuf(int sock, const void* buffer, int length)
                          virtual int SendRaw(int sock, const void* buffer, int length, int flag)
                         virtual void SetAclicMode(TSystem::EAclicMode mode)
                         virtual void SetBuildDir(const char*)
                         virtual void SetDisplay()
                         virtual void SetDynamicPath(const char* pathname)
                         virtual void Setenv(const char* name, const char* value)
                                 void SetErrorStr(const char* errstr)
                         virtual void SetFlagsDebug(const char*)
                         virtual void SetFlagsOpt(const char*)
                        virtual Int_t SetFPEMask(Int_t mask = kDefaultMask)
                         virtual void SetIncludePath(const char* includePath)
                         virtual void SetLinkdefSuffix(const char* suffix)
                         virtual void SetLinkedLibs(const char* linkedLibs)
                         virtual void SetMakeExe(const char* directives)
                         virtual void SetMakeSharedLib(const char* directives)
                         virtual void SetObjExt(const char* objExt)
                         virtual void SetProgname(const char* name)
                          virtual int SetSockOpt(int sock, int kind, int val)
                         virtual void SetSoExt(const char* soExt)
                         virtual void ShowMembers(TMemberInspector& insp, char* parent)
                         virtual void Sleep(UInt_t milliSec)
                      virtual TString SplitAclicMode(const char* filename, TString& mode, TString& args, TString& io) const
                         virtual void StackTrace()
                         virtual void Streamer(TBuffer& b)
                                 void StreamerNVirtual(TBuffer& b)
                          virtual int Symlink(const char* from, const char* to)
                         virtual void Syslog(ELogLevel level, const char* mess)
                  virtual const char* TempDirectory() const
                        virtual FILE* TempFileName(TString& base, const char* dir = "0")
                          virtual int Umask(Int_t mask)
                  virtual const char* UnixPathName(const char* unixpathname) const
                          virtual int Unlink(const char* name)
                         virtual void Unload(const char* module)
                         virtual void Unsetenv(const char* name)
                          virtual int Utime(const char* file, Long_t modtime, Long_t actime)
                        virtual char* Which(const char* search, const char* file, EAccessMode mode = kFileExists)
                  virtual const char* WorkingDirectory() const

### Data Members

        protected:

                      TFdSet* fReadmask         !Files that should be checked for read events
                      TFdSet* fWritemask        !Files that should be checked for write events
                      TFdSet* fReadready        !Files with reads waiting
                      TFdSet* fWriteready       !Files with writes waiting
                      TFdSet* fSignals          !Signals that were trapped
                        Int_t fNfd              Number of fd's in masks
                        Int_t fMaxrfd           Largest fd in read mask
                        Int_t fMaxwfd           Largest fd in write mask
                        Int_t fSigcnt           Number of pending signals
                      TString fWdpath           Working directory
                      TString fHostname         Hostname
                       Bool_t fInsideNotify     Used by DispatchTimers()
                       Bool_t fInControl        True if in eventloop
                       Bool_t fDone             True if eventloop should be finished
                        Int_t fLevel            Level of nested eventloops
                      TString fLastErrorString  Last system error message
              TSeqCollection* fTimers           List of timers
              TSeqCollection* fSignalHandler    List of signal handlers
              TSeqCollection* fFileHandler      List of file handlers
              TSeqCollection* fOnExitList       List of items to be cleaned-up on exit
                      TString fListLibs         List shared libraries, cache used by GetLibraries
                      TString fBuildArch        Architecure for which ROOT was built (passed to ./configure)
                      TString fBuildNode        Detailed information where ROOT was built
                      TString fBuildDir         Location where to build ACLiC shared library and use as scratch area.
                      TString fFlagsDebug       Flags for debug compilation
                      TString fFlagsOpt         Flags for optimized compilation
                      TString fListPaths        List of all include (fIncludePath + interpreter include path). Cache used by GetIncludePath
                      TString fIncludePath      Used to expand $IncludePath in the directives given to SetMakeSharedLib and SetMakeExe
                      TString fLinkedLibs       Used to expand $LinkedLibs in the directives given to SetMakeSharedLib and SetMakeExe
                      TString fSoExt            Extension of shared library (.so, .sl, .a, .dll, etc.)
                      TString fObjExt           Extension of object files (.o, .obj, etc.)
          TSystem::EAclicMode fAclicMode        Whether the compilation should be done debug or opt
                      TString fMakeSharedLib    Directive used to build a shared library
                      TString fMakeExe          Directive used to build an executable
                      TString fLinkdefSuffix    Default suffix for linkdef files to be used by ACLiC
              TSeqCollection* fCompiled         List of shared libs from compiled macros to be deleted
              TSeqCollection* fHelpers          List of helper classes for alternative file/directory access

        public:

          static const TSystem::EAclicMode kDefault
          static const TSystem::EAclicMode kDebug
          static const TSystem::EAclicMode kOpt

## Class Description

     TSystem

     Abstract base class defining a generic interface to the underlying
     Operating System.
     This is not an ABC in the strict sense of the (C++) word. For
     every member function their is an implementation (often not more
     than a call to AbstractMethod() which prints a warning saying
     that the method should be overridden in a derived class), which
     allows a simple partial implementation for new OS'es.

TSystem(const char *name, const char *title) : TNamed(name, title)

     Create a new OS interface.

~TSystem()

     Delete the OS interface.

Bool_t Init()

     Initialize the OS interface.

void SetProgname(const char *name)

     Set the application name (from command line, argv[0]) and copy it in
     gProgName.

void SetDisplay()

     Set DISPLAY environment variable based on utmp entry. Only for UNIX.

void SetErrorStr(const char *errstr)

     Set the system error string. This string will be used by GetError().
     To be used in case one does not want or can use the system error
     string (e.g. because error is generated by a third party POSIX like
     library that does not use standard errno).

const char* GetError()

     Return system error string.

Int_t GetErrno()

     Static function returning system error number.

void ResetErrno()

     Static function resetting system error number.

void RemoveOnExit(TObject *obj)

     Objects that should be deleted on exit of the OS interface.

const char* HostName()

     Return the system's host name.

void Run()

     System event loop.

void ExitLoop()

     Exit from event loop.

void InnerLoop()

     Inner event loop.

Bool_t ProcessEvents()

     Process pending events (GUI, timers, sockets). Returns the result of
     TROOT::IsInterrupted(). The interrupt flag (TROOT::SetInterrupt())
     can be set during the handling of the events. This mechanism allows
     macros running in tight calculating loops to be interrupted by some
     GUI event (depending on the interval with which this method is
     called). For example hitting ctrl-c in a canvas will set the
     interrupt flag.

void DispatchOneEvent(Bool_t)

     Dispatch a single event.

void Sleep(UInt_t)

     Sleep milliSec milli seconds.

Int_t Select(TList *, Long_t)

     Select on active file descriptors (called by TMonitor).

Int_t Select(TFileHandler *, Long_t)

     Select on active file descriptors (called by TMonitor).

TTime Now()

     Return current time.

void AddTimer(TTimer *ti)

     Add timer to list of system timers.

TTimer* RemoveTimer(TTimer *ti)

     Remove timer from list of system timers. Returns removed timer or 0
     if timer was not active.

Long_t NextTimeOut(Bool_t mode)

     Time when next timer of mode (synchronous=kTRUE or
     asynchronous=kFALSE) will time-out (in ms).

void AddSignalHandler(TSignalHandler *h)

     Add a signal handler to list of system signal handlers. Only adds
     the handler if it is not already in the list of signal handlers.

TSignalHandler* RemoveSignalHandler(TSignalHandler *h)

     Remove a signal handler from list of signal handlers. Returns
     the handler or 0 if the handler was not in the list of signal handlers.

void AddFileHandler(TFileHandler *h)

     Add a file handler to the list of system file handlers. Only adds
     the handler if it is not already in the list of file handlers.

TFileHandler* RemoveFileHandler(TFileHandler *h)

     Remove a file handler from the list of file handlers. Returns
     the handler or 0 if the handler was not in the list of file handlers.

void ResetSignal(ESignals /*sig*/, Bool_t /*reset*/)

     If reset is true reset the signal handler for the specified signal
     to the default handler, else restore previous behaviour.

void IgnoreSignal(ESignals /*sig*/, Bool_t /*ignore*/)

     If ignore is true ignore the specified signal, else restore previous
     behaviour.

void IgnoreInterrupt(Bool_t ignore)

     If ignore is true ignore the interrupt signal, else restore previous
     behaviour. Typically call ignore interrupt before writing to disk.

Int_t GetFPEMask()

     Return the bitmap of conditions that trigger a floating point exception.

Int_t SetFPEMask(Int_t)

     Set which conditions trigger a floating point exception.
     Return the previous set of conditions.

int Exec(const char*)

     Execute a command.

FILE* OpenPipe(const char*, const char*)

     Open a pipe.

int ClosePipe(FILE*)

     Close the pipe.

int GetPid()

     Get process id.

void Exit(int, Bool_t)

     Exit the application.

void Abort(int)

     Abort the application.

void StackTrace()

     Print a stack trace.

TSystem* FindHelper(const char *path, void *dirptr)

     Create helper TSystem to handle file and directory operations that
     might be special for remote file access, like via rfiod or rootd.

Bool_t ConsistentWith(const char *path, void *dirptr)

     Check consistency of this helper with the one required
     by 'path' or 'dirptr'

int MakeDirectory(const char*)

     Make a directory. Returns 0 in case of success and
     -1 if the directory could not be created (either already exists or
     illegal path name).

void* OpenDirectory(const char*)

     Open a directory. Returns 0 if directory does not exist.

void FreeDirectory(void*)

     Free a directory.

const char* GetDirEntry(void*)

     Get a directory entry. Returns 0 if no more entries.

Bool_t ChangeDirectory(const char*)

     Change directory.

const char* WorkingDirectory()

     Return working directory.

const char* HomeDirectory(const char*)

     Return the user's home directory.

int mkdir(const char *name, Bool_t recursive)

     Make a file system directory. Returns 0 in case of success and
     -1 if the directory could not be created (either already exists or
     illegal path name).
     If 'recursive' is true, makes parent directories as needed.

const char* BaseName(const char *name)

     Base name of a file name. Base name of /user/root is root.

Bool_t IsAbsoluteFileName(const char *dir)

     Return true if dir is an absolute pathname.

Bool_t IsFileInIncludePath(const char *name)

     Return true if 'name' is a file that can be found in the ROOT include
     path or the current directory.
     If 'name' contains any ACLiC style information (e.g. trailing +[+][g|O]),
     it will be striped off 'name'.

const char* DirName(const char *pathname)

     Return the directory name in pathname. DirName of /user/root is /user.

const char* UnixPathName(const char *name)

     Convert from a Unix pathname to a local pathname. E.g. from /user/root to \user\root.

char* ConcatFileName(const char *, const char *)

     Concatenate a directory and a file name.

const char* ExpandFileName(const char *fname)

     Expand a pathname getting rid of special shell characters like ~.$, etc.
     For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
     environment variables in a pathname. If compatibility is not an issue
     you can use on Unix directly $XXX. This is a protected function called
     from the OS specific system classes, like TUnixSystem and TWinNTSystem.

Bool_t ExpandPathName(TString&)

     Expand a pathname getting rid of special shell characaters like ~.$, etc.
     For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
     environment variables in a pathname. If compatibility is not an issue
     you can use on Unix directly $XXX.

char* ExpandPathName(const char *)

     Expand a pathname getting rid of special shell characaters like ~.$, etc.
     For Unix/Win32 compatibility use $(XXX) instead of $XXX when using
     environment variables in a pathname. If compatibility is not an issue
     you can use on Unix directly $XXX. The user must delete returned string.

Bool_t AccessPathName(const char *, EAccessMode)

     Returns FALSE if one can access a file using the specified access mode.
     The file name must not contain any special shell characters line ~ or $,
     in those cases first call ExpandPathName().
     Attention, bizarre convention of return value!!

int CopyFile(const char *, const char *, Bool_t)

     Copy a file. If overwrite is true and file already exists the
     file will be overwritten. Returns 0 when successful, -1 in case
     of failure, -2 in case the file already exists and overwrite was false.

int Rename(const char *, const char *)

     Rename a file.

int Link(const char *, const char *)

     Create a link from file1 to file2.

int Symlink(const char *, const char *)

     Create a symbolic link from file1 to file2.

int Unlink(const char *)

     Unlink, i.e. remove, a file.

int GetPathInfo(const char *path, Long_t *id, Long_t *size, Long_t *flags, Long_t *modtime)

     Get info about a file: id, size, flags, modification time.
     Id      is (statbuf.st_dev << 24) + statbuf.st_ino
     Size    is the file size
     Flags   is file type: 0 is regular file, bit 0 set executable,
                           bit 1 set directory, bit 2 set special file
                           (socket, fifo, pipe, etc.)
     Modtime is modification time.
     The function returns 0 in case of success and 1 if the file could
     not be stat'ed.

int GetPathInfo(const char *path, Long_t *id, Long64_t *size, Long_t *flags, Long_t *modtime)

     Get info about a file: id, size, flags, modification time.
     Id      is (statbuf.st_dev << 24) + statbuf.st_ino
     Size    is the file size
     Flags   is file type: 0 is regular file, bit 0 set executable,
                           bit 1 set directory, bit 2 set special file
                           (socket, fifo, pipe, etc.)
     Modtime is modification time.
     The function returns 0 in case of success and 1 if the file could
     not be stat'ed.

int GetPathInfo(const char *, FileStat_t &)

     Get info about a file. Info is returned in the form of a FileStat_t
     structure (see TSystem.h).
     The function returns 0 in case of success and 1 if the file could
     not be stat'ed.

int GetFsInfo(const char *, Long_t *, Long_t *, Long_t *, Long_t *)

     Get info about a file system: fs type, block size, number of blocks,
     number of free blocks.

const char* TempDirectory() const

     Return a user configured or systemwide directory to create
     temporary files in.

FILE* TempFileName(TString &, const char *)

     Create a secure temporary file by appending a unique
     6 letter string to base. The file will be created in
     a standard (system) directory or in the directory
     provided in dir. The full filename is returned in base
     and a filepointer is returned for safely writing to the file
     (this avoids certain security problems). Returns 0 in case
     of error.

int Chmod(const char *, UInt_t)

     Set the file permission bits. Returns -1 in case or error, 0 otherwise.

int Umask(Int_t)

     Set the process file creation mode mask.

int Utime(const char *, Long_t, Long_t)

     Set the a files modification and access times. If actime = 0 it will be
     set to the modtime. Returns 0 on success and -1 in case of error.

char* Which(const char *, const char *, EAccessMode)

     Find location of file in a search path. User must delete returned string.
     Returns 0 in case file is not found.

Int_t GetUid(const char * /*user*/)

     Returns the user's id. If user = 0, returns current user's id.

Int_t GetEffectiveUid()

     Returns the effective user id. The effective id corresponds to the
     set id bit on the file being executed.

Int_t GetGid(const char * /*group*/)

     Returns the group's id. If group = 0, returns current user's group.

Int_t GetEffectiveGid()

     Returns the effective group id. The effective group id corresponds
     to the set id bit on the file being executed.

UserGroup_t* GetUserInfo(Int_t /*uid*/)

     Returns all user info in the UserGroup_t structure. The returned
     structure must be deleted by the user. In case of error 0 is returned.

UserGroup_t* GetUserInfo(const char * /*user*/)

     Returns all user info in the UserGroup_t structure. If user = 0, returns
     current user's id info. The returned structure must be deleted by the
     user. In case of error 0 is returned.

UserGroup_t* GetGroupInfo(Int_t /*gid*/)

     Returns all group info in the UserGroup_t structure. The only active
     fields in the UserGroup_t structure for this call are:
        fGid and fGroup
     The returned structure must be deleted by the user. In case of
     error 0 is returned.

UserGroup_t* GetGroupInfo(const char * /*group*/)

     Returns all group info in the UserGroup_t structure. The only active
     fields in the UserGroup_t structure for this call are:
        fGid and fGroup
     If group = 0, returns current user's group. The returned structure
     must be deleted by the user. In case of error 0 is returned.

void Setenv(const char*, const char*)

     Set environment variable.

void Unsetenv(const char *name)

     Unset environment variable.

const char* Getenv(const char*)

     Get environment variable.

void Openlog(const char *, Int_t, ELogFacility)

     Open connection to system log daemon. For the use of the options and
     facility see the Unix openlog man page.

void Syslog(ELogLevel, const char *)

     Send mess to syslog daemon. Level is the logging level and mess the
     message that will be written on the log.

void Closelog()

     Close connection to system log daemon.

const char* GetDynamicPath()

     Return the dynamic path (used to find shared libraries).

void SetDynamicPath(const char *)

     Set the dynamic path to a new value.
     If the value of 'path' is zero, the dynamic path is reset to its
     default value.

int Load(const char *module, const char *entry, Bool_t system)

     Load a shared library. Returns 0 on successful loading, 1 in
     case lib was already loaded and -1 in case lib does not exist
     or in case of error. When entry is specified the loaded lib is
     search for this entry point (return -1 when entry does not exist,
     0 otherwise). When the system flag is kTRUE, the library is consisdered
     a permanent systen library that should not be unloaded during the
     course of the session.

char* DynamicPathName(const char *, Bool_t)

Func_t DynFindSymbol(const char * /*lib*/, const char *entry)

     Find specific entry point in specified library. Specify "*" for lib
     to search in all libraries.

void Unload(const char *module)

     Unload a shared library.

void ListSymbols(const char *, const char *)

     List symbols in a shared library.

void ListLibraries(const char *regexp)

     List all loaded shared libraries.

const char* GetLinkedLibraries()

     Get list of shared libraries loaded at the start of the executable.
     Returns 0 in case list cannot be obtained or in case of error.

const char* GetLibraries(const char *regexp, const char *options, Bool_t isRegexp)

     Return a space separated list of loaded shared libraries.
     This list is of a format suitable for a linker, i.e it may contain
     -Lpathname and/or -lNameOfLib.
     Option can be any of:
       S: shared libraries loaded at the start of the executable, because
          they were specified on the link line.
       D: shared libraries dynamically loaded after the start of the program.
     For MacOS only:
       L: list the .dylib rather than the .so (this is intended for linking)
          [This options is not the default]

TInetAddress GetHostByName(const char *)

     Get Internet Protocol (IP) address of host.

TInetAddress GetPeerName(int)

     Get Internet Protocol (IP) address of remote host and port #.

TInetAddress GetSockName(int)

     Get Internet Protocol (IP) address of host and port #.

int GetServiceByName(const char *)

     Get port # of internet service.

char* GetServiceByPort(int)

     Get name of internet service.

int OpenConnection(const char*, int, int)

     Open a connection to another host.

int AnnounceTcpService(int, Bool_t, int, int)

     Announce TCP/IP service.

int AnnounceUnixService(int, int)

     Announce unix domain service.

int AcceptConnection(int)

     Accept a connection.

void CloseConnection(int, Bool_t)

     Close socket connection.

int RecvRaw(int, void *, int, int)

     Receive exactly length bytes into buffer. Use opt to receive out-of-band
     data or to have a peek at what is in the buffer (see TSocket).

int SendRaw(int, const void *, int, int)

     Send exactly length bytes from buffer. Use opt to send out-of-band
     data (see TSocket).

int RecvBuf(int, void *, int)

     Receive a buffer headed by a length indicator.

int SendBuf(int, const void *, int)

     Send a buffer headed by a length indicator.

int SetSockOpt(int, int, int)

     Set socket option.

int GetSockOpt(int, int, int*)

     Get socket option.

int CompileMacro(const char *filename, Option_t * opt, const char *library_specified, const char *build_dir)

     This method compiles and loads a shared library containing
     the code from the file "filename".

     The possible options are:
         k : keep the shared library after the session end.
         f : force recompilation.
         g : compile with debug symbol
         O : optimized the code (ignore if 'g' is specified)
         c : compile only, do not attempt to the load the library.

     If library_specified is specified, CompileMacro generates the file
     "library_specified".soext where soext is the shared library extension for
     the current platform.

     If build_dir is specified, it is used as an alternative 'root' for the
     generation of the shared library.  The library is stored in a sub-directories
     of 'build_dir' including the full pathname of the script.  See also
     TSystem::SetBuildDir.

     If library_specified is not specified, CompileMacro generate a default name
     for library by taking the name of the file "filename" but replacing the
     dot before the extension by an underscore and by adding the shared
     library extension for the current platform.
     For example on most platform, hsimple.cxx will generate hsimple_cxx.so

     It uses the directive fMakeSharedLibs to create a shared library.
     If loading the shared library fails, it tries to output a list of missing
     symbols by creating an executable (on some platforms like OSF, this does
     not HAVE to be an executable) containing the script. It uses the
     directive fMakeExe to do so.
     For both directives, before passing them to TSystem::Exec, it expands the
     variables $SourceFiles, $SharedLib, $LibName, $IncludePath, $LinkedLibs,
     $ExeName and $ObjectFiles. See SetMakeSharedLib() for more information on
     those variables.

     This method is used to implement the following feature:

     Synopsis:

     The purpose of this addition is to allow the user to use an external
     compiler to create a shared library from its C++ macro (scripts).
     Currently in order to execute a script, a user has to type at the root
     prompt

      .X myfunc.C(arg1,arg2)

     We allow him to type:

      .X myfunc.C++(arg1,arg2)
     or
      .X myfunc.C+(arg1,arg2)

     In which case an external compiler will be called to create a shared
     library.  This shared library will then be loaded and the function
     myfunc will be called with the two arguments.  With '++' the shared library
     is always recompiled.  With '+' the shared library is recompiled only
     if it does not exist yet or the macro file is newer than the shared
     library.

     Of course the + and ++ notation is supported in similar way for .x and .L.

     Through the function TSystem::SetMakeSharedLib(), the user will be able to
     indicate, with shell commands, how to build a shared library (a good
     default will be provided). The most common change, namely where to find
     header files, will be available through the function
     TSystem::SetIncludePath().
     A good default will be provided so that a typical user session should be at
     most:

     root[1] gSystem->SetIncludePath("-I$ROOTSYS/include
     -I$HOME/mypackage/include");
     root[2] .x myfunc.C++(10,20);

     The user may sometimes try to compile a script before it has loaded all the
     needed shared libraries.  In this case we want to be helpfull and output a
     list of the unresolved symbols. So if the loading of the created shared
     library fails, we will try to build a executable that contains the
     script. The linker should then output a list of missing symbols.

     To support this we provide a TSystem::SetMakeExe() function, that sets the
     directive telling how to create an executable. The loader will need
     to be informed of all the libraries available. The information about
     the libraries that has been loaded by .L and TSystem::Load() is accesible
     to the script compiler. However, the information about
     the libraries that have been selected at link time by the application
     builder (like the root libraries for root.exe) are not available and need
     to be explictly listed in fLinkedLibs (either by default or by a call to
     TSystem::SetLinkedLibs()).

     To simplify customization we could also add to the .rootrc support for the
     variables

     Unix.*.Root.IncludePath:     -I$ROOTSYS/include
     WinNT.*.Root.IncludePath:    -I%ROOTSYS%/include

     Unix.*.Root.LinkedLibs:      -L$ROOTSYS/lib -lBase ....
     WinNT.*.Root.LinkedLibs:     %ROOTSYS%/lib/*.lib msvcrt.lib ....

     And also support for MakeSharedLibs() and MakeExe().

     (the ... have to be replaced by the actual values and are here only to
     shorten this comment).

const char* GetBuildArch() const

const char* GetBuildNode() const

const char* GetBuildDir() const

const char* GetFlagsDebug() const

const char* GetFlagsOpt() const

const char* GetMakeSharedLib() const

const char* GetMakeExe() const

const char* GetIncludePath()

const char* GetLinkedLibs() const

const char* GetLinkdefSuffix() const

const char* GetSoExt() const

const char* GetObjExt() const

void SetBuildDir(const char* build_dir)

     Set the location where ACLiC will create libraries and use as
     a scratch area.  Note that the libraries are actually stored in
     sub-directories of 'build_dir' including the full pathname of the
     script.  If the script is location at /full/path/name/macro.C
     the library will be located at 'build_dir+/full/path/name/macro_C.so'

void SetFlagsDebug(const char *flags)

     FlagsDebug should contain the options to pass to the C++ compiler
     in order to compile the library in debug mode.

void SetFlagsOpt(const char *flags)

     FlagsOpt should contain the options to pass to the C++ compiler
     in order to compile the library in optimized mode.

void SetAclicMode(EAclicMode mode)

     AclicMode indicates whether the library should be built in
     debug mode or optimized.  The values are:
     TSystem::kDefault : compile the same as the current ROOT
     TSystem::kDebug : compiled in debug mode
     TSystem::kOpt : optimized the library

void SetMakeExe(const char *directives)

     Directives has the same syntax as the argument of SetMakeSharedLib but is
     used to create an executable. This creation is used as a means to output
     a list of unresolved symbols, when loading a shared library has failed.
     The required variable is $ExeName rather than $SharedLib, e.g.:
     gSystem->SetMakeExe(
     "g++ -Wall -fPIC $IncludePath $SourceFiles
      -o $ExeName $LinkedLibs -L/usr/X11R6/lib -lX11 -lm -ldl -rdynamic");

void SetMakeSharedLib(const char *directives)

     Directives should contain the description on how to compile and link a
     shared lib. This description can be any valid shell command, including
     the use of ';' to separate several instructions. However, shell specific
     construct should be avoided. In particular this description can contain
     environment variables, like $ROOTSYS (or %ROOTSYS% on windows).

     Five special variables will be expanded before execution:
       Variable name       Expands to
       -------------       ----------
       $SourceFiles        Name of source files to be compiled
       $SharedLib          Name of the shared library being created
       $LibName            Name of shared library without extension
       $BuildDir           Directory where the files will be created
       $IncludePath        value of fIncludePath
       $LinkedLibs         value of fLinkedLibs
       $ObjectFiles        Name of source files to be compiler with
                           their extension changed to .o or .obj
       $Opt                location of the optimization/debug options
                           set fFlagsDebug and fFlagsOpt

     e.g.:
     gSystem->SetMakeSharedLib(
     "KCC -n32 --strict $IncludePath -K0 \$Opt $SourceFile
      --no_exceptions --signed_chars --display_error_number
      --diag_suppress 68 -o $SharedLib");

     gSystem->setMakeSharedLib(
     "Cxx $IncludePath -c $SourceFile;
      ld  -L/usr/lib/cmplrs/cxx -rpath /usr/lib/cmplrs/cxx -expect_unresolved
      \$Opt -shared /usr/lib/cmplrs/cc/crt0.o /usr/lib/cmplrs/cxx/_main.o
      -o $SharedLib $ObjectFile -lcxxstd -lcxx -lexc -lots -lc"

     gSystem->SetMakeSharedLib(
     "$HOME/mygcc/bin/g++ \$Opt -Wall -fPIC $IncludePath $SourceFile
      -shared -o $SharedLib");

     gSystem->SetMakeSharedLib(
     "cl -DWIN32  -D_WIN32 -D_MT -D_DLL -MD /O2 /G5 /MD -DWIN32
      -DVISUAL_CPLUSPLUS -D_WINDOWS $IncludePath $SourceFile
      /link -PDB:NONE /NODEFAULTLIB /INCREMENTAL:NO /RELEASE /NOLOGO
      $LinkedLibs -entry:_DllMainCRTStartup@12 -dll /out:$SharedLib")

void AddIncludePath(const char *includePath)

     Add includePath to the already set include path.

void AddLinkedLibs(const char *linkedLib)

     Add linkedLib to already set linked libs.

void SetIncludePath(const char *includePath)

     IncludePath should contain the list of compiler flags to indicate where
     to find user defined header files. It is used to expand $IncludePath in
     the directives given to SetMakeSharedLib() and SetMakeExe(), e.g.:
        gSystem->SetInclude("-I$ROOTSYS/include -Imydirectory/include");
     the default value of IncludePath on Unix is:
        "-I$ROOTSYS/include "
     and on Windows:
        "/I%ROOTSYS%/include "

void SetLinkedLibs(const char *linkedLibs)

     LinkedLibs should contain the library directory and list of libraries
     needed to recreate the current executable. It is used to expand $LinkedLibs
     in the directives given to SetMakeSharedLib() and SetMakeExe()
     The default value on Unix is: root-config --glibs

void SetLinkdefSuffix(const char *suffix)

     The 'suffix' will be appended to the name of a script loaded by ACLiC
     and used to locate any eventual additional linkdef information that
     ACLiC should used to produce the dictionary.
     So by default, when doing .L MyScript.cxx, ACLiC will look
     for a file name MyScript_linkdef and having one of the .h (.hpp,
     etc.) extensions.  If such a file exist, it will be added to
     the end of the linkdef file used to created the ACLiC dictionary.
     This effectively enable the full customization of the creation
     of the dictionary.  It should be noted that the file is intended
     as a linkdef 'fragment', so usually you would not list the
     typical '#pragma link off ....".

void SetSoExt(const char *SoExt)

     Set shared library extension, should be either .so, .sl, .a, .dll, etc.

void SetObjExt(const char *ObjExt)

     Set object files extension, should be either .o, .obj, etc.

TString SplitAclicMode(const char* filename, TString &aclicMode, TString &arguments, TString &io) const

     This method split a filename of the form:
       [path/]macro.C[+|++[g|O]][(args)].
     It stores the ACliC mode [+|++[g|O]] in 'mode',
     the arguments (including paranthesis) in arg
     and the I/O indirection in io

void CleanCompiledMacros()

     Remove the shared libs produced by the CompileMacro() function.

### Inline Functions

                           void SigAlarmInterruptsSyscalls(Bool_t)
                    const char* GetErrorStr() const
                         Bool_t InControl() const
                TSeqCollection* GetListOfFileHandlers() const
                           void ResetTimer(TTimer*)
                          void* GetDirPtr() const
                         Bool_t cd(const char* path)
                    const char* pwd() const
            TSystem::EAclicMode GetAclicMode() const
                        TClass* Class()
                        TClass* IsA() const
                           void ShowMembers(TMemberInspector& insp, char* parent)
                           void Streamer(TBuffer& b)
                           void StreamerNVirtual(TBuffer& b)
                        TSystem TSystem(const TSystem&)
                       TSystem& operator=(const TSystem&)

Author: Fons Rademakers 15/09/95
Last update: root/base:$Name: $:$Id: TSystem.cxx,v 1.125 2005/06/23 06:24:27 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *