ftp.nice.ch/Attic/openStep/implementation/gnustep/sources/objcX-0.87.tgz#/objcX-0.87/dpsclient/xtpsops.m

This is xtpsops.m in view mode; [Download] [Up]

/* xtpsops - PostScript operators and mappings to Xt calls. 

   Copyright (C) 1995 Free Software Foundation, Inc.

   Written by:  Adam Fedor <fedor@boulder.colorado.edu>
   Date: Nov 1995
   
   This file is part of the GNU Objective C User Interface library.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.
   
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.
   
   You should have received a copy of the GNU Library General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   */

#include "psops.h"
#include "XtDrawContext.h"

void PScolorimage( void )
{
  [currentContext DPScolorimage];
}


void PScurrentblackgeneration( void )
{
  [currentContext DPScurrentblackgeneration];
}


void PScurrentcmykcolor(float *c, float *m, float *y, float *k)
{
  [currentContext DPScurrentcmykcolor:c :m :y :k];
}

void PScurrentcolorscreen( void )
{
  [currentContext DPScurrentcolorscreen];
}

void PScurrentcolortransfer( void )
{
  [currentContext DPScurrentcolortransfer];
}

void PScurrentundercolorremoval( void )
{
  [currentContext DPScurrentundercolorremoval];
}

void PSsetblackgeneration( void )
{
  [currentContext DPSsetblackgeneration];
}

void PSsetcmykcolor(float c, float m, float y, float k)
{
  [currentContext DPSsetcmykcolor: c : m : y : k];
}

void PSsetcolorscreen( void )
{
  [currentContext DPSsetcolorscreen];
}

void PSsetcolortransfer( void )
{
  [currentContext DPSsetcolortransfer];
}

void PSsetundercolorremoval( void )
{
  [currentContext DPSsetundercolorremoval];
}

void PSeq( void )
{
  [currentContext DPSeq];
}

void PSexit( void )
{
  [currentContext DPSexit];
}

void PSfalse( void )
{
  [currentContext DPSfalse];
}

void PSfor( void )
{
  [currentContext DPSfor];
}

void PSforall( void )
{
  [currentContext DPSforall];
}

void PSge( void )
{
  [currentContext DPSge];
}

void PSgt( void )
{
  [currentContext DPSgt];
}

void PSif( void )
{
  [currentContext DPSif];
}

void PSifelse( void )
{
  [currentContext DPSifelse];
}

void PSle( void )
{
  [currentContext DPSle];
}

void PSloop( void )
{
  [currentContext DPSloop];
}

void PSlt( void )
{
  [currentContext DPSlt];
}

void PSne( void )
{
  [currentContext DPSne];
}

void PSnot( void )
{
  [currentContext DPSnot];
}

void PSor( void )
{
  [currentContext DPSor];
}

void PSrepeat( void )
{
  [currentContext DPSrepeat];
}

void PSstop( void )
{
  [currentContext DPSstop];
}

void PSstopped( void )
{
  [currentContext DPSstopped];
}

void PStrue( void )
{
  [currentContext DPStrue];
}

void PScondition( void )
{
  [currentContext DPScondition];
}

void PScurrentcontext(int *cid)
{
  [currentContext DPScurrentcontext: cid];
}

void PScurrentobjectformat(int *code)
{
  [currentContext DPScurrentobjectformat: code];
}

void PSdefineusername(int i, const char *username)
{
  [currentContext DPSdefineusername:i :username];
}

void PSdefineuserobject( void )
{
  [currentContext DPSdefineuserobject];
}

void PSdetach( void )
{
  [currentContext DPSdetach];
}

void PSexecuserobject(int index)
{
  [currentContext DPSexecuserobject: index];
}

void PSfork( void )
{
  [currentContext DPSfork];
}

void PSjoin( void )
{
  [currentContext DPSjoin];
}

void PSlock( void )
{
  [currentContext DPSlock];
}

void PSmonitor( void )
{
  [currentContext DPSmonitor];
}

void PSnotify( void )
{
  [currentContext DPSnotify];
}

void PSsetobjectformat(int code)
{
  [currentContext DPSsetobjectformat: code];
}

void PSsetvmthreshold(int i)
{
  [currentContext DPSsetvmthreshold: i];
}

void PSundefineuserobject(int index)
{
  [currentContext DPSundefineuserobject: index];
}

void PSuserobject( void )
{
  [currentContext DPSuserobject];
}

void PSwait( void )
{
  [currentContext DPSwait];
}

void PSyield( void )
{
  [currentContext DPSyield];
}

void PSaload( void )
{
  [currentContext DPSaload];
}

void PSanchorsearch(int *truth)
{
  [currentContext DPSanchorsearch: truth];
}

void PSarray(int len)
{
  [currentContext DPSarray: len];
}

void PSastore( void )
{
  [currentContext DPSastore];
}

void PSbegin( void )
{
  [currentContext DPSbegin];
}

void PSclear( void )
{
  [currentContext DPSclear];
}

void PScleartomark( void )
{
  [currentContext DPScleartomark];
}

void PScopy(int n)
{
  [currentContext DPScopy: n];
}

void PScount(int *n)
{
  [currentContext DPScount: n];
}

void PScounttomark(int *n)
{
  [currentContext DPScounttomark: n];
}

void PScvi( void )
{
  [currentContext DPScvi];
}

void PScvlit( void )
{
  [currentContext DPScvlit];
}

void PScvn( void )
{
  [currentContext DPScvn];
}

void PScvr( void )
{
  [currentContext DPScvr];
}

void PScvrs( void )
{
  [currentContext DPScvrs];
}

void PScvs( void )
{
  [currentContext DPScvs];
}

void PScvx( void )
{
  [currentContext DPScvx];
}

void PSdef( void )
{
  [currentContext DPSdef];
}

void PSdict(int len)
{
  [currentContext DPSdict: len];
}

void PSdictstack( void )
{
  [currentContext DPSdictstack];
}

void PSdup( void )
{
  [currentContext DPSdup];
}

void PSend( void )
{
  [currentContext DPSend];
}

void PSexch( void )
{
  [currentContext DPSexch];
}

void PSexecstack( void )
{
  [currentContext DPSexecstack];
}

void PSexecuteonly( void )
{
  [currentContext DPSexecuteonly];
}

void PSget( void )
{
  [currentContext DPSget];
}

void PSgetinterval( void )
{
  [currentContext DPSgetinterval];
}

void PSindex(int i)
{
  [currentContext DPSindex: i];
}

void PSknown(int *b)
{
  [currentContext DPSknown: b];
}

void PSlength(int *len)
{
  [currentContext DPSlength: len];
}

void PSload( void )
{
  [currentContext DPSload];
}

void PSmark( void )
{
  [currentContext DPSmark];
}

void PSmatrix( void )
{
  [currentContext DPSmatrix];
}

void PSmaxlength(int *len)
{
  [currentContext DPSmaxlength: len];
}

void PSnoaccess( void )
{
  [currentContext DPSnoaccess];
}

void PSnull( void )
{
  [currentContext DPSnull];
}

void PSpackedarray( void )
{
  [currentContext DPSpackedarray];
}

void PSpop( void )
{
  [currentContext DPSpop];
}

void PSput( void )
{
  [currentContext DPSput];
}

void PSputinterval( void )
{
  [currentContext DPSputinterval];
}

void PSrcheck(int *b)
{
  [currentContext DPSrcheck: b];
}

void PSreadonly( void )
{
  [currentContext DPSreadonly];
}

void PSroll(int n, int j)
{
  [currentContext DPSroll: n : j];
}

void PSscheck(int *b)
{
  [currentContext DPSscheck: b];
}

void PSsearch(int *b)
{
  [currentContext DPSsearch: b];
}

void PSshareddict( void )
{
  [currentContext DPSshareddict];
}

void PSstatusdict( void )
{
  [currentContext DPSstatusdict];
}

void PSstore( void )
{
  [currentContext DPSstore];
}

void PSstring(int len)
{
  [currentContext DPSstring: len];
}

void PSstringwidth(const char *s, float *xp, float *yp)
{
  [currentContext DPSstringwidth: s : xp : yp];
}

void PSsystemdict( void )
{
  [currentContext DPSsystemdict];
}

void PSuserdict( void )
{
  [currentContext DPSuserdict];
}

void PSwcheck(int *b)
{
  [currentContext DPSwcheck: b];
}

void PSwhere(int *b)
{
  [currentContext DPSwhere: b];
}

void PSxcheck(int *b)
{
  [currentContext DPSxcheck: b];
}

void PSFontDirectory( void )
{
  [currentContext DPSFontDirectory];
}

void PSISOLatin1Encoding( void )
{
  [currentContext DPSISOLatin1Encoding];
}

void PSSharedFontDirectory( void )
{
  [currentContext DPSSharedFontDirectory];
}

void PSStandardEncoding( void )
{
  [currentContext DPSStandardEncoding];
}

void PScachestatus(int *bsize, int *bmax, int *msize)
{
  [currentContext DPScachestatus: bsize : bmax : msize];
}

void PScurrentcacheparams( void )
{
  [currentContext DPScurrentcacheparams];
}

void PScurrentfont( void )
{
  [currentContext DPScurrentfont];
}

void PSdefinefont( void )
{
  [currentContext DPSdefinefont];
}

void PSfindfont(const char *name)
{
  [currentContext DPSfindfont: name];
}

void PSmakefont( void )
{
  [currentContext DPSmakefont];
}

void PSscalefont(float size)
{
  [currentContext DPSscalefont: size];
}

void PSselectfont(const char *name, float scale)
{
  [currentContext DPSselectfont: name : scale];
}

void PSsetcachedevice(float wx, float wy, float llx, float lly, float urx, float ury)
{
  [currentContext DPSsetcachedevice: wy : wy : lly : lly : urx : ury];
}

void PSsetcachelimit(float n)
{
  [currentContext DPSsetcachelimit: n];
}

void PSsetcacheparams( void )
{
  [currentContext DPSsetcacheparams];
}

void PSsetcharwidth(float wx, float wy)
{
  [currentContext DPSsetcharwidth: wx : wy];
}

void PSsetfont(int f)
{
  [currentContext DPSsetfont: f];
}

void PSundefinefont(const char *name)
{
  [currentContext DPSundefinefont: name];
}

void 
PSconcat(const float m[])
{
  [currentContext DPSconcat: m];
}

void 
PScurrentdash( void )
{
  [currentContext DPScurrentdash];
}

void PScurrentflat(float *flatness)
{
  [currentContext DPScurrentflat: flatness];
}

void PScurrentgray(float *gray)
{
  [currentContext DPScurrentgray: gray];
}

void PScurrentgstate(int gst)
{
  [currentContext DPScurrentgstate: gst];
}

void PScurrenthalftone( void )
{
  [currentContext DPScurrenthalftone];
}

void PScurrenthalftonephase(float *x, float *y)
{
  [currentContext DPScurrenthalftonephase: x : y];
}

void PScurrenthsbcolor(float *h, float *s, float *b)
{
  [currentContext DPScurrenthsbcolor: h : s : b];
}

void PScurrentlinecap(int *linecap)
{
  [currentContext DPScurrentlinecap: linecap];
}

void PScurrentlinejoin(int *linejoin)
{
  [currentContext DPScurrentlinejoin: linejoin];
}

void PScurrentlinewidth(float *width)
{
  [currentContext DPScurrentlinewidth: width];
}

void PScurrentmatrix( void )
{
  [currentContext DPScurrentmatrix];
}

void PScurrentmiterlimit(float *limit)
{
  [currentContext DPScurrentmiterlimit: limit];
}

void PScurrentpoint(float *x, float *y)
{
  [currentContext DPScurrentpoint: x : y];
}

void PScurrentrgbcolor(float *r, float *g, float *b)
{
  [currentContext DPScurrentrgbcolor: r : g : b];
}

void PScurrentscreen( void )
{
  [currentContext DPScurrentscreen];
}

void PScurrentstrokeadjust(int *b)
{
  [currentContext DPScurrentstrokeadjust: b];
}

void PScurrenttransfer( void )
{
  [currentContext DPScurrenttransfer];
}

void PSdefaultmatrix( void )
{
  [currentContext DPSdefaultmatrix];
}

void PSgrestore( void )
{
  [currentContext DPSgrestore];
}

void PSgrestoreall( void )
{
  [currentContext DPSgrestoreall];
}

void PSgsave( void )
{
  [currentContext DPSgsave];
}

void PSgstate( void )
{
  [currentContext DPSgstate];
}

void PSinitgraphics( void )
{
  [currentContext DPSinitgraphics];
}

void PSinitmatrix( void )
{
  [currentContext DPSinitmatrix];
}

void PSrotate(float angle)
{
  [currentContext DPSrotate: angle];
}

void PSscale(float x, float y)
{
  [currentContext DPSscale: x : y];
}

void PSsetdash(const float pat[], int size, float offset)
{
  [currentContext DPSsetdash: pat : size : offset];
}

void PSsetflat(float flatness)
{
  [currentContext DPSsetflat: flatness];
}

void PSsetgray(float gray)
{
  [currentContext DPSsetgray: gray];
}

void PSsetgstate(int gst)
{
  [currentContext DPSsetgstate: gst];
}

void PSsethalftone( void )
{
  [currentContext DPSsethalftone];
}

void PSsethalftonephase(float x, float y)
{
  [currentContext DPSsethalftonephase: x : y];
}

void PSsethsbcolor(float h, float s, float b)
{
  [currentContext DPSsethsbcolor: h : s : b];
}

void PSsetlinecap(int linecap)
{
  [currentContext DPSsetlinecap: linecap];
}

void PSsetlinejoin(int linejoin)
{
  [currentContext DPSsetlinejoin: linejoin];
}

void PSsetlinewidth(float width)
{
  [currentContext DPSsetlinewidth: width];
}

void PSsetmatrix( void )
{
  [currentContext DPSsetmatrix];
}

void PSsetmiterlimit(float limit)
{
  [currentContext DPSsetmiterlimit: limit];
}

void PSsetrgbcolor(float r, float g, float b)
{
  [currentContext DPSsetrgbcolor: r : g : b];
}

void PSsetscreen( void )
{
  [currentContext DPSsetscreen];
}

void PSsetstrokeadjust(int b)
{
  [currentContext DPSsetstrokeadjust: b];
}

void PSsettransfer( void )
{
  [currentContext DPSsettransfer];
}

void PStranslate(float x, float y)
{
  [currentContext DPStranslate: x : y];
}

void PSequals( void )
{
  [currentContext DPSequals];
}

void PSequalsequals( void )
{
  [currentContext DPSequalsequals];
}

void PSbytesavailable(int *n)
{
  [currentContext DPSbytesavailable: n];
}

void PSclosefile( void )
{
  [currentContext DPSclosefile];
}

void PScurrentfile( void )
{
  [currentContext DPScurrentfile];
}

void PSdeletefile(const char *filename)
{
  [currentContext DPSdeletefile: filename];
}

void PSecho(int b)
{
  [currentContext DPSecho: b];
}

void PSfile(const char *name, const char *access)
{
  [currentContext DPSfile: name : access];
}

void PSfilenameforall( void )
{
  [currentContext DPSfilenameforall];
}

void PSfileposition(int *pos)
{
  [currentContext DPSfileposition: pos];
}

void PSflush( void )
{
  [currentContext DPSflush];
}

void PSflushfile( void )
{
  [currentContext DPSflushfile];
}

void PSprint( void )
{
  [currentContext DPSprint];
}

void PSprintobject(int tag)
{
  [currentContext DPSprintobject: tag];
}

void PSpstack( void )
{
  [currentContext DPSpstack];
}

void PSread(int *b)
{
  [currentContext DPSread: b];
}

void PSreadhexstring(int *b)
{
  [currentContext DPSreadhexstring: b];
}

void PSreadline(int *b)
{
  [currentContext DPSreadline: b];
}

void PSreadstring(int *b)
{
  [currentContext DPSreadstring: b];
}

void PSrenamefile(const char *old, const char *new)
{
  [currentContext DPSrenamefile: old : new];
}

void PSresetfile( void )
{
  [currentContext DPSresetfile];
}

void PSsetfileposition(int pos)
{
  [currentContext DPSsetfileposition: pos];
}

void PSstack( void )
{
  [currentContext DPSstack];
}

void PSstatus(int *b)
{
  [currentContext DPSstatus: b];
}

void PStoken(int *b)
{
  [currentContext DPStoken: b];
}

void PSwrite( void )
{
  [currentContext DPSwrite];
}

void PSwritehexstring( void )
{
  [currentContext DPSwritehexstring];
}

void PSwriteobject(int tag)
{
  [currentContext DPSwriteobject: tag];
}

void PSwritestring( void )
{
  [currentContext DPSwritestring];
}

void PSabs( void )
{
  [currentContext DPSabs];
}

void PSadd( void )
{
  [currentContext DPSadd];
}

void PSand( void )
{
  [currentContext DPSand];
}

void PSatan( void )
{
  [currentContext DPSatan];
}

void PSbitshift(int shift)
{
  [currentContext DPSbitshift: shift];
}

void PSceiling( void )
{
  [currentContext DPSceiling];
}

void PScos( void )
{
  [currentContext DPScos];
}

void PSdiv( void )
{
  [currentContext DPSdiv];
}

void PSexp( void )
{
  [currentContext DPSexp];
}

void PSfloor( void )
{
  [currentContext DPSfloor];
}

void PSidiv( void )
{
  [currentContext DPSidiv];
}

void PSln( void )
{
  [currentContext DPSln];
}

void PSlog( void )
{
  [currentContext DPSlog];
}

void PSmod( void )
{
  [currentContext DPSmod];
}

void PSmul( void )
{
  [currentContext DPSmul];
}

void PSneg( void )
{
  [currentContext DPSneg];
}

void PSround( void )
{
  [currentContext DPSround];
}

void PSsin( void )
{
  [currentContext DPSsin];
}

void PSsqrt( void )
{
  [currentContext DPSsqrt];
}

void PSsub( void )
{
  [currentContext DPSsub];
}

void PStruncate( void )
{
  [currentContext DPStruncate];
}

void PSxor( void )
{
  [currentContext DPSxor];
}

void PSconcatmatrix( void )
{
  [currentContext DPSconcatmatrix];
}

void PSdtransform(float x1, float y1, float *x2, float *y2)
{
  [currentContext DPSdtransform: x1 : y1 : x2 : y2];
}

void PSidentmatrix( void )
{
  [currentContext DPSidentmatrix];
}

void PSidtransform(float x1, float y1, float *x2, float *y2)
{
  [currentContext DPSidtransform: x1 : y1 : x2 : y2];
}

void PSinvertmatrix( void )
{
  [currentContext DPSinvertmatrix];
}

void PSitransform(float x1, float y1, float *x2, float *y2)
{
  [currentContext DPSitransform: x1 : y1 : x2 : y2];
}

void PStransform(float x1, float y1, float *x2, float *y2)
{
  [currentContext DPStransform: x1 : y1 : x2 : y2];
}

void PSbanddevice( void )
{
  [currentContext DPSbanddevice];
}

void PSframedevice( void )
{
  [currentContext DPSframedevice];
}

void PSnulldevice( void )
{
  [currentContext DPSnulldevice];
}

void PSrenderbands( void )
{
  [currentContext DPSrenderbands];
}

void PSgetboolean(int *it)
{
  [currentContext DPSgetboolean: it];
}

void PSgetchararray(int size, char s[])
{
  [currentContext DPSgetchararray: size : s];
}

void PSgetfloat(float *it)
{
  [currentContext DPSgetfloat: it];
}

void PSgetfloatarray(int size, float a[])
{
  [currentContext DPSgetfloatarray: size : a];
}

void PSgetint(int *it)
{
  [currentContext DPSgetint: it];
}

void PSgetintarray(int size, int a[])
{
  [currentContext DPSgetintarray: size : a];
}

void PSgetstring(char *s)
{
  [currentContext DPSgetstring: s];
}

void PSsendboolean(int it)
{
  [currentContext DPSsendboolean: it];
}

void PSsendchararray(const char s[], int size)
{
  [currentContext DPSsendchararray: s : size];
}

void PSsendfloat(float it)
{
  [currentContext DPSsendfloat: it];
}

void PSsendfloatarray(const float a[], int size)
{
  [currentContext DPSsendfloatarray: a : size];
}

void PSsendint(int it)
{
  [currentContext DPSsendint: it];
}

void PSsendintarray(const int a[], int size)
{
  [currentContext DPSsendintarray: a : size];
}

void PSsendstring(const char *s)
{
  [currentContext DPSsendstring: s];
}

void PSashow(float x, float y, const char *s)
{
  [currentContext DPSashow: x : y : s];
}

void PSawidthshow(float cx, float cy, int c, float ax, float ay, const char *s)
{
  [currentContext DPSawidthshow: cx : cy : c : ax : ay : s];
}

void PScopypage( void )
{
  [currentContext DPScopypage];
}

void PSeofill( void )
{
  [currentContext DPSeofill];
}

void PSerasepage( void )
{
  [currentContext DPSerasepage];
}

void PSfill( void )
{
  [currentContext DPSfill];
}

void PSimage( void )
{
  [currentContext DPSimage];
}

void PSimagemask( void )
{
  [currentContext DPSimagemask];
}

void PSkshow(const char *s)
{
  [currentContext DPSkshow: s];
}

void PSrectfill(float x, float y, float w, float h)
{
  [currentContext DPSrectfill: x : y : w : h];
}

void PSrectstroke(float x, float y, float w, float h)
{
  [currentContext DPSrectstroke: x : y : w : h];
}

void PSshow(const char *s)
{
  [currentContext DPSshow: s];
}

void PSshowpage( void )
{
  [currentContext DPSshowpage];
}

void PSstroke( void )
{
  [currentContext DPSstroke];
}

void PSstrokepath( void )
{
  [currentContext DPSstrokepath];
}

void PSueofill(const char nums[], int n, const char ops[], int l)
{
  [currentContext DPSueofill: nums : n : ops : l];
}

void PSufill(const char nums[], int n, const char ops[], int l)
{
  [currentContext DPSufill: nums : n : ops : l];
}

void PSustroke(const char nums[], int n, const char ops[], int l)
{
  [currentContext DPSustroke: nums : n : ops : l];
}

void PSustrokepath(const char nums[], int n, const char ops[], int l)
{
  [currentContext DPSustrokepath: nums : n : ops : l];
}

void PSwidthshow(float x, float y, int c, const char *s)
{
  [currentContext DPSwidthshow: x : y : c : s];
}

void PSxshow(const char *s, const float numarray[], int size)
{
  [currentContext DPSxshow: s : numarray : size];
}

void PSxyshow(const char *s, const float numarray[], int size)
{
  [currentContext DPSxyshow: s : numarray : size];
}

void PSyshow(const char *s, const float numarray[], int size)
{
  [currentContext DPSyshow: s : numarray : size];
}

void PSarc(float x, float y, float r, float angle1, float angle2)
{
  [currentContext DPSarc: x : y : r : angle1 : angle2];
}

void PSarcn(float x, float y, float r, float angle1, float angle2)
{
  [currentContext DPSarcn: x : y : r : angle1 : angle2];
}

void PSarct(float x1, float y1, float x2, float y2, float r)
{
  [currentContext DPSarct: x1 : y1 : x2 : y2 : r];
}

void PSarcto(float x1, float y1, float x2, float y2, float r, float *xt1, float *yt1, float *xt2, float *yt2)
{
  [currentContext DPSarcto: x1 : y1 : x2 : y2 : r : xt1 : yt1 : xt2 : yt2];
}

void PScharpath(const char *s, int b)
{
  [currentContext DPScharpath: s : b];
}

void PSclip( void )
{
  [currentContext DPSclip];
}

void PSclippath( void )
{
  [currentContext DPSclippath];
}

void PSclosepath( void )
{
  [currentContext DPSclosepath];
}

void PScurveto(float x1, float y1, float x2, float y2, float x3, float y3)
{
  [currentContext DPScurveto: x1 : y1 : x2 : y2 : x3 : y3];
}

void PSeoclip( void )
{
  [currentContext DPSeoclip];
}

void PSeoviewclip( void )
{
  [currentContext DPSeoviewclip];
}

void PSflattenpath( void )
{
  [currentContext DPSflattenpath];
}

void PSinitclip( void )
{
  [currentContext DPSinitclip];
}

void PSinitviewclip( void )
{
  [currentContext DPSinitviewclip];
}

void PSlineto(float x, float y)
{
  [currentContext DPSlineto: x : y];
}

void PSmoveto(float x, float y)
{
  [currentContext DPSmoveto: x : y];
}

void PSnewpath( void )
{
  [currentContext DPSnewpath];
}

void PSpathbbox(float *llx, float *lly, float *urx, float *ury)
{
  [currentContext DPSpathbbox: llx : lly : urx : ury];
}

void PSpathforall( void )
{
  [currentContext DPSpathforall];
}

void PSrcurveto(float x1, float y1, float x2, float y2, float x3, float y3)
{
  [currentContext DPSrcurveto: x1 : y1 : x2 : y2 : x3 : y3];
}

void PSrectclip(float x, float y, float w, float h)
{
  [currentContext DPSrectclip: x : y : w : h];
}

void PSrectviewclip(float x, float y, float w, float h)
{
  [currentContext DPSrectviewclip: x : y : w : h];
}

void PSreversepath( void )
{
  [currentContext DPSreversepath];
}

void PSrlineto(float x, float y)
{
  [currentContext DPSrlineto: x : y];
}

void PSrmoveto(float x, float y)
{
  [currentContext DPSrmoveto: x : y];
}

void PSsetbbox(float llx, float lly, float urx, float ury)
{
  [currentContext DPSsetbbox: llx : lly : urx : ury];
}

void PSsetucacheparams( void )
{
  [currentContext DPSsetucacheparams];
}

void PSuappend(const char nums[], int n, const char ops[], int l)
{
  [currentContext DPSuappend: nums : n : ops : l];
}

void PSucache( void )
{
  [currentContext DPSucache];
}

void PSucachestatus( void )
{
  [currentContext DPSucachestatus];
}

void PSupath(int b)
{
  [currentContext DPSupath: b];
}

void PSviewclip( void )
{
  [currentContext DPSviewclip];
}

void PSviewclippath( void )
{
  [currentContext DPSviewclippath];
}

void PSbind( void )
{
  [currentContext DPSbind];
}

void PScountdictstack(int *n)
{
  [currentContext DPScountdictstack: n];
}

void PScountexecstack(int *n)
{
  [currentContext DPScountexecstack: n];
}

void PScurrentdict( void )
{
  [currentContext DPScurrentdict];
}

void PScurrentpacking(int *b)
{
  [currentContext DPScurrentpacking: b];
}

void PScurrentshared(int *b)
{
  [currentContext DPScurrentshared: b];
}

void PSdeviceinfo( void )
{
  [currentContext DPSdeviceinfo];
}

void PSerrordict( void )
{
  [currentContext DPSerrordict];
}

void PSexec( void )
{
  [currentContext DPSexec];
}

void PSprompt( void )
{
  [currentContext DPSprompt];
}

void PSquit( void )
{
  [currentContext DPSquit];
}

void PSrand( void )
{
  [currentContext DPSrand];
}

void PSrealtime(int *i)
{
  [currentContext DPSrealtime: i];
}

void PSrestore( void )
{
  [currentContext DPSrestore];
}

void PSrrand( void )
{
  [currentContext DPSrrand];
}

void PSrun(const char *filename)
{
  [currentContext DPSrun: filename];
}

void PSsave( void )
{
  [currentContext DPSsave];
}

void PSsetpacking(int b)
{
  [currentContext DPSsetpacking: b];
}

void PSsetshared(int b)
{
  [currentContext DPSsetshared: b];
}

void PSsrand( void )
{
  [currentContext DPSsrand];
}

void PSstart( void )
{
  [currentContext DPSstart];
}

void PStype( void )
{
  [currentContext DPStype];
}

void PSundef(const char *name)
{
  [currentContext DPSundef: name];
}

void PSusertime(int *milliseconds)
{
  [currentContext DPSusertime: milliseconds];
}

void PSversion(int bufsize, char buf[])
{
  [currentContext DPSversion: bufsize : buf];
}

void PSvmreclaim(int code)
{
  [currentContext DPSvmreclaim: code];
}

void PSvmstatus(int *level, int *used, int *maximum)
{
  [currentContext DPSvmstatus: level : used : maximum];
}

void PSineofill(float x, float y, int *b)
{
  [currentContext DPSineofill: x : y : b];
}

void PSinfill(float x, float y, int *b)
{
  [currentContext DPSinfill: x : y : b];
}

void PSinstroke(float x, float y, int *b)
{
  [currentContext DPSinstroke: x : y : b];
}

void PSinueofill(float x, float y, const char nums[], int n, const char ops[], int l, int *b)
{
  [currentContext DPSinueofill: x : y : nums : n : ops : l : b];
}

void PSinufill(float x, float y, const char nums[], int n, const char ops[], int l, int *b)
{
  [currentContext DPSinufill: x : y : nums : n : ops : l : b];
}

void PSinustroke(float x, float y, const char nums[], int n, const char ops[], int l, int *b)
{
  [currentContext DPSinustroke: x : y : nums : n : ops : l : b];
}

void PSwtranslation(float *x, float *y)
{
  [currentContext DPSwtranslation: x : y];
}

void PSleftbracket( void )
{
  [currentContext DPSleftbracket];
}

void PSrightbracket( void )
{
  [currentContext DPSrightbracket];
}

void PSleftleft( void )
{
  [currentContext DPSleftleft];
}

void PSrightright( void )
{
  [currentContext DPSrightright];
}

void PScshow(const char *s)
{
  [currentContext DPScshow: s];
}

void PScurrentcolor( void )
{
  [currentContext DPScurrentcolor];
}

void PScurrentcolorrendering( void )
{
  [currentContext DPScurrentcolorrendering];
}

void PScurrentcolorspace( void )
{
  [currentContext DPScurrentcolorspace];
}

void PScurrentdevparams(const char *dev)
{
  [currentContext DPScurrentdevparams: dev];
}

void PScurrentglobal(int *b)
{
  [currentContext DPScurrentglobal: b];
}

void PScurrentoverprint(int *b)
{
  [currentContext DPScurrentoverprint: b];
}

void PScurrentpagedevice( void )
{
  [currentContext DPScurrentpagedevice];
}

void PScurrentsystemparams( void )
{
  [currentContext DPScurrentsystemparams];
}

void PScurrentuserparams( void )
{
  [currentContext DPScurrentuserparams];
}

void PSdefineresource(const char *category)
{
  [currentContext DPSdefineresource: category];
}

void PSexecform( void )
{
  [currentContext DPSexecform];
}

void PSfilter( void )
{
  [currentContext DPSfilter];
}

void PSfindencoding(const char *key)
{
  [currentContext DPSfindencoding: key];
}

void PSfindresource(const char *key, const char *category)
{
  [currentContext DPSfindresource: key : category];
}

void PSgcheck(int *b)
{
  [currentContext DPSgcheck: b];
}

void PSglobaldict( void )
{
  [currentContext DPSglobaldict];
}

void PSGlobalFontDirectory( void )
{
  [currentContext DPSGlobalFontDirectory];
}

void PSglyphshow(const char *name)
{
  [currentContext DPSglyphshow: name];
}

void PSlanguagelevel(int *n)
{
  [currentContext DPSlanguagelevel: n];
}

void PSmakepattern( void )
{
  [currentContext DPSmakepattern];
}

void PSproduct( void )
{
  [currentContext DPSproduct];
}

void PSresourceforall(const char *category)
{
  [currentContext DPSresourceforall: category];
}

void PSresourcestatus(const char *key, const char *category, int *b)
{
  [currentContext DPSresourcestatus: key : category : b];
}

void PSrevision(int *n)
{
  [currentContext DPSrevision: n];
}

void PSrootfont( void )
{
  [currentContext DPSrootfont];
}

void PSserialnumber(int *n)
{
  [currentContext DPSserialnumber: n];
}

void PSsetcolor( void )
{
  [currentContext DPSsetcolor];
}

void PSsetcolorrendering( void )
{
  [currentContext DPSsetcolorrendering];
}

void PSsetcolorspace( void )
{
  [currentContext DPSsetcolorspace];
}

void PSsetdevparams( void )
{
  [currentContext DPSsetdevparams];
}

void PSsetglobal(int b)
{
  [currentContext DPSsetglobal: b];
}

void PSsetoverprint(int b)
{
  [currentContext DPSsetoverprint: b];
}

void PSsetpagedevice( void )
{
  [currentContext DPSsetpagedevice];
}

void PSsetpattern(int patternDict)
{
  [currentContext DPSsetpattern: patternDict];
}

void PSsetsystemparams( void )
{
  [currentContext DPSsetsystemparams];
}

void PSsetuserparams( void )
{
  [currentContext DPSsetuserparams];
}

void PSstartjob(int b, const char *password)
{
  [currentContext DPSstartjob: b : password];
}

void PSundefineresource(const char *key, const char *category)
{
  [currentContext DPSundefineresource: key : category];
}

These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.