1553 lines
54 KiB
C++
1553 lines
54 KiB
C++
// Copyright (c) 1993-1999 Microsoft Corporation
|
||
|
||
#ifndef __CMDANA_HXX__
|
||
#define __CMDANA_HXX__
|
||
|
||
#include "common.hxx"
|
||
#include "errors.hxx"
|
||
#include <stream.hxx>
|
||
|
||
class ISTREAM;
|
||
|
||
enum _swenum
|
||
{
|
||
SWITCH_NOTHING
|
||
,BASE_FILENAME = SWITCH_NOTHING
|
||
,SWITCH_D
|
||
,SWITCH_I
|
||
,SWITCH_U
|
||
,SWITCH_W
|
||
,SWITCH_CONFIRM
|
||
,SWITCH_NOLOGO
|
||
,SWITCH_CPP_CMD
|
||
,SWITCH_CPP_OPT
|
||
,SWITCH_MSC_VER
|
||
,SWITCH_CSTUB
|
||
,SWITCH_ENV
|
||
,SWITCH_ERROR
|
||
,SWITCH_ROBUST
|
||
,SWITCH_NO_ROBUST
|
||
,SWITCH_HEADER
|
||
,SWITCH_NO_HEADER
|
||
,SWITCH_NO_CPP
|
||
,SWITCH_NO_DEF_IDIR
|
||
,SWITCH_NO_ENUM_LIT
|
||
,SWITCH_USE_EPV
|
||
,SWITCH_NO_DEFAULT_EPV
|
||
,SWITCH_NO_WARN
|
||
,SWITCH_OUT
|
||
,SWITCH_SSTUB
|
||
,SWITCH_STUB
|
||
,SWITCH_SYNTAX_CHECK
|
||
,SWITCH_TARGET_SYSTEM
|
||
,SWITCH_ZS
|
||
,SWITCH_V
|
||
,SWITCH_VERSION
|
||
,SWITCH_DEBUGEXC
|
||
,SWITCH_DEBUGLINE
|
||
,SWITCH_DEBUG64_OPT
|
||
,SWITCH_DEBUG64
|
||
,SWITCH_APPEND64
|
||
,SWITCH_ACF
|
||
,SWITCH_PACK
|
||
,SWITCH_ZP
|
||
,SWITCH_CLIENT
|
||
,SWITCH_NO_CLIENT
|
||
,SWITCH_SERVER
|
||
,SWITCH_NO_SERVER
|
||
,SWITCH_PREFIX
|
||
,SWITCH_SUFFIX
|
||
,SWITCH_DUMP
|
||
,SWITCH_SAVEPP
|
||
,SWITCH_CHAR
|
||
,SWITCH_HELP
|
||
,SWITCH_WX
|
||
,SWITCH_X
|
||
,SWITCH_MS_EXT
|
||
,SWITCH_MS_CONF_STRUCT
|
||
,SWITCH_APP_CONFIG
|
||
,SWITCH_INTERNAL
|
||
,SWITCH_NO_STAMP
|
||
,SWITCH_C_EXT
|
||
,SWITCH_O
|
||
// files for proxies
|
||
,SWITCH_IID
|
||
,SWITCH_NO_IID
|
||
,SWITCH_PROXY
|
||
,SWITCH_NO_PROXY
|
||
,SWITCH_PROXY_DEF
|
||
,SWITCH_NO_PROXY_DEF
|
||
,SWITCH_DLLDATA
|
||
,SWITCH_NO_DLLDATA
|
||
// files for inprocserver32s
|
||
,SWITCH_DLL_SERVER_DEF
|
||
,SWITCH_NO_DLL_SERVER_DEF
|
||
,SWITCH_DLL_SERVER_CLASS_GEN
|
||
,SWITCH_NO_DLL_SERVER_CLASS_GEN
|
||
// files for localserver32s
|
||
,SWITCH_EXE_SERVER_MAIN
|
||
,SWITCH_NO_EXE_SERVER_MAIN
|
||
,SWITCH_EXE_SERVER
|
||
,SWITCH_NO_EXE_SERVER
|
||
// files for both
|
||
,SWITCH_TESTCLIENT
|
||
,SWITCH_NO_TESTCLIENT
|
||
,SWITCH_SERVER_REG
|
||
,SWITCH_NO_SERVER_REG
|
||
// files for com class servers
|
||
,SWITCH_CLASS_METHODS
|
||
,SWITCH_NO_CLASS_METHODS
|
||
,SWITCH_CLASS_IUNKNOWN
|
||
,SWITCH_NO_CLASS_IUNKNOWN
|
||
,SWITCH_CLASS_HEADER
|
||
,SWITCH_NO_CLASS_HEADER
|
||
|
||
,SWITCH_MS_UNION
|
||
,SWITCH_OVERRIDE
|
||
,SWITCH_GUARD_DEFS
|
||
,SWITCH_OLDNAMES
|
||
,SWITCH_RPCSS
|
||
,SWITCH_NO_FMT_OPT
|
||
,SWITCH_OSF // disables setting /ms_ext and /c_ext as default
|
||
,SWITCH_HOOKOLE
|
||
,SWITCH_NETMON
|
||
,SWITCH_NETMON_STUB_OUTPUT_FILE
|
||
,SWITCH_NETMON_STUB_OBJ_OUTPUT_FILE
|
||
,SWITCH_VERSION_STAMP
|
||
|
||
// MKTYPLIB switches
|
||
,SWITCH_TLIB
|
||
,SWITCH_TLIB64
|
||
,SWITCH_REDIRECT_OUTPUT
|
||
,SWITCH_ODL_ENV
|
||
,SWITCH_MKTYPLIB
|
||
,SWITCH_OLD_TLB
|
||
,SWITCH_NEW_TLB
|
||
,SWITCH_LOCALE_ID
|
||
|
||
,SWITCH_NOREUSE_BUFFER
|
||
,SWITCH_USE_VT_INT_PTR
|
||
,SWITCH_NO_TLIB
|
||
|
||
,SWITCH_TRANSFER_SYNTAX
|
||
,SWITCH_MS_EXT64
|
||
|
||
,SWITCH_DEBUGINFO
|
||
|
||
,SWITCH_WIRE_COMPAT
|
||
|
||
//
|
||
// enter all new switches before this label
|
||
//
|
||
,SW_VALUE_MAX
|
||
};
|
||
|
||
/*** client : can take values "stub", "none" ***/
|
||
|
||
#define CLNT_STUB (0x0)
|
||
#define CLNT_NONE (0x2)
|
||
|
||
/*** server : can take values "stub", "none" ***/
|
||
|
||
#define SRVR_STUB (0x0)
|
||
#define SRVR_NONE (0x2)
|
||
|
||
/** env switch values **/
|
||
|
||
#define ENV_WIN32 (0x4)
|
||
#define ENV_WIN64 (0x20)
|
||
#define ENV_OBSOLETE (0)
|
||
|
||
/** targeted system switch values **/
|
||
|
||
typedef enum _target_enum
|
||
{
|
||
NOTARGET = 0,
|
||
NT40 = 40,
|
||
NT50 = 50,
|
||
NT51 = 51
|
||
} TARGET_ENUM;
|
||
|
||
|
||
#define DEFAULT_ZEEPEE (8)
|
||
|
||
/** error switch values **/
|
||
|
||
#define ERROR_NONE (0x0000)
|
||
#define ERROR_BOUNDS_CHECK (0x0001)
|
||
#define ERROR_ENUM (0x0002)
|
||
#define ERROR_ALLOCATION (0x0004)
|
||
#define ERROR_REF (0x0008)
|
||
#define ERROR_STUB_DATA (0x0010)
|
||
|
||
#define ERROR_ALL (ERROR_BOUNDS_CHECK | \
|
||
ERROR_ENUM | \
|
||
ERROR_ALLOCATION | \
|
||
ERROR_REF | \
|
||
ERROR_STUB_DATA \
|
||
)
|
||
|
||
/** char switch values **/
|
||
|
||
#define CHAR_SIGNED (0x1)
|
||
#define CHAR_UNSIGNED (0x2)
|
||
#define CHAR_ANSI7 (0x3)
|
||
|
||
/** rpc ss allocate **/
|
||
|
||
#define RPC_SS_ALLOCATE_DISABLED (0x0)
|
||
#define RPC_SS_ALLOCATE_ENABLED (0x1)
|
||
|
||
/** manifests defining prefix arguments **/
|
||
|
||
#define PREFIX_CLIENT_STUB (0x0)
|
||
#define PREFIX_SERVER_MGR (0x1)
|
||
#define PREFIX_SWICH_PROTOTYPE (0x2)
|
||
#define PREFIX_ALL (0x3)
|
||
|
||
/** wire compatibility options (allocated as bitfields) **/
|
||
|
||
#define WIRE_COMPAT_ENUM16UNIONALIGN (0x0001)
|
||
|
||
|
||
/*****************************************************************************
|
||
* some data structures used.
|
||
*****************************************************************************/
|
||
|
||
// basically a singly linked list implementation,
|
||
// used for switches which can be specified multiply like -D / -I etc
|
||
|
||
typedef struct _optlist
|
||
{
|
||
char * pStr; // pointer to argument string
|
||
struct _optlist * pNext; // pointer to the next argument
|
||
size_t ActualOffset;
|
||
bool NeedsQuotes;
|
||
} OptList;
|
||
|
||
|
||
/*****************************************************************************
|
||
* class defintions used by the command analyser.
|
||
*****************************************************************************/
|
||
//
|
||
// the multiple occurence switch class
|
||
// This class of switches are ones which can be specified multiple times
|
||
// on the command line. Examples of such switches are -D / -U <20>/ -I etc
|
||
// This switch really keeps a linked list of all arguments specified for
|
||
// the switch.
|
||
//
|
||
|
||
class multiple_switch
|
||
{
|
||
private:
|
||
OptList * pFirst, // first of the list of arguments.
|
||
* pCurrent; // current in the scan of list of args.
|
||
public:
|
||
|
||
// constructor
|
||
multiple_switch( ) : pFirst(NULL), pCurrent(NULL) {};
|
||
multiple_switch( char *pArg, size_t ActualOffset );
|
||
|
||
// add the arguments of another occurence of this switch
|
||
|
||
void Add( char *, size_t ActualOffset );
|
||
|
||
// initialise the scan of the list. Called before any GetNextIsDone
|
||
|
||
void Init();
|
||
|
||
// Get the argument to the next occurence of the switch
|
||
|
||
char * GetNext( size_t *pActualOffset = NULL, bool *pNeedQuotes = NULL );
|
||
|
||
// Collect all the arguments into a buffer
|
||
|
||
char * GetConsolidatedOptions( bool NeedsQuotes = false );
|
||
|
||
// return the length of all the arguments. Generally used to allocate
|
||
// a buffer size for a GetConsolidatedOptions call.
|
||
|
||
short GetConsolidatedLength( bool NeedsQuotes = false );
|
||
|
||
void StreamIn( char*& );
|
||
void StreamOut( STREAM* );
|
||
};
|
||
|
||
|
||
//
|
||
// the onetime_switch class.
|
||
// such a switch can occur only once, and takes just one argument. We need
|
||
// to hold on to the argument during compilation.
|
||
//
|
||
|
||
class onetime_switch
|
||
{
|
||
char * pOpt; // the user argument
|
||
|
||
public:
|
||
|
||
// the constructor.
|
||
|
||
onetime_switch(
|
||
char * pArg = 0 // argument to switch
|
||
);
|
||
|
||
// the destructor
|
||
|
||
~onetime_switch();
|
||
|
||
// get the user option
|
||
|
||
char * GetOption();
|
||
|
||
// get length of the user option string
|
||
|
||
short GetLength();
|
||
|
||
void StreamIn( char*& pBuffer );
|
||
void StreamOut( STREAM* );
|
||
};
|
||
|
||
|
||
//
|
||
// the filename_switch
|
||
//
|
||
// There are a lot of switches which have filenames as arguments. This
|
||
// class exists to ease processing of such switches, all of whom behave more
|
||
// or less the same way. Only the -out switch is a little different.
|
||
// We need to access the filename components too, so we store both as
|
||
// components and as the full name.
|
||
//
|
||
|
||
class filename_switch
|
||
{
|
||
private:
|
||
char * pFullName;
|
||
public:
|
||
|
||
// the constructor. Takes an argument as the switch it is defining, so that
|
||
// it can check for a redef.
|
||
|
||
filename_switch(
|
||
char * pThisArg = 0 // this argument is supplied
|
||
);
|
||
|
||
// the constructor. It takes a set of filename components. This is not
|
||
// called as a result of a user switch, but by internal routines which
|
||
// do not need to check for duplicate definitions.
|
||
|
||
filename_switch(
|
||
char * pD, // drive
|
||
char * pP, // path
|
||
char * pN, // base name
|
||
char * pE, // extension
|
||
char * pS // suffix ("_c/_s") etc to name
|
||
// etc.
|
||
);
|
||
|
||
// the destructor
|
||
|
||
~filename_switch();
|
||
|
||
// Set file name components , given a full name.
|
||
|
||
void SetFileName(
|
||
char * pName // full name
|
||
);
|
||
|
||
// set file name and components, given the components. Note that some
|
||
// components may be null, indicating that they are absent.
|
||
|
||
void SetFileName(
|
||
char * pD, // drive
|
||
char * pP, // path
|
||
char * pN, // base name
|
||
char * pE, // extension
|
||
char * pS // suffix to name
|
||
);
|
||
|
||
// the the full filename
|
||
|
||
char * GetFileName( void );
|
||
|
||
// Get the file name components. If an input pointer is NULL, it means the
|
||
// user is not interested in that component of the filename.
|
||
|
||
void GetFileNameComponents(
|
||
char * pD, // buffer for drive
|
||
char * pP, // buffer for path
|
||
char * pN, // buffer for name
|
||
char * pE // buffer for ext
|
||
);
|
||
|
||
void TransformFileNameForOut(
|
||
char * pD, // drive
|
||
char * pP // path
|
||
);
|
||
|
||
void StreamIn( char*& pBuffer );
|
||
void StreamOut( STREAM* );
|
||
};
|
||
|
||
// This data structure is used for specifying data for switches which can take
|
||
// different user specification, eg -mode ( osf | msft | c_port ) etc.
|
||
|
||
typedef struct _choice
|
||
{
|
||
const char * pChoice; // user input
|
||
short Choice; // internal compiler code.
|
||
} CHOICE;
|
||
|
||
class CommandLine;
|
||
// this data structure is for paired items, like prefix
|
||
class pair_switch
|
||
{
|
||
private:
|
||
CHOICE * pArrayOfChoices;
|
||
char ** pUserStrings;
|
||
long ArraySize;
|
||
|
||
short Current;
|
||
|
||
public:
|
||
// get the index of a particular system string
|
||
short GetIndex( char * pSys );
|
||
|
||
// constructor
|
||
|
||
pair_switch( const CHOICE * pValidChoices );
|
||
|
||
// construction functions
|
||
|
||
// void CmdProcess( CommandLine*, char *pF);
|
||
|
||
void AddPair( short index, char * pUser );
|
||
|
||
// get the user defined equivalent of this system defined prefix string
|
||
|
||
char * GetUserDefinedEquivalent( short );
|
||
|
||
// iteration functions ( for printout )
|
||
void Init()
|
||
{
|
||
Current = -1;
|
||
}
|
||
|
||
short GetNext( char ** pSys, char ** pUser );
|
||
|
||
void StreamIn( char*& );
|
||
void StreamOut( STREAM* );
|
||
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
//
|
||
// Class for Ndr stub version control
|
||
// - what compiler guesses from the usage.
|
||
//
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
|
||
class NdrVersionControl
|
||
{
|
||
// NT 3.51 or Win95
|
||
// VTable size limit is 32
|
||
unsigned long fHasStublessProxies : 1;
|
||
unsigned long fHasCommFaultStatusInOi12 : 1;
|
||
// NT 4.0 or DCOM Win95
|
||
unsigned long fHasOi2 : 1;
|
||
unsigned long fHasUserMarshal : 1;
|
||
unsigned long fHasRawPipes : 1;
|
||
unsigned long fHasFloatOrDoubleInOi : 1;
|
||
unsigned long fHasMoreThan64DelegatedProcs : 1;
|
||
unsigned long fHasNT4VTableSize : 1; // 110 methods
|
||
// NT 4.0 + SP3
|
||
unsigned long fHasMessageAttr : 1;
|
||
unsigned long fHasNT43VTableSize : 1; // 512 methods
|
||
// NT 5.0
|
||
// fHasObjectPipes // revoked later.
|
||
unsigned long fHasAsyncHandleRpc : 1;
|
||
unsigned long fHasNT5VTableSize : 1; // 1024 methods
|
||
// NT 5.0 Beta 2
|
||
unsigned long fHasDOA : 1;
|
||
unsigned long fHasAsyncUUID : 1;
|
||
unsigned long fHasInterpretedNotify : 1;
|
||
unsigned long fHasContextSerialization : 1;
|
||
// Unlimited number of methods
|
||
// NT 5.0 Beta 3
|
||
unsigned long fHasOicfPickling : 1;
|
||
|
||
// NT 6.0
|
||
unsigned long f64BitSupport : 1;
|
||
unsigned long fHasStructPadN : 1;
|
||
unsigned long fMultiTransferSyntax : 1;
|
||
unsigned long fHasMsExt64 : 1;
|
||
unsigned long fHasPartialIgnore : 1;
|
||
unsigned long fHasForceAllocate : 1;
|
||
unsigned long fInterpretedComplexReturns : 1;
|
||
|
||
unsigned long Unused : 8;
|
||
|
||
TARGET_ENUM TargetSystem;
|
||
|
||
public:
|
||
NdrVersionControl()
|
||
{
|
||
ClearNdrVersionControl();
|
||
}
|
||
|
||
void SetHasStublessProxies()
|
||
{
|
||
fHasStublessProxies = 1;
|
||
}
|
||
|
||
unsigned long HasStublessProxies()
|
||
{
|
||
return fHasStublessProxies;
|
||
}
|
||
|
||
void SetHasOi2()
|
||
{
|
||
fHasOi2 = 1;
|
||
}
|
||
|
||
unsigned long HasOi2()
|
||
{
|
||
return fHasOi2;
|
||
}
|
||
|
||
void SetHasUserMarshal()
|
||
{
|
||
fHasUserMarshal = 1;
|
||
}
|
||
|
||
unsigned long HasUserMarshal()
|
||
{
|
||
return fHasUserMarshal;
|
||
}
|
||
|
||
void SetHasRawPipes()
|
||
{
|
||
fHasRawPipes = 1;
|
||
}
|
||
|
||
unsigned long HasRawPipes()
|
||
{
|
||
return fHasRawPipes;
|
||
}
|
||
|
||
void SetHasMessageAttr()
|
||
{
|
||
fHasMessageAttr = 1;
|
||
}
|
||
|
||
unsigned long HasMessageAttr()
|
||
{
|
||
return fHasMessageAttr;
|
||
}
|
||
|
||
void SetHasAsyncHandleRpc()
|
||
{
|
||
fHasAsyncHandleRpc = 1;
|
||
}
|
||
|
||
unsigned long HasAsyncHandleRpc()
|
||
{
|
||
return fHasAsyncHandleRpc;
|
||
}
|
||
|
||
void SetHasMoreThan64DelegatedProcs()
|
||
{
|
||
fHasMoreThan64DelegatedProcs = 1;
|
||
}
|
||
|
||
unsigned long HasMoreThan64DelegatedProcs()
|
||
{
|
||
return fHasMoreThan64DelegatedProcs;
|
||
}
|
||
|
||
void SetHasNT4VTableSize()
|
||
{
|
||
fHasNT4VTableSize = 1;
|
||
}
|
||
|
||
unsigned long HasNT4VTableSize()
|
||
{
|
||
return fHasNT4VTableSize;
|
||
}
|
||
|
||
void SetHasNT43VTableSize()
|
||
{
|
||
fHasNT43VTableSize = 1;
|
||
}
|
||
|
||
unsigned long HasNT43VTableSize()
|
||
{
|
||
return fHasNT43VTableSize;
|
||
}
|
||
|
||
void SetHasNT5VTableSize()
|
||
{
|
||
fHasNT5VTableSize = 1;
|
||
}
|
||
|
||
unsigned long HasNT5VTableSize()
|
||
{
|
||
return fHasNT5VTableSize;
|
||
}
|
||
|
||
void SetHasFloatOrDoubleInOi()
|
||
{
|
||
fHasFloatOrDoubleInOi = 1;
|
||
}
|
||
|
||
unsigned long HasFloatOrDoubleInOi()
|
||
{
|
||
return fHasFloatOrDoubleInOi;
|
||
}
|
||
|
||
void SetHasCommFaultStatusInOi12()
|
||
{
|
||
fHasCommFaultStatusInOi12 = 1;
|
||
}
|
||
|
||
unsigned long HasCommFaultStatusInOi12()
|
||
{
|
||
return fHasCommFaultStatusInOi12;
|
||
}
|
||
|
||
void SetHasDOA()
|
||
{
|
||
fHasDOA = 1;
|
||
}
|
||
|
||
unsigned long HasDOA()
|
||
{
|
||
return fHasDOA;
|
||
}
|
||
|
||
void SetHasAsyncUUID()
|
||
{
|
||
fHasAsyncUUID = 1;
|
||
}
|
||
|
||
unsigned long HasAsyncUUID()
|
||
{
|
||
return fHasAsyncUUID;
|
||
}
|
||
|
||
void SetHasInterpretedNotify()
|
||
{
|
||
fHasInterpretedNotify = 1;
|
||
}
|
||
|
||
unsigned long HasInterpretedNotify()
|
||
{
|
||
return fHasInterpretedNotify;
|
||
}
|
||
|
||
void SetHasContextSerialization()
|
||
{
|
||
fHasContextSerialization = 1;
|
||
}
|
||
|
||
unsigned long HasContextSerialization()
|
||
{
|
||
return fHasContextSerialization;
|
||
}
|
||
|
||
void SetHasOicfPickling()
|
||
{
|
||
fHasOicfPickling = 1;
|
||
}
|
||
|
||
unsigned long HasOicfPickling()
|
||
{
|
||
return fHasOicfPickling;
|
||
}
|
||
|
||
void SetHas64BitSupport()
|
||
{
|
||
f64BitSupport = 1;
|
||
}
|
||
|
||
unsigned long Has64BitSupport()
|
||
{
|
||
return f64BitSupport;
|
||
}
|
||
|
||
void SetHasStructPadN()
|
||
{
|
||
fHasStructPadN = 1;
|
||
}
|
||
|
||
unsigned long HasStructPadN()
|
||
{
|
||
return fHasStructPadN;
|
||
}
|
||
|
||
void SetHasMultiTransferSyntax()
|
||
{
|
||
fMultiTransferSyntax = 1;
|
||
}
|
||
|
||
unsigned long HasMultiTransferSyntax()
|
||
{
|
||
return fMultiTransferSyntax;
|
||
}
|
||
|
||
void SetHasMsExt64()
|
||
{
|
||
fHasMsExt64 = 1;
|
||
}
|
||
|
||
unsigned long HasMsExt64()
|
||
{
|
||
return fHasMsExt64;
|
||
}
|
||
|
||
void SetHasPartialIgnore()
|
||
{
|
||
fHasPartialIgnore = 1;
|
||
}
|
||
|
||
unsigned long HasPartialIgnore()
|
||
{
|
||
return fHasPartialIgnore;
|
||
}
|
||
|
||
void SetHasForceAllocate()
|
||
{
|
||
fHasForceAllocate = 1;
|
||
}
|
||
|
||
unsigned long HasForceAllocate()
|
||
{
|
||
return fHasForceAllocate;
|
||
}
|
||
|
||
void ClearNdrVersionControl()
|
||
{
|
||
fHasStublessProxies = 0;
|
||
fHasCommFaultStatusInOi12 = 0;
|
||
fHasOi2 = 0;
|
||
fHasUserMarshal = 0;
|
||
fHasRawPipes = 0;
|
||
fHasFloatOrDoubleInOi = 0;
|
||
fHasMessageAttr = 0;
|
||
fHasMoreThan64DelegatedProcs = 0;
|
||
fHasAsyncHandleRpc = 0;
|
||
fHasNT4VTableSize = 0;
|
||
fHasNT43VTableSize = 0;
|
||
fHasNT5VTableSize = 0;
|
||
fHasDOA = 0;
|
||
fHasAsyncUUID = 0;
|
||
fHasInterpretedNotify = 0;
|
||
fHasContextSerialization = 0;
|
||
fHasOicfPickling = 0;
|
||
f64BitSupport = 0;
|
||
fHasStructPadN = 0;
|
||
fMultiTransferSyntax = 0;
|
||
fHasMsExt64 = 0;
|
||
fHasForceAllocate = 0;
|
||
fHasPartialIgnore = 0;
|
||
Unused = 0;
|
||
TargetSystem = NOTARGET;
|
||
}
|
||
|
||
void AddtoNdrVersionControl(
|
||
NdrVersionControl & VC )
|
||
{
|
||
fHasStublessProxies |= VC.HasStublessProxies();
|
||
fHasCommFaultStatusInOi12 |= VC.HasCommFaultStatusInOi12();
|
||
fHasOi2 |= VC.HasOi2();
|
||
fHasUserMarshal |= VC.HasUserMarshal();
|
||
fHasRawPipes |= VC.HasRawPipes();
|
||
fHasMoreThan64DelegatedProcs |= VC.HasMoreThan64DelegatedProcs();
|
||
fHasFloatOrDoubleInOi |= VC.HasFloatOrDoubleInOi();
|
||
fHasMessageAttr |= VC.HasMessageAttr();
|
||
fHasAsyncHandleRpc |= VC.HasAsyncHandleRpc();
|
||
fHasNT4VTableSize |= VC.HasNT4VTableSize();
|
||
fHasNT43VTableSize |= VC.HasNT43VTableSize();
|
||
fHasNT5VTableSize |= VC.HasNT5VTableSize();
|
||
fHasDOA |= VC.HasDOA();
|
||
fHasAsyncUUID |= VC.HasAsyncUUID();
|
||
fHasInterpretedNotify |= VC.HasInterpretedNotify();
|
||
fHasContextSerialization |= VC.HasContextSerialization();
|
||
fHasOicfPickling |= VC.HasOicfPickling();
|
||
f64BitSupport |= VC.Has64BitSupport();
|
||
fHasStructPadN |= VC.HasStructPadN();
|
||
fMultiTransferSyntax |= VC.HasMultiTransferSyntax();
|
||
fHasMsExt64 |= VC.HasMsExt64();
|
||
fHasForceAllocate |= VC.HasForceAllocate();
|
||
|
||
// REVIEW
|
||
if (VC.TargetSystem > TargetSystem)
|
||
TargetSystem = VC.TargetSystem;
|
||
}
|
||
|
||
BOOL HasNdr11Feature()
|
||
{
|
||
return ( fHasStublessProxies ||
|
||
fHasCommFaultStatusInOi12 );
|
||
}
|
||
|
||
BOOL HasNdr20Feature()
|
||
{
|
||
return ( fHasOi2 ||
|
||
fHasUserMarshal ||
|
||
fHasRawPipes ||
|
||
fHasMoreThan64DelegatedProcs ||
|
||
fHasFloatOrDoubleInOi ||
|
||
fHasMessageAttr ||
|
||
TargetSystem >= NT40 );
|
||
}
|
||
|
||
BOOL HasNdr50Feature()
|
||
{
|
||
return ( fHasAsyncHandleRpc ||
|
||
fHasDOA ||
|
||
fHasAsyncUUID ||
|
||
fHasInterpretedNotify ||
|
||
fHasContextSerialization ||
|
||
fHasOicfPickling ||
|
||
f64BitSupport ||
|
||
TargetSystem >= NT50 );
|
||
}
|
||
|
||
// Note, "ndr60" is kind of confusing. This is the
|
||
// version of ndr that shipped with NT 5.1
|
||
// (aka "Whistler").
|
||
|
||
BOOL HasNdr60Feature()
|
||
{
|
||
return HasStructPadN() ||
|
||
fMultiTransferSyntax ||
|
||
fHasMsExt64 ||
|
||
fHasForceAllocate ||
|
||
fHasPartialIgnore ||
|
||
TargetSystem >= NT51;
|
||
}
|
||
|
||
BOOL IsNdr60orLaterRequired()
|
||
{
|
||
return HasNdr60Feature();
|
||
}
|
||
|
||
BOOL IsNdr50orLaterRequired()
|
||
{
|
||
return HasNdr50Feature();
|
||
}
|
||
|
||
void SetTargetSystem( TARGET_ENUM target )
|
||
{
|
||
TargetSystem = target;
|
||
}
|
||
|
||
TARGET_ENUM GetTargetSystem()
|
||
{
|
||
return TargetSystem;
|
||
}
|
||
|
||
BOOL TargetIsNT40OrLater()
|
||
{
|
||
return (TargetSystem >= NT40);
|
||
}
|
||
|
||
BOOL TargetIsNT50OrLater()
|
||
{
|
||
return (TargetSystem >= NT50);
|
||
}
|
||
|
||
BOOL TargetIsLessThanNT50()
|
||
{
|
||
return ( NOTARGET != TargetSystem )
|
||
&& ( TargetSystem < NT50 );
|
||
}
|
||
|
||
BOOL TargetIsNT51OrLater()
|
||
{
|
||
return (TargetSystem >= NT51);
|
||
}
|
||
|
||
BOOL TargetIsLessThanNT51()
|
||
{
|
||
return ( NOTARGET != TargetSystem )
|
||
&& ( TargetSystem < NT51 );
|
||
}
|
||
|
||
BOOL AllowIntrepretedComplexReturns()
|
||
{
|
||
return HasMultiTransferSyntax();
|
||
}
|
||
};
|
||
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
// the big boy - the command analyser object
|
||
/////////////////////////////////////////////////////////////////////////////
|
||
|
||
typedef class _cmd_arg
|
||
{
|
||
protected:
|
||
unsigned long switch_def_vector[ 5 ]; // switch definition vector
|
||
unsigned char fClient; // client switch options
|
||
unsigned char fServer; // server switch options
|
||
unsigned char Env; // env - flat /segmented
|
||
unsigned char CharOption; // char option
|
||
unsigned char fMintRun; // this is a mint ( MIDL-lint) run
|
||
unsigned short MajorVersion; // major version
|
||
unsigned short MinorVersion; // minor version
|
||
unsigned short UpdateNumber; // update
|
||
unsigned short ErrorOption; // error option
|
||
unsigned short WireCompatOption; // wire_compat options
|
||
unsigned short ConfigMask; // configuration mask for error reporting
|
||
unsigned short MSCVersion; // MS C Compiler version
|
||
bool fShowLogo;
|
||
|
||
NdrVersionControl VersionControl; // compiler evaluation
|
||
|
||
unsigned short OptimFlags; // optimization flags from user
|
||
OPT_LEVEL_ENUM OptimLevel; // internal optimization level
|
||
TARGET_ENUM TargetSystem; // targeted system
|
||
SYNTAX_ENUM TargetSyntax;
|
||
|
||
short iArgV; // index into the argument vector
|
||
short cArgs; // count of arguments
|
||
|
||
short WLevel; // warning level
|
||
|
||
unsigned short ZeePee; // the Zp switch option value
|
||
unsigned short EnumSize; // memory size of enum16
|
||
unsigned long LocaleId; // the lcid for MBCS
|
||
|
||
BOOL fDoubleFor64; // double run marker
|
||
BOOL fHasAppend64; // the 64 append run
|
||
BOOL fIsNDR64Run; // NDR64 run
|
||
BOOL fIsNDRRun; // NDR run
|
||
BOOL fIs2ndCodegenRun; // protocol all
|
||
BOOL fNeedsNDR64Header; // protocol all, no -env, 32bit
|
||
|
||
char szCompileTime[32];
|
||
char szCompilerVersion[32];
|
||
|
||
filename_switch * pInputFNSwitch, // input file name
|
||
* pOutputPathSwitch, // output path
|
||
* pCStubSwitch, // cstub
|
||
* pSStubSwitch, // sstub
|
||
* pHeaderSwitch, // header
|
||
* pAcfSwitch, // acf
|
||
* pIIDSwitch, // iid
|
||
* pDllDataSwitch, // dlldata
|
||
* pProxySwitch, // proxy
|
||
* pProxyDefSwitch, // proxy
|
||
* pTlibSwitch, // Type Library file name
|
||
* pNetmonStubSwitch, // Netmon stub file
|
||
* pNetmonStubObjSwitch, // Netmon stub file
|
||
* pRedirectOutputSwitch; // redirect stdout to this file
|
||
|
||
pair_switch * pSwitchPrefix; // -prefix
|
||
pair_switch * pSwitchSuffix; // -suffix
|
||
|
||
multiple_switch * pDSwitch, // -D
|
||
* pISwitch, // -I
|
||
* pUSwitch; // -U
|
||
|
||
onetime_switch * pCppCmdSwitch, // cpp_cmd
|
||
* pCppOptSwitch, // cpp_opt
|
||
* pMSCVerSwitch, // msc_ver
|
||
* pDebug64Switch, // debug64
|
||
* pDebug64OptSwitch; // debug64_opt
|
||
|
||
public:
|
||
_cmd_arg();
|
||
|
||
// Is the switch defined ?
|
||
|
||
BOOL IsSwitchDefined( short SWNo )
|
||
{
|
||
unsigned long sw = switch_def_vector[ SWNo / 32 ];
|
||
unsigned long temp = SWNo % 32;
|
||
|
||
sw = sw & ( (unsigned long)1 << temp );
|
||
return sw ? (BOOL)1 : (BOOL)0;
|
||
}
|
||
|
||
// Set the switch to be defined.
|
||
void SwitchDefined( short );
|
||
|
||
// Get filename.
|
||
char * GetInputFileName()
|
||
{
|
||
return pInputFNSwitch->GetFileName();
|
||
}
|
||
|
||
void GetInputFileNameComponents(
|
||
char *pD, // drive buffer
|
||
char *pP, // path buffer
|
||
char *pN, // base name buffer
|
||
char *pE // extension buffer
|
||
)
|
||
{
|
||
pInputFNSwitch->GetFileNameComponents( pD,
|
||
pP,
|
||
pN,
|
||
pE );
|
||
}
|
||
|
||
char * GetAcfFileName()
|
||
{
|
||
return pAcfSwitch->GetFileName();
|
||
}
|
||
|
||
void GetAcfFileNameComponents(
|
||
char *pD,
|
||
char *pP,
|
||
char *pN,
|
||
char *pE )
|
||
{
|
||
pAcfSwitch->GetFileNameComponents( pD,
|
||
pP,
|
||
pN,
|
||
pE );
|
||
}
|
||
|
||
char * GetOutputPath();
|
||
|
||
char * GetCstubFName()
|
||
{
|
||
return pCStubSwitch->GetFileName();
|
||
}
|
||
|
||
void GetCstubFileNameComponents(
|
||
char *pD,
|
||
char *pP,
|
||
char *pN,
|
||
char *pE )
|
||
{
|
||
pCStubSwitch->GetFileNameComponents( pD,
|
||
pP,
|
||
pN,
|
||
pE );
|
||
}
|
||
|
||
char * GetSstubFName()
|
||
{
|
||
return pSStubSwitch->GetFileName();
|
||
}
|
||
|
||
void GetSstubFileNameComponents(
|
||
char *pD,
|
||
char *pP,
|
||
char *pN,
|
||
char *pE )
|
||
{
|
||
pSStubSwitch->GetFileNameComponents( pD,
|
||
pP,
|
||
pN,
|
||
pE );
|
||
}
|
||
|
||
char * GetHeader()
|
||
{
|
||
return pHeaderSwitch->GetFileName();
|
||
}
|
||
|
||
void GetHeaderFileNameComponents(
|
||
char *pD,
|
||
char *pP,
|
||
char *pN,
|
||
char *pE )
|
||
{
|
||
pHeaderSwitch->GetFileNameComponents( pD,
|
||
pP,
|
||
pN,
|
||
pE );
|
||
}
|
||
|
||
char * GetIIDFName()
|
||
{
|
||
return pIIDSwitch->GetFileName();
|
||
}
|
||
|
||
char * GetDllDataFName()
|
||
{
|
||
return pDllDataSwitch->GetFileName();
|
||
}
|
||
|
||
char * GetProxyFName()
|
||
{
|
||
return pProxySwitch->GetFileName();
|
||
}
|
||
|
||
char * GetTypeLibraryFName()
|
||
{
|
||
return pTlibSwitch->GetFileName();
|
||
}
|
||
|
||
char * GetNetmonStubFName()
|
||
{
|
||
return pNetmonStubSwitch->GetFileName();
|
||
}
|
||
|
||
char * GetNetmonStubObjFName()
|
||
{
|
||
return pNetmonStubObjSwitch->GetFileName();
|
||
}
|
||
|
||
// get preprocessor command
|
||
char * GetCPPCmd()
|
||
{
|
||
return pCppCmdSwitch->GetOption();
|
||
}
|
||
|
||
// get preprocessor options
|
||
char * GetCPPOpt()
|
||
{
|
||
return pCppOptSwitch->GetOption();
|
||
}
|
||
|
||
bool ShowLogo()
|
||
{
|
||
return fShowLogo;
|
||
}
|
||
|
||
unsigned short GetMSCVer()
|
||
{
|
||
return MSCVersion;
|
||
}
|
||
|
||
char * GetDebug64()
|
||
{
|
||
return pDebug64Switch->GetOption();
|
||
}
|
||
|
||
char * GetDebug64Opt()
|
||
{
|
||
return pDebug64OptSwitch->GetOption();
|
||
}
|
||
|
||
// get warning level
|
||
short GetWarningLevel() { return WLevel; };
|
||
|
||
// get env switch value
|
||
short GetEnv()
|
||
{
|
||
return (short)Env;
|
||
}
|
||
|
||
void SetEnv( int env )
|
||
{
|
||
Env = (unsigned char) env;
|
||
}
|
||
|
||
TARGET_ENUM GetTargetSystem()
|
||
{
|
||
return TargetSystem;
|
||
}
|
||
|
||
BOOL Is32BitEnv()
|
||
{
|
||
return (BOOL) (Env == ENV_WIN32);
|
||
}
|
||
|
||
BOOL Is32BitDefaultEnv()
|
||
{
|
||
return (BOOL) (Env == ENV_WIN32) &&
|
||
! IsSwitchDefined( SWITCH_ENV );
|
||
}
|
||
|
||
BOOL Is64BitEnv()
|
||
{
|
||
return (BOOL) (Env == ENV_WIN64);
|
||
}
|
||
|
||
BOOL IsDoubleRunFor64()
|
||
{
|
||
return fDoubleFor64;
|
||
}
|
||
|
||
void SetDoubleRunFor64()
|
||
{
|
||
fDoubleFor64 = HasAppend64();
|
||
}
|
||
|
||
BOOL HasAppend64()
|
||
{
|
||
return fHasAppend64;
|
||
}
|
||
|
||
void SetHasAppend64( BOOL NeedsAppending )
|
||
{
|
||
fHasAppend64 = NeedsAppending;
|
||
}
|
||
|
||
BOOL Needs64Run()
|
||
{
|
||
return fHasAppend64;
|
||
}
|
||
|
||
BOOL IsNDR64Run()
|
||
{
|
||
return fIsNDR64Run;
|
||
}
|
||
|
||
void SetIsNDR64Run()
|
||
{
|
||
fIsNDR64Run = TRUE;
|
||
}
|
||
|
||
void ResetIsNDR64Run()
|
||
{
|
||
fIsNDR64Run = FALSE;
|
||
}
|
||
|
||
BOOL IsNDRRun()
|
||
{
|
||
return fIsNDRRun;
|
||
}
|
||
|
||
void SetIsNDRRun()
|
||
{
|
||
fIsNDRRun = TRUE;
|
||
}
|
||
|
||
void ResetIsNDRRun()
|
||
{
|
||
fIsNDRRun = FALSE;
|
||
}
|
||
|
||
void SetIs2ndCodegenRun()
|
||
{
|
||
fIs2ndCodegenRun = TRUE;
|
||
}
|
||
|
||
BOOL Is2ndCodegenRun()
|
||
{
|
||
return fIs2ndCodegenRun;
|
||
}
|
||
|
||
BOOL NeedsNDR64Run()
|
||
{
|
||
if ( TargetSyntax == SYNTAX_BOTH ||
|
||
TargetSyntax == SYNTAX_NDR64 )
|
||
return TRUE;
|
||
else
|
||
return FALSE;
|
||
}
|
||
|
||
void SetNeedsNDR64Header()
|
||
{
|
||
fNeedsNDR64Header = TRUE;
|
||
}
|
||
|
||
BOOL NeedsNDR64Header()
|
||
{
|
||
return fNeedsNDR64Header;
|
||
}
|
||
|
||
BOOL IsFinalProtocolRun()
|
||
{
|
||
if ( SYNTAX_BOTH == TargetSyntax && !fIsNDR64Run )
|
||
return FALSE;
|
||
else
|
||
return TRUE;
|
||
}
|
||
|
||
// TODO: yongqu: might consider an compiler option.
|
||
SYNTAX_ENUM GetDefaultSyntax()
|
||
{
|
||
if ( TargetSyntax == SYNTAX_DCE ||
|
||
TargetSyntax == SYNTAX_BOTH )
|
||
return SYNTAX_DCE;
|
||
else
|
||
return SYNTAX_NDR64;
|
||
}
|
||
|
||
BOOL NeedsNDRRun()
|
||
{
|
||
if ( TargetSyntax == SYNTAX_BOTH ||
|
||
TargetSyntax == SYNTAX_DCE )
|
||
return TRUE;
|
||
else
|
||
return FALSE;
|
||
}
|
||
|
||
BOOL NeedsBothSyntaxes()
|
||
{
|
||
return ( TargetSyntax == SYNTAX_BOTH );
|
||
}
|
||
|
||
BOOL UseExprFormatString()
|
||
{
|
||
return IsNDR64Run();
|
||
}
|
||
|
||
BOOL NeedsNDR64DebugInfo()
|
||
{
|
||
return IsSwitchDefined(SWITCH_DEBUGINFO);
|
||
}
|
||
|
||
// get error options
|
||
short GetErrorOption()
|
||
{
|
||
return ErrorOption;
|
||
}
|
||
|
||
short WireCompat( short checkoption )
|
||
{
|
||
return WireCompatOption & checkoption;
|
||
}
|
||
|
||
// get the switch values
|
||
short GetClientSwitchValue()
|
||
{
|
||
return (short)fClient;
|
||
}
|
||
|
||
void SetClientSwitchValue( short s )
|
||
{
|
||
fClient = (unsigned char) s;
|
||
}
|
||
|
||
short GetServerSwitchValue()
|
||
{
|
||
return (short)fServer;
|
||
}
|
||
|
||
void SetServerSwitchValue( short s )
|
||
{
|
||
fServer = (unsigned char) s;
|
||
}
|
||
|
||
BOOL GenerateSStub()
|
||
{
|
||
return (fServer == SRVR_STUB) && !IsSwitchDefined( SWITCH_NO_SERVER );
|
||
}
|
||
|
||
BOOL GenerateCStub()
|
||
{
|
||
return (fClient == CLNT_STUB) && !IsSwitchDefined( SWITCH_NO_CLIENT );
|
||
}
|
||
|
||
BOOL GenerateStubs()
|
||
{
|
||
return GenerateSStub() || GenerateCStub();
|
||
}
|
||
|
||
BOOL GenerateHeader()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_HEADER );
|
||
}
|
||
|
||
BOOL GenerateIID()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_IID );
|
||
}
|
||
|
||
BOOL GenerateDllData()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_DLLDATA );
|
||
}
|
||
|
||
BOOL GenerateProxy()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_PROXY );
|
||
}
|
||
|
||
BOOL GenerateProxyDefFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_PROXY_DEF );
|
||
}
|
||
|
||
BOOL GenerateServerFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_CLASS_METHODS );
|
||
}
|
||
|
||
BOOL GenerateServerUnkFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_CLASS_IUNKNOWN );
|
||
}
|
||
|
||
BOOL GenerateServerHeaderFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_CLASS_HEADER );
|
||
}
|
||
|
||
BOOL GenerateDllServerDefFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_DLL_SERVER_DEF );
|
||
}
|
||
|
||
BOOL GenerateDllServerClassGenFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_DLL_SERVER_CLASS_GEN );
|
||
}
|
||
|
||
BOOL GenerateServerRegFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_SERVER_REG );
|
||
}
|
||
|
||
BOOL GenerateExeServerFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_EXE_SERVER );
|
||
}
|
||
|
||
BOOL GenerateExeServerMainFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_EXE_SERVER_MAIN );
|
||
}
|
||
|
||
BOOL GenerateTestFile()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_TESTCLIENT );
|
||
}
|
||
|
||
BOOL GenerateTypeLibrary()
|
||
{
|
||
return !IsSwitchDefined( SWITCH_NO_TLIB );
|
||
}
|
||
|
||
BOOL IsValidZeePee(long NewZeePee);
|
||
|
||
short GetZeePee()
|
||
{
|
||
return ZeePee;
|
||
}
|
||
|
||
unsigned short GetEnumSize()
|
||
{
|
||
return EnumSize;
|
||
}
|
||
|
||
void SetEnumSize(unsigned short sEnumSize)
|
||
{
|
||
EnumSize = sEnumSize;
|
||
}
|
||
|
||
unsigned long GetLocaleId()
|
||
{
|
||
return LocaleId;
|
||
}
|
||
|
||
void GetCompilerVersion(
|
||
unsigned short *pMajor,
|
||
unsigned short *pMinor,
|
||
unsigned short *pUpdate )
|
||
{
|
||
*pMajor = MajorVersion;
|
||
*pMinor = MinorVersion;
|
||
*pUpdate= UpdateNumber;
|
||
}
|
||
|
||
unsigned short GetOptimizationFlags()
|
||
{
|
||
// Don't propagate the optimize _IX flag out.
|
||
return (unsigned short) (OptimFlags & 0xff);
|
||
}
|
||
|
||
// destroys previous flags
|
||
unsigned short SetOptimizationFlags( unsigned short f )
|
||
{
|
||
return ( OptimFlags = f );
|
||
}
|
||
|
||
// preserves previous flags
|
||
unsigned short AddOptimizationFlags( unsigned short f )
|
||
{
|
||
return ( OptimFlags |= f );
|
||
}
|
||
|
||
OPT_LEVEL_ENUM GetOptimizationLevel()
|
||
{
|
||
return OptimLevel;
|
||
}
|
||
|
||
// miscellaneous flags
|
||
|
||
// get the minus I specified by the user as 1 single buffer. If the -i
|
||
// is not defined, return a null.
|
||
|
||
char * GetMinusISpecification();
|
||
|
||
BOOL IsMintRun()
|
||
{
|
||
return fMintRun;
|
||
}
|
||
|
||
unsigned short GetModeSwitchConfigMask()
|
||
{
|
||
return (unsigned short)ConfigMask;
|
||
}
|
||
|
||
void SetModeSwitchConfigMask()
|
||
{
|
||
unsigned short M = (unsigned short) ( IsSwitchDefined(SWITCH_MS_EXT) ?1:0 );
|
||
unsigned short C = (unsigned short) ( IsSwitchDefined(SWITCH_C_EXT) ?1:0 );
|
||
unsigned short A = (unsigned short) ( IsSwitchDefined(SWITCH_APP_CONFIG)?1:0 );
|
||
|
||
ConfigMask = unsigned short ( 1 << ( A * 4 + C * 2 + M ) );
|
||
}
|
||
|
||
unsigned short GetCharOption()
|
||
{
|
||
return (unsigned short)CharOption;
|
||
}
|
||
|
||
BOOL IsRpcSSAllocateEnabled()
|
||
{
|
||
return IsSwitchDefined( SWITCH_RPCSS );
|
||
}
|
||
|
||
BOOL IsNetmonStubGenerationEnabled()
|
||
{
|
||
return IsSwitchDefined( SWITCH_NETMON )
|
||
&& IsSwitchDefined( SWITCH_INTERNAL );
|
||
}
|
||
|
||
char * GetUserPrefix( short index )
|
||
{
|
||
return pSwitchPrefix->GetUserDefinedEquivalent( index );
|
||
}
|
||
|
||
BOOL IsPrefixDefinedForCStub()
|
||
{
|
||
return (BOOL)
|
||
( GetUserPrefix( PREFIX_CLIENT_STUB ) != 0 );
|
||
}
|
||
|
||
BOOL IsPrefixDefinedForSStub()
|
||
{
|
||
return (BOOL)
|
||
( GetUserPrefix( PREFIX_SERVER_MGR ) != 0 );
|
||
}
|
||
|
||
char* GetCompilerVersion()
|
||
{
|
||
return szCompilerVersion;
|
||
}
|
||
|
||
// note that this string ends with a newline.
|
||
char* GetCompileTime()
|
||
{
|
||
return szCompileTime;
|
||
}
|
||
|
||
BOOL IsPrefixDifferentForStubs();
|
||
void EmitConfirm( ISTREAM * pStream );
|
||
|
||
STATUS_T StreamIn( char* );
|
||
void StreamOut( STREAM* );
|
||
|
||
NdrVersionControl & GetNdrVersionControl()
|
||
{
|
||
return VersionControl;
|
||
}
|
||
} CMD_ARG;
|
||
|
||
typedef unsigned long ulong;
|
||
|
||
extern CMD_ARG* pCommand;
|
||
|
||
#endif // __CMDANA_HXX__
|