From c685695d30d92cc376ab180641e5faf73cd2b8c1 Mon Sep 17 00:00:00 2001 From: sumedh Date: Mon, 17 Feb 1997 00:09:24 +0000 Subject: Added IIOP files --- TAO/IIOP/test/cubit.cpp | 590 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 590 insertions(+) create mode 100644 TAO/IIOP/test/cubit.cpp (limited to 'TAO/IIOP/test/cubit.cpp') diff --git a/TAO/IIOP/test/cubit.cpp b/TAO/IIOP/test/cubit.cpp new file mode 100644 index 00000000000..077ba286522 --- /dev/null +++ b/TAO/IIOP/test/cubit.cpp @@ -0,0 +1,590 @@ +// @(#)cubit.cpp 1.2 95/09/29 +// Copyright 1994-1995 by Sun Microsystems Inc. +// All Rights Reserved +// +// TEST: hand-written C-style "Cubit" stubs and "skeletons" +// +// NOTE: these "skeletons" are really the methods, using DSI. No real +// ORB would be implemented in this particular way. Several things would +// be more typical of real (static) skeletons: +// +// * Most of the "in" (and much of the "out") parameter data would +// be preallocated on the stack, not heap allocated. (Static +// preallocation doesnt' really work in a multithreaded system, +// and moreover can waste a lot of space.) +// +// * The ORB core wouldn't be told about parameters using heap +// allocated data structures (e.g. NVList). +// +// * Skeletons would need to some kind of "marshal the response NOW" +// API so that stack-allocated "out" values wouldn't become invalid +// up until they were safely marshaled. +// +// * They'd handle exceptions rather than just generating debugging +// messages when they happen. +// +// * Method code would be called by the skeletons, not written as +// part of the "skeleton" itself! +// +// A key part of turning this code into a complete ORB would be to ensure +// that skeletons were always efficient and correct. They might not need +// to be sharable between different implementations of the same OMG-IDL +// object interface, but many ORBs choose to be structured that way. +// + +#include "cubit.hh" // for stubs ... +#include // ... and skeletons + +#include "../lib/runtime/debug.hh" // ... and debugging + + +// +// CUBE OCTET +// + +static const paramdata Cubit_cube_octet_params [] = { + { _tc_CORBA_Octet, PARAM_RETURN, 0 }, + { _tc_CORBA_Octet, PARAM_IN, 0 } +}; + +static const calldata Cubit_cube_octet_calldata = { + "cube_octet", CORBA_B_TRUE, + 2, &Cubit_cube_octet_params [0], + 0, 0 +}; + + +CORBA_Octet +Cubit_cube_octet ( + Cubit_ptr target, + CORBA_Octet o, + CORBA_Environment &env +) +{ + CORBA_Octet retval; + STUB_Object *data; + + if (target->QueryInterface (IID_STUB_Object, (void **)&data) + != NOERROR) + env.exception (new CORBA_INV_OBJREF (COMPLETED_NO)); + else { + data->do_call (env, &Cubit_cube_octet_calldata, + &retval, &o); + data->Release (); + } + return retval; +} + +static void +_cube_octet_skel ( + CORBA_ServerRequest &req, + CORBA_Environment &env +) +{ + CORBA_NVList_ptr nvlist; + CORBA_NamedValue_ptr nv; + CORBA_Any temp_value (_tc_CORBA_Octet); + + req.orb()->create_list (0, nvlist); + nv = nvlist->add_value (0, temp_value, CORBA_ARG_IN, env); + dexc (env, "cube_octet, add value"); + + req.params (nvlist, env); + dexc (env, "cube_octet, get params"); + + CORBA_Octet *value = new CORBA_Octet; + + *value = *(CORBA_Octet *)nv->value ()->value (); + // dmsg1 ("cube octet, parameter '%d'", *value); + *value = (CORBA_Octet) ((*value) * (*value) * (*value)); + // dmsg1 ("cube octet, result '%d'", *value); + + CORBA_Any *any = + new CORBA_Any (_tc_CORBA_Octet, value, CORBA_B_TRUE); + + req.result (any, env); + dexc (env, "cube_octet, result"); +} + + +// +// CUBE SHORT +// + +static const paramdata Cubit_cube_short_params [] = { + { _tc_CORBA_Short, PARAM_RETURN, 0 }, + { _tc_CORBA_Short, PARAM_IN, 0 } +}; + +static const calldata Cubit_cube_short_calldata = { + "cube_short", CORBA_B_TRUE, + 2, &Cubit_cube_short_params [0], + 0, 0 +}; + + +CORBA_Short +Cubit_cube_short ( + Cubit_ptr target, + CORBA_Short s, + CORBA_Environment &env +) +{ + CORBA_Short retval; + STUB_Object *data; + + if (target->QueryInterface (IID_STUB_Object, (void **)&data) + != NOERROR) + env.exception (new CORBA_INV_OBJREF (COMPLETED_NO)); + else { + data->do_call (env, &Cubit_cube_short_calldata, + &retval, &s); + data->Release (); + } + return retval; +} + +static void +_cube_short_skel ( + CORBA_ServerRequest &req, + CORBA_Environment &env +) +{ + CORBA_NVList_ptr nvlist; + CORBA_NamedValue_ptr nv; + CORBA_Any temp_value (_tc_CORBA_Short); + + req.orb()->create_list (0, nvlist); + nv = nvlist->add_value (0, temp_value, CORBA_ARG_IN, env); + dexc (env, "cube_short, add_value"); + + req.params (nvlist, env); + dexc (env, "cube_short, get params"); + + CORBA_Short *value = new CORBA_Short; + + *value = *(CORBA_Short *)nv->value ()->value (); + // dmsg1 ("cube short, parameter '%d'", *value); + *value =(CORBA_Short) ((*value) * (*value) * (*value)); + // dmsg1 ("cube short, result '%d'", *value); + + CORBA_Any *any = + new CORBA_Any (_tc_CORBA_Short, value, CORBA_B_TRUE); + + req.result (any, env); + dexc (env, "cube_short, result"); +} + + +// +// CUBE LONG +// + +static const paramdata Cubit_cube_long_params [] = { + { _tc_CORBA_Long, PARAM_RETURN, 0 }, + { _tc_CORBA_Long, PARAM_IN, 0 } +}; + +static const calldata Cubit_cube_long_calldata = { + "cube_long", CORBA_B_TRUE, + 2, &Cubit_cube_long_params [0], + 0, 0 +}; + + +CORBA_Long +Cubit_cube_long ( + Cubit_ptr target, + CORBA_Long l, + CORBA_Environment &env +) +{ + CORBA_Long retval; + STUB_Object *data; + + if (target->QueryInterface (IID_STUB_Object, (void **)&data) + != NOERROR) + env.exception (new CORBA_INV_OBJREF (COMPLETED_NO)); + else { + data->do_call (env, &Cubit_cube_long_calldata, + &retval, &l); + data->Release (); + } + return retval; +} + + +static void +_cube_long_skel ( + CORBA_ServerRequest &req, + CORBA_Environment &env +) +{ + CORBA_NVList_ptr nvlist; + CORBA_NamedValue_ptr nv; + CORBA_Any temp_value (_tc_CORBA_Long); + + req.orb()->create_list (0, nvlist); + nv = nvlist->add_value (0, temp_value, CORBA_ARG_IN, env); + dexc (env, "cube_long, add_value"); + + req.params (nvlist, env); + dexc (env, "cube_long, get params"); + + CORBA_Long *value = new CORBA_Long; + + *value = *(CORBA_Long *)nv->value ()->value (); + // dmsg1 ("cube long, parameter '%d'", *value); + *value = (*value) * (*value) * (*value); + // dmsg1 ("cube long, result '%d'", *value); + + CORBA_Any *any = + new CORBA_Any (_tc_CORBA_Long, value, CORBA_B_TRUE); + + req.result (any, env); + dexc (env, "cube_long, result"); +} + +// +// Encapsulated parameters for struct "Cubit_Many" typecode. +// None of these parameters is complicated, so this is just +// a linear sequence of element encodings +// +// NOTE: it's important that this be longword aligned!! +// +static const CORBA_Long _oc_Cubit_Many [] = { + 1, // byte order flag (TRICKY!) + + 1, 0, // empty string: repository/type ID + 1, 0, // empty string: struct name + + 3, // three struct elements + + // First structure element: name, typecode for Octet + 1, 0, // empty string: name "o" + tk_octet, + + // Second structure element: name, typecode for Long + 1, 0, // empty string: name "l" + tk_long, + + // Third structure element: name, typecode for Short + 1, 0, // empty string: name "s" + tk_short, +}; + +static CORBA_TypeCode _tc_Cubit_Many (tk_struct, + sizeof _oc_Cubit_Many, (unsigned char *) &_oc_Cubit_Many, + CORBA_B_FALSE); +CORBA_TypeCode_ptr TC_Cubit_Many = &_tc_Cubit_Many; + + +// +// CUBE STRUCT +// + +static const paramdata Cubit_cube_struct_params [] = { + { &_tc_Cubit_Many, PARAM_RETURN, sizeof (Cubit_Many) }, + { &_tc_Cubit_Many, PARAM_IN, 0 } +}; + +static const calldata Cubit_cube_struct_calldata = { + "cube_struct", CORBA_B_TRUE, + 2, &Cubit_cube_struct_params [0], + 0, 0 +}; + +Cubit_Many * +Cubit_cube_struct ( + Cubit_ptr target, + Cubit_Many &values, + CORBA_Environment &env +) +{ + Cubit_Many *retval; + STUB_Object *data; + + if (target->QueryInterface (IID_STUB_Object, (void **)&data) + != NOERROR) + env.exception (new CORBA_INV_OBJREF (COMPLETED_NO)); + else { + data->do_call (env, &Cubit_cube_struct_calldata, + &retval, &values); + data->Release (); + } + return retval; +} + + +static void +_cube_struct_skel ( + CORBA_ServerRequest &req, + CORBA_Environment &env +) +{ + CORBA_NVList_ptr nvlist; + CORBA_NamedValue_ptr nv; + CORBA_Any temp_value (TC_Cubit_Many); + + req.orb()->create_list (0, nvlist); + nv = nvlist->add_value (0, temp_value, CORBA_ARG_IN, env); + dexc (env, "cube_struct, add_value"); + + req.params (nvlist, env); + dexc (env, "cube_struct, get params"); + + Cubit_Many *value; + Cubit_Many *retval = new Cubit_Many; + + value = (Cubit_Many *)nv->value ()->value (); + + retval->o = (CORBA_Octet) (value->o * value->o * value->o); + retval->s = (CORBA_Short) (value->s * value->s * value->s); + retval->l = value->l * value->l * value->l; + + // dmsg2 ("cube struct.o, %d -> %d", value->o, retval->o); + // dmsg2 ("cube struct.s, %d -> %d", value->s, retval->s); + // dmsg2 ("cube struct.l, %d -> %d", value->l, retval->l); + + CORBA_Any *any = + new CORBA_Any (TC_Cubit_Many, retval, CORBA_B_TRUE); + + req.result (any, env); + dexc (env, "cube_struct, result"); +} + +// +// CUBE UNION +// + +// +// NOTE: not all union typecodes can be encoded as an array +// of "long "values, but this one can. Ones with discriminants +// that are one or two bytes long can't easily be coded portably. +// +// The benefit of doing it as an array of "long" values is +// twofold: (a) easier to read; (b) on most systems it's then +// adequately aligned for the typecode interpreter to use, so +// no additional runtime copy needs to be made. +// +static const CORBA_Long _oc_Cubit_oneof [] = { + 1, // byte order flag (TRICKY) + 1, 0, // omitted repository/type ID + 1, 0, // omitted struct name, "oneof" + + // + // discriminant typecode: + // + tk_enum, // tk_enum + 72, // encapsulation length + + 1, // byte order flag (TRICKY) + 1, 0, // omitted repository/type ID + 1, 0, // omitted enum name, "discrim" + 6, // 5 elements in the enum + + 1, 0, // omitted member name, "e_0th" + 1, 0, // omitted member name, "e_1st" + 1, 0, // omitted member name, "e_2nd" + 1, 0, // omitted member name, "e_3rd" + 1, 0, // omitted member name, "e_4th" + 1, 0, // omitted member name, "e_5th" + + 4, // default member index (zero based) + 5, // number of union members + + // the 1st union branch arm + e_0th, // member label value + 1, 0, // omitted member name, "o" + tk_octet, // member typecode + + // the 2nd union branch arm + e_1st, // member label value + 1, 0, // omitted member name, "s" + tk_short, // member typecode + + // the 3rd union branch arm + e_2nd, // member label value + 1, 0, // omitted member name, "l" + tk_long, // member typecode + + // the 4th union branch arm + e_3rd, // member label value + 1, 0, // omitted member name, "cm" + + // the 4th union member typecode + tk_struct, // tk_struct + 60, // encap length + + 1, // byte order flag (TRICKY) + 1, 0, // omitted repository/type ID + 1, 0, // omitted struct name, "Many" + 3, // three struct members + + // First structure element + 1, 0, // omitted member name, "o" + tk_octet, // member type, tk_octet + + // Second structure element + 1, 0, // omitted member name, "l" + tk_long, // member type, tk_long + + // Third structure element + 1, 0, // omitted member name, "s" + tk_short, // member type, tk_short + + // the 5th union branch arm + 4, // the 5th member label value + 1, 0, // omitted member name, "cm" + ~0, // indirected typecode (~0) + -84 // offset to struct "Many" typecode +}; + +static CORBA_TypeCode _tc_Cubit_oneof (tk_union, + (sizeof _oc_Cubit_oneof), (unsigned char *) &_oc_Cubit_oneof, + CORBA_B_FALSE); +CORBA_TypeCode_ptr TC_Cubit_oneof = &_tc_Cubit_oneof; + +static const paramdata Cubit_cube_union_params [] = { + { &_tc_Cubit_oneof, PARAM_RETURN, sizeof (Cubit_oneof) }, + { &_tc_Cubit_oneof, PARAM_IN, 0 } +}; + +static const calldata Cubit_cube_union_calldata = { + "cube_union", CORBA_B_TRUE, + 2, &Cubit_cube_union_params [0], + 0, 0 +}; + +Cubit_oneof * +Cubit_cube_union ( + Cubit_ptr target, + Cubit_oneof &values, + CORBA_Environment &env +) +{ + Cubit_oneof *retval; + STUB_Object *data; + + if (target->QueryInterface (IID_STUB_Object, (void **)&data) + != NOERROR) + env.exception (new CORBA_INV_OBJREF (COMPLETED_NO)); + else { + data->do_call (env, &Cubit_cube_union_calldata, + &retval, &values); + data->Release (); + } + return retval; +} + + +static void +_cube_union_skel ( + CORBA_ServerRequest &req, + CORBA_Environment &env +) +{ + CORBA_NVList_ptr nvlist; + CORBA_NamedValue_ptr nv; + CORBA_Any temp_value (TC_Cubit_oneof); + + req.orb()->create_list (0, nvlist); + nv = nvlist->add_value (0, temp_value, CORBA_ARG_IN, env); + dexc (env, "cube_union_3rd, add_value"); + + req.params (nvlist, env); + dexc (env, "cube_union_3rd, get params"); + + Cubit_oneof *v; + Cubit_oneof *r = new Cubit_oneof; + + v = (Cubit_oneof *)nv->value ()->value (); + r->_disc = v->_disc; + + switch (v->_disc) { + case e_0th: + r->o = (CORBA_Octet) (v->o * v->o * v->o); + break; + + case e_1st: + r->s = (CORBA_Short) (v->s * v->s * v->s); + break; + + case e_2nd: + r->l = v->l * v->l * v->l; + break; + + case e_3rd: + default: + r->cm.o = (CORBA_Octet) (v->cm.o * v->cm.o * v->cm.o); + r->cm.s = (CORBA_Short) (v->cm.s * v->cm.s * v->cm.s); + r->cm.l = v->cm.l * v->cm.l * v->cm.l; + break; + } + + CORBA_Any *any = new CORBA_Any (TC_Cubit_oneof, r, CORBA_B_TRUE); + + req.result (any, env); + dexc (env, "cube_struct, result"); +} + + +// +// PLEASE EXIT +// + +static const calldata Cubit_please_exit_calldata = { + "please_exit", CORBA_B_FALSE, + 0, 0, + 0, 0 +}; + +void +Cubit_please_exit ( + Cubit_ptr target, + CORBA_Environment &env +) +{ + STUB_Object *data; + + if (target->QueryInterface (IID_STUB_Object, (void **)&data) + != NOERROR) + env.exception (new CORBA_INV_OBJREF (COMPLETED_NO)); + else { + data->do_call (env, &Cubit_please_exit_calldata + ); + data->Release (); + } +} + +static void +_please_exit_skel ( + CORBA_ServerRequest &req, + CORBA_Environment &env +) +{ + dmsg ("I've been asked to shut down..."); + req.oa ()->please_shutdown (env); + dexc (env, "please_exit, please_shutdown"); +} + + +const CORBA_Char *Cubit__id = (CORBA_Char *) + "IDL:Eng.SUN.COM/Cubit:1.1"; + + +// +// table of all operations, used by operation dispatch to get to the +// right skeleton ... could be sorted by the IDL compiler so bsearch +// is effective, perhaps with help from opname hashes and a small cache +// (e.g. like Obj-C?). for now, just lsearch. +// +const skel_entry Cubit_operations [] = { + { &Cubit_cube_octet_calldata, _cube_octet_skel }, + { &Cubit_cube_short_calldata, _cube_short_skel }, + { &Cubit_cube_long_calldata, _cube_long_skel }, + { &Cubit_cube_struct_calldata, _cube_struct_skel }, + { &Cubit_cube_union_calldata, _cube_union_skel }, + { &Cubit_please_exit_calldata, _please_exit_skel }, + { 0, 0 } // last entry +}; -- cgit v1.2.1