Macintosh-Tools
/
executor
mirror of https://github.com/ctm/executor.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
executor/src/script.c

971 lines
21 KiB
C
Raw Permalink Blame History

/* 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);
}
Reference in New Issue View Git Blame Copy Permalink