求大姐姐帮小弟调试上上面这个程序，原始程序小弟我打包

求各位大哥大姐姐帮小弟调试下下面这个程序，原始程序我打包
下面这个程序在调试的时候有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


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