//---------------------------------------------------------------------------
long File::writeFloat (float value)
{
unsigned long result = 0;
gosASSERT(!isNAN(&value));
if (parent == NULL)
{
if (isOpen())
{
if ( inRAM )
{
if ( logicalPosition + sizeof( value ) > physicalLength )
return BAD_WRITE_ERR;
memcpy( fileImage + logicalPosition, &value, sizeof( value ) );
result = sizeof( value );
}
else
result = _write(handle,(&value),sizeof(float));
if (result == sizeof(float))
{
logicalPosition += sizeof(float);
result = NO_ERR;
}
else
{
result = BAD_WRITE_ERR;
}
}
else
{
lastError = FILE_NOT_OPEN;
}
}
else
{
lastError = CANT_WRITE_TO_CHILD;
}
return(result);
}
static double
ecvt_rint(double x)
{
double s, t, one;
one = 1.0;
if (ecvt_init == 0) {
int i;
L = 1.0;
for (i = 52; i != 0; i--)
L *= 2.0;
ecvt_init = 1;
}
if (isNAN(x))
return (x);
if (ecvt_copysign(x, one) >= L) /* already an integer */
return (x);
s = ecvt_copysign(L, x);
t = x + s; /* x+s rounded to integer */
return (t - s);
}
float File::readFloat( void )
{
float value = 0;
unsigned long result = 0;
if (inRAM && fileImage)
{
char *readAddress = (char*)fileImage+logicalPosition;
memcpy((char *)(&value),readAddress,sizeof(value));
logicalPosition += sizeof(value);
}
else if (fastFile)
{
result = fastFile->readFast(fastFileHandle,(char *)&value,sizeof(value));
logicalPosition += sizeof(value);
}
else
{
if (isOpen())
{
result = _read(handle,(&value),sizeof(value));
logicalPosition += sizeof(value);
if (result != sizeof(value))
lastError = errno;
}
else
{
lastError = FILE_NOT_OPEN;
}
}
if (isNAN(&value)) {
gosASSERT(false);
value = 1.0/*arbitrary value that seems safe*/;
}
return value;
}
// read gpx format
BOOLINT minipath::read_gpx_format(ministrings &gpx)
{
unsigned int trk,trkseg,trkpt;
if (gpx.empty()) return(FALSE);
if (gpx[0].startswith("<?xml"))
{
minixml xml;
xml.from_strings(gpx);
if (xml.get("gpx.version").empty()) return(FALSE);
if (!xml.get("gpx.description").empty())
description=xml.get("gpx.description");
for (trk=1; ; trk++)
{
ministring prefix="gpx.trk";
if (trk>1) prefix+="#"+ministring(trk);
if (xml.get(prefix+".trkseg.trkpt.lat").empty() ||
xml.get(prefix+".trkseg.trkpt.lon").empty() ||
xml.get(prefix+".trkseg.trkpt.time").empty()) break;
for (trkseg=1; ; trkseg++)
{
ministring infix=".trkseg";
if (trkseg>1) infix+="#"+ministring(trkseg);
if (xml.get(prefix+infix+".trkpt.lat").empty() ||
xml.get(prefix+infix+".trkpt.lon").empty() ||
xml.get(prefix+infix+".trkpt.time").empty()) break;
for (trkpt=1; ; trkpt++)
{
ministring infix2=".trkpt";
if (trkpt>1) infix2+="#"+ministring(trkpt);
ministring lat=xml.get(prefix+infix+infix2+".lat");
ministring lon=xml.get(prefix+infix+infix2+".lon");
ministring ele=xml.get(prefix+infix+infix2+".ele");
ministring time=xml.get(prefix+infix+infix2+".time");
ministring hdop=xml.get(prefix+infix+infix2+".hdop");
ministring vdop=xml.get(prefix+infix+infix2+".vdop");
ministring pdop=xml.get(prefix+infix+infix2+".pdop");
ministring speed=xml.get(prefix+infix+infix2+".speed");
ministring degrees=xml.get(prefix+infix+infix2+".degrees");
ministring description=xml.get(prefix+infix+infix2+".description");
if (lat.empty() || lon.empty() || time.empty()) break;
minimeas meas;
meas.set_llh(lat.value(),lon.value(),ele.value(),utc2unixtime(time),crs_orb);
meas.accuracy=pdop.value();
if (isNAN(meas.accuracy))
{
meas.accuracy=hdop.value();
if (isNAN(meas.accuracy))
meas.accuracy=vdop.value();
}
meas.velocity=speed.value();
meas.heading=degrees.value();
if (!description.empty())
meas.set_description(description);
append(meas);
}
}
}
return(gpx.empty());
}
return(FALSE);
}
HRESULT VariantChangeTypeSpecial(VARIANT* pvargDest, VARIANT* pVArg, VARTYPE vt, IServiceProvider* pSrvProvider/*=NULL*/, DWORD dwFlags/*=0*/)
{
HRESULT hr;
IVariantChangeType* pVarChangeType = NULL;
if(pSrvProvider)
{
hr = pSrvProvider->QueryService(SID_VariantConversion,
IID_IVariantChangeType, (void**)&pVarChangeType);
if(hr)
{
goto OldWay;
}
// Use script engine conversion routine.
hr = pVarChangeType->ChangeType(pvargDest, pVArg, 0, vt);
if(!hr)
{
goto Cleanup; // ChangeType suceeded we're done...
}
}
// Fall back to our tried & trusted type coercions
OldWay:
hr = S_OK;
if(vt==VT_BSTR && V_VT(pVArg)==VT_NULL)
{
// Converting a NULL to BSTR
V_VT(pvargDest) = VT_BSTR;
hr = FormsAllocString(_T("null"), &V_BSTR(pvargDest));
goto Cleanup;
}
else if(vt==VT_BSTR && V_VT(pVArg)==VT_EMPTY)
{
// Converting "undefined" to BSTR
V_VT(pvargDest) = VT_BSTR;
hr = FormsAllocString(_T("undefined"), &V_BSTR(pvargDest));
goto Cleanup;
}
else if(vt==VT_BOOL && V_VT(pVArg)==VT_BSTR)
{
// Converting from BSTR to BOOL
// To match Navigator compatibility empty strings implies false when
// assigned to a boolean type any other string implies true.
V_VT(pvargDest) = VT_BOOL;
V_BOOL(pvargDest) = FormsStringLen(V_BSTR(pVArg))==0 ? VARIANT_FALSE : VARIANT_TRUE;
goto Cleanup;
}
else if(V_VT(pVArg)==VT_BOOL && vt==VT_BSTR)
{
// Converting from BOOL to BSTR
// To match Nav we either get "true" or "false"
V_VT(pvargDest) = VT_BSTR;
hr = FormsAllocString(
V_BOOL(pVArg)==VARIANT_TRUE?_T("true"):_T("false"),
&V_BSTR(pvargDest));
goto Cleanup;
}
// If we're converting R4 or R8 to a string then we need special handling to
// map Nan and +/-Inf.
else if(vt==VT_BSTR && (V_VT(pVArg)==VT_R8||V_VT(pVArg)==VT_R4))
{
double dblValue = V_VT(pVArg)==VT_R8 ? V_R8(pVArg) : (double)(V_R4(pVArg));
// Infinity or NAN?
if(!isFinite(dblValue))
{
if(isNAN(dblValue))
{
// NAN
hr = FormsAllocStringW(_T("NaN"), &(V_BSTR(pvargDest)));
}
else
{
// Infinity
hr = FormsAllocStringW((dblValue<0)?_T("-Infinity"):_T("Infinity"), &(V_BSTR(pvargDest)));
}
}
else
{
goto DefaultConvert;
}
// Any error from allocating string?
if(hr)
{
goto Cleanup;
}
V_VT(pvargDest) = vt;
goto Cleanup;
}
DefaultConvert:
// Default VariantChangeTypeEx.
// VARIANT_NOUSEROVERRIDE flag is undocumented flag that tells OLEAUT to convert to the lcid
// given. Without it the conversion is done to user localeid
hr = VariantChangeTypeEx(pvargDest, pVArg, LCID_SCRIPTING, dwFlags|VARIANT_NOUSEROVERRIDE, vt);
if(hr == DISP_E_TYPEMISMATCH)
{
if(V_VT(pVArg) == VT_NULL)
{
hr = S_OK;
switch(vt)
{
case VT_BOOL:
V_BOOL(pvargDest) = VARIANT_FALSE;
V_VT(pvargDest) = VT_BOOL;
break;
// For NS compatability - NS treats NULL args as 0
default:
V_I4(pvargDest)=0;
break;
}
}
else if(V_VT(pVArg) == VT_DISPATCH)
{
// Nav compatability - return the string [object] or null
V_VT(pvargDest) = VT_BSTR;
hr = FormsAllocString((V_DISPATCH(pVArg))?_T("[object]"):_T("null"), &V_BSTR(pvargDest));
}
else if(V_VT(pVArg)==VT_BSTR &&
(V_BSTR(pVArg) && ((V_BSTR(pVArg))[0]==_T('\0')) ||!V_BSTR(pVArg)) &&
(vt==VT_I4 || vt==VT_I2 || vt==VT_UI2||vt==VT_UI4
|| vt==VT_I8||vt==VT_UI8 || vt==VT_INT || vt==VT_UINT))
{
// Converting empty string to integer => Zero
hr = S_OK;
V_VT(pvargDest) = vt;
V_I4(pvargDest) = 0;
goto Cleanup;
}
}
else if(hr==DISP_E_OVERFLOW && vt==VT_I4 && (V_VT(pVArg)==VT_R8 || V_VT(pVArg)==VT_R4))
{
// Nav compatability - return MAXLONG on overflow
V_VT(pvargDest) = VT_I4;
V_I4(pvargDest) = MAXLONG;
hr = S_OK;
goto Cleanup;
}
// To match Navigator change any scientific notation E to e.
if(!hr && (vt==VT_BSTR && (V_VT(pVArg)==VT_R8 || V_VT(pVArg)==VT_R4)))
{
TCHAR* pENotation;
pENotation = _tcschr(V_BSTR(pvargDest), _T('E'));
if(pENotation)
{
*pENotation = _T('e');
}
}
Cleanup:
ReleaseInterface(pVarChangeType);
RRETURN(hr);
}
