mpw/toolbox/packages.cpp

/*
 * Copyright (c) 2015, Kelvin W Sherlock
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <cerrno>
#include <cctype>
#include <ctime>
#include <algorithm>
#include <chrono>
#include <deque>
#include <string>

#include <stdlib.h>

#include <cpu/defs.h>
#include <cpu/CpuModule.h>
#include <cpu/fmem.h>

#include <macos/sysequ.h>
#include <macos/errors.h>
#include <macos/traps.h>

#include "toolbox.h"
#include "stackframe.h"
#include "os.h"
#include "packages.h"

using ToolBox::Log;
using OS::MacToUnix;

namespace Packages {

	enum {
		shortDate = 0,
		longDate = 1,
		abbrevDate = 2
	};

	enum {
		mdy = 0,
		dmy = 1,
		ymd = 2,
		myd = 3,
		dym = 4,
		ydm = 5
	};

	enum {
		timeCycle24                   = 0,    /*time sequence 0:00 - 23:59*/
		timeCycleZero                 = 1,    /*time sequence 0:00-11:59, 0:00 - 11:59*/
		timeCycle12                   = 255,  /*time sequence 12:00 - 11:59, 12:00 - 11:59*/
		zeroCycle                     = 1,    /*old name for timeCycleZero*/
		longDay                       = 0,    /*day of the month*/
		longWeek                      = 1,    /*day of the week*/
		longMonth                     = 2,    /*month of the year*/
		longYear                      = 3,    /*year*/
		supDay                        = 1,    /*suppress day of month*/
		supWeek                       = 2,    /*suppress day of week*/
		supMonth                      = 4,    /*suppress month*/
		supYear                       = 8,    /*suppress year*/

		dayLdingZ                     = 32,
		mntLdingZ                     = 64,
		century                       = 128,
		secLeadingZ                   = 32,
		minLeadingZ                   = 64,
		hrLeadingZ                    = 128
	};

	#if 0
struct Intl0Rec {
  char                decimalPt;              /*decimal point character*/
  char                thousSep;               /*thousands separator character*/
  char                listSep;                /*list separator character*/
  char                currSym1;               /*currency symbol*/
  char                currSym2;
  char                currSym3;
  UInt8               currFmt;                /*currency format flags*/
  UInt8               dateOrder;              /*order of short date elements: mdy, dmy, etc.*/
  UInt8               shrtDateFmt;            /*format flags for each short date element*/
  char                dateSep;                /*date separator character*/
  UInt8               timeCycle;              /*specifies time cycle: 0..23, 1..12, or 0..11*/
  UInt8               timeFmt;                /*format flags for each time element*/
  char                mornStr[4];             /*trailing string for AM if 12-hour cycle*/
  char                eveStr[4];              /*trailing string for PM if 12-hour cycle*/
  char                timeSep;                /*time separator character*/
  char                time1Suff;              /*trailing string for AM if 24-hour cycle*/
  char                time2Suff;
  char                time3Suff;
  char                time4Suff;
  char                time5Suff;              /*trailing string for PM if 24-hour cycle*/
  char                time6Suff;
  char                time7Suff;
  char                time8Suff;
  UInt8               metricSys;              /*255 if metric, 0 if inches etc.*/
  short               intl0Vers;              /*region code (hi byte) and version (lo byte)*/
};
	#endif
	enum {
		o_decimalPt = 0,
		o_thousSep = 1,
		o_listSep = 2, 
		o_currSym1 = 3,
		o_currSym2 = 4,
		o_currSym3 = 5,
		o_currFmt = 6,
		o_dateOrder = 7,
		o_shrtDateFmt = 8,
		o_dateSep = 9,
		o_timeCycle = 10,
		o_timeFmt = 11,
		o_mornStr = 12,
		o_eveStr = 16,
		o_timeSep = 20,
		o_time1Suff = 21,
		o_time2Suff = 22,
		o_time3Suff = 23,
		o_time4Suff = 24,
		o_time5Suff = 25,
		o_time6Suff = 26,
		o_time7Suff = 27,
		o_time8Suff = 28,
		o_metricSys = 29,
		o_intl0Vers = 30, /* 16-bit */

	};

	struct DateFormat {
		uint8_t dateOrder = mdy;
		uint8_t dateSep = '/';
		uint8_t shrtDateFmt = 0;

		void unpack(uint32_t intlPtr) {
			if (!intlPtr) return;

			dateOrder = memoryReadByte(intlPtr + o_dateOrder);
			shrtDateFmt = memoryReadByte(intlPtr + o_shrtDateFmt);
			dateSep = memoryReadByte(intlPtr + o_dateSep);
		}
	};

	struct TimeFormat {
		uint8_t timeCycle = timeCycle12;
		uint8_t timeSep = ':';
		uint8_t timeFmt = secLeadingZ + minLeadingZ;

		std::string mornStr = " AM";
		std::string eveStr = " PM";

		void unpack(uint32_t intlPtr) {
			if (!intlPtr) return;

			timeCycle = memoryReadByte(intlPtr + o_timeCycle);
			timeFmt = memoryReadByte(intlPtr + o_timeFmt);
			timeSep = memoryReadByte(intlPtr + o_timeSep);

			if (timeCycle ==  timeCycle24) {
				mornStr = read_string(intlPtr + o_time1Suff);
				eveStr = read_string(intlPtr + o_time5Suff);
			} else {
				mornStr = read_string(intlPtr + o_mornStr);
				eveStr = read_string(intlPtr + o_eveStr);
			}
		}

		static std::string read_string(uint32_t address) {
			std::string rv;
			for (unsigned i = 0; i < 4; ++i, ++address) {
				char c = memoryReadByte(address);
				if (!c) break;
				rv.push_back(c);
			}
			return rv;
		}
	};


	namespace {

		std::string FormatAbbrDate(uint32_t dateTime, uint32_t intlPtr) {
			std::string rv;

			char dd[8];
			char mm[8];
			char yy[8];

			std::string sep;

			DateFormat df;

			time_t t = MacToUnix(dateTime);
			struct tm *tm = ::localtime(&t);

			if (intlPtr) df.unpack(intlPtr);
			if (df.dateSep) sep.push_back(df.dateSep);

			if (df.shrtDateFmt & dayLdingZ) snprintf(dd, sizeof(dd), "%02u", tm->tm_mday);
			else snprintf(dd, sizeof(dd), "%u", tm->tm_mday);

			if (df.shrtDateFmt & mntLdingZ) snprintf(mm, sizeof(mm), "%02u", tm->tm_mon + 1);
			else snprintf(mm, sizeof(mm), "%u", tm->tm_mon + 1);

			if (df.shrtDateFmt & century) snprintf(yy, sizeof(yy), "%04u", tm->tm_year + 1900);
			else snprintf(yy, sizeof(yy), "%02u", tm->tm_year % 100);


			switch(df.dateOrder) {
				default:
				case mdy:
  					rv = mm + sep + dd + sep + yy;
  					break;
				case dmy:
  					rv = dd + sep + mm + sep + yy;
  					break;
				case ymd:
  					rv = yy + sep + mm + sep + dd;
					break;
				case myd:
  					rv = mm + sep + yy + sep + dd;
  					break;
				case dym:
  					rv = dd + sep + yy + sep + mm;
  					break;
				case ydm:
  					rv = yy + sep + dd + sep + mm;
  					break;
			}
			return rv;
		}

		std::string FormatDate(uint32_t dateTime, unsigned form, uint32_t intlPtr) {
			/* not localized.  some foreign day/month strings include macroman chars */

			if (form == abbrevDate)
				return FormatAbbrDate(dateTime, intlPtr);

			char buffer[256];
			int length;
			std::string rv;



			time_t t = MacToUnix(dateTime);
			struct tm *tm = ::localtime(&t);


			switch(form) {
				case shortDate:
					// Sat, Jul 11, 2020
					// length = std::strftime(buffer, sizeof(buffer), "%a, %b %e, %Y", tm);
					length = std::strftime(buffer, sizeof(buffer), "%a, %b ", tm);
					rv = std::string(buffer, buffer + length);
					length = std::snprintf(buffer, sizeof(buffer), "%u, %04u",
						tm->tm_mday, tm->tm_year + 1900);
					rv.append(buffer, buffer + length);
					break;
				case longDate:
				default:
					// Saturday, July 11, 2020
					// length = std::strftime(buffer, sizeof(buffer), "%A, %B %e, %Y", tm);
					length = std::strftime(buffer, sizeof(buffer), "%A, %B ", tm);
					rv = std::string(buffer, buffer + length);
					length = std::snprintf(buffer, sizeof(buffer), "%u, %04u",
						tm->tm_mday, tm->tm_year + 1900);
					rv.append(buffer, buffer + length);
					break;
			}

			return rv;

		}


		std::string FormatTime(uint32_t dateTime, bool seconds, uint32_t intlPtr) {

			char hh[8];
			char mm[8];
			char ss[8];

			std::string rv;

			std::string sep;

			TimeFormat tf;

			time_t t = MacToUnix(dateTime);
			struct tm *tm = ::localtime(&t);

			if (intlPtr) tf.unpack(intlPtr);
			if (tf.timeSep) sep.push_back(tf.timeSep);


			if (tf.timeFmt & secLeadingZ) snprintf(ss, sizeof(ss), "%02u", tm->tm_sec);
			else snprintf(ss, sizeof(ss), "%u", tm->tm_sec);

			if (tf.timeFmt & minLeadingZ) snprintf(mm, sizeof(mm), "%02u", tm->tm_min);
			else snprintf(mm, sizeof(mm), "%u", tm->tm_min);


			unsigned h = tm->tm_hour;
			bool am = h < 12;
			switch (tf.timeCycle) {
				default:
				case timeCycle12:
					h %= 12;
					if (!h) h = 12;
					break;
				case timeCycle24:
					break;
				case timeCycleZero:
					h %= 12;
					break;
			}

			if (tf.timeFmt & hrLeadingZ) snprintf(hh, sizeof(hh), "%02u", h);
			else snprintf(hh, sizeof(hh), "%u", h);


			rv = hh + sep + mm;
			if (seconds) {
				rv += sep + ss;
			}

			rv.append( am ? tf.mornStr : tf.eveStr);

			return rv;
		}

	}

	uint16_t IUDateString()
	{
		// void IUDateString(long dateTime, DateForm longFlag, Str255 result)

		std::string out;

		uint32_t dateTime;
		uint8_t flag;
		uint32_t result;


		StackFrame<10>(dateTime, flag, result);

		Log("     IUDateString(%08x, %02x, %08x)\n", dateTime, flag, result);

		out = FormatDate(dateTime, flag, 0);
		ToolBox::WritePString(result, out);
		return 0;

	}

	uint16_t IUDatePString()
	{
		// void IUDateString(long dateTime, DateForm longFlag, Str255 result, Handle intlHandle)

		std::string out;

		uint32_t dateTime;
		uint8_t flag;
		uint32_t result;
		uint32_t intlHandle;
		uint32_t intlPtr;


		StackFrame<14>(dateTime, flag, result, intlHandle);

		Log("     IUDatePString(%08x, %02x, %08x, %08x)\n", dateTime, flag, result, intlHandle);

		intlPtr = intlHandle ? memoryReadLong(intlHandle) : 0;

		out = FormatDate(dateTime, flag, intlPtr);
		ToolBox::WritePString(result, out);
		return 0;

	}

	uint16_t IUTimeString()
	{
		// void IUTimeString(long dateTime,Boolean wantSeconds,Str255 result)
		// output: 12:00:00 AM or 12:00 AM

		std::string out;

		uint32_t dateTime;
		uint8_t wantSeconds;
		uint32_t result;


		StackFrame<10>(dateTime, wantSeconds, result);
		Log("     IUTimeString(%08x, %02x, %08x)\n", dateTime, wantSeconds, result);

		out = FormatTime(dateTime, wantSeconds, 0);

		ToolBox::WritePString(result, out);
		return 0;
	}


	uint16_t IUTimePString() {
		// void IUTimePString(long dateTime, Boolean wantSeconds, Str255 result, Handle intlHandle)


		std::string out;

		uint32_t dateTime;
		uint8_t wantSeconds;
		uint32_t result;
		uint32_t intlHandle;
		uint32_t intlPtr;

		StackFrame<14>(dateTime, wantSeconds, result, intlHandle);
		Log("     IUTimePString(%08x, %02x, %08x, %08x)\n", dateTime, wantSeconds, result, intlHandle);

		intlPtr = intlHandle ? memoryReadLong(intlHandle) : 0;

		out = FormatTime(dateTime, wantSeconds, intlPtr);
		ToolBox::WritePString(result, out);
		return 0;
	}

	uint16_t InitDateCache()
	{
		// OSErr InitDateCache(DateCachePtr theCache) 
		uint32_t theCache;
		uint32_t sp;
		sp = StackFrame<4>(theCache);
		Log("     InitDateCache(%08x)\n", theCache);
		/* cache not used */

		ToolReturn<4>(sp, 0);
		return 0;
	}

	enum {
		                                /* StringToDate status values */
		fatalDateTime                 = 0x8000, /* StringToDate and String2Time mask to a fatal error */
		longDateFound                 = 1,    /* StringToDate mask to long date found */
		leftOverChars                 = 2,    /* StringToDate & Time mask to warn of left over characters */
		sepNotIntlSep                 = 4,    /* StringToDate & Time mask to warn of non-standard separators */
		fieldOrderNotIntl             = 8,    /* StringToDate & Time mask to warn of non-standard field order */
		extraneousStrings             = 16,   /* StringToDate & Time mask to warn of unparsable strings in text */
		tooManySeps                   = 32,   /* StringToDate & Time mask to warn of too many separators */
		sepNotConsistent              = 64,   /* StringToDate & Time mask to warn of inconsistent separators */
		tokenErr                      = 0x8100, /* StringToDate & Time mask for 'tokenizer err encountered' */
		cantReadUtilities             = 0x8200,
		dateTimeNotFound              = 0x8400,
		dateTimeInvalid               = 0x8800
	};

#if 0
typedef short                           StringToDateStatus;
typedef StringToDateStatus              String2DateStatus;
struct DateCacheRecord {
  short               hidden[256];            /* only for temporary use */
};
typedef struct DateCacheRecord          DateCacheRecord;
typedef DateCacheRecord *               DateCachePtr;
struct DateTimeRec {
  short               year;
  short               month;
  short               day;
  short               hour;
  short               minute;
  short               second;
  short               dayOfWeek;
};
typedef struct DateTimeRec              DateTimeRec;

typedef SInt64                          LongDateTime;
union LongDateCvt {
  SInt64              c;
  struct {
    UInt32              lHigh;
    UInt32              lLow;
  }                       hl;
};
typedef union LongDateCvt               LongDateCvt;
union LongDateRec {
  struct {
    short               era;
    short               year;
    short               month;
    short               day;
    short               hour;
    short               minute;
    short               second;
    short               dayOfWeek;
    short               dayOfYear;
    short               weekOfYear;
    short               pm;
    short               res1;
    short               res2;
    short               res3;
  }                       ld;
  short               list[14];               /*Index by LongDateField!*/
  struct {
    short               eraAlt;
    DateTimeRec         oldDate;
  }                       od;
};
typedef union LongDateRec               LongDateRec;
#endif

	enum {

		o_era = 0, /* 0 = AD, -1 = BC */
		o_year = 2,
		o_month = 4, /* 1-12 */
		o_day = 6, /* 1-31 */
		o_hour = 8,
		o_minute = 10,
		o_second = 12,
		o_dayOfWeek = 14, /*1-7, sun-sat */
		o_dayOfYear = 16, /* 1-365 (366) */
		o_weekOfYear = 18, /* 1- 52 */
		o_pm = 20, /* 0 = am, 1 = pm */
		o_res1 = 22,
		o_res2 = 24,
		o_res3 = 26,
	};

	uint16_t StringToDate()
	{
		// StringToDateStatus StringToDate(Ptr textPtr, long textLen, DateCachePtr theCache, long *lengthUsed, LongDateRec *dateTime)
		uint32_t sp;
		uint32_t textPtr;
		uint32_t textLen;
		uint32_t theCache;
		uint32_t lengthUsed;
		uint32_t dateTime;

		uint16_t rv = 0;
		uint32_t used = 0;

		struct tm tm = {};

		sp = StackFrame<20>(textPtr, textLen, theCache, lengthUsed, dateTime);
		std::string s = ToolBox::ReadString(textPtr, textLen);

		Log("     StringToDate(%s, %08lx)\n", s.c_str(), dateTime);

		rv = dateTimeNotFound;
		if (s.length()) {
			/* only allow %Y-%m-%d for now */
			char *cp;
			cp = strptime(s.c_str(), " %Y-%m-%d", &tm);
			if (!cp) cp = strptime(s.c_str(), "%m/%d/%Y", &tm);

			if (cp) {
				rv = longDateFound;
				used = cp - s.c_str();

				memoryWriteWord(0, dateTime+o_era); /* o = AD, -1 = BC */
				memoryWriteWord(1900 + tm.tm_year, dateTime+o_year);
				memoryWriteWord(1 + tm.tm_mon, dateTime+o_month);
				memoryWriteWord(0 + tm.tm_mday, dateTime+o_day);
				/* not populated */
				//memoryWriteWord(1 + tm.tm_wday, dateTime+o_dayOfWeek);
				//memoryWriteWord(1 + tm.tm_yday, dateTime+o_dayOfYear);
				// unsupported - week of year....
			}
		}


		memoryWriteLong(used, lengthUsed);
		ToolReturn<2>(sp, rv);
		return 0;
	}

	uint16_t StringToTime()
	{
		// StringToDateStatus StringToTime(Ptr textPtr, long textLen, DateCachePtr theCache, long *lengthUsed, LongDateRec *dateTime)
		uint32_t sp;
		uint32_t textPtr;
		uint32_t textLen;
		uint32_t theCache;
		uint32_t lengthUsed;
		uint32_t dateTime;

		uint16_t rv = 0;
		uint32_t used = 0;

		sp = StackFrame<20>(textPtr, textLen, theCache, lengthUsed, dateTime);
		std::string s = ToolBox::ReadString(textPtr, textLen);

		Log("     StringToTime(%s, %08lx)\n", s.c_str(), dateTime);


		rv = dateTimeNotFound;

		memoryWriteLong(used, lengthUsed);
		ToolReturn<2>(sp, rv);
		return 0;
	}

	uint16_t GetIntlResource()
	{
		// FUNCTION GetIntlResource (theID: Integer) :Handle;

		// todo -- actually load the resource

		/*
		 * theID Contains an integer (0, 1, 2, 4, or 5 respectively for
		 * the 'itl0', 'itl1', 'itl2',  'itl4', and 'itl5'resources) to
		 * identify the type of the desired international resource.
		 */


		uint16_t theID;

		uint32_t sp = StackFrame<2>(theID);

		Log("     GetIntlResource(%04x)\n", theID);

		ToolReturn<4>(sp, 0);
		return 0; // should set res error.
	}

	uint16_t Pack6(uint16_t trap)
	{

		uint16_t selector;
		StackFrame<2>(selector);

		Log("%04x Pack6(%04x)\n", trap, selector);

		switch(selector)
		{
		case 0x0000:
			return IUDateString();
		case 0x0002:
			return IUTimeString();
		// case 0x0004: return IsMetric();
		case 0x0006:
			return GetIntlResource();
		// case 0x0008: return SetIntlResource();
		case 0x000e:
			return IUDatePString();
		case 0x0010:
			return IUTimePString();

		default:
			fprintf(stderr, "Pack6: selector %04x not supported\n", selector);
			exit(1);
		}
		return 0;
	}


	uint16_t ScriptUtil(uint16_t trap)
	{
		uint32_t selector;
		StackFrame<4>(selector);
		Log("%04x ScriptUtil(%08x)\n", trap, selector);

		switch(selector)
		{
		case 0x8204fff8:
			return InitDateCache();
		case 0x8214fff6:
			return StringToDate();
		case 0x8214fff4:
			return StringToTime();
		default:
			fprintf(stderr, "ScriptUtil: selector %08x not supported\n", selector);
			exit(1);
		}



	}

}