diff -Naur gnustep-gui-0.9.4.orig/Headers/AppKit/DPSOperators.h gnustep-gui-0.9.4/Headers/AppKit/DPSOperators.h
--- gnustep-gui-0.9.4.orig/Headers/AppKit/DPSOperators.h	Thu Jul 31 23:52:08 2003
+++ gnustep-gui-0.9.4/Headers/AppKit/DPSOperators.h	Tue Nov  2 13:11:11 2004
@@ -32,60 +32,60 @@
 /* Color operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPScurrentalpha(GSCTXT *ctxt, float* a)
+DPScurrentalpha(GSCTXT *ctxt_GSCTXT, float *alphaFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentcmykcolor(GSCTXT *ctxt, float* c, float* m, float* y, float* k)
+DPScurrentcmykcolor(GSCTXT *ctxt_GSCTXT, float *cyanFloatPtr, float *magentaFloatPtr, float *yellowFloatPtr, float *kBlackFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentgray(GSCTXT *ctxt, float* gray)
+DPScurrentgray(GSCTXT *ctxt_GSCTXT, float *grayFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrenthsbcolor(GSCTXT *ctxt, float* h, float* s, float* b)
+DPScurrenthsbcolor(GSCTXT *ctxt_GSCTXT, float *hueFloatPtr, float *saturationFloatPtr, float *brightnessFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentrgbcolor(GSCTXT *ctxt, float* r, float* g, float* b)
+DPScurrentrgbcolor(GSCTXT *ctxt_GSCTXT, float *redFloatPtr, float *greenFloatPtr, float *blueFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPSsetalpha(GSCTXT *ctxt, float a)
+DPSsetalpha(GSCTXT *ctxt_GSCTXT, float alphaFloat)
 __attribute__((unused));
 
 static inline void
-DPSsetcmykcolor(GSCTXT *ctxt, float c, float m, float y, float k)
+DPSsetcmykcolor(GSCTXT *ctxt_GSCTXT, float cyanFloat, float magentaFloat, float yellowFloat, float fBlackFloat)
 __attribute__((unused));
 
 static inline void
-DPSsetgray(GSCTXT *ctxt, float gray)
+DPSsetgray(GSCTXT *ctxt_GSCTXT, float grayFloat)
 __attribute__((unused));
 
 static inline void
-DPSsethsbcolor(GSCTXT *ctxt, float h, float s, float b)
+DPSsethsbcolor(GSCTXT *ctxt_GSCTXT, float hueFloat, float saturationFloat, float brightnessFloat)
 __attribute__((unused));
 
 static inline void
-DPSsetrgbcolor(GSCTXT *ctxt, float r, float g, float b)
+DPSsetrgbcolor(GSCTXT *ctxt_GSCTXT, float redFloat, float greenFloat, float blueFloat)
 __attribute__((unused));
 
 
 static inline void
-GSSetFillColorspace(GSCTXT *ctxt, NSDictionary * dict)
+GSSetFillColorspace(GSCTXT *ctxt_GSCTXT, NSDictionary *anNSDictionary)
 __attribute__((unused));
 
 static inline void
-GSSetStrokeColorspace(GSCTXT *ctxt, NSDictionary * dict)
+GSSetStrokeColorspace(GSCTXT *ctxt_GSCTXT, NSDictionary *anNSDictionary)
 __attribute__((unused));
 
 static inline void
-GSSetFillColor(GSCTXT *ctxt, float * values)
+GSSetFillColor(GSCTXT *ctxt_GSCTXT, float *valuesFloatPtr)
 __attribute__((unused));
 
 static inline void
-GSSetStrokeColor(GSCTXT *ctxt, float * values)
+GSSetStrokeColor(GSCTXT *ctxt_GSCTXT, float *valuesFloatPtr)
 __attribute__((unused));
 
 
@@ -93,76 +93,76 @@
 /* Text operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPSashow(GSCTXT *ctxt, float x, float y, const char* s)
+DPSashow(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, const char *sConstChar)
 __attribute__((unused));
 
 static inline void
-DPSawidthshow(GSCTXT *ctxt, float cx, float cy, int c, float ax, float ay, const char* s)
+DPSawidthshow(GSCTXT *ctxt_GSCTXT, float cxFloat, float cyFloat, int cInt, float axFloat, float ayFloat, const char *sConstChar)
 __attribute__((unused));
 
 static inline void
-DPScharpath(GSCTXT *ctxt, const char* s, int b)
+DPScharpath(GSCTXT *ctxt_GSCTXT, const char *sConstChar, int bInt)
 __attribute__((unused));
 
 static inline void
-DPSshow(GSCTXT *ctxt, const char* s)
+DPSshow(GSCTXT *ctxt_GSCTXT, const char *sConstChar)
 __attribute__((unused));
 
 static inline void
-DPSwidthshow(GSCTXT *ctxt, float x, float y, int c, const char* s)
+DPSwidthshow(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, int cInt, const char *sConstChar)
 __attribute__((unused));
 
 static inline void
-DPSxshow(GSCTXT *ctxt, const char* s, const float* numarray, int size)
+DPSxshow(GSCTXT *ctxt_GSCTXT, const char *sConstChar, const float *numarrayFloatPtr, int size)
 __attribute__((unused));
 
 static inline void
-DPSxyshow(GSCTXT *ctxt, const char* s, const float* numarray, int size)
+DPSxyshow(GSCTXT *ctxt_GSCTXT, const char *sConstChar, const float *numarrayFloatPtr, int size)
 __attribute__((unused));
 
 static inline void
-DPSyshow(GSCTXT *ctxt, const char* s, const float* numarray, int size)
+DPSyshow(GSCTXT *ctxt_GSCTXT, const char *sConstChar, const float *numarrayFloatPtr, int size)
 __attribute__((unused));
 
 
 static inline void
-GSSetCharacterSpacing(GSCTXT *ctxt, float extra)
+GSSetCharacterSpacing(GSCTXT *ctxt_GSCTXT, float extraFloat)
 __attribute__((unused));
 
 static inline void
-GSSetFont(GSCTXT *ctxt, NSFont* font)
+GSSetFont(GSCTXT *ctxt_GSCTXT, NSFont *anNSFont)
 __attribute__((unused));
 
 static inline void
-GSSetFontSize(GSCTXT *ctxt, float size)
+GSSetFontSize(GSCTXT *ctxt_GSCTXT, float size)
 __attribute__((unused));
 
 static inline NSAffineTransform *
-GSGetTextCTM(GSCTXT *ctxt)
+GSGetTextCTM(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline NSPoint
-GSGetTextPosition(GSCTXT *ctxt)
+GSGetTextPosition(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-GSSetTextCTM(GSCTXT *ctxt, NSAffineTransform * ctm)
+GSSetTextCTM(GSCTXT *ctxt_GSCTXT, NSAffineTransform *ctmNSAffineTransform)
 __attribute__((unused));
 
 static inline void
-GSSetTextDrawingMode(GSCTXT *ctxt, GSTextDrawingMode mode)
+GSSetTextDrawingMode(GSCTXT *ctxt_GSCTXT, GSTextDrawingMode mode_GSTextDrawingMode)
 __attribute__((unused));
 
 static inline void
-GSSetTextPosition(GSCTXT *ctxt, NSPoint loc)
+GSSetTextPosition(GSCTXT *ctxt_GSCTXT, NSPoint anNSPoint)
 __attribute__((unused));
 
 static inline void
-GSShowText(GSCTXT *ctxt, const char * string, size_t length)
+GSShowText(GSCTXT *ctxt_GSCTXT, const char *sConstChar, size_t length)
 __attribute__((unused));
 
 static inline void
-GSShowGlyphs(GSCTXT *ctxt, const NSGlyph * glyphs, size_t length)
+GSShowGlyphs(GSCTXT *ctxt_GSCTXT, const NSGlyph *glyphsNSGlyphPtr, size_t length)
 __attribute__((unused));
 
 
@@ -170,95 +170,95 @@
 /* Gstate Handling */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPSgrestore(GSCTXT *ctxt)
+DPSgrestore(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSgsave(GSCTXT *ctxt)
+DPSgsave(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSinitgraphics(GSCTXT *ctxt)
+DPSinitgraphics(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSsetgstate(GSCTXT *ctxt, int gst)
+DPSsetgstate(GSCTXT *ctxt_GSCTXT, int gStateTagInt)
 __attribute__((unused));
 
 
 static inline int
-GSDefineGState(GSCTXT *ctxt)
+GSDefineGState(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-GSUndefineGState(GSCTXT *ctxt, int gst)
+GSUndefineGState(GSCTXT *ctxt_GSCTXT, int gStateTagInt)
 __attribute__((unused));
 
 static inline void
-GSReplaceGState(GSCTXT *ctxt, int gst)
+GSReplaceGState(GSCTXT *ctxt_GSCTXT, int gStateTagInt)
 __attribute__((unused));
 
 /* ----------------------------------------------------------------------- */
 /* Gstate operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPScurrentflat(GSCTXT *ctxt, float* flatness)
+DPScurrentflat(GSCTXT *ctxt_GSCTXT, float *flatnessFloat)
 __attribute__((unused));
 
 static inline void
-DPScurrentlinecap(GSCTXT *ctxt, int* linecap)
+DPScurrentlinecap(GSCTXT *ctxt_GSCTXT, int *linecapIntPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentlinejoin(GSCTXT *ctxt, int* linejoin)
+DPScurrentlinejoin(GSCTXT *ctxt_GSCTXT, int *linejoinIntPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentlinewidth(GSCTXT *ctxt, float* width)
+DPScurrentlinewidth(GSCTXT *ctxt_GSCTXT, float *widthFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentmiterlimit(GSCTXT *ctxt, float* limit)
+DPScurrentmiterlimit(GSCTXT *ctxt_GSCTXT, float *limitFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentpoint(GSCTXT *ctxt, float* x, float* y)
+DPScurrentpoint(GSCTXT *ctxt_GSCTXT, float *xFloatPtr, float *yFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentstrokeadjust(GSCTXT *ctxt, int* b)
+DPScurrentstrokeadjust(GSCTXT *ctxt_GSCTXT, int *bIntPtr)
 __attribute__((unused));
 
 static inline void
-DPSsetdash(GSCTXT *ctxt, const float* pat, int size, float offset)
+DPSsetdash(GSCTXT *ctxt_GSCTXT, const float *patternFloatPtr, int size, float offsetFloat)
 __attribute__((unused));
 
 static inline void
-DPSsetflat(GSCTXT *ctxt, float flatness)
+DPSsetflat(GSCTXT *ctxt_GSCTXT, float flatnessFloat)
 __attribute__((unused));
 
 static inline void
-DPSsethalftonephase(GSCTXT *ctxt, float x, float y)
+DPSsethalftonephase(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-DPSsetlinecap(GSCTXT *ctxt, int linecap)
+DPSsetlinecap(GSCTXT *ctxt_GSCTXT, int linecapInt)
 __attribute__((unused));
 
 static inline void
-DPSsetlinejoin(GSCTXT *ctxt, int linejoin)
+DPSsetlinejoin(GSCTXT *ctxt_GSCTXT, int linejoinInt)
 __attribute__((unused));
 
 static inline void
-DPSsetlinewidth(GSCTXT *ctxt, float width)
+DPSsetlinewidth(GSCTXT *ctxt_GSCTXT, float widthFloat)
 __attribute__((unused));
 
 static inline void
-DPSsetmiterlimit(GSCTXT *ctxt, float limit)
+DPSsetmiterlimit(GSCTXT *ctxt_GSCTXT, float limitFloat)
 __attribute__((unused));
 
 static inline void
-DPSsetstrokeadjust(GSCTXT *ctxt, int b)
+DPSsetstrokeadjust(GSCTXT *ctxt_GSCTXT, int bInt)
 __attribute__((unused));
 
 
@@ -266,36 +266,36 @@
 /* Matrix operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPSconcat(GSCTXT *ctxt, const float* m)
+DPSconcat(GSCTXT *ctxt_GSCTXT, const float *mFloatPtr)
 __attribute__((unused));
 
 static inline void
-DPSinitmatrix(GSCTXT *ctxt)
+DPSinitmatrix(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSrotate(GSCTXT *ctxt, float angle)
+DPSrotate(GSCTXT *ctxt_GSCTXT, float angleFloat)
 __attribute__((unused));
 
 static inline void
-DPSscale(GSCTXT *ctxt, float x, float y)
+DPSscale(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-DPStranslate(GSCTXT *ctxt, float x, float y)
+DPStranslate(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 __attribute__((unused));
 
 
 static inline NSAffineTransform *
-GSCurrentCTM(GSCTXT *ctxt)
+GSCurrentCTM(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-GSSetCTM(GSCTXT *ctxt, NSAffineTransform * ctm)
+GSSetCTM(GSCTXT *ctxt_GSCTXT, NSAffineTransform *ctmNSAffineTransform)
 __attribute__((unused));
 
 static inline void
-GSConcatCTM(GSCTXT *ctxt, NSAffineTransform * ctm)
+GSConcatCTM(GSCTXT *ctxt_GSCTXT, NSAffineTransform *ctmNSAffineTransform)
 __attribute__((unused));
 
 
@@ -303,112 +303,112 @@
 /* Paint operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPSarc(GSCTXT *ctxt, float x, float y, float r, float angle1, float angle2)
+DPSarc(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float radiusFloat, float angle1Float, float angle2Float)
 __attribute__((unused));
 
 static inline void
-DPSarcn(GSCTXT *ctxt, float x, float y, float r, float angle1, float angle2)
+DPSarcn(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float radiusFloat, float angle1Float, float angle2Float)
 __attribute__((unused));
 
 static inline void
-DPSarct(GSCTXT *ctxt, float x1, float y1, float x2, float y2, float r)
+DPSarct(GSCTXT *ctxt_GSCTXT, float x1Float, float y1Float, float x2Float, float y2Float, float radiusFloat)
 __attribute__((unused));
 
 static inline void
-DPSclip(GSCTXT *ctxt)
+DPSclip(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSclosepath(GSCTXT *ctxt)
+DPSclosepath(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPScurveto(GSCTXT *ctxt, float x1, float y1, float x2, float y2, float x3, float y3)
+DPScurveto(GSCTXT *ctxt_GSCTXT, float x1Float, float y1Float, float x2Float, float y2Float, float x3Float, float y3Float)
 __attribute__((unused));
 
 static inline void
-DPSeoclip(GSCTXT *ctxt)
+DPSeoclip(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSeofill(GSCTXT *ctxt)
+DPSeofill(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSfill(GSCTXT *ctxt)
+DPSfill(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSflattenpath(GSCTXT *ctxt)
+DPSflattenpath(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSinitclip(GSCTXT *ctxt)
+DPSinitclip(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSlineto(GSCTXT *ctxt, float x, float y)
+DPSlineto(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-DPSmoveto(GSCTXT *ctxt, float x, float y)
+DPSmoveto(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-DPSnewpath(GSCTXT *ctxt)
+DPSnewpath(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSpathbbox(GSCTXT *ctxt, float* llx, float* lly, float* urx, float* ury)
+DPSpathbbox(GSCTXT *ctxt_GSCTXT, float *lowerLeftXFloat, float *lowerLeftYFloat, float *upperRightXFloat, float *upperRightYFloat)
 __attribute__((unused));
 
 static inline void
-DPSrcurveto(GSCTXT *ctxt, float x1, float y1, float x2, float y2, float x3, float y3)
+DPSrcurveto(GSCTXT *ctxt_GSCTXT, float x1Float, float y1Float, float x2Float, float y2Float, float x3Float, float y3Float)
 __attribute__((unused));
 
 static inline void
-DPSrectclip(GSCTXT *ctxt, float x, float y, float w, float h)
+DPSrectclip(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat)
 __attribute__((unused));
 
 static inline void
-DPSrectfill(GSCTXT *ctxt, float x, float y, float w, float h)
+DPSrectfill(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat)
 __attribute__((unused));
 
 static inline void
-DPSrectstroke(GSCTXT *ctxt, float x, float y, float w, float h)
+DPSrectstroke(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat)
 __attribute__((unused));
 
 static inline void
-DPSreversepath(GSCTXT *ctxt)
+DPSreversepath(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSrlineto(GSCTXT *ctxt, float x, float y)
+DPSrlineto(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-DPSrmoveto(GSCTXT *ctxt, float x, float y)
+DPSrmoveto(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-DPSstroke(GSCTXT *ctxt)
+DPSstroke(GSCTXT *ctxt_GSCTXT)
 __attribute__((unused));
 
 static inline void
-DPSshfill(GSCTXT *ctxt, NSDictionary *shaderDictionary)
+DPSshfill(GSCTXT *ctxt_GSCTXT, NSDictionary *shaderDictionary)
 __attribute__((unused));
 
 
 static inline void
-GSSendBezierPath(GSCTXT *ctxt, NSBezierPath * path)
+GSSendBezierPath(GSCTXT *ctxt_GSCTXT, NSBezierPath *anNSBezierPath)
 __attribute__((unused));
 
 static inline void
-GSRectClipList(GSCTXT *ctxt, const NSRect * rects, int count)
+GSRectClipList(GSCTXT *ctxt_GSCTXT, const NSRect *rectsPtr, int countInt)
 __attribute__((unused));
 
 static inline void
-GSRectFillList(GSCTXT *ctxt, const NSRect * rects, int count)
+GSRectFillList(GSCTXT *ctxt_GSCTXT, const NSRect *rectsPtr, int countInt)
 __attribute__((unused));
 
 
@@ -416,19 +416,19 @@
 /* Window system ops */
 /* ----------------------------------------------------------------------- */
 static inline void
-GSCurrentDevice(GSCTXT *ctxt, void** device, int* x, int* y)
+GSCurrentDevice(GSCTXT *ctxt_GSCTXT, void** deviceVoidPtrPtr, int *xIntPtr, int *yIntPtr)
 __attribute__((unused));
 
 static inline void
-DPScurrentoffset(GSCTXT *ctxt, int* x, int* y)
+DPScurrentoffset(GSCTXT *ctxt_GSCTXT, int *xIntPtr, int *yIntPtr)
 __attribute__((unused));
 
 static inline void
-GSSetDevice(GSCTXT *ctxt, void* device, int x, int y)
+GSSetDevice(GSCTXT *ctxt_GSCTXT, void *deviceVoidPtrPtr, int xInt, int yInt)
 __attribute__((unused));
 
 static inline void
-DPSsetoffset(GSCTXT *ctxt, short int x, short int y)
+DPSsetoffset(GSCTXT *ctxt_GSCTXT, short int xShort, short int yShort)
 __attribute__((unused));
 
 
@@ -436,133 +436,133 @@
 /* Graphics Extensions Ops */
 /*-------------------------------------------------------------------------*/
 static inline void
-DPScomposite(GSCTXT *ctxt, float x, float y, float w, float h, int gstateNum, float dx, float dy, int op)
+DPScomposite(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat, int gstateNum, float destinationXFloat, float destinationYFloat, int compositingOperationInt)
 __attribute__((unused));
 
 static inline void
-DPScompositerect(GSCTXT *ctxt, float x, float y, float w, float h, int op)
+DPScompositerect(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat, int compositingOperationInt)
 __attribute__((unused));
 
 static inline void
-DPSdissolve(GSCTXT *ctxt, float x, float y, float w, float h, int gstateNum, float dx, float dy, float delta)
+DPSdissolve(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat, int gstateNum, float destinationXFloat, float destinationYFloat, float deltaFloat)
 __attribute__((unused));
 
 
 static inline void
-GSDrawImage(GSCTXT *ctxt, NSRect rect, void * imageref)
+GSDrawImage(GSCTXT *ctxt_GSCTXT, NSRect rect, void *imagerefVoidPtr)
 __attribute__((unused));
 
 /* ----------------------------------------------------------------------- */
 /* Postscript Client functions */
 /* ----------------------------------------------------------------------- */
 static void
-DPSPrintf(GSCTXT *ctxt, const char * fmt, ...)
+DPSPrintf(GSCTXT *ctxt_GSCTXT, const char *fmt, ...)
 __attribute__((unused));
 
 static inline void
-DPSWriteData(GSCTXT *ctxt, const char * buf, unsigned int count)
+DPSWriteData(GSCTXT *ctxt_GSCTXT, const char *buf, unsigned int countUnsignedInt)
 __attribute__((unused));
 
 /* ----------------------------------------------------------------------- */
 /* Color operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPScurrentalpha(GSCTXT *ctxt, float* a)
+DPScurrentalpha(GSCTXT *ctxt_GSCTXT, float *alphaFloatPtr)
 {
-  (ctxt->methods->DPScurrentalpha_)
-    (ctxt, @selector(DPScurrentalpha:), a);
+  (ctxt_GSCTXT->methods->DPScurrentalpha_)
+    (ctxt_GSCTXT, @selector(DPScurrentalpha:), alphaFloatPtr);
 }
 
 static inline void
-DPScurrentcmykcolor(GSCTXT *ctxt, float* c, float* m, float* y, float* k)
+DPScurrentcmykcolor(GSCTXT *ctxt_GSCTXT, float *cyanFloatPtr, float *magentaFloatPtr, float *yellowFloatPtr, float *kBlackFloatPtr)
 {
-  (ctxt->methods->DPScurrentcmykcolor____)
-    (ctxt, @selector(DPScurrentcmykcolor::::), c, m, y, k);
+  (ctxt_GSCTXT->methods->DPScurrentcmykcolor____)
+    (ctxt_GSCTXT, @selector(DPScurrentcmykcolor::::), cyanFloatPtr, magentaFloatPtr, yellowFloatPtr, kBlackFloatPtr);
 }
 
 static inline void
-DPScurrentgray(GSCTXT *ctxt, float* gray)
+DPScurrentgray(GSCTXT *ctxt_GSCTXT, float *grayFloatPtr)
 {
-  (ctxt->methods->DPScurrentgray_)
-    (ctxt, @selector(DPScurrentgray:), gray);
+  (ctxt_GSCTXT->methods->DPScurrentgray_)
+    (ctxt_GSCTXT, @selector(DPScurrentgray:), grayFloatPtr);
 }
 
 static inline void
-DPScurrenthsbcolor(GSCTXT *ctxt, float* h, float* s, float* b)
+DPScurrenthsbcolor(GSCTXT *ctxt_GSCTXT, float *hueFloatPtr, float *saturationFloatPtr, float *brightnessFloatPtr)
 {
-  (ctxt->methods->DPScurrenthsbcolor___)
-    (ctxt, @selector(DPScurrenthsbcolor:::), h, s, b);
+  (ctxt_GSCTXT->methods->DPScurrenthsbcolor___)
+    (ctxt_GSCTXT, @selector(DPScurrenthsbcolor:::), hueFloatPtr, saturationFloatPtr, brightnessFloatPtr);
 }
 
 static inline void
-DPScurrentrgbcolor(GSCTXT *ctxt, float* r, float* g, float* b)
+DPScurrentrgbcolor(GSCTXT *ctxt_GSCTXT, float *redFloatPtr, float *greenFloatPtr, float *blueFloatPtr)
 {
-  (ctxt->methods->DPScurrentrgbcolor___)
-    (ctxt, @selector(DPScurrentrgbcolor:::), r, g, b);
+  (ctxt_GSCTXT->methods->DPScurrentrgbcolor___)
+    (ctxt_GSCTXT, @selector(DPScurrentrgbcolor:::), redFloatPtr, greenFloatPtr, blueFloatPtr);
 }
 
 static inline void
-DPSsetalpha(GSCTXT *ctxt, float a)
+DPSsetalpha(GSCTXT *ctxt_GSCTXT, float alphaFloat)
 {
-  (ctxt->methods->DPSsetalpha_)
-    (ctxt, @selector(DPSsetalpha:), a);
+  (ctxt_GSCTXT->methods->DPSsetalpha_)
+    (ctxt_GSCTXT, @selector(DPSsetalpha:), alphaFloat);
 }
 
 static inline void
-DPSsetcmykcolor(GSCTXT *ctxt, float c, float m, float y, float k)
+DPSsetcmykcolor(GSCTXT *ctxt_GSCTXT, float cyanFloat, float magentaFloat, float yellowFloat, float fBlackFloat)
 {
-  (ctxt->methods->DPSsetcmykcolor____)
-    (ctxt, @selector(DPSsetcmykcolor::::), c, m, y, k);
+  (ctxt_GSCTXT->methods->DPSsetcmykcolor____)
+    (ctxt_GSCTXT, @selector(DPSsetcmykcolor::::), cyanFloat, magentaFloat, yellowFloat, fBlackFloat);
 }
 
 static inline void
-DPSsetgray(GSCTXT *ctxt, float gray)
+DPSsetgray(GSCTXT *ctxt_GSCTXT, float grayFloat)
 {
-  (ctxt->methods->DPSsetgray_)
-    (ctxt, @selector(DPSsetgray:), gray);
+  (ctxt_GSCTXT->methods->DPSsetgray_)
+    (ctxt_GSCTXT, @selector(DPSsetgray:), grayFloat);
 }
 
 static inline void
-DPSsethsbcolor(GSCTXT *ctxt, float h, float s, float b)
+DPSsethsbcolor(GSCTXT *ctxt_GSCTXT, float hueFloat, float saturationFloat, float brightnessFloat)
 {
-  (ctxt->methods->DPSsethsbcolor___)
-    (ctxt, @selector(DPSsethsbcolor:::), h, s, b);
+  (ctxt_GSCTXT->methods->DPSsethsbcolor___)
+    (ctxt_GSCTXT, @selector(DPSsethsbcolor:::), hueFloat, saturationFloat, brightnessFloat);
 }
 
 static inline void
-DPSsetrgbcolor(GSCTXT *ctxt, float r, float g, float b)
+DPSsetrgbcolor(GSCTXT *ctxt_GSCTXT, float redFloat, float greenFloat, float blueFloat)
 {
-  (ctxt->methods->DPSsetrgbcolor___)
-    (ctxt, @selector(DPSsetrgbcolor:::), r, g, b);
+  (ctxt_GSCTXT->methods->DPSsetrgbcolor___)
+    (ctxt_GSCTXT, @selector(DPSsetrgbcolor:::), redFloat, greenFloat, blueFloat);
 }
 
 
 static inline void
-GSSetFillColorspace(GSCTXT *ctxt, NSDictionary * dict)
+GSSetFillColorspace(GSCTXT *ctxt_GSCTXT, NSDictionary *anNSDictionary)
 {
-  (ctxt->methods->GSSetFillColorspace_)
-    (ctxt, @selector(GSSetFillColorspace:), dict);
+  (ctxt_GSCTXT->methods->GSSetFillColorspace_)
+    (ctxt_GSCTXT, @selector(GSSetFillColorspace:), anNSDictionary);
 }
 
 static inline void
-GSSetStrokeColorspace(GSCTXT *ctxt, NSDictionary * dict)
+GSSetStrokeColorspace(GSCTXT *ctxt_GSCTXT, NSDictionary *anNSDictionary)
 {
-  (ctxt->methods->GSSetStrokeColorspace_)
-    (ctxt, @selector(GSSetStrokeColorspace:), dict);
+  (ctxt_GSCTXT->methods->GSSetStrokeColorspace_)
+    (ctxt_GSCTXT, @selector(GSSetStrokeColorspace:), anNSDictionary);
 }
 
 static inline void
-GSSetFillColor(GSCTXT *ctxt, float * values)
+GSSetFillColor(GSCTXT *ctxt_GSCTXT, float *valuesFloatPtr)
 {
-  (ctxt->methods->GSSetFillColor_)
-    (ctxt, @selector(GSSetFillColor:), values);
+  (ctxt_GSCTXT->methods->GSSetFillColor_)
+    (ctxt_GSCTXT, @selector(GSSetFillColor:), valuesFloatPtr);
 }
 
 static inline void
-GSSetStrokeColor(GSCTXT *ctxt, float * values)
+GSSetStrokeColor(GSCTXT *ctxt_GSCTXT, float *valuesFloatPtr)
 {
-  (ctxt->methods->GSSetStrokeColor_)
-    (ctxt, @selector(GSSetStrokeColor:), values);
+  (ctxt_GSCTXT->methods->GSSetStrokeColor_)
+    (ctxt_GSCTXT, @selector(GSSetStrokeColor:), valuesFloatPtr);
 }
 
 
@@ -570,130 +570,130 @@
 /* Text operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPSashow(GSCTXT *ctxt, float x, float y, const char* s)
+DPSashow(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, const char *sConstChar)
 {
-  (ctxt->methods->DPSashow___)
-    (ctxt, @selector(DPSashow:::), x, y, s);
+  (ctxt_GSCTXT->methods->DPSashow___)
+    (ctxt_GSCTXT, @selector(DPSashow:::), xFloat, yFloat, sConstChar);
 }
 
 static inline void
-DPSawidthshow(GSCTXT *ctxt, float cx, float cy, int c, float ax, float ay, const char* s)
+DPSawidthshow(GSCTXT *ctxt_GSCTXT, float cxFloat, float cyFloat, int cInt, float axFloat, float ayFloat, const char *sConstChar)
 {
-  (ctxt->methods->DPSawidthshow______)
-    (ctxt, @selector(DPSawidthshow::::::), cx, cy, c, ax, ay, s);
+  (ctxt_GSCTXT->methods->DPSawidthshow______)
+    (ctxt_GSCTXT, @selector(DPSawidthshow::::::), cxFloat, cyFloat, cInt, axFloat, ayFloat, sConstChar);
 }
 
 static inline void
-DPScharpath(GSCTXT *ctxt, const char* s, int b)
+DPScharpath(GSCTXT *ctxt_GSCTXT, const char *sConstChar, int bInt)
 {
-  (ctxt->methods->DPScharpath__)
-    (ctxt, @selector(DPScharpath::), s, b);
+  (ctxt_GSCTXT->methods->DPScharpath__)
+    (ctxt_GSCTXT, @selector(DPScharpath::), sConstChar, bInt);
 }
 
 static inline void
-DPSshow(GSCTXT *ctxt, const char* s)
+DPSshow(GSCTXT *ctxt_GSCTXT, const char *sConstChar)
 {
-  (ctxt->methods->DPSshow_)
-    (ctxt, @selector(DPSshow:), s);
+  (ctxt_GSCTXT->methods->DPSshow_)
+    (ctxt_GSCTXT, @selector(DPSshow:), sConstChar);
 }
 
 static inline void
-DPSwidthshow(GSCTXT *ctxt, float x, float y, int c, const char* s)
+DPSwidthshow(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, int cInt, const char *sConstChar)
 {
-  (ctxt->methods->DPSwidthshow____)
-    (ctxt, @selector(DPSwidthshow::::), x, y, c, s);
+  (ctxt_GSCTXT->methods->DPSwidthshow____)
+    (ctxt_GSCTXT, @selector(DPSwidthshow::::), xFloat, yFloat, cInt, sConstChar);
 }
 
 static inline void
-DPSxshow(GSCTXT *ctxt, const char* s, const float* numarray, int size)
+DPSxshow(GSCTXT *ctxt_GSCTXT, const char *sConstChar, const float *numarrayFloatPtr, int size)
 {
-  (ctxt->methods->DPSxshow___)
-    (ctxt, @selector(DPSxshow:::), s, numarray, size);
+  (ctxt_GSCTXT->methods->DPSxshow___)
+    (ctxt_GSCTXT, @selector(DPSxshow:::), sConstChar, numarrayFloatPtr, size);
 }
 
 static inline void
-DPSxyshow(GSCTXT *ctxt, const char* s, const float* numarray, int size)
+DPSxyshow(GSCTXT *ctxt_GSCTXT, const char *sConstChar, const float *numarrayFloatPtr, int size)
 {
-  (ctxt->methods->DPSxyshow___)
-    (ctxt, @selector(DPSxyshow:::), s, numarray, size);
+  (ctxt_GSCTXT->methods->DPSxyshow___)
+    (ctxt_GSCTXT, @selector(DPSxyshow:::), sConstChar, numarrayFloatPtr, size);
 }
 
 static inline void
-DPSyshow(GSCTXT *ctxt, const char* s, const float* numarray, int size)
+DPSyshow(GSCTXT *ctxt_GSCTXT, const char *sConstChar, const float *numarrayFloatPtr, int size)
 {
-  (ctxt->methods->DPSyshow___)
-    (ctxt, @selector(DPSyshow:::), s, numarray, size);
+  (ctxt_GSCTXT->methods->DPSyshow___)
+    (ctxt_GSCTXT, @selector(DPSyshow:::), sConstChar, numarrayFloatPtr, size);
 }
 
 
 static inline void
-GSSetCharacterSpacing(GSCTXT *ctxt, float extra)
+GSSetCharacterSpacing(GSCTXT *ctxt_GSCTXT, float extraFloat)
 {
-  (ctxt->methods->GSSetCharacterSpacing_)
-    (ctxt, @selector(GSSetCharacterSpacing:), extra);
+  (ctxt_GSCTXT->methods->GSSetCharacterSpacing_)
+    (ctxt_GSCTXT, @selector(GSSetCharacterSpacing:), extraFloat);
 }
 
 static inline void
-GSSetFont(GSCTXT *ctxt, NSFont* font)
+GSSetFont(GSCTXT *ctxt_GSCTXT, NSFont *anNSFont)
 {
-  (ctxt->methods->GSSetFont_)
-    (ctxt, @selector(GSSetFont:), font);
+  (ctxt_GSCTXT->methods->GSSetFont_)
+    (ctxt_GSCTXT, @selector(GSSetFont:), anNSFont);
 }
 
 static inline void
-GSSetFontSize(GSCTXT *ctxt, float size)
+GSSetFontSize(GSCTXT *ctxt_GSCTXT, float size)
 {
-  (ctxt->methods->GSSetFontSize_)
-    (ctxt, @selector(GSSetFontSize:), size);
+  (ctxt_GSCTXT->methods->GSSetFontSize_)
+    (ctxt_GSCTXT, @selector(GSSetFontSize:), size);
 }
 
 static inline NSAffineTransform *
-GSGetTextCTM(GSCTXT *ctxt)
+GSGetTextCTM(GSCTXT *ctxt_GSCTXT)
 {
-  return (ctxt->methods->GSGetTextCTM)
-    (ctxt, @selector(GSGetTextCTM));
+  return (ctxt_GSCTXT->methods->GSGetTextCTM)
+    (ctxt_GSCTXT, @selector(GSGetTextCTM));
 }
 
 static inline NSPoint
-GSGetTextPosition(GSCTXT *ctxt)
+GSGetTextPosition(GSCTXT *ctxt_GSCTXT)
 {
-  return (ctxt->methods->GSGetTextPosition)
-    (ctxt, @selector(GSGetTextPosition));
+  return (ctxt_GSCTXT->methods->GSGetTextPosition)
+    (ctxt_GSCTXT, @selector(GSGetTextPosition));
 }
 
 static inline void
-GSSetTextCTM(GSCTXT *ctxt, NSAffineTransform * ctm)
+GSSetTextCTM(GSCTXT *ctxt_GSCTXT, NSAffineTransform *ctmNSAffineTransform)
 {
-  (ctxt->methods->GSSetTextCTM_)
-    (ctxt, @selector(GSSetTextCTM:), ctm);
+  (ctxt_GSCTXT->methods->GSSetTextCTM_)
+    (ctxt_GSCTXT, @selector(GSSetTextCTM:), ctmNSAffineTransform);
 }
 
 static inline void
-GSSetTextDrawingMode(GSCTXT *ctxt, GSTextDrawingMode mode)
+GSSetTextDrawingMode(GSCTXT *ctxt_GSCTXT, GSTextDrawingMode mode_GSTextDrawingMode)
 {
-  (ctxt->methods->GSSetTextDrawingMode_)
-    (ctxt, @selector(GSSetTextDrawingMode:), mode);
+  (ctxt_GSCTXT->methods->GSSetTextDrawingMode_)
+    (ctxt_GSCTXT, @selector(GSSetTextDrawingMode:), mode_GSTextDrawingMode);
 }
 
 static inline void
-GSSetTextPosition(GSCTXT *ctxt, NSPoint loc)
+GSSetTextPosition(GSCTXT *ctxt_GSCTXT, NSPoint anNSPoint)
 {
-  (ctxt->methods->GSSetTextPosition_)
-    (ctxt, @selector(GSSetTextPosition:), loc);
+  (ctxt_GSCTXT->methods->GSSetTextPosition_)
+    (ctxt_GSCTXT, @selector(GSSetTextPosition:), anNSPoint);
 }
 
 static inline void
-GSShowText(GSCTXT *ctxt, const char * string, size_t length)
+GSShowText(GSCTXT *ctxt_GSCTXT, const char *sConstChar, size_t length)
 {
-  (ctxt->methods->GSShowText__)
-    (ctxt, @selector(GSShowText::), string, length);
+  (ctxt_GSCTXT->methods->GSShowText__)
+    (ctxt_GSCTXT, @selector(GSShowText::), sConstChar, length);
 }
 
 static inline void
-GSShowGlyphs(GSCTXT *ctxt, const NSGlyph * glyphs, size_t length)
+GSShowGlyphs(GSCTXT *ctxt_GSCTXT, const NSGlyph *glyphsNSGlyphPtr, size_t length)
 {
-  (ctxt->methods->GSShowGlyphs__)
-    (ctxt, @selector(GSShowGlyphs::), glyphs, length);
+  (ctxt_GSCTXT->methods->GSShowGlyphs__)
+    (ctxt_GSCTXT, @selector(GSShowGlyphs::), glyphsNSGlyphPtr, length);
 }
 
 
@@ -701,161 +701,161 @@
 /* Gstate Handling */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPSgrestore(GSCTXT *ctxt)
+DPSgrestore(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSgrestore)
-    (ctxt, @selector(DPSgrestore));
+  (ctxt_GSCTXT->methods->DPSgrestore)
+    (ctxt_GSCTXT, @selector(DPSgrestore));
 }
 
 static inline void
-DPSgsave(GSCTXT *ctxt)
+DPSgsave(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSgsave)
-    (ctxt, @selector(DPSgsave));
+  (ctxt_GSCTXT->methods->DPSgsave)
+    (ctxt_GSCTXT, @selector(DPSgsave));
 }
 
 static inline void
-DPSinitgraphics(GSCTXT *ctxt)
+DPSinitgraphics(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSinitgraphics)
-    (ctxt, @selector(DPSinitgraphics));
+  (ctxt_GSCTXT->methods->DPSinitgraphics)
+    (ctxt_GSCTXT, @selector(DPSinitgraphics));
 }
 
 static inline void
-DPSsetgstate(GSCTXT *ctxt, int gst)
+DPSsetgstate(GSCTXT *ctxt_GSCTXT, int gStateTagInt)
 {
-  (ctxt->methods->DPSsetgstate_)
-    (ctxt, @selector(DPSsetgstate:), gst);
+  (ctxt_GSCTXT->methods->DPSsetgstate_)
+    (ctxt_GSCTXT, @selector(DPSsetgstate:), gStateTagInt);
 }
 
 
 static inline int
-GSDefineGState(GSCTXT *ctxt)
+GSDefineGState(GSCTXT *ctxt_GSCTXT)
 {
-  return (ctxt->methods->GSDefineGState)
-    (ctxt, @selector(GSDefineGState));
+  return (ctxt_GSCTXT->methods->GSDefineGState)
+    (ctxt_GSCTXT, @selector(GSDefineGState));
 }
 
 static inline void
-GSUndefineGState(GSCTXT *ctxt, int gst)
+GSUndefineGState(GSCTXT *ctxt_GSCTXT, int gStateTagInt)
 {
-  (ctxt->methods->GSUndefineGState_)
-    (ctxt, @selector(GSUndefineGState:), gst);
+  (ctxt_GSCTXT->methods->GSUndefineGState_)
+    (ctxt_GSCTXT, @selector(GSUndefineGState:), gStateTagInt);
 }
 
 static inline void
-GSReplaceGState(GSCTXT *ctxt, int gst)
+GSReplaceGState(GSCTXT *ctxt_GSCTXT, int gStateTagInt)
 {
-  (ctxt->methods->GSReplaceGState_)
-    (ctxt, @selector(GSReplaceGState:), gst);
+  (ctxt_GSCTXT->methods->GSReplaceGState_)
+    (ctxt_GSCTXT, @selector(GSReplaceGState:), gStateTagInt);
 }
 
 /* ----------------------------------------------------------------------- */
 /* Gstate operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPScurrentflat(GSCTXT *ctxt, float* flatness)
+DPScurrentflat(GSCTXT *ctxt_GSCTXT, float *flatnessFloatPtr)
 {
-  (ctxt->methods->DPScurrentflat_)
-    (ctxt, @selector(DPScurrentflat:), flatness);
+  (ctxt_GSCTXT->methods->DPScurrentflat_)
+    (ctxt_GSCTXT, @selector(DPScurrentflat:), flatnessFloatPtr);
 }
 
 static inline void
-DPScurrentlinecap(GSCTXT *ctxt, int* linecap)
+DPScurrentlinecap(GSCTXT *ctxt_GSCTXT, int *linecapIntPtr)
 {
-  (ctxt->methods->DPScurrentlinecap_)
-    (ctxt, @selector(DPScurrentlinecap:), linecap);
+  (ctxt_GSCTXT->methods->DPScurrentlinecap_)
+    (ctxt_GSCTXT, @selector(DPScurrentlinecap:), linecapIntPtr);
 }
 
 static inline void
-DPScurrentlinejoin(GSCTXT *ctxt, int* linejoin)
+DPScurrentlinejoin(GSCTXT *ctxt_GSCTXT, int *linejoinIntPtr)
 {
-  (ctxt->methods->DPScurrentlinejoin_)
-    (ctxt, @selector(DPScurrentlinejoin:), linejoin);
+  (ctxt_GSCTXT->methods->DPScurrentlinejoin_)
+    (ctxt_GSCTXT, @selector(DPScurrentlinejoin:), linejoinIntPtr);
 }
 
 static inline void
-DPScurrentlinewidth(GSCTXT *ctxt, float* width)
+DPScurrentlinewidth(GSCTXT *ctxt_GSCTXT, float *widthFloatPtr)
 {
-  (ctxt->methods->DPScurrentlinewidth_)
-    (ctxt, @selector(DPScurrentlinewidth:), width);
+  (ctxt_GSCTXT->methods->DPScurrentlinewidth_)
+    (ctxt_GSCTXT, @selector(DPScurrentlinewidth:), widthFloatPtr);
 }
 
 static inline void
-DPScurrentmiterlimit(GSCTXT *ctxt, float* limit)
+DPScurrentmiterlimit(GSCTXT *ctxt_GSCTXT, float *limitFloatPtr)
 {
-  (ctxt->methods->DPScurrentmiterlimit_)
-    (ctxt, @selector(DPScurrentmiterlimit:), limit);
+  (ctxt_GSCTXT->methods->DPScurrentmiterlimit_)
+    (ctxt_GSCTXT, @selector(DPScurrentmiterlimit:), limitFloatPtr);
 }
 
 static inline void
-DPScurrentpoint(GSCTXT *ctxt, float* x, float* y)
+DPScurrentpoint(GSCTXT *ctxt_GSCTXT, float *xFloatPtr, float *yFloatPtr)
 {
-  (ctxt->methods->DPScurrentpoint__)
-    (ctxt, @selector(DPScurrentpoint::), x, y);
+  (ctxt_GSCTXT->methods->DPScurrentpoint__)
+    (ctxt_GSCTXT, @selector(DPScurrentpoint::), xFloatPtr, yFloatPtr);
 }
 
 static inline void
-DPScurrentstrokeadjust(GSCTXT *ctxt, int* b)
+DPScurrentstrokeadjust(GSCTXT *ctxt_GSCTXT, int *bIntPtr)
 {
-  (ctxt->methods->DPScurrentstrokeadjust_)
-    (ctxt, @selector(DPScurrentstrokeadjust:), b);
+  (ctxt_GSCTXT->methods->DPScurrentstrokeadjust_)
+    (ctxt_GSCTXT, @selector(DPScurrentstrokeadjust:), bIntPtr);
 }
 
 static inline void
-DPSsetdash(GSCTXT *ctxt, const float* pat, int size, float offset)
+DPSsetdash(GSCTXT *ctxt_GSCTXT, const float *patternFloatPtr, int size, float offsetFloat)
 {
-  (ctxt->methods->DPSsetdash___)
-    (ctxt, @selector(DPSsetdash:::), pat, size, offset);
+  (ctxt_GSCTXT->methods->DPSsetdash___)
+    (ctxt_GSCTXT, @selector(DPSsetdash:::), patternFloatPtr, size, offsetFloat);
 }
 
 static inline void
-DPSsetflat(GSCTXT *ctxt, float flatness)
+DPSsetflat(GSCTXT *ctxt_GSCTXT, float flatnessFloat)
 {
-  (ctxt->methods->DPSsetflat_)
-    (ctxt, @selector(DPSsetflat:), flatness);
+  (ctxt_GSCTXT->methods->DPSsetflat_)
+    (ctxt_GSCTXT, @selector(DPSsetflat:), flatnessFloat);
 }
 
 static inline void
-DPSsethalftonephase(GSCTXT *ctxt, float x, float y)
+DPSsethalftonephase(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 {
-  (ctxt->methods->DPSsethalftonephase__)
-    (ctxt, @selector(DPSsethalftonephase::), x, y);
+  (ctxt_GSCTXT->methods->DPSsethalftonephase__)
+    (ctxt_GSCTXT, @selector(DPSsethalftonephase::), xFloat, yFloat);
 }
 
 static inline void
-DPSsetlinecap(GSCTXT *ctxt, int linecap)
+DPSsetlinecap(GSCTXT *ctxt_GSCTXT, int linecapIntPtr)
 {
-  (ctxt->methods->DPSsetlinecap_)
-    (ctxt, @selector(DPSsetlinecap:), linecap);
+  (ctxt_GSCTXT->methods->DPSsetlinecap_)
+    (ctxt_GSCTXT, @selector(DPSsetlinecap:), linecapIntPtr);
 }
 
 static inline void
-DPSsetlinejoin(GSCTXT *ctxt, int linejoin)
+DPSsetlinejoin(GSCTXT *ctxt_GSCTXT, int linejoinIntPtr)
 {
-  (ctxt->methods->DPSsetlinejoin_)
-    (ctxt, @selector(DPSsetlinejoin:), linejoin);
+  (ctxt_GSCTXT->methods->DPSsetlinejoin_)
+    (ctxt_GSCTXT, @selector(DPSsetlinejoin:), linejoinIntPtr);
 }
 
 static inline void
-DPSsetlinewidth(GSCTXT *ctxt, float width)
+DPSsetlinewidth(GSCTXT *ctxt_GSCTXT, float widthFloatPtr)
 {
-  (ctxt->methods->DPSsetlinewidth_)
-    (ctxt, @selector(DPSsetlinewidth:), width);
+  (ctxt_GSCTXT->methods->DPSsetlinewidth_)
+    (ctxt_GSCTXT, @selector(DPSsetlinewidth:), widthFloatPtr);
 }
 
 static inline void
-DPSsetmiterlimit(GSCTXT *ctxt, float limit)
+DPSsetmiterlimit(GSCTXT *ctxt_GSCTXT, float limitFloatPtr)
 {
-  (ctxt->methods->DPSsetmiterlimit_)
-    (ctxt, @selector(DPSsetmiterlimit:), limit);
+  (ctxt_GSCTXT->methods->DPSsetmiterlimit_)
+    (ctxt_GSCTXT, @selector(DPSsetmiterlimit:), limitFloatPtr);
 }
 
 static inline void
-DPSsetstrokeadjust(GSCTXT *ctxt, int b)
+DPSsetstrokeadjust(GSCTXT *ctxt_GSCTXT, int bInt)
 {
-  (ctxt->methods->DPSsetstrokeadjust_)
-    (ctxt, @selector(DPSsetstrokeadjust:), b);
+  (ctxt_GSCTXT->methods->DPSsetstrokeadjust_)
+    (ctxt_GSCTXT, @selector(DPSsetstrokeadjust:), bInt);
 }
 
 
@@ -863,60 +863,60 @@
 /* Matrix operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPSconcat(GSCTXT *ctxt, const float* m)
+DPSconcat(GSCTXT *ctxt_GSCTXT, const float *mFloatPtr)
 {
-  (ctxt->methods->DPSconcat_)
-    (ctxt, @selector(DPSconcat:), m);
+  (ctxt_GSCTXT->methods->DPSconcat_)
+    (ctxt_GSCTXT, @selector(DPSconcat:), mFloatPtr);
 }
 
 static inline void
-DPSinitmatrix(GSCTXT *ctxt)
+DPSinitmatrix(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSinitmatrix)
-    (ctxt, @selector(DPSinitmatrix));
+  (ctxt_GSCTXT->methods->DPSinitmatrix)
+    (ctxt_GSCTXT, @selector(DPSinitmatrix));
 }
 
 static inline void
-DPSrotate(GSCTXT *ctxt, float angle)
+DPSrotate(GSCTXT *ctxt_GSCTXT, float angleFloat)
 {
-  (ctxt->methods->DPSrotate_)
-    (ctxt, @selector(DPSrotate:), angle);
+  (ctxt_GSCTXT->methods->DPSrotate_)
+    (ctxt_GSCTXT, @selector(DPSrotate:), angleFloat);
 }
 
 static inline void
-DPSscale(GSCTXT *ctxt, float x, float y)
+DPSscale(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 {
-  (ctxt->methods->DPSscale__)
-    (ctxt, @selector(DPSscale::), x, y);
+  (ctxt_GSCTXT->methods->DPSscale__)
+    (ctxt_GSCTXT, @selector(DPSscale::), xFloat, yFloat);
 }
 
 static inline void
-DPStranslate(GSCTXT *ctxt, float x, float y)
+DPStranslate(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 {
-  (ctxt->methods->DPStranslate__)
-    (ctxt, @selector(DPStranslate::), x, y);
+  (ctxt_GSCTXT->methods->DPStranslate__)
+    (ctxt_GSCTXT, @selector(DPStranslate::), xFloat, yFloat);
 }
 
 
 static inline NSAffineTransform *
-GSCurrentCTM(GSCTXT *ctxt)
+GSCurrentCTM(GSCTXT *ctxt_GSCTXT)
 {
-  return (ctxt->methods->GSCurrentCTM)
-    (ctxt, @selector(GSCurrentCTM));
+  return (ctxt_GSCTXT->methods->GSCurrentCTM)
+    (ctxt_GSCTXT, @selector(GSCurrentCTM));
 }
 
 static inline void
-GSSetCTM(GSCTXT *ctxt, NSAffineTransform * ctm)
+GSSetCTM(GSCTXT *ctxt_GSCTXT, NSAffineTransform *ctmNSAffineTransform)
 {
-  (ctxt->methods->GSSetCTM_)
-    (ctxt, @selector(GSSetCTM:), ctm);
+  (ctxt_GSCTXT->methods->GSSetCTM_)
+    (ctxt_GSCTXT, @selector(GSSetCTM:), ctmNSAffineTransform);
 }
 
 static inline void
-GSConcatCTM(GSCTXT *ctxt, NSAffineTransform * ctm)
+GSConcatCTM(GSCTXT *ctxt_GSCTXT, NSAffineTransform *ctmNSAffineTransform)
 {
-  (ctxt->methods->GSConcatCTM_)
-    (ctxt, @selector(GSConcatCTM:), ctm);
+  (ctxt_GSCTXT->methods->GSConcatCTM_)
+    (ctxt_GSCTXT, @selector(GSConcatCTM:), ctmNSAffineTransform);
 }
 
 
@@ -924,193 +924,193 @@
 /* Paint operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-DPSarc(GSCTXT *ctxt, float x, float y, float r, float angle1, float angle2)
+DPSarc(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float radiusFloat, float angle1Float, float angle2Float)
 {
-  (ctxt->methods->DPSarc_____)
-    (ctxt, @selector(DPSarc:::::), x, y, r, angle1, angle2);
+  (ctxt_GSCTXT->methods->DPSarc_____)
+    (ctxt_GSCTXT, @selector(DPSarc:::::), xFloat, yFloat, radiusFloat, angle1Float, angle2Float);
 }
 
 static inline void
-DPSarcn(GSCTXT *ctxt, float x, float y, float r, float angle1, float angle2)
+DPSarcn(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float radiusFloat, float angle1Float, float angle2Float)
 {
-  (ctxt->methods->DPSarcn_____)
-    (ctxt, @selector(DPSarcn:::::), x, y, r, angle1, angle2);
+  (ctxt_GSCTXT->methods->DPSarcn_____)
+    (ctxt_GSCTXT, @selector(DPSarcn:::::), xFloat, yFloat, radiusFloat, angle1Float, angle2Float);
 }
 
 static inline void
-DPSarct(GSCTXT *ctxt, float x1, float y1, float x2, float y2, float r)
+DPSarct(GSCTXT *ctxt_GSCTXT, float x1Float, float y1Float, float x2Float, float y2Float, float radiusFloat)
 {
-  (ctxt->methods->DPSarct_____)
-    (ctxt, @selector(DPSarct:::::), x1, y1, x2, y2, r);
+  (ctxt_GSCTXT->methods->DPSarct_____)
+    (ctxt_GSCTXT, @selector(DPSarct:::::), x1Float, y1Float, x2Float, y2Float, radiusFloat);
 }
 
 static inline void
-DPSclip(GSCTXT *ctxt)
+DPSclip(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSclip)
-    (ctxt, @selector(DPSclip));
+  (ctxt_GSCTXT->methods->DPSclip)
+    (ctxt_GSCTXT, @selector(DPSclip));
 }
 
 static inline void
-DPSclosepath(GSCTXT *ctxt)
+DPSclosepath(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSclosepath)
-    (ctxt, @selector(DPSclosepath));
+  (ctxt_GSCTXT->methods->DPSclosepath)
+    (ctxt_GSCTXT, @selector(DPSclosepath));
 }
 
 static inline void
-DPScurveto(GSCTXT *ctxt, float x1, float y1, float x2, float y2, float x3, float y3)
+DPScurveto(GSCTXT *ctxt_GSCTXT, float x1Float, float y1Float, float x2Float, float y2Float, float x3Float, float y3Float)
 {
-  (ctxt->methods->DPScurveto______)
-    (ctxt, @selector(DPScurveto::::::), x1, y1, x2, y2, x3, y3);
+  (ctxt_GSCTXT->methods->DPScurveto______)
+    (ctxt_GSCTXT, @selector(DPScurveto::::::), x1Float, y1Float, x2Float, y2Float, x3Float, y3Float);
 }
 
 static inline void
-DPSeoclip(GSCTXT *ctxt)
+DPSeoclip(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSeoclip)
-    (ctxt, @selector(DPSeoclip));
+  (ctxt_GSCTXT->methods->DPSeoclip)
+    (ctxt_GSCTXT, @selector(DPSeoclip));
 }
 
 static inline void
-DPSeofill(GSCTXT *ctxt)
+DPSeofill(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSeofill)
-    (ctxt, @selector(DPSeofill));
+  (ctxt_GSCTXT->methods->DPSeofill)
+    (ctxt_GSCTXT, @selector(DPSeofill));
 }
 
 static inline void
-DPSfill(GSCTXT *ctxt)
+DPSfill(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSfill)
-    (ctxt, @selector(DPSfill));
+  (ctxt_GSCTXT->methods->DPSfill)
+    (ctxt_GSCTXT, @selector(DPSfill));
 }
 
 static inline void
-DPSflattenpath(GSCTXT *ctxt)
+DPSflattenpath(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSflattenpath)
-    (ctxt, @selector(DPSflattenpath));
+  (ctxt_GSCTXT->methods->DPSflattenpath)
+    (ctxt_GSCTXT, @selector(DPSflattenpath));
 }
 
 static inline void
-DPSinitclip(GSCTXT *ctxt)
+DPSinitclip(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSinitclip)
-    (ctxt, @selector(DPSinitclip));
+  (ctxt_GSCTXT->methods->DPSinitclip)
+    (ctxt_GSCTXT, @selector(DPSinitclip));
 }
 
 static inline void
-DPSlineto(GSCTXT *ctxt, float x, float y)
+DPSlineto(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 {
-  (ctxt->methods->DPSlineto__)
-    (ctxt, @selector(DPSlineto::), x, y);
+  (ctxt_GSCTXT->methods->DPSlineto__)
+    (ctxt_GSCTXT, @selector(DPSlineto::), xFloat, yFloat);
 }
 
 static inline void
-DPSmoveto(GSCTXT *ctxt, float x, float y)
+DPSmoveto(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 {
-  (ctxt->methods->DPSmoveto__)
-    (ctxt, @selector(DPSmoveto::), x, y);
+  (ctxt_GSCTXT->methods->DPSmoveto__)
+    (ctxt_GSCTXT, @selector(DPSmoveto::), xFloat, yFloat);
 }
 
 static inline void
-DPSnewpath(GSCTXT *ctxt)
+DPSnewpath(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSnewpath)
-    (ctxt, @selector(DPSnewpath));
+  (ctxt_GSCTXT->methods->DPSnewpath)
+    (ctxt_GSCTXT, @selector(DPSnewpath));
 }
 
 static inline void
-DPSpathbbox(GSCTXT *ctxt, float* llx, float* lly, float* urx, float* ury)
+DPSpathbbox(GSCTXT *ctxt_GSCTXT, float *lowerLeftXFloat, float *lowerLeftYFloat, float *upperRightXFloat, float *upperRightYFloat)
 {
-  (ctxt->methods->DPSpathbbox____)
-    (ctxt, @selector(DPSpathbbox::::), llx, lly, urx, ury);
+  (ctxt_GSCTXT->methods->DPSpathbbox____)
+    (ctxt_GSCTXT, @selector(DPSpathbbox::::), lowerLeftXFloat, lowerLeftYFloat, upperRightXFloat, upperRightYFloat);
 }
 
 static inline void
-DPSrcurveto(GSCTXT *ctxt, float x1, float y1, float x2, float y2, float x3, float y3)
+DPSrcurveto(GSCTXT *ctxt_GSCTXT, float x1Float, float y1Float, float x2Float, float y2Float, float x3Float, float y3Float)
 {
-  (ctxt->methods->DPSrcurveto______)
-    (ctxt, @selector(DPSrcurveto::::::), x1, y1, x2, y2, x3, y3);
+  (ctxt_GSCTXT->methods->DPSrcurveto______)
+    (ctxt_GSCTXT, @selector(DPSrcurveto::::::), x1Float, y1Float, x2Float, y2Float, x3Float, y3Float);
 }
 
 static inline void
-DPSrectclip(GSCTXT *ctxt, float x, float y, float w, float h)
+DPSrectclip(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat)
 {
-  (ctxt->methods->DPSrectclip____)
-    (ctxt, @selector(DPSrectclip::::), x, y, w, h);
+  (ctxt_GSCTXT->methods->DPSrectclip____)
+    (ctxt_GSCTXT, @selector(DPSrectclip::::), xFloat, yFloat, widthFloat, heightFloat);
 }
 
 static inline void
-DPSrectfill(GSCTXT *ctxt, float x, float y, float w, float h)
+DPSrectfill(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat)
 {
-  (ctxt->methods->DPSrectfill____)
-    (ctxt, @selector(DPSrectfill::::), x, y, w, h);
+  (ctxt_GSCTXT->methods->DPSrectfill____)
+    (ctxt_GSCTXT, @selector(DPSrectfill::::), xFloat, yFloat, widthFloat, heightFloat);
 }
 
 static inline void
-DPSrectstroke(GSCTXT *ctxt, float x, float y, float w, float h)
+DPSrectstroke(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat)
 {
-  (ctxt->methods->DPSrectstroke____)
-    (ctxt, @selector(DPSrectstroke::::), x, y, w, h);
+  (ctxt_GSCTXT->methods->DPSrectstroke____)
+    (ctxt_GSCTXT, @selector(DPSrectstroke::::), xFloat, yFloat, widthFloat, heightFloat);
 }
 
 static inline void
-DPSreversepath(GSCTXT *ctxt)
+DPSreversepath(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSreversepath)
-    (ctxt, @selector(DPSreversepath));
+  (ctxt_GSCTXT->methods->DPSreversepath)
+    (ctxt_GSCTXT, @selector(DPSreversepath));
 }
 
 static inline void
-DPSrlineto(GSCTXT *ctxt, float x, float y)
+DPSrlineto(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 {
-  (ctxt->methods->DPSrlineto__)
-    (ctxt, @selector(DPSrlineto::), x, y);
+  (ctxt_GSCTXT->methods->DPSrlineto__)
+    (ctxt_GSCTXT, @selector(DPSrlineto::), xFloat, yFloat);
 }
 
 static inline void
-DPSrmoveto(GSCTXT *ctxt, float x, float y)
+DPSrmoveto(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat)
 {
-  (ctxt->methods->DPSrmoveto__)
-    (ctxt, @selector(DPSrmoveto::), x, y);
+  (ctxt_GSCTXT->methods->DPSrmoveto__)
+    (ctxt_GSCTXT, @selector(DPSrmoveto::), xFloat, yFloat);
 }
 
 static inline void
-DPSstroke(GSCTXT *ctxt)
+DPSstroke(GSCTXT *ctxt_GSCTXT)
 {
-  (ctxt->methods->DPSstroke)
-    (ctxt, @selector(DPSstroke));
+  (ctxt_GSCTXT->methods->DPSstroke)
+    (ctxt_GSCTXT, @selector(DPSstroke));
 }
 
 static inline void
-DPSshfill(GSCTXT *ctxt, NSDictionary *shaderDictionary)
+DPSshfill(GSCTXT *ctxt_GSCTXT, NSDictionary *shaderDictionary)
 {
-  (ctxt->methods->DPSshfill)
-    (ctxt, @selector(DPSshfill:), shaderDictionary);
+  (ctxt_GSCTXT->methods->DPSshfill)
+    (ctxt_GSCTXT, @selector(DPSshfill:), shaderDictionary);
 }
 
 
 static inline void
-GSSendBezierPath(GSCTXT *ctxt, NSBezierPath * path)
+GSSendBezierPath(GSCTXT *ctxt_GSCTXT, NSBezierPath *anNSBezierPath)
 {
-  (ctxt->methods->GSSendBezierPath_)
-    (ctxt, @selector(GSSendBezierPath:), path);
+  (ctxt_GSCTXT->methods->GSSendBezierPath_)
+    (ctxt_GSCTXT, @selector(GSSendBezierPath:), anNSBezierPath);
 }
 
 static inline void
-GSRectClipList(GSCTXT *ctxt, const NSRect * rects, int count)
+GSRectClipList(GSCTXT *ctxt_GSCTXT, const NSRect *rectsPtr, int countInt)
 {
-  (ctxt->methods->GSRectClipList__)
-    (ctxt, @selector(GSRectClipList::), rects, count);
+  (ctxt_GSCTXT->methods->GSRectClipList__)
+    (ctxt_GSCTXT, @selector(GSRectClipList::), rectsPtr, countInt);
 }
 
 static inline void
-GSRectFillList(GSCTXT *ctxt, const NSRect * rects, int count)
+GSRectFillList(GSCTXT *ctxt_GSCTXT, const NSRect *rectsPtr, int countInt)
 {
-  (ctxt->methods->GSRectFillList__)
-    (ctxt, @selector(GSRectFillList::), rects, count);
+  (ctxt_GSCTXT->methods->GSRectFillList__)
+    (ctxt_GSCTXT, @selector(GSRectFillList::), rectsPtr, countInt);
 }
 
 
@@ -1118,31 +1118,31 @@
 /* Window system ops */
 /* ----------------------------------------------------------------------- */
 static inline void
-GSCurrentDevice(GSCTXT *ctxt, void** device, int* x, int* y)
+GSCurrentDevice(GSCTXT *ctxt_GSCTXT, void** deviceVoidPtrPtr, int *xIntPtr, int *yIntPtr)
 {
-  (ctxt->methods->GSCurrentDevice___)
-    (ctxt, @selector(GSCurrentGCDevice:::), device, x, y);
+  (ctxt_GSCTXT->methods->GSCurrentDevice___)
+    (ctxt_GSCTXT, @selector(GSCurrentGCDevice:::), deviceVoidPtrPtr, xIntPtr, yIntPtr);
 }
 
 static inline void
-DPScurrentoffset(GSCTXT *ctxt, int* x, int* y)
+DPScurrentoffset(GSCTXT *ctxt_GSCTXT, int *xIntPtr, int *yIntPtr)
 {
-  (ctxt->methods->DPScurrentoffset__)
-    (ctxt, @selector(DPScurrentoffset::), x, y);
+  (ctxt_GSCTXT->methods->DPScurrentoffset__)
+    (ctxt_GSCTXT, @selector(DPScurrentoffset::), xIntPtr, yIntPtr);
 }
 
 static inline void
-GSSetDevice(GSCTXT *ctxt, void* device, int x, int y)
+GSSetDevice(GSCTXT *ctxt_GSCTXT, void *deviceVoidPtrPtr, int xInt, int yInt)
 {
-  (ctxt->methods->GSSetDevice___)
-    (ctxt, @selector(GSSetGCDevice:::), device, x, y);
+  (ctxt_GSCTXT->methods->GSSetDevice___)
+    (ctxt_GSCTXT, @selector(GSSetGCDevice:::), deviceVoidPtrPtr, xInt, yInt);
 }
 
 static inline void
-DPSsetoffset(GSCTXT *ctxt, short int x, short int y)
+DPSsetoffset(GSCTXT *ctxt_GSCTXT, short int xShort, short int yShort)
 {
-  (ctxt->methods->DPSsetoffset__)
-    (ctxt, @selector(DPSsetoffset::), x, y);
+  (ctxt_GSCTXT->methods->DPSsetoffset__)
+    (ctxt_GSCTXT, @selector(DPSsetoffset::), xShort, yShort);
 }
 
 
@@ -1150,32 +1150,32 @@
 /* Graphics Extensions Ops */
 /*-------------------------------------------------------------------------*/
 static inline void
-DPScomposite(GSCTXT *ctxt, float x, float y, float w, float h, int gstateNum, float dx, float dy, int op)
+DPScomposite(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat, int gstateNum, float destinationXFloat, float destinationYFloat, int compositingOperationInt)
 {
-  (ctxt->methods->DPScomposite________)
-    (ctxt, @selector(DPScomposite::::::::), x, y, w, h, gstateNum, dx, dy, op);
+  (ctxt_GSCTXT->methods->DPScomposite________)
+    (ctxt_GSCTXT, @selector(DPScomposite::::::::), xFloat, yFloat, widthFloat, heightFloat, gstateNum, destinationXFloat, destinationYFloat, compositingOperationInt);
 }
 
 static inline void
-DPScompositerect(GSCTXT *ctxt, float x, float y, float w, float h, int op)
+DPScompositerect(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat, int compositingOperationInt)
 {
-  (ctxt->methods->DPScompositerect_____)
-    (ctxt, @selector(DPScompositerect:::::), x, y, w, h, op);
+  (ctxt_GSCTXT->methods->DPScompositerect_____)
+    (ctxt_GSCTXT, @selector(DPScompositerect:::::), xFloat, yFloat, widthFloat, heightFloat, compositingOperationInt);
 }
 
 static inline void
-DPSdissolve(GSCTXT *ctxt, float x, float y, float w, float h, int gstateNum, float dx, float dy, float delta)
+DPSdissolve(GSCTXT *ctxt_GSCTXT, float xFloat, float yFloat, float widthFloat, float heightFloat, int gstateNum, float destinationXFloat, float destinationYFloat, float deltaFloat)
 {
-  (ctxt->methods->DPSdissolve________)
-    (ctxt, @selector(DPSdissolve::::::::), x, y, w, h, gstateNum, dx, dy, delta);
+  (ctxt_GSCTXT->methods->DPSdissolve________)
+    (ctxt_GSCTXT, @selector(DPSdissolve::::::::), xFloat, yFloat, widthFloat, heightFloat, gstateNum, destinationXFloat, destinationYFloat, deltaFloat);
 }
 
 
 static inline void
-GSDrawImage(GSCTXT *ctxt, NSRect rect, void * imageref)
+GSDrawImage(GSCTXT *ctxt_GSCTXT, NSRect rect, void *imagerefVoidPtr)
 {
-  (ctxt->methods->GSDrawImage__)
-    (ctxt, @selector(GSDrawImage::), rect, imageref);
+  (ctxt_GSCTXT->methods->GSDrawImage__)
+    (ctxt_GSCTXT, @selector(GSDrawImage::), rect, imagerefVoidPtr);
 }
 
 
@@ -1183,22 +1183,22 @@
 /* Postscript Client functions */
 /* ----------------------------------------------------------------------- */
 static void
-DPSPrintf(GSCTXT *ctxt, const char * fmt, ...)
+DPSPrintf(GSCTXT *ctxt_GSCTXT, const char *fmt, ...)
 {
   va_list ap;
 
   va_start(ap, fmt);
   if (fmt != NULL)
-    (ctxt->methods->DPSPrintf__)
-      (ctxt, @selector(DPSPrintf::), fmt, ap);
+    (ctxt_GSCTXT->methods->DPSPrintf__)
+      (ctxt_GSCTXT, @selector(DPSPrintf::), fmt, ap);
   va_end(ap);
 }
 
 static inline void
-DPSWriteData(GSCTXT *ctxt, const char * buf, unsigned int count)
+DPSWriteData(GSCTXT *ctxt_GSCTXT, const char *buf, unsigned int countUnsignedInt)
 {
-  (ctxt->methods->DPSWriteData__)
-    (ctxt, @selector(DPSWriteData::), buf, count);
+  (ctxt_GSCTXT->methods->DPSWriteData__)
+    (ctxt_GSCTXT, @selector(DPSWriteData::), buf, countUnsignedInt);
 }
 
 #endif	
diff -Naur gnustep-gui-0.9.4.orig/Headers/AppKit/NSGraphicsContext.h gnustep-gui-0.9.4/Headers/AppKit/NSGraphicsContext.h
--- gnustep-gui-0.9.4.orig/Headers/AppKit/NSGraphicsContext.h	Fri Jul 30 13:58:03 2004
+++ gnustep-gui-0.9.4/Headers/AppKit/NSGraphicsContext.h	Tue Nov  2 13:11:14 2004
@@ -222,13 +222,13 @@
 /* ----------------------------------------------------------------------- */
 /* Color operations */
 /* ----------------------------------------------------------------------- */
-- (void) DPScurrentalpha: (float*)a;
-- (void) DPScurrentcmykcolor: (float*)c : (float*)m : (float*)y : (float*)k;
+- (void) DPScurrentalpha: (float*)aP;
+- (void) DPScurrentcmykcolor: (float*)cP : (float*)mP : (float*)yP : (float*)kP;
 - (void) DPScurrentgray: (float*)gray;
 - (void) DPScurrenthsbcolor: (float*)h : (float*)s : (float*)b;
 - (void) DPScurrentrgbcolor: (float*)r : (float*)g : (float*)b;
 - (void) DPSsetalpha: (float)a;
-- (void) DPSsetcmykcolor: (float)c : (float)m : (float)y : (float)k;
+- (void) DPSsetcmykcolor: (float)cyanFloat : (float)magentaFloat : (float)yellowFloat : (float)kBlackFloat;
 - (void) DPSsetgray: (float)gray;
 - (void) DPSsethsbcolor: (float)h : (float)s : (float)b;
 - (void) DPSsetrgbcolor: (float)r : (float)g : (float)b;
@@ -282,7 +282,7 @@
 - (void) DPScurrentlinejoin: (int*)linejoin;
 - (void) DPScurrentlinewidth: (float*)width;
 - (void) DPScurrentmiterlimit: (float*)limit;
-- (void) DPScurrentpoint: (float*)x : (float*)y;
+- (void) DPScurrentpoint: (float*)x : (float*)yP;
 - (void) DPScurrentstrokeadjust: (int*)b;
 - (void) DPSsetdash: (const float*)pat : (int)size : (float)offset;
 - (void) DPSsetflat: (float)flatness;
@@ -296,7 +296,7 @@
 /* ----------------------------------------------------------------------- */
 /* Matrix operations */
 /* ----------------------------------------------------------------------- */
-- (void) DPSconcat: (const float*)m;
+- (void) DPSconcat: (const float*)mConstFloat;
 - (void) DPSinitmatrix;
 - (void) DPSrotate: (float)angle;
 - (void) DPSscale: (float)x : (float)y;
diff -Naur gnustep-gui-0.9.4.orig/Headers/AppKit/PSOperators.h gnustep-gui-0.9.4/Headers/AppKit/PSOperators.h
--- gnustep-gui-0.9.4.orig/Headers/AppKit/PSOperators.h	Thu Jul 31 23:52:09 2003
+++ gnustep-gui-0.9.4/Headers/AppKit/PSOperators.h	Tue Nov  2 13:11:20 2004
@@ -36,43 +36,43 @@
 /* Color operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PScurrentalpha(float* a)
+PScurrentalpha(float *alphaFloatPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentcmykcolor(float* c, float* m, float* y, float* k)
+PScurrentcmykcolor(float *cyanFloatPtr, float *magentaFloatPtr, float *yellowFloatPtr, float *kBlackFloatPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentgray(float* gray)
+PScurrentgray(float *greenFloatPtrray)
 __attribute__((unused));
 
 static inline void
-PScurrenthsbcolor(float* h, float* s, float* b)
+PScurrenthsbcolor(float *hueFloatPtr, float *saturationFloatPtr, float *brightnessFloatPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentrgbcolor(float* r, float* g, float* b)
+PScurrentrgbcolor(float *redFloatPtr, float *greenFloatPtr, float *blueFloatPtr)
 __attribute__((unused));
 
 static inline void
-PSsetalpha(float a)
+PSsetalpha(float alphaFloat)
 __attribute__((unused));
 
 static inline void
-PSsetcmykcolor(float c, float m, float y, float k)
+PSsetcmykcolor(float cyanFloat, float magentaFloat, float yellowFloat, float kBlackFloat)
 __attribute__((unused));
 
 static inline void
-PSsetgray(float gray)
+PSsetgray(float grayFloat)
 __attribute__((unused));
 
 static inline void
-PSsethsbcolor(float h, float s, float b)
+PSsethsbcolor(float hueFloat, float saturationFloat, float brightnessFloat)
 __attribute__((unused));
 
 static inline void
-PSsetrgbcolor(float r, float g, float b)
+PSsetrgbcolor(float redFloat, float greenFloat, float blueFloat)
 __attribute__((unused));
 
 
@@ -81,35 +81,35 @@
 /* Text operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PSashow(float x, float y, const char* s)
+PSashow(float xFloat, float yFloat, const char *sConstChar)
 __attribute__((unused));
 
 static inline void
-PSawidthshow(float cx, float cy, int c, float ax, float ay, const char* s)
+PSawidthshow(float cxFloat, float cyFloat, int cInt, float axFloat, float ayFloat, const char *sConstChar)
 __attribute__((unused));
 
 static inline void
-PScharpath(const char* s, int b)
+PScharpath(const char *sConstChar, int bInt)
 __attribute__((unused));
 
 static inline void
-PSshow(const char* s)
+PSshow(const char *sConstChar)
 __attribute__((unused));
 
 static inline void
-PSwidthshow(float x, float y, int c, const char* s)
+PSwidthshow(float xFloat, float yFloat, int cInt, const char *sConstChar)
 __attribute__((unused));
 
 static inline void
-PSxshow(const char* s, const float* numarray, int size)
+PSxshow(const char *sConstChar, const float *numarrayFloatPtr, int size)
 __attribute__((unused));
 
 static inline void
-PSxyshow(const char* s, const float* numarray, int size)
+PSxyshow(const char *sConstChar, const float *numarrayFloatPtr, int size)
 __attribute__((unused));
 
 static inline void
-PSyshow(const char* s, const float* numarray, int size)
+PSyshow(const char *sConstChar, const float *numarrayFloatPtr, int size)
 __attribute__((unused));
 
 
@@ -130,7 +130,7 @@
 __attribute__((unused));
 
 static inline void
-PSsetgstate(int gst)
+PSsetgstate(int gstateTagInt)
 __attribute__((unused));
 
 
@@ -139,63 +139,63 @@
 /* Gstate operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PScurrentflat(float* flatness)
+PScurrentflat(float *flatnessFloatPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentlinecap(int* linecap)
+PScurrentlinecap(int *linecapIntPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentlinejoin(int* linejoin)
+PScurrentlinejoin(int *linejoinIntPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentlinewidth(float* width)
+PScurrentlinewidth(float *widthFloatPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentmiterlimit(float* limit)
+PScurrentmiterlimit(float *limitFloatPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentpoint(float* x, float* y)
+PScurrentpoint(float *xFloatPtr, float *yFloatPtr)
 __attribute__((unused));
 
 static inline void
-PScurrentstrokeadjust(int* b)
+PScurrentstrokeadjust(int *bIntPtr)
 __attribute__((unused));
 
 static inline void
-PSsetdash(const float* pat, int size, float offset)
+PSsetdash(const float *patternFloatPtr, int size, float offsetFloat)
 __attribute__((unused));
 
 static inline void
-PSsetflat(float flatness)
+PSsetflat(float flatnessFloat)
 __attribute__((unused));
 
 static inline void
-PSsethalftonephase(float x, float y)
+PSsethalftonephase(float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-PSsetlinecap(int linecap)
+PSsetlinecap(int linecapInt)
 __attribute__((unused));
 
 static inline void
-PSsetlinejoin(int linejoin)
+PSsetlinejoin(int linejoinInt)
 __attribute__((unused));
 
 static inline void
-PSsetlinewidth(float width)
+PSsetlinewidth(float widthFloat)
 __attribute__((unused));
 
 static inline void
-PSsetmiterlimit(float limit)
+PSsetmiterlimit(float limitFloat)
 __attribute__((unused));
 
 static inline void
-PSsetstrokeadjust(int b)
+PSsetstrokeadjust(int bInt)
 __attribute__((unused));
 
 
@@ -203,7 +203,7 @@
 /* Matrix operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PSconcat(const float* m)
+PSconcat(const float *magentaFloatPtr)
 __attribute__((unused));
 
 static inline void
@@ -211,15 +211,15 @@
 __attribute__((unused));
 
 static inline void
-PSrotate(float angle)
+PSrotate(float angleFloat)
 __attribute__((unused));
 
 static inline void
-PSscale(float x, float y)
+PSscale(float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-PStranslate(float x, float y)
+PStranslate(float xFloat, float yFloat)
 __attribute__((unused));
 
 
@@ -228,15 +228,15 @@
 /* Paint operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PSarc(float x, float y, float r, float angle1, float angle2)
+PSarc(float xFloat, float yFloat, float radiusFloat, float angle1Float, float angle2Float)
 __attribute__((unused));
 
 static inline void
-PSarcn(float x, float y, float r, float angle1, float angle2)
+PSarcn(float xFloat, float yFloat, float radiusFloat, float angle1Float, float angle2Float)
 __attribute__((unused));
 
 static inline void
-PSarct(float x1, float y1, float x2, float y2, float r)
+PSarct(float x1Float, float y1Float, float x2Float, float y2Float, float radiusFloat)
 __attribute__((unused));
 
 static inline void
@@ -248,7 +248,7 @@
 __attribute__((unused));
 
 static inline void
-PScurveto(float x1, float y1, float x2, float y2, float x3, float y3)
+PScurveto(float x1Float, float y1Float, float x2Float, float y2Float, float x3Float, float y3Float)
 __attribute__((unused));
 
 static inline void
@@ -272,11 +272,11 @@
 __attribute__((unused));
 
 static inline void
-PSlineto(float x, float y)
+PSlineto(float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-PSmoveto(float x, float y)
+PSmoveto(float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
@@ -284,23 +284,23 @@
 __attribute__((unused));
 
 static inline void
-PSpathbbox(float* llx, float* lly, float* urx, float* ury)
+PSpathbbox(float *lowerLeftXFloat, float *lowerLeftYFloat, float *upperRightXFloat, float *upperRightYFloat)
 __attribute__((unused));
 
 static inline void
-PSrcurveto(float x1, float y1, float x2, float y2, float x3, float y3)
+PSrcurveto(float x1Float, float y1Float, float x2Float, float y2Float, float x3Float, float y3Float)
 __attribute__((unused));
 
 static inline void
-PSrectclip(float x, float y, float w, float h)
+PSrectclip(float xFloat, float yFloat, float widthFloat, float heightFloat)
 __attribute__((unused));
 
 static inline void
-PSrectfill(float x, float y, float w, float h)
+PSrectfill(float xFloat, float yFloat, float widthFloat, float heightFloat)
 __attribute__((unused));
 
 static inline void
-PSrectstroke(float x, float y, float w, float h)
+PSrectstroke(float xFloat, float yFloat, float widthFloat, float heightFloat)
 __attribute__((unused));
 
 static inline void
@@ -308,11 +308,11 @@
 __attribute__((unused));
 
 static inline void
-PSrlineto(float x, float y)
+PSrlineto(float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
-PSrmoveto(float x, float y)
+PSrmoveto(float xFloat, float yFloat)
 __attribute__((unused));
 
 static inline void
@@ -328,15 +328,15 @@
 /* Graphics Extensions Ops */
 /*-------------------------------------------------------------------------*/
 static inline void
-PScomposite(float x, float y, float w, float h, int gstateNum, float dx, float dy, int op)
+PScomposite(float xFloat, float yFloat, float widthFloat, float heightFloat, int gstateNum, float destinationXFloat, float destinationYFloat, int compositingOperationInt)
 __attribute__((unused));
 
 static inline void
-PScompositerect(float x, float y, float w, float h, int op)
+PScompositerect(float xFloat, float yFloat, float widthFloat, float heightFloat, int compositingOperationInt)
 __attribute__((unused));
 
 static inline void
-PSdissolve(float x, float y, float w, float h, int gstateNum, float dx, float dy, float delta)
+PSdissolve(float xFloat, float yFloat, float widthFloat, float heightFloat, int gstateNum, float destinationXFloat, float destinationYFloat, float deltaFloat)
 __attribute__((unused));
 
 
@@ -345,11 +345,11 @@
 /* Postscript Client functions */
 /* ----------------------------------------------------------------------- */
 static inline void
-PSPrintf(const char * fmt, va_list args)
+PSPrintf(const char *fmt, va_list args)
 __attribute__((unused));
 
 static inline void
-PSWriteData(const char * buf, unsigned int count)
+PSWriteData(const char *buf, unsigned int count)
 __attribute__((unused));
 
 
@@ -357,63 +357,63 @@
 /* Color operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PScurrentalpha(float* a)
+PScurrentalpha(float *alphaFloatPtr)
 {
-  DPScurrentalpha(DEFCTXT, a);
+  DPScurrentalpha(DEFCTXT, alphaFloatPtr);
 }
 
 static inline void
-PScurrentcmykcolor(float* c, float* m, float* y, float* k)
+PScurrentcmykcolor(float *cyanFloatPtr, float *magentaFloatPtr, float *yellowFloatPtr, float *kBlackFloatPtr)
 {
-  DPScurrentcmykcolor(DEFCTXT, c, m, y, k);
+  DPScurrentcmykcolor(DEFCTXT, cyanFloatPtr, magentaFloatPtr, yellowFloatPtr, kBlackFloatPtr);
 }
 
 static inline void
-PScurrentgray(float* gray)
+PScurrentgray(float *grayFloatPtr)
 {
-  DPScurrentgray(DEFCTXT, gray);
+  DPScurrentgray(DEFCTXT, grayFloatPtr);
 }
 
 static inline void
-PScurrenthsbcolor(float* h, float* s, float* b)
+PScurrenthsbcolor(float *hueFloatPtr, float *saturationFloatPtr, float *brightnessFloatPtr)
 {
-  DPScurrenthsbcolor(DEFCTXT, h, s, b);
+  DPScurrenthsbcolor(DEFCTXT, hueFloatPtr, saturationFloatPtr, brightnessFloatPtr);
 }
 
 static inline void
-PScurrentrgbcolor(float* r, float* g, float* b)
+PScurrentrgbcolor(float *redFloatPtr, float *greenFloatPtr, float *brightnessFloatPtr)
 {
-  DPScurrentrgbcolor(DEFCTXT, r, g, b);
+  DPScurrentrgbcolor(DEFCTXT, redFloatPtr, greenFloatPtr, brightnessFloatPtr);
 }
 
 static inline void
-PSsetalpha(float a)
+PSsetalpha(float alphaFloat)
 {
-  DPSsetalpha(DEFCTXT, a);
+  DPSsetalpha(DEFCTXT, alphaFloat);
 }
 
 static inline void
-PSsetcmykcolor(float c, float m, float y, float k)
+PSsetcmykcolor(float cyanFloat, float magentaFloat, float yellowFloat, float kBlackFloat)
 {
-  DPSsetcmykcolor(DEFCTXT, c, m, y, k);
+  DPSsetcmykcolor(DEFCTXT, cyanFloat, magentaFloat, yellowFloat, kBlackFloat);
 }
 
 static inline void
-PSsetgray(float gray)
+PSsetgray(float grayFloat)
 {
-  DPSsetgray(DEFCTXT, gray);
+  DPSsetgray(DEFCTXT, grayFloat);
 }
 
 static inline void
-PSsethsbcolor(float h, float s, float b)
+PSsethsbcolor(float hueFloat, float saturationFloat, float brightnessFloat)
 {
-  DPSsethsbcolor(DEFCTXT, h, s, b);
+  DPSsethsbcolor(DEFCTXT, hueFloat, saturationFloat, brightnessFloat);
 }
 
 static inline void
-PSsetrgbcolor(float r, float g, float b)
+PSsetrgbcolor(float redFloat, float greenFloat, float blueFloat)
 {
-  DPSsetrgbcolor(DEFCTXT, r, g, b);
+  DPSsetrgbcolor(DEFCTXT, redFloat, greenFloat, blueFloat);
 }
 
 
@@ -422,51 +422,51 @@
 /* Text operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PSashow(float x, float y, const char* s)
+PSashow(float xFloat, float yFloat, const char *sConstChar)
 {
-  DPSashow(DEFCTXT, x, y, s);
+  DPSashow(DEFCTXT, xFloat, yFloat, sConstChar);
 }
 
 static inline void
-PSawidthshow(float cx, float cy, int c, float ax, float ay, const char* s)
+PSawidthshow(float cxFloat, float cyFloat, int cInt, float axFloat, float ayFloat, const char *sConstChar)
 {
-  DPSawidthshow(DEFCTXT, cx, cy, c, ax, ay, s);
+  DPSawidthshow(DEFCTXT, cxFloat, cyFloat, cInt, axFloat, ayFloat, sConstChar);
 }
 
 static inline void
-PScharpath(const char* s, int b)
+PScharpath(const char *sConstChar, int bInt)
 {
-  DPScharpath(DEFCTXT, s, b);
+  DPScharpath(DEFCTXT, sConstChar, bInt);
 }
 
 static inline void
-PSshow(const char* s)
+PSshow(const char *sConstChar)
 {
-  DPSshow(DEFCTXT, s);
+  DPSshow(DEFCTXT, sConstChar);
 }
 
 static inline void
-PSwidthshow(float x, float y, int c, const char* s)
+PSwidthshow(float xFloat, float yFloat, int cInt, const char *sConstChar)
 {
-  DPSwidthshow(DEFCTXT, x, y, c, s);
+  DPSwidthshow(DEFCTXT, xFloat, yFloat, cInt, sConstChar);
 }
 
 static inline void
-PSxshow(const char* s, const float* numarray, int size)
+PSxshow(const char *sConstChar, const float *numarrayFloatPtr, int size)
 {
-  DPSxshow(DEFCTXT, s, numarray, size);
+  DPSxshow(DEFCTXT, sConstChar, numarrayFloatPtr, size);
 }
 
 static inline void
-PSxyshow(const char* s, const float* numarray, int size)
+PSxyshow(const char *sConstChar, const float *numarrayFloatPtr, int size)
 {
-  DPSxyshow(DEFCTXT, s, numarray, size);
+  DPSxyshow(DEFCTXT, sConstChar, numarrayFloatPtr, size);
 }
 
 static inline void
-PSyshow(const char* s, const float* numarray, int size)
+PSyshow(const char *sConstChar, const float *numarrayFloatPtr, int size)
 {
-  DPSyshow(DEFCTXT, s, numarray, size);
+  DPSyshow(DEFCTXT, sConstChar, numarrayFloatPtr, size);
 }
 
 
@@ -493,9 +493,9 @@
 }
 
 static inline void
-PSsetgstate(int gst)
+PSsetgstate(int gstateTagInt)
 {
-  DPSsetgstate(DEFCTXT, gst);
+  DPSsetgstate(DEFCTXT, gstateTagInt);
 }
 
 
@@ -504,93 +504,93 @@
 /* Gstate operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PScurrentflat(float* flatness)
+PScurrentflat(float *flatnessFloatPtr)
 {
-  DPScurrentflat(DEFCTXT, flatness);
+  DPScurrentflat(DEFCTXT, flatnessFloatPtr);
 }
 
 static inline void
-PScurrentlinecap(int* linecap)
+PScurrentlinecap(int *linecapIntPtr)
 {
-  DPScurrentlinecap(DEFCTXT, linecap);
+  DPScurrentlinecap(DEFCTXT, linecapIntPtr);
 }
 
 static inline void
-PScurrentlinejoin(int* linejoin)
+PScurrentlinejoin(int *linejoinIntPtr)
 {
-  DPScurrentlinejoin(DEFCTXT, linejoin);
+  DPScurrentlinejoin(DEFCTXT, linejoinIntPtr);
 }
 
 static inline void
-PScurrentlinewidth(float* width)
+PScurrentlinewidth(float *widthFloatPtr)
 {
-  DPScurrentlinewidth(DEFCTXT, width);
+  DPScurrentlinewidth(DEFCTXT, widthFloatPtr);
 }
 
 static inline void
-PScurrentmiterlimit(float* limit)
+PScurrentmiterlimit(float *limitFloatPtr)
 {
-  DPScurrentmiterlimit(DEFCTXT, limit);
+  DPScurrentmiterlimit(DEFCTXT, limitFloatPtr);
 }
 
 static inline void
-PScurrentpoint(float* x, float* y)
+PScurrentpoint(float *xFloatPtr, float *yFloatPtr)
 {
-  DPScurrentpoint(DEFCTXT, x, y);
+  DPScurrentpoint(DEFCTXT, xFloatPtr, yFloatPtr);
 }
 
 static inline void
-PScurrentstrokeadjust(int* b)
+PScurrentstrokeadjust(int *bIntPtr)
 {
-  DPScurrentstrokeadjust(DEFCTXT, b);
+  DPScurrentstrokeadjust(DEFCTXT, bIntPtr);
 }
 
 static inline void
-PSsetdash(const float* pat, int size, float offset)
+PSsetdash(const float *patternFloatPtr, int size, float offsetFloat)
 {
-  DPSsetdash(DEFCTXT, pat, size, offset);
+  DPSsetdash(DEFCTXT, patternFloatPtr, size, offsetFloat);
 }
 
 static inline void
-PSsetflat(float flatness)
+PSsetflat(float flatnessFloat)
 {
-  DPSsetflat(DEFCTXT, flatness);
+  DPSsetflat(DEFCTXT, flatnessFloat);
 }
 
 static inline void
-PSsethalftonephase(float x, float y)
+PSsethalftonephase(float xFloat, float yFloat)
 {
-  DPSsethalftonephase(DEFCTXT, x, y);
+  DPSsethalftonephase(DEFCTXT, xFloat, yFloat);
 }
 
 static inline void
-PSsetlinecap(int linecap)
+PSsetlinecap(int linecapInt)
 {
-  DPSsetlinecap(DEFCTXT, linecap);
+  DPSsetlinecap(DEFCTXT, linecapInt);
 }
 
 static inline void
-PSsetlinejoin(int linejoin)
+PSsetlinejoin(int linejoinInt)
 {
-  DPSsetlinejoin(DEFCTXT, linejoin);
+  DPSsetlinejoin(DEFCTXT, linejoinInt);
 }
 
 static inline void
-PSsetlinewidth(float width)
+PSsetlinewidth(float widthFloat)
 {
-  DPSsetlinewidth(DEFCTXT, width);
+  DPSsetlinewidth(DEFCTXT, widthFloat);
 }
 
 static inline void
-PSsetmiterlimit(float limit)
+PSsetmiterlimit(float limitFloat)
 {
-  DPSsetmiterlimit(DEFCTXT, limit);
+  DPSsetmiterlimit(DEFCTXT, limitFloat);
 }
 
 static inline void
-PSsetstrokeadjust(int b)
+PSsetstrokeadjust(int bInt)
 {
-  DPSsetstrokeadjust(DEFCTXT, b);
+  DPSsetstrokeadjust(DEFCTXT, bInt);
 }
 
 
@@ -598,9 +598,9 @@
 /* Matrix operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PSconcat(const float* m)
+PSconcat(const float *magentaFloatPtr)
 {
-  DPSconcat(DEFCTXT, m);
+  DPSconcat(DEFCTXT, magentaFloatPtr);
 }
 
 static inline void
@@ -610,21 +610,21 @@
 }
 
 static inline void
-PSrotate(float angle)
+PSrotate(float angleFloat)
 {
-  DPSrotate(DEFCTXT, angle);
+  DPSrotate(DEFCTXT, angleFloat);
 }
 
 static inline void
-PSscale(float x, float y)
+PSscale(float xFloat, float yFloat)
 {
-  DPSscale(DEFCTXT, x, y);
+  DPSscale(DEFCTXT, xFloat, yFloat);
 }
 
 static inline void
-PStranslate(float x, float y)
+PStranslate(float xFloat, float yFloat)
 {
-  DPStranslate(DEFCTXT, x, y);
+  DPStranslate(DEFCTXT, xFloat, yFloat);
 }
 
 
@@ -633,21 +633,21 @@
 /* Paint operations */
 /* ----------------------------------------------------------------------- */
 static inline void
-PSarc(float x, float y, float r, float angle1, float angle2)
+PSarc(float xFloat, float yFloat, float radiusFloat, float angle1Float, float angle2Float)
 {
-  DPSarc(DEFCTXT, x, y, r, angle1, angle2);
+  DPSarc(DEFCTXT, xFloat, yFloat, radiusFloat, angle1Float, angle2Float);
 }
 
 static inline void
-PSarcn(float x, float y, float r, float angle1, float angle2)
+PSarcn(float xFloat, float yFloat, float radiusFloat, float angle1Float, float angle2Float)
 {
-  DPSarcn(DEFCTXT, x, y, r, angle1, angle2);
+  DPSarcn(DEFCTXT, xFloat, yFloat, radiusFloat, angle1Float, angle2Float);
 }
 
 static inline void
-PSarct(float x1, float y1, float x2, float y2, float r)
+PSarct(float x1Float, float y1Float, float x2Float, float y2Float, float radiusFloat)
 {
-  DPSarct(DEFCTXT, x1, y1, x2, y2, r);
+  DPSarct(DEFCTXT, x1Float, y1Float, x2Float, y2Float, radiusFloat);
 }
 
 static inline void
@@ -663,9 +663,9 @@
 }
 
 static inline void
-PScurveto(float x1, float y1, float x2, float y2, float x3, float y3)
+PScurveto(float x1Float, float y1Float, float x2Float, float y2Float, float x3Float, float y3Float)
 {
-  DPScurveto(DEFCTXT, x1, y1, x2, y2, x3, y3);
+  DPScurveto(DEFCTXT, x1Float, y1Float, x2Float, y2Float, x3Float, y3Float);
 }
 
 static inline void
@@ -699,15 +699,15 @@
 }
 
 static inline void
-PSlineto(float x, float y)
+PSlineto(float xFloat, float yFloat)
 {
-  DPSlineto(DEFCTXT, x, y);
+  DPSlineto(DEFCTXT, xFloat, yFloat);
 }
 
 static inline void
-PSmoveto(float x, float y)
+PSmoveto(float xFloat, float yFloat)
 {
-  DPSmoveto(DEFCTXT, x, y);
+  DPSmoveto(DEFCTXT, xFloat, yFloat);
 }
 
 static inline void
@@ -717,33 +717,33 @@
 }
 
 static inline void
-PSpathbbox(float* llx, float* lly, float* urx, float* ury)
+PSpathbbox(float *lowerLeftXFloat, float *lowerLeftYFloat, float *upperRightXFloat, float *upperRightYFloat)
 {
-  DPSpathbbox(DEFCTXT, llx, lly, urx, ury);
+  DPSpathbbox(DEFCTXT, lowerLeftXFloat, lowerLeftYFloat, upperRightXFloat, upperRightYFloat);
 }
 
 static inline void
-PSrcurveto(float x1, float y1, float x2, float y2, float x3, float y3)
+PSrcurveto(float x1Float, float y1Float, float x2Float, float y2Float, float x3Float, float y3Float)
 {
-  DPSrcurveto(DEFCTXT, x1, y1, x2, y2, x3, y3);
+  DPSrcurveto(DEFCTXT, x1Float, y1Float, x2Float, y2Float, x3Float, y3Float);
 }
 
 static inline void
-PSrectclip(float x, float y, float w, float h)
+PSrectclip(float xFloat, float yFloat, float widthFloat, float heightFloat)
 {
-  DPSrectclip(DEFCTXT, x, y, w, h);
+  DPSrectclip(DEFCTXT, xFloat, yFloat, widthFloat, heightFloat);
 }
 
 static inline void
-PSrectfill(float x, float y, float w, float h)
+PSrectfill(float xFloat, float yFloat, float widthFloat, float heightFloat)
 {
-  DPSrectfill(DEFCTXT, x, y, w, h);
+  DPSrectfill(DEFCTXT, xFloat, yFloat, widthFloat, heightFloat);
 }
 
 static inline void
-PSrectstroke(float x, float y, float w, float h)
+PSrectstroke(float xFloat, float yFloat, float widthFloat, float heightFloat)
 {
-  DPSrectstroke(DEFCTXT, x, y, w, h);
+  DPSrectstroke(DEFCTXT, xFloat, yFloat, widthFloat, heightFloat);
 }
 
 static inline void
@@ -753,15 +753,15 @@
 }
 
 static inline void
-PSrlineto(float x, float y)
+PSrlineto(float xFloat, float yFloat)
 {
-  DPSrlineto(DEFCTXT, x, y);
+  DPSrlineto(DEFCTXT, xFloat, yFloat);
 }
 
 static inline void
-PSrmoveto(float x, float y)
+PSrmoveto(float xFloat, float yFloat)
 {
-  DPSrmoveto(DEFCTXT, x, y);
+  DPSrmoveto(DEFCTXT, xFloat, yFloat);
 }
 
 static inline void
@@ -781,21 +781,21 @@
 /* Graphics Extensions Ops */
 /*-------------------------------------------------------------------------*/
 static inline void
-PScomposite(float x, float y, float w, float h, int gstateNum, float dx, float dy, int op)
+PScomposite(float xFloat, float yFloat, float widthFloat, float heightFloat, int gstateNum, float destinationXFloat, float destinationYFloat, int compositingOperationInt)
 {
-  DPScomposite(DEFCTXT, x, y, w, h, gstateNum, dx, dy, op);
+  DPScomposite(DEFCTXT, xFloat, yFloat, widthFloat, heightFloat, gstateNum, destinationXFloat, destinationYFloat, compositingOperationInt);
 }
 
 static inline void
-PScompositerect(float x, float y, float w, float h, int op)
+PScompositerect(float xFloat, float yFloat, float widthFloat, float heightFloat, int compositingOperationInt)
 {
-  DPScompositerect(DEFCTXT, x, y, w, h, op);
+  DPScompositerect(DEFCTXT, xFloat, yFloat, widthFloat, heightFloat, compositingOperationInt);
 }
 
 static inline void
-PSdissolve(float x, float y, float w, float h, int gstateNum, float dx, float dy, float delta)
+PSdissolve(float xFloat, float yFloat, float widthFloat, float heightFloat, int gstateNum, float destinationXFloat, float destinationYFloat, float deltaFloat)
 {
-  DPSdissolve(DEFCTXT, x, y, w, h, gstateNum, dx, dy, delta);
+  DPSdissolve(DEFCTXT, xFloat, yFloat, widthFloat, heightFloat, gstateNum, destinationXFloat, destinationYFloat, deltaFloat);
 }
 
 
@@ -804,13 +804,13 @@
 /* Postscript Client functions */
 /* ----------------------------------------------------------------------- */
 static inline void
-PSPrintf(const char * fmt, va_list args)
+PSPrintf(const char *fmt, va_list args)
 {
   DPSPrintf(DEFCTXT, fmt, args);
 }
 
 static inline void
-PSWriteData(const char * buf, unsigned int count)
+PSWriteData(const char *buf, unsigned int count)
 {
   DPSWriteData(DEFCTXT, buf, count);
 }
