mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-11-29 04:46:07 +08:00
Code Issues Packages Projects Releases Wiki Activity
088280c364
php-src/ext/com/conversion.c
Harald Radi 088280c364 -used makros for zval modifications where possible 
-small fixes in safearray to phparray code
2001-06-05 12:47:13 +00:00

831 lines
20 KiB
C
Raw Blame History

/*
+----------------------------------------------------------------------+
| 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: Harald Radi <h.radi@nme.at> |
+----------------------------------------------------------------------+
*/
/*
* 03.6.2001
* Added SafeArray ==> Hash support
*/
#ifdef PHP_WIN32
#include "php.h"
#include "php_COM.h"
#include "unknwn.h"
// prototypes
PHPAPI void php_pval_to_variant(pval *pval_arg, VARIANT *var_arg, int codepage);
PHPAPI void php_pval_to_variant_ex(pval *pval_arg, VARIANT *var_arg, pval *pval_type, int codepage);
PHPAPI int php_variant_to_pval(VARIANT *var_arg, pval *pval_arg, int persistent, int codepage);
PHPAPI OLECHAR *php_char_to_OLECHAR(char *C_str, uint strlen, int codepage);
PHPAPI char *php_OLECHAR_to_char(OLECHAR *unicode_str, uint *out_length, int persistent, int codepage);
// implementations
PHPAPI void php_pval_to_variant(pval *pval_arg, VARIANT *var_arg, int codepage)
{
OLECHAR *unicode_str;
switch(pval_arg->type)
{
case IS_NULL:
var_arg->vt = VT_NULL;
break;
case IS_BOOL:
var_arg->vt = VT_BOOL;
var_arg->boolVal = (short)pval_arg->value.lval;
break;
case IS_OBJECT:
if(!strcmp(pval_arg->value.obj.ce->name, "VARIANT"))
{
int type;
pval **var_handle;
/* fetch the VARIANT structure */
zend_hash_index_find(pval_arg->value.obj.properties, 0, (void **) &var_handle);
var_arg->pvarVal = (VARIANT FAR*) zend_list_find((*var_handle)->value.lval, &type);
var_arg->vt = VT_VARIANT|VT_BYREF;
}
else if(!strcmp(pval_arg->value.obj.ce->name, "COM"))
{
pval **idispatch_handle;
i_dispatch *obj;
int type;
/* fetch the IDispatch interface */
zend_hash_index_find(pval_arg->value.obj.properties, 0, (void **) &idispatch_handle);
obj = (i_dispatch *)zend_list_find((*idispatch_handle)->value.lval, &type);
if(!obj || (type != php_COM_get_le_idispatch()) || !obj->referenced)
{
VariantInit(var_arg);
}
else
{
var_arg->vt = VT_DISPATCH;
var_arg->pdispVal = obj->i.dispatch;
}
}
else
VariantInit(var_arg);
break;
case IS_ARRAY:
{
/* TODO: Walk the hash and convert the elements */
/* into a SafeArray. */
VariantInit(var_arg);
break;
}
case IS_RESOURCE:
case IS_CONSTANT:
case IS_CONSTANT_ARRAY:
VariantInit(var_arg);
break;
case IS_LONG:
var_arg->vt = VT_I4; /* assuming 32-bit platform */
var_arg->lVal = pval_arg->value.lval;
break;
case IS_DOUBLE:
var_arg->vt = VT_R8; /* assuming 64-bit double precision */
var_arg->dblVal = pval_arg->value.dval;
break;
case IS_STRING:
var_arg->vt = VT_BSTR;
unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage);
var_arg->bstrVal = SysAllocString(unicode_str);
efree(unicode_str);
}
}
PHPAPI void php_pval_to_variant_ex(pval *pval_arg, VARIANT *var_arg, pval *pval_type, int codepage)
{
OLECHAR *unicode_str;
var_arg->vt = (short) pval_type->value.lval;
switch(var_arg->vt)
{
case VT_UI1:
convert_to_long_ex(&pval_arg);
var_arg->bVal = (unsigned char)pval_arg->value.lval;
break;
case VT_I2:
convert_to_long_ex(&pval_arg);
var_arg->iVal = (short)pval_arg->value.lval;
break;
case VT_I4:
convert_to_long_ex(&pval_arg);
var_arg->lVal = pval_arg->value.lval;
break;
case VT_R4:
convert_to_double_ex(&pval_arg);
var_arg->fltVal = (float)pval_arg->value.dval;
break;
case VT_R8:
convert_to_double_ex(&pval_arg);
var_arg->dblVal = pval_arg->value.dval;
break;
case VT_BOOL:
convert_to_boolean_ex(&pval_arg);
var_arg->boolVal = (short)pval_arg->value.lval;
break;
case VT_ERROR:
convert_to_long_ex(&pval_arg);
var_arg->scode = pval_arg->value.lval;
break;
case VT_CY:
convert_to_double_ex(&pval_arg);
VarCyFromR8(pval_arg->value.dval, &(var_arg->cyVal));
break;
case VT_DATE:
{
SYSTEMTIME wintime;
struct tm *phptime;
phptime = gmtime(&(pval_arg->value.lval));
wintime.wYear = phptime->tm_year + 1900;
wintime.wMonth = phptime->tm_mon + 1;
wintime.wDay = phptime->tm_mday;
wintime.wHour = phptime->tm_hour;
wintime.wMinute = phptime->tm_min;
wintime.wSecond = phptime->tm_sec;
SystemTimeToVariantTime(&wintime, &(var_arg->date));
}
case VT_BSTR:
convert_to_string_ex(&pval_arg);
unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage);
var_arg->bstrVal = SysAllocString(unicode_str);
efree(unicode_str);
break;
case VT_DECIMAL:
convert_to_string_ex(&pval_arg);
unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage);
VarDecFromStr(unicode_str, LOCALE_SYSTEM_DEFAULT, 0, &(var_arg->decVal));
break;
case VT_DECIMAL|VT_BYREF:
convert_to_string_ex(&pval_arg);
unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage);
VarDecFromStr(unicode_str, LOCALE_SYSTEM_DEFAULT, 0, var_arg->pdecVal);
break;
case VT_UNKNOWN:
php_pval_to_variant(pval_arg, var_arg, codepage);
if(var_arg->vt != VT_DISPATCH)
{
VariantInit(var_arg);
}
else
{
HRESULT hr;
hr = var_arg->pdispVal->lpVtbl->QueryInterface(var_arg->pdispVal, &IID_IUnknown, &(var_arg->punkVal));
if(FAILED(hr))
{
php_error(E_WARNING,"can't query IUnknown");
VariantInit(var_arg);
}
else
{
var_arg->vt = VT_UNKNOWN;
}
}
break;
case VT_DISPATCH:
php_pval_to_variant(pval_arg, var_arg, codepage);
if(var_arg->vt != VT_DISPATCH)
{
VariantInit(var_arg);
}
break;
case VT_UI1|VT_BYREF:
convert_to_long(pval_arg);
var_arg->pbVal = (unsigned char FAR*) &(pval_arg->value.lval);
break;
case VT_I2|VT_BYREF:
convert_to_long(pval_arg);
var_arg->piVal = (short FAR*) &(pval_arg->value.lval);
break;
case VT_I4|VT_BYREF:
convert_to_long(pval_arg);
var_arg->plVal = (long FAR*) &(pval_arg->value.lval);
break;
case VT_R4|VT_BYREF:
convert_to_double(pval_arg);
var_arg->pfltVal = (float FAR*) &(pval_arg->value.lval);
break;
case VT_R8|VT_BYREF:
convert_to_double(pval_arg);
var_arg->pdblVal = (double FAR*) &(pval_arg->value.lval);
break;
case VT_BOOL|VT_BYREF:
convert_to_boolean(pval_arg);
var_arg->pboolVal = (short FAR*) &(pval_arg->value.lval);
break;
case VT_ERROR|VT_BYREF:
convert_to_long(pval_arg);
var_arg->pscode = (long FAR*) &(pval_arg->value.lval);
break;
case VT_CY|VT_BYREF:
convert_to_double_ex(&pval_arg);
VarCyFromR8(pval_arg->value.dval, var_arg->pcyVal);
break;
case VT_DATE|VT_BYREF:
{
SYSTEMTIME wintime;
struct tm *phptime;
phptime = gmtime(&(pval_arg->value.lval));
wintime.wYear = phptime->tm_year + 1900;
wintime.wMonth = phptime->tm_mon + 1;
wintime.wDay = phptime->tm_mday;
wintime.wHour = phptime->tm_hour;
wintime.wMinute = phptime->tm_min;
wintime.wSecond = phptime->tm_sec;
SystemTimeToVariantTime(&wintime, var_arg->pdate);
}
case VT_BSTR|VT_BYREF:
convert_to_string(pval_arg);
var_arg->pbstrVal = (BSTR FAR*) emalloc(sizeof(BSTR FAR*));
unicode_str = php_char_to_OLECHAR(pval_arg->value.str.val, pval_arg->value.str.len, codepage);
*(var_arg->pbstrVal) = SysAllocString(unicode_str);
efree(unicode_str);
break;
case VT_UNKNOWN|VT_BYREF:
php_pval_to_variant(pval_arg, var_arg, codepage);
if(var_arg->vt != VT_DISPATCH)
{
VariantInit(var_arg);
}
else
{
HRESULT hr;
hr = var_arg->pdispVal->lpVtbl->QueryInterface(var_arg->pdispVal, &IID_IUnknown, &(var_arg->punkVal));
if(FAILED(hr))
{
php_error(E_WARNING,"can't query IUnknown");
VariantInit(var_arg);
}
else
{
var_arg->vt = VT_UNKNOWN|VT_BYREF;
}
}
break;
case VT_DISPATCH|VT_BYREF:
php_pval_to_variant(pval_arg, var_arg, codepage);
if(var_arg->vt != VT_DISPATCH)
{
VariantInit(var_arg);
}
else
{
var_arg->vt |= VT_BYREF;
}
break;
case VT_VARIANT|VT_BYREF:
php_pval_to_variant(pval_arg, var_arg, codepage);
if(var_arg->vt != (VT_VARIANT | VT_BYREF))
{
VariantInit(var_arg);
}
break;
case VT_I1:
convert_to_long_ex(&pval_arg);
var_arg->cVal = (char)pval_arg->value.lval;
break;
case VT_UI2:
convert_to_long_ex(&pval_arg);
var_arg->uiVal = (unsigned short)pval_arg->value.lval;
break;
case VT_UI4:
convert_to_long_ex(&pval_arg);
var_arg->ulVal = (unsigned long)pval_arg->value.lval;
break;
case VT_INT:
convert_to_long_ex(&pval_arg);
var_arg->intVal = (int)pval_arg->value.lval;
break;
case VT_UINT:
convert_to_long_ex(&pval_arg);
var_arg->uintVal = (unsigned int)pval_arg->value.lval;
break;
case VT_I1|VT_BYREF:
convert_to_long(pval_arg);
var_arg->pcVal = (char FAR*) &pval_arg->value.lval;
break;
case VT_UI2|VT_BYREF:
convert_to_long(pval_arg);
var_arg->puiVal = (unsigned short FAR*) &pval_arg->value.lval;
break;
case VT_UI4|VT_BYREF:
convert_to_long(pval_arg);
var_arg->pulVal = (unsigned long FAR*) &pval_arg->value.lval;
break;
case VT_INT|VT_BYREF:
convert_to_long(pval_arg);
var_arg->pintVal = (int FAR*) &pval_arg->value.lval;
break;
case VT_UINT|VT_BYREF:
convert_to_long(pval_arg);
var_arg->puintVal = (unsigned int FAR*) &pval_arg->value.lval;
break;
default:
php_error(E_WARNING, "Type not supportet or not yet implemented.");
}
}
PHPAPI int php_variant_to_pval(VARIANT *var_arg, pval *pval_arg, int persistent, int codepage)
{
/* Changed the function to return a value for recursive error testing */
/* Existing calls will be unaffected by the change - so it */
/* seemed like the smallest impact on unfamiliar code */
int ret = SUCCESS;
/* Add SafeArray support */
switch(var_arg->vt & ~VT_BYREF)
{
case VT_ARRAY:
{
SAFEARRAY *array = V_ARRAY(var_arg);
LONG indices[1];
LONG lbound=0, ubound;
VARTYPE vartype;
register int ii;
UINT Dims;
VARIANT vv;
pval *element;
/* TODO: Add support for multi-dimensional SafeArrays */
/* For now just validate that the SafeArray has one dimension */
if (1 != (Dims = SafeArrayGetDim(array)))
{
php_error(E_WARNING,"Unsupported: multi-dimensional (%d) SafeArrays", Dims);
var_reset(pval_arg);
return FAILURE;
}
/* This call has failed for everything I have tried */
/* But best leave it to be on the safe side */
if (S_OK != SafeArrayGetVartype(array, &vartype))
{
/* Fall back to what we do know */
/* Mask off the array bit and assume */
/* what is left is the type of the array */
/* elements */
vartype = var_arg->vt & ~VT_ARRAY;
}
SafeArrayGetUBound(array, 1, &ubound);
SafeArrayGetLBound(array, 1, &lbound);
/* Since COM returned an array we set up the php */
/* return value to be an array */
array_init(pval_arg);
/* Walk the safe array */
for (ii=lbound;ii<=ubound;ii++)
{
indices[0] = ii;
VariantInit(&vv); /* Docs say this just set the vt field, but you never know */
/* Set up a variant to pass to a recursive call */
/* So that we do not need to have two copies */
/* of the code */
vv.vt = vartype;
if (S_OK != SafeArrayGetElement(array, indices, (VOID *) &(vv.lVal)))
{
/* Failure to retieve an element probably means the array is sparse */
/* So leave the php array sparse too */
continue;
}
/* Create an element to be added to the array */
ALLOC_ZVAL(element);
/* Call ourself again to handle the base type conversion */
/* If SafeArrayGetElement proclaims to allocate */
/* memory for a BSTR, so the recursive call frees */
/* the string correctly */
if (FAILURE == php_variant_to_pval(&vv, element, persistent, codepage))
{
/* Error occurred setting up array element */
/* Error was displayed by the recursive call */
FREE_ZVAL(element);
/* TODO: Do we stop here, or go on and */
/* try to make sense of the rest of the array */
/* Going on leads to multiple errors displayed */
/* for the same conversion. For large arrays that */
/* could be very annoying */
/* And if we don't go on - what to do about */
/* the parts of the array that are OK? */
/* break; */
}
else
{
/* Just insert the element into our return array */
add_index_zval(pval_arg, ii, element);
}
}
/* Clean up the SafeArray since that is our responsibility */
SafeArrayDestroyData(array);
SafeArrayDestroyDescriptor(array);
}
break;
case VT_EMPTY:
var_uninit(pval_arg);
break;
case VT_UI1:
if(var_arg->vt & VT_BYREF)
{
ZVAL_LONG(pval_arg, (long)*(var_arg->pbVal));
}
else
{
ZVAL_LONG(pval_arg, (long)var_arg->pbVal);
}
break;
case VT_I2:
if(var_arg->vt & VT_BYREF)
{
ZVAL_LONG(pval_arg, (long )*(var_arg->piVal));
}
else
{
ZVAL_LONG(pval_arg, (long)var_arg->iVal);
}
break;
case VT_I4:
if(var_arg->vt & VT_BYREF)
{
ZVAL_LONG(pval_arg, *(var_arg->plVal));
}
else
{
ZVAL_LONG(pval_arg, var_arg->lVal);
}
break;
case VT_R4:
if(var_arg->vt & VT_BYREF)
{
ZVAL_DOUBLE(pval_arg, (double)*(var_arg->pfltVal));
}
else
{
ZVAL_DOUBLE(pval_arg, (double)var_arg->fltVal);
}
break;
case VT_R8:
if(var_arg->vt & VT_BYREF)
{
ZVAL_DOUBLE(pval_arg, *(var_arg->pdblVal));
}
else
{
ZVAL_DOUBLE(pval_arg, var_arg->dblVal);
}
break;
/* 96bit uint */
case VT_DECIMAL:
{
OLECHAR *unicode_str;
switch(VarBstrFromDec(&var_arg->decVal, LOCALE_SYSTEM_DEFAULT, 0, &unicode_str))
{
case S_OK:
pval_arg->value.str.val = php_OLECHAR_to_char(unicode_str, &pval_arg->value.str.len, persistent, codepage);
pval_arg->type = IS_STRING;
break;
default:
ZVAL_NULL(pval_arg);
ret = FAILURE;
php_error(E_WARNING, "Error converting DECIMAL value to PHP string");
break;
}
}
break;
/* Currency */
case VT_CY:
if(var_arg->vt & VT_BYREF)
{
VarR8FromCy(var_arg->cyVal, &(pval_arg->value.dval));
}
else
{
VarR8FromCy(*(var_arg->pcyVal), &(pval_arg->value.dval));
}
pval_arg->type = IS_DOUBLE;
break;
case VT_BOOL:
if(var_arg->vt & VT_BYREF)
{
ZVAL_BOOL(pval_arg, *(var_arg->pboolVal));
}
else
{
ZVAL_BOOL(pval_arg, var_arg->boolVal);
}
break;
case VT_NULL:
case VT_VOID:
ZVAL_NULL(pval_arg);
break;
case VT_VARIANT:
php_variant_to_pval(var_arg->pvarVal, pval_arg, persistent, codepage);
break;
case VT_BSTR:
if(pval_arg->is_ref == 0 || (var_arg->vt & VT_BYREF) != VT_BYREF)
{
pval_arg->value.str.val = php_OLECHAR_to_char(var_arg->bstrVal, &pval_arg->value.str.len, persistent, codepage);
SysFreeString(var_arg->bstrVal);
}
else
{
pval_arg->value.str.val = php_OLECHAR_to_char(*(var_arg->pbstrVal), &pval_arg->value.str.len, persistent, codepage);
SysFreeString(*(var_arg->pbstrVal));
efree(var_arg->pbstrVal);
}
pval_arg->type = IS_STRING;
break;
case VT_DATE: {
SYSTEMTIME wintime;
struct tm phptime;
if((var_arg->vt & VT_BYREF) != VT_BYREF)
{
VariantTimeToSystemTime(var_arg->date, &wintime);
}
else
{
VariantTimeToSystemTime(*(var_arg->pdate), &wintime);
}
phptime.tm_year = wintime.wYear - 1900;
phptime.tm_mon = wintime.wMonth - 1;
phptime.tm_mday = wintime.wDay;
phptime.tm_hour = wintime.wHour;
phptime.tm_min = wintime.wMinute;
phptime.tm_sec = wintime.wSecond;
phptime.tm_isdst = -1;
tzset();
ZVAL_LONG(pval_arg, mktime(&phptime));
}
break;
case VT_UNKNOWN:
if(var_arg->punkVal == NULL)
{
var_arg->pdispVal = NULL;
}
else
{
HRESULT hr;
hr = var_arg->punkVal->lpVtbl->QueryInterface(var_arg->punkVal, &IID_IDispatch, &(var_arg->pdispVal));
if(FAILED(hr))
{
char *error_message;
error_message = php_COM_error_message(hr);
php_error(E_WARNING,"Unable to obtain IDispatch interface: %s", error_message);
LocalFree(error_message);
var_arg->pdispVal = NULL;
}
}
/* break missing intentionaly */
case VT_DISPATCH:
{
pval *handle;
i_dispatch *obj;
if(var_arg->pdispVal == NULL)
{
ret = FAILURE;
ZVAL_NULL(pval_arg);
}
else
{
pval_arg->type = IS_OBJECT;
pval_arg->value.obj.ce = &com_class_entry;
pval_arg->value.obj.properties = (HashTable *) emalloc(sizeof(HashTable));
pval_arg->is_ref = 1;
pval_arg->refcount = 1;
zend_hash_init(pval_arg->value.obj.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
ALLOC_ZVAL(handle);
obj = emalloc(sizeof(i_dispatch));
php_COM_set(obj, var_arg->pdispVal, TRUE);
handle->type = IS_LONG;
handle->value.lval = zend_list_insert(obj, php_COM_get_le_idispatch());
pval_copy_constructor(handle);
INIT_PZVAL(handle);
zend_hash_index_update(pval_arg->value.obj.properties, 0, &handle, sizeof(pval *), NULL);
}
}
break;
case VT_I1:
if(var_arg->vt & VT_BYREF)
{
ZVAL_LONG(pval_arg, (long)*(var_arg->pcVal));
}
else
{
ZVAL_LONG(pval_arg, (long)var_arg->cVal);
}
break;
case VT_UI2:
if(var_arg->vt & VT_BYREF)
{
ZVAL_LONG(pval_arg, (long)*(var_arg->puiVal));
}
else
{
ZVAL_LONG(pval_arg, (long)var_arg->uiVal);
}
break;
case VT_UI4:
if(var_arg->vt & VT_BYREF)
{
ZVAL_LONG(pval_arg, (long)*(var_arg->pulVal));
}
else
{
ZVAL_LONG(pval_arg, (long)var_arg->ulVal);
}
break;
case VT_INT:
if(var_arg->vt & VT_BYREF)
{
ZVAL_LONG(pval_arg, (long)*(var_arg->pintVal));
}
else
{
ZVAL_LONG(pval_arg, (long)var_arg->intVal);
}
break;
case VT_UINT:
if(var_arg->vt & VT_BYREF)
{
ZVAL_LONG(pval_arg, (long)*(var_arg->puintVal));
}
else
{
ZVAL_LONG(pval_arg, (long)var_arg->uintVal);
}
break;
default:
php_error(E_WARNING,"Unsupported variant type: %d (0x%X)", var_arg->vt, var_arg->vt);
ZVAL_NULL(pval_arg);
ret = FAILURE;
break;
}
return ret;
}
PHPAPI OLECHAR *php_char_to_OLECHAR(char *C_str, uint strlen, int codepage)
{
OLECHAR *unicode_str;
//request needed buffersize
uint reqSize = MultiByteToWideChar(codepage, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, C_str, -1, NULL, 0);
if(reqSize)
{
unicode_str = (OLECHAR *) emalloc(sizeof(OLECHAR) * reqSize);
//convert string
MultiByteToWideChar(codepage, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, C_str, -1, unicode_str, reqSize);
}
else
{
unicode_str = (OLECHAR *) emalloc(sizeof(OLECHAR));
*unicode_str = 0;
switch(GetLastError())
{
case ERROR_NO_UNICODE_TRANSLATION:
php_error(E_WARNING,"No unicode translation available for the specified string");
break;
default:
php_error(E_WARNING,"Error in php_char_to_OLECHAR()");
}
}
return unicode_str;
}
PHPAPI char *php_OLECHAR_to_char(OLECHAR *unicode_str, uint *out_length, int persistent, int codepage)
{
char *C_str;
uint length = 0;
//request needed buffersize
uint reqSize = WideCharToMultiByte(codepage, WC_COMPOSITECHECK, unicode_str, -1, NULL, 0, NULL, NULL);
if(reqSize)
{
C_str = (char *) pemalloc(sizeof(char) * reqSize, persistent);
//convert string
length = WideCharToMultiByte(codepage, WC_COMPOSITECHECK, unicode_str, -1, C_str, reqSize, NULL, NULL) - 1;
}
else
{
C_str = (char *) pemalloc(sizeof(char), persistent);
*C_str = 0;
php_error(E_WARNING,"Error in php_OLECHAR_to_char()");
}
if(out_length)
{
*out_length = length;
}
return C_str;
}
#endif /* PHP_WIN32 */
Reference in New Issue View Git Blame Copy Permalink