Delete Type1

Yes, these are still real fonts, but freetype can handle them just fine.

1 files changed, 0 insertions, 745 deletions

diff --git a/src/Type1/paths.c b/src/Type1/paths.c
deleted file mode 100644
index a0fe5a5..0000000
--- a/src/Type1/paths.c
+++ /dev/null
@@ -1,745 +0,0 @@
-/* $Xorg: paths.c,v 1.3 2000/08/17 19:46:31 cpqbld Exp $ */
-/* Copyright International Business Machines, Corp. 1991
- * All Rights Reserved
- * Copyright Lexmark International, Inc. 1991
- * All Rights Reserved
- *
- * License to use, copy, modify, and distribute this software and its
- * documentation for any purpose and without fee is hereby granted,
- * provided that the above copyright notice appear in all copies and that
- * both that copyright notice and this permission notice appear in
- * supporting documentation, and that the name of IBM or Lexmark not be
- * used in advertising or publicity pertaining to distribution of the
- * software without specific, written prior permission.
- *
- * IBM AND LEXMARK PROVIDE THIS SOFTWARE "AS IS", WITHOUT ANY WARRANTIES OF
- * ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO ANY
- * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
- * AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.  THE ENTIRE RISK AS TO THE
- * QUALITY AND PERFORMANCE OF THE SOFTWARE, INCLUDING ANY DUTY TO SUPPORT
- * OR MAINTAIN, BELONGS TO THE LICENSEE.  SHOULD ANY PORTION OF THE
- * SOFTWARE PROVE DEFECTIVE, THE LICENSEE (NOT IBM OR LEXMARK) ASSUMES THE
- * ENTIRE COST OF ALL SERVICING, REPAIR AND CORRECTION.  IN NO EVENT SHALL
- * IBM OR LEXMARK BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
- * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
- * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
- * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
- * THIS SOFTWARE.
- */
-/* $XFree86: xc/lib/font/Type1/paths.c,v 1.7tsi Exp $ */
-
- /* PATHS    CWEB         V0021 ********                             */
-/*
-:h1 id=paths.PATHS Module - Path Operator Handler
- 
-This is the module that is responsible for building and transforming
-path lists.
- 
-&author. Jeffrey B. Lotspiech (lotspiech@almaden.ibm.com)
- 
- 
-:h3.Include Files
- 
-The included files are:
-*/
- 
-                             /*   after the system includes  (dsr)           */
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-#include  "objects.h"
-#include  "spaces.h"
-#include  "paths.h"
-#include  "regions.h"      /* understands about Union                      */
-#include  "fonts.h"        /* understands about TEXTTYPEs                  */
-#include  "pictures.h"     /* understands about handles                    */
-#include  "strokes.h"      /* understands how to coerce stroke paths       */
-#include  "trig.h"
-
-
-/*
-:h3.Routines Available to the TYPE1IMAGER User
- 
-The PATHS routines that are made available to the outside user are:
-*/
- 
-/*SHARED LINE(S) ORIGINATED HERE*/
-/*
-:h3.Functions Provided to Other Modules
- 
-The path routines that are made available to other TYPE1IMAGER modules
-are defined here:
-*/
- 
-/*SHARED LINE(S) ORIGINATED HERE*/
-/*
-NOTE:  because of the casts put in the macros for Loc, ArcCA, Conic,
-RoundConic, PathSegment, and JoinSegment, we cannot use the macro names
-when the functions are actually defined.  We have to use the unique
-names with their unique first two characters.  Thus, if anyone in the
-future ever decided to change the first two characters, it would not be
-enough just to change the macro (as it would for most other functions).
-He would have to also change the function definition.
-*/
-/*
-:h3.Macros Provided to Other Modules
- 
-The CONCAT macro is defined here and used in the STROKES module.  See
-:hdref refid=pathmac..
-*/
- 
-/*SHARED LINE(S) ORIGINATED HERE*/
- 
-/*
-:h2.Path Segment Structures
- 
-A path is represented as a linked list of the following structure:
-*/
- 
-/*SHARED LINE(S) ORIGINATED HERE*/
-/*
-When 'link' is NULL, we are at the last segment in the path (surprise!).
- 
-'last' is only non-NULL on the first segment of a path,
-for all the other segments 'last' == NULL.  We test for a non-NULL
-'last' (ISPATHANCHOR predicate) when we are given an alleged path
-to make sure the user is not trying to pull a fast one on us.
- 
-A path may be a collection of disjoint paths.  Every break in the
-disjoint path is represented by a MOVETYPE segment.
- 
-Closed paths are discussed in :hdref refid=close..
- 
-:h3.CopyPath() - Physically Duplicating a Path
- 
-This simple function illustrates moving through the path linked list.
-Duplicating a segment just involves making a copy of it, except for
-text, which has some auxilliary things involved.  We don't feel
-competent to duplicate text in this module, so we call someone who
-knows how (in the FONTS module).
-*/
-struct segment *
-CopyPath(struct segment *p0)         /* path to duplicate                    */
-{
-       register struct segment *p,*n = NULL,*last = NULL,*anchor;
- 
-       for (p = p0, anchor = NULL; p != NULL; p = p->link) {
- 
-               ARGCHECK((!ISPATHTYPE(p->type) || (p != p0 && p->last != NULL)),
-                       "CopyPath: invalid segment", p, NULL, (0), struct segment *);
- 
-               if (p->type == TEXTTYPE)
-                       n = (struct segment *) CopyText(p);
-               else
-                       n = (struct segment *)Allocate(p->size, p, 0);
-               n->last = NULL;
-               if (anchor == NULL)
-                       anchor = n;
-               else
-                       last->link = n;
-               last = n;
-       }
-/*
-At this point we have a chain of newly allocated segments hanging off
-'anchor'.  We need to make sure the first segment points to the last:
-*/
-       if (anchor != NULL) {
-               n->link = NULL;
-               anchor->last = n;
-       }
- 
-       return(anchor);
-}
-/*
-:h3.KillPath() - Destroying a Path
- 
-Destroying a path is simply a matter of freeing each segment in the
-linked list.  Again, we let the experts handle text.
-*/
-void 
-KillPath(struct segment *p)         /* path to destroy                       */
-{
-       register struct segment *linkp;  /* temp register holding next segment*/
- 
-       /* return conditional based on reference count 3-26-91 PNM */
-       if ( (--(p->references) > 1) ||
-          ( (p->references == 1) && !ISPERMANENT(p->flag) ) )
-           return;
- 
-       while (p != NULL) {
-               if (!ISPATHTYPE(p->type)) {
-                       ArgErr("KillPath: bad segment", p, NULL);
-                       return;
-               }
-               linkp = p->link;
-               if (p->type == TEXTTYPE)
-                       KillText(p);
-               else
-                       Free(p);
-               p = linkp;
-       }
-}
- 
-/*
-:h2 id=location."location" Objects
- 
-The TYPE1IMAGER user creates and destroys objects of type "location".  These
-objects locate points for the primitive path operators.  We play a trick
-here and store these objects in the same "segment" structure used for
-paths, with a type field == MOVETYPE.
- 
-This allows the Line() operator, for example, to be very trivial:
-It merely stamps its input structure as a LINETYPE and returns it to the
-caller--assuming, of course, the input structure was not permanent (as
-it usually isn't).
- 
-:h3.The "movesegment" Template Structure
- 
-This template is used as a generic segment structure for Allocate:
-*/
- 
-/* added reference field 1 to temporary template below 3-26-91 PNM */
-static struct segment movetemplate = { MOVETYPE, 0, 1, sizeof(struct segment), 0,
-                NULL, NULL, {0, 0} };
-/*
-:h3.Loc() - Create an "Invisible Line" Between (0,0) and a Point
- 
-*/
- 
-struct segment *
-t1_Loc(struct XYspace *S,    /* coordinate space to interpret X,Y            */
-       double x, double y)   /* destination point                            */
-{
-       register struct segment *r;
- 
- 
-       r = (struct segment *)Allocate(sizeof(struct segment), &movetemplate, 0);
-       TYPECHECK("Loc", S, SPACETYPE, r, (0), struct segment *);
- 
-       r->last = r;
-       r->context = S->context;
-       (*S->convert)(&r->dest, S, x, y);
-       ConsumeSpace(S);
-       return(r);
-}
-/*
-:h3.ILoc() - Loc() With Integer Arguments
- 
-*/
-struct segment *
-ILoc(struct XYspace *S,         /* coordinate space to interpret X,Y         */
-     int x, int y)              /* destination point                         */
-{
-       register struct segment *r;
- 
-       r = (struct segment *)Allocate(sizeof(struct segment), &movetemplate, 0);
-       TYPECHECK("Loc", S, SPACETYPE, r, (0), struct segment *);
- 
-       r->last = r;
-       r->context = S->context;
-       (*S->iconvert)(&r->dest, S, (long) x, (long) y);
-       ConsumeSpace(S);
-       return(r);
-}
- 
-/*
-:h2.Straight Line Segments
- 
-:h3.PathSegment() - Create a Generic Path Segment
- 
-Many routines need a LINETYPE or MOVETYPE path segment, but do not
-want to go through the external user's interface, because, for example,
-they already know the "fractpel" destination of the segment and the
-conversion is unnecessary.  PathSegment() is an internal routine
-provided to the rest of TYPE1IMAGER for handling these cases.
-*/
- 
-struct segment *
-t1_PathSegment(int type,     /* LINETYPE or MOVETYPE                         */
-	       fractpel x, fractpel y) /* where to go to, if known           */
-{
-       register struct segment *r;  /* newly created segment                 */
- 
-       r = (struct segment *)Allocate(sizeof(struct segment), &movetemplate, 0);
-       r->type = type;
-       r->last = r;          /* last points to itself for singleton          */
-       r->dest.x = x;
-       r->dest.y = y;
-       return(r);
-}
-/*
-:h3.Line() - Create a Line Segment Between (0,0) and a Point P
- 
-This involves just creating and filling out a segment structure:
-*/
-struct segment *
-Line(struct segment *P)      /* relevant coordinate space                    */
-{
-       ARGCHECK(!ISLOCATION(P), "Line: arg not a location", P, NULL, (0), struct segment *);
- 
-       P = UniquePath(P);
-       P->type = LINETYPE;
-       return(P);
-}
-/*
-:h2.Curved Path Segments
- 
-We need more points to describe curves.  So, the structures for curved
-path segments are slightly different.  The first part is identical;
-the curved structures are larger with the extra points on the end.
- 
-:h3.Bezier Segment Structure
- 
-We support third order Bezier curves.  They are specified with four
-control points A, B, C, and D.  The curve starts at A with slope AB
-and ends at D with slope CD.  The curvature at the point A is inversely
-related to the length |AB|, and the curvature at the point D is
-inversely related to the length |CD|.  Point A is always point (0,0).
- 
-*/
- 
-/*SHARED LINE(S) ORIGINATED HERE*/
-/*
-:h3.Bezier() - Generate a Bezier Segment
- 
-This is just a simple matter of filling out a 'beziersegment' structure:
-*/
- 
-struct beziersegment *
-Bezier(struct segment *B,           /* second control point                  */
-       struct segment *C,           /* third control point                   */
-       struct segment *D)           /* fourth control point (ending point)   */
-{
-/* added reference field of 1 to temporary template below 3-26-91  PNM */
-       static struct beziersegment template =
-                    { BEZIERTYPE, 0, 1, sizeof(struct beziersegment), 0,
-                      NULL, NULL, { 0, 0 }, { 0, 0 }, { 0, 0 } };
- 
-       register struct beziersegment *r;  /* output segment                  */
- 
-       ARGCHECK(!ISLOCATION(B), "Bezier: bad B", B, NULL, (2,C,D), struct beziersegment *);
-       ARGCHECK(!ISLOCATION(C), "Bezier: bad C", C, NULL, (2,B,D), struct beziersegment *);
-       ARGCHECK(!ISLOCATION(D), "Bezier: bad D", D, NULL, (2,B,C), struct beziersegment *);
- 
-       r = (struct beziersegment *)Allocate(sizeof(struct beziersegment), &template, 0);
-       r->last = (struct segment *) r;
-       r->dest.x = D->dest.x;
-       r->dest.y = D->dest.y;
-       r->B.x = B->dest.x;
-       r->B.y = B->dest.y;
-       r->C.x = C->dest.x;
-       r->C.y = C->dest.y;
- 
-       ConsumePath(B);
-       ConsumePath(C);
-       ConsumePath(D);
-       return(r);
-}
- 
-/*SHARED LINE(S) ORIGINATED HERE*/
- 
-/*
-POP removes the first segment in a path 'p' and Frees it.  'p' is left
-pointing to the end of the path:
-*/
-#define POP(p) \
-     { register struct segment *linkp; \
-       linkp = p->link; \
-       if (linkp != NULL) \
-               linkp->last = p->last; \
-       Free(p); \
-       p = linkp; }
-/*
-INSERT inserts a single segment in the middle of a chain.  'b' is
-the segment before, 'p' the segment to be inserted, and 'a' the
-segment after.
-*/
-#define INSERT(b,p,a)  b->link=p; p->link=a; p->last=NULL
- 
-/*
-:h3.Join() - Join Two Objects Together
- 
-If these are paths, this operator simply invokes the CONCAT macro.
-Why so much code then, you ask?  Well we have to check for object
-types other than paths, and also check for certain path consistency
-rules.
-*/
- 
-struct segment *
-Join(struct segment *p1, struct segment *p2)
-{
-/*
-We start with a whole bunch of very straightforward argument tests:
-*/
-       if (p2 != NULL) {
-               if (!ISPATHTYPE(p2->type)) {
- 
-                       if (p1 == NULL)
-                               return((struct segment *)Unique(p2));
- 
-                       switch (p1->type) {
- 
-                           case REGIONTYPE:
- 
-                           case STROKEPATHTYPE:
-                               p1 = CoercePath(p1);
-                               break;
- 
-                           default:
-                               return((struct segment *)BegHandle(p1, p2));
-                       }
-               }
- 
-               ARGCHECK((p2->last == NULL), "Join: right arg not anchor", p2, NULL, (1,p1), struct segment *);
-               p2 = UniquePath(p2);
- 
-/*
-In certain circumstances, we don't have to duplicate a permanent
-location.  (We would just end up destroying it anyway).  These cases
-are when 'p2' begins with a move-type segment:
-*/
-               if (p2->type == TEXTTYPE || p2->type == MOVETYPE) {
-                       if (p1 == NULL)
-                               return(p2);
-                       if (ISLOCATION(p1)) {
-                               p2->dest.x += p1->dest.x;
-                               p2->dest.y += p1->dest.y;
-                               ConsumePath(p1);
-                               return(p2);
-                       }
-               }
-       }
-       else
-               return((struct segment *)Unique(p1));
- 
-       if (p1 != NULL) {
-               if (!ISPATHTYPE(p1->type))
- 
-                       switch (p2->type) {
- 
-                           case REGIONTYPE:
- 
-                           case STROKEPATHTYPE:
-                               p2 = CoercePath(p2);
-                               break;
- 
-                           default:
-                               return((struct segment *)EndHandle(p1, p2));
-                       }
- 
-               ARGCHECK((p1->last == NULL), "Join: left arg not anchor", p1, NULL, (1,p2), struct segment *);
-               p1 = UniquePath(p1);
-       }
-       else
-               return(p2);
- 
-/*
-At this point all the checking is done.  We have two temporary non-null
-path types in 'p1' and 'p2'.  If p1 ends with a MOVE, and p2 begins with
-a MOVE, we collapse the two MOVEs into one.  We enforce the rule that
-there may not be two MOVEs in a row:
-*/
- 
-       if (p1->last->type == MOVETYPE && p2->type == MOVETYPE) {
-               p1->last->flag |= p2->flag;
-               p1->last->dest.x += p2->dest.x;
-               p1->last->dest.y += p2->dest.y;
-               POP(p2);
-               if (p2 == NULL)
-                       return(p1);
-       }
-/*
-Now we check for another silly rule.  If a path has any TEXTTYPEs,
-then it must have only TEXTTYPEs and MOVETYPEs, and furthermore,
-it must begin with a TEXTTYPE.  This rule makes it easy to check
-for the special case of text.  If necessary, we will coerce
-TEXTTYPEs into paths so we don't mix TEXTTYPEs with normal paths.
-*/
-       if (p1->type == TEXTTYPE) {
-               if (p2->type != TEXTTYPE && !ISLOCATION(p2))
-                       p1 = CoerceText(p1);
-       }
-       else {
-               if (p2->type == TEXTTYPE) {
-                       if (ISLOCATION(p1)) {
-                               p2->dest.x += p1->dest.x;
-                               p2->dest.y += p1->dest.y;
-                               Free(p1);
-                               return(p2);
-                       }
-                       else
-                               p2 = CoerceText(p2);
-               }
-       }
-/*
-Thank God!  Finally!  It's hard to believe, but we are now able to
-actually do the join.  This is just invoking the CONCAT macro:
-*/
-       CONCAT(p1, p2);
- 
-       return(p1);
-}
- 
-/*
-:h3.JoinSegment() - Create a Path Segment and Join It to a Known Path
- 
-This internal function is quicker than a full-fledged join because
-it can do much less checking.
-*/
- 
-struct segment *
-t1_JoinSegment(struct segment *before, /* path to join before new segment    */
-	       int type,     /* type of new segment (MOVETYPE or LINETYPE)   */
-	       fractpel x, fractpel y, /* x,y of new segment                 */
-	       struct segment *after) /* path to join after new segment      */
-{
-       register struct segment *r;  /* returned path built here              */
- 
-       r = PathSegment(type, x, y);
-       if (before != NULL) {
-               CONCAT(before, r);
-               r = before;
-       }
-       else
-               r->context = after->context;
-       if (after != NULL)
-               CONCAT(r, after);
-       return(r);
-}
- 
-/*
-:h2.Other Path Functions
- 
-*/
- 
- 
-struct segment *
-t1_ClosePath(struct segment *p0, /* path to close                            */
-	     int lastonly)     /*  flag deciding to close all subpaths or... */
-{
-       register struct segment *p,*last = NULL,*start;  /* used in looping through path */
-       register fractpel x,y;  /* current position in path                   */
-       register fractpel firstx = 0,firsty = 0;  /* start position of sub path       */
-       register struct segment *lastnonhint = NULL;  /* last non-hint segment in path */
- 
-       if (p0 != NULL && p0->type == TEXTTYPE)
-               return(UniquePath(p0));
-       if (p0->type == STROKEPATHTYPE)
-               return((struct segment *)Unique(p0));
-       /*
-       * NOTE: a null closed path is different from a null open path
-       * and is denoted by a closed (0,0) move segment.  We make
-       * sure this path begins and ends with a MOVETYPE:
-       */
-       if (p0 == NULL || p0->type != MOVETYPE)
-               p0 = JoinSegment(NULL, MOVETYPE, 0, 0, p0);
-       TYPECHECK("ClosePath", p0, MOVETYPE, NULL, (0), struct segment *);
-       if (p0->last->type != MOVETYPE)
-               p0 = JoinSegment(p0, MOVETYPE, 0, 0, NULL);
- 
-       p0 = UniquePath(p0);
- 
-/*
-We now begin a loop through the path,
-incrementing current 'x' and 'y'.  We are searching
-for MOVETYPE segments (breaks in the path) that are not already closed.
-At each break, we insert a close segment.
-*/
-       for (p = p0, x = y = 0, start = NULL;
-            p != NULL;
-            x += p->dest.x, y += p->dest.y, last = p, p = p->link)
-       {
- 
-               if (p->type == MOVETYPE) {
-                       if (start != NULL && (lastonly?p->link==NULL:TRUE) &&
-                             !(ISCLOSED(start->flag) && LASTCLOSED(last->flag))) {
-                               register struct segment *r;  /* newly created */
- 
-                               start->flag |= ISCLOSED(ON);
-                               r = PathSegment(LINETYPE, firstx - x,
-                                                         firsty - y);
-                               INSERT(last, r, p);
-                               r->flag |= LASTCLOSED(ON);
-                               /*< adjust 'last' if possible for a 0,0 close >*/
-{
- 
-#define   CLOSEFUDGE    3    /* if we are this close, let's change last segment */
- 
-       if (r->dest.x != 0 || r->dest.y != 0) {
-               if (r->dest.x <= CLOSEFUDGE && r->dest.x >= -CLOSEFUDGE
-                    && r->dest.y <= CLOSEFUDGE && r->dest.y >= -CLOSEFUDGE) {
-                       lastnonhint->dest.x += r->dest.x;
-                       lastnonhint->dest.y += r->dest.y;
-                       r->dest.x = r->dest.y = 0;
-               }
-       }
-}
-                               if (p->link != NULL) {
-                                       p->dest.x += x - firstx;
-                                       p->dest.y += y - firsty;
-                                       x = firstx;
-                                       y = firsty;
-                               }
-                       }
-                       start = p;
-                       firstx = x + p->dest.x;
-                       firsty = y + p->dest.y;
-               }
-               else if (p->type != HINTTYPE)
-                       lastnonhint = p;
-       }
-       return(p0);
-}
- 
-/*
-:h2.Transforming and Putting Handles on Paths
- 
-:h3.PathTransform() - Transform a Path
- 
-Transforming a path involves transforming all the points.  In order
-that closed paths do not become "unclosed" when their relative
-positions are slightly changed due to loss of arithmetic precision,
-all point transformations are in absolute coordinates.
- 
-(It might be better to reset the "absolute" coordinates every time a
-move segment is encountered.  This would mean that we could accumulate
-error from subpath to subpath, but we would be less likely to make
-the "big error" where our fixed point arithmetic "wraps".  However, I
-think I'll keep it this way until something happens to convince me
-otherwise.)
- 
-The transform is described as a "space", that way we can use our
-old friend the "iconvert" function, which should be very efficient.
-*/
- 
-struct segment *
-PathTransform(struct segment *p0,      /* path to transform                  */
-	      struct XYspace *S)       /* pseudo space to transform in       */
-{
-       register struct segment *p;   /* to loop through path with            */
-       register fractpel newx,newy;  /* current transformed position in path */
-       register fractpel oldx,oldy;  /* current untransformed position in path */
-       register fractpel savex,savey;  /* save path delta x,y                */
- 
-       p0 = UniquePath(p0);
- 
-       newx = newy = oldx = oldy = 0;
- 
-       for (p=p0; p != NULL; p=p->link) {
- 
-               savex = p->dest.x;   savey = p->dest.y;
- 
-               (*S->iconvert)(&p->dest, S, p->dest.x + oldx, p->dest.y + oldy);
-               p->dest.x -= newx;
-               p->dest.y -= newy;
- 
-               switch (p->type) {
- 
-                   case LINETYPE:
-                   case MOVETYPE:
-                       break;
- 
-                   case CONICTYPE:
-                   {
-                       register struct conicsegment *cp = (struct conicsegment *) p;
- 
-                       (*S->iconvert)(&cp->M, S, cp->M.x + oldx, cp->M.y + oldy);
-                       cp->M.x -= newx;
-                       cp->M.y -= newy;
-                       /*
-                       * Note roundness doesn't change... linear transform
-                       */
-                       break;
-                   }
- 
- 
-                   case BEZIERTYPE:
-                   {
-                       register struct beziersegment *bp = (struct beziersegment *) p;
- 
-                       (*S->iconvert)(&bp->B, S, bp->B.x + oldx, bp->B.y + oldy);
-                       bp->B.x -= newx;
-                       bp->B.y -= newy;
-                       (*S->iconvert)(&bp->C, S, bp->C.x + oldx, bp->C.y + oldy);
-                       bp->C.x -= newx;
-                       bp->C.y -= newy;
-                       break;
-                   }
- 
-                   case HINTTYPE:
-                   {
-                       register struct hintsegment *hp = (struct hintsegment *) p;
- 
-                       (*S->iconvert)(&hp->ref, S, hp->ref.x + oldx, hp->ref.y + oldy);
-                       hp->ref.x -= newx;
-                       hp->ref.y -= newy;
-                       (*S->iconvert)(&hp->width, S, hp->width.x, hp->width.y);
-                       /* Note: width is not relative to origin */
-                       break;
-                   }
- 
-                   case TEXTTYPE:
-                   {
-                        XformText(p,S);
-                        break;
-                   }
- 
-                   default:
-                       Abort("PathTransform:  invalid segment");
-               }
-               oldx += savex;
-               oldy += savey;
-               newx += p->dest.x;
-               newy += p->dest.y;
-       }
-       return(p0);
-}
- 
-/*
-:h3.PathDelta() - Return a Path's Ending Point
-*/
- 
-void 
-PathDelta(struct segment *p,       /* input path                             */
-	  struct fractpoint *pt)   /* pointer to x,y to set                  */
-{
-       struct fractpoint mypoint;  /* I pass this to TextDelta               */
-       register fractpel x,y;  /* working variables for path current point   */
-
-       mypoint.x = mypoint.y = 0;
- 
-       for (x=y=0; p != NULL; p=p->link) {
-               x += p->dest.x;
-               y += p->dest.y;
-               if (p->type == TEXTTYPE) {
-                       TextDelta(p, &mypoint);
-                       x += mypoint.x;
-                       y += mypoint.y;
-               }
-       }
- 
-       pt->x = x;
-       pt->y = y;
-}
- 
-/*
-:h2.Querying Locations and Paths
- 
-:h3.QueryLoc() - Return the X,Y of a Locition
-*/
- 
-void 
-QueryLoc(struct segment *P,      /* location to query, not consumed          */
-	 struct XYspace *S,      /* XY space to return coordinates in        */
-	 double *xP, double *yP) /* coordinates returned here                */
-{
-       if (!ISLOCATION(P)) {
-               ArgErr("QueryLoc: first arg not a location", P, NULL);
-               return;
-       }
-       if (S->type != SPACETYPE) {
-               ArgErr("QueryLoc: second arg not a space", S, NULL);
-               return;
-       }
-       UnConvert(S, &P->dest, xP, yP);
-}