Macintosh-SW/mpw
1
0
Fork 0
mirror of https://github.com/ksherlock/mpw.git synced 2024-11-22 00:32:44 +00:00
Code Issues Projects Releases Wiki Activity
861ca9b83a
mpw/toolbox/sane.cpp

1266 lines
26 KiB
C++
Raw Blame History

/*
* Copyright (c) 2013, 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 "qd.h"
#include "toolbox.h"
#include "sane.h"
#include <cpu/defs.h>
#include <cpu/CpuModule.h>
#include <cpu/fmem.h>
#include <stdlib.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include "stackframe.h"
#include "complex.h"
#include "fpinfo.h"
using ToolBox::Log;
namespace SANE
{
using std::to_string;
using std::fpclassify;
using std::signbit;
using std::abs;
using its_complicated::to_string;
using its_complicated::fpclassify;
using its_complicated::signbit;
namespace {
// default environment is:
// rounding direction: to nearest
// rounding precision: extended
// exception flags: clear
// halts: clear
/*
* Environment: x d d e e e e e x p p h h h h h
* x - reserved
* d d - rounding direction
* e - exception flags
* p - rounding precision
* h - halt flags
*/
enum {
kExceptionInexact = 1 << 12,
kExceptionDivideByZero = 1 << 11,
kExceptionOverflow = 1 << 10,
kExceptionUnderflow = 1 << 9,
kExceptionInvalid = 1 << 8,
kHaltInexact = 1 << 4,
kHaltDivideByZero = 1 << 3,
kHaltOverflow = 1 << 2,
kHaltUnderflow = 1 << 1,
kHaltInvalid = 1 << 0,
kRoundingDirectionMask = 0x6000,
kRoundingDirectionToNearest = 0x0000,
kRoundingDirectionUpward = 0x2000,
kRoundingDirectionDownward = 0x4000,
kRoundingDirectionTowardZero = 0x6000,
kRoundingPrecisionMask = 0x0060,
kRoundingPrecisionExtended = 0x0000,
kRoundingPrecisionDouble = 0x0020,
kRoundingPrecisionSingle = 0x0040,
kRoundingPrecisionUndefined = 0x0060,
};
const uint16_t DefaultEnvironment = 0;
uint16_t Environment = DefaultEnvironment;
}
// long double is an 80-bit extended with an extra 48-bits of 0 padding.
typedef long double extended;
template <class T>
T readnum(uint32_t address);
template<>
int16_t readnum<int16_t>(uint32_t address)
{
return memoryReadWord(address);
}
template<>
int32_t readnum<int32_t>(uint32_t address)
{
return memoryReadLong(address);
}
template<>
int64_t readnum<int64_t>(uint32_t address)
{
return memoryReadLongLong(address);
}
template<>
complex readnum<complex>(uint32_t address)
{
return complex(memoryReadLongLong(address));
}
template<>
float readnum<float>(uint32_t address)
{
static_assert(sizeof(float) == 4, "unexpected float size");
uint32_t x = memoryReadLong(address);
return *((float *)&x);
}
template<>
double readnum<double>(uint32_t address)
{
static_assert(sizeof(double) == 8, "unexpected double size");
uint64_t x = memoryReadLongLong(address);
return *((double *)&x);
}
template<>
long double readnum<long double>(uint32_t address)
{
char buffer[16];
static_assert(sizeof(long double) == 16, "unexpected long double size");
// read and swap 10 bytes
// this is very much little endian.
for (unsigned i = 0; i < 10; ++i)
{
buffer[9 - i] = memoryReadByte(address + i);
}
// remainder are 0-filled.
for (unsigned i = 10; i < 16; ++i)
buffer[i] = 0;
// now cast...
return *((long double *)buffer);
}
template<class T>
void writenum(T value, uint32_t address);
template<>
void writenum<int16_t>(int16_t value, uint32_t address)
{
memoryWriteWord(value, address);
}
template<>
void writenum<int32_t>(int32_t value, uint32_t address)
{
memoryWriteLong(value, address);
}
template<>
void writenum<int64_t>(int64_t value, uint32_t address)
{
memoryWriteLongLong(value, address);
}
template<>
void writenum<complex>(complex value, uint32_t address)
{
memoryWriteLongLong(value, address);
}
template<>
void writenum<float>(float value, uint32_t address)
{
static_assert(sizeof(value) == 4, "unexpected float size");
memoryWriteLong(*((uint32_t *)&value), address);
}
template<>
void writenum<double>(double value, uint32_t address)
{
static_assert(sizeof(value) == 8, "unexpected double size");
memoryWriteLongLong(*((uint64_t *)&value), address);
}
template<>
void writenum<long double>(long double value, uint32_t address)
{
static_assert(sizeof(value) == 16, "unexpected long double size");
char buffer[16];
std::memcpy(buffer, &value, sizeof(value));
// copy 10 bytes over
// little-endian specific.
for(unsigned i = 0; i < 10; ++i)
memoryWriteByte(buffer[9 - i], address + i);
}
decform decform::read(uint32_t address)
{
enum {
_style = 0,
_unused = 1,
_digits = 2,
};
decform d;
if (!address) return d;
d.style = memoryReadByte(address + _style);
d.digits = memoryReadWord(address + _digits);
return d;
}
void decform::write(uint32_t address)
{
enum {
_style = 0,
_unused = 1,
_digits = 2,
};
if (!address) return;
memoryWriteByte(style, address + _style);
memoryWriteWord(digits, address + _digits);
}
decimal decimal::read(uint32_t address)
{
enum {
_sgn = 0,
_exp = 2,
_sig = 4,
SIGDIGLEN = 20,
};
decimal d;
if (!address) return d;
d.sgn = memoryReadByte(address + _sgn);
d.exp = memoryReadWord(address + _exp);
//unsigned length = memoryReadByte(address + _sig);
//length = std::min(length, (unsigned)SIGDIGLEN);
d.sig = ToolBox::ReadPString(address + _sig, false);
return d;
}
void decimal::write(uint32_t address)
{
enum {
_sgn = 0,
_exp = 2,
_sig = 4,
SIGDIGLEN = 20,
};
memoryWriteByte(sgn, address + _sgn);
memoryWriteByte(0, address + _sgn + 1); // unused.
memoryWriteWord(exp, address + _exp);
// check if <= SIGDIGLEN?
ToolBox::WritePString(address + _sig, sig);
}
void format_f(extended x, int precision, std::string &mm, std::string &nn)
{
char *buffer = nullptr;
mm.clear();
nn.clear();
if (precision < 0) precision = 0;
int length = asprintf(&buffer, "%.*Lf", precision, x);
std::string tmp(buffer, length);
free(buffer);
auto dot = tmp.find('.');
if (dot == tmp.npos)
{
mm = std::move(tmp);
}
else
{
mm = tmp.substr(0, dot);
nn = tmp.substr(dot + 1);
}
// skip mm if it's 0
if (mm.length() == 1 && mm.front() == '0') mm.clear();
// skip nn if it's 0000...
if (std::all_of(nn.begin(), nn.end(), [](char c){ return c == '0'; }))
nn.clear();
}
void format_e(extended x, int precision, std::string &mm, std::string &nn, int &exp)
{
char *buffer = nullptr;
exp = 0;
mm.clear();
nn.clear();
if (precision < 0) precision = 0;
if (precision > 19) precision = 19;
int length = asprintf(&buffer, "%.*Le", precision, x);
// output mm . nn e[+-]exp
// mm e[+-]exp
std::string tmp(buffer, length);
free(buffer);
auto dot = tmp.find('.');
auto e = tmp.find('e');
if (dot == tmp.npos)
{
mm = tmp.substr(0, e);
}
else
{
mm = tmp.substr(0, dot);
nn = tmp.substr(dot + 1, e - dot - 1);
}
char sign = tmp[e+1];
tmp = tmp.substr(e + 2);
exp = std::stoi(tmp);
if (sign == '-') exp = -exp;
}
uint16_t fx2dec()
{
// extended (80-bit fp) to decimal
// convert a to d based on decform f
// used by printf %g, %f, %e, etc
uint16_t op;
uint32_t f_adr;
uint32_t a_adr;
uint32_t d_adr;
decform df;
decimal d;
StackFrame<14>(f_adr, a_adr, d_adr, op);
Log(" FX2DEC(%08x, %08x, %08x, %04x)\n", f_adr, a_adr, d_adr, op);
extended s = readnum<extended>(a_adr);
df = decform::read(f_adr);
if (ToolBox::Trace)
{
std::string tmp1 = std::to_string(s);
Log(" %s (style: %d digits: %d)\n", tmp1.c_str(), df.style, df.digits);
}
/*
* SANE pp 30, 31
*
* Floating style:
* [-| ]m[.nnn]e[+|-]dddd
*
* Fixed style:
* [-]mmm[.nnn]
*/
if (df.digits < 0) df.digits = 0;
if (df.digits > 19) df.digits = 19;
fpinfo fpi(s);
//fprintf(stderr, "%02x %02x %d %016llx\n", fpi.sign, fpi.one, fpi.exp, fpi.sig);
d.sgn = signbit(s);
// handle infinity, nan as a special case.
switch (fpclassify(s))
{
case FP_ZERO:
d.sig = "0";
d.write(d_adr);
return 0;
case FP_NAN:
// NAN type encoded in the sig.
{
char buffer[20]; // 16 + 2 needed
snprintf(buffer, 20, "N%016llx", fpi.sig);
d.sig = buffer;
d.write(d_adr);
}
return 0;
case FP_INFINITE:
d.sig = "I";
d.write(d_adr);
return 0;
default:
break;
}
// normal and subnormal handled here....
// float decimal: df.digits refers to the total length
// fixed decimal: df.digits refers to the fractional part only.
s = abs(s);
if (s < 1.0 && df.style == decform::FLOATDECIMAL)
{
std::string mm;
std::string nn;
format_e(s, df.digits - 1, mm, nn, d.exp);
d.sig = mm + nn;
// better be < 0...
if (d.exp < 0)
d.exp -= nn.length();
d.write(d_adr);
return 0;
}
else // s > 1
{
std::string mm;
std::string nn;
format_f(s, df.digits, mm, nn);
if (mm.empty() && nn.empty())
{
// very large 0.
d.sig = "0";
d.write(d_adr);
return 0;
}
// if nn is empty (or 0s), this is a large number,
// and we don't have to worry about the fraction.
if (nn.empty())
{
d.exp = 0;
if (df.style == decform::FIXEDDECIMAL) df.digits = 19;
// limit the length.
if (mm.length() > df.digits)
{
d.exp = mm.length() - df.digits;
mm.resize(df.digits);
}
d.sig = std::move(mm);
}
else
{
if (df.style == decform::FIXEDDECIMAL)
{
// digits is the total size, mm + nn
// re-format with new precision.
// this is getting repetitive...
if (mm.length())
{
int precision = df.digits - mm.length();
if (precision < 0) precision = 1;
format_f(s, precision, mm, nn);
}
}
// todo -- if mm is empty and nn has leading 0s,
// drop the leading 0s and adjust the exponent
// accordingly.
d.sig = mm + nn;
d.exp = -nn.length();
if (d.sig.length() > 19)
{
d.exp += (d.sig.length() - 19);
d.sig.resize(19);
}
}
d.write(d_adr);
return 0;
}
}
template<class SrcType, class DestType = extended>
uint16_t fadd(const char *name)
{
// faddi, etc.
// destination is always extended.
uint16_t op;
uint32_t dest;
uint32_t src;
StackFrame<10>(src, dest, op);
Log(" %s(%08x, %08x, %04x)\n", name, src, dest, op);
SrcType s = readnum<SrcType>(src);
DestType d = readnum<DestType>(dest);
if (ToolBox::Trace)
{
std::string tmp1 = std::to_string(d);
std::string tmp2 = std::to_string(s);
Log(" %s + %s\n", tmp1.c_str(), tmp2.c_str());
}
d = d + s;
writenum<DestType>(d, dest);
return 0;
}
template<class SrcType, class DestType = extended>
uint16_t fsub(const char *name)
{
// fsub, etc.
// destination is always extended.
uint16_t op;
uint32_t dest;
uint32_t src;
StackFrame<10>(src, dest, op);
Log(" %s(%08x, %08x, %04x)\n", name, src, dest, op);
SrcType s = readnum<SrcType>(src);
DestType d = readnum<DestType>(dest);
if (ToolBox::Trace)
{
std::string tmp1 = std::to_string(d);
std::string tmp2 = std::to_string(s);
Log(" %s - %s\n", tmp1.c_str(), tmp2.c_str());
}
d = d - s;
writenum<DestType>(d, dest);
return 0;
}
template<class SrcType, class DestType = extended>
uint16_t fmul(const char *name)
{
// multiply extended (80-bit fp)
uint16_t op;
uint32_t dest;
uint32_t src;
StackFrame<10>(src, dest, op);
Log(" %s(%08x, %08x, %04x)\n", name, src, dest, op);
SrcType s = readnum<SrcType>(src);
DestType d = readnum<DestType>(dest);
if (ToolBox::Trace)
{
std::string tmp1 = std::to_string(d);
std::string tmp2 = std::to_string(s);
Log(" %s * %s\n", tmp1.c_str(), tmp2.c_str());
}
d = d * s;
writenum<DestType>((extended)d, dest);
return 0;
}
template<class SrcType, class DestType = extended>
uint16_t fdiv(const char *name)
{
// div extended (80-bit fp)
uint16_t op;
uint32_t dest;
uint32_t src;
StackFrame<10>(src, dest, op);
Log(" %s(%08x, %08x, %04x)\n", name, src, dest, op);
SrcType s = readnum<SrcType>(src);
DestType d = readnum<DestType>(dest);
if (ToolBox::Trace)
{
std::string tmp1 = std::to_string(d);
std::string tmp2 = std::to_string(s);
Log(" %s / %s\n", tmp1.c_str(), tmp2.c_str());
}
// dest = dest / src
d = d / s;
writenum<DestType>(d, dest);
return 0;
}
template<class SrcType, class DestType>
uint16_t fconvert(const char *name)
{
// type conversion.
uint16_t op;
uint32_t dest;
uint32_t src;
StackFrame<10>(src, dest, op);
Log(" %s(%08x, %08x, %04x)\n", name, src, dest, op);
SrcType s = readnum<SrcType>(src);
if (ToolBox::Trace)
{
std::string tmp1 = to_string(s);
Log(" %s\n", tmp1.c_str());
}
writenum<DestType>((DestType)s, dest);
return 0;
}
extern "C" void cpuSetFlagsShift(BOOLE z, BOOLE n, BOOLE c, BOOLE v);
template<class SrcType, class DestType = extended>
uint16_t fcmp(const char *name)
{
uint16_t op;
uint32_t dest;
uint32_t src;
// TODO op & 0x0f == 0x08 vs 0x0a
// for signaling unordered & NaN
StackFrame<10>(src, dest, op);
Log(" %s(%08x, %08x, %04x)\n", name, src, dest, op);
SrcType s = readnum<SrcType>(src);
DestType d = readnum<DestType>(dest);
if (ToolBox::Trace)
{
std::string tmp1 = std::to_string(d);
std::string tmp2 = std::to_string(s);
Log(" %s <> %s\n", tmp1.c_str(), tmp2.c_str());
}
// TODO -- verify if src/dest are backwards here
//
//
// check if ordered...
if (d > s)
{
cpuSetFlagsShift(false, false, false, false);
return 0;
}
if (d < s)
{
cpuSetFlagsShift(false, true, true, false);
return 0;
}
if (d == s)
{
cpuSetFlagsShift(true, false, false, false);
return 0;
}
// unorderable?
// signal?
cpuSetFlagsShift(false, false, false, true);
return 0;
}
template <class DestType>
uint16_t fdecimal(const char *name)
{
uint16_t op;
uint32_t decimalPtr;
uint32_t dest;
StackFrame<10>(decimalPtr, dest, op);
uint16_t sgn = memoryReadByte(decimalPtr);
int16_t exp = memoryReadWord(decimalPtr + 2);
std::string sig;
sig = ToolBox::ReadPString(decimalPtr + 4, false);
Log(" %s({%c %s e%d}, %08x)\n",
name,
sgn ? '-' : ' ', sig.c_str(), exp,
dest
);
extended tmp = 0;
if (sig.length())
{
if (sig[0] == 'I')
{
tmp = INFINITY;
}
else if (sig[0] == 'N')
{
tmp = NAN; // todo -- nan type
}
else
{
tmp = stold(sig);
while (exp > 0)
{
tmp = tmp * 10.0;
exp--;
}
while (exp < 0)
{
tmp = tmp / 10.0;
exp++;
}
}
}
if (sgn) tmp = -tmp;
writenum<DestType>((DestType)tmp, dest);
return 0;
}
template <class SrcType>
uint16_t fclassify(const char *name)
{
/*
* The classify operations set the sign of the destination to
* the sign of the source and the value of the destination
* according to the class of the source, as shown in Table E-18.
* The destination is an integer variable. (pg 273)
*
*
* Table E-18
* Class Information
* ----------------------
* Class of SRC Value
* ----------------------
* Signaling NaN 1
* Quiet NaN 2
* Infinity 3
* Zero 4
* Normalized 5
* Denormalized 6
*
* Table E-19
* ---------------------------
* Sign of SRC Sign of DST
* ---------------------------
* Positive Positive
* Negative Negative
*/
// N.B. - Sane.h uses 0-5, but how can you have integer -0?
uint16_t op;
uint32_t dest;
uint32_t src;
StackFrame<10>(src, dest, op);
Log(" %s(%08x, %08x, %04x)\n", name, src, dest, op);
SrcType s = readnum<SrcType>(src);
if (ToolBox::Trace)
{
std::string tmp1 = to_string(s);
Log(" %s\n", tmp1.c_str());
}
int16_t klass = 0;
switch(fpclassify(s))
{
case FP_INFINITE:
klass = 3;
break;
case FP_NAN:
// todo -- signaling NaN is indicated
// by the MSB of the fraction field f
// 1 is quiet, 0 is signaling.
klass = 1;
break;
case FP_NORMAL:
klass = 5;
break;
case FP_SUBNORMAL:
klass = 6;
break;
case FP_ZERO:
klass = 4;
break;
}
if (signbit(s)) klass = -klass;
if (dest) {
memoryWriteWord(klass, dest);
}
return 0;
}
#pragma mark - environment
/*
* environment is a uint16_t *.
* void setenvironment(environment e);
* void getenvironment(environment *e);
* void procentry(environment *e);
* void procexit(environment e);
*/
uint16_t fgetenv(void)
{
uint32_t address;
uint16_t op;
StackFrame<6>(address, op);
Log(" FGETENV(%08x)\n", address);
memoryWriteWord(Environment, address);
return 0;
}
uint16_t fsetenv(void)
{
uint32_t address;
uint16_t value;
uint16_t op;
StackFrame<6>(address, op);
value = address ? memoryReadWord(address) : DefaultEnvironment;
Log(" FSETENV(%08x (%04x))\n", address, value);
Environment = value;
return 0;
}
uint16_t fprocentry(void)
{
uint32_t address;
uint16_t op;
StackFrame<6>(address, op);
Log(" FPROCENTRY(%08x)\n", address);
if (address) memoryWriteWord(Environment, address);
Environment = DefaultEnvironment;
return 0;
}
uint16_t fprocexit(void)
{
uint32_t address;
uint16_t value;
uint16_t op;
StackFrame<6>(address, op);
value = address ? memoryReadWord(address) : DefaultEnvironment;
Log(" FPROCEXIT(%08x (%04x))\n", address, value);
// todo -- also should signal exceptions/halts at this point.
Environment = value;
return 0;
}
uint16_t ftintx()
{
// truncate (round towards 0 regardless of rounding settings)
uint32_t address;
uint16_t op;
StackFrame<6>(address, op);
Log(" FTINTX(%08x)\n", address);
extended s = readnum<extended>(address);
if (ToolBox::Trace)
{
std::string tmp1 = to_string(s);
Log(" %s\n", tmp1.c_str());
}
s = std::trunc(s);
writenum<extended>(s, address);
return 0;
}
extern "C" void cpuSetFlagsAbs(UWO f);
uint16_t fp68k(uint16_t trap)
{
uint16_t op;
uint32_t sp;
sp = cpuGetAReg(7);
op = memoryReadWord(sp);
Log("%04x FP68K(%04x)\n", trap, op);
cpuSetFlagsAbs(0x4);
if (op == 0x000b) return fx2dec();
switch(op)
{
// addition
case 0x0000: return fadd<extended>("FADDX");
case 0x0800: return fadd<double>("FADDD");
case 0x1000: return fadd<float>("FADDS");
//case 0x3000: return fadd<complex>("FADDC");
case 0x2000: return fadd<int16_t>("FADDI");
case 0x2800: return fadd<int32_t>("FADDL");
// subtraction
case 0x0002: return fsub<extended>("FSUBX");
case 0x0802: return fsub<double>("FSUBD");
case 0x1002: return fsub<float>("FSUBS");
//case 0x3002: return fsub<complex>("FSUBC");
case 0x2002: return fsub<int16_t>("FSUBI");
case 0x2802: return fsub<int32_t>("FSUBL");
// multiplication
case 0x0004: return fmul<extended>("FMULX");
case 0x0804: return fmul<double>("FMULD");
case 0x1004: return fmul<float>("FMULS");
//case 0x3004: return fmul<complex>("FMUlC");
case 0x2004: return fmul<int16_t>("FMULI");
case 0x2804: return fmul<int32_t>("FMULL");
// division
case 0x0006: return fdiv<extended>("FDIVX");
case 0x0806: return fdiv<double>("FDIVD");
case 0x1006: return fdiv<float>("FDIVS");
//case 0x3006: return fdiv<complex>("FDIVC");
case 0x2006: return fdiv<int16_t>("FDIVI");
case 0x2806: return fdiv<int32_t>("FDIVL");
// comparison
case 0x0008: return fcmp<extended>("FCMPX");
case 0x0808: return fcmp<double>("FCMPD");
case 0x1008: return fcmp<float>("FCMPS");
//case 0x3008: return fcmp<complex>("FCMPC");
case 0x2008: return fcmp<int16_t>("FCMPI");
case 0x2808: return fcmp<int32_t>("FCMPL");
case 0x000a: return fcmp<extended>("FCPXX");
case 0x080a: return fcmp<double>("FCPXD");
case 0x100a: return fcmp<float>("FCPXS");
//case 0x300a: return fcmp<complex>("FCPXC");
case 0x200a: return fcmp<int16_t>("FCPXI");
case 0x280a: return fcmp<int32_t>("FCPXL");
// conversion (extended -> ???)
case 0x0010: return fconvert<extended, extended>("FX2X");
case 0x0810: return fconvert<extended, double>("FX2D");
case 0x1010: return fconvert<extended, float>("FX2S");
case 0x3010: return fconvert<extended, complex>("FX2C");
case 0x2010: return fconvert<extended, int16_t>("FX2I");
case 0x2810: return fconvert<extended, int32_t>("FX2L");
// conversion (??? -> extended)
case 0x000e: return fconvert<extended, extended>("FX2X");
case 0x080e: return fconvert<double, extended>("FD2X");
case 0x100e: return fconvert<float, extended>("FS2X");
case 0x300e: return fconvert<complex, extended>("FC2X");
case 0x200e: return fconvert<int16_t, extended>("FI2X");
case 0x280e: return fconvert<int32_t, extended>("FL2X");
case 0x001c: return fclassify<extended>("FCLASSX");
case 0x081c: return fclassify<double>("FCLASSD");
case 0x101c: return fclassify<float>("FCLASSS");
case 0x301c: return fclassify<complex>("FCLASSC");
case 0x0009:
// fdec2x
return fdecimal<extended>("FDEC2X");
break;
case 0x0016: return ftintx();
case 0x0017: return fprocentry();
case 0x0019: return fprocexit();
case 0x0003: return fgetenv();
case 0x0001: return fsetenv();
}
fprintf(stderr, "fp68k -- op %04x is not yet supported\n", op);
exit(1);
return 0;
}
uint16_t NumToString(void)
{
/*
* on entry:
* A0 Pointer to pascal string
* D0 The number
*
* on exit:
* A0 Pointer to pascal string
* D0 Result code
*
*/
int32_t theNum = cpuGetDReg(0);
uint32_t theString = cpuGetAReg(0);
//std::string s = ToolBox::ReadPString(theString, false);
Log(" NumToString(%08x, %08x)\n", theNum, theString);
std::string s = std::to_string(theNum);
ToolBox::WritePString(theString, s);
return 0;
}
uint32_t StringToNum(void)
{
/*
* on entry:
* A0 Pointer to pascal string
*
* on exit:
* D0 the number
*
*/
uint32_t theString = cpuGetAReg(0);
std::string s = ToolBox::ReadPString(theString, false);
Log(" StringToNum(%s)\n", s.c_str());
bool negative = false;
uint32_t tmp = 0;
if (!s.length()) return 0;
auto iter = s.begin();
// check for leading +-
if (*iter == '-')
{
negative = true;
++iter;
}
else if (*iter == '+')
{
negative = false;
++iter;
}
for ( ; iter != s.end(); ++iter)
{
// doesn't actually check if it's a number.
int value = *iter & 0x0f;
tmp = tmp * 10 + value;
}
if (negative) tmp = -tmp;
return tmp;
}
uint32_t fstr2dec(char type)
{
// void str2dec(const char *s,short *ix,decimal *d,short *vp);
#if 0
#define SIGDIGLEN 20 /* significant decimal digits */
#define DECSTROUTLEN 80 /* max length for dec2str output */
struct decimal {
char sgn; /*sign 0 for +, 1 for -*/
char unused;
short exp; /*decimal exponent*/
struct{
unsigned char length;
unsigned char text[SIGDIGLEN]; /*significant digits */
unsigned char unused;
}sig;
};
#endif
uint32_t stringPtr;
uint32_t indexPtr;
uint32_t decimalPtr;
uint32_t validPtr;
uint16_t valid;
uint16_t index;
decimal d;
StackFrame<16>(stringPtr, indexPtr, decimalPtr, validPtr);
index = memoryReadWord(indexPtr);
std::string str;
if (type == 'P') str = ToolBox::ReadPString(stringPtr, false);
if (type == 'C') str = ToolBox::ReadCString(stringPtr, false);
Log(" F%cSTR2DEC(%s, %04x, %08x, %08x)\n",
type, str.c_str(), index, decimalPtr, validPtr);
if (type == 'P') index--;
str2dec(str, index, d, valid);
if (type == 'P') index++;
memoryWriteWord(index, indexPtr);
memoryWriteWord(valid, validPtr);
if (d.sig.length() > 20)
{
// truncate and adjust the exponent
// 1234e0 -> 123e1 -> 12e2 -> 1e3
// 1234e-1 -> 123e-0 -> 12e1
int over = d.sig.length() - 20;
d.sig.resize(20);
d.exp += over;
}
memoryWriteByte(d.sgn, decimalPtr);
memoryWriteByte(0, decimalPtr + 1);
memoryWriteWord(d.exp, decimalPtr + 2);
ToolBox::WritePString(decimalPtr + 4, d.sig);
return 0;
}
uint32_t decstr68k(uint16_t trap)
{
// this is a strange one since it may be sane or it may be the binary/decimal package.
uint16_t op;
StackFrame<2>(op);
Log("%04x DECSTR68K(%04x)\n", trap, op);
switch (op)
{
case 0x00:
return NumToString();
break;
case 0x01:
return StringToNum();
break;
case 0x02:
// fpstr2dec
return fstr2dec('P');
break;
case 0x04:
// fcstr2dec
return fstr2dec('C');
break;
default:
fprintf(stderr, "decstr68k -- op %04x is not yet supported\n", op);
exit(1);
}
return 0;
}
}
Reference in New Issue View Git Blame Copy Permalink