/* Copyright 1986, 1989, 1990, 1995 by Abacus Research and
 * Development, Inc.  All rights reserved.
 */

#if !defined (OMIT_RCSID_STRINGS)
char ROMlib_rcsid_toolutil[] =
	    "$Id: toolutil.c 63 2004-12-24 18:19:43Z ctm $";
#endif

/* Forward declarations in ToolboxUtil.h (DO NOT DELETE THIS LINE) */

#include "rsys/common.h"
#include "ResourceMgr.h"
#include "QuickDraw.h"
#include "CQuickDraw.h"
#include "ToolboxUtil.h"
#include "OSUtil.h"
#include "MemoryMgr.h"

#include "rsys/cquick.h"
#include "rsys/mman.h"
#include "rsys/glue.h"
#include "SANE.h"
#include "rsys/float.h"
#include "rsys/floatconv.h"
#include "rsys/next.h" /* for ROMlib_info */
#include "rsys/string.h"
#include "rsys/mman_private.h"

P2(PUBLIC pascal trap, Fixed, FixRatio, INTEGER, n, INTEGER, d)
{
    if (!d)
        return(n < 0 ? 0x80000001 : 0x7fffffff);
    return(((LONGINT) n << 16) / d);
}

P2(PUBLIC pascal trap, Fixed, FixMul, Fixed, a, Fixed, b)
{
    int sign = 1;
    ULONGINT ms1, ms2, ls1, ls2, mm, ml, lm, ll;

    if (a < 0) {
        a = -a;
        sign = -sign;
    }
    if (b < 0) {
        b = -b;
        sign = -sign;
    }
    ms1 = (ULONGINT) a >> 16;
    ms2 = (ULONGINT) b >> 16;
    ls1 = (ULONGINT) a & 0xffff;
    ls2 = (ULONGINT) b & 0xffff;

    mm = ms1 * ms2;
    if (mm >= (1L << 15))
	return sign == 1 ? 0x7FFFFFFF : 0x80000000;
    ml = ms1 * ls2;
    lm = ls1 * ms2;
    ll = ls1 * ls2;

    mm <<= 16;
    mm += ml + lm + (ll >> 16);

    if (mm & 0x80000000)
	return sign == 1 ? 0x7FFFFFFF : 0x80000000;
    return(sign*mm);
}

P1(PUBLIC pascal trap, INTEGER, FixRound, Fixed, x)
{
    return((x>>16) + ((x & 0x8000L) != 0));
}

P1(PUBLIC pascal trap, StringHandle, NewString, StringPtr, s)
{
    HIDDEN_Handle retval;
    
    PtrToHand((Ptr) s, &retval, (LONGINT)U(s[0]) + 1);
    return((StringHandle) retval.p);
}

P2(PUBLIC pascal trap, void, SetString, StringHandle, h, StringPtr, s)
{
    PtrToXHand((Ptr) s, (Handle) h, (LONGINT)U(s[0]) + 1);
}

A2(PUBLIC, Handle, ROMlib_getrestid, ResType, rest,		/* INTERNAL */
								  INTEGER, id)
{
    Handle retval;
    
    retval = GetResource(rest, id);
    if (retval)
	LoadResource(retval);
    return retval;
}

PUBLIC StringHandle ROMlib_phoney_name_string;

PRIVATE StringHandle
get_phoney_name_resource (void)
{
  if (!ROMlib_phoney_name_string)
    {
      char *name = "";
#if defined (linux) || defined (MACOSX)
      name = getlogin ();
      if (!name)
        name = getenv ("LOGNAME");
      if (!name)
        name = "";
#endif
      int len;

      len = strlen (name);
      ROMlib_phoney_name_string = (StringHandle) NewHandleSys (len+1);
      if (ROMlib_phoney_name_string)
	{
	  HSetRBit ((Handle) ROMlib_phoney_name_string);
	  str255_from_c_string (STARH (ROMlib_phoney_name_string), name);
	}
    }
  return ROMlib_phoney_name_string;
}

P1(PUBLIC pascal trap, StringHandle, GetString, INTEGER, i)
{
  StringHandle retval;

  retval = (StringHandle) ROMlib_getrestid(TICK("STR "), i);
  if (i == -16096 && !retval)
    retval = get_phoney_name_resource ();
  return retval;
}

A3(PUBLIC, void, GetIndString, StringPtr, s, INTEGER, sid, INTEGER, index)
{
    Handle retval;
    char *p, *ep, *op;
    
    retval = GetResource(TICK("STR#"), sid);
    LoadResource(retval);
    if (ResError() != noErr || *(INTEGER *) STARH(retval) < index) {
        s[0] = 0;
/*-->*/ return;
    }
    p = (char *) STARH(retval) + 2;
    while (--index)
        p += 1 + U(*p);
    for (ep = p + 1 + U(*p), op = (char *)s; p != ep; *op++ = *p++)
        ;
}

A4(PRIVATE, int, cmpstrings, char *, p, char *, ep, char *, p1, LONGINT, len)
{
    int retval = TRUE;
    
    while (retval && p != ep && len--)
        if (*p++ != *p1++)
            retval = FALSE;
    return(retval);
}

/*
 * TODO: find out mroe about what Munger does.  If it's returning an
 * undocumented error return in D0, does that mean that the global memory
 * error location isn't changed?
 */

#warning Munger returns undocumented error return in D0 

#define RETURN(x) do { retval = (x); goto DONE; } while (FALSE)

#warning We never check for offset greater than HandleSize -- check and fix

#warning We also return -1 even though the Mac may return something different

P6(PUBLIC pascal trap, LONGINT, Munger, Handle, h, LONGINT, off, Ptr, p1,
					 LONGINT, len1, Ptr, p2, LONGINT, len2)
{
    char *p, *ep;
    LONGINT hs, tomove;
    LONGINT retval;
    
    MM_SLAM ("entry");
    p = (char *) STARH(h) + off;
    ep = (char *) STARH(h) + (hs = GetHandleSize(h));
    if (p1 && len1) {
        while (!cmpstrings(p, ep, (char *) p1, len1))
            p++;
        if (p == ep)
            RETURN (-1);
        if (ep - p < len1)
	  {
            if (p != (char *) STARH(h) + off)
	      RETURN (-1);
            else
	      len1 = ep - p;
	  }
        off = p - (char *) STARH(h);
    } else if (len1 < 0)
        len1 = hs - off;
    if (!p2 && p1)
        RETURN (off);
    tomove = ep - p - len1;
    if (len1 > len2) {
        BlockMove((Ptr) p+len1, (Ptr) p+len2, tomove);
        SetHandleSize(h, hs + len2 - len1);
        p = (char *) STARH(h) + off;
    } else if (len1 < len2) {
        SetHandleSize(h, hs + len2 - len1);
        p = (char *) STARH(h) + off;
        BlockMove((Ptr) p+len1, (Ptr) p+len2, tomove);
    }
    while (len2--)
        *p++ = *p2++;
    RETURN (p - (char *) STARH(h));
 DONE:
    MM_SLAM ("exit");
    EM_D0 &= 0xFFFF0000; /* for now ... we never have an error */
    return retval;
}
#undef RETURN

P3(PUBLIC pascal trap, void, PackBits, HIDDEN_Ptr *, sp, HIDDEN_Ptr *, dp, INTEGER, len)
{
  char *ip, *op, *ep, *erp, *markp, c;
  
  ip = (char *) MR((*sp).p);
  op = (char *) MR((*dp).p);
  ep = ip + len;
  erp = ip + len - 2;
  markp = op++;
  while (ip != ep)
    {
      while (ip != ep
	     && (ip >= erp || *ip != *(ip+1) || *ip != *(ip+2))
	     && op - markp - 2 < 127)
	*op++ = *ip++;
      if (op != markp+1)
	{
	  *markp = op - markp - 2;
        }
      else
	op--;
      if (ip != ep)
	{
	  markp = ip;
	  c = *ip++;
	  while (ip != ep && c == *ip && ip - markp - 1 < 127)
	    ip++;
	  *op++ = -(ip - markp - 1);
	  *op++ = c;
        }
      markp = op++;
    }
  (*sp).p = (Ptr) RM (ip);
  (*dp).p = (Ptr) RM (op-1);
}


#define UNPACK_BITS_BODY(out_type)					 \
do {									 \
  const int8 *ip;							 \
  out_type *op, *ep;							 \
									 \
  ip = (const int8 *) MR (sp->p);					 \
  op = (out_type *) MR (dp->p);						 \
  ep = (out_type *) ((int8 *) op + len);				 \
									 \
  while (op < ep)							 \
    {									 \
      int count = *ip++;						 \
      if (count < 0)							 \
	{								 \
	  out_type v = *(out_type *)ip;					 \
	  ip += sizeof (out_type);					 \
	  for (count = MIN (1 - count, ep - op); count > 0; count--)	 \
	    *op++ = v;							 \
	}								 \
      else								 \
	{								 \
	  unsigned bytes = MIN (count + 1, ep - op) * sizeof (out_type); \
	  memmove (op, ip, bytes);					 \
	  op += bytes / sizeof *op;					 \
	  ip += bytes;							 \
	}								 \
    }									 \
									 \
  sp->p = (Ptr) RM (ip);						 \
  dp->p = (Ptr) RM (op);						 \
} while (FALSE)


void
unpack_int16_bits (HIDDEN_Ptr *sp, HIDDEN_Ptr *dp, INTEGER len)
{
  /* This is used when unpacking 16 bpp PICT bitmaps. */
  UNPACK_BITS_BODY (int16);
}

P3(PUBLIC pascal trap, void, UnpackBits, HIDDEN_Ptr *, sp, HIDDEN_Ptr *, dp, INTEGER, len)
{
  UNPACK_BITS_BODY (int8);
}

P2(PUBLIC pascal trap, BOOLEAN, BitTst, Ptr, bp, LONGINT, bn)
{
    bp += bn / 8;
    return((*bp&(1<<((7-bn)&7)))!=0);
}

P2(PUBLIC pascal trap, void, BitSet, Ptr, bp, LONGINT, bn)
{
    bp += bn / 8;
    *bp |= 1<<((7-bn)&7);
}

P2(PUBLIC pascal trap, void, BitClr, Ptr, bp, LONGINT, bn)
{
    bp += bn / 8;
    *bp &= ~(1<<((7-bn)&7));
}

P2(PUBLIC pascal trap, LONGINT, BitAnd, LONGINT, a, LONGINT, b)
{
    return(a&b);
}

P2(PUBLIC pascal trap, LONGINT, BitOr, LONGINT, a, LONGINT, b)
{
    return(a|b);
}

P2(PUBLIC pascal trap, LONGINT, BitXor, LONGINT, a, LONGINT, b)
{
    return(a^b);
}

P1(PUBLIC pascal trap, LONGINT, BitNot, LONGINT, a)
{
    return(~a);
}

P2(PUBLIC pascal trap, LONGINT, BitShift, LONGINT, a, INTEGER, n)
{
    if (n < 0) {
	n = -n;
	return ((n %= 64) & 32) ? 0 : (ULONGINT) a >> n;
    } else
	return ((n %= 64) & 32) ? 0 : (ULONGINT) a << n;
}

P1(PUBLIC pascal trap, INTEGER, HiWord, LONGINT, a)
{
    return(a>>16);
}

P1(PUBLIC pascal trap, INTEGER, LoWord, LONGINT, a)
{
    return(a&0xFFFF);
}

P3(PUBLIC pascal trap, void, LongMul, LONGINT, a, LONGINT, b, Int64Bit *, c)
{
    int sign;
    ULONGINT ha, hb, la, lb, halb, lahb;
    int carry;
    
    if ((a > 0 && b < 0) || (a < 0 && b > 0))
        sign = -1;
    else
        sign = 1;
    if (a < 0)
        a = -a;
    if (b < 0)
        b = -b;
    ha = a >> 16;
    hb = b >> 16;
    la = a & 0xFFFF;
    lb = b & 0xFFFF;
    halb = ha * lb;
    lahb = la * hb;
    c->hiLong = CL(ha * hb);
    c->loLong = CL(la * lb);
    c->hiLong = CL(CL(c->hiLong) + (halb >> 16));
    c->hiLong = CL(CL(c->hiLong) + (lahb >> 16));
    carry = CL(c->loLong) >> 31;
    c->loLong = CL(CL(c->loLong) + (halb << 16));
    carry += (halb >> 15) & 1;
    c->loLong = CL(CL(c->loLong) + (lahb << 16));
    carry += (lahb >> 15) & 1;
    carry >>= 1;
    c->hiLong = CL(CL(c->hiLong) + (carry));
    if (sign == -1) {
        c->hiLong = ~c->hiLong;
        if (c->loLong)
            c->loLong = CL(~CL(c->loLong) + 1);
        else
            c->hiLong = CL(CL(c->hiLong) + 1);
    }
}

A2(PUBLIC, void, ScreenRes, INTEGER *, hp, INTEGER *, vp)
{
    *hp = ScrHRes;
    *vp = ScrVRes;
}

P1(PUBLIC pascal trap, PatHandle, GetPattern, INTEGER, id)
{
    return((PatHandle) ROMlib_getrestid(TICK("PAT "), id));
}

A3(PUBLIC, void, GetIndPattern, Byte *, op, INTEGER, plistid, INTEGER, index)
{
    Handle retval;
    char *p, *ep;
    
    retval = GetResource(TICK("PAT#"), plistid);
    LoadResource(retval);
    if (ResError() != noErr || *(INTEGER *) STARH(retval) < index) {
        return;
    }
    p = (char *) STARH(retval) + 2 + 8 * (index - 1);
    for (ep = p + 8; p != ep; *op++ = *p++)
        ;
}

P1(PUBLIC pascal trap, CursHandle, GetCursor, INTEGER, id)
{
    return((CursHandle) ROMlib_getrestid(TICK("CURS"), id));
}

/*
 * Note:  ShieldCursor is found in qd/qCursor.c
 */

P1(PUBLIC pascal trap, PicHandle, GetPicture, INTEGER, id)
{
  PicHandle retval;

  retval = (PicHandle) ROMlib_getrestid(TICK("PICT"), id);
  return retval;
}

P2(PUBLIC pascal trap, LONGINT, DeltaPoint, Point, a, Point, b)
{
    return (((LONGINT)a.v - b.v) << 16) | (unsigned short)(a.h - b.h);
}

A1(PRIVATE, Fixed, minvert, Fixed, f) /* wants postive number */
{
    return(((0x80000000 / (ULONGINT)f) << 1) & 0x7FFFFFFF);
}

PRIVATE Fixed sloptab[46] = {
    0x80000001, 0x00394a30, 0x001ca2d7, 0x001314bd, 0x000e4cf5,
    0x000b6e17, 0x000983ad, 0x000824f3, 0x00071d88, 0x00065051,
    0x0005abd9, 0x00052501, 0x00046462, 0x000454db, 0x000402c2,
    0x0003bb68, 0x00037cc7, 0x00034556, 0x000313e3, 0x0002e77a,
    0x0002bf5b, 0x00029ae7, 0x000279af, 0x00025b19, 0x00023efc,
    0x000224fe, 0x00020ce1, 0x0001f66e, 0x0001e177, 0x0001cdd6,
    0x0001bb68, 0x0001aa0e, 0x000199af, 0x00018a35, 0x00017689,
    0x00016dab, 0x0001605b, 0x000153b9, 0x000147aa, 0x00013c22,
    0x00013117, 0x0001267f, 0x00011c51, 0x00011287, 0x00010919,
    0x00010000
};
    
P1(PUBLIC pascal trap, Fixed, SlopeFromAngle, INTEGER, a)
{
    int sign, recip;
    auto Fixed retval;	/* cc -a problems */
    
    if (a < 0)
        a -= 360 * ((a / 360) - 1);
    if (a > 360)
        a %= 360;
    if (a > 180)
        a -= 180;
    if (a < 90) {
        sign = -1;
        a = 180 - a;
    } else
        sign = 1;
    if (a > 135) {
        recip = TRUE;
        a = 270 - a;
    } else
        recip = FALSE;
    retval = sloptab[a - 90];
    if (recip)
        retval = minvert(retval);
    if (sign == -1)
        retval = -retval;
    return(retval);
}

P1(PUBLIC pascal trap, INTEGER, AngleFromSlope, Fixed, s)
{
    int neg, inv, retval;
    ULONGINT *ulp;
    
    if (s < 0) {
        s = -s;
        neg = TRUE;
    } else
        neg = FALSE;
    if (s < 0x10000) {
        if (s)
            s = minvert(s);
        else
            s = 0x7fffffff;
        inv = TRUE;
    } else
        inv = FALSE;
    for (ulp = (ULONGINT *)sloptab+1; *ulp > (ULONGINT) s ; ulp++)
        ;
    if (*(ulp-1) - s < s - *ulp)
        ulp--;
#if !defined(__GNUC__) || defined(FIXEDGCC)
    retval = ulp - (ULONGINT *)sloptab + 90;
#else
    {
    ULONGINT * volatile temp;

    temp = (ULONGINT *) sloptab;
    retval = ulp - temp + 90;
    }
#endif
    if (inv)
        retval = 270 - retval;
    if (neg)
        retval = 180 - retval;
    return(retval ? retval : 180);
}

P2(PUBLIC pascal trap, Fract, FracMul, Fract, x, Fract, y)	/* IMIV-64 */
{
    Extended z;
    
    if ((uint32) x == 0x80000000 && (uint32) y == 0x80000000)
/*-->*/	return 0;	/* this is a deliberate "bug" according to IMIV-63
				    but nevertheless the mac+ returns 0 here */
    z = Frac2X(x) * Frac2X(y);
    return X2Frac(&z);
}

P2(PUBLIC pascal trap, Fixed, FixDiv, Fixed, x, Fixed, y)	/* IMIV-64 */
{
    Extended z;

    z = Fix2X(x) / Fix2X(y);
    return X2Fix(&z);
}

P2(PUBLIC pascal trap, Fract, FracDiv, Fract, x, Fract, y)	/* IMIV-64 */
{
    Extended z;

    z = Frac2X(x) / Frac2X(y);
    return X2Frac(&z);
}

#define MAXLONG2FIX	0x7FFF
#define MINLONG2FIX	- ((LONGINT) MAXLONG2FIX + 1)
#define POSOVERFLOW 0x7FFFFFFF
#define NEGOVERFLOW 0x80000000

P1(PUBLIC pascal trap, Fixed, Long2Fix, LONGINT, x)	/* IMIV-65 */
{
    if (x > MAXLONG2FIX)
/*-->*/	return POSOVERFLOW;
    else if (x < MINLONG2FIX)
/*-->*/	return NEGOVERFLOW;
    else
/*-->*/	return x << 16;
}

P1(PUBLIC pascal trap, LONGINT, Fix2Long, Fixed, x)	/* IMIV-65 */
{
    return x >= 0 ?
	(x + (1L << 15)) >> 16
    :
	0xFFFF0000 | ((x + (1L << 15)) >> 16);
}

#define MAXFIX2FRAC 0x1FFFF
#define MINFIX2FRAC - ((LONGINT) MAXFIX2FRAC + 1)

P1(PUBLIC pascal trap, Fract, Fix2Frac, Fixed, x)	/* IMIV-65 */
{
    if (x > MAXFIX2FRAC)
/*-->*/	return POSOVERFLOW;
    else if (x < MINFIX2FRAC)
/*-->*/	return NEGOVERFLOW;
    else
/*-->*/	return x << 14;
}

P1(PUBLIC pascal trap, Fixed, Frac2Fix, Fract, x)	/* IMIV-65 */
{
    return x >= 0 ?
	(x + (1 << 13)) >> 14
    :
	0xFFFC0000 | ((x + (1 << 13)) >> 14);
}

A1(PUBLIC, Extended, Fix2X, Fixed, x)	/* IMIV-65 */
{
    return (Extended) x / (1L << 16);
}

#define MAXX2FIX MAXLONG2FIX
#define MINX2FIX MINLONG2FIX

A1(PUBLIC, Fixed, X2Fix, Extended *, xp)	/* IMIV-65 */
{
    Extended x;

    if ((x = *xp) >= 0) {
	if (x > MAXX2FIX)
/*-->*/	    return POSOVERFLOW;
	else
/*-->*/	    return (Fixed) (x * (1L << 16) + .5);
    } else {
	if (x < MINX2FIX)
/*-->*/	    return NEGOVERFLOW;
	else
/*-->*/	    return (Fixed) (x * (1L << 16) - .5);
    }
}

A1(PUBLIC, Extended, Frac2X, Fract, x)	/* IMIV-65 */
{
    return (Extended) x / (1L << 30);
}

#define BEYONDMAXX2FRAC 2
#define MINX2FRAC -2

A1(PUBLIC, Fract, X2Frac, Extended *, xp)	/* IMIV-65 */
{
    Extended x;

    if ((x = *xp) >= 0) {
	if (x >= BEYONDMAXX2FRAC)
/*-->*/	    return POSOVERFLOW;
	else
/*-->*/	    return (Fract) (x * (1L << 30) + .5);
    } else {
	if (x < MINX2FRAC)
/*-->*/	    return NEGOVERFLOW;
	else
/*-->*/	    return (Fract) (x * (1L << 30) - .5);
    }
}

#if defined (BINCOMPAT)

A3(PUBLIC trap, void, R_Fix2X, void *, dummyretpc, Fixed, x,	/* INTERNAL */
							     extended80 *, ret)
{
#if 0
    extended96 temp;

    asm("fmovel %1, fp0\n\t"
	"fdivl #0x10000, fp0\n\t"
	"fmovex fp0, %0" : "=m" (temp) : "m" (x) : "fp0");
    X96TO80(temp, *ret);
#else
    register ieee_t n = x;
    n /= 0x10000;
    ieee_to_x80 (n, ret);
#endif
}

A3(PUBLIC trap, void, R_Frac2X, void *, dummyretpc, Fract, x,	/* INTERNAL */
							      extended80 *, ret)
{
#if 0
    extended96 temp;

    asm("fmovel %1, fp0\n\t"
	"fdivl #0x40000000, fp0\n\t"
	"fmovex fp0, %0" : "=m" (temp) : "m" (x) : "fp0");
    X96TO80(temp, *ret);
#else
    register ieee_t n = x;
    n /= 0x40000000;
    ieee_to_x80 (n, ret);
#endif
}

P1(PUBLIC pascal trap, Fixed, R_X2Fix, extended80 *, x)
{
#if 0
    extended96 temp;
    Fixed retval;

    X80TO96(*x, temp);
    asm("fmovex %1, fp0\n\t"
	"fmull #0x10000, fp0\n\t"
	"fmovel fp0, %0" : "=g" (retval) : "m" (temp) : "fp0");
    return retval;
#else
    register ieee_t n = x80_to_ieee (x);
    n *= 0x10000;
    return (Fixed) n;
#endif
}

P1(PUBLIC pascal trap, Fract, R_X2Frac, extended80 *, x)
{
#if 0
    extended96 temp;
    Fract retval;

    X80TO96(*x, temp);
    asm("fmovex %1, fp0\n\t"
	"fmull #0x40000000, fp0\n\t"
	"fmovel fp0, %0" : "=g" (retval) : "m" (temp) : "fp0");
    return retval;
#else
    register ieee_t n = x80_to_ieee (x);
    n *= 0x40000000;
    return (Fract) n;
#endif
}

#endif /* BINCOMPAT */