mirror of
https://github.com/php/php-src.git
synced 2024-10-13 20:42:38 +00:00
437 lines
10 KiB
C
437 lines
10 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| PHP version 4.0 |
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) 1997-2001 The PHP Group |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 2.02 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available at through the world-wide-web at |
|
|
| http://www.php.net/license/2_02.txt. |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Author: David Eriksson <david@2good.com> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
/*
|
|
* $Id$
|
|
* vim: syntax=c tabstop=2 shiftwidth=2
|
|
*/
|
|
|
|
/* -----------------------------------------------------------------------
|
|
*
|
|
* functions to convert IDL_tree info to CORBA_TypeCodes
|
|
*
|
|
* ought to be cleaned up...
|
|
*
|
|
* -----------------------------------------------------------------------
|
|
*/
|
|
#include "corba.h"
|
|
#include "common.h"
|
|
#include "findtype.h"
|
|
#include "typecode.h"
|
|
|
|
void satellite_release_typecode(CORBA_TypeCode typecode)
|
|
{
|
|
CORBA_Object_release((CORBA_Object)typecode, orbit_get_environment());
|
|
}
|
|
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_enum(IDL_tree type)
|
|
{
|
|
CORBA_TypeCode type_code;
|
|
CORBA_EnumMemberSeq * p_members = NULL;
|
|
|
|
p_members = CORBA_EnumMemberSeq__alloc();
|
|
p_members->_maximum = p_members->_length = 1;
|
|
p_members->_buffer = CORBA_sequence_CORBA_Identifier_allocbuf(p_members->_length);
|
|
|
|
p_members->_buffer[0] = "dummy";
|
|
|
|
/*
|
|
* TODO: initialize p_members with members...
|
|
* look at orbit_idl_tree_type_to_typecode_struct
|
|
*/
|
|
|
|
type_code = CORBA_ORB_create_enum_tc(
|
|
orbit_get_orb(),
|
|
IDL_IDENT(IDL_TYPE_ENUM(type).ident).repo_id,
|
|
IDL_IDENT(IDL_TYPE_ENUM(type).ident).str,
|
|
p_members,
|
|
orbit_get_environment());
|
|
|
|
if (orbit_error_test("CORBA_ORB_create_enum_tc"))
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
if (type_code == NULL)
|
|
{
|
|
/* printf("unable to create enum typecode for type %s\n",
|
|
IDL_IDENT(IDL_TYPE_ENUM(type).ident).str);*/
|
|
}
|
|
|
|
goto exit;
|
|
|
|
error:
|
|
type_code = NULL;
|
|
|
|
exit:
|
|
CORBA_free(p_members);
|
|
return type_code;
|
|
}
|
|
|
|
/*
|
|
* create a member sequence for a struct or exception
|
|
*/
|
|
static CORBA_StructMemberSeq * orbit_create_member_sequence(IDL_tree member_list)
|
|
{
|
|
int i = 0;
|
|
CORBA_StructMemberSeq * p_members = NULL;
|
|
IDL_tree first_member = member_list;
|
|
|
|
p_members = CORBA_sequence_CORBA_StructMember__alloc();
|
|
/* this is initially set to false, why? */
|
|
p_members->_release = CORBA_TRUE;
|
|
|
|
/* ok with empty list */
|
|
if (member_list == NULL)
|
|
return p_members;
|
|
|
|
/* first iteration, find out member count */
|
|
do
|
|
{
|
|
IDL_tree declaration = IDL_MEMBER(IDL_LIST(member_list).data).dcls;
|
|
if (declaration == NULL) /* very unlikely! */
|
|
continue;
|
|
|
|
do
|
|
{
|
|
p_members->_length++;
|
|
} while ((declaration = IDL_LIST(declaration).next));
|
|
} while ((member_list = IDL_LIST(member_list).next));
|
|
|
|
p_members->_maximum = p_members->_length;
|
|
p_members->_buffer =
|
|
CORBA_sequence_CORBA_StructMember_allocbuf(p_members->_length);
|
|
|
|
/* second iteration, set member data */
|
|
member_list = first_member;
|
|
do
|
|
{
|
|
IDL_tree declaration = IDL_MEMBER(IDL_LIST(member_list).data).dcls;
|
|
CORBA_TypeCode type_code = NULL;
|
|
|
|
if (declaration == NULL) /* very unlikely! */
|
|
continue;
|
|
|
|
type_code = orbit_idl_tree_type_to_typecode(
|
|
IDL_MEMBER(IDL_LIST(member_list).data).type_spec);
|
|
|
|
if (type_code == NULL)
|
|
{
|
|
zend_error(E_WARNING, "(Satellite) unknown type for member %s", IDL_IDENT(IDL_LIST(declaration).data).str);
|
|
goto error;
|
|
}
|
|
|
|
do
|
|
{
|
|
char * p_name = IDL_IDENT(IDL_LIST(declaration).data).str;
|
|
|
|
p_members->_buffer[i].name = CORBA_string_dup(p_name);
|
|
p_members->_buffer[i].type = (CORBA_TypeCode)
|
|
CORBA_Object_duplicate((CORBA_Object)type_code, orbit_get_environment());
|
|
p_members->_buffer[i].type_def = NULL; /* XXX */
|
|
|
|
i++;
|
|
} while ((declaration = IDL_LIST(declaration).next));
|
|
|
|
satellite_release_typecode(type_code);
|
|
|
|
} while ((member_list = IDL_LIST(member_list).next));
|
|
|
|
goto exit;
|
|
|
|
error:
|
|
/* TODO: error clean up */
|
|
CORBA_free(p_members);
|
|
p_members = NULL;
|
|
|
|
exit:
|
|
return p_members;
|
|
}
|
|
|
|
/*
|
|
* create a CORBA_TypeCode for a struct
|
|
*/
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_struct(IDL_tree type)
|
|
{
|
|
CORBA_TypeCode type_code = NULL;
|
|
CORBA_StructMemberSeq * p_members = NULL;
|
|
|
|
#if 0
|
|
if (IDL_TYPE_STRUCT(type).member_list == NULL)
|
|
{
|
|
printf("no struct members\n");
|
|
goto error;
|
|
}
|
|
#endif
|
|
|
|
p_members = orbit_create_member_sequence(IDL_TYPE_STRUCT(type).member_list);
|
|
if (p_members == NULL)
|
|
goto error;
|
|
|
|
type_code = CORBA_ORB_create_struct_tc(
|
|
orbit_get_orb(),
|
|
IDL_IDENT(IDL_TYPE_STRUCT(type).ident).repo_id,
|
|
IDL_IDENT(IDL_TYPE_STRUCT(type).ident).str,
|
|
p_members,
|
|
orbit_get_environment());
|
|
|
|
if (type_code == NULL)
|
|
goto error;
|
|
|
|
goto exit;
|
|
|
|
error:
|
|
satellite_release_typecode(type_code);
|
|
|
|
exit:
|
|
CORBA_free(p_members);
|
|
return type_code;
|
|
}
|
|
|
|
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_float(IDL_tree type)
|
|
{
|
|
enum IDL_float_type float_type = IDL_TYPE_FLOAT(type).f_type;
|
|
|
|
switch (float_type)
|
|
{
|
|
case IDL_FLOAT_TYPE_DOUBLE: return TC_CORBA_double;
|
|
|
|
default:
|
|
/* php_error(E_WARNING, "only double floats supported at the moment at the moment");*/
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_integer(IDL_tree type)
|
|
{
|
|
enum IDL_integer_type integer_type = IDL_TYPE_INTEGER(type).f_type;
|
|
|
|
switch (integer_type)
|
|
{
|
|
case IDL_INTEGER_TYPE_SHORT: return TC_CORBA_short;
|
|
case IDL_INTEGER_TYPE_LONG: return TC_CORBA_long;
|
|
|
|
default:
|
|
/* php_error(E_WARNING, "unsupported integer type %i", integer_type);*/
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_sequence(IDL_tree type)
|
|
{
|
|
CORBA_TypeCode simple_typecode = orbit_idl_tree_type_to_typecode(
|
|
IDL_TYPE_SEQUENCE(type).simple_type_spec);
|
|
|
|
CORBA_TypeCode typecode = CORBA_ORB_create_sequence_tc(
|
|
orbit_get_orb(),
|
|
0, /* bound */
|
|
simple_typecode,
|
|
orbit_get_environment() );
|
|
|
|
#if 0
|
|
if (typecode != NULL)
|
|
{
|
|
typecode->parent.interface = 0;
|
|
typecode->parent.refs = ORBIT_REFCNT_STATIC; /* correct? */
|
|
}
|
|
#endif
|
|
|
|
satellite_release_typecode(simple_typecode);
|
|
|
|
return typecode;
|
|
}
|
|
|
|
/*
|
|
* get real type when we have an object/structure/union/enum ident
|
|
*/
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_ident(IDL_tree type)
|
|
{
|
|
IDL_tree real_type = NULL;
|
|
IDL_tree whole_tree = type;
|
|
|
|
/* go back to to top of tree (ugly code of the day!) */
|
|
while (whole_tree->up)
|
|
whole_tree = whole_tree->up;
|
|
|
|
/* find the real type! */
|
|
real_type = orbit_find_type_simple(whole_tree, IDL_IDENT_REPO_ID(type));
|
|
|
|
/* check return value */
|
|
if (real_type == NULL)
|
|
{
|
|
/* php_error(E_WARNING,
|
|
"unknown repository id %s",
|
|
IDL_IDENT_REPO_ID(type));*/
|
|
return FALSE;
|
|
}
|
|
|
|
/* call our generic function again... (hehehe) */
|
|
return orbit_idl_tree_type_to_typecode(real_type);
|
|
}
|
|
|
|
/*
|
|
* make exception typecode
|
|
*/
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_exception(IDL_tree type)
|
|
{
|
|
CORBA_TypeCode type_code = NULL;
|
|
CORBA_StructMemberSeq * p_members = NULL;
|
|
|
|
#if 0
|
|
if (IDL_EXCEPT_DCL(type).members == NULL)
|
|
{
|
|
printf("no members\n");
|
|
goto error;
|
|
}
|
|
#endif
|
|
|
|
p_members = orbit_create_member_sequence(IDL_EXCEPT_DCL(type).members);
|
|
if (p_members == NULL)
|
|
goto error;
|
|
|
|
type_code = CORBA_ORB_create_exception_tc(
|
|
orbit_get_orb(),
|
|
IDL_IDENT(IDL_EXCEPT_DCL(type).ident).repo_id,
|
|
IDL_IDENT(IDL_EXCEPT_DCL(type).ident).str,
|
|
p_members,
|
|
orbit_get_environment());
|
|
|
|
goto exit;
|
|
|
|
error:
|
|
satellite_release_typecode(type_code);
|
|
|
|
exit:
|
|
CORBA_free(p_members);
|
|
return type_code;
|
|
|
|
}
|
|
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_interface(IDL_tree type)
|
|
{
|
|
CORBA_TypeCode typecode = CORBA_ORB_create_interface_tc(
|
|
orbit_get_orb(),
|
|
IDL_IDENT(IDL_INTERFACE(type).ident).repo_id,
|
|
IDL_IDENT(IDL_INTERFACE(type).ident).str,
|
|
orbit_get_environment());
|
|
|
|
#if 0
|
|
if (typecode != NULL)
|
|
{
|
|
typecode->parent.interface = 0;
|
|
typecode->parent.refs = ORBIT_REFCNT_STATIC; /* correct? */
|
|
}
|
|
#endif
|
|
|
|
return typecode;
|
|
}
|
|
|
|
static CORBA_TypeCode orbit_idl_tree_type_to_typecode_string(IDL_tree type)
|
|
{
|
|
CORBA_TypeCode typecode = CORBA_ORB_create_string_tc(
|
|
orbit_get_orb(),
|
|
0, /* bound */
|
|
orbit_get_environment());
|
|
|
|
#if 0
|
|
if (typecode != NULL)
|
|
{
|
|
typecode->parent.interface = 0;
|
|
typecode->parent.refs = ORBIT_REFCNT_STATIC; /* correct? */
|
|
}
|
|
#endif
|
|
|
|
return typecode;
|
|
}
|
|
|
|
/*
|
|
* get a CORBA_TypeCode from a IDL_tree node type
|
|
*/
|
|
CORBA_TypeCode orbit_idl_tree_type_to_typecode(IDL_tree type)
|
|
{
|
|
CORBA_TypeCode type_code = NULL;
|
|
|
|
if (type == NULL)
|
|
{
|
|
/* not good! */
|
|
return FALSE;
|
|
}
|
|
|
|
switch (IDL_NODE_TYPE(type))
|
|
{
|
|
case IDLN_EXCEPT_DCL:
|
|
type_code = orbit_idl_tree_type_to_typecode_exception(type);
|
|
break;
|
|
|
|
case IDLN_IDENT:
|
|
type_code = orbit_idl_tree_type_to_typecode_ident(type);
|
|
break;
|
|
|
|
case IDLN_INTERFACE:
|
|
/*type_code = TC_CORBA_Object; */
|
|
type_code = orbit_idl_tree_type_to_typecode_interface(type);
|
|
break;
|
|
|
|
case IDLN_TYPE_BOOLEAN:
|
|
type_code = TC_CORBA_boolean;
|
|
break;
|
|
|
|
case IDLN_TYPE_DCL:
|
|
type_code =
|
|
orbit_idl_tree_type_to_typecode(IDL_TYPE_DCL(type).type_spec);
|
|
break;
|
|
|
|
case IDLN_TYPE_ENUM:
|
|
type_code = orbit_idl_tree_type_to_typecode_enum(type);
|
|
break;
|
|
|
|
case IDLN_TYPE_FLOAT:
|
|
type_code = orbit_idl_tree_type_to_typecode_float(type);
|
|
break;
|
|
|
|
case IDLN_TYPE_INTEGER:
|
|
type_code = orbit_idl_tree_type_to_typecode_integer(type);
|
|
break;
|
|
|
|
case IDLN_TYPE_SEQUENCE:
|
|
type_code = orbit_idl_tree_type_to_typecode_sequence(type);
|
|
break;
|
|
|
|
case IDLN_TYPE_STRING:
|
|
/*type_code = TC_CORBA_string; */
|
|
type_code = orbit_idl_tree_type_to_typecode_string(type);
|
|
break;
|
|
|
|
case IDLN_TYPE_STRUCT:
|
|
type_code = orbit_idl_tree_type_to_typecode_struct(type);
|
|
break;
|
|
|
|
/* TODO: handle more types */
|
|
|
|
default:
|
|
/* printf("orbit_idl_tree_type_to_typecode can't handle type %s\n",
|
|
IDL_NODE_TYPE_NAME(type));*/
|
|
}
|
|
|
|
return type_code;
|
|
}
|
|
|
|
|