diff -r cc09a5c2b5fb -r 1911c0fa3c76 perfopts/openvg.cpp
--- a/perfopts/openvg.cpp	Wed Oct 20 10:16:24 2010 +0100
+++ b/perfopts/openvg.cpp	Wed Oct 20 10:19:12 2010 +0100
@@ -18,437 +18,437 @@
 
 extern "C" {
 
-EXPORT_C VGErrorCode   vgGetError(void)
+EXPORT_C VGErrorCode   vgGetError(void) __SOFTFP
    {
    return do_vgGetError();
    }
 
-EXPORT_C void   vgFlush(void)
+EXPORT_C void   vgFlush(void) __SOFTFP
    {
    return do_vgFlush();
    }
 
-EXPORT_C void   vgFinish(void)
+EXPORT_C void   vgFinish(void) __SOFTFP
    {
    return do_vgFinish();
    }
 
-EXPORT_C void  vgSetf (VGParamType type, VGfloat value)
+EXPORT_C  void  vgSetf (VGParamType type, VGfloat value) __SOFTFP
    {
    return do_vgSetf(type,value);
    }
 
-EXPORT_C void   vgSeti (VGParamType type, VGint value)
+EXPORT_C void   vgSeti (VGParamType type, VGint value) __SOFTFP
    {
    return do_vgSeti(type,value);
    }
 
-EXPORT_C void   vgSetfv(VGParamType type, VGint count ,const VGfloat* values)
+EXPORT_C  void  vgSetfv(VGParamType type, VGint count ,const VGfloat* values) __SOFTFP
    {
    return do_vgSetfv(type,count,values);
    }
 
-EXPORT_C void   vgSetiv(VGParamType type, VGint count ,const VGint* values)
+EXPORT_C void   vgSetiv(VGParamType type, VGint count ,const VGint* values) __SOFTFP
    {
    return do_vgSetiv(type,count,values);
    }
 
-EXPORT_C VGfloat   vgGetf(VGParamType type)
+EXPORT_C  VGfloat   vgGetf(VGParamType type) __SOFTFP
    {
    return do_vgGetf(type);
    }
 
-EXPORT_C VGint     vgGeti(VGParamType type)
+EXPORT_C VGint     vgGeti(VGParamType type) __SOFTFP
    {
    return do_vgGeti(type);
    }
 
-EXPORT_C VGint     vgGetVectorSize(VGParamType type)
+EXPORT_C VGint     vgGetVectorSize(VGParamType type) __SOFTFP
    {
    return do_vgGetVectorSize(type);
    }
 
-EXPORT_C void      vgGetfv(VGParamType type, VGint count ,VGfloat* values)
+EXPORT_C  void      vgGetfv(VGParamType type, VGint count ,VGfloat* values) __SOFTFP
    {
    return do_vgGetfv(type,count,values);
    }
 
-EXPORT_C void      vgGetiv(VGParamType type, VGint count ,VGint* values)
+EXPORT_C void      vgGetiv(VGParamType type, VGint count ,VGint* values) __SOFTFP
    {
    return do_vgGetiv(type,count,values);
    }
 
-EXPORT_C void   vgSetParameterf(VGHandle object ,VGint paramType ,VGfloat value)
+EXPORT_C  void   vgSetParameterf(VGHandle object ,VGint paramType ,VGfloat value) __SOFTFP
    {
    return do_vgSetParameterf(object,paramType,value);
    }
 
-EXPORT_C void   vgSetParameteri(VGHandle object ,VGint paramType ,VGint value)
+EXPORT_C void   vgSetParameteri(VGHandle object ,VGint paramType ,VGint value) __SOFTFP
    {
    return do_vgSetParameteri(object,paramType,value);
    }
 
-EXPORT_C void   vgSetParameterfv(VGHandle object ,VGint paramType ,VGint count ,const VGfloat* values)
+EXPORT_C  void   vgSetParameterfv(VGHandle object ,VGint paramType ,VGint count ,const VGfloat* values) __SOFTFP
    {
    return do_vgSetParameterfv(object,paramType,count,values);
    }
 
-EXPORT_C void   vgSetParameteriv(VGHandle object ,VGint paramType ,VGint count ,const VGint* values)
+EXPORT_C void   vgSetParameteriv(VGHandle object ,VGint paramType ,VGint count ,const VGint* values) __SOFTFP
    {
    return do_vgSetParameteriv(object,paramType,count,values);
    }
 
-EXPORT_C VGfloat   vgGetParameterf(VGHandle object ,VGint paramType)
+EXPORT_C  VGfloat   vgGetParameterf(VGHandle object ,VGint paramType) __SOFTFP
    {
    return do_vgGetParameterf(object,paramType);
    }
 
-EXPORT_C VGint   vgGetParameteri(VGHandle object ,VGint paramType)
+EXPORT_C VGint   vgGetParameteri(VGHandle object ,VGint paramType) __SOFTFP
    {
    return do_vgGetParameteri(object,paramType);
    }
 
-EXPORT_C VGint   vgGetParameterVectorSize(VGHandle object ,VGint paramType)
+EXPORT_C VGint   vgGetParameterVectorSize(VGHandle object ,VGint paramType) __SOFTFP
    {
    return do_vgGetParameterVectorSize(object,paramType);
    }
 
-EXPORT_C void   vgGetParameterfv(VGHandle object ,VGint paramType ,VGint count ,VGfloat* values)
+EXPORT_C  void   vgGetParameterfv(VGHandle object ,VGint paramType ,VGint count ,VGfloat* values) __SOFTFP
    {
    return do_vgGetParameterfv(object,paramType,count,values);
    }
 
-EXPORT_C void   vgGetParameteriv(VGHandle object ,VGint paramType ,VGint count ,VGint* values)
+EXPORT_C void   vgGetParameteriv(VGHandle object ,VGint paramType ,VGint count ,VGint* values) __SOFTFP
    {
    return do_vgGetParameteriv(object,paramType,count,values);
    }
 
-EXPORT_C void   vgLoadIdentity(void)
+EXPORT_C void   vgLoadIdentity(void) __SOFTFP
    {
    return do_vgLoadIdentity();
    }
 
-EXPORT_C void   vgLoadMatrix(const VGfloat* m)
+EXPORT_C  void   vgLoadMatrix(const VGfloat* m) __SOFTFP
    {
    return do_vgLoadMatrix(m);
    }
 
-EXPORT_C void   vgGetMatrix(VGfloat* m)
+EXPORT_C  void   vgGetMatrix(VGfloat* m) __SOFTFP
    {
    return do_vgGetMatrix(m);
    }
 
-EXPORT_C void   vgMultMatrix(const  VGfloat* m)
+EXPORT_C  void   vgMultMatrix(const  VGfloat* m) __SOFTFP
    {
    return do_vgMultMatrix(m);
    }
 
-EXPORT_C void   vgTranslate(VGfloat tx, VGfloat ty)
+EXPORT_C  void   vgTranslate(VGfloat tx, VGfloat ty) __SOFTFP
    {
    return do_vgTranslate(tx,ty);
    }
 
-EXPORT_C void   vgScale(VGfloat sx, VGfloat sy)
+EXPORT_C  void   vgScale(VGfloat sx, VGfloat sy) __SOFTFP
    {
    return do_vgScale(sx,sy);
    }
 
-EXPORT_C void   vgShear(VGfloat shx, VGfloat shy)
+EXPORT_C  void   vgShear(VGfloat shx, VGfloat shy) __SOFTFP
    {
    return do_vgShear(shx,shy);
    }
 
-EXPORT_C void   vgRotate(VGfloat angle)
+EXPORT_C  void   vgRotate(VGfloat angle) __SOFTFP
    {
    return do_vgRotate(angle);
    }
 
-EXPORT_C void   vgMask(VGHandle mask, VGMaskOperation operation ,VGint x, VGint y ,VGint width, VGint height)
+EXPORT_C void   vgMask(VGHandle mask, VGMaskOperation operation ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
    {
    return do_vgMask(mask,operation,x,y,width,height);
    }
 
-EXPORT_C void   vgRenderToMask(VGPath path ,VGbitfield paintModes ,VGMaskOperation operation)
+EXPORT_C void   vgRenderToMask(VGPath path ,VGbitfield paintModes ,VGMaskOperation operation) __SOFTFP
    {
    return do_vgRenderToMask(path,paintModes,operation);
    }
 
-EXPORT_C VGMaskLayer   vgCreateMaskLayer(VGint width, VGint height)
+EXPORT_C VGMaskLayer   vgCreateMaskLayer(VGint width, VGint height) __SOFTFP
    {
    return do_vgCreateMaskLayer(width,height);
    }
 
-EXPORT_C void   vgDestroyMaskLayer(VGMaskLayer maskLayer)
+EXPORT_C void   vgDestroyMaskLayer(VGMaskLayer maskLayer) __SOFTFP
    {
    return do_vgDestroyMaskLayer(maskLayer);
    }
 
-EXPORT_C void   vgFillMaskLayer(VGMaskLayer maskLayer ,VGint x, VGint y ,VGint width, VGint height ,VGfloat value)
+EXPORT_C  void   vgFillMaskLayer(VGMaskLayer maskLayer ,VGint x, VGint y ,VGint width, VGint height ,VGfloat value) __SOFTFP
    {
    return do_vgFillMaskLayer(maskLayer,x,y,width,height,value);
    }
 
-EXPORT_C void   vgCopyMask(VGMaskLayer maskLayer ,VGint sx, VGint sy ,VGint dx, VGint dy ,VGint width, VGint height)
+EXPORT_C void   vgCopyMask(VGMaskLayer maskLayer ,VGint sx, VGint sy ,VGint dx, VGint dy ,VGint width, VGint height) __SOFTFP
    {
    return do_vgCopyMask(maskLayer,sx,sy,dx,dy,width,height);
    }
 
-EXPORT_C void   vgClear(VGint x, VGint y ,VGint width, VGint height)
+EXPORT_C void   vgClear(VGint x, VGint y ,VGint width, VGint height) __SOFTFP
    {
    return do_vgClear(x,y,width,height);
    }
 
-EXPORT_C VGPath   vgCreatePath(VGint pathFormat ,VGPathDatatype datatype ,VGfloat scale, VGfloat bias ,VGint segmentCapacityHint ,VGint coordCapacityHint ,VGbitfield capabilities)
+EXPORT_C  VGPath   vgCreatePath(VGint pathFormat ,VGPathDatatype datatype ,VGfloat scale, VGfloat bias ,VGint segmentCapacityHint ,VGint coordCapacityHint ,VGbitfield capabilities) __SOFTFP
    {
    return do_vgCreatePath(pathFormat,datatype,scale,bias,segmentCapacityHint,coordCapacityHint,capabilities);
    }
 
-EXPORT_C void   vgClearPath(VGPath path, VGbitfield capabilities)
+EXPORT_C void   vgClearPath(VGPath path, VGbitfield capabilities) __SOFTFP
    {
    return do_vgClearPath(path,capabilities);
    }
 
-EXPORT_C void   vgDestroyPath(VGPath path)
+EXPORT_C void   vgDestroyPath(VGPath path) __SOFTFP
    {
    return do_vgDestroyPath(path);
    }
 
-EXPORT_C void   vgRemovePathCapabilities(VGPath path ,VGbitfield capabilities)
+EXPORT_C void   vgRemovePathCapabilities(VGPath path ,VGbitfield capabilities) __SOFTFP
    {
    return do_vgRemovePathCapabilities(path,capabilities);
    }
 
-EXPORT_C VGbitfield   vgGetPathCapabilities(VGPath path)
+EXPORT_C VGbitfield   vgGetPathCapabilities(VGPath path) __SOFTFP
    {
    return do_vgGetPathCapabilities(path);
    }
 
-EXPORT_C void   vgAppendPath(VGPath dstPath, VGPath srcPath)
+EXPORT_C void   vgAppendPath(VGPath dstPath, VGPath srcPath) __SOFTFP
    {
    return do_vgAppendPath(dstPath,srcPath);
    }
 
-EXPORT_C void   vgAppendPathData(VGPath dstPath ,VGint numSegments ,const  VGubyte* pathSegments ,const  void* pathData)
+EXPORT_C void   vgAppendPathData(VGPath dstPath ,VGint numSegments ,const  VGubyte* pathSegments ,const  void* pathData) __SOFTFP
    {
    return do_vgAppendPathData(dstPath,numSegments,pathSegments,pathData);
    }
 
-EXPORT_C void   vgModifyPathCoords(VGPath dstPath ,VGint startIndex ,VGint numSegments ,const void* pathData)
+EXPORT_C void   vgModifyPathCoords(VGPath dstPath ,VGint startIndex ,VGint numSegments ,const void* pathData) __SOFTFP
    {
    return do_vgModifyPathCoords(dstPath,startIndex,numSegments,pathData);
    }
 
-EXPORT_C void   vgTransformPath(VGPath dstPath, VGPath srcPath)
+EXPORT_C void   vgTransformPath(VGPath dstPath, VGPath srcPath) __SOFTFP
    {
    return do_vgTransformPath(dstPath,srcPath);
    }
 
-EXPORT_C VGboolean   vgInterpolatePath(VGPath dstPath ,VGPath startPath ,VGPath endPath ,VGfloat amount)
+EXPORT_C  VGboolean   vgInterpolatePath(VGPath dstPath ,VGPath startPath ,VGPath endPath ,VGfloat amount) __SOFTFP
    {
    return do_vgInterpolatePath(dstPath,startPath,endPath,amount);
    }
 
-EXPORT_C VGfloat   vgPathLength(VGPath path ,VGint startSegment ,VGint numSegments)
+EXPORT_C  VGfloat   vgPathLength(VGPath path ,VGint startSegment ,VGint numSegments) __SOFTFP
    {
    return do_vgPathLength(path,startSegment,numSegments);
    }
 
-EXPORT_C void   vgPointAlongPath(VGPath path ,VGint startSegment ,VGint numSegments ,VGfloat distance ,VGfloat* x, VGfloat* y ,VGfloat* tangentX ,VGfloat* tangentY)
+EXPORT_C  void   vgPointAlongPath(VGPath path ,VGint startSegment ,VGint numSegments ,VGfloat distance ,VGfloat* x, VGfloat* y ,VGfloat* tangentX ,VGfloat* tangentY) __SOFTFP
    {
    return do_vgPointAlongPath(path,startSegment,numSegments,distance,x,y,tangentX,tangentY);
    }
 
-EXPORT_C void   vgPathBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height)
+EXPORT_C  void   vgPathBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height) __SOFTFP
    {
    return do_vgPathBounds(path,minX,minY,width,height);
    }
 
-EXPORT_C void   vgPathTransformedBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height)
+EXPORT_C  void   vgPathTransformedBounds(VGPath path ,VGfloat* minX ,VGfloat* minY ,VGfloat* width ,VGfloat* height) __SOFTFP
    {
    return do_vgPathTransformedBounds(path,minX,minY,width,height);
    }
 
-EXPORT_C void   vgDrawPath(VGPath path, VGbitfield paintModes)
+EXPORT_C void   vgDrawPath(VGPath path, VGbitfield paintModes) __SOFTFP
    {
    return do_vgDrawPath(path,paintModes);
    }
 
-EXPORT_C VGPaint   vgCreatePaint(void)
+EXPORT_C VGPaint   vgCreatePaint(void) __SOFTFP
    {
    return do_vgCreatePaint();
    }
 
-EXPORT_C void   vgDestroyPaint(VGPaint paint)
+EXPORT_C void   vgDestroyPaint(VGPaint paint) __SOFTFP
    {
    return do_vgDestroyPaint(paint);
    }
 
-EXPORT_C void   vgSetPaint(VGPaint paint, VGbitfield paintModes)
+EXPORT_C void   vgSetPaint(VGPaint paint, VGbitfield paintModes) __SOFTFP
    {
    return do_vgSetPaint(paint,paintModes);
    }
 
-EXPORT_C VGPaint   vgGetPaint(VGPaintMode paintMode)
+EXPORT_C VGPaint   vgGetPaint(VGPaintMode paintMode) __SOFTFP
    {
    return do_vgGetPaint(paintMode);
    }
 
-EXPORT_C void   vgSetColor(VGPaint paint, VGuint rgba)
+EXPORT_C void   vgSetColor(VGPaint paint, VGuint rgba) __SOFTFP
    {
    return do_vgSetColor(paint,rgba);
    }
 
-EXPORT_C VGuint   vgGetColor(VGPaint paint)
+EXPORT_C VGuint   vgGetColor(VGPaint paint) __SOFTFP
    {
    return do_vgGetColor(paint);
    }
 
-EXPORT_C void   vgPaintPattern(VGPaint paint, VGImage pattern)
+EXPORT_C void   vgPaintPattern(VGPaint paint, VGImage pattern) __SOFTFP
    {
    return do_vgPaintPattern(paint,pattern);
    }
 
-EXPORT_C VGImage   vgCreateImage(VGImageFormat format ,VGint width, VGint height ,VGbitfield allowedQuality)
+EXPORT_C VGImage   vgCreateImage(VGImageFormat format ,VGint width, VGint height ,VGbitfield allowedQuality) __SOFTFP
    {
    return do_vgCreateImage(format,width,height,allowedQuality);
    }
 
-EXPORT_C void   vgDestroyImage(VGImage image)
+EXPORT_C void   vgDestroyImage(VGImage image) __SOFTFP
    {
    return do_vgDestroyImage(image);
    }
 
-EXPORT_C void   vgClearImage(VGImage image ,VGint x, VGint y ,VGint width, VGint height)
+EXPORT_C void   vgClearImage(VGImage image ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
    {
    return do_vgClearImage(image,x,y,width,height);
    }
 
-EXPORT_C void   vgImageSubData(VGImage image ,const void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height)
+EXPORT_C void   vgImageSubData(VGImage image ,const void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
    {
    return do_vgImageSubData(image,data,dataStride,dataFormat,x,y,width,height);
    }
 
-EXPORT_C void   vgGetImageSubData(VGImage image ,void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height)
+EXPORT_C void   vgGetImageSubData(VGImage image ,void* data ,VGint dataStride ,VGImageFormat dataFormat ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
    {
    return do_vgGetImageSubData(image,data,dataStride,dataFormat,x,y,width,height);
    }
 
-EXPORT_C VGImage   vgChildImage(VGImage parent ,VGint x, VGint y ,VGint width, VGint height)
+EXPORT_C VGImage   vgChildImage(VGImage parent ,VGint x, VGint y ,VGint width, VGint height) __SOFTFP
    {
    return do_vgChildImage(parent,x,y,width,height);
    }
 
-EXPORT_C VGImage   vgGetParent(VGImage image)
+EXPORT_C VGImage   vgGetParent(VGImage image) __SOFTFP
    {
    return do_vgGetParent(image);
    }
 
-EXPORT_C void   vgCopyImage(VGImage dst, VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height ,VGboolean dither)
+EXPORT_C void   vgCopyImage(VGImage dst, VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height ,VGboolean dither) __SOFTFP
    {
    return do_vgCopyImage(dst,dx,dy,src,sx,sy,width,height,dither);
    }
 
-EXPORT_C void   vgDrawImage(VGImage image)
+EXPORT_C void   vgDrawImage(VGImage image) __SOFTFP
    {
    return do_vgDrawImage(image);
    }
 
-EXPORT_C void   vgSetPixels(VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height)
+EXPORT_C void   vgSetPixels(VGint dx, VGint dy ,VGImage src, VGint sx, VGint sy ,VGint width, VGint height) __SOFTFP
    {
    return do_vgSetPixels(dx,dy,src,sx,sy,width,height);
    }
 
-EXPORT_C void   vgWritePixels(const void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint dx, VGint dy ,VGint width, VGint height)
+EXPORT_C void   vgWritePixels(const void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint dx, VGint dy ,VGint width, VGint height) __SOFTFP
    {
    return do_vgWritePixels(data,dataStride,dataFormat,dx,dy,width,height);
    }
 
-EXPORT_C void   vgGetPixels(VGImage dst, VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height)
+EXPORT_C void   vgGetPixels(VGImage dst, VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height) __SOFTFP
    {
    return do_vgGetPixels(dst,dx,dy,sx,sy,width,height);
    }
 
-EXPORT_C void   vgReadPixels(void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint sx, VGint sy ,VGint width, VGint height)
+EXPORT_C void   vgReadPixels(void* data, VGint dataStride ,VGImageFormat dataFormat ,VGint sx, VGint sy ,VGint width, VGint height) __SOFTFP
    {
    return do_vgReadPixels(data,dataStride,dataFormat,sx,sy,width,height);
    }
 
-EXPORT_C void   vgCopyPixels(VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height)
+EXPORT_C void   vgCopyPixels(VGint dx, VGint dy ,VGint sx, VGint sy ,VGint width, VGint height) __SOFTFP
    {
    return do_vgCopyPixels(dx,dy,sx,sy,width,height);
    }
 
-EXPORT_C VGFont   vgCreateFont(VGint glyphCapacityHint)
+EXPORT_C VGFont   vgCreateFont(VGint glyphCapacityHint) __SOFTFP
    {
    return do_vgCreateFont(glyphCapacityHint);
    }
 
-EXPORT_C void   vgDestroyFont(VGFont font)
+EXPORT_C void   vgDestroyFont(VGFont font) __SOFTFP
    {
    return do_vgDestroyFont(font);
    }
 
-EXPORT_C void   vgSetGlyphToPath(VGFont font ,VGuint glyphIndex ,VGPath path ,VGboolean isHinted ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2])
+EXPORT_C  void   vgSetGlyphToPath(VGFont font ,VGuint glyphIndex ,VGPath path ,VGboolean isHinted ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2]) __SOFTFP
    {
    return do_vgSetGlyphToPath(font,glyphIndex,path,isHinted,glyphOrigin,escapement);
    }
 
-EXPORT_C void   vgSetGlyphToImage(VGFont font ,VGuint glyphIndex ,VGImage image ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2])
+EXPORT_C  void   vgSetGlyphToImage(VGFont font ,VGuint glyphIndex ,VGImage image ,const VGfloat glyphOrigin [2] ,const VGfloat escapement[2]) __SOFTFP
    {
    return do_vgSetGlyphToImage(font,glyphIndex,image,glyphOrigin,escapement);
    }
 
-EXPORT_C void   vgClearGlyph(VGFont font ,VGuint glyphIndex)
+EXPORT_C void   vgClearGlyph(VGFont font ,VGuint glyphIndex) __SOFTFP
    {
    return do_vgClearGlyph(font,glyphIndex);
    }
 
-EXPORT_C void   vgDrawGlyph(VGFont font ,VGuint glyphIndex ,VGbitfield paintModes ,VGboolean allowAutoHinting)
+EXPORT_C void   vgDrawGlyph(VGFont font ,VGuint glyphIndex ,VGbitfield paintModes ,VGboolean allowAutoHinting) __SOFTFP
    {
    return do_vgDrawGlyph(font,glyphIndex,paintModes,allowAutoHinting);
    }
 
-EXPORT_C void   vgDrawGlyphs(VGFont font ,VGint glyphCount ,const VGuint* glyphIndices ,const VGfloat* adjustments_x ,const VGfloat* adjustments_y ,VGbitfield paintModes ,VGboolean allowAutoHinting)
+EXPORT_C  void   vgDrawGlyphs(VGFont font ,VGint glyphCount ,const VGuint* glyphIndices ,const VGfloat* adjustments_x ,const VGfloat* adjustments_y ,VGbitfield paintModes ,VGboolean allowAutoHinting) __SOFTFP
    {
    return do_vgDrawGlyphs(font,glyphCount,glyphIndices,adjustments_x,adjustments_y,paintModes,allowAutoHinting);
    }
 
-EXPORT_C void   vgColorMatrix(VGImage dst, VGImage src ,const VGfloat* matrix)
+EXPORT_C  void   vgColorMatrix(VGImage dst, VGImage src ,const VGfloat* matrix) __SOFTFP
    {
    return do_vgColorMatrix(dst,src,matrix);
    }
 
-EXPORT_C void   vgConvolve(VGImage dst, VGImage src ,VGint kernelWidth, VGint kernelHeight ,VGint shiftX, VGint shiftY ,const VGshort* kernel ,VGfloat scale ,VGfloat bias ,VGTilingMode tilingMode)
+EXPORT_C  void   vgConvolve(VGImage dst, VGImage src ,VGint kernelWidth, VGint kernelHeight ,VGint shiftX, VGint shiftY ,const VGshort* kernel ,VGfloat scale ,VGfloat bias ,VGTilingMode tilingMode) __SOFTFP
    {
    return do_vgConvolve(dst,src,kernelWidth,kernelHeight,shiftX,shiftY,kernel,scale,bias,tilingMode);
    }
 
-EXPORT_C void   vgSeparableConvolve(VGImage dst, VGImage src ,VGint kernelWidth ,VGint kernelHeight ,VGint shiftX, VGint shiftY ,const VGshort* kernelX ,const VGshort* kernelY ,VGfloat scale ,VGfloat bias ,VGTilingMode tilingMode)
+EXPORT_C  void   vgSeparableConvolve(VGImage dst, VGImage src ,VGint kernelWidth ,VGint kernelHeight ,VGint shiftX, VGint shiftY ,const VGshort* kernelX ,const VGshort* kernelY ,VGfloat scale ,VGfloat bias ,VGTilingMode tilingMode) __SOFTFP
    {
    return do_vgSeparableConvolve(dst,src,kernelWidth,kernelHeight,shiftX,shiftY,kernelX,kernelY,scale,bias,tilingMode);
    }
 
-EXPORT_C void   vgGaussianBlur(VGImage dst, VGImage src ,VGfloat stdDeviationX ,VGfloat stdDeviationY ,VGTilingMode tilingMode)
+EXPORT_C  void   vgGaussianBlur(VGImage dst, VGImage src ,VGfloat stdDeviationX ,VGfloat stdDeviationY ,VGTilingMode tilingMode) __SOFTFP
    {
    return do_vgGaussianBlur(dst,src,stdDeviationX,stdDeviationY,tilingMode);
    }
 
-EXPORT_C void   vgLookup(VGImage dst, VGImage src ,const VGubyte* redLUT ,const VGubyte* greenLUT ,const VGubyte* blueLUT ,const VGubyte* alphaLUT ,VGboolean outputLinear ,VGboolean outputPremultiplied)
+EXPORT_C void   vgLookup(VGImage dst, VGImage src ,const VGubyte* redLUT ,const VGubyte* greenLUT ,const VGubyte* blueLUT ,const VGubyte* alphaLUT ,VGboolean outputLinear ,VGboolean outputPremultiplied) __SOFTFP
    {
    return do_vgLookup(dst,src,redLUT,greenLUT,blueLUT,alphaLUT,outputLinear,outputPremultiplied);
    }
 
-EXPORT_C void   vgLookupSingle(VGImage dst, VGImage src ,const VGuint* lookupTable ,VGImageChannel sourceChannel ,VGboolean outputLinear ,VGboolean outputPremultiplied)
+EXPORT_C void   vgLookupSingle(VGImage dst, VGImage src ,const VGuint* lookupTable ,VGImageChannel sourceChannel ,VGboolean outputLinear ,VGboolean outputPremultiplied) __SOFTFP
    {
    return do_vgLookupSingle(dst,src,lookupTable,sourceChannel,outputLinear,outputPremultiplied);
    }
 
-EXPORT_C VGHardwareQueryResult   vgHardwareQuery        (VGHardwareQueryType key ,VGint setting)
+EXPORT_C VGHardwareQueryResult   vgHardwareQuery        (VGHardwareQueryType key ,VGint setting) __SOFTFP
    {
    return do_vgHardwareQuery(key,setting);
    }
 
-EXPORT_C const VGubyte *   vgGetString(VGStringID name)
+EXPORT_C const VGubyte *   vgGetString(VGStringID name) __SOFTFP
    {
    return do_vgGetString(name);
    }