generic-library/poco
1
0
Fork 0
mirror of https://github.com/pocoproject/poco.git synced 2025-10-28 19:51:58 +01:00
Code Issues Projects Releases Wiki Activity

GH #1988: Remove OpenVMS support

Browse Source
This commit is contained in:
Guenter Obiltschnig
2017-11-09 11:15:18 +01:00
parent 60ffb229ec
commit 7d4d01e343
83 changed files with 241 additions and 5502 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
Foundation/include/Poco/Debugger.h
View File

@@ -39,8 +39,6 @@ public:
/// function.
/// On Unix, this function returns true if the environment
/// variable POCO_ENABLE_DEBUGGER is set.
/// On OpenVMS, this function always returns true in debug,
/// mode, false otherwise.
static void message(const std::string& msg);
/// Writes a message to the debugger log, if available, otherwise to
@@ -54,7 +52,6 @@ public:
/// Breaks into the debugger, if it is available.
/// On Windows, this is done using the DebugBreak() function.
/// On Unix, the SIGINT signal is raised.
/// On OpenVMS, the SS$_DEBUG signal is raised.
static void enter(const std::string& msg);
/// Writes a debug message to the debugger log and breaks into it.

75
Foundation/include/Poco/DirectoryIterator_VMS.h
View File

@@ -1,75 +0,0 @@
//
// DirectoryIterator_VMS.h
//
// Library: Foundation
// Package: Filesystem
// Module: DirectoryIterator
//
// Definition of the DirectoryIteratorImpl class for OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_DirectoryIterator_VMS_INCLUDED
#define Foundation_DirectoryIterator_VMS_INCLUDED
#include "Poco/Foundation.h"
#include <rms.h>
namespace Poco {
class Foundation_API DirectoryIteratorImpl
{
public:
DirectoryIteratorImpl(const std::string& path);
~DirectoryIteratorImpl();
void duplicate();
void release();
const std::string& get() const;
const std::string& next();
private:
struct FAB _fab;
struct NAM _nam;
std::string _search;
char _spec[255];
std::string _current;
int _rc;
};
//
// inlines
//
const std::string& DirectoryIteratorImpl::get() const
{
return _current;
}
inline void DirectoryIteratorImpl::duplicate()
{
++_rc;
}
inline void DirectoryIteratorImpl::release()
{
if (--_rc == 0)
delete this;
}
} // namespace Poco
#endif // Foundation_DirectoryIterator_VMS_INCLUDED

57
Foundation/include/Poco/Environment_VMS.h
View File

@@ -1,57 +0,0 @@
//
// Environment_VMS.h
//
// Library: Foundation
// Package: Core
// Module: Environment
//
// Definition of the EnvironmentImpl class for OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Environment_VMS_INCLUDED
#define Foundation_Environment_VMS_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Mutex.h"
namespace Poco {
class Foundation_API EnvironmentImpl
{
public:
typedef UInt8 NodeId[6]; /// Ethernet address.
static std::string getImpl(const std::string& name);
static bool hasImpl(const std::string& name);
static void setImpl(const std::string& name, const std::string& value);
static std::string osNameImpl();
static std::string osDisplayNameImpl();
static std::string osVersionImpl();
static std::string osArchitectureImpl();
static std::string nodeNameImpl();
static void nodeIdImpl(NodeId& id);
static unsigned processorCountImpl();
static std::string getsyi(unsigned short code);
/// a wrapper for $GETSYIW
static std::string trnlnm(const std::string& name);
private:
static FastMutex _mutex;
};
} // namespace Poco
#endif // Foundation_Environment_VMS_INCLUDED

14
Foundation/include/Poco/FPEnvironment.h
View File

@@ -23,7 +23,7 @@
#if defined(POCO_NO_FPENVIRONMENT)
#include "Poco/FPEnvironment_DUMMY.h"
#elif defined(__osf__) || defined(__VMS)
#elif defined(__osf__)
#include "Poco/FPEnvironment_DEC.h"
#elif defined(sun) || defined(__sun)
#include "Poco/FPEnvironment_SUN.h"
@@ -48,7 +48,7 @@ class Foundation_API FPEnvironment: private FPEnvironmentImpl
/// mode and floating-point flags).
/// The class also provides various static
/// methods to query certain properties
/// of a floating-point number.
/// of a floating-point number.
{
public:
enum RoundingMode
@@ -82,7 +82,7 @@ public:
~FPEnvironment();
/// Restores the previous environment (unless
/// keepCurrent() has been called previously)
FPEnvironment& operator = (const FPEnvironment& env);
/// Assignment operator
@@ -95,10 +95,10 @@ public:
static bool isFlag(Flag flag);
/// Returns true iff the given flag is set.
static void setRoundingMode(RoundingMode mode);
/// Sets the rounding mode.
static RoundingMode getRoundingMode();
/// Returns the current rounding mode.
@@ -140,13 +140,13 @@ inline void FPEnvironment::setRoundingMode(RoundingMode mode)
setRoundingModeImpl(RoundingModeImpl(mode));
}
inline FPEnvironment::RoundingMode FPEnvironment::getRoundingMode()
{
return RoundingMode(getRoundingModeImpl());
}
inline bool FPEnvironment::isInfinite(float value)
{
return isInfiniteImpl(value);

66
Foundation/include/Poco/File.h
View File

@@ -35,8 +35,6 @@
#include "Poco/File_VX.h"
#elif defined(POCO_OS_FAMILY_UNIX)
#include "Poco/File_UNIX.h"
#else
#include "Poco/File_VMS.h"
#endif
@@ -49,17 +47,17 @@ class Path;
class Foundation_API File: private FileImpl
/// The File class provides methods for working with a file.
///
/// Regarding paths passed to the various methods, note that
/// Regarding paths passed to the various methods, note that
/// platform-specific limitations regarding maximum length
/// of the entire path and its components apply.
///
/// On Windows, if compiled with UTF-8 support (POCO_WIN32_UTF8)
/// On Windows, if compiled with UTF-8 support (POCO_WIN32_UTF8)
/// the implementation tries to work around the rather low
/// 260 characters MAX_PATH limit by adding the "\\?\" prefix if
/// a path is absolute and exceeds MAX_PATH characters in length.
/// Note that various limitations regarding usage of the "\\?\"
/// Note that various limitations regarding usage of the "\\?\"
/// prefix apply in that case, e.g. the path must
/// not contain relative components ("." and "..") and must not
/// not contain relative components ("." and "..") and must not
/// use the forward slash ("/") as directory separator.
{
public:
@@ -70,19 +68,19 @@ public:
File(const std::string& path);
/// Creates the file.
File(const char* path);
/// Creates the file.
File(const Path& path);
/// Creates the file.
File(const File& file);
/// Copy constructor.
virtual ~File();
/// Destroys the file.
File& operator = (const File& file);
/// Assignment operator.
@@ -94,39 +92,39 @@ public:
File& operator = (const Path& path);
/// Assignment operator.
void swap(File& file);
/// Swaps the file with another one.
const std::string& path() const;
/// Returns the path.
bool exists() const;
/// Returns true iff the file exists.
bool canRead() const;
/// Returns true iff the file is readable.
bool canWrite() const;
/// Returns true iff the file is writeable.
bool canExecute() const;
/// Returns true iff the file is executable.
///
/// On Windows and OpenVMS, the file must have
/// On Windows, the file must have
/// the extension ".EXE" to be executable.
/// On Unix platforms, the executable permission
/// bit must be set.
bool isFile() const;
/// Returns true iff the file is a regular file.
bool isLink() const;
/// Returns true iff the file is a symbolic link.
bool isDirectory() const;
/// Returns true iff the file is a directory.
bool isDevice() const;
/// Returns true iff the file is a device.
@@ -150,67 +148,67 @@ public:
Timestamp getLastModified() const;
/// Returns the modification date of the file.
File& setLastModified(const Timestamp& ts);
/// Sets the modification date of the file.
FileSize getSize() const;
/// Returns the size of the file in bytes.
File& setSize(FileSize size);
/// Sets the size of the file in bytes. Can be used
/// to truncate a file.
File& setWriteable(bool flag = true);
/// Makes the file writeable (if flag is true), or
/// non-writeable (if flag is false) by setting the
/// file's flags in the filesystem accordingly.
File& setReadOnly(bool flag = true);
/// Makes the file non-writeable (if flag is true), or
/// writeable (if flag is false) by setting the
/// file's flags in the filesystem accordingly.
File& setExecutable(bool flag = true);
/// Makes the file executable (if flag is true), or
/// non-executable (if flag is false) by setting
/// the file's permission bits accordingly.
///
/// Does nothing on Windows and OpenVMS.
/// Does nothing on Windows.
void copyTo(const std::string& path) const;
/// Copies the file (or directory) to the given path.
/// Copies the file (or directory) to the given path.
/// The target path can be a directory.
///
/// A directory is copied recursively.
void moveTo(const std::string& path);
/// Copies the file (or directory) to the given path and
/// Copies the file (or directory) to the given path and
/// removes the original file. The target path can be a directory.
void renameTo(const std::string& path);
/// Renames the file to the new name.
void remove(bool recursive = false);
/// Deletes the file. If recursive is true and the
/// file is a directory, recursively deletes all
/// files in the directory.
bool createFile();
/// Creates a new, empty file in an atomic operation.
/// Returns true if the file has been created and false
/// if the file already exists. Throws an exception if
/// an error occurs.
bool createDirectory();
/// Creates a directory. Returns true if the directory
/// has been created and false if it already exists.
/// Throws an exception if an error occurs.
void createDirectories();
/// Creates a directory (and all parent directories
/// if necessary).
void list(std::vector<std::string>& files) const;
/// Fills the vector with the names of all
/// files in the directory.
@@ -225,7 +223,7 @@ public:
bool operator <= (const File& file) const;
bool operator > (const File& file) const;
bool operator >= (const File& file) const;
static void handleLastError(const std::string& path);
/// For internal use only. Throws an appropriate
/// exception for the last file-related error.

79
Foundation/include/Poco/File_VMS.h
View File

@@ -1,79 +0,0 @@
//
// File_VMS.h
//
// Library: Foundation
// Package: Filesystem
// Module: File
//
// Definition of the FileImpl class for OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_File_VMS_INCLUDED
#define Foundation_File_VMS_INCLUDED
#include "Poco/Foundation.h"
namespace Poco {
class FileImpl
{
protected:
typedef UInt64 FileSizeImpl;
FileImpl();
FileImpl(const std::string& path);
virtual ~FileImpl();
void setPath(const std::string& path);
void swapImpl(FileImpl& file);
void setPathImpl(const std::string& path);
const std::string& getPathImpl() const;
bool existsImpl() const;
bool canReadImpl() const;
bool canWriteImpl() const;
bool canExecuteImpl() const;
bool isFileImpl() const;
bool isDirectoryImpl() const;
bool isLinkImpl() const;
bool isDeviceImpl() const;
bool isHiddenImpl() const;
Timestamp createdImpl() const;
Timestamp getLastModifiedImpl() const;
void setLastModifiedImpl(const Timestamp& ts);
FileSizeImpl getSizeImpl() const;
void setSizeImpl(FileSizeImpl size);
void setWriteableImpl(bool flag = true);
void setExecutableImpl(bool flag = true);
void copyToImpl(const std::string& path) const;
void renameToImpl(const std::string& path);
void removeImpl();
bool createFileImpl();
bool createDirectoryImpl();
static void handleLastError(const std::string& path);
private:
std::string _path;
};
//
// inlines
//
inline const std::string& FileImpl::getPathImpl() const
{
return _path;
}
} // namespace Poco
#endif // Foundation_File_VMS_INCLUDED

2
Foundation/include/Poco/Foundation.h
View File

@@ -98,8 +98,6 @@
#include "Poco/Platform.h"
#if defined(_WIN32)
#include "Poco/Platform_WIN32.h"
#elif defined(__VMS)
#include "Poco/Platform_VMS.h"
#elif defined(POCO_VXWORKS)
#include "Poco/Platform_VX.h"
#elif defined(POCO_OS_FAMILY_UNIX)

6
Foundation/include/Poco/LogFile.h
View File

@@ -25,8 +25,6 @@
#include "Poco/LogFile_WIN32U.h"
#elif defined(POCO_OS_FAMILY_WINDOWS)
#include "Poco/LogFile_WIN32.h"
#elif defined(POCO_OS_FAMILY_VMS)
#include "Poco/LogFile_VMS.h"
#else
#include "Poco/LogFile_STD.h"
#endif
@@ -53,10 +51,10 @@ public:
UInt64 size() const;
/// Returns the current size in bytes of the log file.
Timestamp creationDate() const;
/// Returns the date and time the log file was created.
const std::string& path() const;
/// Returns the path given in the constructor.
};

53
Foundation/include/Poco/LogFile_VMS.h
View File

@@ -1,53 +0,0 @@
//
// LogFile_VMS.h
//
// Library: Foundation
// Package: Logging
// Module: LogFile
//
// Definition of the LogFileImpl class using C I/O with OpenVMS extensions.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_LogFile_VMS_INCLUDED
#define Foundation_LogFile_VMS_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Timestamp.h"
#include <stdio.h>
namespace Poco {
class Foundation_API LogFileImpl
/// The implementation of LogFile for OpenVMS.
/// The C Standard Library functions for file I/O
/// are used with OpenVMS-specific extensions to
/// control sharing and locking behavior.
{
public:
LogFileImpl(const std::string& path);
~LogFileImpl();
void writeImpl(const std::string& text, bool flush);
UInt64 sizeImpl() const;
Timestamp creationDateImpl() const;
const std::string& pathImpl() const;
private:
std::string _path;
mutable FILE* _file;
Timestamp _creationDate;
};
} // namespace Poco
#endif // Foundation_LogFile_VMS_INCLUDED

13
Foundation/include/Poco/LoggingFactory.h
View File

@@ -37,7 +37,6 @@ class Foundation_API LoggingFactory
/// - FileChannel
/// - FormattingChannel
/// - NullChannel
/// - OpcomChannel (OpenVMS only)
/// - SplitterChannel
/// - SyslogChannel (Unix platforms only)
///
@@ -56,23 +55,23 @@ public:
~LoggingFactory();
/// Destroys the LoggingFactory.
void registerChannelClass(const std::string& className, ChannelInstantiator* pFactory);
/// Registers a channel class with the LoggingFactory.
void registerFormatterClass(const std::string& className, FormatterFactory* pFactory);
/// Registers a formatter class with the LoggingFactory.
Channel* createChannel(const std::string& className) const;
/// Creates a new Channel instance from specified class.
///
/// Throws a NotFoundException if the specified channel class
/// Throws a NotFoundException if the specified channel class
/// has not been registered.
Formatter* createFormatter(const std::string& className) const;
/// Creates a new Formatter instance from specified class.
///
/// Throws a NotFoundException if the specified formatter class
/// Throws a NotFoundException if the specified formatter class
/// has not been registered.
static LoggingFactory& defaultFactory();
@@ -81,7 +80,7 @@ public:
private:
void registerBuiltins();
DynamicFactory<Channel> _channelFactory;
DynamicFactory<Formatter> _formatterFactory;
};

10
Foundation/include/Poco/NamedEvent.h
View File

@@ -29,8 +29,6 @@
#include "Poco/NamedEvent_Android.h"
#elif defined(POCO_OS_FAMILY_UNIX)
#include "Poco/NamedEvent_UNIX.h"
#else
#include "Poco/NamedEvent_VMS.h"
#endif
@@ -38,7 +36,7 @@ namespace Poco {
class Foundation_API NamedEvent: public NamedEventImpl
/// An NamedEvent is a global synchronization object
/// An NamedEvent is a global synchronization object
/// that allows one process or thread to signal an
/// other process or thread that a certain event
/// has happened.
@@ -58,13 +56,13 @@ class Foundation_API NamedEvent: public NamedEventImpl
public:
NamedEvent(const std::string& name);
/// Creates the event.
~NamedEvent();
/// Destroys the event.
void set();
/// Signals the event.
/// The one thread or process waiting for the event
/// Signals the event.
/// The one thread or process waiting for the event
/// can resume execution.
void wait();

44
Foundation/include/Poco/NamedEvent_VMS.h
View File

@@ -1,44 +0,0 @@
//
// NamedEvent_VMS.h
//
// Library: Foundation
// Package: Processes
// Module: NamedEvent
//
// Definition of the NamedEventImpl class for OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_NamedEvent_VMS_INCLUDED
#define Foundation_NamedEvent_VMS_INCLUDED
#include "Poco/Foundation.h"
namespace Poco {
class Foundation_API NamedEventImpl
{
protected:
NamedEventImpl(const std::string& name);
~NamedEventImpl();
void setImpl();
void waitImpl();
private:
std::string _name;
unsigned short _mbxChan;
};
} // namespace Poco
#endif // Foundation_NamedEvent_VMS_INCLUDED

10
Foundation/include/Poco/NamedMutex.h
View File

@@ -30,8 +30,6 @@
#include "Poco/NamedMutex_Android.h"
#elif defined(POCO_OS_FAMILY_UNIX)
#include "Poco/NamedMutex_UNIX.h"
#else
#include "Poco/NamedMutex_VMS.h"
#endif
@@ -39,7 +37,7 @@ namespace Poco {
class Foundation_API NamedMutex: private NamedMutexImpl
/// A NamedMutex (mutual exclusion) is a global synchronization
/// A NamedMutex (mutual exclusion) is a global synchronization
/// mechanism used to control access to a shared resource
/// in a concurrent (multi process) scenario.
/// Using the ScopedLock class is the preferred way to automatically
@@ -58,10 +56,10 @@ class Foundation_API NamedMutex: private NamedMutexImpl
{
public:
typedef Poco::ScopedLock<NamedMutex> ScopedLock;
NamedMutex(const std::string& name);
/// creates the Mutex.
~NamedMutex();
/// destroys the Mutex.
@@ -77,7 +75,7 @@ public:
void unlock();
/// Unlocks the mutex so that it can be acquired by
/// other threads.
private:
NamedMutex();
NamedMutex(const NamedMutex&);

48
Foundation/include/Poco/NamedMutex_VMS.h
View File

@@ -1,48 +0,0 @@
//
// NamedMutex_VMS.h
//
// Library: Foundation
// Package: Processes
// Module: NamedMutex
//
// Definition of the NamedMutexImpl class for OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_NamedMutex_VMS_INCLUDED
#define Foundation_NamedMutex_VMS_INCLUDED
#include "Poco/Foundation.h"
#include <descrip.h>
#include <lckdef.h>
namespace Poco {
class Foundation_API NamedMutexImpl
{
protected:
NamedMutexImpl(const std::string& name);
~NamedMutexImpl();
void lockImpl();
bool tryLockImpl();
void unlockImpl();
private:
std::string _name;
struct dsc$descriptor_s _nameDesc;
int _lksb[4];
};
} // namespace Poco
#endif // Foundation_NamedMutex_VMS_INCLUDED

80
Foundation/include/Poco/OpcomChannel.h
View File

@@ -1,80 +0,0 @@
//
// OpcomChannel.h
//
// Library: Foundation
// Package: Logging
// Module: OpcomChannel
//
// Definition of the OpcomChannel class specific to OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_OpcomChannel_INCLUDED
#define Foundation_OpcomChannel_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Channel.h"
namespace Poco {
class Foundation_API OpcomChannel: public Channel
/// A OpenVMS-only channel that uses the OpenVMS OPCOM service.
{
public:
OpcomChannel();
/// Creates an OpcomChannel that uses the OPC$M_NM_CENTRL
/// target.
OpcomChannel(int target);
/// Creates an OpcomChannel that uses the given target.
/// Specify one of the OPC$M_NM_* values.
/// See also setProperty().
void log(const Message& msg);
/// Logs the given message using the OpenVMS OPCOM service.
void setProperty(const std::string& name, const std::string& value);
/// Sets the property with the given name.
///
/// The only supported property is "target", which must
/// be set to one of the following values:
///
/// * CARDS: Card device operator
/// * CENTRL: Central operator
/// * SECURITY: Security operator
/// * CLUSTER: OpenVMS Cluster operator
/// * DEVICE: Device status information
/// * DISKS: Disks operator
/// * NTWORK: Network operator
/// * TAPES: Tapes operator
/// * PRINT: Printer operator
/// * OPER1 ..
/// * OPER12: System-manager-defined operator functions
std::string getProperty(const std::string& name) const;
/// Returns the value of the property with the given name.
/// See setProperty() for a description of the supported
/// properties.
static const std::string PROP_TARGET;
protected:
~OpcomChannel();
private:
int _target;
};
} // namespace Poco
#endif // Foundation_OpcomChannel_INCLUDED

43
Foundation/include/Poco/Path_VMS.h
View File

@@ -1,43 +0,0 @@
//
// Path_VMS.h
//
// Library: Foundation
// Package: Filesystem
// Module: Path
//
// Definition of the PathImpl class for OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Path_VMS_INCLUDED
#define Foundation_Path_VMS_INCLUDED
#include "Poco/Foundation.h"
#include <vector>
namespace Poco {
class PathImpl
{
public:
static std::string currentImpl();
static std::string homeImpl();
static std::string tempImpl();
static std::string nullImpl();
static std::string expandImpl(const std::string& path);
static void listRootsImpl(std::vector<std::string>& roots);
};
} // namespace Poco
#endif // Foundation_Path_VMS_INCLUDED

70
Foundation/include/Poco/Platform_VMS.h
View File

@@ -1,70 +0,0 @@
//
// Platform_VMS.h
//
// Library: Foundation
// Package: Core
// Module: Platform
//
// Platform and architecture identification macros
// and platform-specific definitions for OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Platform_VMS_INCLUDED
#define Foundation_Platform_VMS_INCLUDED
// Define the POCO_DESCRIPTOR_STRING and POCO_DESCRIPTOR_LITERAL
// macros which we use instead of $DESCRIPTOR and $DESCRIPTOR64.
// Our macros work with both 32bit and 64bit pointer sizes.
#if __INITIAL_POINTER_SIZE != 64
#define POCO_DESCRIPTOR_STRING(name, string) \
struct dsc$descriptor_s name = \
{ \
string.size(), \
DSC$K_DTYPE_T, \
DSC$K_CLASS_S, \
(char*) string.data() \
}
#define POCO_DESCRIPTOR_LITERAL(name, string) \
struct dsc$descriptor_s name = \
{ \
sizeof(string) - 1, \
DSC$K_DTYPE_T, \
DSC$K_CLASS_S, \
(char*) string \
}
#else
#define POCO_DESCRIPTOR_STRING(name, string) \
struct dsc64$descriptor_s name =\
{ \
1, \
DSC64$K_DTYPE_T, \
DSC64$K_CLASS_S, \
-1, \
string.size(), \
(char*) string.data() \
}
#define POCO_DESCRIPTOR_LITERAL(name, string) \
struct dsc64$descriptor_s name =\
{ \
1, \
DSC64$K_DTYPE_T, \
DSC64$K_CLASS_S, \
-1, \
sizeof(string) - 1, \
(char*) string \
}
#endif
// No <sys/select.h> header file
#define POCO_NO_SYS_SELECT_H
#endif // Foundation_Platform_VMS_INCLUDED

70
Foundation/include/Poco/Process.h
View File

@@ -33,8 +33,6 @@
#include "Poco/Process_VX.h"
#elif defined(POCO_OS_FAMILY_UNIX)
#include "Poco/Process_UNIX.h"
#else
#include "Poco/Process_VMS.h"
#endif
@@ -56,28 +54,28 @@ public:
ProcessHandle(const ProcessHandle& handle);
/// Creates a ProcessHandle by copying another one.
~ProcessHandle();
/// Destroys the ProcessHandle.
ProcessHandle& operator = (const ProcessHandle& handle);
/// Assigns another handle.
PID id() const;
/// Returns the process ID.
int wait() const;
/// Waits for the process to terminate
/// and returns the exit code of the process.
protected:
ProcessHandle(ProcessHandleImpl* pImpl);
private:
ProcessHandle();
ProcessHandleImpl* _pImpl;
friend class Process;
};
@@ -89,22 +87,22 @@ public:
typedef PIDImpl PID;
typedef ArgsImpl Args;
typedef EnvImpl Env;
static PID id();
/// Returns the process ID of the current process.
static void times(long& userTime, long& kernelTime);
/// Returns the number of seconds spent by the
/// current process in user and kernel mode.
static ProcessHandle launch(const std::string& command, const Args& args);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
/// passed to the command on the command line.
static ProcessHandle launch(
const std::string& command,
const Args& args,
const std::string& command,
const Args& args,
const std::string& initialDirectory);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
@@ -112,10 +110,10 @@ public:
/// The process starts executing in the specified initial directory.
static ProcessHandle launch(
const std::string& command,
const Args& args,
Pipe* inPipe,
Pipe* outPipe,
const std::string& command,
const Args& args,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
@@ -144,11 +142,11 @@ public:
/// int rc = ph.wait();
static ProcessHandle launch(
const std::string& command,
const Args& args,
const std::string& command,
const Args& args,
const std::string& initialDirectory,
Pipe* inPipe,
Pipe* outPipe,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe);
/// Creates a new process for the given command and returns
/// a ProcessHandle of the new process. The given arguments are
@@ -176,12 +174,12 @@ public:
/// PipeInputStream istr(outPipe);
/// ... // read output of ps from istr
/// int rc = ph.wait();
static ProcessHandle launch(
const std::string& command,
const Args& args,
Pipe* inPipe,
Pipe* outPipe,
const std::string& command,
const Args& args,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe,
const Env& env);
/// Creates a new process for the given command and returns
@@ -195,11 +193,11 @@ public:
/// The launched process is given the specified environment variables.
static ProcessHandle launch(
const std::string& command,
const Args& args,
const std::string& command,
const Args& args,
const std::string& initialDirectory,
Pipe* inPipe,
Pipe* outPipe,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe,
const Env& env);
/// Creates a new process for the given command and returns
@@ -214,7 +212,7 @@ public:
static int wait(const ProcessHandle& handle);
/// Waits for the process specified by handle to terminate
/// and returns the exit code of the process.
static bool isRunning(const ProcessHandle& handle);
/// check if the process specified by handle is running or not
///
@@ -223,7 +221,7 @@ public:
static bool isRunning(PID pid);
/// Check if the process specified by given pid is running or not.
static void kill(ProcessHandle& handle);
/// Kills the process specified by handle.
///
@@ -232,7 +230,7 @@ public:
static void kill(PID pid);
/// Kills the process with the given pid.
static void requestTermination(PID pid);
/// Requests termination of the process with the give PID.
///
@@ -240,7 +238,7 @@ public:
/// process and thus work with arbitrary processes.
///
/// On other platforms, a global event flag
/// will be set. Setting the flag will cause
/// will be set. Setting the flag will cause
/// Util::ServerApplication::waitForTerminationRequest() to
/// return. Therefore this will only work with applications
/// based on Util::ServerApplication.
@@ -255,7 +253,7 @@ inline Process::PID Process::id()
return ProcessImpl::idImpl();
}
inline void Process::times(long& userTime, long& kernelTime)
{
ProcessImpl::timesImpl(userTime, kernelTime);

77
Foundation/include/Poco/Process_VMS.h
View File

@@ -1,77 +0,0 @@
//
// Process_VMS.h
//
// Library: Foundation
// Package: Processes
// Module: Process
//
// Definition of the ProcessImpl class for OpenVMS.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_Process_VMS_INCLUDED
#define Foundation_Process_VMS_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/RefCountedObject.h"
#include <vector>
#include <map>
#include <unistd.h>
namespace Poco {
class Pipe;
class ProcessHandleImpl: public RefCountedObject
{
public:
ProcessHandleImpl(pid_t pid);
~ProcessHandleImpl();
pid_t id() const;
int wait() const;
private:
pid_t _pid;
};
class ProcessImpl
{
public:
typedef pid_t PIDImpl;
typedef std::vector<std::string> ArgsImpl;
typedef std::map<std::string, std::string> EnvImpl;
static PIDImpl idImpl();
static void timesImpl(long& userTime, long& kernelTime);
static ProcessHandleImpl* launchImpl(
const std::string& command,
const ArgsImpl& args,
const std::string& initialDirectory,
Pipe* inPipe,
Pipe* outPipe,
Pipe* errPipe,
const EnvImpl& env);
static int waitImpl(PIDImpl pid);
static void killImpl(ProcessHandleImpl& handle);
static void killImpl(PIDImpl pid);
static bool isRunningImpl(const ProcessHandleImpl& handle);
static bool isRunningImpl(PIDImpl pid);
static void requestTerminationImpl(PIDImpl pid);
};
} // namespace Poco
#endif // Foundation_Process_VMS_INCLUDED

22
Foundation/include/Poco/SharedLibrary.h
View File

@@ -31,8 +31,6 @@
#include "Poco/SharedLibrary_WIN32U.h"
#elif defined(POCO_OS_FAMILY_WINDOWS)
#include "Poco/SharedLibrary_WIN32.h"
#elif defined(POCO_OS_FAMILY_VMS)
#include "Poco/SharedLibrary_VMS.h"
#endif
@@ -40,7 +38,7 @@ namespace Poco {
class Foundation_API SharedLibrary: private SharedLibraryImpl
/// The SharedLibrary class dynamically
/// The SharedLibrary class dynamically
/// loads shared libraries at run-time.
{
public:
@@ -52,7 +50,7 @@ public:
///
/// This flag is ignored on platforms that do not use dlopen().
SHLIB_LOCAL = 2
SHLIB_LOCAL = 2
/// On platforms that use dlopen(), use RTLD_LOCAL instead of RTLD_GLOBAL.
///
/// Note that if this flag is specified, RTTI (including dynamic_cast and throw) will
@@ -61,17 +59,17 @@ public:
///
/// This flag is ignored on platforms that do not use dlopen().
};
SharedLibrary();
/// Creates a SharedLibrary object.
SharedLibrary(const std::string& path);
/// Creates a SharedLibrary object and loads a library
/// from the given path.
SharedLibrary(const std::string& path, int flags);
/// Creates a SharedLibrary object and loads a library
/// from the given path, using the given flags.
/// from the given path, using the given flags.
/// See the Flags enumeration for valid values.
virtual ~SharedLibrary();
@@ -110,20 +108,20 @@ public:
/// is the entry point of the function.
/// Throws a NotFoundException if the symbol
/// does not exist.
const std::string& getPath() const;
/// Returns the path of the library, as
/// specified in a call to load() or the
/// specified in a call to load() or the
/// constructor.
static std::string suffix();
/// Returns the platform-specific filename suffix
/// for shared libraries (including the period).
/// In debug mode, the suffix also includes a
/// "d" to specify the debug version of a library
/// (e.g., "d.so", "d.dll") unless the library has
/// (e.g., "d.so", "d.dll") unless the library has
/// been compiled with -DPOCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX.
private:
SharedLibrary(const SharedLibrary&);
SharedLibrary& operator = (const SharedLibrary&);

49
Foundation/include/Poco/SharedLibrary_VMS.h
View File

@@ -1,49 +0,0 @@
//
// SharedLibrary_VMS.h
//
// Library: Foundation
// Package: SharedLibrary
// Module: SharedLibrary
//
// Definition of the SharedLibraryImpl class for VMS (dlopen).
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_SharedLibrary_VMS_INCLUDED
#define Foundation_SharedLibrary_VMS_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/Mutex.h"
namespace Poco {
class Foundation_API SharedLibraryImpl
{
protected:
SharedLibraryImpl();
~SharedLibraryImpl();
void loadImpl(const std::string& path, int flags);
void unloadImpl();
bool isLoadedImpl() const;
void* findSymbolImpl(const std::string& name);
const std::string& getPathImpl() const;
static std::string suffixImpl();
private:
std::string _path;
static FastMutex _mutex;
};
} // namespace Poco
#endif // Foundation_SharedLibrary_VMS_INCLUDED

23
Foundation/include/Poco/Types.h
View File

@@ -87,21 +87,10 @@ namespace Poco {
typedef unsigned int UInt32;
typedef signed __int64 Int64;
typedef unsigned __int64 UInt64;
#if defined(__VMS)
#if defined(__32BITS)
typedef signed long IntPtr;
typedef unsigned long UIntPtr;
#else
typedef Int64 IntPtr;
typedef UInt64 UIntPtr;
#define POCO_PTR_IS_64_BIT 1
#endif
#else
typedef signed long IntPtr;
typedef unsigned long UIntPtr;
#define POCO_PTR_IS_64_BIT 1
#define POCO_LONG_IS_64_BIT 1
#endif
typedef signed long IntPtr;
typedef unsigned long UIntPtr;
#define POCO_PTR_IS_64_BIT 1
#define POCO_LONG_IS_64_BIT 1
#define POCO_HAVE_INT64 1
#elif defined(__HP_aCC)
//
@@ -147,7 +136,7 @@ namespace Poco {
typedef unsigned long long UInt64;
#endif
#define POCO_HAVE_INT64 1
#elif defined(__IBMCPP__)
#elif defined(__IBMCPP__)
//
// IBM XL C++
//
@@ -169,7 +158,7 @@ namespace Poco {
typedef unsigned long long UInt64;
#endif
#define POCO_HAVE_INT64 1
#elif defined(__sgi)
#elif defined(__sgi)
//
// MIPSpro C++
//