//--------------------------------------------------------------------------- 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); }