Sage-ST ä

Cfglib

Documentation

Global Declarations (Constants, Types, Variables)
ChangeUserInfo ChangeUserPassword ConvertCFGToCurrent
GetDFLPath GetLogPath GetPath GetRelationPath
ReleaseForeignUserPasswords ResetCFGRelationPath ResetDFLPath ResetLogPath
ResetPath ReturnUserID ReturnUserInfo ReturnUserPWData
ReturnUserProcesses STRChangeUserInfo STRChangeUserPassword STRConvertCFGToCurrent
STRGetDFLPath STRGetLogPath STRGetPath STRGetRelationPath
STRResetCFGRelationPath STRResetDFLPath STRResetLogPath STRResetPath
STRReturnUserID STRReturnUserInfo STRReturnUserPWData STRReturnUserProcesses
STRSetForeignUserPasswords STRSetUserPasswords STRTotalProcesses STRTotalUsers
SetForeignUserPasswords SetUserPasswords TotalProcesses TotalUsers





  const
    TypeLen6_1 = 30;
    TypeLen6_2 = 257;

  type
    TokenType = array [0 .. 7] of char;




  procedure GetPath
             (const dflFile : array of char;
              const keyName : array of char;
              var   Path    : array of char); overload; stdcall;

  exports GetPath (const dflFile : array of char;
                   const keyName : array of char;
                   var   Path    : array of char) name 'CFGLib_GetPath';

  //*
  //  GetPath - Get a special path from the configuration file.
  //
  //
  //  This procedure returns a path associated with a special key as
  //  defined in the configuration file (.CFG) if it exists.
  //
  //  CALLING SEQUENCE -
  //
  //    GetPath (dflFile, keyName, path)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the .DFL file of concern.
  //
  //    keyName : array of char
  //      The name which identifies the required path.
  //
  //  EXIT -
  //
  //    path : array of char
  //      The path associated with the given key name.
  //




  procedure GetPath
             (const dflFile : string;
              const keyName : string;
              var   Path    : array of char); overload; stdcall;

  exports GetPath (const dflFile : string;
                   const keyName : string;
                   var   Path    : array of char) name 'CFGLib_STRGetPath';

  //*
  //  STRGetPath - See documentation of GetPath.
  //




  procedure ResetPath
             (const dflFile : array of char;
              const keyName : array of char;
              const Path    : array of char;
              var   Error   : boolean); overload; stdcall;

  exports ResetPath (const dflFile : array of char;
                     const keyName : array of char;
                     const Path    : array of char;
                     var   Error   : boolean) name 'CFGLib_ResetPath';

  //*
  //  ResetPath - Reset a special path for a configuration key.
  //
  //
  //  This procedure resets a path associated with a special key as
  //  defined in the configuration file (.CFG) if it exists.
  //
  //  CALLING SEQUENCE -
  //
  //    ResetPath (dflFile, keyName, path, error)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the .DFL file of concern.
  //
  //    keyName : array of char
  //      The name which identifies the required path.
  //
  //    path : array of char
  //      The path to reset.
  //
  //  EXIT -
  //
  //    error : boolean
  //      The result of the modification True=Success, False=No Success
  //




  procedure ResetPath
             (const dflFile : string;
              const keyName : string;
              const Path    : string;
              var   Error   : boolean); overload; stdcall;

  exports ResetPath (const dflFile : string;
                     const keyName : string;
                     const Path    : string;
                     var   Error   : boolean) name 'CFGLib_STRResetPath';

  //*
  //  STRResetPath - See documentation of ResetPath.
  //




  procedure GetRelationPath
             (const dflFile      : array of char;
              const RelationName : array of char;
              var   Path         : array of char); overload; stdcall;

  exports GetRelationPath (const dflFile      : array of char;
                           const RelationName : array of char;
                           var   Path         : array of char) name 'CFGLib_GetRelationPath';

  //*
  //  GetRelationPath - Get a relation path from the configuration file.
  //
  //
  //  This procedure returns a path associated with a relation as
  //  defined in the configuration file (.CFG) if it exists.
  //
  //  CALLING SEQUENCE -
  //
  //    GetRelationPath (dflFile, relationName, path)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the .DFL file of concern.
  //
  //    relationName : array of char
  //      The relation name which identifies the required path.
  //
  //  EXIT -
  //
  //    path : array of char
  //      The path associated with the given relation name.
  //




  procedure GetRelationPath
             (const dflFile      : string;
              const RelationName : string;
              var   Path         : array of char); overload; stdcall;

  exports GetRelationPath (const dflFile      : string;
                           const RelationName : string;
                           var   Path         : array of char) name 'CFGLib_STRGetRelationPath';

  //*
  //  STRGetRelationPath - See documentation of GetRelationPath.
  //




  procedure ResetCFGRelationPath
             (const dflFile      : array of char;
              const RelationName : array of char;
              const Path         : array of char;
              var   Error        : boolean); overload; stdcall;

  exports ResetCFGRelationPath (const dflFile      : array of char;
                                const RelationName : array of char;
                                const Path         : array of char;
                                var   Error        : boolean) name 'CFGLib_ResetCFGRelationPath';

  //*
  //  ResetCFGRelationPath - Reset a saved relation path to the configuration file.
  //
  //
  //  This procedure resets the path associated with the specified
  //  relation as defined in the configuration file (.CFG) if it exists.
  //
  //  CALLING SEQUENCE -
  //
  //    ResetCFGRelationPath (dflFile, relationName, path, error)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the .DFL file of concern.
  //
  //    relationName : array of char
  //      The relation name which identifies the required path.
  //
  //    path : array of char
  //      The new path.
  //
  //  EXIT -
  //
  //    error : boolean
  //      The result of the modification True=Success, False=No Success
  //




  procedure ResetCFGRelationPath
             (const dflFile      : string;
              const RelationName : string;
              const Path         : string;
              var   Error        : boolean); overload; stdcall;

  exports ResetCFGRelationPath (const dflFile      : string;
                                const RelationName : string;
                                const Path         : string;
                                var   Error        : boolean) name 'CFGLib_STRResetCFGRelationPath';

  //*
  //  STRResetCFGRelationPath - See documentation of ResetCFGRelationPath.
  //




  procedure GetDFLPath
             (const dflFile : array of char;
              var   Path    : array of char); overload; stdcall;

  exports GetDFLPath (const dflFile : array of char;
                      var   Path    : array of char) name 'CFGLib_GetDFLPath';

  //*
  //  GetDFLPath - Get a dfl path from the configuration file.
  //
  //
  //  This procedure returns a path associated with a dfl as
  //  defined in the configuration file (.CFG) if it exists.
  //
  //  CALLING SEQUENCE -
  //
  //    GetDFLPath (dflFile, path)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the .dfl file of concern.
  //
  //  EXIT -
  //
  //    path : array of char
  //      The path associated with the given .dfl name.
  //




  procedure GetDFLPath
             (const dflFile : string;
              var   Path    : array of char); overload; stdcall;

  exports GetDFLPath (const dflFile : string;
                      var   Path    : array of char) name 'CFGLib_STRGetDFLPath';

  //*
  //  STRGetDFLPath - See documentation of GetDFLPath.
  //




  procedure ResetDFLPath
             (const dflFile : array of char;
              const Path    : array of char;
              var   Error   : boolean); overload; stdcall;

  exports ResetDFLPath (const dflFile : array of char;
                        const Path    : array of char;
                        var   Error   : boolean) name 'CFGLib_ResetDFLPath';

  //*
  //  ResetDFLPath - Reset the DFL path found in the configuration file.
  //
  //
  //  This procedure resets the dfl path found in the configuration
  //  defined in the configuration file (.CFG) if it exists.
  //
  //  CALLING SEQUENCE -
  //
  //    ResetDFLPath (dflFile, path, error)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the .dfl file of concern.
  //
  //    path : array of char
  //      The new dfl path.
  //
  //  EXIT -
  //
  //    error : boolean
  //      The result of the modification True=Success, False=No Success
  //




  procedure ResetDFLPath
             (const dflFile : string;
              const Path    : string;
              var   Error   : boolean); overload; stdcall;

  exports ResetDFLPath (const dflFile : string;
                        const Path    : string;
                        var   Error   : boolean) name 'CFGLib_STRResetDFLPath';

  //*
  //  STRResetDFLPath - See documentation of ResetDFLPath.
  //




  procedure GetLogPath
             (const dflFile : array of char;
              var   Path    : array of char); overload; stdcall;

  exports GetLogPath (const dflFile : array of char;
                      var   Path    : array of char) name 'CFGLib_GetLogPath';

  //*
  //  GetLogPath - Get a Log path from the configuration file.
  //
  //
  //  This procedure returns a path associated with a Log as
  //  defined in the configuration file (.CFG) if it exists.
  //
  //  CALLING SEQUENCE -
  //
  //    GetLogPath (dflFile, path)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the .dfl file of concern.
  //
  //  EXIT -
  //
  //    path : array of char
  //      The path associated with the given Log name.
  //




  procedure GetLogPath
             (const dflFile : string;
              var   Path    : array of char); overload; stdcall;

  exports GetLogPath (const dflFile : string;
                      var   Path    : array of char) name 'CFGLib_STRGetLogPath';

  //*
  //  STRGetLogPath - See documentation of GetLogPath.
  //




  procedure ResetLogPath
             (const dflFile : array of char;
              const Path    : array of char;
              var   Error   : boolean); overload; stdcall;

  exports ResetLogPath (const dflFile : array of char;
                        const Path    : array of char;
                        var   Error   : boolean) name 'CFGLib_ResetLogPath';

  //*
  //  ResetLogGPath - Reset the log file path found in the configuration file.
  //
  //
  //  This procedure resets the log file path found in the configuration
  //  defined in the configuration file (.CFG) if it exists.
  //
  //  CALLING SEQUENCE -
  //
  //    ResetLogPath (dflFile, path, error)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the .dfl file of concern.
  //
  //    path : array of char
  //      The new log file path
  //
  //  EXIT -
  //
  //    error : boolean
  //      The result of the modification True=Success, False=No Success
  //




  procedure ResetLogPath
             (const dflFile : string;
              const Path    : string;
              var   Error   : boolean); overload; stdcall;

  exports ResetLogPath (const dflFile : string;
                        const Path    : string;
                        var   Error   : boolean) name 'CFGLib_STRResetLogPath';

  //*
  //  STRResetLogGPath - See documentation of ResetLogPath.
  //




  function TotalUsers
             (const dflFile : array of char) : cardinal; overload; stdcall;

  exports TotalUsers (const dflFile : array of char) name 'CFGLib_TotalUsers';

  //*
  //  TotalUsers - Return the total users in the security system.
  //
  //
  //  This procedure returns the total number of users stored in
  //  the security system.
  //
  //  CALLING SEQUENCE -
  //
  //    n := TotalUsers (dflFile);
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      The name of the database file (if a suffix is not given,
  //      then '.DFL' is appended).
  //
  //  EXIT -
  //
  //    n : cardinal
  //      The total number of users referenced in the configuration.
  //




  function TotalUsers
             (const dflFile : string) : cardinal; overload; stdcall;

  exports TotalUsers (const dflFile : string) name 'CFGLib_STRTotalUsers';

  //*
  //  STRTotalUsers - See documentation of TotalUsers.
  //




  procedure ReturnUserID
             (const dflFile : array of char;
              const userNum : cardinal;
              var   userID  : array of char); overload; stdcall;

  exports ReturnUserID (const dflFile : array of char;
                        const userNum : cardinal;
                        var   userID  : array of char) name 'CFGLib_ReturnUserID';

  //*
  //  ReturnUserID - Return the user ID for a specified user number.
  //
  //
  //  This procedure returns the user ID for a given user number.
  //




  procedure ReturnUserID
             (const dflFile : string;
              const userNum : cardinal;
              var   userID  : array of char); overload; stdcall;

  exports ReturnUserID (const dflFile : string;
                        const userNum : cardinal;
                        var   userID  : array of char) name 'CFGLib_STRReturnUserID';

  //*
  //  STRReturnUserID - See documentation of ReturnUserID.
  //




  procedure ReturnUserInfo
             (const dflFile     : array of char;
              const userID      : array of char;
              var   lastName    : array of char;
              var   firstName   : array of char;
              var   middleIChar : char;
              var   loggingChar : char;
              var   phone       : array of char;
              var   org         : array of char;
              var   address1    : array of char;
              var   address2    : array of char;
              var   city        : array of char;
              var   state       : array of char;
              var   country     : array of char;
              var   zip         : array of char;
              var   Des         : array of char); overload; stdcall;

  exports ReturnUserInfo (const dflFile     : array of char;
                          const userID      : array of char;
                          var   lastName    : array of char;
                          var   firstName   : array of char;
                          var   middleIChar : char;
                          var   loggingChar : char;
                          var   phone       : array of char;
                          var   org         : array of char;
                          var   address1    : array of char;
                          var   address2    : array of char;
                          var   city        : array of char;
                          var   state       : array of char;
                          var   country     : array of char;
                          var   zip         : array of char;
                          var   Des         : array of char) name 'CFGLib_ReturnUserInfo';

  //*
  //  ReturnUserInfo - Return information about the given user.
  //
  //
  //  This procedure returns the basic user information
  //  for the specified user.
  //




  procedure ReturnUserInfo
             (const dflFile     : string;
              const userID      : string;
              var   lastName    : array of char;
              var   firstName   : array of char;
              var   middleIChar : char;
              var   loggingChar : char;
              var   phone       : array of char;
              var   org         : array of char;
              var   address1    : array of char;
              var   address2    : array of char;
              var   city        : array of char;
              var   state       : array of char;
              var   country     : array of char;
              var   zip         : array of char;
              var   Des         : array of char); overload; stdcall;

  exports ReturnUserInfo (const dflFile     : string;
                          const userID      : string;
                          var   lastName    : array of char;
                          var   firstName   : array of char;
                          var   middleIChar : char;
                          var   loggingChar : char;
                          var   phone       : array of char;
                          var   org         : array of char;
                          var   address1    : array of char;
                          var   address2    : array of char;
                          var   city        : array of char;
                          var   state       : array of char;
                          var   country     : array of char;
                          var   zip         : array of char;
                          var   Des         : array of char) name 'CFGLib_STRReturnUserInfo';

  //*
  //  STRReturnUserInfo - See documentation of ReturnUserInfo.
  //




  procedure ChangeUserInfo
             (const dflFile     : array of char;
              const userID      : array of char;
              const lastName    : array of char;
              const firstName   : array of char;
              const middleIChar : char;
              const phone       : array of char;
              const org         : array of char;
              const address1    : array of char;
              const address2    : array of char;
              const city        : array of char;
              const state       : array of char;
              const country     : array of char;
              const zip         : array of char;
              var   good        : boolean); overload; stdcall;

  exports ChangeUserInfo (const dflFile     : array of char;
                          const userID      : array of char;
                          const lastName    : array of char;
                          const firstName   : array of char;
                          const middleIChar : char;
                          const phone       : array of char;
                          const org         : array of char;
                          const address1    : array of char;
                          const address2    : array of char;
                          const city        : array of char;
                          const state       : array of char;
                          const country     : array of char;
                          const zip         : array of char;
                          var   good        : boolean) name 'CFGLib_ChangeUserInfo';

  //*
  //  ChangeUserInfo - Change user information.
  //
  //
  //  This procedure allows changing of selected user information
  //  items.  Other items such as the description and passwords
  //  are not changed by this procedure.  The current user information
  //  may be acquired using 'CFGLib.ReturnUserInfo'.
  //




  procedure ChangeUserInfo
             (const dflFile     : string;
              const userID      : string;
              const lastName    : string;
              const firstName   : string;
              const middleIChar : char;
              const phone       : string;
              const org         : string;
              const address1    : string;
              const address2    : string;
              const city        : string;
              const state       : string;
              const country     : string;
              const zip         : string;
              var   good        : boolean); overload; stdcall;

  exports ChangeUserInfo (const dflFile     : string;
                          const userID      : string;
                          const lastName    : string;
                          const firstName   : string;
                          const middleIChar : char;
                          const phone       : string;
                          const org         : string;
                          const address1    : string;
                          const address2    : string;
                          const city        : string;
                          const state       : string;
                          const country     : string;
                          const zip         : string;
                          var   good        : boolean) name 'CFGLib_STRChangeUserInfo';

  //*
  //  STRChangeUserInfo - See documentation of ChangeUserInfo.
  //




  procedure ChangeUserPassword
             (const dflFile : array of char;
              const userID  : array of char;
              const oldPW   : array of char;
              const NewPW   : array of char;
              var   good    : boolean); overload; stdcall;

  exports ChangeUserPassword (const dflFile : array of char;
                              const userID  : array of char;
                              const oldPW   : array of char;
                              const NewPW   : array of char;
                              var   good    : boolean) name 'CFGLib_ChangeUserPassword';

  //*
  //  ChangeUserPassword - Change a current user password.
  //
  //
  //  This procedure changes the selected current user password
  //  from the previous value to the new value.  A user may have
  //  more than one password.  This procedure only changes the
  //  one specified.  The new password should not be blank.
  //




  procedure ChangeUserPassword
             (const dflFile : string;
              const userID  : string;
              const oldPW   : string;
              const NewPW   : string;
              var   good    : boolean); overload; stdcall;

  exports ChangeUserPassword (const dflFile : string;
                              const userID  : string;
                              const oldPW   : string;
                              const NewPW   : string;
                              var   good    : boolean) name 'CFGLib_STRChangeUserPassword';

  //*
  //  STRChangeUserPassword - See documentation of ChangeUserPassword.
  //




  procedure SetUserPasswords
             (const dflFile      : array of char;
              const userID       : array of char;
              const userPassword : array of char); overload; stdcall;

  exports SetUserPasswords (const dflFile      : array of char;
                            const userID       : array of char;
                            const userPassword : array of char) name 'CFGLib_SetUserPasswords';

  //*
  //  SetUserPasswords - Submit passwords to the system.
  //
  //
  //  This procedure submits passwords to SAGE based on the given
  //  user ID and password.  The associated system passwords are
  //  set which allows the user permissions of data base access
  //  as restricted by the normal SAGE password security system.
  //




  procedure SetUserPasswords
             (const dflFile      : string;
              const userID       : string;
              const userPassword : string); overload; stdcall;

  exports SetUserPasswords (const dflFile      : string;
                            const userID       : string;
                            const userPassword : string) name 'CFGLib_STRSetUserPasswords';

  //*
  //  STRSetUserPasswords - See documentation of SetUserPasswords.
  //




  procedure SetForeignUserPasswords
             (const dflFile      : array of char;
              const userID       : array of char;
              const userPassword : array of char); overload; stdcall;

  exports SetForeignUserPasswords (const dflFile      : array of char;
                                   const userID       : array of char;
                                   const userPassword : array of char) name 'CFGLib_SetForeignUserPasswords';

  //*
  //  SetUserPasswords - Submit passwords to the system for external DFL's.
  //
  //
  //  This procedure submits passwords to SAGE based on the given
  //  user ID and password.  The associated system passwords are
  //  set which allows the user permissions of data base access
  //  as restricted by the normal SAGE password security system
  //  implemented in libraries such as 'SageDyn'.  Each time this
  //  is called, the previously established foreign passwords are
  //  released.
  //




  procedure SetForeignUserPasswords
             (const dflFile      : string;
              const userID       : string;
              const userPassword : string); overload; stdcall;

  exports SetForeignUserPasswords (const dflFile      : string;
                                   const userID       : string;
                                   const userPassword : string) name 'CFGLib_STRSetForeignUserPasswords';

  //*
  //  STRForeignSetUserPasswords - See documentation of SetForeighUserPasswords.
  //




  procedure ReleaseForeignUserPasswords; stdcall;

  exports ReleaseForeignUserPasswords name 'CFGLib_ReleaseForeignUserPasswords';

  //*
  //  ReleaseForeignUserPasswords - Release internal list of foreign pw's.
  //
  //
  //  This procedure releases the list of passwords which were previously
  //  set by a call to 'SetForeignUserPasswords.
  //




  procedure ReturnUserPWData
             (const dflFile      : array of char;
              const userID       : array of char;
              const userPassword : array of char;
              var   accessMode   : cardinal;
              var   workAreaPath : array of char); overload; stdcall;

  exports ReturnUserPWData (const dflFile      : array of char;
                            const userID       : array of char;
                            const userPassword : array of char;
                            var   accessMode   : cardinal;
                            var   workAreaPath : array of char) name 'CFGLib_ReturnUserPWData';

  //*
  //  ReturnUserPWData - Return information associated with the user PW.
  //
  //
  //  This procedure returns information associated with the
  //  given user and password for the specified data base.
  //
  //  CALLING SEQUENCE -
  //
  //    ReturnUserPWData (dflFile, userID, userPassword, accessMode,
  //                      workAreaPath, totalProcesses)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      Name of data base dictionary file.  If given without
  //      a suffix, then '.DFL' is appended.
  //
  //    userID : array of char
  //      User ID of the user.
  //
  //    userPassword : array of char
  //      Password for the specified user.
  //
  //  EXIT -
  //
  //    accessMode : cardinal
  //      The access mode associated with this password.  These
  //      may be determined by the program, but are commonly
  //      defined as follows -
  //
  //        0 - Single user normal access.
  //        1 - Single user with File.DenyNone set for the sharing mode
  //        2 - Copy required relation files to local space.  Single
  //            user access to those relations.
  //        3 - MultSage access with exclusive locks
  //        4 - Try for an exclusive lock.  If unavailable, use normal
  //            MultSage access
  //        5 - Normal MultSage access
  //
  //    workAreaPath : array of char
  //      Path for the required local work area.  This area may be
  //      used for local file space if 'accessMode' is set to 2.
  //
  //    totalProcesses : cardinal
  //      The total number of processes associated with the given
  //      db name, user, and password.  The actual process may
  //      be retrieved using 'CFGLib.ReturnUserProcesses'.
  //      This is the same number as returned from
  //      'CFGLib.TotalProcesses'.
  //




  procedure ReturnUserPWData
             (const dflFile      : string;
              const userID       : string;
              const userPassword : string;
              var   accessMode   : cardinal;
              var   workAreaPath : array of char); overload; stdcall;

  exports ReturnUserPWData (const dflFile      : string;
                            const userID       : string;
                            const userPassword : string;
                            var   accessMode   : cardinal;
                            var   workAreaPath : array of char) name 'CFGLib_STRReturnUserPWData';

  //*
  //  STRReturnUserPWData - See documentation of ReturnUserPWData.
  //




  function TotalProcesses
             (const dflFile      : array of char;
              const userID       : array of char;
              const userPassword : array of char) : cardinal; overload; stdcall;

  exports TotalProcesses (const dflFile      : array of char;
                          const userID       : array of char;
                          const userPassword : array of char) name 'CFGLib_TotalProcesses';

  //*
  //  TotalProcesses - Return the total processes available for the user.
  //
  //
  //  This procedure returns the total number of passwords assigned
  //  to the given user under the specified password.  The names of
  //  these processes may be retrieved using
  //  'CFGLib.ReturnUserProcesses'.
  //




  function TotalProcesses
             (const dflFile      : string;
              const userID       : string;
              const userPassword : string) : cardinal; overload; stdcall;

  exports TotalProcesses (const dflFile      : string;
                          const userID       : string;
                          const userPassword : string) name 'CFGLib_STRTotalProcesses';

  //*
  //  STRTotalProcesses - See documentation of TotalProcesses.
  //




  procedure ReturnUserProcesses
             (const dflFile       : array of char;
              const userID        : array of char;
              const userPassword  : array of char;
              var   processes     : array of TokenType;
              const maxProcesses  : cardinal;
              var   totalReturned : cardinal); overload; stdcall;

  exports ReturnUserProcesses (const dflFile       : array of char;
                               const userID        : array of char;
                               const userPassword  : array of char;
                               var   processes     : array of TokenType;
                               const maxProcesses  : cardinal;
                               var   totalReturned : cardinal) name 'CFGLib_ReturnUserProcesses';

  //*
  //  ReturnUserProcesses - Return the processes for the user.
  //
  //
  //  This procedure returns the processes assigned to the given
  //  user and associated given user password.  It will return
  //  no more than the 'maxProcesses' specified in the argument
  //  list.  To determine the total number of processes available
  //  under the given user and password conditions, the
  //  'CFGLib.TotalProcesses' procedure may be used.
  //




  procedure ReturnUserProcesses
             (const dflFile       : string;
              const userID        : string;
              const userPassword  : string;
              var   processes     : array of TokenType;
              const maxProcesses  : cardinal;
              var   totalReturned : cardinal); overload; stdcall;

  exports ReturnUserProcesses (const dflFile       : string;
                               const userID        : string;
                               const userPassword  : string;
                               var   processes     : array of TokenType;
                               const maxProcesses  : cardinal;
                               var   totalReturned : cardinal) name 'CFGLib_STRReturnUserProcesses';

  //*
  //  STRReturnUserProcesses - See documentation of ReturnUserProcesses.
  //




  procedure ConvertCFGToCurrent
             (const dflFile   : array of char;
              var   CFGFound  : boolean;
              var   Converted : boolean); overload; stdcall;

  exports ConvertCFGToCurrent (const dflFile   : array of char;
                               var   CFGFound  : boolean;
                               var   Converted : boolean) name 'CFGLib_ConvertCFGToCurrent';

  //*
  //  ConvertCFGToCurrent - Convert CFG file to current format.
  //
  //
  //  This procedure converts the .CFG file of the given .DFL to
  //  the latest format if possible.  If the file is found the
  //  CFGFound param is set appropriately whether the file gets
  //  converted or not.  The Converted parameter will give the
  //  result of the attempt to convert.
  //
  //  CALLING SEQUENCE -
  //
  //    ConvertCFGToCurrent (dflFile, CFGFound, Converted)
  //
  //  ENTRY -
  //
  //    dflFile : array of char
  //      Name of data base dictionary file.  If given without a suffix,
  //      then '.DFL' is appended.
  //
  //  EXIT -
  //
  //    CFGFound : boolean
  //      True - The .CFG file was located whether conversion was successful
  //             or not.
  //      False - The .CFG file was not located whether conversion was successful
  //             or not.
  //
  //    Converted : boolean
  //      True - The .CFG file was converted to the current format.
  //      False - The .CFG file was not converted to the current format.
  //




  procedure ConvertCFGToCurrent
             (const dflFile   : string;
              var   CFGFound  : boolean;
              var   Converted : boolean); overload; stdcall;

  exports ConvertCFGToCurrent (const dflFile   : string;
                               var   CFGFound  : boolean;
                               var   Converted : boolean) name 'CFGLib_STRConvertCFGToCurrent';

  //*
  //  STRConvertCFGToCurrent - See documentation of ConvertCFGToCurrent.
  //




Send mail to   warren.merrill@inl.gov with questions or comments about this web site.
Copyright © 1989-2006 Battelle Energy Alliance