static BOOLEAN
LoadSummary (SUMMARY_DESC *SummPtr, void *fp)
{
if (!LoadSisState (&SummPtr->SS, fp))
return FALSE;
if (
read_8 (fp, &SummPtr->Activity) != 1 ||
read_8 (fp, &SummPtr->Flags) != 1 ||
read_8 (fp, &SummPtr->day_index) != 1 ||
read_8 (fp, &SummPtr->month_index) != 1 ||
read_16 (fp, &SummPtr->year_index) != 1 ||
read_8 (fp, &SummPtr->MCreditLo) != 1 ||
read_8 (fp, &SummPtr->MCreditHi) != 1 ||
read_8 (fp, &SummPtr->NumShips) != 1 ||
read_8 (fp, &SummPtr->NumDevices) != 1 ||
read_a8 (fp, SummPtr->ShipList, MAX_BUILT_SHIPS) != 1 ||
read_a8 (fp, SummPtr->DeviceList, MAX_EXCLUSIVE_DEVICES) != 1 ||
read_8 (fp, &SummPtr->res_factor) != 1 || // JMS: This'll help making saves between different resolutions compatible.
read_16 (fp, NULL) != 1 /* padding */
)
return FALSE;
else
return TRUE;
}
static BOOLEAN
LoadSisState (SIS_STATE *SSPtr, void *fp)
{
if (
read_32s (fp, &SSPtr->log_x) != 1 ||
read_32s (fp, &SSPtr->log_y) != 1 ||
read_32 (fp, &SSPtr->ResUnits) != 1 ||
read_32 (fp, &SSPtr->FuelOnBoard) != 1 ||
read_16 (fp, &SSPtr->CrewEnlisted) != 1 ||
read_16 (fp, &SSPtr->TotalElementMass) != 1 ||
read_16 (fp, &SSPtr->TotalBioMass) != 1 ||
read_a8 (fp, SSPtr->ModuleSlots, NUM_MODULE_SLOTS) != 1 ||
read_a8 (fp, SSPtr->DriveSlots, NUM_DRIVE_SLOTS) != 1 ||
read_a8 (fp, SSPtr->JetSlots, NUM_JET_SLOTS) != 1 ||
read_8 (fp, &SSPtr->NumLanders) != 1 ||
read_a16 (fp, SSPtr->ElementAmounts, NUM_ELEMENT_CATEGORIES) != 1 ||
read_str (fp, SSPtr->ShipName, SIS_NAME_SIZE) != 1 ||
read_str (fp, SSPtr->CommanderName, SIS_NAME_SIZE) != 1 ||
read_str (fp, SSPtr->PlanetName, SIS_NAME_SIZE) != 1 ||
read_16 (fp, NULL) != 1 /* padding */
)
return FALSE;
else
{
// JMS: Let's make savegames work even between different resolution modes.
SSPtr->log_x <<= RESOLUTION_FACTOR;
SSPtr->log_y <<= RESOLUTION_FACTOR;
return TRUE;
}
}
void Space::load_motor(int m, int32_t &addr) { // {{{
loaddebug("loading motor %d", m);
uint16_t enable = motor[m]->enable_pin.write();
double old_home_pos = motor[m]->home_pos;
double old_steps_per_unit = motor[m]->steps_per_unit;
motor[m]->step_pin.read(read_16(addr));
motor[m]->dir_pin.read(read_16(addr));
motor[m]->enable_pin.read(read_16(addr));
motor[m]->limit_min_pin.read(read_16(addr));
motor[m]->limit_max_pin.read(read_16(addr));
motor[m]->steps_per_unit = read_float(addr);
motor[m]->home_pos = read_float(addr);
motor[m]->limit_v = read_float(addr);
motor[m]->limit_a = read_float(addr);
motor[m]->home_order = read_8(addr);
arch_motors_change();
SET_OUTPUT(motor[m]->enable_pin);
if (enable != motor[m]->enable_pin.write()) {
if (motors_busy)
SET(motor[m]->enable_pin);
else {
RESET(motor[m]->enable_pin);
}
}
RESET(motor[m]->step_pin);
SET_INPUT(motor[m]->limit_min_pin);
SET_INPUT(motor[m]->limit_max_pin);
bool must_move = false;
if (!isnan(motor[m]->home_pos)) {
// Axes with a limit switch.
if (motors_busy && (old_home_pos != motor[m]->home_pos || old_steps_per_unit != motor[m]->steps_per_unit) && !isnan(old_home_pos)) {
double ohp = old_home_pos * old_steps_per_unit;
double hp = motor[m]->home_pos * motor[m]->steps_per_unit;
double diff = hp - ohp;
motor[m]->settings.current_pos += diff;
//debug("load motor %d %d new home %f add %f", id, m, motor[m]->home_pos, diff);
arch_addpos(id, m, diff);
must_move = true;
}
}
else {
// Axes without a limit switch, including extruders.
if (motors_busy && old_steps_per_unit != motor[m]->steps_per_unit) {
debug("load motor %d %d new steps no home", id, m);
double oldpos = motor[m]->settings.current_pos;
double pos = oldpos / old_steps_per_unit;
motor[m]->settings.current_pos = pos * motor[m]->steps_per_unit;
arch_addpos(id, m, motor[m]->settings.current_pos - oldpos);
// Adjust current_pos in all history.
for (int h = 0; h < FRAGMENTS_PER_BUFFER; ++h) {
oldpos = motor[m]->history[h].current_pos;
pos = oldpos / old_steps_per_unit;
motor[m]->history[h].current_pos = pos * motor[m]->steps_per_unit;
}
}
}
if (must_move)
move_to_current();
} // }}}
/* Reads in a value from the constant pool. */
void skip_constant(FILE *classfile, u_int16_t *cur)
{
u_int16_t len;
int seekerr = 1;
pool[*cur] = ftell(classfile);
switch(read_8(classfile))
{
case CP_UTF8:
len = read_16(classfile);
seekerr = fseek(classfile, len, SEEK_CUR);
break;
case CP_CLASS:
case CP_STRING:
seekerr = fseek(classfile, 2, SEEK_CUR);
break;
case CP_INTEGER:
case CP_FLOAT:
case CP_FIELDREF:
case CP_METHODREF:
case CP_INTERFACEMETHODREF:
case CP_NAMEANDTYPE:
seekerr = fseek(classfile, 4, SEEK_CUR);
break;
case CP_LONG:
case CP_DOUBLE:
seekerr = fseek(classfile, 8, SEEK_CUR);
++(*cur);
break;
default:
corrupt_error();
}
if(seekerr)
seek_error();
}
/* Read an old packet CTB and return the length of the body. */
static void
read_old_length (cdk_stream_t inp, int ctb, size_t * r_len, size_t * r_size)
{
int llen = ctb & 0x03;
if (llen == 0)
{
*r_len = cdk_stream_getc (inp);
(*r_size)++;
}
else if (llen == 1)
{
*r_len = read_16 (inp);
(*r_size) += 2;
}
else if (llen == 2)
{
*r_len = read_32 (inp);
(*r_size) += 4;
}
else
{
*r_len = 0;
*r_size = 0;
}
}
static inline COUNT
read_a16 (void *fp, UWORD *ar, COUNT count)
{
assert (ar != NULL);
for ( ; count > 0; --count, ++ar)
{
if (read_16 (fp, ar) != 1)
return 0;
}
return 1;
}
void Space::load_motor(uint8_t m, int32_t &addr) { // {{{
loaddebug("loading motor %d", m);
uint16_t enable = motor[m]->enable_pin.write();
double old_home_pos = motor[m]->home_pos;
double old_steps_per_unit = motor[m]->steps_per_unit;
motor[m]->step_pin.read(read_16(addr));
motor[m]->dir_pin.read(read_16(addr));
motor[m]->enable_pin.read(read_16(addr));
motor[m]->limit_min_pin.read(read_16(addr));
motor[m]->limit_max_pin.read(read_16(addr));
motor[m]->sense_pin.read(read_16(addr));
motor[m]->steps_per_unit = read_float(addr);
motor[m]->max_steps = read_8(addr);
motor[m]->home_pos = read_float(addr);
motor[m]->limit_v = read_float(addr);
motor[m]->limit_a = read_float(addr);
motor[m]->home_order = read_8(addr);
arch_motors_change();
SET_OUTPUT(motor[m]->enable_pin);
if (enable != motor[m]->enable_pin.write()) {
if (motors_busy)
SET(motor[m]->enable_pin);
else {
RESET(motor[m]->enable_pin);
}
}
RESET(motor[m]->step_pin);
SET_INPUT(motor[m]->limit_min_pin);
SET_INPUT(motor[m]->limit_max_pin);
SET_INPUT(motor[m]->sense_pin);
bool must_move = false;
if (!isnan(motor[m]->home_pos)) {
// Axes with a limit switch.
if (motors_busy && (old_home_pos != motor[m]->home_pos || old_steps_per_unit != motor[m]->steps_per_unit) && !isnan(old_home_pos)) {
int32_t hp = motor[m]->home_pos * motor[m]->steps_per_unit + (motor[m]->home_pos > 0 ? .49 : -.49);
int32_t ohp = old_home_pos * old_steps_per_unit + (old_home_pos > 0 ? .49 : -.49);
int32_t diff = hp - ohp;
motor[m]->settings.current_pos += diff;
cpdebug(id, m, "load motor new home add %d", diff);
arch_addpos(id, m, diff);
must_move = true;
}
}
else {
// Axes without a limit switch, including extruders.
if (motors_busy && old_steps_per_unit != motor[m]->steps_per_unit) {
int32_t cp = motor[m]->settings.current_pos;
double pos = cp / old_steps_per_unit;
cpdebug(id, m, "load motor new steps no home");
motor[m]->settings.current_pos = pos * motor[m]->steps_per_unit;
int diff = motor[m]->settings.current_pos - cp;
arch_addpos(id, m, diff);
}
}
if (must_move)
move_to_current();
} // }}}
void Temp::load(int32_t &addr, int id)
{
R0 = read_float(addr);
R1 = read_float(addr);
logRc = read_float(addr);
Tc = read_float(addr);
beta = read_float(addr);
K = exp(logRc - beta / Tc);
//debug("K %f R0 %f R1 %f logRc %f Tc %f beta %f", K, R0, R1, logRc, Tc, beta);
/*
core_C = read_float(addr);
shell_C = read_float(addr);
transfer = read_float(addr);
radiation = read_float(addr);
power = read_float(addr);
*/
power_pin[0].read(read_16(addr));
power_pin[1].read(read_16(addr));
int old_pin = thermistor_pin.write();
bool old_valid = thermistor_pin.valid();
thermistor_pin.read(read_16(addr));
target[1] = read_float(addr);
arch_set_duty(power_pin[1], read_float(addr));
for (int i = 0; i < 2; ++i) {
adctarget[i] = toadc(target[i], MAXINT);
SET_OUTPUT(power_pin[i]);
if (is_on[i])
SET(power_pin[i]);
else
RESET(power_pin[i]);
}
if (old_pin != thermistor_pin.write() && old_valid)
arch_setup_temp(~0, old_pin, false);
if (thermistor_pin.valid())
arch_setup_temp(id, thermistor_pin.pin, true, power_pin[0].valid() ? power_pin[0].pin : ~0, power_pin[0].inverted(), adctarget[0], power_pin[1].valid() ? power_pin[1].pin : ~0, power_pin[1].inverted(), adctarget[1]);
}
static cdk_error_t
read_public_key (cdk_stream_t inp, size_t pktlen, cdk_pkt_pubkey_t pk)
{
size_t i, ndays, npkey;
if (!inp || !pk)
return CDK_Inv_Value;
if (DEBUG_PKT)
_cdk_log_debug ("read_public_key: %d octets\n", pktlen);
pk->is_invalid = 1; /* default to detect missing self signatures */
pk->is_revoked = 0;
pk->has_expired = 0;
pk->version = cdk_stream_getc (inp);
if (pk->version < 2 || pk->version > 4)
return CDK_Inv_Packet_Ver;
pk->timestamp = read_32 (inp);
if (pk->version < 4)
{
ndays = read_16 (inp);
if (ndays)
pk->expiredate = pk->timestamp + ndays * 86400L;
}
pk->pubkey_algo = _pgp_pub_algo_to_cdk (cdk_stream_getc (inp));
npkey = cdk_pk_get_npkey (pk->pubkey_algo);
if (!npkey)
{
gnutls_assert ();
_cdk_log_debug ("invalid public key algorithm %d\n", pk->pubkey_algo);
return CDK_Inv_Algo;
}
for (i = 0; i < npkey; i++)
{
cdk_error_t rc = read_mpi (inp, &pk->mpi[i], 0);
if (rc)
return rc;
}
/* This value is just for the first run and will be
replaced with the actual key flags from the self signature. */
pk->pubkey_usage = 0;
return 0;
}
static cdk_error_t
read_mpi (cdk_stream_t inp, bigint_t * ret_m, int secure)
{
bigint_t m;
int err;
byte buf[MAX_MPI_BYTES + 2];
size_t nread, nbits;
cdk_error_t rc;
if (!inp || !ret_m)
return CDK_Inv_Value;
*ret_m = NULL;
nbits = read_16 (inp);
nread = (nbits + 7) / 8;
if (nbits > MAX_MPI_BITS || nbits == 0)
{
_cdk_log_debug ("read_mpi: too large %d bits\n", nbits);
return CDK_MPI_Error; /* Sanity check */
}
rc = stream_read (inp, buf + 2, nread, &nread);
if (!rc && nread != ((nbits + 7) / 8))
{
_cdk_log_debug ("read_mpi: too short %d < %d\n", nread,
(nbits + 7) / 8);
return CDK_MPI_Error;
}
buf[0] = nbits >> 8;
buf[1] = nbits >> 0;
nread += 2;
err = _gnutls_mpi_scan_pgp (&m, buf, nread);
if (err < 0)
return map_gnutls_error (err);
*ret_m = m;
return rc;
}
void Z80_Exec_ED(Z80_State *state, uint8_t opcode)
{
uint16_t addr;
uint8_t tmp;
//uint16_t tmp_16;
switch (opcode)
{
case 0x40: // in b, (c)
rB = in(rBC);
in_f(rB);
break;
case 0x41: // out (c), b
out(rBC, rB);
break;
case 0x42: // sbc hl, bc
t_states(7);
sbc_16(rHL, rBC);
break;
case 0x43: // ld (**), bc
addr = arg_16();
write_16(addr, rBC);
break;
case 0x44: // neg
neg();
break;
case 0x45: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x46: // im 0
S(IM) = 0;
break;
case 0x47: // ld i, a
t_states(1);
rI = rA;
break;
case 0x48: // in c, (c)
rC = in(rBC);
in_f(rC);
break;
case 0x49: // out (c), c
out(rBC, rC);
break;
case 0x4A: // adc hl, bc
t_states(7);
adc_16(rHL, rBC);
break;
case 0x4B: // ld bc, (**)
addr = arg_16();
rBC = read_16(addr);
break;
case 0x4C: // neg
neg();
break;
case 0x4D: // reti
rPC = pop_16();
break;
case 0x4E: // im 0/1
S(IM) = 0;
break;
case 0x4F: // ld r, a
t_states(1);
rR = rA;
break;
case 0x50: // in d, (c)
rD = in(rBC);
in_f(rD);
break;
case 0x51: // out (c), d
out(rBC, rD);
break;
case 0x52: // sbc hl, de
t_states(7);
sbc_16(rHL, rDE);
break;
case 0x53: // ld (**), de
addr = arg_16();
write_16(addr, rDE);
break;
case 0x54: // neg
neg();
break;
case 0x55: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x56: // im 1
S(IM) = 1;
break;
case 0x57: // ld a, i
t_states(1);
rA = rI;
ld_f(rA);
break;
case 0x58: // in e, (c)
rE = in(rBC);
in_f(rE);
break;
case 0x59: // out (c), e
out(rBC, rE);
break;
case 0x5A: // adc hl, de
t_states(7);
adc_16(rHL, rDE);
break;
case 0x5B: // ld de, (**)
addr = arg_16();
rDE = read_16(addr);
break;
case 0x5C: // neg
neg();
break;
case 0x5D: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x5E: // im 2
S(IM) = 2;
break;
case 0x5F: // ld a, r
t_states(1);
rA = rR;
ld_f(rA);
break;
case 0x60: // in h, (c)
rH = in(rBC);
in_f(rH);
break;
case 0x61: // out (c), h
out(rBC, rH);
break;
case 0x62: // sbc hl, hl
t_states(7);
sbc_16(rHL, rHL);
break;
case 0x63: // ld (**), hl
addr = arg_16();
write_16(addr, rHL);
break;
case 0x64: // neg
neg();
break;
case 0x65: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x66: // im 0
S(IM) = 0;
break;
case 0x67: // rrd
tmp = read(rHL);
t_states(4);
rrd(tmp);
write(rHL, tmp);
break;
case 0x68: // in l, (c)
rL = in(rBC);
in_f(rL);
break;
case 0x69: // out (c), l
out(rBC, rL);
break;
case 0x6A: // adc hl, hl
t_states(7);
adc_16(rHL, rHL);
break;
case 0x6B: // ld hl, (**)
addr = arg_16();
rHL = read_16(addr);
break;
case 0x6C: // neg
neg();
break;
case 0x6D: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x6E: // im 0/1
S(IM) = 0;
break;
case 0x6F: // rld
tmp = read(rHL);
t_states(4);
rld(tmp);
write(rHL, tmp);
break;
case 0x70: // in (c)
tmp = in(rBC);
in_f(tmp);
break;
case 0x71: // out (c), 0
out(rBC, 0);
break;
case 0x72: // sbc hl, sp
t_states(7);
sbc_16(rHL, rSP);
break;
case 0x73: // ld (**), sp
addr = arg_16();
write_16(addr, rSP);
break;
case 0x74: // neg
neg();
break;
case 0x75: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x76: // im 1
S(IM) = 1;
break;
case 0x78: // in a, (c)
rA = in(rBC);
in_f(rA);
break;
case 0x79: // out (c), a
out(rBC, rA);
break;
case 0x7A: // adc hl, sp
t_states(7);
adc_16(rHL, rSP);
break;
case 0x7B: // ld sp, (**)
addr = arg_16();
rSP = read_16(addr);
break;
case 0x7C: // neg
neg();
break;
case 0x7D: // retn
S(IFF1) = S(IFF2);
rPC = pop_16();
break;
case 0x7E: // im 2
S(IM) = 2;
break;
case 0xA0: // ldi
tmp = read(rHL++);
write(rDE++, tmp);
t_states(2);
rBC--;
ldr_f(tmp);
break;
case 0xA1: // cpi
tmp = read(rHL++);
t_states(5);
rBC--;
cpr_f(tmp);
break;
case 0xA2: // ini
t_states(1);
tmp = in(rBC);
write(rHL++, tmp);
rB--;
inir_f(tmp);
break;
case 0xA3: // outi
t_states(1);
tmp = read(rHL++);
rB--;
out(rBC, tmp);
outr_f(tmp);
break;
case 0xA8: // ldd
tmp = read(rHL--);
write(rDE--, tmp);
t_states(2);
rBC--;
ldr_f(tmp);
break;
case 0xA9: // cpd
tmp = read(rHL--);
t_states(5);
rBC--;
cpr_f(tmp);
break;
case 0xAA: // ind
t_states(1);
tmp = in(rBC);
write(rHL--, tmp);
rB--;
indr_f(tmp);
break;
case 0xAB: // outd
t_states(1);
tmp = read(rHL--);
rB--;
out(rBC, tmp);
outr_f(tmp);
break;
case 0xB0: // ldir
tmp = read(rHL++);
write(rDE++, tmp);
t_states(2);
rBC--;
ldr_f(tmp);
if (rBC) {
t_states(5);
rep();
}
break;
case 0xB1: // cpir
tmp = read(rHL++);
t_states(5);
rBC--;
cpr_f(tmp);
if (rBC && !(rF & fZ)) {
t_states(5);
rep();
}
break;
case 0xB2: // inir
t_states(1);
tmp = in(rBC);
write(rHL++, tmp);
rB--;
inir_f(tmp);
if (rB) {
t_states(5);
rep();
}
break;
case 0xB3: // otir
t_states(1);
tmp = read(rHL++);
rB--;
out(rBC, tmp);
outr_f(tmp);
if (rB) {
t_states(5);
rep();
}
break;
case 0xB8: // lddr
tmp = read(rHL--);
write(rDE--, tmp);
t_states(2);
rBC--;
ldr_f(tmp);
if (rBC) {
t_states(5);
rep();
}
break;
case 0xB9: // cpdr
tmp = read(rHL--);
t_states(5);
rBC--;
cpr_f(tmp);
if (rBC && !(rF & fZ)) {
t_states(5);
rep();
}
break;
case 0xBA: // indr
t_states(1);
tmp = in(rBC);
write(rHL--, tmp);
rB--;
indr_f(tmp);
if (rB) {
t_states(5);
rep();
}
break;
case 0xBB: // otdr
t_states(1);
tmp = read(rHL--);
rB--;
out(rBC, tmp);
outr_f(tmp);
if (rB) {
t_states(5);
rep();
}
break;
}
}
static cdk_error_t
read_signature (cdk_stream_t inp, size_t pktlen, cdk_pkt_signature_t sig)
{
size_t nbytes;
size_t i, size, nsig;
cdk_error_t rc;
if (!inp || !sig)
return CDK_Inv_Value;
if (DEBUG_PKT)
_cdk_log_debug ("read_signature: %d octets\n", pktlen);
if (pktlen < 16)
return CDK_Inv_Packet;
sig->version = cdk_stream_getc (inp);
if (sig->version < 2 || sig->version > 4)
return CDK_Inv_Packet_Ver;
sig->flags.exportable = 1;
sig->flags.revocable = 1;
if (sig->version < 4)
{
if (cdk_stream_getc (inp) != 5)
return CDK_Inv_Packet;
sig->sig_class = cdk_stream_getc (inp);
sig->timestamp = read_32 (inp);
sig->keyid[0] = read_32 (inp);
sig->keyid[1] = read_32 (inp);
sig->pubkey_algo = _pgp_pub_algo_to_cdk (cdk_stream_getc (inp));
sig->digest_algo = _pgp_hash_algo_to_gnutls (cdk_stream_getc (inp));
sig->digest_start[0] = cdk_stream_getc (inp);
sig->digest_start[1] = cdk_stream_getc (inp);
nsig = cdk_pk_get_nsig (sig->pubkey_algo);
if (!nsig)
return CDK_Inv_Algo;
for (i = 0; i < nsig; i++)
{
rc = read_mpi (inp, &sig->mpi[i], 0);
if (rc)
return rc;
}
}
else
{
sig->sig_class = cdk_stream_getc (inp);
sig->pubkey_algo = _pgp_pub_algo_to_cdk (cdk_stream_getc (inp));
sig->digest_algo = _pgp_hash_algo_to_gnutls (cdk_stream_getc (inp));
sig->hashed_size = read_16 (inp);
size = sig->hashed_size;
sig->hashed = NULL;
while (size > 0)
{
rc = read_subpkt (inp, &sig->hashed, &nbytes);
if (rc)
return rc;
size -= nbytes;
}
sig->unhashed_size = read_16 (inp);
size = sig->unhashed_size;
sig->unhashed = NULL;
while (size > 0)
{
rc = read_subpkt (inp, &sig->unhashed, &nbytes);
if (rc)
return rc;
size -= nbytes;
}
rc = parse_sig_subpackets (sig);
if (rc)
return rc;
sig->digest_start[0] = cdk_stream_getc (inp);
sig->digest_start[1] = cdk_stream_getc (inp);
nsig = cdk_pk_get_nsig (sig->pubkey_algo);
if (!nsig)
return CDK_Inv_Algo;
for (i = 0; i < nsig; i++)
{
rc = read_mpi (inp, &sig->mpi[i], 0);
if (rc)
return rc;
}
}
return 0;
}
static cdk_error_t
read_secret_key (cdk_stream_t inp, size_t pktlen, cdk_pkt_seckey_t sk)
{
size_t p1, p2, nread;
int i, nskey;
int rc;
if (!inp || !sk || !sk->pk)
return CDK_Inv_Value;
if (DEBUG_PKT)
_cdk_log_debug ("read_secret_key: %d octets\n", pktlen);
p1 = cdk_stream_tell (inp);
rc = read_public_key (inp, pktlen, sk->pk);
if (rc)
return rc;
sk->s2k_usage = cdk_stream_getc (inp);
sk->protect.sha1chk = 0;
if (sk->s2k_usage == 254 || sk->s2k_usage == 255)
{
sk->protect.sha1chk = (sk->s2k_usage == 254);
sk->protect.algo = _pgp_cipher_to_gnutls (cdk_stream_getc (inp));
sk->protect.s2k = cdk_calloc (1, sizeof *sk->protect.s2k);
if (!sk->protect.s2k)
return CDK_Out_Of_Core;
rc = read_s2k (inp, sk->protect.s2k);
if (rc)
return rc;
/* refer to --export-secret-subkeys in gpg(1) */
if (sk->protect.s2k->mode == CDK_S2K_GNU_EXT)
sk->protect.ivlen = 0;
else
{
sk->protect.ivlen =
_gnutls_cipher_get_block_size (sk->protect.algo);
if (!sk->protect.ivlen)
return CDK_Inv_Packet;
rc = stream_read (inp, sk->protect.iv, sk->protect.ivlen, &nread);
if (rc)
return rc;
if (nread != sk->protect.ivlen)
return CDK_Inv_Packet;
}
}
else
sk->protect.algo = _pgp_cipher_to_gnutls (sk->s2k_usage);
if (sk->protect.algo == GNUTLS_CIPHER_NULL)
{
sk->csum = 0;
nskey = cdk_pk_get_nskey (sk->pk->pubkey_algo);
if (!nskey)
{
gnutls_assert ();
return CDK_Inv_Algo;
}
for (i = 0; i < nskey; i++)
{
rc = read_mpi (inp, &sk->mpi[i], 1);
if (rc)
return rc;
}
sk->csum = read_16 (inp);
sk->is_protected = 0;
}
else if (sk->pk->version < 4)
{
/* The length of each multiprecision integer is stored in plaintext. */
nskey = cdk_pk_get_nskey (sk->pk->pubkey_algo);
if (!nskey)
{
gnutls_assert ();
return CDK_Inv_Algo;
}
for (i = 0; i < nskey; i++)
{
rc = read_mpi (inp, &sk->mpi[i], 1);
if (rc)
return rc;
}
sk->csum = read_16 (inp);
sk->is_protected = 1;
}
else
{
/* We need to read the rest of the packet because we do not
have any information how long the encrypted mpi's are */
p2 = cdk_stream_tell (inp);
p2 -= p1;
sk->enclen = pktlen - p2;
if (sk->enclen < 2)
return CDK_Inv_Packet; /* at least 16 bits for the checksum! */
sk->encdata = cdk_calloc (1, sk->enclen + 1);
if (!sk->encdata)
return CDK_Out_Of_Core;
if (stream_read (inp, sk->encdata, sk->enclen, &nread))
return CDK_Inv_Packet;
/* Handle the GNU S2K extensions we know (just gnu-dummy right now): */
if (sk->protect.s2k->mode == CDK_S2K_GNU_EXT)
{
unsigned char gnumode;
if ((sk->enclen < strlen ("GNU") + 1) ||
(0 != memcmp ("GNU", sk->encdata, strlen ("GNU"))))
return CDK_Inv_Packet;
gnumode = sk->encdata[strlen ("GNU")];
/* we only handle gnu-dummy (mode 1).
mode 2 should refer to external smart cards.
*/
if (gnumode != 1)
return CDK_Inv_Packet;
/* gnu-dummy should have no more data */
if (sk->enclen != strlen ("GNU") + 1)
return CDK_Inv_Packet;
}
nskey = cdk_pk_get_nskey (sk->pk->pubkey_algo);
if (!nskey)
{
gnutls_assert ();
return CDK_Inv_Algo;
}
/* We mark each MPI entry with NULL to indicate a protected key. */
for (i = 0; i < nskey; i++)
sk->mpi[i] = NULL;
sk->is_protected = 1;
}
sk->is_primary = 1;
_cdk_copy_pk_to_sk (sk->pk, sk);
return 0;
}
int main(int argc, char **argv)
{
FILE *classfile;
u_int16_t cp_count, i, this_class, classinfo_ptr;
u_int8_t length;
program = argv[0];
if(!argv[1])
error("%s: Missing input file\n", program);
classfile = fopen(argv[1], "rb");
if(!classfile)
error("%s: Error opening %s\n", program, argv[1]);
if(fseek(classfile, 8, SEEK_SET)) /* skip magic and version numbers */
seek_error();
cp_count = read_16(classfile);
pool = calloc(cp_count, sizeof(long));
if(!pool)
error("%s: Out of memory for constant pool\n", program);
for(i = 1; i < cp_count; ++i)
skip_constant(classfile, &i);
if(fseek(classfile, 2, SEEK_CUR)) /* skip access flags */
seek_error();
this_class = read_16(classfile);
if(this_class < 1 || this_class >= cp_count)
corrupt_error();
if(!pool[this_class] || pool[this_class] == -1)
corrupt_error();
if(fseek(classfile, pool[this_class] + 1, SEEK_SET))
seek_error();
classinfo_ptr = read_16(classfile);
if(classinfo_ptr < 1 || classinfo_ptr >= cp_count)
corrupt_error();
if(!pool[classinfo_ptr] || pool[classinfo_ptr] == -1)
corrupt_error();
if(fseek(classfile, pool[classinfo_ptr] + 1, SEEK_SET))
seek_error();
length = read_16(classfile);
for(i = 0; i < length; ++i)
{
u_int8_t x = read_8(classfile);
if((x & 0x80) || !x)
{
if((x & 0xE0) == 0xC0)
{
u_int8_t y = read_8(classfile);
if((y & 0xC0) == 0x80)
{
int c = ((x & 0x1f) << 6) + (y & 0x3f);
if(c) putchar(c);
else utf8_error();
}
else utf8_error();
}
else utf8_error();
}
else if(x == '/') putchar('.');
else putchar(x);
}
putchar('\n');
free(pool);
fclose(classfile);
return 0;
}
int m7700_disassemble(char* buff, unsigned int pc, unsigned int pb, const UINT8 *oprom, int m_flag, int x_flag)
{
unsigned int instruction;
const m7700_opcode_struct *opcode;
char* ptr;
int var;
signed char varS;
int length = 1;
unsigned int address;
//unsigned int start;
UINT32 flags = 0;
pb <<= 16;
address = pc | pb;
//start = address;
instruction = read_8(oprom,0);
// check for prefixes
switch (instruction)
{
case 0x42:
address++;
length++;
oprom++;
instruction = read_8(oprom,0);
opcode = &m7700_opcode_struct::get_prefix42(instruction);
break;
case 0x89:
address++;
length++;
oprom++;
instruction = read_8(oprom,0);
opcode = &m7700_opcode_struct::get_prefix89(instruction);
break;
default:
opcode = &m7700_opcode_struct::get(instruction);
break;
}
if (opcode->is_call())
flags = DASMFLAG_STEP_OVER;
else if (opcode->is_return())
flags = DASMFLAG_STEP_OUT;
sprintf(buff, "%s", opcode->name());
ptr = buff + strlen(buff);
switch(opcode->ea)
{
case IMP :
break;
case ACC :
sprintf(ptr, " A");
break;
case ACCB :
sprintf(ptr, " B");
break;
case RELB:
varS = read_8(oprom,1);
length++;
sprintf(ptr, " %06x (%s)", pb | ((pc + length + varS)&0xffff), int_8_str(varS));
break;
case RELW:
case PER :
var = read_16(oprom,1);
length += 2;
sprintf(ptr, " %06x (%s)", pb | ((pc + length + var)&0xffff), int_16_str(var));
break;
case IMM :
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x", read_16(oprom,1));
length += 2;
}
else
{
sprintf(ptr, " #$%02x", read_8(oprom,1));
length++;
}
break;
case BBCD:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
varS = read_8(oprom,4);
length += 4;
sprintf(ptr, " #$%04x, $%02x, %06x (%s)", read_16(oprom,2), read_8(oprom,1), pb | ((pc + length + varS)&0xffff), int_8_str(varS));
}
else
{
varS = read_8(oprom,3);
length += 3;
sprintf(ptr, " #$%02x, $%02x, %06x (%s)", read_8(oprom,2), read_8(oprom,1), pb | ((pc + length + varS)&0xffff), int_8_str(varS));
}
break;
case BBCA:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
length += 5;
varS = read_8(oprom,5);
sprintf(ptr, " #$%04x, $%04x, %06x (%s)", read_16(oprom,3), read_16(oprom,1), pb | ((pc + length + varS)&0xffff), int_8_str(varS));
}
else
{
length += 4;
varS = read_8(oprom,4);
sprintf(ptr, " #$%02x, $%04x, %06x (%s)", read_8(oprom,3), read_16(oprom,1), pb | ((pc + length + varS)&0xffff), int_8_str(varS));
}
break;
case LDM4:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x, $%02x", read_16(oprom,2), read_8(oprom,1));
length += 3;
}
else
{
sprintf(ptr, " #$%02x, $%02x", read_8(oprom,2), read_8(oprom,1));
length += 2;
}
break;
case LDM5:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x, $%04x", read_16(oprom,3), read_16(oprom,1));
length += 4;
}
else
{
sprintf(ptr, " #$%02x, $%04x", read_8(oprom,3), read_16(oprom,1));
length += 3;
}
break;
case LDM4X:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x, $%02x, X", read_16(oprom,2), read_8(oprom,1));
length += 3;
}
else
{
sprintf(ptr, " #$%02x, $%02x, X", read_8(oprom,2), read_8(oprom,1));
length += 2;
}
break;
case LDM5X:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x, $%04x, X", read_16(oprom,3), read_16(oprom,1));
length += 4;
}
else
{
sprintf(ptr, " #$%02x, $%04x, X", read_8(oprom,3), read_16(oprom,1));
length += 3;
}
break;
case A :
case PEA :
sprintf(ptr, " $%04x", read_16(oprom,1));
length += 2;
break;
case AI :
sprintf(ptr, " ($%04x)", read_16(oprom,1));
length += 2;
break;
case AL :
sprintf(ptr, " $%06x", read_24(oprom,1));
length += 3;
break;
case ALX :
sprintf(ptr, " $%06x,X", read_24(oprom,1));
length += 3;
break;
case AX :
sprintf(ptr, " $%04x,X", read_16(oprom,1));
length += 2;
break;
case AXI :
sprintf(ptr, " ($%04x,X)", read_16(oprom,1));
length += 2;
break;
case AY :
sprintf(ptr, " $%04x,Y", read_16(oprom,1));
length += 2;
break;
case D :
sprintf(ptr, " $%02x", read_8(oprom,1));
length++;
break;
case DI :
case PEI :
sprintf(ptr, " ($%02x)", read_8(oprom,1));
length++;
break;
case DIY :
sprintf(ptr, " ($%02x),Y", read_8(oprom,1));
length++;
break;
case DLI :
sprintf(ptr, " [$%02x]", read_8(oprom,1));
length++;
break;
case DLIY:
sprintf(ptr, " [$%02x],Y", read_8(oprom,1));
length++;
break;
case DX :
sprintf(ptr, " $%02x,X", read_8(oprom,1));
length++;
break;
case DXI :
sprintf(ptr, " ($%02x,X)", read_8(oprom,1));
length++;
break;
case DY :
sprintf(ptr, " $%02x,Y", read_8(oprom,1));
length++;
break;
case S :
sprintf(ptr, " %s,S", int_8_str(read_8(oprom,1)));
length++;
break;
case SIY :
sprintf(ptr, " (%s,S),Y", int_8_str(read_8(oprom,1)));
length++;
break;
case SIG :
sprintf(ptr, " #$%02x", read_8(oprom,1));
length++;
break;
case MVN :
case MVP :
sprintf(ptr, " $%02x, $%02x", read_8(oprom,2), read_8(oprom,1));
length += 2;
break;
}
return length | flags | DASMFLAG_SUPPORTED;
}
static unsigned char *
handle_attributes (DebuginfoData *data, unsigned char *ptr, struct abbrev_tag *t, GHashTable *files, GError **error)
{
int i;
uint32_t list_offs;
int found_list_offs;
g_autofree char *comp_dir = NULL;
comp_dir = NULL;
list_offs = 0;
found_list_offs = 0;
for (i = 0; i < t->nattr; ++i)
{
uint32_t form = t->attr[i].form;
size_t len = 0;
while (1)
{
if (t->attr[i].attr == DW_AT_stmt_list)
{
if (form == DW_FORM_data4 ||
form == DW_FORM_sec_offset)
{
list_offs = do_read_32_relocated (ptr);
found_list_offs = 1;
}
}
if (t->attr[i].attr == DW_AT_comp_dir)
{
if (form == DW_FORM_string)
{
g_free (comp_dir);
comp_dir = g_strdup ((char *) ptr);
}
else if (form == DW_FORM_strp &&
data->debug_sections[DEBUG_STR].data)
{
char *dir;
dir = (char *) data->debug_sections[DEBUG_STR].data
+ do_read_32_relocated (ptr);
g_free (comp_dir);
comp_dir = g_strdup (dir);
}
}
else if ((t->tag == DW_TAG_compile_unit ||
t->tag == DW_TAG_partial_unit) &&
t->attr[i].attr == DW_AT_name &&
form == DW_FORM_strp &&
data->debug_sections[DEBUG_STR].data)
{
char *name;
name = (char *) data->debug_sections[DEBUG_STR].data
+ do_read_32_relocated (ptr);
if (*name == '/' && comp_dir == NULL)
{
char *enddir = strrchr (name, '/');
if (enddir != name)
{
comp_dir = g_malloc (enddir - name + 1);
memcpy (comp_dir, name, enddir - name);
comp_dir[enddir - name] = '\0';
}
else
{
comp_dir = g_strdup ("/");
}
}
}
switch (form)
{
case DW_FORM_ref_addr:
if (cu_version == 2)
ptr += ptr_size;
else
ptr += 4;
break;
case DW_FORM_flag_present:
break;
case DW_FORM_addr:
ptr += ptr_size;
break;
case DW_FORM_ref1:
case DW_FORM_flag:
case DW_FORM_data1:
++ptr;
break;
case DW_FORM_ref2:
case DW_FORM_data2:
ptr += 2;
break;
case DW_FORM_ref4:
case DW_FORM_data4:
case DW_FORM_sec_offset:
ptr += 4;
break;
case DW_FORM_ref8:
case DW_FORM_data8:
case DW_FORM_ref_sig8:
ptr += 8;
break;
case DW_FORM_sdata:
case DW_FORM_ref_udata:
case DW_FORM_udata:
(void) read_uleb128 (ptr);
break;
case DW_FORM_strp:
ptr += 4;
break;
case DW_FORM_string:
ptr = (unsigned char *) strchr ((char *) ptr, '\0') + 1;
break;
case DW_FORM_indirect:
form = read_uleb128 (ptr);
continue;
case DW_FORM_block1:
len = *ptr++;
break;
case DW_FORM_block2:
len = read_16 (ptr);
form = DW_FORM_block1;
break;
case DW_FORM_block4:
len = read_32 (ptr);
form = DW_FORM_block1;
break;
case DW_FORM_block:
case DW_FORM_exprloc:
len = read_uleb128 (ptr);
form = DW_FORM_block1;
g_assert (len < UINT_MAX);
break;
default:
g_warning ("%s: Unknown DWARF DW_FORM_%d", data->filename, form);
return NULL;
}
if (form == DW_FORM_block1)
ptr += len;
break;
}
}
/* Ensure the CU current directory will exist even if only empty. Source
filenames possibly located in its parent directories refer relatively to
it and the debugger (GDB) cannot safely optimize out the missing
CU current dir subdirectories. */
if (comp_dir)
g_hash_table_insert (files, g_strdup (comp_dir), NULL);
if (found_list_offs &&
!handle_dwarf2_line (data, list_offs, comp_dir, files, error))
return NULL;
return ptr;
}
unsigned g65816_disassemble(char* buff, unsigned int pc, unsigned int pb, const UINT8 *oprom, int m_flag, int x_flag)
{
unsigned int instruction;
const opcode_struct* opcode;
char* ptr;
int var;
int length = 1;
unsigned int address;
unsigned dasm_flags;
pb <<= 16;
address = pc | pb;
base_oprom = oprom;
base_pc = address;
instruction = read_8(address);
opcode = g_opcodes + instruction;
strcpy(buff, g_opnames[opcode->name]);
ptr = buff + strlen(buff);
switch(opcode->name)
{
case JSR:
case JSL:
dasm_flags = DASMFLAG_STEP_OVER;
break;
case RTI:
case RTL:
case RTS:
dasm_flags = DASMFLAG_STEP_OUT;
break;
default:
dasm_flags = 0;
break;
}
switch(opcode->ea)
{
case IMP :
break;
case ACC :
sprintf(ptr, "A");
break;
case RELB:
var = (INT8) read_8(address+1);
length++;
sprintf(ptr, " %06x (%s)", pb | ((pc + length + var)&0xffff), int_8_str(var));
break;
case RELW:
case PER :
var = read_16(address+1);
sprintf(ptr, " %06x (%s)", pb | ((pc + 1 + var)&0xffff), int_16_str(var));
length += 2;
break;
case IMM :
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x", read_16(address+1));
length += 2;
}
else
{
sprintf(ptr, " #$%02x", read_8(address+1));
length++;
}
break;
case A :
case PEA :
sprintf(ptr, " $%04x", read_16(address+1));
length += 2;
break;
case AI :
sprintf(ptr, " ($%04x)", read_16(address+1));
length += 2;
break;
case AL :
sprintf(ptr, " $%06x", read_24(address+1));
length += 3;
break;
case ALX :
sprintf(ptr, " $%06x,X", read_24(address+1));
length += 3;
break;
case AX :
sprintf(ptr, " $%04x,X", read_16(address+1));
length += 2;
break;
case AXI :
sprintf(ptr, " ($%04x,X)", read_16(address+1));
length += 2;
break;
case AY :
sprintf(ptr, " $%04x,Y", read_16(address+1));
length += 2;
break;
case D :
sprintf(ptr, " $%02x", read_8(address+1));
length++;
break;
case DI :
case PEI :
sprintf(ptr, " ($%02x)", read_8(address+1));
length++;
break;
case DIY :
sprintf(ptr, " ($%02x),Y", read_8(address+1));
length++;
break;
case DLI :
sprintf(ptr, " [$%02x]", read_8(address+1));
length++;
break;
case DLIY:
sprintf(ptr, " [$%02x],Y", read_8(address+1));
length++;
break;
case DX :
sprintf(ptr, " $%02x,X", read_8(address+1));
length++;
break;
case DXI :
sprintf(ptr, " ($%02x,X)", read_8(address+1));
length++;
break;
case DY :
sprintf(ptr, " $%02x,Y", read_8(address+1));
length++;
break;
case S :
sprintf(ptr, " %s,S", int_8_str(read_8(address+1)));
length++;
break;
case SIY :
sprintf(ptr, " (%s,S),Y", int_8_str(read_8(address+1)));
length++;
break;
case SIG :
sprintf(ptr, " #$%02x", read_8(address+1));
length++;
break;
case MVN :
case MVP :
sprintf(ptr, " $%02x, $%02x", read_8(address+2), read_8(address+1));
length += 2;
break;
}
return length | DASMFLAG_SUPPORTED | dasm_flags;
}
static gboolean
handle_dwarf2_line (DebuginfoData *data, uint32_t off, char *comp_dir, GHashTable *files, GError **error)
{
unsigned char *ptr = data->debug_sections[DEBUG_LINE].data, *dir;
unsigned char **dirt;
unsigned char *endsec = ptr + data->debug_sections[DEBUG_LINE].size;
unsigned char *endcu, *endprol;
unsigned char opcode_base;
uint32_t value, dirt_cnt;
size_t comp_dir_len = !comp_dir ? 0 : strlen (comp_dir);
/* XXX: RhBug:929365, should we error out instead of ignoring? */
if (ptr == NULL)
return TRUE;
ptr += off;
endcu = ptr + 4;
endcu += read_32 (ptr);
if (endcu == ptr + 0xffffffff)
return flatpak_fail (error, "%s: 64-bit DWARF not supported", data->filename);
if (endcu > endsec)
return flatpak_fail (error, "%s: .debug_line CU does not fit into section", data->filename);
value = read_16 (ptr);
if (value != 2 && value != 3 && value != 4)
return flatpak_fail (error, "%s: DWARF version %d unhandled", data->filename, value);
endprol = ptr + 4;
endprol += read_32 (ptr);
if (endprol > endcu)
return flatpak_fail (error, "%s: .debug_line CU prologue does not fit into CU", data->filename);
opcode_base = ptr[4 + (value >= 4)];
ptr = dir = ptr + 4 + (value >= 4) + opcode_base;
/* dir table: */
value = 1;
while (*ptr != 0)
{
ptr = (unsigned char *) strchr ((char *) ptr, 0) + 1;
++value;
}
dirt = (unsigned char **) alloca (value * sizeof (unsigned char *));
dirt[0] = (unsigned char *) ".";
dirt_cnt = 1;
ptr = dir;
while (*ptr != 0)
{
dirt[dirt_cnt++] = ptr;
ptr = (unsigned char *) strchr ((char *) ptr, 0) + 1;
}
ptr++;
/* file table: */
while (*ptr != 0)
{
char *s, *file;
size_t file_len, dir_len;
file = (char *) ptr;
ptr = (unsigned char *) strchr ((char *) ptr, 0) + 1;
value = read_uleb128 (ptr);
if (value >= dirt_cnt)
return flatpak_fail (error, "%s: Wrong directory table index %u", data->filename, value);
file_len = strlen (file);
dir_len = strlen ((char *) dirt[value]);
s = g_malloc (comp_dir_len + 1 + file_len + 1 + dir_len + 1);
if (*file == '/')
{
memcpy (s, file, file_len + 1);
}
else if (*dirt[value] == '/')
{
memcpy (s, dirt[value], dir_len);
s[dir_len] = '/';
memcpy (s + dir_len + 1, file, file_len + 1);
}
else
{
char *p = s;
if (comp_dir_len != 0)
{
memcpy (s, comp_dir, comp_dir_len);
s[comp_dir_len] = '/';
p += comp_dir_len + 1;
}
memcpy (p, dirt[value], dir_len);
p[dir_len] = '/';
memcpy (p + dir_len + 1, file, file_len + 1);
}
canonicalize_path (s, s);
if (s)
g_hash_table_insert (files, s, NULL);
(void) read_uleb128 (ptr);
(void) read_uleb128 (ptr);
}
++ptr;
return TRUE;
}
int g65816_disassemble(char* buff, unsigned int pc, unsigned int pb, int m_flag, int x_flag)
{
unsigned int instruction;
opcode_struct* opcode;
char* ptr;
int var;
int length = 1;
unsigned int address;
pb <<= 16;
address = pc | pb;
instruction = read_8(address);
opcode = g_opcodes + instruction;
strcpy(buff, g_opnames[opcode->name]);
ptr = buff + strlen(buff);
switch(opcode->ea)
{
case IMP :
break;
case ACC :
sprintf(ptr, "A");
break;
case RELB:
var = read_8(address+1);
length++;
sprintf(ptr, " %06x (%s)", pb | ((pc + length + var)&0xffff), int_8_str(var));
break;
case RELW:
case PER :
var = read_16(address+1);
sprintf(ptr, " %06x (%s)", pb | ((pc + 1 + var)&0xffff), int_16_str(var));
length += 2;
break;
case IMM :
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x", read_16(address+1));
length += 2;
}
else
{
sprintf(ptr, " #$%02x", read_8(address+1));
length++;
}
break;
case A :
case PEA :
sprintf(ptr, " $%04x", read_16(address+1));
length += 2;
break;
case AI :
sprintf(ptr, " ($%04x)", read_16(address+1));
length += 2;
break;
case AL :
sprintf(ptr, " $%06x", read_24(address+1));
length += 3;
break;
case ALX :
sprintf(ptr, " $%06x,X", read_24(address+1));
length += 3;
break;
case AX :
sprintf(ptr, " $%04x,X", read_16(address+1));
length += 2;
break;
case AXI :
sprintf(ptr, " ($%04x,X)", read_16(address+1));
length += 2;
break;
case AY :
sprintf(ptr, " $%04x,Y", read_16(address+1));
length += 2;
break;
case D :
sprintf(ptr, " $%02x", read_8(address+1));
length++;
break;
case DI :
case PEI :
sprintf(ptr, " ($%02x)", read_8(address+1));
length++;
break;
case DIY :
sprintf(ptr, " ($%02x),Y", read_8(address+1));
length++;
break;
case DLI :
sprintf(ptr, " [$%02x]", read_8(address+1));
length++;
break;
case DLIY:
sprintf(ptr, " [$%02x],Y", read_8(address+1));
length++;
break;
case DX :
sprintf(ptr, " $%02x,X", read_8(address+1));
length++;
break;
case DXI :
sprintf(ptr, " ($%02x,X)", read_8(address+1));
length++;
break;
case DY :
sprintf(ptr, " $%02x,Y", read_8(address+1));
length++;
break;
case S :
sprintf(ptr, " %s,S", int_8_str(read_8(address+1)));
length++;
break;
case SIY :
sprintf(ptr, " (%s,S),Y", int_8_str(read_8(address+1)));
length++;
break;
case SIG :
sprintf(ptr, " #$%02x", read_8(address+1));
length++;
break;
case MVN :
case MVP :
sprintf(ptr, " $%02x, $%02x", read_8(address+2), read_8(address+1));
length += 2;
break;
}
return length;
}
static gboolean
handle_dwarf2_section (DebuginfoData *data, GHashTable *files, GError **error)
{
Elf_Data *e_data;
int i;
debug_section_t *debug_sections;
ptr_size = 0;
if (data->ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
{
do_read_16 = buf_read_ule16;
do_read_32 = buf_read_ule32;
}
else if (data->ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
{
do_read_16 = buf_read_ube16;
do_read_32 = buf_read_ube32;
}
else
{
return flatpak_fail (error, "%s: Wrong ELF data encoding", data->filename);
}
debug_sections = data->debug_sections;
if (debug_sections[DEBUG_INFO].data != NULL)
{
unsigned char *ptr, *endcu, *endsec;
uint32_t value;
struct abbrev_tag *t;
g_autofree REL *relbuf = NULL;
if (debug_sections[DEBUG_INFO].relsec)
{
Elf_Scn *scn;
int ndx, maxndx;
GElf_Rel rel;
GElf_Rela rela;
GElf_Sym sym;
GElf_Addr base = data->shdr[debug_sections[DEBUG_INFO].sec].sh_addr;
Elf_Data *symdata = NULL;
int rtype;
i = debug_sections[DEBUG_INFO].relsec;
scn = data->scns[i];
e_data = elf_getdata (scn, NULL);
g_assert (e_data != NULL && e_data->d_buf != NULL);
g_assert (elf_getdata (scn, e_data) == NULL);
g_assert (e_data->d_off == 0);
g_assert (e_data->d_size == data->shdr[i].sh_size);
maxndx = data->shdr[i].sh_size / data->shdr[i].sh_entsize;
relbuf = g_malloc (maxndx * sizeof (REL));
reltype = data->shdr[i].sh_type;
symdata = elf_getdata (data->scns[data->shdr[i].sh_link], NULL);
g_assert (symdata != NULL && symdata->d_buf != NULL);
g_assert (elf_getdata (data->scns[data->shdr[i].sh_link], symdata) == NULL);
g_assert (symdata->d_off == 0);
g_assert (symdata->d_size == data->shdr[data->shdr[i].sh_link].sh_size);
for (ndx = 0, relend = relbuf; ndx < maxndx; ++ndx)
{
if (data->shdr[i].sh_type == SHT_REL)
{
gelf_getrel (e_data, ndx, &rel);
rela.r_offset = rel.r_offset;
rela.r_info = rel.r_info;
rela.r_addend = 0;
}
else
{
gelf_getrela (e_data, ndx, &rela);
}
gelf_getsym (symdata, ELF64_R_SYM (rela.r_info), &sym);
/* Relocations against section symbols are uninteresting
in REL. */
if (data->shdr[i].sh_type == SHT_REL && sym.st_value == 0)
continue;
/* Only consider relocations against .debug_str, .debug_line
and .debug_abbrev. */
if (sym.st_shndx != debug_sections[DEBUG_STR].sec &&
sym.st_shndx != debug_sections[DEBUG_LINE].sec &&
sym.st_shndx != debug_sections[DEBUG_ABBREV].sec)
continue;
rela.r_addend += sym.st_value;
rtype = ELF64_R_TYPE (rela.r_info);
switch (data->ehdr.e_machine)
{
case EM_SPARC:
case EM_SPARC32PLUS:
case EM_SPARCV9:
if (rtype != R_SPARC_32 && rtype != R_SPARC_UA32)
goto fail;
break;
case EM_386:
if (rtype != R_386_32)
goto fail;
break;
case EM_PPC:
case EM_PPC64:
if (rtype != R_PPC_ADDR32 && rtype != R_PPC_UADDR32)
goto fail;
break;
case EM_S390:
if (rtype != R_390_32)
goto fail;
break;
case EM_IA_64:
if (rtype != R_IA64_SECREL32LSB)
goto fail;
break;
case EM_X86_64:
if (rtype != R_X86_64_32)
goto fail;
break;
case EM_ALPHA:
if (rtype != R_ALPHA_REFLONG)
goto fail;
break;
#if defined(EM_AARCH64) && defined(R_AARCH64_ABS32)
case EM_AARCH64:
if (rtype != R_AARCH64_ABS32)
goto fail;
break;
#endif
case EM_68K:
if (rtype != R_68K_32)
goto fail;
break;
default:
fail:
return flatpak_fail (error, "%s: Unhandled relocation %d in .debug_info section",
data->filename, rtype);
}
relend->ptr = debug_sections[DEBUG_INFO].data
+ (rela.r_offset - base);
relend->addend = rela.r_addend;
++relend;
}
if (relbuf == relend)
{
g_free (relbuf);
relbuf = NULL;
relend = NULL;
}
else
{
qsort (relbuf, relend - relbuf, sizeof (REL), rel_cmp);
}
}
ptr = debug_sections[DEBUG_INFO].data;
relptr = relbuf;
endsec = ptr + debug_sections[DEBUG_INFO].size;
while (ptr != NULL && ptr < endsec)
{
g_autoptr(GHashTable) abbrev = NULL;
if (ptr + 11 > endsec)
return flatpak_fail (error, "%s: .debug_info CU header too small", data->filename);
endcu = ptr + 4;
endcu += read_32 (ptr);
if (endcu == ptr + 0xffffffff)
return flatpak_fail (error, "%s: 64-bit DWARF not supported", data->filename);
if (endcu > endsec)
return flatpak_fail (error, "%s: .debug_info too small", data->filename);
cu_version = read_16 (ptr);
if (cu_version != 2 && cu_version != 3 && cu_version != 4)
return flatpak_fail (error, "%s: DWARF version %d unhandled", data->filename, cu_version);
value = read_32_relocated (ptr);
if (value >= debug_sections[DEBUG_ABBREV].size)
{
if (debug_sections[DEBUG_ABBREV].data == NULL)
return flatpak_fail (error, "%s: .debug_abbrev not present", data->filename);
else
return flatpak_fail (error, "%s: DWARF CU abbrev offset too large", data->filename);
}
if (ptr_size == 0)
{
ptr_size = read_1 (ptr);
if (ptr_size != 4 && ptr_size != 8)
return flatpak_fail (error, "%s: Invalid DWARF pointer size %d", data->filename, ptr_size);
}
else if (read_1 (ptr) != ptr_size)
{
return flatpak_fail (error, "%s: DWARF pointer size differs between CUs", data->filename);
}
abbrev = read_abbrev (data,
debug_sections[DEBUG_ABBREV].data + value);
while (ptr < endcu)
{
guint entry = read_uleb128 (ptr);
if (entry == 0)
continue;
t = g_hash_table_lookup (abbrev, GINT_TO_POINTER (entry));
if (t == NULL)
{
g_warning ("%s: Could not find DWARF abbreviation %d", data->filename, entry);
}
else
{
ptr = handle_attributes (data, ptr, t, files, error);
if (ptr == NULL)
return FALSE;
}
}
}
}
return TRUE;
}
bool globals_load(int32_t &addr)
{
bool change_hw = false;
uint8_t nt = read_8(addr);
uint8_t ng = read_8(addr);
// Free the old memory and initialize the new memory.
if (nt != num_temps) {
ldebug("new temp");
for (uint8_t t = nt; t < num_temps; ++t)
temps[t].free();
Temp *new_temps = new Temp[nt];
for (uint8_t t = 0; t < min(nt, num_temps); ++t)
temps[t].copy(new_temps[t]);
for (uint8_t t = num_temps; t < nt; ++t)
new_temps[t].init();
delete[] temps;
temps = new_temps;
num_temps = nt;
}
if (ng != num_gpios) {
for (uint8_t g = ng; g < num_gpios; ++g)
gpios[g].free();
Gpio *new_gpios = new Gpio[ng];
for (uint8_t g = 0; g < min(ng, num_gpios); ++g)
gpios[g].copy(new_gpios[g]);
for (uint8_t g = num_gpios; g < ng; ++g)
new_gpios[g].init();
delete[] gpios;
gpios = new_gpios;
num_gpios = ng;
}
ldebug("new done");
int p = led_pin.write();
led_pin.read(read_16(addr));
if (p != led_pin.write())
change_hw = true;
p = stop_pin.write();
stop_pin.read(read_16(addr));
if (p != stop_pin.write())
change_hw = true;
p = probe_pin.write();
probe_pin.read(read_16(addr));
if (p != probe_pin.write())
change_hw = true;
p = spiss_pin.write();
spiss_pin.read(read_16(addr));
if (p != spiss_pin.write())
change_hw = true;
int t = timeout;
timeout = read_16(addr);
if (t != timeout)
change_hw = true;
bed_id = read_16(addr);
fan_id = read_16(addr);
spindle_id = read_16(addr);
feedrate = read_float(addr);
if (isnan(feedrate) || isinf(feedrate) || feedrate <= 0)
feedrate = 1;
max_deviation = read_float(addr);
max_v = read_float(addr);
int ce = read_8(addr);
targetx = read_float(addr);
targety = read_float(addr);
double zo = read_float(addr);
if (motors_busy && (current_extruder != ce || zoffset != zo) && settings.queue_start == settings.queue_end && !settings.queue_full && !computing_move) {
queue[settings.queue_end].probe = false;
queue[settings.queue_end].cb = false;
queue[settings.queue_end].f[0] = INFINITY;
queue[settings.queue_end].f[1] = INFINITY;
for (int i = 0; i < spaces[0].num_axes; ++i) {
queue[settings.queue_end].data[i] = spaces[0].axis[i]->settings.current - (i == 2 ? zoffset : 0);
for (int s = 0; s < NUM_SPACES; ++s)
queue[settings.queue_end].data[i] = space_types[spaces[s].type].unchange0(&spaces[s], i, queue[settings.queue_end].data[i]);
}
for (int i = spaces[0].num_axes; i < QUEUE_LENGTH; ++i) {
queue[settings.queue_end].data[i] = NAN;
}
settings.queue_end = (settings.queue_end + 1) % QUEUE_LENGTH;
// This shouldn't happen and causes communication problems, but if you have a 1-item buffer it is correct.
if (settings.queue_end == settings.queue_start)
settings.queue_full = true;
current_extruder = ce;
zoffset = zo;
next_move();
buffer_refill();
}
else {
current_extruder = ce;
zoffset = zo;
}
bool store = read_8(addr);
if (store && !store_adc) {
store_adc = fopen("/tmp/franklin-adc-dump", "a");
}
else if (!store && store_adc) {
fclose(store_adc);
store_adc = NULL;
}
ldebug("all done");
if (change_hw)
arch_motors_change();
return true;
}
int m7700_disassemble(char* buff, unsigned int pc, unsigned int pb, int m_flag, int x_flag)
{
unsigned int instruction;
opcode_struct *opcode;
char* ptr;
int var;
signed char varS;
int length = 1;
unsigned int address;
pb <<= 16;
address = pc | pb;
instruction = read_8(address);
// check for prefixes
switch (instruction)
{
case 0x42:
address++;
length++;
instruction = read_8(address);
opcode = g_opcodes_prefix42 + instruction;
break;
case 0x89:
address++;
length++;
instruction = read_8(address);
opcode = g_opcodes_prefix89 + instruction;
break;
default:
opcode = g_opcodes + instruction;
break;
}
sprintf(buff, "%s", g_opnames[opcode->name]);
ptr = buff + strlen(buff);
switch(opcode->ea)
{
case IMP :
break;
case ACC :
sprintf(ptr, " A");
break;
case ACCB :
sprintf(ptr, " B");
break;
case RELB:
varS = read_8(address+1);
length++;
sprintf(ptr, " %06x (%s)", pb | ((pc + length + varS)&0xffff), int_8_str(varS));
break;
case RELW:
case PER :
var = read_16(address+1);
sprintf(ptr, " %06x (%s)", pb | ((pc + 1 + var)&0xffff), int_16_str(var));
length += 2;
break;
case IMM :
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x", read_16(address+1));
length += 2;
}
else
{
sprintf(ptr, " #$%02x", read_8(address+1));
length++;
}
break;
case BBCD:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
varS = read_8(address+4);
length += 4;
sprintf(ptr, " #$%04x, $%02x, %06x (%s)", read_16(address+2), read_8(address+1), pb | ((pc + length + varS)&0xffff), int_8_str(varS));
}
else
{
varS = read_8(address+3);
length += 3;
sprintf(ptr, " #$%02x, $%02x, %06x (%s)", read_8(address+2), read_8(address+1), pb | ((pc + length + varS)&0xffff), int_8_str(varS));
}
break;
case BBCA:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
length += 5;
varS = read_8(address+5);
sprintf(ptr, " #$%04x, $%04x, %06x (%s)", read_16(address+3), read_16(address+1), pb | ((pc + length + varS)&0xffff), int_8_str(varS));
}
else
{
length += 4;
varS = read_8(address+4);
sprintf(ptr, " #$%02x, $%04x, %06x (%s)", read_8(address+3), read_16(address+1), pb | ((pc + length + varS)&0xffff), int_8_str(varS));
}
break;
case LDM4:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x, $%02x", read_16(address+2), read_8(address+1));
length += 3;
}
else
{
sprintf(ptr, " #$%02x, $%02x", read_8(address+2), read_8(address+1));
length += 2;
}
break;
case LDM5:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x, $%04x", read_16(address+3), read_16(address+1));
length += 4;
}
else
{
sprintf(ptr, " #$%02x, $%04x", read_8(address+3), read_16(address+1));
length += 3;
}
break;
case LDM4X:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x, $%02x, X", read_16(address+2), read_8(address+1));
length += 3;
}
else
{
sprintf(ptr, " #$%02x, $%02x, X", read_8(address+2), read_8(address+1));
length += 2;
}
break;
case LDM5X:
if((opcode->flag == M && !m_flag) || (opcode->flag == X && !x_flag))
{
sprintf(ptr, " #$%04x, $%04x, X", read_16(address+3), read_16(address+1));
length += 4;
}
else
{
sprintf(ptr, " #$%02x, $%04x, X", read_8(address+3), read_16(address+1));
length += 3;
}
break;
case A :
case PEA :
sprintf(ptr, " $%04x", read_16(address+1));
length += 2;
break;
case AI :
sprintf(ptr, " ($%04x)", read_16(address+1));
length += 2;
break;
case AL :
sprintf(ptr, " $%06x", read_24(address+1));
length += 3;
break;
case ALX :
sprintf(ptr, " $%06x,X", read_24(address+1));
length += 3;
break;
case AX :
sprintf(ptr, " $%04x,X", read_16(address+1));
length += 2;
break;
case AXI :
sprintf(ptr, " ($%04x,X)", read_16(address+1));
length += 2;
break;
case AY :
sprintf(ptr, " $%04x,Y", read_16(address+1));
length += 2;
break;
case D :
sprintf(ptr, " $%02x", read_8(address+1));
length++;
break;
case DI :
case PEI :
sprintf(ptr, " ($%02x)", read_8(address+1));
length++;
break;
case DIY :
sprintf(ptr, " ($%02x),Y", read_8(address+1));
length++;
break;
case DLI :
sprintf(ptr, " [$%02x]", read_8(address+1));
length++;
break;
case DLIY:
sprintf(ptr, " [$%02x],Y", read_8(address+1));
length++;
break;
case DX :
sprintf(ptr, " $%02x,X", read_8(address+1));
length++;
break;
case DXI :
sprintf(ptr, " ($%02x,X)", read_8(address+1));
length++;
break;
case DY :
sprintf(ptr, " $%02x,Y", read_8(address+1));
length++;
break;
case S :
sprintf(ptr, " %s,S", int_8_str(read_8(address+1)));
length++;
break;
case SIY :
sprintf(ptr, " (%s,S),Y", int_8_str(read_8(address+1)));
length++;
break;
case SIG :
sprintf(ptr, " #$%02x", read_8(address+1));
length++;
break;
case MVN :
case MVP :
sprintf(ptr, " $%02x, $%02x", read_8(address+2), read_8(address+1));
length += 2;
break;
}
return length;
}
Buffer::ConstPointer
Buffer::read(uint16_t &out_value) const throw(KafkaError) {
out_value = *reinterpret_cast<const uint16_t *>(read_16());
return shared_from_this();
}
