求各位大哥大姐姐帮小弟调试下下面这个程序，原始程序我打包
下面这个程序在调试的时候有102处错误，这个程序的环境我都搭建不起来，呜呜
整个原代码需要的联系我QQ415632971（验证信息 陈兵）
急。。。。。。。。。。，急。。。。。。。。。。。。











/*
* Copyright 2001 Borland Software Corporation, Inc.
*
* GENERATED CODE --- DO NOT EDIT
*
*/

#ifndef __BASE_IDL___client
#define __BASE_IDL___client


#ifndef _corba_h_
# ifndef _VIS_INCLUDE_IR
# define _VIS_INCLUDE_IR
# endif // _VIS_INCLUDE_IR

#endif // _corba_h_

class DEF {
public:
enum VARTYPE {
VT_NULL,
VT_BOOL,
VT_R4
};

typedef VARTYPE& VARTYPE_out;

friend VISostream& operator<<(VISostream& _strm, const VARTYPE _enum_type);
friend VISistream& operator>>(VISistream& _strm, VARTYPE& _enum_type);

friend Ostream& operator<<(Ostream&, const VARTYPE&);
friend Istream& operator>>(Istream&, VARTYPE&);

friend void _pretty_print(VISostream& _strm, VARTYPE _val);

static ::CORBA::TypeCode_ptr _tc_VARTYPE;
static ::CORBA::TypeCode_ptr _tc_VARTYPE_get();

friend void operator<<=(::CORBA::Any&, const VARTYPE&);
friend ::CORBA::Boolean operator>>=(const ::CORBA::Any&, VARTYPE&);
// idl struct: DEF::VARIANT
struct VARIANT {

VARTYPE vt;
::CORBA::Short bVal;
::CORBA::Float fltVal;
#if defined(MSVCNEWDLL_BUG)
void *operator new(size_t ts);
void *operator new(size_t ts, char*, int) {return operator new(ts);}
void operator delete(void *p);
#endif // MSVCNEWDLL_BUG
friend VISostream& operator<<(VISostream&, const VARIANT&);
friend VISistream& operator>>(VISistream&, VARIANT&);

friend VISostream& operator<<(VISostream& _strm, const VARIANT* _obj);
friend VISistream& operator>>(VISistream& _strm, VARIANT*& _obj);

friend void _pretty_print(VISostream&, const VARIANT&);
friend Ostream& operator<<(Ostream&, const VARIANT&);
friend Istream& operator>>(Istream&, VARIANT&);
friend Istream& operator>>(Istream&, VARIANT*&);
};
typedef VARIANT * VARIANT_ptr;

static ::CORBA::TypeCode_ptr _tc_VARIANT;
static ::CORBA::TypeCode_ptr _tc_VARIANT_get();

friend void operator<<=(::CORBA::Any& _a, const VARIANT& _val);
friend ::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, VARIANT& _val);

class VARIANT_var {
private:
VARIANT_ptr _ptr;
public:
VARIANT_var() : _ptr((VARIANT*)NULL) {}
VARIANT_var(VARIANT *_p) : _ptr(_p) {}

VARIANT_var(const VARIANT_var& _var) {
_ptr = _var._ptr ? (new VARIANT(*_var._ptr)) : (VARIANT*)NULL;
}

virtual ~VARIANT_var() { delete _ptr; }
VARIANT_var& operator=(VARIANT* _p);
VARIANT_var& operator=(const VARIANT_var& _var);
operator VARIANT*() const { return _ptr; }

VARIANT* operator->() { return _ptr; }
const VARIANT* operator->() const { return _ptr; }

operator VARIANT&() { return *_ptr; }
operator const VARIANT&() const { return *_ptr; }

const VARIANT& in() const { return *_ptr; }

VARIANT& inout() { return *_ptr; }
VARIANT& out() { return *_ptr; }
VARIANT _retn() { return *_ptr; }
friend VISostream& operator<<(VISostream&, const VARIANT_var&);
friend VISistream& operator>>(VISistream&, VARIANT_var&);
};
typedef VARIANT& VARIANT_out;
class DataStream;
typedef DataStream* DataStream_ptr;

class DataStream : private VISResource {
private:
::CORBA::Octet *_contents;
::CORBA::ULong _count;
::CORBA::ULong _num_allocated;
::CORBA::Boolean _release_flag;

public:
#if defined(MSVCNEWDLL_BUG)
void *operator new(size_t ts);
void *operator new(size_t ts, char*, int) {return operator new(ts);}
void operator delete(void *p);
#endif // MSVCNEWDLL_BUG

static ::CORBA::Octet *allocbuf(::CORBA::ULong _nelems);
static void freebuf(::CORBA::Octet* _data);

DataStream(::CORBA::ULong _max = 0);
DataStream(::CORBA::ULong max, ::CORBA::ULong length,
::CORBA::Octet *_data,
::CORBA::Boolean release = (::CORBA::Boolean)0);
DataStream(const DataStream&);
virtual ~DataStream();

DataStream& operator=(const DataStream&);
DataStream& operator=(const DataStream* _obj) {
assert(_obj);
return operator=(*_obj);
}

::CORBA::ULong maximum() const { return _num_allocated; }

void length(::CORBA::ULong _len);
::CORBA::ULong length() const { return _count; }

void replace(::CORBA::ULong _max, ::CORBA::ULong _len,
::CORBA::Octet *_data,
::CORBA::Boolean _release = (::CORBA::Boolean)0);

::CORBA::Boolean _vis_release_flag () const { return _release_flag; }

::CORBA::Octet *get_buffer(::CORBA::Boolean orphan = (::CORBA::Boolean) 0);
const ::CORBA::Octet* get_buffer() const;

::CORBA::Octet& operator[](::CORBA::ULong _index);
const ::CORBA::Octet& operator[](::CORBA::ULong _index) const;

static DataStream *_duplicate(DataStream* _ptr) {
if (_ptr) _ptr->_ref();
return _ptr;
}

static void _release(DataStream *_ptr) {
if (_ptr && (_ptr->_deref() == 0L))
delete _ptr;
}

friend VISostream& operator<<(VISostream&, const DataStream&);
friend VISistream& operator>>(VISistream&, DataStream&);

friend VISostream& operator<<(VISostream& _strm, const DataStream* _obj);
friend VISistream& operator>>(VISistream& _strm, DataStream_ptr& _obj);

friend void _pretty_print(VISostream&, const DataStream&);

friend Ostream& operator<<(Ostream&, const DataStream&);
friend Istream& operator>>(Istream&, DataStream&);
friend Istream& operator>>(Istream&, DataStream_ptr&);
};

static ::CORBA::TypeCode_ptr _tc_DataStream;
static ::CORBA::TypeCode_ptr _tc_DataStream_get();

friend void operator<<=(::CORBA::Any& _a, const DataStream& _val);
friend ::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, DataStream& _val);
class DataStream_out;

class DataStream_var {
friend class DataStream_out;

private:
DataStream *_ptr;
public:
DataStream_var() : _ptr((DataStream*)NULL) {}
DataStream_var(DataStream *_p) : _ptr(_p) {}
DataStream_var(const DataStream_var& _var) :_ptr(DataStream::_duplicate(_var._ptr)){}
virtual ~DataStream_var() { DataStream::_release(_ptr); }
DataStream_var& operator=(DataStream* _p) {
DataStream::_release(_ptr);
_ptr = _p;
return *this;
}

DataStream_var& operator=(const DataStream_var& _var) {
DataStream::_release(_ptr);
_ptr = DataStream::_duplicate(_var._ptr);
return *this;
}
operator DataStream*() const { return _ptr; }

DataStream* operator->() { return _ptr; }
const DataStream* operator->() const { return _ptr; }

operator DataStream&() { return *_ptr; }
operator const DataStream&() const { return *_ptr; }

const DataStream& in() const { return *_ptr; }
DataStream& inout() { return *_ptr; }
DataStream_ptr & out() {
DataStream::_release(_ptr);
_ptr = (DataStream *)NULL;
return _ptr;
}

DataStream* _retn() {
DataStream* _tmp_ptr;
_tmp_ptr = _ptr;
_ptr = (DataStream *)NULL;
return _tmp_ptr;
}
friend VISostream& operator<<(VISostream&, const DataStream_var&);
friend VISistream& operator>>(VISistream&, DataStream_var&);

::CORBA::Octet& operator[](::CORBA::ULong _index);
const ::CORBA::Octet& operator[](::CORBA::ULong _index) const;

};
class DataStream_out {
private:
DataStream_ptr& _ptr;
static DataStream* _nil() { return (DataStream*)NULL; }

void operator=(const DataStream_out&);
void operator=(const DataStream_var&);
public:
DataStream_out(const DataStream_out& _o) : _ptr(_o._ptr) {}
DataStream_out(DataStream_ptr& _p) : _ptr(_p) {
_ptr = _nil();
}
DataStream_out(DataStream_var& _v) : _ptr(_v._ptr) {
_v = _nil();
}
DataStream_out& operator=(DataStream* _p) {
_ptr = _p;
return *this;
}
operator DataStream_ptr&() { return _ptr; }
DataStream_ptr& ptr() { return _ptr; }
DataStream* operator->() { return _ptr; }
};
// idl struct: DEF::DOT
struct DOT {

::CORBA::String_var sName;
VARIANT vValue;
::CORBA::Short iReserved1;
::CORBA::Short iReserved2;
::CORBA::Short iReserved3;
#if defined(MSVCNEWDLL_BUG)
void *operator new(size_t ts);
void *operator new(size_t ts, char*, int) {return operator new(ts);}
void operator delete(void *p);
#endif // MSVCNEWDLL_BUG


[解决办法]
你有什么编译环境？报告什么错误？错误不可怕只要报告就可以更改，你这么发帖什么问题都看不到，至少将主要错误类型粘贴上来，其他人才好帮助你