[omniORB] idl compile error
Seong-Gu Kim
sgkim@comet.columbia.edu
Mon, 28 Sep 1998 01:01:23 -0400
This is a multi-part message in MIME format.
------=_NextPart_000_0079_01BDEA7B.831FFAB0
Content-Type: text/plain;
charset="euc-kr"
Content-Transfer-Encoding: 7bit
Hello there.
Currently, I am using omniORB2.5.0.
I would like to ask some question about the error when I compile idl with
omniORB. Now also I am attaching the all include files. If someone have good
idea for solving this problem, please teach me.
This file name is test.idl
//test.idl
#ifndef QOS_CONNECTION_MAN_IDL
#define QOS_CONNECTION_MAN_IDL
#include "common.idl"
#include "QOS.idl"
#include "EndPoint.idl"
#include "FBDefs.idl"
#include "FlowInfo.idl"
interface MobilityAgent {
...
BIBStatus refreshFlowBundle(in long fbi,
inout EndPointList host_A[2],
inout EndPointList host_B[2],
inout double msr_time) raises (Reject);
...
};
#endif
Here I am using array (host_A[2],host_B[2]), but it makes the error. I tried
to put in module for #include files. But it didn't work.
In EndPoint.idl, there are also arrays, which are in structures, but it is
fine.
Please teach me what is wrong.
--------------------------------------------------------------------------
Seong-Gu Kim sgkim@comet.columbia.edu
Wireless Media System http://comet.columbia.edu/~sgkim
COMET Group
Center for Telecommunications Research 212-586-3678(H)
Columbia University 212-854-5599(LAB)
--------------------------------------------------------------------------
------=_NextPart_000_0079_01BDEA7B.831FFAB0
Content-Type: application/octet-stream;
name="common.idl"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
filename="common.idl"
// File : common.idl
//
// Description : Common IDL defintions for xbind base classes
//
// Contact : mobiware@comet.columbia.edu
//
// This is unpubliched software developed as part of the the
// Mobiware Project by the COMET Group, Center for Telecommunications
// Research at Columbia University; it may not be disclosed to third
// parties, copied or duplicated in any form, in whole or in part,
// without the prior written permission of the Center for
// Telecommunications Research at Columbia University.
//
// All advertising materials mentioning features or use of this
// software must display the following acknowledgement: This product
// includes software developed by the COMET Group, Center for
// Telecommunications Research at Columbia University. It is
// distributed as it is, with absolutely no warranty of any kind, either
// expressed or implied, including, but not limited to, the implied
// warranties of merchantability of fitness for a particular
// purpose. The entire risk as to the quality and performance of the
// programs is with you. Should the programs prove defective, you
// assume the cost of all necessary servicing, repair or correction.
#ifndef COMMON_IDL
#define COMMON_IDL
#include "defs.idl"
#ifdef WIN32
interface COMETObject{
readonly attribute BIBObjectId boid;
readonly attribute BIBTime creationtime;
readonly attribute string hostname;
readonly attribute long pid;
readonly attribute string owner;
ObjectInfo getobjectinfo();
};
interface BIBObject:COMETObject{
readonly attribute string bibversion;
};
interface ServiceObject:COMETObject{
readonly attribute string serviceversion;
};
#else WIN32
interface CObject{
readonly attribute BIBObjectId boid;
readonly attribute BIBTime creationtime;
readonly attribute string hostname;
readonly attribute long pid;
readonly attribute string owner;
ObjectInfo getobjectinfo();
};
interface BIBObject:CObject{
readonly attribute string bibversion;
};
interface ServiceObject:CObject{
readonly attribute string serviceversion;
};
#endif
#endif
------=_NextPart_000_0079_01BDEA7B.831FFAB0
Content-Type: application/octet-stream;
name="test.idl"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
filename="test.idl"
//test.idl
#ifndef QOS_CONNECTION_MAN_IDL
#define QOS_CONNECTION_MAN_IDL
#include "common.idl"
#include "QOS.idl"
#include "EndPoint.idl"
#include "FBDefs.idl"
#include "FlowInfo.idl"
interface MobilityAgent {
exception Reject { string reason; };
BIBStatus addFlow(
in long fbi,
inout QOSSpecification qosSpec,
inout FlowInfo flowinfo1,
inout EndPoint host_A,
inout EndPoint host_B,
in string source,
inout double msr_time) raises (Reject);
void removeFlow(
in long fbi,
in EndPoint host_A,
in EndPoint host_B) raises (Reject);
void removeFlowBundle(
in long fbi,
inout EndPointList host_A,
inout EndPointList host_B) raises (Reject);
BIBStatus refreshFlow(
in long fbi,
inout EndPoint host_A,
inout EndPoint host_B,
inout double msr_time) raises (Reject);
BIBStatus refreshFlowBundle(
in long fbi,
inout EndPointList host_A[2],
inout EndPointList host_B[2],
inout double msr_time) raises (Reject);
BIBStatus handoffFlowBundle(
in long fbi,
inout SourceList srcnamelist[2],
inout EndPointList srclist[2],
inout EndPointList destlist[2],
inout QOSSpecList qosSpec[2],
inout FlowInfoList flowinfo1[2],
inout double msr_time) raises (Reject);
BIBStatus renegotiate(
in QOSSpecification qosSpec,
in FlowInfo flowinfo,
in EndPoint host_A,
in EndPoint host_B, in string source) raises (Reject);
};
#endif
------=_NextPart_000_0079_01BDEA7B.831FFAB0
Content-Type: application/octet-stream;
name="QOS.idl"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: attachment;
filename="QOS.idl"
// File : QOS.idl
//=20
// Description : This file contains end-to-end QOS terminology =
description. =20
//
// Contact : mobiware@comet.columbia.edu
//=20
// This is unpubliched software developed as part of the the
// Mobiware Project by the COMET Group, Center for Telecommunications
// Research at Columbia University; it may not be disclosed to third
// parties, copied or duplicated in any form, in whole or in part,
// without the prior written permission of the Center for
// Telecommunications Research at Columbia University.
//
// All advertising materials mentioning features or use of this
// software must display the following acknowledgement: This product
// includes software developed by the COMET Group, Center for
// Telecommunications Research at Columbia University. It is
// distributed as it is, with absolutely no warranty of any kind, either
// expressed or implied, including, but not limited to, the implied
// warranties of merchantability of fitness for a particular
// purpose. The entire risk as to the quality and performance of the
// programs is with you. Should the programs prove defective, you
// assume the cost of all necessary servicing, repair or correction.
#ifndef _QOS_IDL
#define _QOS_IDL
// ----------- LEVEL DEFINITION
// to prevent name clash, is appended at the end of each enum=20
// _[u|a|n|t][p|s|q] for _(level)(definition)
enum Level
{
user, application, transport, network
};
// ----------- SERVICE DEFINITION
enum TransportService // transport level
{
MPEG_I_ts, MPEG_II_ts, JPEG_ts, CD_ts,=20
RAW_COMET_I_ts, RAW_COMET_II_ts, RAW_COMET_III_ts,=20
BestEffort
};
enum NetworkService // network level
{
COMET_I_ns, COMET_II_ns, COMET_III_ns, COMET_C_ns
};
typedef TransportService ServiceType;
typedef NetworkService TrafficClass;
// ----------- PROTOCOL DEFINITION
enum TransportProtocol
{ =20
none_tp, qStack_tp, n_keshav_tp, n_atm_forum_tp,=20
tcp_ip_tp, tcp_atm_tp, tcp_ip_atm_tp
};
enum NetworkProtocol
{
ATM_np, IP_np
};
// ----------- QOS DEFINITION
struct TransportQOS // per frame
{
float delay;
float loss;
short gap_loss;=20
float PDU_peak_rate;
float PDU_max_size;
};
struct NetworkQOS // per cell (assumes ATM!)
{
float delay;
float loss;
short gap_loss;=20
float unit; // rate -- to be redefined later.
};
// ----------- QOS SPECIFICATION DEFINITION
struct UserQOSSpecification
{
short nothing;
};
struct ApplicationQOSSpecification
{
short nothingtoo;
};
struct TransportQOSSpecification
{
TransportService service;
TransportQOS qos;
TransportProtocol protocol;
};
struct NetworkQOSSpecification
{
NetworkService service;
NetworkQOS qos;
NetworkProtocol protocol;
};
union QOSSpecification switch(Level)
{
case user: UserQOSSpecification u;
case application: ApplicationQOSSpecification a;
case network: NetworkQOSSpecification n;
case transport: TransportQOSSpecification t;
};
#endif
------=_NextPart_000_0079_01BDEA7B.831FFAB0
Content-Type: application/octet-stream;
name="endpoint.hh"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
filename="endpoint.hh"
#ifndef __endpoint_hh__
#define __endpoint_hh__
#include <omniORB2/CORBA.h>
enum EndPointFormat { IP_epf, ATM_epf, E164_epf, CORBA_epf };
inline void operator>>= (EndPointFormat _e,NetBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (EndPointFormat &_e,NetBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case IP_epf:
case ATM_epf:
case E164_epf:
case CORBA_epf:
_e = (EndPointFormat) __e;
break;
default:
_CORBA_marshal_error();
}
}
inline void operator>>= (EndPointFormat _e,MemBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (EndPointFormat &_e,MemBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case IP_epf:
case ATM_epf:
case E164_epf:
case CORBA_epf:
_e = (EndPointFormat) __e;
break;
default:
_CORBA_marshal_error();
}
}
struct ATMEndPointId {
CORBA::Short port;
CORBA::Short VPI;
CORBA::Long VCI;
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<ATMEndPointId> ATMEndPointId_var;
typedef ATMEndPointId E164EndPointId;
typedef ATMEndPointId_var E164EndPointId_var;
struct IPEndPointId {
CORBA::Char ipadd[16];
CORBA::Short port;
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<IPEndPointId> IPEndPointId_var;
struct CORBAEndPointId {
CORBA::Char marker[128];
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<CORBAEndPointId> CORBAEndPointId_var;
class EndPointId {
public:
EndPointId() {
}
EndPointId(const EndPointId& _value) {
switch(_value.pd__d) {
case IP_epf: ip(_value.pd_ip); break;
case ATM_epf: atm(_value.pd_atm); break;
case E164_epf: e164(_value.pd_e164); break;
case CORBA_epf: corba(_value.pd_corba); break;
default: break;
}
}
~EndPointId() {}
EndPointId& operator=(const EndPointId& _value) {
switch(_value.pd__d) {
case IP_epf: ip(_value.pd_ip); break;
case ATM_epf: atm(_value.pd_atm); break;
case E164_epf: e164(_value.pd_e164); break;
case CORBA_epf: corba(_value.pd_corba); break;
default: break;
}
return *this;
}
EndPointFormat _d () const { return pd__d;}
void _d(EndPointFormat _value) {}
const IPEndPointId &ip () const { return pd_ip; }
IPEndPointId &ip () { return pd_ip; }
void ip (const IPEndPointId& _value) {
pd__d = IP_epf;
pd__default = 0;
pd_ip = _value;
}
const ATMEndPointId &atm () const { return pd_atm; }
ATMEndPointId &atm () { return pd_atm; }
void atm (const ATMEndPointId& _value) {
pd__d = ATM_epf;
pd__default = 0;
pd_atm = _value;
}
const E164EndPointId &e164 () const { return pd_e164; }
E164EndPointId &e164 () { return pd_e164; }
void e164 (const E164EndPointId& _value) {
pd__d = E164_epf;
pd__default = 0;
pd_e164 = _value;
}
const CORBAEndPointId &corba () const { return pd_corba; }
CORBAEndPointId &corba () { return pd_corba; }
void corba (const CORBAEndPointId& _value) {
pd__d = CORBA_epf;
pd__default = 0;
pd_corba = _value;
}
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
private:
EndPointFormat pd__d;
CORBA::Boolean pd__default;
union {
#ifndef USING_PROXY_FLOAT
IPEndPointId pd_ip;
#endif
#ifndef USING_PROXY_FLOAT
ATMEndPointId pd_atm;
#endif
#ifndef USING_PROXY_FLOAT
E164EndPointId pd_e164;
#endif
#ifndef USING_PROXY_FLOAT
CORBAEndPointId pd_corba;
#endif
};
#ifdef USING_PROXY_FLOAT
IPEndPointId pd_ip;
#endif
#ifdef USING_PROXY_FLOAT
ATMEndPointId pd_atm;
#endif
#ifdef USING_PROXY_FLOAT
E164EndPointId pd_e164;
#endif
#ifdef USING_PROXY_FLOAT
CORBAEndPointId pd_corba;
#endif
};
typedef _CORBA_ConstrType_Fix_Var<EndPointId> EndPointId_var;
enum Direction { incoming, outgoing, incoming_bi, outgoing_bi };
inline void operator>>= (Direction _e,NetBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (Direction &_e,NetBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case incoming:
case outgoing:
case incoming_bi:
case outgoing_bi:
_e = (Direction) __e;
break;
default:
_CORBA_marshal_error();
}
}
inline void operator>>= (Direction _e,MemBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (Direction &_e,MemBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case incoming:
case outgoing:
case incoming_bi:
case outgoing_bi:
_e = (Direction) __e;
break;
default:
_CORBA_marshal_error();
}
}
struct EndPoint {
EndPointFormat epformat;
CORBA::Char hostname[128];
EndPointId epid;
EndPointId fepid;
Direction dir;
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<EndPoint> EndPoint_var;
#endif // __endpoint_hh__
------=_NextPart_000_0079_01BDEA7B.831FFAB0
Content-Type: application/octet-stream;
name="FBDefs.idl"
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
filename="FBDefs.idl"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------=_NextPart_000_0079_01BDEA7B.831FFAB0
Content-Type: application/octet-stream;
name="flowinfo.hh"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
filename="flowinfo.hh"
#ifndef __flowinfo_hh__
#define __flowinfo_hh__
#include <omniORB2/CORBA.h>
enum FlowType { video, audio, data, signaling };
inline void operator>>= (FlowType _e,NetBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (FlowType &_e,NetBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case video:
case audio:
case data:
case signaling:
_e = (FlowType) __e;
break;
default:
_CORBA_marshal_error();
}
}
inline void operator>>= (FlowType _e,MemBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (FlowType &_e,MemBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case video:
case audio:
case data:
case signaling:
_e = (FlowType) __e;
break;
default:
_CORBA_marshal_error();
}
}
struct VideoFlow {
CORBA::Float rate;
CORBA::Short MStype;
CORBA::Short FECtype;
CORBA::Short FECerrortype;
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<VideoFlow> VideoFlow_var;
struct AudioFlow {
CORBA::Float rate;
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<AudioFlow> AudioFlow_var;
struct DataFlow {
CORBA::Float rate;
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<DataFlow> DataFlow_var;
struct SignalingFlow {
CORBA::Float rate;
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<SignalingFlow> SignalingFlow_var;
class Flow {
public:
Flow() {
}
Flow(const Flow& _value) {
switch(_value.pd__d) {
case video: v(_value.pd_v); break;
case audio: a(_value.pd_a); break;
case data: d(_value.pd_d); break;
case signaling: s(_value.pd_s); break;
default: break;
}
}
~Flow() {}
Flow& operator=(const Flow& _value) {
switch(_value.pd__d) {
case video: v(_value.pd_v); break;
case audio: a(_value.pd_a); break;
case data: d(_value.pd_d); break;
case signaling: s(_value.pd_s); break;
default: break;
}
return *this;
}
FlowType _d () const { return pd__d;}
void _d(FlowType _value) {}
const VideoFlow &v () const { return pd_v; }
VideoFlow &v () { return pd_v; }
void v (const VideoFlow& _value) {
pd__d = video;
pd__default = 0;
pd_v = _value;
}
const AudioFlow &a () const { return pd_a; }
AudioFlow &a () { return pd_a; }
void a (const AudioFlow& _value) {
pd__d = audio;
pd__default = 0;
pd_a = _value;
}
const DataFlow &d () const { return pd_d; }
DataFlow &d () { return pd_d; }
void d (const DataFlow& _value) {
pd__d = data;
pd__default = 0;
pd_d = _value;
}
const SignalingFlow &s () const { return pd_s; }
SignalingFlow &s () { return pd_s; }
void s (const SignalingFlow& _value) {
pd__d = signaling;
pd__default = 0;
pd_s = _value;
}
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
private:
FlowType pd__d;
CORBA::Boolean pd__default;
union {
#ifndef USING_PROXY_FLOAT
VideoFlow pd_v;
#endif
#ifndef USING_PROXY_FLOAT
AudioFlow pd_a;
#endif
#ifndef USING_PROXY_FLOAT
DataFlow pd_d;
#endif
#ifndef USING_PROXY_FLOAT
SignalingFlow pd_s;
#endif
};
#ifdef USING_PROXY_FLOAT
VideoFlow pd_v;
#endif
#ifdef USING_PROXY_FLOAT
AudioFlow pd_a;
#endif
#ifdef USING_PROXY_FLOAT
DataFlow pd_d;
#endif
#ifdef USING_PROXY_FLOAT
SignalingFlow pd_s;
#endif
};
typedef _CORBA_ConstrType_Fix_Var<Flow> Flow_var;
enum Direc { DOWNLINK, UPLINK, UPSTACK };
inline void operator>>= (Direc _e,NetBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (Direc &_e,NetBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case DOWNLINK:
case UPLINK:
case UPSTACK:
_e = (Direc) __e;
break;
default:
_CORBA_marshal_error();
}
}
inline void operator>>= (Direc _e,MemBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (Direc &_e,MemBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case DOWNLINK:
case UPLINK:
case UPSTACK:
_e = (Direc) __e;
break;
default:
_CORBA_marshal_error();
}
}
enum State { soft, hard };
inline void operator>>= (State _e,NetBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (State &_e,NetBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case soft:
case hard:
_e = (State) __e;
break;
default:
_CORBA_marshal_error();
}
}
inline void operator>>= (State _e,MemBufferedStream &s) {
::operator>>=((CORBA::ULong)_e,s);
}
inline void operator<<= (State &_e,MemBufferedStream &s) {
CORBA::ULong __e;
__e <<= s;
switch (__e) {
case soft:
case hard:
_e = (State) __e;
break;
default:
_CORBA_marshal_error();
}
}
struct FlowInfo {
FlowType type;
Flow flow1;
Direc direc1;
State state1;
size_t NP_alignedSize(size_t initialoffset) const;
void operator>>= (NetBufferedStream &) const;
void operator<<= (NetBufferedStream &);
void operator>>= (MemBufferedStream &) const;
void operator<<= (MemBufferedStream &);
};
typedef _CORBA_ConstrType_Fix_Var<FlowInfo> FlowInfo_var;
#endif // __flowinfo_hh__
------=_NextPart_000_0079_01BDEA7B.831FFAB0--