You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1554 lines
55 KiB
1554 lines
55 KiB
// 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 à/ -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 ||
|
|
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;
|
|
}
|
|
|
|
void VerifyTargetSwitch();
|
|
|
|
} CMD_ARG;
|
|
|
|
typedef unsigned long ulong;
|
|
|
|
extern CMD_ARG* pCommand;
|
|
|
|
#endif // __CMDANA_HXX__
|