All the Executor source as-is from the subversion tree it was last worked on.

2026-03-16 00:16:27 +00:00 · 2008-10-05 21:48:37 -06:00
commit 3183eb6ea0
2517 changed files with 441747 additions and 0 deletions
--- a/src/script.c
+++ b/src/script.c
@@ -0,0 +1,970 @@
+/* Copyright 1991 by Abacus Research and
+ * Development, Inc.  All rights reserved.
+ */
+
+/* Forward declarations in ScriptMgr.h (DO NOT DELETE THIS LINE) */
+
+#if !defined (OMIT_RCSID_STRINGS)
+char ROMlib_rcsid_script[] =
+	    "$Id: script.c 88 2005-05-25 03:59:37Z ctm $";
+#endif
+
+#include "rsys/common.h"
+#include "QuickDraw.h"
+#include "IntlUtil.h"
+#include "ScriptMgr.h"
+#include "MemoryMgr.h"
+#include "ToolboxUtil.h"
+#include "OSUtil.h"
+
+#include "rsys/hook.h"
+#include "rsys/quick.h"
+#include "rsys/cquick.h"
+#include "rsys/osutil.h"
+#include "rsys/osevent.h"
+#include "rsys/print.h"
+#include "rsys/floatconv.h"
+#include "rsys/string.h"
+#include "rsys/mman.h"
+
+#include <ctype.h>
+
+/*
+ * NOTE: these are stubs to help me make FileMaker Pro go.
+ */
+
+P1(PUBLIC pascal trap, LONGINT, GetEnvirons, INTEGER, verb)
+{
+  LONGINT retval;
+
+  switch (verb)
+    {
+    case smEnabled:
+      /* powerpoint seems to require that at least one script is
+         present */
+      warning_unimplemented ("reporting script manager is enabled");
+      /* we currently only have a single script */
+      retval = 1;
+      break;
+
+    case smKCHRCache:
+      retval = (LONGINT) US_TO_SYN68K (ROMlib_kchr_ptr ());
+      break;
+
+    default:
+      warning_unexpected ("unhandled selector `%d'", verb);
+      retval = 0;
+    }
+  return retval;
+}
+
+P2(PUBLIC pascal trap, OSErr, SetEnvirons, INTEGER, verb, LONGINT, param)
+{
+#if defined (BINCOMPAT)
+    ROMlib_hook(script_notsupported);
+#endif /* BINCOMPAT */
+    return smVerbNotFound;
+}
+
+P2(PUBLIC pascal trap, LONGINT, GetScript, INTEGER, script, INTEGER, verb)
+{
+  warning_unimplemented (NULL_STRING);
+  return 0;
+}
+
+P3(PUBLIC pascal trap, OSErr, SetScript, INTEGER, script, INTEGER, verb,
+							        LONGINT, param)
+{
+  warning_unimplemented (NULL_STRING);
+  return smVerbNotFound;
+}
+
+P1(PUBLIC pascal trap, INTEGER, Font2Script, INTEGER, fontnum)
+{
+  warning_unimplemented (NULL_STRING);
+  return 0;
+}
+
+/*
+ * butchered Transliterate provided for Excel 3.0
+ */
+
+#define LOWERTOUPPEROFFSET 'A' - 'a'
+A1(PRIVATE, char, upper, char, ch)
+{
+    if (ch >= 'a' && ch <= 'z')
+#if 1
+        return ch + LOWERTOUPPEROFFSET;
+#else /* 0 */
+	return ch & ~0x20;
+#endif /* 0 */
+    else
+	return ch;
+}
+
+#define UPPERTOLOWEROFFSET ('a' - 'A')
+A1(PRIVATE, char, lower, char, ch)
+{
+    if (ch >= 'A' && ch <= 'Z')
+#if 1
+        return ch + UPPERTOLOWEROFFSET;
+#else /* 0 */
+	return ch | 0x20;
+#endif /* 0 */
+    else
+	return ch;
+}
+
+P4(PUBLIC pascal trap, INTEGER, Transliterate, Handle, srch, Handle, dsth,
+					     INTEGER, target, LONGINT, srcmask)
+{
+    char *sp, *dp, *ep;
+
+    sp = (char *) STARH(srch);
+    dp = (char *) STARH(dsth);
+    ep = sp + GetHandleSize(srch);
+    if (target & smTransLower) {
+	if (target & smTransUpper)
+/*-->*/     return -1;
+        while (sp < ep)
+	    *dp++ = lower(*sp++);
+    } else if (target & smTransUpper) {
+        while (sp < ep)
+	    *dp++ = upper(*sp++);
+    } else {
+        while (sp < ep)
+	    *dp++ = *sp++;
+    }
+    return 0;
+}
+
+/*
+ * NOTE: These are all recent additions, made just before 1.2.2 was frozen.
+ *	 They haven't been tested much, if at all.  In addition, much of
+ *	 the code below just tries to return something "reasonable", although
+ *	 not necessarily correct!
+ */
+
+P0(PUBLIC pascal trap, INTEGER, FontScript)
+{
+  warning_unimplemented (NULL_STRING);
+  return smRoman;
+}
+
+P0(PUBLIC pascal trap, INTEGER, IntlScript)
+{
+  warning_unimplemented (NULL_STRING);
+  return smRoman;
+}
+
+P1(PUBLIC pascal trap, void, KeyScript, INTEGER, scriptcode)
+{
+  warning_unimplemented (NULL_STRING);
+}
+
+P2(PUBLIC pascal trap, INTEGER, CharType, Ptr, textbufp, INTEGER, offset)
+{
+    INTEGER retval;
+    unsigned char c;
+#if defined (BINCOMPAT)
+    ROMlib_hook(script_notsupported);
+#endif /* BINCOMPAT */
+
+    retval = 0;
+    c = textbufp[offset];
+    if (!isalpha(c)) {
+	retval |= smCharPunct;
+	if (isspace(c))
+	    retval |= smPunctBlank;
+	else if (isdigit(c))
+	    retval |= smPunctNumber;
+	else if (ispunct(c))
+	    retval |= smPunctSymbol;
+    } else {
+	retval |= smCharAscii;
+	if (islower(c))
+	    retval |= smCharLower;
+	else
+	    retval |= smCharUpper;
+    }
+    retval |= smCharLeft;
+    retval |= smChar1byte;
+
+    return retval;
+}
+
+P4 (PUBLIC pascal trap, void, MeasureJust, Ptr, textbufp, int16, length,
+    int16, slop, Ptr, charlocs)
+{
+  if (slop)
+    warning_unimplemented ("slop = %d", slop);
+  MeasureText (length, textbufp, charlocs);
+}
+
+P7 (PUBLIC pascal trap, void, NMeasureJust, Ptr, text, int32, length,
+    Fixed, slop, Ptr, charLocs, JustStyleCode, run_pos,
+    Point, numer, Point, denom)
+{
+  Point numerx, denomx;
+  
+  warning_unimplemented ("slop = %d, run_pos = %d", slop, run_pos);
+  
+  numerx.v = CW (numer.v);
+  numerx.h = CW (numer.h);
+  denomx.v = CW (denomx.v);
+  denomx.h = CW (denomx.h);
+  
+  xStdTxMeas (length, (uint8 *) text, &numerx, &denomx,
+	      NULL, (int16 *) charLocs);
+}
+
+P1 (PUBLIC pascal trap, Boolean, ParseTable,
+    CharByteTable, table)
+{
+  memset (table, 0, sizeof (CharByteTable));
+  return TRUE;
+}
+
+P2 (PUBLIC pascal trap, Boolean, FillParseTable,
+    CharByteTable, table, ScriptCode, script)
+{
+  /* ### should we even look at `script' */
+  memset (table, 0, sizeof (CharByteTable));
+  return TRUE;
+}
+
+P3 (PUBLIC pascal trap, INTEGER, CharacterByteType, Ptr, textBuf,
+    INTEGER, textOffset, ScriptCode, script)
+{
+  warning_unimplemented (NULL_STRING);
+  /* Single-byte character */
+  return 0;
+}
+
+P3 (PUBLIC pascal trap, INTEGER, CharacterType, Ptr, textbufp,
+    INTEGER, offset, ScriptCode, script)
+{
+  warning_unimplemented (NULL_STRING);
+  return CharType (textbufp, offset);
+}
+
+P5 (PUBLIC pascal trap, INTEGER, TransliterateText, Handle, srch, Handle, dsth,
+    INTEGER, target, LONGINT, srcmask, ScriptCode, script)
+{
+  warning_unimplemented (NULL_STRING);
+  return Transliterate (srch, dsth, target, srcmask);
+}
+
+P5(PUBLIC pascal trap, INTEGER, Pixel2Char, Ptr, textbufp, INTEGER, len,
+			INTEGER, slop, INTEGER, pixwidth, BOOLEAN *, leftsidep)
+{
+  Point num, den;
+  INTEGER retval;
+
+  warning_unimplemented ("poorly implemented");
+  
+  num.h = 1;
+  num.v = 1;
+  den.h = 1;
+  den.v = 1;
+  retval = C_PixelToChar (textbufp, len, slop << 16, pixwidth << 16, leftsidep,
+			  0, 0, num, den);
+  return retval;
+}
+
+P5(PUBLIC pascal trap, INTEGER, Char2Pixel, Ptr, textbufp, INTEGER, len,
+			       INTEGER, slop, INTEGER, offset, SignedByte, dir)
+{
+    INTEGER retval;
+    Point num, den;
+
+    warning_unimplemented ("poorly implemented");
+
+    num.h = 1;
+    num.v = 1;
+    den.h = 1;
+    den.v = 1;
+    
+    retval = C_CharToPixel (textbufp, len, slop << 16, offset, dir, 0,
+			    num, den);
+    return retval;
+
+}
+
+P6(PUBLIC pascal trap, void, FindWord, Ptr, textbufp, INTEGER, length,
+	   INTEGER, offset, BOOLEAN, leftside, Ptr, breaks, INTEGER *, offsets)
+{
+  INTEGER start, stop;
+  boolean_t chasing_spaces_p;
+#if defined (BINCOMPAT)
+    ROMlib_hook(script_notsupported);
+#endif /* BINCOMPAT */
+
+    if (!leftside)
+      --offset;
+    if (offset < 0)
+      offset = 0;
+
+    chasing_spaces_p = isspace (textbufp[offset]);
+    for (start = offset;
+	 start > 0 && !isspace (textbufp[start-1]) == !chasing_spaces_p;
+	 --start)
+      ;
+
+    for (stop = offset;
+	 stop < length && !isspace (textbufp[stop]) == !chasing_spaces_p;
+	 ++stop)
+      ;
+
+    offsets[0] = CW(start);
+    offsets[1] = CW(stop);
+    offsets[2] = 0; /* Testing on Brute shows we should zero this memory */
+    offsets[3] = 0;
+    offsets[4] = 0;
+    offsets[5] = 0;
+    warning_unimplemented ("poorly implemented");
+}
+
+P4(PUBLIC pascal trap, void, HiliteText, Ptr, textbufp, INTEGER, firstoffset,
+				     INTEGER, secondoffset, INTEGER *, offsets)
+{
+#if defined (BINCOMPAT)
+    ROMlib_hook(script_notsupported);
+#endif /* BINCOMPAT */
+    offsets[0] = CW(firstoffset);
+    offsets[1] = CW(secondoffset);
+    offsets[2] = 0;
+    offsets[3] = 0;
+    offsets[4] = 0;
+    offsets[5] = 0;
+}
+
+PRIVATE int16
+count_spaces (Ptr textbufp, int16 length)
+{
+  int16 retval;
+
+  retval = 0;
+  while (length-- > 0)
+    if (*textbufp++ == ' ')
+      ++retval;
+
+  return retval;
+}
+
+P3 (PUBLIC pascal trap, void, DrawJust, Ptr, textbufp,
+    int16, length, int16, slop)
+{
+  Fixed save_sp_extra_x;
+  int n_spaces;
+
+  save_sp_extra_x = PORT_SP_EXTRA_X (thePort);
+  n_spaces = count_spaces (textbufp, length);
+  if (n_spaces)
+    {
+      Fixed extra;
+
+      extra = CL (save_sp_extra_x) + FixRatio (slop, n_spaces);
+      PORT_SP_EXTRA_X (thePort) = CL (extra);
+    }
+  DrawText (textbufp, 0, length);
+  PORT_SP_EXTRA_X (thePort) = save_sp_extra_x;
+}
+
+PRIVATE int
+snag_date_part (Ptr text, int *offsetp, LONGINT len)
+{
+  int retval;
+
+  retval = 0;
+
+  while (*offsetp < len && text[*offsetp] != '/')
+    {
+      retval = retval * 10 + text[*offsetp] - '0';
+      ++*offsetp;
+    }
+
+  if (*offsetp < len && text[*offsetp] == '/')
+    ++*offsetp;
+
+  return retval;
+}
+
+enum { longDateFound = 1, dateTimeNotFound = 0x8400 };
+
+P5(PUBLIC pascal trap, String2DateStatus, String2Time, Ptr, textp,
+       LONGINT, len, Ptr, cachep, LONGINT *, lenusedp, HIDDEN_Ptr *, datetimep)
+{
+  warning_unimplemented (NULL_STRING);
+  *lenusedp = CLC (0);
+  return (String2DateStatus) dateTimeNotFound;
+}
+
+PRIVATE void
+this_date_rec(DateTimeRec *p)
+{
+  LONGINT now;
+
+  GetDateTime (&now);
+  now = CL (now);
+  Secs2Date (now, p);
+}
+
+PRIVATE int
+this_century (void)
+{
+  DateTimeRec d;
+  int retval;
+
+  this_date_rec (&d);
+  retval = CW (d.year) / 100 * 100;
+  return retval;
+}
+
+PRIVATE int
+this_millennium (void)
+{
+  int retval;
+
+  retval = this_century () / 1000 * 1000;
+  return retval;
+}
+
+P5 (PUBLIC pascal trap, String2DateStatus, String2Date,
+    Ptr, text, int32, length, DateCachePtr, cache,
+    int32 *, length_used_ret, LongDatePtr, date_time)
+{
+  String2DateStatus retval;
+
+  if (length <= 10 && (text[1] == '/' || text[2] == '/'))
+    {
+      int offset, month, day, year;
+      int offset_save, year_length;
+      
+      offset = 0;
+      month = snag_date_part (text, &offset, length);
+      day = snag_date_part (text, &offset, length);
+
+      offset_save = offset;
+      year = snag_date_part (text, &offset, length);
+      year_length = offset - offset_save;
+
+      if (year_length == 3)
+	year += this_millennium ();
+      else if (year_length < 3)
+	year += this_century ();
+
+      *length_used_ret = CL (offset);
+
+      /* not clear what we should do with other fields, some should probably
+	 be zeroed */
+
+      date_time->year = CW (year);
+      date_time->month = CW (month);
+      date_time->day = CW (day);
+      retval = longDateFound;
+    }
+  else
+    {
+      *length_used_ret = CLC (0);
+      warning_unexpected (NULL_STRING);
+      retval = (String2DateStatus) dateTimeNotFound;
+    }
+  warning_unimplemented (NULL_STRING);
+  return retval;
+}
+
+P7 (PUBLIC pascal trap, StyledLineBreakCode, StyledLineBreak,
+    Ptr, textp, int32, length,
+    int32, text_start, int32, text_end, int32, flags,
+    Fixed *, text_width_fp, int32 *, text_offset)
+{
+  char *text = (char *) textp;
+  /* the index into `text' that began the last word, which is where we
+     want to break if the current word extends past the end of the
+     current line */
+  int last_word_break = -1;
+  char current_char;
+  int current_index;
+  int text_width;
+  int width = 0;
+  
+  /* ### are we losing information here? */
+  text_width = Fix2Long (CL (*text_width_fp));
+  
+  for (current_index = text_start, current_char = text[current_index];
+       current_index < text_end;
+       current_index ++, current_char = text[current_index])
+    {
+      /* ### do we do this? */
+      if (current_char == '\r')
+	{
+	  *text_offset = CL (current_index + 1);
+	  return smBreakWord;
+	}
+	  
+      if (current_index > text_start
+	  && current_char != ' '
+	  && text[current_index - 1] == ' ')
+	{
+	  last_word_break = current_index - 1;
+	}
+      
+      width += CharWidth (current_char);
+      
+      if (width > text_width)
+	{
+	  /* we got our char */
+	  if (last_word_break == -1)
+	    {
+	      /* d'oh, we are on the first word */
+	      if (*text_offset)
+		{
+		  /* beginning of the line, break here */
+		  *text_offset = CL (current_index - 1);
+		  return smBreakChar;
+		}
+	      *text_offset = CL (current_index - 1);
+	      return smBreakWord;
+	    }
+	  else
+	    {
+	      *text_offset = CL (last_word_break);
+	      return smBreakWord;
+	    }
+	}
+    }
+  /* if we got here, that means the run did not extend past the end of
+     the current line */
+  *text_width_fp = CL (Long2Fix (text_width - width));
+  *text_offset = CL (current_index);
+  return smBreakOverflow;
+}
+
+P3 (PUBLIC pascal trap, INTEGER, ReplaceText,
+    Handle, base_text, Handle, subst_text,
+    Str15, key)
+{
+  INTEGER retval;
+
+  warning_unimplemented ("not tested much");
+
+  retval = 0;
+  LOCK_HANDLE_EXCURSION_1
+    (subst_text, 
+     {
+       Ptr p;
+       INTEGER len;
+       LONGINT offset;
+       LONGINT l;
+
+       p = (Ptr) STARH (subst_text);
+       len = GetHandleSize (subst_text);
+       offset = 0;
+       while (retval >= 0 &&
+	      (l = Munger (base_text,
+			   offset, (Ptr) key+1, key[0], NULL, 1)) >= 0)
+	 {
+	   offset = Munger (base_text,
+			    l, (Ptr) key+1, key[0], p, len);
+	   if (offset < 0)
+	     retval = offset;
+	   else
+	     ++retval;
+	 }
+     });
+
+  return retval;
+}
+
+/* FormatStr2X is now StringToExtended */
+P4 (PUBLIC pascal trap, FormatStatus, StringToExtended,  /* TTS TODO */
+   Str255, string, 
+   NumFormatStringRec *, formatp,
+   NumberParts *, partsp,
+   Extended80 *, xp)
+{
+  FormatStatus retval;
+  double d;
+  char buf[256];
+
+  memcpy (buf, string+1, string[0]);
+  buf[string[0]] = 0;
+  sscanf (buf, "%lg", &d);
+  ieee_to_x80 ((ieee_t) d, xp);
+  warning_unimplemented (NULL_STRING);
+  retval = noErr;
+  return retval;
+}
+
+P4 (PUBLIC pascal trap, FormatStatus, ExtendedToString,  /* TTS TODO */
+    Extended80 *, xp,
+    NumFormatStringRec *, formatp,
+    NumberParts *, partsp,
+    Str255, string)
+{
+  ieee_t val;
+  FormatStatus retval;
+  char buf[256];
+
+  val = x80_to_ieee (xp);
+#if !defined (CYGWIN32)
+  sprintf (buf, "%Lg", val);
+#else
+#warning may lose bits of precision here
+  sprintf (buf, "%g", (double) val);
+#endif
+  str255_from_c_string (string ,buf);
+  warning_unimplemented (NULL_STRING);
+  retval = noErr;
+  return retval;
+}
+
+P3 (PUBLIC pascal trap, FormatStatus, StringToFormatRec, /* TTS TODO */
+    Str255, in_string,
+    NumberParts *, partsp,
+    NumFormatStringRec *, out_string)
+{
+  FormatStatus retval;
+
+  warning_unimplemented (NULL_STRING);
+  retval = 0;
+  return retval;
+}
+
+P5 (PUBLIC pascal trap, ToggleResults, ToggleDate,  /* TTS TODO */
+    LongDateTime *, lsecsp,
+    LongDateField, field,
+    DateDelta, delta,
+    INTEGER, ch,
+    TogglePB *, paramsp)
+{
+  ToggleResults retval;
+
+  warning_unimplemented (NULL_STRING);
+  retval = 0;
+  return retval;
+}
+
+P3 (PUBLIC pascal trap, INTEGER, TruncString,  /* TTS TODO */
+    INTEGER, width, Str255, string,
+    TruncCode, code)
+{
+  warning_unimplemented (NULL_STRING);
+  
+  /* ### claim we didn't have to truncate the string */
+  return Truncated;
+}
+
+P2 (PUBLIC pascal trap, LONGINT, VisibleLength, Ptr, textp, LONGINT, len)
+{
+  warning_unimplemented ("poorly implemented -- what about other white space");
+
+  warning_trace_info ("%.*s", (int) len, textp);
+  while (len > 0 && textp[len-1] == ' ')
+    --len;
+  return len;
+}
+
+P2 (PUBLIC pascal trap, void, LongDate2Secs, LongDateRec *, ldatep,
+    ULONGINT *, secs_outp)
+{
+  long long secs;
+  LONGINT high, low;
+  INTEGER hour;
+
+  hour = CW (ldatep->hour);
+  if (ldatep->pm && hour < 12)
+    hour += 12;
+    
+  secs = ROMlib_long_long_secs (CW (ldatep->year), CW (ldatep->month),
+				CW (ldatep->day), hour,
+				CW (ldatep->minute), CW (ldatep->second));
+  high = secs >> 32;
+  low = secs;
+  secs_outp[0] = CL (high);
+  secs_outp[1] = CL (low);
+}
+
+P2 (PUBLIC pascal trap, void, LongSecs2Date, ULONGINT *, secs_inp,
+    LongDateRec *, ldatep)
+
+{
+  long long secs;
+  INTEGER pm;
+  
+  secs = ((long long) CL (secs_inp[0]) << 32) | CL (secs_inp[1]);
+  date_to_swapped_fields (secs, &ldatep->year, &ldatep->month, &ldatep->day,
+			  &ldatep->hour, &ldatep->minute, &ldatep->second,
+			  &ldatep->dayOfWeek, &ldatep->dayOfYear,
+			  &ldatep->weekOfYear);
+
+  pm = (CW (ldatep->hour) > 12) ? 1 : 0;
+  ldatep->pm = CW (pm);
+}
+
+/*
+ * NOTE: At least some of these need to be implemented if we want
+ *	 Resolve to work
+ */
+
+
+#if 0
+ParseTable
+
+PortionText
+
+FindScriptRun
+
+IsSpecialFont
+
+RawPrinterValues
+
+NPixel2Char
+
+NChar2Pixel
+
+NDrawJust
+
+NPortionText
+
+ReplaceText
+
+TruncText
+
+TrunString
+
+NFindWord
+
+ValidDate
+
+FormatStr2X
+
+FormatX2Str
+
+Format2Str
+
+Str2Format
+
+ToggleDate
+
+LongSecs2Date
+
+LongDate2Secs
+
+IntlTokenize
+
+GetFormatOrder
+#endif
+
+A0(PUBLIC, INTEGER, GetAppFont)
+{
+    return CW (ApFontID);
+}
+
+#if 0
+/*
+ * NOTE: the following is stuff I typed in before noticing that these are
+ *       provided by glue.  Hence they will be necessary if we ever support
+ *	 ROMlib again but are not needed for Executor.
+ */
+
+A0(PUBLIC, INTEGER, GetDefFontSize)
+{
+  return 0;
+}
+
+A0(PUBLIC, INTEGER, GetSysFont)
+{
+    return 0;
+}
+
+A0(PUBLIC, INTEGER, GetMBarHeight)
+{
+    return 0;
+}
+
+A0(PUBLIC, INTEGER, GetSysJust)
+{
+    return 0;
+}
+
+A1(PUBLIC, void, SetSysJust, INTEGER, just)
+{
+}
+#endif
+
+P1 (PUBLIC pascal trap, OSErr, InitDateCache, DateCachePtr, cache)  /* TTS TODO */
+{
+  warning_unimplemented (NULL_STRING);
+  return noErr;
+}
+
+P2(PUBLIC pascal trap, INTEGER, CharByte, Ptr, textBuf, INTEGER, textOffset)
+{
+  warning_unimplemented (NULL_STRING);
+  /* Single-byte character */
+  return 0;
+}
+
+P5(PUBLIC pascal trap, Fixed, PortionLine,
+   Ptr, textPtr,
+   LONGINT, textLen,
+   JustStyleCode, styleRunPosition,
+   Point, numer,
+   Point, denom)
+{
+  Fixed retval;
+
+  warning_unimplemented (NULL_STRING);
+  retval = 0x10000;
+  return retval;
+}
+
+P6(PUBLIC pascal trap, void, DrawJustified,
+   Ptr, textPtr,
+   LONGINT, textLength,
+   Fixed, slop,
+   JustStyleCode, styleRunPosition,
+   Point, numer,
+   Point, denom)
+{
+  Point swapped_numer;
+  Point swapped_denom;
+  
+  warning_unimplemented ("poorly implemented");
+  swapped_numer.h = CW (numer.h);
+  swapped_numer.v = CW (numer.v);
+  swapped_denom.h = CW (denom.h);
+  swapped_denom.v = CW (denom.v);
+  text_helper (textLength, textPtr, &swapped_numer, &swapped_denom, 0, 0,
+	       text_helper_draw);
+}
+
+P3(PUBLIC pascal trap, ScriptRunStatus, FindScriptRun,
+   Ptr, textPtr,
+   LONGINT, textLen,
+   LONGINT *, lenUsedp)
+{
+  warning_unimplemented (NULL_STRING);
+  *lenUsedp = CLC (1);
+  return 0;
+}
+
+P9(PUBLIC pascal trap, INTEGER, PixelToChar,
+   Ptr, textBuf,
+   LONGINT, textLen,
+   Fixed, slop,
+   Fixed, pixelWidth,
+   BOOLEAN *, leadingEdgep,
+   Fixed *, widthRemainingp,
+   JustStyleCode, styleRunPosition,
+   Point, numer,
+   Point, denom)
+{
+  INTEGER *locs;
+  INTEGER retval, i;
+  Point swapped_numer;
+  Point swapped_denom;
+  INTEGER int_pix_width;
+
+  warning_unimplemented ("poorly implemented");
+
+  locs = alloca( sizeof(INTEGER) * (textLen + 1));
+
+  swapped_numer.h = CW (numer.h);
+  swapped_numer.v = CW (numer.v);
+  swapped_denom.h = CW (denom.h);
+  swapped_denom.v = CW (denom.v);
+
+  int_pix_width = pixelWidth >> 16;
+
+  text_helper (textLen, textBuf, &swapped_numer, &swapped_denom, 0, locs,
+	       text_helper_measure);
+
+  /* NOTE: we could distribute slop here, or we could adjust text_helper
+     to account for slop (probably better in the long run).  Right now,
+     we do neither.  Ick. */
+
+  if (int_pix_width >= CW(locs[textLen]))
+    {
+      retval = textLen;
+      *leadingEdgep = FALSE;
+      *widthRemainingp = pixelWidth - (CW(locs[textLen]) << 16);
+    }
+  else
+    {
+      *widthRemainingp = CLC (-1);
+      for (i = 0; int_pix_width > CW(locs[i]); ++i)
+	;
+      if ((i > 0) &&
+	  ((int_pix_width - CW(locs[i-1])) > (CW(locs[i]) - int_pix_width)))
+	{
+	  retval = i - 1;
+	  *leadingEdgep = FALSE;
+	}
+      else
+	{
+	  retval = i;
+	  *leadingEdgep = TRUE;
+	}
+    }
+  return retval;
+}
+
+P8(PUBLIC pascal trap, INTEGER, CharToPixel,
+   Ptr, textBuf,
+   LONGINT, textLen,
+   Fixed, slop,
+   LONGINT, offset,
+   INTEGER, direction,
+   JustStyleCode, styleRunPosition,
+   Point, numer,
+   Point, denom)
+{
+  INTEGER retval;
+  Point swapped_numer, swapped_denom;
+
+  warning_unimplemented ("poorly implemented");
+
+  swapped_numer.h = CW (numer.h);
+  swapped_numer.v = CW (numer.v);
+  swapped_denom.h = CW (denom.h);
+  swapped_denom.v = CW (denom.v);
+  retval = text_helper (offset, textBuf, &swapped_numer, &swapped_denom,
+			0, 0, text_helper_measure);
+  retval += (slop / textLen) >> 16;
+  return retval;
+}
+
+P3(PUBLIC pascal trap, void, LowercaseText,
+   Ptr, textp,
+   INTEGER, len,
+   ScriptCode, script)
+{
+  warning_unimplemented ("poorly implemented");
+}
+
+P3(PUBLIC pascal trap, void, UppercaseText,
+   Ptr, textp,
+   INTEGER, len,
+   ScriptCode, script)
+{
+  ROMlib_UprString ((StringPtr) textp, FALSE, len);
+}
+
+P3(PUBLIC pascal trap, void, StripDiacritics,
+   Ptr, textp,
+   INTEGER, len,
+   ScriptCode, script)
+{
+  warning_unimplemented ("poorly implemented");
+}
+
+P3(PUBLIC pascal trap, void, UppercaseStripDiacritics,
+   Ptr, textp,
+   INTEGER, len,
+   ScriptCode, script)
+{
+  ROMlib_UprString ((StringPtr) textp, TRUE, len);
+}