Apple-2-Tools
/
regs
mirror of https://github.com/mrkite/regs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

initial import

This commit is contained in:
Sean 2018-08-19 17:24:54 -07:00
commit 2154a1a7e3
58 changed files with 10167 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.gitignore vendored Normal file
View File

@ -0,0 +1,7 @@
*.o
*.swp
*.map
seg*
2mg
omf
regs

312
2mg.c Normal file
View File

@ -0,0 +1,312 @@
/**
* @copyright 2018 Sean Kasun
* Extracts 2mg and other prodos disk images into a directory structure
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <ctype.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <argp.h>
#include <stdbool.h>
#include "handle.h"
static void doDirectory(uint16_t key, uint8_t *disk, uint32_t disklen,
int depth);
static void doEntry(uint8_t *entry, uint8_t *disk, uint32_t disklen,
int depth);
static void doFile(uint16_t key, uint32_t len, char *name, uint8_t *disk,
uint32_t disklen, int type);
static void doGSOS(uint16_t key, char *name, uint8_t *disk, uint32_t disklen,
int depth);
const char *argp_program_version = "2mg 0.2";
const char *argp_program_bug_address = "sean@seancode.com";
static char doc[] = "Extract ProDOS disk images";
static char args_doc[] = "DISKIMAGE";
static struct argp_option options[] = {
{"list", 'l', 0, 0, "List files"},
{ 0 }
};
struct arguments {
char *diskimage;
bool list;
};
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
struct arguments *arguments = state->input;
switch (key) {
case 'l':
arguments->list = true;
break;
case ARGP_KEY_ARG:
if (state->arg_num >= 1) {
argp_usage(state);
}
arguments->diskimage = arg;
break;
case ARGP_KEY_END:
if (state->arg_num < 1) {
argp_usage(state);
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static struct argp argp = { options, parse_opt, args_doc, doc };
int main(int argc, char **argv) {
struct arguments arguments;
arguments.list = false;
argp_parse(&argp, argc, argv, 0, 0, &arguments);
FILE *f = fopen(arguments.diskimage, "rb");
if (!f) {
fprintf(stderr, "Failed to open '%s'\n", arguments.diskimage);
return -1;
}
fseek(f, 0, SEEK_END);
size_t len = ftell(f);
fseek(f, 0, SEEK_SET);
if (len < 64) {
fprintf(stderr, "%s is not a valid disk image\n", argv[1]);
fclose(f);
return -1;
}
uint8_t *header = malloc(64);
fread(header, 64, 1, f);
uint32_t disklen = len;
uint32_t diskofs = 0;
if (r4(header) == fourcc("2IMG")) {
if (r32(header + 0xc) != 1) {
fprintf(stderr, "Not a ProDOS disk image\n");
fclose(f);
return -1;
}
disklen = r32(header + 0x14) * 512;
diskofs = r32(header + 0x18);
}
free(header);
fseek(f, diskofs, SEEK_SET);
uint8_t *disk = malloc(disklen);
fread(disk, disklen, 1, f);
fclose(f);
doDirectory(2, disk, disklen, arguments.list ? 0 : -1);
free(disk);
return 0;
}
static void readFilename(uint8_t *filename, uint8_t length, char *outname) {
for (int i = 0; i < length; i++) {
char ch = filename[i];
if (isalnum(ch) || ch == '_' || ch == '.' || ch == ' ') {
*outname++ = ch;
} else {
*outname++ = 'x';
char hi = ch >> 4;
char lo = ch & 0xf;
if (hi > 9) {
*outname++ = 'a' + (hi - 10);
} else {
*outname++ = '0' + hi;
}
if (lo > 9) {
*outname++ = '0' + (lo - 10);
} else {
*outname++ = '0' + lo;
}
}
}
*outname = 0;
}
static void indent(int depth) {
for (int i = 0; i < depth; i++) {
printf(" ");
}
}
static void doDirectory(uint16_t key, uint8_t *disk, uint32_t disklen,
int depth) {
uint8_t *block = disk + key * 512;
if ((block[4] & 0xf0) != 0xf0 && (block[4] & 0xf0) != 0xe0) {
fprintf(stderr, "Invalid ProDOS disk\n");
return;
}
char dirname[50];
readFilename(block + 5, block[4] & 0xf, dirname);
if (depth < 0) {
mkdir(dirname, 0777);
chdir(dirname);
} else {
indent(depth);
printf("%s <dir>\n", dirname);
}
uint8_t entryLength = block[0x23];
uint8_t entriesPerBlock = block[0x24];
uint16_t fileCount = r16(block + 0x25);
uint8_t *entry = block + entryLength + 4;
uint8_t curEntry = 1;
uint16_t curFile = 0;
while (curFile < fileCount) {
if (entry[0] != 0) {
doEntry(entry, disk, disklen, depth < 0 ? -1 : depth + 1);
curFile++;
}
curEntry++;
entry += entryLength;
if (curEntry == entriesPerBlock) {
curEntry = 0;
block = disk + r16(block + 2) * 512;
entry = block + 4;
}
}
if (depth < 0) {
chdir("..");
}
}
static void doEntry(uint8_t *entry, uint8_t *disk, uint32_t disklen,
int depth) {
uint16_t key = r16(entry + 0x11);
uint32_t eof = r24(entry + 0x15);
char filename[50];
readFilename(entry + 1, entry[0] & 0xf, filename);
switch (entry[0] & 0xf0) {
case 0x10: // seedling
case 0x20: // sapling
case 0x30: // tree
if (depth < 0) {
doFile(key, eof, filename, disk, disklen, entry[0] >> 4);
} else {
indent(depth);
printf("%s %d bytes\n", filename, eof);
}
break;
case 0x50:
doGSOS(key, filename, disk, disklen, depth);
break;
case 0xd0:
doDirectory(key, disk, disklen, depth < 0 ? -1 : depth + 1);
break;
default:
fprintf(stderr, "Unknown file type: %x\n", entry[0] & 0xf0);
return;
}
}
static void dumpSeedling(uint8_t *block, uint32_t len, FILE *f) {
if (block == NULL) {
fseek(f, len, SEEK_CUR);
} else {
fwrite(block, len, 1, f);
}
}
static void dumpSapling(uint8_t *index, uint32_t len, FILE *f, uint8_t *disk,
uint32_t disklen) {
if (index == NULL) {
fseek(f, len, SEEK_CUR);
return;
}
while (len > 0) {
uint16_t blockid = index[0] | (index[256] << 8);
uint8_t *block = NULL;
if (blockid && (blockid + 1) * 512 <= disklen) {
block = disk + blockid * 512;
}
uint32_t blen = len > 512 ? 512 : len;
dumpSeedling(block, blen, f);
len -= blen;
index++;
}
}
static void dumpTree(uint8_t *index, uint32_t len, FILE *f, uint8_t *disk,
uint32_t disklen) {
if (index == NULL) {
fseek(f, len, SEEK_CUR);
return;
}
while (len > 0) {
uint16_t blockid = index[0] | (index[256] << 8);
uint8_t *block = NULL;
if (blockid && (blockid + 1) * 512 <= disklen) {
block = disk + blockid * 512;
}
uint32_t blen = len > 256 * 512 ? 256 * 512 : len;
dumpSapling(block, blen, f, disk, disklen);
len -= blen;
index++;
}
}
static void doGSOS(uint16_t key, char *name, uint8_t *disk,
uint32_t disklen, int depth) {
uint8_t *block = disk + key * 512;
int type = *block;
uint16_t subkey = r16(block + 1);
uint32_t eof = r24(block + 5);
if (depth < 0) {
doFile(subkey, eof, name, disk, disklen, type);
}
char resname[50];
strncpy(resname, name, 50);
strncat(resname, ".res", 50);
block = disk + key * 512 + 0x100;
type = *block;
subkey = r16(block + 1);
uint32_t reof = r24(block + 5);
if (depth < 0) {
doFile(subkey, reof, resname, disk, disklen, type);
} else {
indent(depth);
printf("%s %d bytes resource: %d bytes\n", name, eof, reof);
}
}
static void doFile(uint16_t key, uint32_t len, char *name, uint8_t *disk,
uint32_t disklen, int type) {
uint8_t *block = disk + key * 512;
FILE *f = fopen(name, "wb");
if (!f) {
fprintf(stderr, "Failed to create '%s'\n", name);
return;
}
switch (type) {
case 1:
dumpSeedling(block, len, f);
break;
case 2:
dumpSapling(block, len, f, disk, disklen);
break;
case 3:
dumpTree(block, len, f, disk, disklen);
break;
}
fclose(f);
}

374
65816.h Normal file
View File

@ -0,0 +1,374 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* Defines the 65816 opcodes, their addressing modes, and sizes
*/
/**
Addressing modes:
imp implied
imm #$const (l)
immm #$const (l | h) if m16
immx #$const (l | h) if x16
imms #$const (l | h)
abs $addr (addrl | addrh)
abl $addr (addrl | addrh | bank)
abx $addr,x (addrl | addrh)
aby $addr,y (addrl | addrh)
ablx $addr,x (addrl | addrh | bank)
aix ($addr,x) (addrl | addrh)
zp $zp (offset)
zpx $zp,x (offset)
zpy $zp,y (offset)
zps $zp,s (offset)
ind ($addr) (addrl | addrh)
inz ($zp) (offset)
inl [$zp] (offset)
inx ($zp,x) (offset)
iny ($zp),y (offset)
inly [$zp],y (offset)
ins ($zp,s),y (offset)
rel $r (signed byte + pc)
rell $r (offsetl | offseth) + pc
bank $sb,$db (dstbnk | srcbnk)
db $op
dw $op
dd $op
*/
typedef enum {
IMP = 0,
IMM,
IMMM,
IMMX,
IMMS,
ABS,
ABL,
ABX,
ABY,
ABLX,
AIX,
ZP,
ZPX,
ZPY,
ZPS,
IND,
INZ,
INL,
INX,
INY,
INLY,
INS,
REL,
RELL,
BANK,
DB,
DW,
DD
} Address;
typedef enum {
BREAK = 0,
NORMAL = 1,
BRANCH = 2,
CALL = 3,
RETURN = 4,
JUMP = 5
} OpType;
typedef struct {
const char *inst;
Address address;
OpType type;
} Opcode;
static Opcode opcodes[] = {
{"brk", IMP, BREAK}, // 00
{"ora", INX, NORMAL}, // 01
{"cop", IMP, NORMAL}, // 02
{"ora", ZPS, NORMAL}, // 03
{"tsb", ZP, NORMAL}, // 04
{"ora", ZP, NORMAL}, // 05
{"asl", ZP, NORMAL}, // 06
{"ora", INL, NORMAL}, // 07
{"php", IMP, NORMAL}, // 08
{"ora", IMMM, NORMAL}, // 09
{"asl", IMP, NORMAL}, // 0a
{"phd", IMP, NORMAL}, // 0b
{"tsb", ABS, NORMAL}, // 0c
{"ora", ABS, NORMAL}, // 0d
{"asl", ABS, NORMAL}, // 0e
{"ora", ABL, NORMAL}, // 0f
{"bpl", REL, BRANCH}, // 10
{"ora", INY, NORMAL}, // 11
{"ora", INZ, NORMAL}, // 12
{"ora", INS, NORMAL}, // 13
{"trb", ZP, NORMAL}, // 14
{"ora", ZPX, NORMAL}, // 15
{"asl", ZPX, NORMAL}, // 16
{"ora", INLY, NORMAL}, // 17
{"clc", IMP, NORMAL}, // 18
{"ora", ABY, NORMAL}, // 19
{"inc", IMP, NORMAL}, // 1a
{"tcs", IMP, NORMAL}, // 1b
{"trb", ABS, NORMAL}, // 1c
{"ora", ABX, NORMAL}, // 1d
{"asl", ABX, NORMAL}, // 1e
{"ora", ABLX, NORMAL}, // 1f
{"jsr", ABS, CALL}, // 20
{"and", INX, NORMAL}, // 21
{"jsl", ABL, CALL}, // 22
{"and", ZPS, NORMAL}, // 23
{"bit", ZP, NORMAL}, // 24
{"and", ZP, NORMAL}, // 25
{"rol", ZP, NORMAL}, // 26
{"and", INL, NORMAL}, // 27
{"plp", IMP, NORMAL}, // 28
{"and", IMMM, NORMAL}, // 29
{"rol", IMP, NORMAL}, // 2a
{"pld", IMP, NORMAL}, // 2b
{"bit", ABS, NORMAL}, // 2c
{"and", ABS, NORMAL}, // 2d
{"rol", ABS, NORMAL}, // 2e
{"and", ABL, NORMAL}, // 2f
{"bmi", REL, BRANCH}, // 30
{"and", INY, NORMAL}, // 31
{"and", INZ, NORMAL}, // 32
{"and", INS, NORMAL}, // 33
{"bit", ZPX, NORMAL}, // 34
{"and", ZPX, NORMAL}, // 35
{"rol", ZPX, NORMAL}, // 36
{"and", INLY, NORMAL}, // 37
{"sec", IMP, NORMAL}, // 38
{"and", ABY, NORMAL}, // 39
{"dec", IMP, NORMAL}, // 3a
{"tsc", IMP, NORMAL}, // 3b
{"bit", ABX, NORMAL}, // 3c
{"and", ABX, NORMAL}, // 3d
{"rol", ABX, NORMAL}, // 3e
{"and", ABLX, NORMAL}, // 3f
{"rti", IMP, RETURN}, // 40
{"eor", INX, NORMAL}, // 41
{"db", DB, BREAK}, // 42
{"eor", ZPS, NORMAL}, // 43
{"mvp", BANK, NORMAL}, // 44
{"eor", ZP, NORMAL}, // 45
{"lsr", ZP, NORMAL}, // 46
{"eor", INL, NORMAL}, // 47
{"pha", IMP, NORMAL}, // 48
{"eor", IMMM, NORMAL}, // 49
{"lsr", IMP, NORMAL}, // 4a
{"phk", IMP, NORMAL}, // 4b
{"jmp", ABS, JUMP}, // 4c
{"eor", ABS, NORMAL}, // 4d
{"lsr", ABS, NORMAL}, // 4e
{"eor", ABL, NORMAL}, // 4f
{"bvc", REL, BRANCH}, // 50
{"eor", INY, NORMAL}, // 51
{"eor", INZ, NORMAL}, // 52
{"eor", INS, NORMAL}, // 53
{"mvn", BANK, NORMAL}, // 54
{"eor", ZPX, NORMAL}, // 55
{"lsr", ZPX, NORMAL}, // 56
{"eor", INLY, NORMAL}, // 57
{"cli", IMP, NORMAL}, // 58
{"eor", ABY, NORMAL}, // 59
{"phy", IMP, NORMAL}, // 5a
{"tcd", IMP, NORMAL}, // 5b
{"jmp", ABL, JUMP}, // 5c
{"eor", ABX, NORMAL}, // 5d
{"lsr", ABX, NORMAL}, // 5e
{"eor", ABLX, NORMAL}, // 5f
{"rts", IMP, RETURN}, // 60
{"adc", INX, NORMAL}, // 61
{"per", IMP, NORMAL}, // 62
{"adc", ZPS, NORMAL}, // 63
{"stz", ZP, NORMAL}, // 64
{"adc", ZP, NORMAL}, // 65
{"ror", ZP, NORMAL}, // 66
{"adc", INL, NORMAL}, // 67
{"pla", IMP, NORMAL}, // 68
{"adc", IMMM, NORMAL}, // 69
{"ror", IMP, NORMAL}, // 6a
{"rtl", IMP, RETURN}, // 6b
{"jmp", IND, JUMP}, // 6c
{"adc", ABS, NORMAL}, // 6d
{"ror", ABS, NORMAL}, // 6e
{"adc", ABL, NORMAL}, // 6f
{"bvs", REL, BRANCH}, // 70
{"adc", INY, NORMAL}, // 71
{"adc", INZ, NORMAL}, // 72
{"adc", INS, NORMAL}, // 73
{"stz", ZPX, NORMAL}, // 74
{"adc", ZPX, NORMAL}, // 75
{"ror", ZPX, NORMAL}, // 76
{"adc", INLY, NORMAL}, // 77
{"sei", IMP, NORMAL}, // 78
{"adc", ABY, NORMAL}, // 79
{"ply", IMP, NORMAL}, // 7a
{"tdc", IMP, NORMAL}, // 7b
{"jmp", AIX, JUMP}, // 7c
{"adc", ABX, NORMAL}, // 7d
{"ror", ABX, NORMAL}, // 7e
{"adc", ABLX, NORMAL}, // 7f
{"bra", REL, JUMP}, // 80
{"sta", INX, NORMAL}, // 81
{"brl", RELL, JUMP}, // 82
{"sta", ZPS, NORMAL}, // 83
{"sty", ZP, NORMAL}, // 84
{"sta", ZP, NORMAL}, // 85
{"stx", ZP, NORMAL}, // 86
{"sta", INL, NORMAL}, // 87
{"dey", IMP, NORMAL}, // 88
{"bit", IMMM, NORMAL}, // 89
{"txa", IMP, NORMAL}, // 8a
{"phb", IMP, NORMAL}, // 8b
{"sty", ABS, NORMAL}, // 8c
{"sta", ABS, NORMAL}, // 8d
{"stx", ABS, NORMAL}, // 8e
{"sta", ABL, NORMAL}, // 8f
{"bcc", REL, BRANCH}, // 90
{"sta", INY, NORMAL}, // 91
{"sta", INZ, NORMAL}, // 92
{"sta", INS, NORMAL}, // 93
{"sty", ZPX, NORMAL}, // 94
{"sta", ZPX, NORMAL}, // 95
{"stx", ZPY, NORMAL}, // 96
{"sta", INLY, NORMAL}, // 97
{"tya", IMP, NORMAL}, // 98
{"sta", ABY, NORMAL}, // 99
{"txs", IMP, NORMAL}, // 9a
{"txy", IMP, NORMAL}, // 9b
{"stz", ABS, NORMAL}, // 9c
{"sta", ABX, NORMAL}, // 9d
{"stz", ABX, NORMAL}, // 9e
{"sta", ABLX, NORMAL}, // 9f
{"ldy", IMMX, NORMAL}, // a0
{"lda", INX, NORMAL}, // a1
{"ldx", IMMX, NORMAL}, // a2
{"lda", ZPS, NORMAL}, // a3
{"ldy", ZP, NORMAL}, // a4
{"lda", ZP, NORMAL}, // a5
{"ldx", ZP, NORMAL}, // a6
{"lda", INL, NORMAL}, // a7
{"tay", IMP, NORMAL}, // a8
{"lda", IMMM, NORMAL}, // a9
{"tax", IMP, NORMAL}, // aa
{"plb", IMP, NORMAL}, // ab
{"ldy", ABS, NORMAL}, // ac
{"lda", ABS, NORMAL}, // ad
{"ldx", ABS, NORMAL}, // ae
{"lda", ABL, NORMAL}, // af
{"bcs", REL, BRANCH}, // b0
{"lda", INY, NORMAL}, // b1
{"lda", INZ, NORMAL}, // b2
{"lda", INS, NORMAL}, // b3
{"ldy", ZPX, NORMAL}, // b4
{"lda", ZPX, NORMAL}, // b5
{"ldx", ZPY, NORMAL}, // b6
{"lda", INLY, NORMAL}, // b7
{"clv", IMP, NORMAL}, // b8
{"lda", ABY, NORMAL}, // b9
{"tsx", IMP, NORMAL}, // ba
{"tyx", IMP, NORMAL}, // bb
{"ldy", ABX, NORMAL}, // bc
{"lda", ABX, NORMAL}, // bd
{"ldx", ABY, NORMAL}, // be
{"lda", ABLX, NORMAL}, // bf
{"cpy", IMMX, NORMAL}, // c0
{"cmp", INX, NORMAL}, // c1
{"rep", IMM, NORMAL}, // c2
{"cmp", ZPS, NORMAL}, // c3
{"cpy", ZP, NORMAL}, // c4
{"cmp", ZP, NORMAL}, // c5
{"dec", ZP, NORMAL}, // c6
{"cmp", INL, NORMAL}, // c7
{"iny", IMP, NORMAL}, // c8
{"cmp", IMMM, NORMAL}, // c9
{"dex", IMP, NORMAL}, // ca
{"wai", IMP, NORMAL}, // cb
{"cpy", ABS, NORMAL}, // cc
{"cmp", ABS, NORMAL}, // cd
{"dec", ABS, NORMAL}, // ce
{"cmp", ABL, NORMAL}, // cf
{"bne", REL, BRANCH}, // d0
{"cmp", INY, NORMAL}, // d1
{"cmp", INZ, NORMAL}, // d2
{"cmp", INS, NORMAL}, // d3
{"pei", ZP, NORMAL}, // d4
{"cmp", ZPX, NORMAL}, // d5
{"dec", ZPX, NORMAL}, // d6
{"cmp", INLY, NORMAL}, // d7
{"cld", IMP, NORMAL}, // d8
{"cmp", ABY, NORMAL}, // d9
{"phx", IMP, NORMAL}, // da
{"stp", IMP, BREAK}, // db
{"jmp", IND, JUMP}, // dc
{"cmp", ABX, NORMAL}, // dd
{"dec", ABX, NORMAL}, // de
{"cmp", ABLX, NORMAL}, // df
{"cpx", IMMX, NORMAL}, // e0
{"sbc", INX, NORMAL}, // e1
{"sep", IMM, NORMAL}, // e2
{"sbc", ZPS, NORMAL}, // e3
{"cpx", ZP, NORMAL}, // e4
{"sbc", ZP, NORMAL}, // e5
{"inc", ZP, NORMAL}, // e6
{"sbc", INL, NORMAL}, // e7
{"inx", IMP, NORMAL}, // e8
{"sbc", IMMM, NORMAL}, // e9
{"nop", IMP, NORMAL}, // ea
{"xba", IMP, NORMAL}, // eb
{"cpx", ABS, NORMAL}, // ec
{"sbc", ABS, NORMAL}, // ed
{"inc", ABS, NORMAL}, // ee
{"sbc", ABL, NORMAL}, // ef
{"beq", REL, BRANCH}, // f0
{"sbc", INY, NORMAL}, // f1
{"sbc", INZ, NORMAL}, // f2
{"sbc", INS, NORMAL}, // f3
{"pea", IMMS, NORMAL}, // f4
{"sbc", ZPX, NORMAL}, // f5
{"inc", ZPX, NORMAL}, // f6
{"sbc", INLY, NORMAL}, // f7
{"sed", IMP, NORMAL}, // f8
{"sbc", ABY, NORMAL}, // f9
{"plx", IMP, NORMAL}, // fa
{"xce", IMP, NORMAL}, // fb
{"jsr", AIX, CALL}, // fc
{"sbc", ABX, NORMAL}, // fd
{"inc", ABX, NORMAL}, // fe
{"sbc", ABLX, NORMAL} // ff
};
static uint8_t addressSizes[] = {
1, // IMP
2, // IMM
3, // IMMM
3, // IMMX
3, // IMMS
3, // ABS
4, // ABL
3, // ABX
3, // ABY
4, // ABLX
3, // AIX
2, // ZP
2, // ZPX
2, // ZPY
2, // ZPS
3, // IND
2, // INZ
2, // INL
2, // INX
2, // INY
2, // INLY
2, // INS
2, // REL
3, // RELL
3, // BANK
1, // DB
2, // DW
4 // DD
};

24
LICENSE Normal file
View File

@ -0,0 +1,24 @@
Copyright (c) 2018, Sean Kasun
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* 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 HOLDER 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.

19
Makefile Normal file
View File

@ -0,0 +1,19 @@
CC=clang
CFLAGS=-Wall
all: 2mg omf regs
2mg: 2mg.o
$(CC) $(CFLAGS) -o $@ $^
omf: omf.o parser.o
$(CC) $(CFLAGS) -o $@ $^
regs: regs.o map.o scan.o parser.o disasm.o
$(CC) $(CFLAGS) -o $@ $^
%.o: %.c
$(CC) -c $(CFLAGS) -o $@ $<
clean:
rm -f *.o 2mg omg regs

175
README.md Executable file
View File

@ -0,0 +1,175 @@
# What is this?
This is a set of command-line tools designed specifically to reverse engineer Apple IIgs software. It is comprised of 3 separate tools; `2mg`, `omf`, and `regs`.
## 2mg
`2mg` extracts .2mg and .po prodos disk images. You can also just list the contents of the disk image with the `-l` or `--list` command line argument. Otherwise, it will create a folder with the name of the disk and extract all the files into that folder.
## omf
`omf` is a rather complicated tool which is designed to extract relocatable segments from OMF files. Apple IIgs executables (.sys16 files) and system tools (ex. SYSTEM/TOOLS/TOOL025) are in OMF format.
You first run this tool and pass it an OMF file and it will generate a .map file. This map file is a simple text file that you may edit. Each line is in the format:
`segment:memory location`
The `segment`is the segment number from the OMF file, and `memory location` is where in memory to relocate that segment.
`omf` does its best to automatically pack all the relocatable segments into the smallest memory possible, starting at `$2/0000`. You can change the starting memory address with the `-o` or `--org` argument. If you wish to manually specify where each segment should go in memory, feel free to edit the .map file however you wish.
The next step is to run `omf` again, this time specifying the map file with `-m` or `--map`. This will apply the .map to the OMF and output each segment along with a corresponding .map file. `omf` will throw an error if the segments cannot be mapped as the .map file dictates (for example, you modified the map file so that the segments accidentally overlap).
`omf` will modify each segment, applying the proper relocations before outputting the segment. If you wish to change where a segment is in memory, you should modify the original .map file and re-run `omf`. The resulting output files will be hardcoded for those specific memory locations.
The segment outputs will be named `segX` and `segX.map`, where `X` is the segment number, in hex. If you wish to change the prefix from `seg` use the `-p` or `--prefix` argument.
At this point, you can use the resulting segment files and map files as input to the `regs` tool.
## regs
`regs`is my 65816 tracing disassembler. It can be used in conjunction with the .map files created by `omf` or on its own. Since it is a tracing disassembler, it will start disassembly at a given location, and keep disassembling, following all possible paths. Everything not disassembled will be assumed to be data and shown in a hex view.
#### regs by itself
You can call `regs` and simply pass it a binary file and it will attempt to disassemble it. You can specify where in memory it should load the file before disassembly with the `-o` or `--org` argument. You can also control whether or not the disassembler is in emulation mode or 16-bit mode with various command-line arguments. Emulation mode is also useful for disassembling 8-bit Apple II software. Use `-e` to start in emulation mode (default native mode), `-m` to start with an 8-bit accumulator (default 16-bit), and `-x` to start with 8-bit index registers (default 16-bit).
#### regs with .map files
`regs` with .map files is where the disassembler really shines. You can call `regs` and pass it a .map file generated by `omf` and have real control over the disassembly. The .map file is designed to be edited by hand. The format is as follows:
```
gMAP "seg1"
sORG $30000
$30000:
$30053:mx
$31066:e
```
The first line specifies the segment file that this map applies to. The filename in the quotes should be relative to the current directory.
The next line specifies where the segment belongs in memory. **Do not edit this** if the segment was created by `omf`, since it has also been hardcoded in the binary.
The next lines are a list of entry points to begin disassembly at. If, when analyzing the disassembly you find a switch case encoded as an indirect jump, you can take that list of jumps and add them to the map file and re-run `regs` to disassemble the previously un-disassembled data. As you work through a disassembly, you may end up with a map file with hundreds of entry points, that's normal.
The flags after the colon are optional, and specify whether emulation mode should be enabled, or 16-bit or 8-bit accumulator and index registers should be used. It defaults to native mode with 16-bit registers.
You can also use bank-separators if you wish. `$3/1066` is the same as `$31066`.
## Pascal folder
You'll notice a pascal folder in this repository. These are the original GS/OS pascal header files. This is to make it easier for you to look up the arguments and structures of various tool calls you'll come across when disassembling.
# Examples
The flexibility of these tools makes their use a little complicated. So here are some examples of how to go about disassembling various things.
### Disassembling an S16
I'll be using the S16 from Dream Zone as an example.
Generate a basic map of your S16:
`$ omf dream.s16`
This will create a file called `dream.s16.map`, which we could edit if we choose. We'll leave it as it is. Extract the segments of the OMF with:
`$ omf --map=dream.s16.map dream.s16 --prefix=dream`
This will create files `dream1`to `dream5` as well as `dream1.map` to `dream5.map`.
The program's entry point is always the beginning of the first segment, so we'll start there.
`$ regs dream1.map > dream1.s`
This will disassemble the entry point. We can then modify the map to further refine the disassembly if we wish.
### Disassembling a Tool
This works the same as disassembling an S16, but with an important difference.
We'll start the same, generating a map and extracting it.
```
$ omf TOOL025
$ omf --map=TOOL025.map TOOL025
```
Now, we'll remove all disassembly instructions from the map. You'll see why in a second. So we edit the map file to look like the following:
```
gMAP "seg1"
sORG $20000
```
That's it.. no disassembly instructions. Now we run the disassembler:
`$ regs seg1.map > seg1.s`
This will just give us a hex dump of the segment. That's actually what we want. All tools start with a tool table. The first dword specifies the number of tools in this toolset. The next dwords all contain addresses (minus 1) of the various tool entry points.
Let's say I want to disassemble NoteOn. We check the pascal folder and discover that it's tool $0b inside the $19 toolset. Which is the TOOL025 file we're working on (the tool numbers in the filenames are in decimal). So we calculate the offset to that entry point.
`$0b * 4 + $20000 = $2:002c`
If we look at the hex dump at that location we'll discover the entry point of NoteOn: `$2:02dd`. Well that's minus one, so we add the real entry point to the .map file:
```
gMAP "seg1"
sORG $20000
$2/02de:
```
And rerun the disassembler.
`$ regs seg1.map > seg1.s`
We have just disassembled the NoteOn function.
### Disassembling a Specific Tool Call in ROM
Let's say I want to disassemble WriteRamBlock. We discover it's in the sound toolset $08. If you search, you'll discover that there isn't a TOOL008 anywhere, so we'll have to pull it from ROM. I'll be using an older 128k ROM just because it's convenient.
First thing I do, is actually hand make a `rom.map` file for the ROM.
```
gMAP "APPLE2GS.ROM"
sORG $fe0000
$fe/0000:
```
and disassemble it.
`$ regs rom.map > rom.s`
This is actually the bootstrap that initializes the `$e1/0000` tool call entrypoint. I notice it copies over a block of memory from `$fe/0051` into `$e1/0000`. So we add `$fe/0051` to the disassembly list of the map file, and disassemble it again.
Following along with the disassembly, we discover that there's a toolset list starting at `$fe/012f`. It starts with a dword with the number of toolsets in the ROM, followed by a list of offsets to the various toolsets. We want toolset 8 for the sound toolset.
`$8 * 4 + $fe012f = $fe014f`
Look up the dword in that location and I find that the toolset is located at `$ff/3e00`. If you then jump to that location, you'll find this is in the exact same format as a tool on disk. It starts with a tool table. WriteRamBlock is tool 9.
`$9 * 4 + $ff3e00 = $ff3e24`
At that location, we discover the offset to the tool entry point is `$ff/41a4` so we'll add `$ff/41a5`to the map file and rerun the disassembly.
Boom, we have just disassembled a specific tool call from ram.

412
addresses.h Normal file
View File

@ -0,0 +1,412 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* Defines important IIgs memory addresses.
*/
typedef struct {
uint32_t address;
const char *comment;
} MemAddress;
static MemAddress addresses[] = {
{0x03d0, "Enter BASIC"},
{0x03d2, "Reconnect DOS"},
{0x03d9, "Cow Sound"},
{0x03ea, "Reconnect IO"},
{0x03f2, "Control-Reset Vector"},
{0x03f5, "Ampersand Vector"},
{0x03f8, "Control-Y Vector"},
{0x0400, "Text Screen"},
{0x0800, "Text Screen 2"},
{0x0803, "Enter assembler"},
{0x2000, "Hires screen"},
{0x4000, "Hires screen 2"},
{0x9dbf, "Reconnect DOS 3.3"},
{0xa56e, "CATALOG"},
{0xc000, "KBD / 80STOREOFF"},
{0xc001, "80STOREON"},
{0xc002, "RDMAINRAM"},
{0xc003, "RDCARDRAM"},
{0xc004, "WRMAINRAM"},
{0xc005, "WRCARDRAM"},
{0xc006, "SETSLOTCXROM"},
{0xc007, "SETINTCXROM"},
{0xc008, "SETSTDZP"},
{0xc009, "SETALTZP"},
{0xc00a, "SETINTC3ROM"},
{0xc00b, "SETSLOTC3ROM"},
{0xc00c, "CLR80VID"},
{0xc00d, "SET80VID"},
{0xc00e, "CLRALTCHAR"},
{0xc00f, "SETALTCHAR"},
{0xc010, "KBDSTRB"},
{0xc011, "RDLCBNK2"},
{0xc012, "RDLCRAM"},
{0xc013, "RDRAMRD"},
{0xc014, "RDRAMWRT"},
{0xc015, "RDCXROM"},
{0xc016, "RDALTZP"},
{0xc017, "RDC3ROM"},
{0xc018, "RD80STORE"},
{0xc019, "RDVBL"},
{0xc01a, "RDTEXT"},
{0xc01b, "RDMIXED"},
{0xc01c, "RDPAGE2"},
{0xc01d, "RDHIRES"},
{0xc01e, "RDALTCHAR"},
{0xc01f, "RD80VID"},
{0xc020, "TAPEOUT"},
{0xc021, "MONOCOLOR"},
{0xc022, "TBCOLOR"},
{0xc023, "VGCINT"},
{0xc024, "MOUSEDATA"},
{0xc025, "KEYMODREG"},
{0xc026, "DATAREG"},
{0xc027, "KMSTATUS"},
{0xc028, "ROMBANK"},
{0xc029, "NEWVIDEO"},
{0xc02b, "LANGSEL"},
{0xc02c, "CHARROM"},
{0xc02d, "SLTROMSEL"},
{0xc02e, "VERTCNT"},
{0xc02f, "HORIZCNT"},
{0xc030, "SPKR"},
{0xc031, "DISKREG"},
{0xc032, "SCANINT"},
{0xc033, "CLOCKDATA"},
{0xc034, "CLOCKCTL"},
{0xc035, "SHADOW"},
{0xc036, "CYAREG"},
{0xc037, "DMAREG"},
{0xc038, "SCCBREG"},
{0xc039, "SCCAREG"},
{0xc03a, "SCCBDATA"},
{0xc03b, "SCCADATA"},
{0xc03c, "SOUNDCTL"},
{0xc03d, "SOUNDDATA"},
{0xc03e, "SOUNDADRL"},
{0xc03f, "SOUNDADRH"},
{0xc040, "STROBE"},
{0xc041, "INTEN"},
{0xc044, "MMDELTAX"},
{0xc045, "MMDELTAY"},
{0xc046, "DIAGTYPE"},
{0xc047, "CLRVBLINT"},
{0xc048, "CLRXYINT"},
{0xc050, "TXTCLR"},
{0xc051, "TXTSET"},
{0xc052, "MIXCLR"},
{0xc053, "MIXSET"},
{0xc054, "TXTPAGE1"},
{0xc055, "TXTPAGE2"},
{0xc056, "LORES"},
{0xc057, "HIRES"},
{0xc058, "CLRAN0"},
{0xc059, "SETAN0"},
{0xc05a, "CLRAN1"},
{0xc05b, "SETAN1"},
{0xc05c, "CLRAN2"},
{0xc05d, "SETAN2"},
{0xc05e, "DHIRESON"},
{0xc05f, "DHIRESOFF"},
{0xc060, "TAPEIN"},
{0xc061, "RDBTN0"},
{0xc062, "RDBTN1"},
{0xc063, "RDBTN2"},
{0xc064, "PADDL0"},
{0xc065, "PADDL1"},
{0xc066, "PADDL2"},
{0xc067, "PADDL3"},
{0xc068, "STATEREG"},
{0xc06d, "TESTREG"},
{0xc06e, "CLTRM"},
{0xc06f, "ENTM"},
{0xc070, "PTRIG"},
{0xc073, "BANKSEL"},
{0xc07e, "IOUDISON"},
{0xc07f, "IOUDISOFF"},
{0xc081, "ROMIN"},
{0xc083, "LCBANK2"},
{0xc08b, "LCBANK1"},
{0xc0e0, "PH0 off"},
{0xc0e1, "PH0 on"},
{0xc0e2, "PH1 off"},
{0xc0e3, "PH1 on"},
{0xc0e4, "PH2 off"},
{0xc0e5, "PH2 on"},
{0xc0e6, "PH3 off"},
{0xc0e7, "PH3 on"},
{0xc0e8, "motor off"},
{0xc0e9, "motor on"},
{0xc0ea, "drive 1"},
{0xc0eb, "drive 2"},
{0xc0ec, "q6 off"},
{0xc0ed, "q6 on"},
{0xc0ee, "q7 off"},
{0xc0ef, "q7 on"},
{0xc311, "AUXMOVE"},
{0xc314, "XFER"},
{0xc50d, "Smartport"},
{0xc70d, "Smartport"},
{0xcfff," CLRROM"},
{0xd1fc, "Hires Find"},
{0xd2c9, "Hires bg"},
{0xd331, "Hires graphics bg"},
{0xd33a, "Hires DRAW1"},
{0xd3b9, "Hires SHLOAD"},
{0xd683, "Clear FOR"},
{0xdafb, "Carriage Return"},
{0xe000, "Reset Int Basic"},
{0xe04b, "IntBASIC LIST"},
{0xe5ad, "NEW"},
{0xe5b7, "PLOT"},
{0xe836, "IntBASIC CHAIN"},
{0xefec, "IntBASIC RUN"},
{0xf07c, "IntBASIC LOAD"},
{0xf0e0, "Leave monitor"},
{0xf123, "DRAW shape"},
{0xf14f, "Plot point"},
{0xf171, "IntBASIC TRACE ON"},
{0xf176, "IntBASIC TRACE OFF"},
{0xf30a, "IntBASIC CON"},
{0xf317, "RESUME"},
{0xf328, "Clear error"},
{0xf3de, "HGR"},
{0xf3e4, "Show hires"},
{0xf3f2, "Clear hires"},
{0xf3f6, "Clear hires color"},
{0xf666, "Enter assembler"},
{0xf800, "PLOT"},
{0xf80e, "PLOT1"},
{0xf819, "HLINE"},
{0xf828, "VLINE"},
{0xf832, "CLRSCR"},
{0xf836, "CLRTOP"},
{0xf838, "Clear lores y"},
{0xf83c, "Clear rect"},
{0xf847, "GBASCALC"},
{0xf85e, "Add 3 COLOR"},
{0xf85f, "NXTCOL"},
{0xf864, "SETCOL"},
{0xf871, "SCRN"},
{0xf88c, "INSDS1.2"},
{0xf88e, "INSDS2"},
{0xf890, "GET816LEN"},
{0xf8d0, "INSTDSP"},
{0xf940, "PRNTYX"},
{0xf941, "PRNTAX"},
{0xf944, "PRNTX"},
{0xf948, "PRBLNK"},
{0xf94a, "PRBL2"},
{0xf94c, "Print X blank"},
{0xf953, "PCADJ"},
{0xf962, "TEXT2COPY"},
{0xfa40, "OLDIRQ"},
{0xfa4c, "BREAK"},
{0xfa59, "OLDBRK"},
{0xfa62, "RESET"},
{0xfaa6, "PWRUP"},
{0xfaba, "SLOOP"},
{0xfad7, "REGDSP"},
{0xfb19, "RTBL"},
{0xfb1e, "PREAD"},
{0xfb21, "PREAD4"},
{0xfb2f, "INIT"},
{0xfb39, "SETTXT"},
{0xfb40, "SETGR"},
{0xfb4b, "SETWND"},
{0xfb51, "SETWND2"},
{0xfb5b, "TABV"},
{0xfb60, "APPLEII"},
{0xfb6f, "SETPWRC"},
{0xfb78, "VIDWAIT"},
{0xfb88, "KBDWAIT"},
{0xfbb3, "VERSION"},
{0xfbbf, "ZIDBYTE2"},
{0xfbc0, "ZIDBYTE"},
{0xfbc1, "BASCALC"},
{0xfbdd, "BELL1"},
{0xfbe2, "BELL1.2"},
{0xfbe4, "BELL2"},
{0xfbf0, "STORADV"},
{0xfbf4, "ADVANCE"},
{0xfbfd, "VIDOUT"},
{0xfc10, "BS"},
{0xfc1a, "UP"},
{0xfc22, "VTAB"},
{0xfc24, "VTABZ"},
{0xfc2c, "ESC"},
{0xfc42, "CLREOP"},
{0xfc58, "HOME"},
{0xfc62, "CR"},
{0xfc66, "LF"},
{0xfc70, "SCROLL"},
{0xfc9c, "CLREOL"},
{0xfc9e, "CLREOLZ"},
{0xfca8, "WAIT"},
{0xfcb4, "NXTA4"},
{0xfcba, "NXTA1"},
{0xfcc9, "HEADR"},
{0xfd0c, "RDKEY"},
{0xfd10, "FD10"},
{0xfd18, "RDKEY1"},
{0xfd1b, "KEYIN"},
{0xfd35, "RDCHAR"},
{0xfd5a, "Wait return"},
{0xfd5c, "Ring bell wait"},
{0xfd67, "GETLNZ"},
{0xfd6a, "GETLN"},
{0xfd6c, "GETLN0"},
{0xfd6f, "GETLN1"},
{0xfd75, "Wait line"},
{0xfd8b, "CROUT1"},
{0xfd8e, "CROUT"},
{0xfd92, "PRA1"},
{0xfda3, "Print memory"},
{0xfdda, "PRBYTE"},
{0xfde3, "PRHEX"},
{0xfded, "COUT"},
{0xfdf0, "COUT1"},
{0xfdf6, "COUTZ"},
{0xfe1f, "IDROUTINE"},
{0xfe2c, "MOVE"},
{0xfe5e, "LIST"},
{0xfe61, "Disassembler"},
{0xfe80, "INVERSE"},
{0xfe84, "NORMAL"},
{0xfe86, "Set I"},
{0xfe89, "SETKBD"},
{0xfe8b, "INPORT"},
{0xfe93, "SETVID"},
{0xfe95, "OUTPORT"},
{0xfeb0, "Jump BASIC"},
{0xfeb6, "GO"},
{0xfebf, "Display regs"},
{0xfec2, "Perform trace"},
{0xfecd, "WRITE"},
{0xfefd, "READ"},
{0xff2d, "PRERR"},
{0xff3a, "BELL"},
{0xff3f, "RESTORE"},
{0xff44, "RSTR1"},
{0xff4a, "SAVE"},
{0xff4c, "SAV1"},
{0xff58, "IORTS"},
{0xff59, "OLDRST"},
{0xff65, "MON"},
{0xff69, "MONZ"},
{0xff6c, "MONZ2"},
{0xff70, "MONZ4"},
{0xff8a, "DIG"},
{0xffa7, "GETNUM"},
{0xffad, "NXTCHR"},
{0xffbe, "TOSUB"},
{0xffc7, "ZMODE"},
{0xe01e04, "StdText"},
{0xe01e08, "StdLine"},
{0xe01e0c, "StdRect"},
{0xe01e10, "StdRRect"},
{0xe01e14, "StdOval"},
{0xe01e18, "StdArc"},
{0xe01e1c, "StdPoly"},
{0xe01e20, "StdRgn"},
{0xe01e24, "StdPixels"},
{0xe01e28, "StdComment"},
{0xe01e2c, "StdTxMeas"},
{0xe01e30, "StdTxBnds"},
{0xe01e34, "StdGetPic"},
{0xe01e38, "StdPutPic"},
{0xe01e98, "ShieldCursor"},
{0xe01e9c, "UnshieldCursor"},
{0xe10000, "System Tool dispatch"},
{0xe10004, "System Tool dispatch"},
{0xe10008, "User Tool dispatch"},
{0xe1000c, "User Tool dispatch"},
{0xe10010, "Interrupt manager"},
{0xe10014, "COP manager"},
{0xe10018, "Abort manager"},
{0xe1001c, "System death manager"},
{0xe10020, "AppleTalk interrupt"},
{0xe10024, "Serial interrupt"},
{0xe10028, "Scanline interrupt"},
{0xe1002c, "Sound interrupt"},
{0xe10030, "VBlank interrupt"},
{0xe10034, "Mouse interrupt"},
{0xe10038, "250ms interrupt"},
{0xe1003c, "Keyboard interrupt"},
{0xe10040, "ADB Response"},
{0xe10044, "ADB SRQ"},
{0xe10048, "DA manager"},
{0xe1004c, "Flush Buffer"},
{0xe10050, "KbdMicro interrupt"},
{0xe10054, "1s interrupt"},
{0xe10058, "External VGC interrupt"},
{0xe1005c, "Ohter interrupt"},
{0xe10060, "Cursor update"},
{0xe10064, "IncBusy"},
{0xe10068, "DecBusy"},
{0xe1006c, "Bell vector"},
{0xe10070, "Break vector"},
{0xe10074, "Trace vector"},
{0xe10078, "Step vector"},
{0xe1007c, "ROM disk"},
{0xe10080, "ToWriteBram"},
{0xe10084, "ToReadBram"},
{0xe10088, "ToWriteTime"},
{0xe1008c, "ToReadTime"},
{0xe10090, "ToCtrlPanel"},
{0xe10094, "ToBramSetup"},
{0xe10098, "ToPrintMsg8"},
{0xe1009c, "ToPrintMsg16"},
{0xe100a0, "Native Ctl-Y"},
{0xe100a4, "ToAltDispCDA"},
{0xe100a8, "Prodos 16"},
{0xe100ac, "OS vector"},
{0xe100b0, "GS/OS"},
{0xe100b4, "P8 Switch"},
{0xe100b8, "Public Flags"},
{0xe100bc, "OS Kind"},
{0xe100bd, "OS Boot"},
{0xe100be, "OS Busy"},
{0xe100c0, "MsgPtr"},
{0xe10180, "ToBusyStrip"},
{0xe10184, "ToStrip"},
{0xe101b2, "MidiInputPoll"},
{0xe10200, "Memory manager"},
{0xe10204, "Set System Speed"},
{0xe10208, "Slot Arbiter"},
{0xe10220, "Hypercard callback"},
{0xe10224, "WordForRTL"},
{0xe11004, "ATLK Basic"},
{0xe11008, "ATLK Pascal"},
{0xe1100c, "ATLK RamGoComp"},
{0xe11010, "ATLK SoftReset"},
{0xe11014, "ATLK RamDispatch"},
{0xe11018, "ATLK RamForbid"},
{0xe1101c, "ATLK RamPermit"},
{0xe11020, "ATLK ProEntry"},
{0xe11022, "ATLK ProDOS"},
{0xe11026, "ATLK SerStatus"},
{0xe1102a, "ATLK SerWrite"},
{0xe1102e, "ATLK SerRead"},
{0xe1103e, "ATLK PFI"},
{0xe1d600, "ATLK CmdTable"},
{0xe1da00, "ATLK TickCount"}
};
#define numAddresses (sizeof(addresses) / sizeof(addresses[0]))
static const char *addressLookup(uint32_t addr) {
for (int i = 0; i < numAddresses; i++) {
if (addresses[i].address >= addr) {
if (addresses[i].address == addr)
return addresses[i].comment;
break;
}
}
if (addr & ~0xffff)
return addressLookup(addr & 0xffff); // try pageless
return NULL;
}

358
disasm.c Normal file
View File

@ -0,0 +1,358 @@
/**
* @copyright 2018 Sean Kasun
* The main disassembler.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdbool.h>
#include "disasm.h"
#include "65816.h"
#include "handle.h"
#include "addresses.h"
#include "prodos8.h"
#include "prodos16.h"
#include "smartport.h"
#include "tools.h"
static void dumphex(uint8_t *ptr, uint32_t addr, uint32_t len) {
uint8_t *eof = ptr + len;
for (int line = 0; ptr < eof; line++) {
printf("%02x/%04x: ", addr >> 16, addr & 0xffff);
uint8_t *p = ptr;
int skip = addr & 0xf;
int i = 0;
for (; i < skip; i++) {
if (i == 8) {
printf(" ");
}
printf(" ");
}
for (; i < 16 && p < eof; i++) {
if (i == 8) {
printf(" ");
}
printf("%02x ", *p++);
}
for (; i < 16; i++) {
if (i == 8) {
printf(" ");
}
printf(" ");
}
printf("| ");
i = 0;
for (; i < skip; i++) {
if (i == 8) {
printf(" ");
}
printf(" ");
}
for (; i < 16 && ptr < eof; i++) {
if (i == 8) {
printf(" ");
}
uint8_t c = *ptr++;
addr++;
printf("%c", (c >= ' ' && c <= '~') ? c : '.');
}
printf("\n");
}
}
void disassemble(uint8_t *data, size_t len, Map *map) {
uint8_t *ptr = data;
uint8_t *end = data + len;
uint16_t x = 0;
uint32_t val;
int8_t delta;
int16_t delta16;
uint32_t d6;
bool smart = false, dos8 = false, dos16 = false;
uint32_t addr = map->minMemory;
while (ptr < end) {
MapFlags flags = map->mem[addr - map->minMemory];
if ((flags & IsOpcode) || smart || dos8 || dos16) {
printf("%02x/%04x:", addr >> 16, addr & 0xffff);
uint8_t *start = ptr;
uint8_t opcode = *ptr++;
const char *inst = opcodes[opcode].inst;
Address mode = opcodes[opcode].address;
if (smart || dos8) {
mode = DB;
inst = "db";
}
if (dos16) {
mode = DW;
inst = "dw";
}
uint16_t width = addressSizes[mode];
if (mode == IMMM && (flags & (IsEmu | IsM8))) {
width--;
}
if (mode == IMMX && (flags & (IsEmu | IsX8))) {
width--;
}
addr += width;
for (int i = 0; i < width; i++) {
printf(" %02x", start[i]);
}
for (int i = 0; i < 4 - width; i++) {
printf(" ");
}
printf(" %s", inst);
for (int i = strlen(inst); i < 8; i++) {
printf(" ");
}
const char *comments = NULL;
uint8_t oprlen = 0;
switch (mode) {
case IMP:
break;
case IMM:
printf("#$%02x", *ptr++);
oprlen = 4;
break;
case IMMM:
if (flags & (IsEmu | IsM8)) {
printf("#$%02x", *ptr++);
oprlen = 4;
} else {
printf("#$%04x", r16(ptr)); ptr += 2;
oprlen = 6;
}
break;
case IMMX:
if (flags & (IsEmu | IsX8)) {
x = *ptr++;
printf("#$%02x", x);
oprlen = 4;
} else {
x = r16(ptr); ptr += 2;
printf("#$%04x", x);
oprlen = 6;
}
break;
case IMMS:
printf("#$%04x", r16(ptr)); ptr += 2;
oprlen = 6;
break;
case ABS:
val = r16(ptr); ptr += 2;
printf("$%04x", val);
oprlen = 5;
comments = addressLookup(val);
break;
case ABL:
val = r24(ptr); ptr += 3;
printf("$%02x/%04x", val >> 16, val & 0xffff);
oprlen = 8;
comments = addressLookup(val);
break;
case ABX:
printf("$%04x, x", r16(ptr)); ptr += 2;
oprlen = 8;
break;
case ABY:
printf("$%04x, y", r16(ptr)); ptr += 2;
oprlen = 8;
break;
case ABLX:
val = r24(ptr); ptr += 3;
printf("$%02x/%04x, x", val >> 16, val & 0xffff);
oprlen = 11;
break;
case AIX:
printf("($%04x, x)", r16(ptr)); ptr += 2;
oprlen = 10;
break;
case ZP:
printf("$%02x", *ptr++);
oprlen = 3;
break;
case ZPX:
printf("$%02x, x", *ptr++);
oprlen = 6;
break;
case ZPY:
printf("$%02x, y", *ptr++);
oprlen = 6;
break;
case ZPS:
printf("$%02x, s", *ptr++);
oprlen = 6;
break;
case IND:
printf("($%04x)", r16(ptr)); ptr += 2;
oprlen = 7;
break;
case INZ:
printf("($%02x)", *ptr++);
oprlen = 5;
break;
case INL:
printf("[$%02x]", *ptr++);
oprlen = 5;
break;
case INX:
printf("($%02x, x)", *ptr++);
oprlen = 8;
break;
case INY:
printf("($%02x), y", *ptr++);
oprlen = 8;
break;
case INLY:
printf("[$%02x], y", *ptr++);
oprlen = 8;
break;
case INS:
printf("($%02x, s), y", *ptr++);
oprlen = 11;
break;
case REL:
delta = *ptr++;
d6 = delta + addr;
printf("$%02x/%04x", d6 >> 16, d6 & 0xffff);
oprlen = 8;
break;
case RELL:
delta16 = r16(ptr); ptr += 2;
d6 = delta16 + addr;
printf("$%02x/%04x", d6 >> 16, d6 & 0xffff);
oprlen = 8;
break;
case BANK:
val = *ptr++;
printf("$%02x, $%02x", *ptr++, val);
oprlen = 8;
break;
case DB:
printf("$%02x", opcode);
oprlen = 3;
break;
case DW:
val = opcode | (*ptr++ << 8);
printf("$%04x", val);
oprlen = 5;
break;
case DD:
printf("$%08x", opcode | r24(ptr) << 8); ptr += 3;
oprlen = 9;
break;
}
if (smart) {
comments = smartportLookup(opcode);
smart = false;
}
if (dos8) {
comments = prodos8Lookup(opcode);
dos8 = false;
}
if (dos16) {
comments = prodos16Lookup(val);
dos16 = false;
}
if (opcode == 0xa2) { // ldx
if (*ptr == 0x22) { // jsl
if (r24(ptr + 1) == 0xe10000) { // jsl el/0000
comments = toolLookup(x);
}
}
}
if (opcode == 0x20) { // jsr
if (val == 0xc50d || val == 0xc70d) {
smart = true;
}
if (val == 0xbf00) {
dos8 = true;
}
}
if (opcode == 0x22) { // jsl
if (val == 0xe100a8) {
dos16 = true;
}
}
if (comments != NULL) {
for (int i = oprlen; i < 16; i++) {
printf(" ");
}
printf("; %s", comments);
}
uint16_t nextFlags = map->mem[addr - map->minMemory];
if (((flags ^ nextFlags) & (IsEmu | IsM8 | IsX8)) && comments == NULL &&
(nextFlags & IsOpcode)) {
for (int i = oprlen; i < 16; i++) {
printf(" ");
}
printf(";");
if ((flags ^ nextFlags) & IsEmu) {
if (nextFlags & IsEmu) {
printf(" 8-bit mode");
} else {
printf(" 16-bit mode");
}
}
if ((flags ^ nextFlags) & IsM8) {
if (nextFlags & IsM8) {
printf(" a.b");
} else {
printf(" a.w");
}
}
if ((flags ^ nextFlags) & IsX8) {
if (nextFlags & IsX8) {
printf(" x.b");
} else {
printf(" x.w");
}
}
}
printf("\n");
} else {
uint32_t dlen = 0;
uint8_t *p = ptr;
while (p < end && !(map->mem[addr + dlen - map->minMemory] & IsOpcode)) {
p++;
dlen++;
}
uint32_t val;
switch (dlen) {
case 4:
printf("%02x/%04x:", addr >> 16, addr & 0xffff);
val = r32(ptr);
printf(" %02x %02x %02x %02x dd $%08x\n", val & 0xff,
(val >> 8) & 0xff, (val >> 16) & 0xff, val >> 24, val);
break;
case 2:
printf("%02x/%04x:", addr >> 16, addr & 0xffff);
val = r16(ptr);
printf(" %02x %02x dw $%04x\n", val & 0xff, val >> 8, val);
break;
case 1:
printf("%02x/%04x:", addr >> 16, addr & 0xffff);
printf(" %02x db $%04x\n", *ptr, *ptr);
break;
default:
dumphex(ptr, addr, dlen);
break;
}
ptr += dlen;
addr += dlen;
}
}
}

10
disasm.h Normal file
View File

@ -0,0 +1,10 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* The main disassembler.
*/
#include "map.h"
extern void disassemble(uint8_t *data, size_t len, Map *map);

41
handle.h Normal file
View File

@ -0,0 +1,41 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* Routines for reading multi-byte numbers from a stream
*/
#include <stdint.h>
static inline uint32_t fourcc(const char *p) {
return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
}
static inline uint16_t r16(uint8_t *p) {
uint16_t r = *p++;
r |= *p << 8;
return r;
}
static inline uint32_t r24(uint8_t *p) {
uint32_t r = *p++;
r |= *p++ << 8;
r |= *p << 16;
return r;
}
static inline uint32_t r32(uint8_t *p) {
uint32_t r = *p++;
r |= *p++ << 8;
r |= *p++ << 16;
r |= *p << 24;
return r;
}
static inline uint32_t r4(uint8_t *p) {
uint32_t r = *p++ << 24;
r |= *p++ << 16;
r |= *p++ << 8;
r |= *p;
return r;
}

142
map.c Normal file
View File

@ -0,0 +1,142 @@
/**
* @copyright 2018 Sean Kasun
* Handles the memory map, for the tracing disassembler.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include "map.h"
#include "parser.h"
#include "handle.h"
static Rule *parseRule(ConfigFile *f) {
Rule *rule = malloc(sizeof(Rule));
rule->next = NULL;
if (!token(f, '$')) {
fail(f, "Address must be a hex value above 0 \n"
"starting with '$', i.e. $c20");
}
rule->address = hex(f);
if (token(f, '/')) {
rule->address <<= 16;
rule->address |= hex(f);
}
if (rule->address == 0) {
fail(f, "Address must be a hex value above 0 \n"
"starting with '$', i.e. $c20");
}
if (!token(f, ':')) {
fail(f, "Expected ':'");
}
rule->flags = IsOpcode;
bool foundFlag = false;
do {
foundFlag = false;
if (token(f, 'e')) {
rule->flags |= IsEmu;
foundFlag = true;
}
if (token(f, 'm')) {
rule->flags |= IsM8;
foundFlag = true;
}
if (token(f, 'x')) {
rule->flags |= IsX8;
foundFlag = true;
}
} while (foundFlag);
return rule;
}
Map *loadMap(const char *filename, uint32_t org, MapFlags flags) {
Map *map = malloc(sizeof(Map));
map->rules = NULL;
map->minMemory = org;
map->maxMemory = 0;
map->mem = NULL;
FILE *f = fopen(filename, "rb");
if (!f) {
fprintf(stderr, "Failed to open '%s'\n", filename);
exit(-1);
}
fseek(f, 0, SEEK_END);
size_t len = ftell(f);
fseek(f, 0, SEEK_SET);
uint8_t *data = malloc(len);
fread(data, len, 1, f);
fclose(f);
if (r4(data) != fourcc("gMAP")) {
// not a map file, use org as the only entry point
map->rules = malloc(sizeof(Rule));
map->rules->address = org;
map->rules->flags = flags;
map->rules->next = NULL;
map->filename = filename;
free(data);
return map;
}
ConfigFile c;
c.start = data;
c.p = c.start;
c.end = c.start + len;
c.filename = filename;
// set filename
c.p += 4;
eatSpaces(&c);
if (!token(&c, '"')) {
fail(&c, "Expected '\"' around the filename.");
}
uint8_t *fnp = c.p;
while (fnp < c.end && *fnp != '"') {
fnp++;
}
if (fnp == c.end) {
fail(&c, "Filename has no closing '\"'.");
}
int flen = fnp - c.p;
char *fname = malloc(flen);
memcpy(fname, c.p, flen);
fname[flen] = 0;
map->filename = fname;
c.p = fnp + 1;
eatSpaces(&c);
if (r4(c.p) != fourcc("sORG")) {
fail(&c, "Expected 'sORG' tag");
}
c.p += 4;
eatSpaces(&c);
if (!token(&c, '$')) {
fail(&c, "ORG must be a hex value above 0\n"
"starting with '$', i.e. $c20");
}
map->minMemory = hex(&c);
if (map->minMemory == 0) {
fail(&c, "ORG must be a hex value above 0\n"
"starting with '$', i.e. $c20");
}
eatSpaces(&c);
// load rules
Rule *lastRule = NULL;
while (c.p < c.end) {
Rule *rule = parseRule(&c);
if (lastRule == NULL) {
map->rules = rule;
} else {
lastRule->next = rule;
}
lastRule = rule;
eatSpaces(&c);
}
free(c.start);
return map;
}

33
map.h Normal file
View File

@ -0,0 +1,33 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* The memory map for the tracing disassembler
*/
#include <stdint.h>
typedef enum {
IsData = 0x01,
IsOpcode = 0x02,
IsOperand = 0x04,
IsX8 = 0x10,
IsM8 = 0x20,
IsEmu = 0x100
} MapFlags;
typedef struct Rule {
uint32_t address;
uint16_t flags;
struct Rule *next;
} Rule;
typedef struct {
Rule *rules;
uint32_t minMemory;
uint32_t maxMemory;
MapFlags *mem;
const char *filename;
} Map;
extern Map *loadMap(const char *filename, uint32_t org, MapFlags flags);

568
omf.c Normal file
View File

@ -0,0 +1,568 @@
/**
* @copyright 2018 Sean Kasun
* Handles parsing and relocating an OMF (s16, tool, etc)
*/
#include "handle.h"
#include "parser.h"
#include <stdlib.h>
#include <string.h>
#include <argp.h>
const char *argp_program_version = "omf 0.5";
const char *argp_program_bug_address = "sean@seancode.com";
static char doc[] = "Relocate and extract OMF segments"
"\vThis should be run twice. The first time to generate the map."
"The second time, to use that map to relocate and extract the segments";
static char args_doc[] = "FILE";
static struct argp_option options[] = {
{"org", 'o', "ADDRESS", OPTION_ARG_OPTIONAL,
"Start mapping the segments at this address, default 20000"},
{"map", 'm', "FILE", OPTION_ARG_OPTIONAL,
"Use this map to extract the segments"},
{"prefix", 'p', "PREFIX", OPTION_ARG_OPTIONAL,
"Prefix segment files with this. Default \"seg\""},
{ 0 }
};
struct arguments {
char *filename;
char *map;
char *prefix;
uint32_t org;
};
static inline uint32_t parseNum(const char *s) {
uint32_t res = 0;
while (isspace(*s)) {
s++;
}
while (isxdigit(*s)) {
res <<= 4;
if (*s >= '0' && *s <= '9') {
res |= *s - '0';
} else if (*s >= 'a' && *s <= 'f') {
res |= *s - 'a' + 10;
} else if (*s >= 'A' && *s <= 'F') {
res |= *s - 'A' + 10;
}
s++;
}
return res;
}
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
struct arguments *arguments = state->input;
switch (key) {
case 'm':
arguments->map = arg;
break;
case 'p':
arguments->prefix = arg;
break;
case 'o':
if (arg) {
arguments->org = parseNum(arg);
}
break;
case ARGP_KEY_ARG:
if (state->arg_num >= 1) {
argp_usage(state);
}
arguments->filename = arg;
break;
case ARGP_KEY_END:
if (state->arg_num < 1) {
argp_usage(state);
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static struct argp argp = { options, parse_opt, args_doc, doc };
typedef struct Segment {
uint32_t bytecnt;
uint32_t resspc;
uint32_t length;
uint8_t lablen;
uint8_t numlen;
uint32_t banksize;
uint16_t kind;
uint32_t org;
uint32_t align;
uint16_t segnum;
uint32_t entry;
char name[256];
uint8_t *offset;
uint8_t *data;
uint32_t mapped;
struct Segment *next;
} Segment;
static Segment *loadOMF(uint8_t *data, size_t len);
static void mapSegments(Segment *segments, uint32_t min);
static void relocSegments(Segment *segments, char *prefix);
int main(int argc, char **argv) {
struct arguments arguments;
arguments.filename = "";
arguments.map = NULL;
arguments.prefix = "seg";
arguments.org = 0x20000;
argp_parse(&argp, argc, argv, 0, 0, &arguments);
// open omf
FILE *f = fopen(arguments.filename, "rb");
if (!f) {
fprintf(stderr, "Failed to open '%s'\n", arguments.filename);
return -1;
}
fseek(f, 0, SEEK_END);
size_t len = ftell(f);
fseek(f, 0, SEEK_SET);
uint8_t *data = malloc(len);
fread(data, len, 1, f);
fclose(f);
Segment *segments = loadOMF(data, len);
if (arguments.map != NULL) {
// load the map!
f = fopen(arguments.map, "rb");
if (!f) {
fprintf(stderr, "Failed to open '%s'\n", arguments.map);
return -1;
}
ConfigFile c;
fseek(f, 0, SEEK_END);
len = ftell(f);
fseek(f, 0, SEEK_SET);
c.start = malloc(len);
fread(c.start, len, 1, f);
fclose(f);
c.p = c.start;
c.end = c.start + len;
while (c.p < c.end) {
uint32_t segnum = hex(&c);
if (!token(&c, ':')) {
fprintf(stderr, "Error: expected ':' in map.\n");
exit(-1);
}
uint32_t mapped = hex(&c);
for (Segment *seg = segments; seg != NULL; seg = seg->next) {
if (seg->segnum == segnum) {
seg->mapped = mapped;
}
}
eatSpaces(&c);
}
free(c.start);
}
// map any unmapped segments
mapSegments(segments, arguments.org);
if (arguments.map != NULL) {
relocSegments(segments, arguments.prefix);
} else {
int mlen = strlen(arguments.filename);
char *mapname = malloc(mlen + 5);
memcpy(mapname, arguments.filename, mlen);
memcpy(mapname + mlen, ".map\0", 5);
f = fopen(mapname, "wb");
if (!f) {
fprintf(stderr, "Failed to create '%s'\n", mapname);
return -1;
}
for (Segment *seg = segments; seg != NULL; seg = seg->next) {
fprintf(f, "%x:%x\n", seg->segnum, seg->mapped);
}
fclose(f);
fprintf(stdout, "Created '%s'. Edit it, and extract with: \n"
" %s --map=%s %s\n", mapname, argv[0], mapname, arguments.filename);
}
free(data);
}
static Segment *loadOMF(uint8_t *data, size_t len) {
Segment *last = NULL;
Segment *segments = NULL;
size_t ofs = 0;
while (ofs < len) {
Segment *seg = malloc(sizeof(Segment));
seg->next = NULL;
uint8_t *p = data + ofs;
seg->bytecnt = r32(p); p += 4;
seg->resspc = r32(p); p += 4;
seg->length = r32(p); p += 4;
uint8_t kind = *p++;
seg->lablen = *p++;
seg->numlen = *p++;
uint8_t version = *p++;
seg->banksize = r32(p); p += 4;
seg->kind = r16(p); p += 2;
p += 2; // undefined
seg->org = r32(p); p += 4;
seg->align = r32(p); p += 4;
p += 2; // byte order
seg->segnum = r16(p); p += 2;
seg->entry = r32(p); p += 4;
uint16_t dispname = r16(p); p += 2;
uint16_t dispdata = r16(p); p += 2;
p = data + ofs + dispname + 0xa;
uint8_t strlen = seg->lablen;
if (strlen == 0) {
strlen = *p++;
}
memcpy(seg->name, p, strlen);
seg->name[strlen] = 0;
seg->offset = data + ofs + dispdata;
if (version == 1) { // convert to v2
seg->bytecnt *= 512;
seg->kind = (kind & 0x1f) | ((kind & 0xe0) << 8);
}
seg->mapped = 0;
seg->data = NULL;
ofs += seg->bytecnt;
if (last == NULL) {
segments = seg;
} else {
last->next = seg;
}
last = seg;
}
return segments;
}
static int cmpmemory(const void *p1, const void *p2) {
const uint32_t *a = p1, *b = p2;
return *a - *b;
}
static void mapSegments(Segment *segments, uint32_t min) {
// we use a memory map that denotes runes of available memory.
// Each segment has a start and end, so we need an array of twice the
// number of segments (+2 for the absolute start and end of memory)
// count segments
uint32_t numSegs = 0;
for (Segment *seg = segments; seg != NULL; seg = seg->next) {
numSegs++;
}
uint32_t *memory = malloc(sizeof(uint32_t) * (numSegs * 2 + 2));
int numNodes = 0;
memory[numNodes++] = min; // minimum
memory[numNodes++] = 0x1000000; // maximum possible memory for the IIgs.
// step one, map hardcoded or overridden targets
for (Segment *seg = segments; seg != NULL; seg = seg->next) {
if (seg->org != 0 || seg->mapped != 0) {
if (seg->mapped == 0) {
if ((seg->kind & 0x1f) == 0x11) { // absolute bank
seg->mapped = seg->org << 16;
} else {
seg->mapped = seg->org;
}
}
bool collision = false;
// verify we aren't overlapping.. that would be tremendously bad.
for (int node = 0; node < numNodes; node += 2) {
if (seg->mapped < memory[node] &&
seg->mapped + seg->length > memory[node]) { // crosses!
collision = true;
}
if (seg->mapped < memory[node + 1] &&
seg->mapped + seg->length > memory[node + 1]) { // crosses!
collision = true;
}
}
if (collision) {
fprintf(stderr, "Segment #$%x collides with another segment!\n",
seg->segnum);
exit(-1);
}
memory[numNodes++] = seg->mapped;
memory[numNodes++] = seg->mapped + seg->length;
if (seg->mapped < memory[0]) { // below the minimum!
memory[0] = seg->mapped; // recalibrate the minimum
}
// resort memory map
qsort(memory, numNodes, sizeof(uint32_t), cmpmemory);
}
}
// finally, map everything else by first fit.
for (Segment *seg = segments; seg != NULL; seg = seg->next) {
if (seg->mapped == 0) {
for (int node = 0; node < numNodes; node += 2) {
uint32_t base = memory[node];
if (seg->align && (base & (seg->align - 1))) { // snap to alignment
base += seg->align;
base &= ~(seg->align - 1);
}
if (seg->banksize &&(((base & (seg->banksize - 1)) + seg->length) &
~(seg->banksize - 1))) { // crosses bank
base += seg->banksize;
base &= ~(seg->banksize - 1);
}
// does it fit?
if (base < memory[node + 1] && memory[node + 1] - base >= seg->length) {
seg->mapped = base;
memory[numNodes++] = seg->mapped;
memory[numNodes++] = seg->mapped + seg->length;
qsort(memory, numNodes, sizeof(uint32_t), cmpmemory);
break;
}
}
if (seg->mapped == 0) {
fprintf(stderr, "Failed to map Segment #$%x, not enough free memory\n",
seg->segnum);
exit(-1);
}
}
}
free(memory);
}
typedef enum {
DONE = 0x00,
RELOC = 0xe2,
INTERSEG = 0xe3,
DS = 0xf1,
LCONST = 0xf2,
cRELOC = 0xf5,
cINTERSEG = 0xf6,
SUPER = 0xf7
} SegOp;
static void patch(uint8_t *data, uint8_t numBytes, uint32_t value) {
for (int i = 0; i < numBytes; i++, value >>= 8) {
data[i] = value & 0xff;
}
}
static void hexout(char *p, uint32_t val, int len) {
p += len;
while (len-- > 0) {
char ch = val & 0xf;
val >>= 4;
if (ch < 10) {
*--p = '0' + ch;
} else {
*--p = 'a' + (ch - 10);
}
}
}
static void relocSegments(Segment *segments, char *prefix) {
int prefixLen = strlen(prefix);
char *filename = malloc(prefixLen + 4);
char *mapname = malloc(prefixLen + 9);
for (Segment *seg = segments; seg != NULL; seg = seg->next) {
bool done = false;
uint32_t pc = seg->mapped;
uint8_t *p = seg->offset;
seg->data = calloc(seg->length, 1);
while (!done) {
uint8_t opcode = *p++;
switch (opcode) {
case DONE:
done = true;
break;
case RELOC:
{
uint8_t numBytes = *p++;
int8_t bitShift = *p++;
uint32_t offset = r32(p); p += 4;
uint32_t subOffset = r32(p) + seg->mapped; p += 4;
if (bitShift < 0) {
subOffset >>= -bitShift;
} else {
subOffset <<= bitShift;
}
patch(seg->data + offset, numBytes, subOffset);
}
break;
case INTERSEG:
{
uint8_t numBytes = *p++;
int8_t bitShift = *p++;
uint32_t offset = r32(p); p += 4;
p += 2; // filenum
uint16_t segnum = r16(p); p += 2;
uint32_t subOffset = r32(p); p += 4;
for (Segment *sub = segments; sub != NULL; sub = sub->next) {
if (sub->segnum == segnum) {
subOffset += sub->mapped;
break;
}
}
if (bitShift < 0) {
subOffset >>= -bitShift;
} else {
subOffset <<= bitShift;
}
patch(seg->data + offset, numBytes, subOffset);
}
break;
case DS:
pc += r32(p); p += 4; // filled with zeros
break;
case LCONST:
{
uint32_t count = r32(p); p += 4;
memcpy(seg->data + pc - seg->mapped, p, count); p += count;
pc += count;
}
break;
case cRELOC:
{
uint8_t numBytes = *p++;
int8_t bitShift = *p++;
uint16_t offset = r16(p); p += 2;
uint32_t subOffset = r16(p) + seg->mapped; p += 2;
if (bitShift < 0) {
subOffset >>= -bitShift;
} else {
subOffset <<= bitShift;
}
patch(seg->data + offset, numBytes, subOffset);
}
break;
case cINTERSEG:
{
uint8_t numBytes = *p++;
int8_t bitShift = *p++;
uint16_t offset = r16(p); p += 2;
uint8_t segnum = *p++;
uint32_t subOffset = r16(p); p += 2;
for (Segment *sub = segments; sub != NULL; sub = sub->next) {
if (sub->segnum == segnum) {
subOffset += sub->mapped;
break;
}
}
if (bitShift < 0) {
subOffset >>= -bitShift;
} else {
subOffset <<= bitShift;
}
patch(seg->data + offset, numBytes, subOffset);
}
break;
case SUPER:
{
uint32_t superLen = r32(p); p += 4;
uint8_t *superEnd = p + superLen;
uint8_t superType = *p++;
uint32_t superPage = 0;
while (p < superEnd) {
uint8_t numOfs = *p++;
if (numOfs & 0x80) {
superPage += 256 * (numOfs & 0x7f);
continue;
}
for (int o = 0; o <= numOfs; o++) {
uint32_t offset = superPage | *p++;
uint8_t numBytes = 0;
uint32_t subOffset = r16(seg->data + offset);
if (superType == 0 || superType == 1) { // RELOC2 | RELOC3
subOffset += seg->mapped;
numBytes = 2 + superType;
} else if (superType < 14) { // INTERSEG1--12
uint8_t segnum = seg->data[offset + 2];
for (Segment *sub = segments; sub != NULL; sub = sub->next) {
if (sub->segnum == segnum) {
subOffset += sub->mapped;
break;
}
}
numBytes = 3;
} else if (superType < 26) { // INTERSEG13--24
uint8_t segnum = superType - 13;
for (Segment *sub = segments; sub != NULL; sub = sub->next) {
if (sub->segnum == segnum) {
subOffset += sub->mapped;
break;
}
}
numBytes = 2;
} else { // INTERSEG25--36
uint8_t segnum = superType - 25;
for (Segment *sub = segments; sub != NULL; sub = sub->next) {
if (sub->segnum == segnum) {
subOffset += sub->mapped;
break;
}
}
subOffset >>= 16;
numBytes = 2;
}
patch(seg->data + offset, numBytes, subOffset);
}
superPage += 256;
}
}
break;
default:
if (opcode < 0xe0) {
memcpy(seg->data + pc - seg->mapped, p, opcode); p += opcode;
pc += opcode;
} else {
fprintf(stderr, "Unknown segment code: %x\n", opcode);
exit(-1);
}
break;
}
}
memcpy(filename, prefix, prefixLen);
int numLen = 3;
if (seg->segnum < 0x10) {
numLen = 1;
} else if (seg->segnum < 0x100) {
numLen = 2;
}
hexout(filename + prefixLen, seg->segnum, numLen);
filename[prefixLen + numLen] = 0;
memcpy(mapname, filename, prefixLen + numLen);
memcpy(mapname + prefixLen + numLen, ".map\0", 5);
FILE *f = fopen(filename, "wb");
if (!f) {
fprintf(stderr, "Failed to create '%s'\n", filename);
exit(-1);
}
fwrite(seg->data, 1, seg->length, f);
fclose(f);
f = fopen(mapname, "wb");
if (!f) {
fprintf(stderr, "Failed to create '%s'\n", mapname);
exit(-1);
}
fprintf(f, "gMAP \"%s\"\n", filename);
fprintf(f, "sORG $%x\n", seg->mapped);
if ((seg->kind & 0x1f) == 0) { // code
fprintf(f, "$%x:\n", seg->mapped + seg->entry);
}
fclose(f);
fprintf(stdout, "Extracted Segment #$%x %s into %s\n", seg->segnum,
seg->name, filename);
fprintf(stdout, "Created map %s\n", mapname);
}
free(filename);
}

66
parser.c Normal file
View File

@ -0,0 +1,66 @@
/**
* @copyright 2018 Sean Kasun
* Routines for parsing a simple config file
*/
#include "parser.h"
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
void fail(ConfigFile *f, char *format, ...) {
// calculate line and column
int line = 1;
int col = 1;
bool done = false;
while (f->p > f->start) {
if (*f->p == '\n') {
done = true;
line++;
}
if (!done) {
col++;
}
f->p--;
}
va_list args;
va_start(args, format);
fprintf(stderr, "%s[%d,%d] Error: ", f->filename, line, col);
vfprintf(stderr, format, args);
fprintf(stderr, "\n");
va_end(args);
exit(-1);
}
void eatSpaces(ConfigFile *f) {
while (f->p < f->end && isspace(*f->p)) {
f->p++;
}
}
bool token(ConfigFile *f, char ch) {
eatSpaces(f);
if (f->p < f->end && *f->p == ch) { // found it, consume
f->p++;
return true;
}
// not found, don't consume anything
return false;
}
uint32_t hex(ConfigFile *f) {
eatSpaces(f);
uint32_t res = 0;
while (f->p < f->end && isxdigit(*f->p)) {
res <<= 4;
if (*f->p >= '0' && *f->p <= '9') {
res |= *f->p - '0';
} else if (*f->p >= 'a' && *f->p <= 'f') {
res |= *f->p - 'a' + 10;
} else if (*f->p >= 'A' && *f->p <= 'F') {
res |= *f->p - 'A' + 10;
}
f->p++;
}
return res;
}

22
parser.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* Routines for parsing simple config files
*/
#include <stdint.h>
#include <stdarg.h>
#include <stdbool.h>
typedef struct {
uint8_t *start;
uint8_t *p;
uint8_t *end;
const char *filename;
} ConfigFile;
extern void fail(ConfigFile *f, char *format, ...);
extern void eatSpaces(ConfigFile *f);
extern bool token(ConfigFile *f, char ch);
extern uint32_t hex(ConfigFile *f);

42
pascal/ace.p Executable file
View File

@ -0,0 +1,42 @@
{********************************************
; File: ACE.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT ACE;
INTERFACE
USES TYPES;
(* *** Toolset Errors ***
CONST
aceNoError = $0; {Error - }
aceIsActive = $1D01; {Error - }
aceBadDP = $1D02; {Error - }
aceNotActive = $1D03; {Error - }
aceNoSuchParam = $1D04; {Error - }
aceBadMethod = $1D05; {Error - }
aceBadSrc = $1D06; {Error - }
aceBadDest = $1D07; {Error - }
aceDataOverlap = $1D08; {Error - }
aceNotImplemented = $1DFF; {Error - }
*** Toolset Errors *** *)
PROCEDURE ACEBootInit ; Tool $1D,$01;
PROCEDURE ACEStartUp ( dPageAddr:Integer) ; Tool $1D,$02;
PROCEDURE ACEShutDown ; Tool $1D,$03;
FUNCTION ACEVersion : Integer ; Tool $1D,$04;
PROCEDURE ACEReset ; Tool $1D,$05;
FUNCTION ACEStatus : Boolean ; Tool $1D,$06;
FUNCTION ACEInfo ( infoItemCode:Integer) : Longint ; Tool $1D,$07;
PROCEDURE ACECompBegin ; Tool $1D,$0B;
PROCEDURE ACECompress ( src:Handle; srcOffset:Longint; dest:Handle;
destOffset:Longint; nBlks:Integer; method:Integer) ; Tool $1D,$09;
PROCEDURE ACEExpand ( src:Handle; srcOffset:Longint; dest:Handle;
destOffset:Longint; nBlks:Integer; method:Integer) ; Tool $1D,$0A;
PROCEDURE ACEExpBegin ; Tool $1D,$0C;
IMPLEMENTATION
END.

102
pascal/adb.p Executable file
View File

@ -0,0 +1,102 @@
{********************************************
; File: ADB.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT ADB;
INTERFACE
USES TYPES;
CONST
(* *** Toolset Errors ***
cmndIncomplete = $0910; {error - Command not completed. }
cantSync = $0911; {error - Can't synchronize }
adbBusy = $0982; {error - Busy (command pending) }
devNotAtAddr = $0983; {error - Device not present at address }
srqListFull = $0984; {error - List full }
*** Toolset Errors *** *)
readModes = $000A; {ReadKeyMicroData - }
readConfig = $000B; {ReadKeyMicroData - }
readADBError = $000C; {ReadKeyMicroData - }
readVersionNum = $000D; {ReadKeyMicroData - }
readAvailCharSet = $000E; {ReadKeyMicroData - }
readAvailLayout = $000F; {ReadKeyMicroData - }
readMicroMem = $0009; {ReadKeyMicroMem - }
abort = $0001; {SendInfo - command }
resetKbd = $0002; {SendInfo - command }
flushKbd = $0003; {SendInfo - command }
setModes = $0004; {SendInfo - 2nd param is pointer to mode byte }
clearModes = $0005; {SendInfo - 2nd param is pointer to mode Byte }
setConfig = $0006; {SendInfo - 2nd param is pointer to SetConfigRec }
synch = $0007; {SendInfo - 2nd param is pointer to SynchRec }
writeMicroMem = $0008; {SendInfo - 2nd param is pointer to MicroControlMemRec }
resetSys = $0010; {SendInfo - command }
keyCode = $0011; {SendInfo - 2nd param is pointer to key code byte. }
resetADB = $0040; {SendInfo - command }
transmitADBBytes = $0047; {SendInfo - add number of bytes to this }
enableSRQ = $0050; {SendInfo - command - ADB address in low nibble }
flushADBDevBuf = $0060; {SendInfo - command - ADB address in low nibble }
disableSRQ = $0070; {SendInfo - command - ADB address in low nibble }
transmit2ADBBytes = $0080; {SendInfo - add ADB address to this }
listen = $0080; {SendInfo - adbCommand = listen + ( 16 * reg) + (adb address) }
talk = $00C0; {SendInfo - adbCommand = talk + ( 16 * reg) + (adb address) }
TYPE
ReadConfigRecPtr = ^ReadConfigRec;
ReadConfigRec = PACKED RECORD
rcRepeatDelay : Byte; { Output Byte: Repeat / Delay }
rcLayoutOrLang : Byte; { Output Byte: Layout / Language }
rcADBAddr : Byte; { Output Byte: ADB address - keyboard and mouse }
END;
SetConfigRecPtr = ^SetConfigRec;
SetConfigRec = PACKED RECORD
scADBAddr : Byte; { keyboard and mouse }
scLayoutOrLang : Byte;
scRepeatDelay : Byte;
END;
SynchRecPtr = ^SynchRec;
SynchRec = PACKED RECORD
synchMode : Byte;
synchKybdMouseAddr : Byte;
synchLayoutOrLang : Byte;
synchRepeatDelay : Byte;
END;
ScaleRecPtr = ^ScaleRec;
ScaleRec = RECORD
xDivide : Integer;
yDivide : Integer;
xOffset : Integer;
yOffset : Integer;
xMultiply : Integer;
yMultiply : Integer;
END;
PROCEDURE ADBBootInit ; Tool $09,$01;
PROCEDURE ADBStartUp ; Tool $09,$02;
PROCEDURE ADBShutDown ; Tool $09,$03;
FUNCTION ADBVersion : Integer ; Tool $09,$04;
PROCEDURE ADBReset ; Tool $09,$05;
FUNCTION ADBStatus : Boolean ; Tool $09,$06;
PROCEDURE AbsOff ; Tool $09,$10;
PROCEDURE AbsOn ; Tool $09,$0F;
PROCEDURE AsyncADBReceive ( compPtr:Ptr) ; Tool $09,$0D;
PROCEDURE ClearSRQTable ; Tool $09,$16;
PROCEDURE GetAbsScale (VAR dataInPtr:ScaleRec) ; Tool $09,$13;
FUNCTION ReadAbs : Integer ; Tool $09,$11;
PROCEDURE ReadKeyMicroData ( dataLength:Integer; dataPtr:Ptr;
adbCommand:Integer) ; Tool $09,$0A;
PROCEDURE ReadKeyMicroMem ( dataLength:Integer; dataPtr:Ptr;
adbCommand:Integer) ; Tool $09,$0B;
PROCEDURE SendInfo ( dataLength:Integer; dataPtr:Ptr; adbCommand:Integer) ;
Tool $09,$09;
PROCEDURE SetAbsScale ( dataOutPtr:ScaleRec) ; Tool $09,$12;
PROCEDURE SRQPoll ( compPtr:Ptr; adbRegAddr:Integer) ; Tool $09,$14;
PROCEDURE SRQRemove ( adbRegAddr:Integer) ; Tool $09,$15;
PROCEDURE SyncADBReceive ( inputWord:Integer; compPtr:Ptr; adbCommand:Integer)
; Tool $09,$0E;
IMPLEMENTATION
END.

166
pascal/applesharefst.p Executable file
View File

@ -0,0 +1,166 @@
{********************************************
; File: AppleShareFST.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT APPLESHAREFST;
INTERFACE
USES TYPES,GSOS;
CONST
ASBufferControl = $0001; {Command Number - }
ASByteRangeLock = $0002; {Command Number - }
ASSpecialOpenFork = $0003; {Command Number - }
ASGetPrivileges = $0004; {Command Number - }
ASSetPrivileges = $0005; {Command Number - }
ASUserInfo = $0006; {Command Number - }
ASCopyFile = $0007; {Command Number - }
ASGetUserPath = $0008; {Command Number - }
ASOpenDesktop = $0009; {Command Number - }
ASCloseDesktop = $000A; {Command Number - }
ASGetComment = $000B; {Command Number - }
ASSetComment = $000C; {Command Number - }
ASGetServerName = $000D; {Command Number - }
appleShareNetError = $0088; {Error - AppleShare Network Error }
unknownUser = $007E; {Error - specified user name not registered }
unknownGroup = $007F; {Error - specified group name not the name of a group }
lockRange = $8000; {Mask - }
relativeToEOF = $4000; {Mask - }
seeFolders = $00; {Mask - }
seeFiles = $02; {Mask - }
makeChanges = $0004; {Mask - }
folderOwner = $80; {Mask - }
onDesktop = $0001; {File Info Mask - }
bFOwnAppl = $0002; {File Info Mask - used internally }
bFNever = $0010; {File Info Mask - never SwitchLaunch }
bFAlways = $0020; {File Info Mask - always SwitchLaunch }
shareApplication = $0040; {File Info Mask - set if file is a shareable
application }
fileIsInited = $0100; {File Info Mask - seen by Finder }
fileHasChanged = $0200; {File Info Mask - used internally by Finder }
fileIsBusy = $0400; {File Info Mask - copied from File System busy bit }
fileNoCopy = $0800; {File Info Mask - not used in 5.0 and later, formally BOZO
}
fileIsSystem = $1000; {File Info Mask - set if file is a system file }
fileHasBundle = $2000; {File Info Mask - }
fileIsInvisible = $4000; {File Info Mask - }
fileIsLocked = $8000; {File Info Mask - }
inTrashWindow = $FFFD; {Window Info Mask - }
inDesktopWindow = $FFFE; {Window Info Mask - }
inDiskWindow = $0000; {Window Info Mask - }
requestReadAccess = $0000; {accessWord Mask - }
requestWriteAccess = $0002; {accessWord Mask - }
denyReadAccess = $0010; {accessWord Mask - }
denyWriteAccess = $0020; {accessWord Mask - }
dataForkNum = $0000; {forkNum Mask - }
resourceForkNum = $0001; {forkNum Mask - }
TYPE
CommandBlock = RECORD
pCount : Integer;
fstNum : Integer;
commandNum : Integer;
END;
BufferControlRecPtr = ^BufferControlRec;
BufferControlRec = RECORD
pBlock : CommandBlock;
refNum : Integer;
flags : Integer;
END;
SpecialOpenForkRecPtr = ^SpecialOpenForkRec;
SpecialOpenForkRec = RECORD
pBlock : CommandBlock;
pathname : GSString255Ptr;
accessMode : Integer;
forkNum : Integer;
END;
ByteRangeLockRecPtr = ^ByteRangeLockRec;
ByteRangeLockRec = RECORD
pBlock : CommandBlock;
referenceNum : Integer;
lockFlag : Integer;
fileOffset : Longint;
rangeLength : Longint;
rangeStart : Longint;
END;
GetAccessRightsRecPtr = ^GetAccessRightsRec;
GetAccessRightsRec = PACKED RECORD
reserved : Byte;
world : Byte;
group : Byte;
owner : Byte;
END;
GetPrivilegesRecPtr = ^GetPrivilegesRec;
GetPrivilegesRec = RECORD
pBlock : CommandBlock;
pathname : GSString255Ptr;
accessRights : GetAccessRightsRec;
ownerName : ResultBuf255Ptr;
groupName : ResultBuf255Ptr;
END;
SetAccessRightsRecPtr = ^SetAccessRightsRec;
SetAccessRightsRec = PACKED RECORD
userSummary : Byte;
world : Byte;
group : Byte;
owner : Byte;
END;
SetPrivilegesRecPtr = ^SetPrivilegesRec;
SetPrivilegesRec = RECORD
pBlock : CommandBlock;
pathname : GSString255Ptr;
accessRights : SetAccessRightsRec;
ownerName : ResultBuf255Ptr;
groupName : ResultBuf255Ptr;
END;
UserInfoRecPtr = ^UserInfoRec;
UserInfoRec = RECORD
pBlock : CommandBlock;
deviceNum : Integer;
userName : ResultBuf255Ptr;
primaryGroupName : ResultBuf255Ptr;
END;
CopyFileRecPtr = ^CopyFileRec;
CopyFileRec = RECORD
pBlock : CommandBlock;
sourcePathname : GSString255Ptr;
destPathname : GSString255Ptr;
END;
GetUserPathRecPtr = ^GetUserPathRec;
GetUserPathRec = RECORD
pBlock : CommandBlock;
prefix : ResultBuf255Ptr;
END;
DesktopRecPtr = ^DesktopRec;
DesktopRec = RECORD
pBlock : CommandBlock;
desktopRefNum : Integer;
pathname : GSString255Ptr;
END;
GetCommentRecPtr = ^GetCommentRec;
GetCommentRec = RECORD
pBlock : CommandBlock;
desktopRefNum : Integer;
pathname : GSString255Ptr;
comment : ResultBuf255Ptr;
END;
SetCommentRecPtr = ^SetCommentRec;
SetCommentRec = RECORD
pBlock : CommandBlock;
desktopRefNum : Integer;
pathname : GSString255Ptr;
comment : GSString255Ptr;
END;
GetServerNameRecPtr = ^GetServerNameRec;
GetServerNameRec = RECORD
pBlock : CommandBlock;
pathname : GSString255Ptr;
serverName : ResultBuf255Ptr;
zoneName : ResultBuf255Ptr;
END;
IMPLEMENTATION
END.

274
pascal/controls.p Executable file
View File

@ -0,0 +1,274 @@
{********************************************
; File: Controls.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT CONTROLS;
INTERFACE
USES TYPES,QUICKDRAW,EVENTS;
CONST
wmNotStartedUp = $1001; {error - Window manager was not started first. }
noConstraint = $0000; {Axis Parameter - No constraint on movement. }
hAxisOnly = $0001; {Axis Parameter - Horizontal axis only. }
vAxisOnly = $0002; {Axis Parameter - Vertical axis only. }
simpRound = $0000; {CtlFlag - Simple button flag }
upFlag = $0001; {CtlFlag - Scroll bar flag. }
boldButton = $0001; {CtlFlag - Bold round cornered outlined button. }
simpBRound = $0001; {CtlFlag - Simple button flag }
downFlag = $0002; {CtlFlag - Scroll bar flag. }
simpSquare = $0002; {CtlFlag - Simple button flag }
simpDropSquare = $0003; {CtlFlag - Simple button flag }
leftFlag = $0004; {CtlFlag - Scroll bar flag. }
rightFlag = $0008; {CtlFlag - Scroll bar flag. }
dirScroll = $0010; {CtlFlag - Scroll bar flag. }
horScroll = $0010; {CtlFlag - Scroll bar flag. }
family = $007F; {CtlFlag - Mask for radio button family number }
ctlInVis = $0080; {CtlFlag - invisible mask for any type of control }
inListBox = $88; {CtlFlag - }
simpleProc = $00000000; {CtlProc - }
checkProc = $02000000; {CtlProc - }
radioProc = $04000000; {CtlProc - }
scrollProc = $06000000; {CtlProc - }
growProc = $08000000; {CtlProc - }
drawCtl = $0000; {DefProc - Draw control command. }
calcCRect = $0001; {DefProc - Compute drag RECT command. }
testCtl = $0002; {DefProc - Hit test command. }
initCtl = $0003; {DefProc - Initialize command. }
dispCtl = $0004; {DefProc - Dispose command. }
posCtl = $0005; {DefProc - Move indicator command. }
thumbCtl = $0006; {DefProc - Compute drag parameters command. }
dragCtl = $0007; {DefProc - Drag command. }
autoTrack = $0008; {DefProc - Action command. }
newValue = $0009; {DefProc - Set new value command. }
setParams = $000A; {DefProc - Set new parameters command. }
moveCtl = $000B; {DefProc - Move command. }
recSize = $000C; {DefProc - Return record size command. }
noHilite = $0000; {hiliteState - Param to HiliteControl }
inactiveHilite = $00FF; {hiliteState - Param to HiliteControl }
noPart = $0000; {PartCode - }
simpleButton = $0002; {PartCode - }
checkBox = $0003; {PartCode - }
radioButton = $0004; {PartCode - }
upArrow = $0005; {PartCode - }
downArrow = $0006; {PartCode - }
pageUp = $0007; {PartCode - }
pageDown = $0008; {PartCode - }
growBox = $000A; {PartCode - }
thumb = $0081; {PartCode - }
fCtlTarget = $8000; {CtlRec.ctlMoreFlags - is current target of typing commands
}
fCtlCanBeTarget = $4000; {CtlRec.ctlMoreFlags - can be made the target control
}
fCtlWantEvents = $2000; {CtlRec.ctlMoreFlags - control can be called view
SendEventToCtl }
fCtlProcRefNotPtr = $1000; {CtlRec.ctlMoreFlags - set = ID of defproc, clear =
pointer to defproc }
fCtlTellAboutSize = $0800; {CtlRec.ctlMoreFlags - set if ctl needs notification
when size of owning window changes }
fCtlIsMultiPar = $0400; {CtlRec.ctlMoreFlags - set if ctl needs notification to
be hidden }
titleIsPtr = $00; {Ctl Verb - }
titleIsHandle = $01; {Ctl Verb - }
titleIsResource = $02; {Ctl Verb - }
colorTableIsPtr = $00; {Ctl Verb - }
colorTableIsHandle = $04; {Ctl Verb - }
colorTableIsResource = $08; {Ctl Verb - }
ctlHandleEvent = $0D; {DefProc message - }
ctlChangeTarget = $0E; {DefProc message - }
ctlChangeBounds = $0F; {DefProc message - }
ctlWindChangeSize = $10; {DefProc message - }
ctlHandleTab = $11; {DefProc message - }
ctlHideCtl = $12; {DefProc message - }
singlePtr = $0000; {InputVerb - }
singleHandle = $0001; {InputVerb - }
singleResource = $0002; {InputVerb - }
ptrToPtr = $0003; {InputVerb - }
ptrToHandle = $0004; {InputVerb - }
ptrToResource = $0005; {InputVerb - }
handleToPtr = $0006; {InputVerb - }
handleToHandle = $0007; {InputVerb - }
handleToResource = $0008; {InputVerb - }
resourceToResource = $0009; {InputVerb - }
simpleButtonControl = $80000000; {ProcRefs - }
checkControl = $82000000; {ProcRefs - }
radioControl = $84000000; {ProcRefs - }
scrollBarControl = $86000000; {ProcRefs - }
growControl = $88000000; {ProcRefs - }
statTextControl = $81000000; {ProcRefs - }
editLineControl = $83000000; {ProcRefs - }
editTextControl = $85000000; {ProcRefs - }
popUpControl = $87000000; {ProcRefs - }
listControl = $89000000; {ProcRefs - }
iconButtonControl = $07FF0001; {ProcRefs - }
pictureControl = $8D000000; {ProcRefs - }
(* *** Toolset Errors ***
noCtlError = $1004; {Error - no controls in window }
noSuperCtlError = $1005; {Error - no super controls in window }
noCtlTargetError = $1006; {Error - no target super control }
notSuperCtlError = $1007; {Error - action can only be done on super control }
canNotBeTargetError = $1008; {Error - conrol cannot be made target }
noSuchIDError = $1009; {Error - specified ID cannot be found }
tooFewParmsError = $100A; {Error - not enough params specified }
noCtlToBeTargetError = $100B; {Error - NextCtl call, no ctl could be target }
noWind_Err = $100C; {Error - there is no front window }
*** Toolset Errors *** *)
TYPE
WindowPtr = GrafPortPtr ;
BarColorsHndl = ^BarColorsPtr;
BarColorsPtr = ^BarColors;
BarColors = RECORD
barOutline : Integer; { color for outlining bar, arrows, and thumb }
barNorArrow : Integer; { color of arrows when not highlighted }
barSelArrow : Integer; { color of arrows when highlighted }
barArrowBack : Integer; { color of arrow box's background }
barNorThumb : Integer; { color of thumb's background when not highlighted }
barSelThumb : Integer; { color of thumb's background when highlighted }
barPageRgn : Integer; { color and pattern page region: high byte - 1=
dither, 0 = solid }
barInactive : Integer; { color of scroll bar's interior when inactive }
END;
BoxColorsHndl = ^BoxColorsPtr;
BoxColorsPtr = ^BoxColors;
BoxColors = RECORD
boxReserved : Integer; { reserved }
boxNor : Integer; { color of box when not checked }
boxSel : Integer; { color of box when checked }
boxTitle : Integer; { color of check box's title }
END;
BttnColorsHndl = ^BttnColorsPtr;
BttnColorsPtr = ^BttnColors;
BttnColors = RECORD
bttnOutline : Integer; { color of outline }
bttnNorBack : Integer; { color of background when not selected }
bttnSelBack : Integer; { color of background when selected }
bttnNorText : Integer; { color of title's text when not selected }
bttnSelText : Integer; { color of title's text when selected }
END;
CtlRecHndlPtr = ^CtlRecHndl;
CtlRecHndl = ^CtlRecPtr;
CtlRecPtr = ^CtlRec;
CtlRec = PACKED RECORD
ctlNext : CtlRecHndl; { Handle of next control. }
ctlOwner : WindowPtr; { Pointer to control's window. }
ctlRect : Rect; { Enclosing rectangle. }
ctlFlag : Byte; { Bit flags. }
ctlHilite : Byte; { Highlighted part. }
ctlValue : Integer; { Control's value. }
ctlProc : LongProcPtr; { Control's definition procedure. }
ctlAction : LongProcPtr; { Control's action procedure. }
ctlData : Longint; { Reserved for CtrlProc's use. }
ctlRefCon : Longint; { Reserved for application's use. }
ctlColor : Ptr; { Pointer to appropriate color table. }
ctlReserved : PACKED ARRAY[1..16] OF Byte; { Reserved for future expansion
}
ctlID : Longint;
ctlMoreFlags : Integer;
ctlVersion : Integer;
END;
LimitBlkHndl = ^LimitBlkPtr;
LimitBlkPtr = ^LimitBlk;
LimitBlk = RECORD
boundRect : Rect; { Drag bounds. }
slopRect : Rect; { Cursor bounds. }
axisParam : Integer; { Movement constrains. }
dragPatt : Ptr; { Pointer to 32 byte Pattern for drag outline. }
END;
RadioColorsHndl = ^RadioColorsPtr;
RadioColorsPtr = ^RadioColors;
RadioColors = RECORD
radReserved : Integer; { reserved }
radNor : Integer; { color of radio button when off }
radSel : Integer; { color of radio button when on }
radTitle : Integer; { color of radio button's title text }
END;
PROCEDURE CtlBootInit ; Tool $10,$01;
PROCEDURE CtlStartUp ( userID:Integer; dPageAddr:Integer) ; Tool $10,$02;
PROCEDURE CtlShutDown ; Tool $10,$03;
FUNCTION CtlVersion : Integer ; Tool $10,$04;
PROCEDURE CtlReset ; Tool $10,$05;
FUNCTION CtlStatus : Boolean ; Tool $10,$06;
PROCEDURE CtlNewRes ; Tool $10,$12;
PROCEDURE DisposeControl ( theControlHandle:CtlRecHndl) ; Tool $10,$0A;
PROCEDURE DragControl ( startX:Integer; startY:Integer; limitRectPtr:Rect;
slopRectPtr:Rect; dragFlag:Integer; theControlHandle:CtlRecHndl) ; Tool
$10,$17;
FUNCTION DragRect ( actionProcPtr:VoidProcPtr; dragPatternPtr:Pattern;
startX:Integer; startY:Integer; dragRectPtr:Rect; limitRectPtr:Rect;
slopRectPtr:Rect; dragFlag:Integer) : Longint ; Tool $10,$1D;
PROCEDURE DrawControls ( theWindowPtr:WindowPtr) ; Tool $10,$10;
PROCEDURE DrawOneCtl ( theControlHandle:CtlRecHndl) ; Tool $10,$25;
PROCEDURE EraseControl ( theControlHandle:CtlRecHndl) ; Tool $10,$24;
FUNCTION FindControl (VAR foundCtl:CtlRecHndl; pointX:Integer; pointY:Integer;
theWindowPtr:WindowPtr) : Integer ; Tool $10,$13;
FUNCTION GetCtlAction ( theControlHandle:CtlRecHndl) : LongProcPtr ; Tool
$10,$21;
FUNCTION GetCtlDPage : Integer ; Tool $10,$1F;
FUNCTION GetCtlParams ( theControlHandle:CtlRecHndl) : Longint ; Tool $10,$1C;
FUNCTION GetCtlRefCon ( theControlHandle:CtlRecHndl) : Longint ; Tool $10,$23;
FUNCTION GetCtlTitle ( theControlHandle:CtlRecHndl) : Ptr ; Tool $10,$0D;
FUNCTION GetCtlValue ( theControlHandle:CtlRecHndl) : Integer ; Tool $10,$1A;
FUNCTION GrowSize : Longint ; Tool $10,$1E;
PROCEDURE HideControl ( theControlHandle:CtlRecHndl) ; Tool $10,$0E;
PROCEDURE HiliteControl ( hiliteState:Integer; theControlHandle:CtlRecHndl) ;
Tool $10,$11;
PROCEDURE KillControls ( theWindowPtr:WindowPtr) ; Tool $10,$0B;
PROCEDURE MoveControl ( newX:Integer; newY:Integer;
theControlHandle:CtlRecHndl) ; Tool $10,$16;
FUNCTION NewControl ( theWindowPtr:WindowPtr; boundsRectPtr:Rect; titlePtr:Ptr;
flag:Integer; value :Integer; param1:Integer; param2:Integer;
defProcPtr:LongProcPtr; refCon:Longint; U__colorTablePtr:Ptr) : CtlRecHndl ;
Tool $10,$09;
PROCEDURE SetCtlAction ( newActionPtr:LongProcPtr; theControlHandle:CtlRecHndl)
; Tool $10,$20;
FUNCTION SetCtlIcons ( newFontHandle:FontHndl) : FontHndl ; Tool $10,$18;
PROCEDURE SetCtlParams ( param2:Integer; param1:Integer;
theControlHandle:CtlRecHndl) ; Tool $10,$1B;
PROCEDURE SetCtlRefCon ( newRefCon:Longint; theControlHandle:CtlRecHndl) ;
Tool $10,$22;
PROCEDURE SetCtlTitle ( title:Str255; theControlHandle:CtlRecHndl) ; Tool
$10,$0C;
PROCEDURE SetCtlValue ( curValue:Integer; theControlHandle:CtlRecHndl) ; Tool
$10,$19;
PROCEDURE ShowControl ( theControlHandle:CtlRecHndl) ; Tool $10,$0F;
FUNCTION TestControl ( pointX:Integer; pointY:Integer;
theControlHandle:CtlRecHndl) : Integer ; Tool $10,$14;
FUNCTION TrackControl ( startX:Integer; startY:Integer;
actionProcPtr:LongProcPtr; theControlHndl:CtlRecHndl) : Integer ; Tool $10,$15;
FUNCTION NewControl2 ( ownerPtr:WindowPtr; inputDesc:RefDescriptor;
inputRef:Ref) : CtlRecHndl ; Tool $10,$31;
FUNCTION FindTargetCtl : CtlRecHndl ; Tool $10,$26;
FUNCTION MakeNextCtlTarget : CtlRecHndl ; Tool $10,$27;
PROCEDURE MakeThisCtlTarget ( targetCtlRecHndl:CtlRecHndl) ; Tool $10,$28;
PROCEDURE CallCtlDefProc ( U__ctlRecHndl:CtlRecHndl; defProcMessage:Integer;
U__param:Longint) ; Tool $10,$2C;
PROCEDURE NotifyControls ( U__mask:Integer; message:Integer; U__param:Longint;
window:WindowPtr) ; Tool $10,$2D;
FUNCTION SendEventToCtl ( targetOnlyFlag:Integer; U__WindowPtr:WindowPtr;
extendedTaskRecPtr:Ptr) : Boolean ; Tool $10,$29;
FUNCTION GetCtlID ( theCtlHandle:CtlRecHndl) : Longint ; Tool $10,$2A;
PROCEDURE SetCtlID ( newID:Longint; theCtlHandle:CtlRecHndl) ; Tool $10,$2B;
FUNCTION GetCtlMoreFlags ( theCtlHandle:CtlRecHndl) : Longint ; Tool $10,$2E;
FUNCTION SetCtlMoreFlags ( newID:Longint; theCtlHandle:CtlRecHndl) : Longint ;
Tool $10,$2F;
FUNCTION GetCtlHandleFromID ( U__WindowPtr:WindowPtr; ControlID:Longint) :
CtlRecHndl ; Tool $10,$30;
PROCEDURE SetCtlParamPtr ( SubArrayPtr:Ptr) ; Tool $10,$34;
FUNCTION GetCtlParamPtr : Ptr ; Tool $10,$35;
FUNCTION CMLoadResource ( U__ResType:Integer; U__ResID:Longint) : Handle ; Tool
$10,$32;
PROCEDURE CMReleaseResource ( U__ResType:Integer; U__ResID:Longint) ; Tool
$10,$33;
PROCEDURE InvalCtls ( U__WindowPtr:Longint) ; Tool $10,$37;
PROCEDURE NotifyCtls ( moreFlagsMask:Integer; message:Integer; param:Longint;
theGrafPortPtr:GrafPort) ; Tool $10,$2D;
IMPLEMENTATION
END.

38
pascal/ctiutils.p Executable file
View File

@ -0,0 +1,38 @@
UNIT CTIUtils;
INTERFACE
USES
FUNCTION Int2String
FUNCTION LongInt2String
FUNCTION Real2String
FUNCTION String2Int
FUNCTION String2LongInt
FUNCTION String2Real
procedure P2GSstring
procedure GS2Pstring
PROCEDURE StuffHex
PROCEDURE CallCode
nBytesIn: integer; BytesIn: univ ptr;
nBytesOut: integer; BytesOut: univ ptr );
IMPLEMENTATION
END.

67
pascal/desk.p Executable file
View File

@ -0,0 +1,67 @@
{********************************************
; File: Desk.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT DESK;
INTERFACE
USES TYPES,QUICKDRAW,EVENTS;
CONST
(* *** Toolset Errors ***
daNotFound = $0510; {error - desk accessory not found }
notSysWindow = $0511; {error - not the system window }
*** Toolset Errors *** *)
eventAction = $0001; {NDA action code - }
runAction = $0002; {NDA action code - }
undoAction = $0005; {NDA action code - }
cutAction = $0006; {NDA action code - }
copyAction = $0007; {NDA action code - }
pasteAction = $0008; {NDA action code - }
clearAction = $0009; {NDA action code - }
cursorAction = $0003; {NDAaction code - }
kUndo = $0001; {System Edit - edit type }
kCut = $0002; {System Edit - edit type }
kCopy = $0003; {System Edit - edit type }
kPaste = $0004; {System Edit - edit type }
kClear = $0005; {System Edit - edit type }
PROCEDURE DeskBootInit ; Tool $05,$01;
PROCEDURE DeskStartUp ; Tool $05,$02;
PROCEDURE DeskShutDown ; Tool $05,$03;
FUNCTION DeskVersion : Integer ; Tool $05,$04;
PROCEDURE DeskReset ; Tool $05,$05;
FUNCTION DeskStatus : Boolean ; Tool $05,$06;
PROCEDURE ChooseCDA ; Tool $05,$11;
PROCEDURE CloseAllNDAs ; Tool $05,$1D;
PROCEDURE CloseNDA ( refNum:Integer) ; Tool $05,$16;
PROCEDURE CloseNDAByWinPtr ( theWindowPtr:GrafPortPtr) ; Tool $05,$1C;
PROCEDURE FixAppleMenu ( startingID:Integer) ; Tool $05,$1E;
FUNCTION GetDAStrPtr : Ptr ; Tool $05,$14;
FUNCTION GetNumNDAs : Integer ; Tool $05,$1B;
PROCEDURE InstallCDA ( idHandle:Handle) ; Tool $05,$0F;
PROCEDURE InstallNDA ( idHandle:Handle) ; Tool $05,$0E;
FUNCTION OpenNDA ( idNum:Integer) : Integer ; Tool $05,$15;
PROCEDURE RestAll ; Tool $05,$0C;
PROCEDURE RestScrn ; Tool $05,$0A;
PROCEDURE SaveAll ; Tool $05,$0B;
PROCEDURE SaveScrn ; Tool $05,$09;
PROCEDURE SetDAStrPtr ( altDispHandle:Handle; stringTablePtr:Ptr) ; Tool
$05,$13;
PROCEDURE SystemClick ( eventRecPtr:EventRecord; theWindowPtr:GrafPortPtr;
findWndwResult:Integer) ; Tool $05,$17;
FUNCTION SystemEdit ( editType:Integer) : Boolean ; Tool $05,$18;
FUNCTION SystemEvent ( eventWhat:Integer; eventMessage:Longint;
eventWhen:Longint; eventWhere:Point; eventMods:Integer) : Boolean ; Tool
$05,$1A;
PROCEDURE SystemTask ; Tool $05,$19;
PROCEDURE AddToRunQ ( headerPtr:Ptr) ; Tool $05,$1F;
PROCEDURE RemoveFromRunQ ( headerPtr:Ptr) ; Tool $05,$20;
PROCEDURE RemoveCDA ( idHandle:Handle) ; Tool $05,$21;
PROCEDURE RemoveNDA ( idHandle:Handle) ; Tool $05,$22;
IMPLEMENTATION
END.

205
pascal/dialogs.p Executable file
View File

@ -0,0 +1,205 @@
{********************************************
; File: Dialogs.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT DIALOGS;
INTERFACE
USES TYPES,QUICKDRAW,EVENTS,CONTROLS,WINDOWS,LINEEDIT;
CONST
(* *** Toolset Errors ***
badItemType = $150A; {error - }
newItemFailed = $150B; {error - }
itemNotFound = $150C; {error - }
notModalDialog = $150D; {error - }
*** Toolset Errors *** *)
getInitView = $0001; {Command - }
getInitTotal = $0002; {Command - }
getInitValue = $0003; {Command - }
scrollLineUp = $0004; {Command - }
scrollLineDown = $0005; {Command - }
scrollPageUp = $0006; {Command - }
scrollPageDown = $0007; {Command - }
scrollThumb = $0008; {Command - }
buttonItem = $000A; {Item Type - }
checkItem = $000B; {Item Type - }
radioItem = $000C; {Item Type - }
scrollBarItem = $000D; {Item Type - }
userCtlItem = $000E; {Item Type - }
statText = $000F; {Item Type - }
longStatText = $0010; {Item Type - }
editLine = $0011; {Item Type - }
iconItem = $0012; {Item Type - }
picItem = $0013; {Item Type - }
userItem = $0014; {Item Type - }
userCtlItem2 = $0015; {Item Type - }
longStatText2 = $0016; {Item Type - }
itemDisable = $8000; {Item Type - }
minItemType = $000A; {Item Type Range - }
maxItemType = $0016; {Item Type Range - }
ok = $0001; {ItemID - }
cancel = $0002; {ItemID - }
inButton = $0002; {ModalDialog2 - Part code }
inCheckBox = $0003; {ModalDialog2 - Part code }
inRadioButton = $0004; {ModalDialog2 - Part code }
inUpArrow = $0005; {ModalDialog2 - Part code }
inDownArrow = $0006; {ModalDialog2 - Part code }
inPageUp = $0007; {ModalDialog2 - Part code }
inPageDown = $0008; {ModalDialog2 - Part code }
inStatText = $0009; {ModalDialog2 - Part code }
inGrow = $000A; {ModalDialog2 - Part code }
inEditLine = $000B; {ModalDialog2 - Part code }
inUserItem = $000C; {ModalDialog2 - Part code }
inLongStatText = $000D; {ModalDialog2 - Part code }
inIconItem = $000E; {ModalDialog2 - Part code }
inLongStatText2 = $000F; {ModalDialog2 - }
inThumb = $0081; {ModalDialog2 - Part code }
okDefault = $0000; {Stage Bit Vector - }
cancelDefault = $0040; {Stage Bit Vector - }
alertDrawn = $0080; {Stage Bit Vector - }
atItemListLength = $0005;
dtItemListLength = $0008;
TYPE
DialogPtr = WindowPtr ;
ItemTempHndl = ^ItemTempPtr;
ItemTempPtr = ^ItemTemplate;
ItemTemplate = RECORD
itemID : Integer;
itemRect : Rect;
itemType : Integer;
itemDescr : Ptr;
itemValue : Integer;
itemFlag : Integer;
itemColor : Ptr; { pointer to appropriate type of color table }
END;
AlertTempHndl = ^AlertTempPtr;
AlertTempPtr = ^AlertTemplate;
AlertTemplate = RECORD
atBoundsRect : Rect;
atAlertID : Integer;
atStage1 : Byte;
atStage2 : Byte;
atStage3 : Byte;
atStage4 : Byte;
atItemList : ARRAY[1..atItemListLength] OF ItemTempPtr; { Null terminated
array }
END;
DlgTempHndl = ^DlgTempPtr;
DlgTempPtr = ^DialogTemplate;
DialogTemplate = RECORD
dtBoundsRect : Rect;
dtVisible : Boolean;
dtRefCon : Longint;
dtItemList : ARRAY[1..dtItemListLength] OF ItemTempPtr; { Null terminated
array }
END;
IconRecordHndl = ^IconRecordPtr;
IconRecordPtr = ^IconRecord;
IconRecord = RECORD
iconRect : Rect;
iconImage : PACKED ARRAY[1..1] OF Byte;
END;
UserCtlItemPBHndl = ^UserCtlItemPBPtr;
UserCtlItemPBPtr = ^UserCtlItemPB;
UserCtlItemPB = RECORD
defProcParm : Longint; { ? should this be a LongProcPtr? }
titleParm : Ptr;
param2 : Integer;
param1 : Integer;
END;
PROCEDURE DialogBootInit ; Tool $15,$01;
PROCEDURE DialogStartUp ( userID:Integer) ; Tool $15,$02;
PROCEDURE DialogShutDown ; Tool $15,$03;
FUNCTION DialogVersion : Integer ; Tool $15,$04;
PROCEDURE DialogReset ; Tool $15,$05;
FUNCTION DialogStatus : Boolean ; Tool $15,$06;
FUNCTION Alert ( alertTemplatePtr:AlertTemplate; filterProcPtr:WordProcPtr) :
Integer ; Tool $15,$17;
FUNCTION CautionAlert ( alertTemplatePtr:AlertTemplate;
filterProcPtr:WordProcPtr) : Integer ; Tool $15,$1A;
PROCEDURE CloseDialog ( theDialogPtr:DialogPtr) ; Tool $15,$0C;
FUNCTION DefaultFilter ( theDialogPtr:DialogPtr; theEventPtr:EventRecord;
itemHitPtr:IntPtr) : Boolean ; Tool $15,$36;
FUNCTION DialogSelect ( theEventPtr:EventRecord;VAR resultPtr:WindowPtr;VAR
itemHitPtr:Integer) : Boolean ; Tool $15,$11;
PROCEDURE DisableDItem ( theDialogPtr:DialogPtr; itemID:Integer) ; Tool
$15,$39;
PROCEDURE DlgCopy ( theDialogPtr:DialogPtr) ; Tool $15,$13;
PROCEDURE DlgCut ( theDialogPtr:DialogPtr) ; Tool $15,$12;
PROCEDURE DlgDelete ( theDialogPtr:DialogPtr) ; Tool $15,$15;
PROCEDURE DlgPaste ( theDialogPtr:DialogPtr) ; Tool $15,$14;
PROCEDURE DrawDialog ( theDialogPtr:DialogPtr) ; Tool $15,$16;
PROCEDURE EnableDItem ( theDialogPtr:DialogPtr; itemID:Integer) ; Tool
$15,$3A;
PROCEDURE ErrorSound ( soundProcPtr:VoidProcPtr) ; Tool $15,$09;
FUNCTION FindDItem ( theDialogPtr:DialogPtr; thePoint:Point) : Integer ; Tool
$15,$24;
FUNCTION GetAlertStage : Integer ; Tool $15,$34;
FUNCTION GetControlDItem ( theDialogPtr:DialogPtr; itemID:Integer) : CtlRecHndl
; Tool $15,$1E;
FUNCTION GetDefButton ( theDialogPtr:DialogPtr) : Integer ; Tool $15,$37;
PROCEDURE GetDItemBox ( theDialogPtr:DialogPtr; itemID:Integer;
itemBoxPtr:Rect) ; Tool $15,$28;
FUNCTION GetDItemType ( theDialogPtr:DialogPtr; itemID:Integer) : Integer ;
Tool $15,$26;
FUNCTION GetDItemValue ( theDialogPtr:DialogPtr; itemID:Integer) : Integer ;
Tool $15,$2E;
FUNCTION GetFirstDItem ( theDialogPtr:DialogPtr) : Integer ; Tool $15,$2A;
PROCEDURE GetIText ( theDialogPtr:DialogPtr; itemID:Integer;VAR text:Str255) ;
Tool $15,$1F;
PROCEDURE GetNewDItem ( theDialogPtr:DialogPtr; itemTemplatePtr:ItemTemplate)
; Tool $15,$33;
FUNCTION GetNewModalDialog ( dialogTemplatePtr:DlgTempPtr) : DialogPtr ; Tool
$15,$32;
FUNCTION GetNextDItem ( theDialogPtr:DialogPtr; itemID:Integer) : Integer ;
Tool $15,$2B;
PROCEDURE HideDItem ( theDialogPtr:DialogPtr; itemID:Integer) ; Tool $15,$22;
FUNCTION IsDialogEvent ( theEventPtr:EventRecord) : Boolean ; Tool $15,$10;
FUNCTION ModalDialog ( filterProcPtr:WordProcPtr) : Integer ; Tool $15,$0F;
FUNCTION ModalDialog2 ( filterProcPtr:WordProcPtr) : Longint ; Tool $15,$2C;
PROCEDURE NewDItem ( theDialogPtr:DialogPtr; itemID:Integer; itemRectPtr:Rect;
itemType:Integer; itemDescr:Ptr; itemValue:Integer; itemFlag:Integer;
itemColorPtr:Ptr) ; Tool $15,$0D;
FUNCTION NewModalDialog ( dBoundsRectPtr:Rect; dVisibleFlag:Boolean;
dRefCon:Longint) : DialogPtr ; Tool $15,$0A;
FUNCTION NewModelessDialog ( dBoundsRectPtr:Rect; dTitle:Str255;
dBehindPtr:DialogPtr; dFlag:Integer; dRefCon:Longint; dFullSizePtr:Rect) :
DialogPtr ; Tool $15,$0B;
FUNCTION NoteAlert ( alertTemplatePtr:AlertTempPtr; filterProcPtr:WordProcPtr)
: Integer ; Tool $15,$19;
PROCEDURE ParamText ( param0:Str255; param1:Str255; param2:Str255;
param3:Str255) ; Tool $15,$1B;
PROCEDURE RemoveDItem ( theDialogPtr:DialogPtr; itemID:Integer) ; Tool
$15,$0E;
PROCEDURE ResetAlertStage ; Tool $15,$35;
PROCEDURE SelIText ( theDialogPtr:DialogPtr; itemID:Integer; startSel:Integer;
endSel:Integer) ; Tool $15,$21;
PROCEDURE SelectIText ( theDialogPtr:DialogPtr; itemID:Integer;
startSel:Integer; endSel:Integer) ; Tool $15,$21;
PROCEDURE SetDAFont ( fontHandle:FontHndl) ; Tool $15,$1C;
PROCEDURE SetDefButton ( defButtonID:Integer; theDialogPtr:DialogPtr) ; Tool
$15,$38;
PROCEDURE SetDItemBox ( theDialogPtr:DialogPtr; itemID:Integer;
itemBoxPtr:Rect) ; Tool $15,$29;
PROCEDURE SetDItemType ( itemType:Integer; theDialogPtr:DialogPtr;
itemID:Integer) ; Tool $15,$27;
PROCEDURE SetDItemValue ( itemValue:Integer; theDialogPtr:DialogPtr;
itemID:Integer) ; Tool $15,$2F;
PROCEDURE SetIText ( theDialogPtr:DialogPtr; itemID:Integer; theString:Str255)
; Tool $15,$20;
PROCEDURE ShowDItem ( theDialogPtr:DialogPtr; itemID:Integer) ; Tool $15,$23;
FUNCTION StopAlert ( alertTemplatePtr:AlertTempPtr; filterProcPtr:WordProcPtr)
: Integer ; Tool $15,$18;
PROCEDURE UpdateDialog ( theDialogPtr:DialogPtr; updateRgnHandle:RgnHandle) ;
Tool $15,$25;
IMPLEMENTATION
END.

133
pascal/events.p Executable file
View File

@ -0,0 +1,133 @@
{********************************************
; File: Events.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT EVENTS;
INTERFACE
USES TYPES;
CONST
(* *** Toolset Errors ***
emDupStrtUpErr = $0601; {error - duplicate EMStartup Call }
emResetErr = $0602; {error - can't reset error the Event Manager }
emNotActErr = $0603; {error - event manager not active }
emBadEvtCodeErr = $0604; {error - illegal event code }
emBadBttnNoErr = $0605; {error - illegal button number }
emQSiz2LrgErr = $0606; {error - queue size too large }
emNoMemQueueErr = $0607; {error - not enough memory for queue }
emBadEvtQErr = $0681; {error - fatal sys error - event queue damaged }
emBadQHndlErr = $0682; {error - fatal sys error - queue handle damaged }
*** Toolset Errors *** *)
nullEvt = $0000; {Event Code - }
mouseDownEvt = $0001; {Event Code - }
mouseUpEvt = $0002; {Event Code - }
keyDownEvt = $0003; {Event Code - }
autoKeyEvt = $0005; {Event Code - }
updateEvt = $0006; {Event Code - }
activateEvt = $0008; {Event Code - }
switchEvt = $0009; {Event Code - }
deskAccEvt = $000A; {Event Code - }
driverEvt = $000B; {Event Code - }
app1Evt = $000C; {Event Code - }
app2Evt = $000D; {Event Code - }
app3Evt = $000E; {Event Code - }
app4Evt = $000F; {Event Code - }
mDownMask = $0002; {Event Masks - }
mUpMask = $0004; {Event Masks - }
keyDownMask = $0008; {Event Masks - }
autoKeyMask = $0020; {Event Masks - }
updateMask = $0040; {Event Masks - }
activeMask = $0100; {Event Masks - }
switchMask = $0200; {Event Masks - }
deskAccMask = $0400; {Event Masks - }
driverMask = $0800; {Event Masks - }
app1Mask = $1000; {Event Masks - }
app2Mask = $2000; {Event Masks - }
app3Mask = $4000; {Event Masks - }
app4Mask = $8000; {Event Masks - }
everyEvent = $FFFF; {Event Masks - }
jcTickCount = $00; {Journal Code - TickCount call }
jcGetMouse = $01; {Journal Code - GetMouse call }
jcButton = $02; {Journal Code - Button call }
jcEvent = $04; {Journal Code - GetNextEvent and EventAvail calls }
activeFlag = $0001; {Modifier Flags - set if window being activated }
changeFlag = $0002; {Modifier Flags - set if active wind. changed state }
btn1State = $0040; {Modifier Flags - set if button 1 up }
btn0State = $0080; {Modifier Flags - set if button 0 up }
appleKey = $0100; {Modifier Flags - set if Apple key down }
shiftKey = $0200; {Modifier Flags - set if shift key down }
capsLock = $0400; {Modifier Flags - set if caps lock key down }
optionKey = $0800; {Modifier Flags - set if option key down }
controlKey = $1000; {Modifier Flags - set if Control key down }
keyPad = $2000; {Modifier Flags - set if keypress from key pad }
TYPE
EventRecordHndl = ^EventRecordPtr;
EventRecordPtr = ^EventRecord;
EventRecord = RECORD CASE INTEGER OF
0: (
what : Integer; { event code }
message : Longint; { event message }
when : Longint; { ticks since startup }
where : Point; { mouse location }
modifiers : Integer; { modifier flags }
);
1: (
wmWhat : Integer;
wmMessage : Longint;
wmWhen : Longint;
wmWhere : Point;
wmModifiers : Integer;
wmTaskData : Longint; { TaskMaster return value. }
wmTaskMask : Longint; { TaskMaster feature mask. }
wmLastClickTick : Longint;
wmClickCount : Integer;
wmTaskData2 : Longint;
wmTaskData3 : Longint;
wmTaskData4 : Longint;
wmLastClickPt : Point;
);
END;
PROCEDURE EMBootInit ; Tool $06,$01;
PROCEDURE EMStartUp ( dPageAddr:Integer; queueSize:Integer; xMinClamp:Integer;
xMaxClamp:Integer; yMinClamp:Integer; yMaxClamp:Integer; userID:Integer) ;
Tool $06,$02;
PROCEDURE EMShutDown ; Tool $06,$03;
FUNCTION EMVersion : Integer ; Tool $06,$04;
PROCEDURE EMReset ; Tool $06,$05;
FUNCTION EMStatus : Boolean ; Tool $06,$06;
FUNCTION Button ( buttonNum:Integer) : Boolean ; Tool $06,$0D;
FUNCTION DoWindows : Integer ; Tool $06,$09;
FUNCTION EventAvail ( eventMask:Integer;VAR eventPtr:EventRecord) : Boolean ;
Tool $06,$0B;
PROCEDURE FakeMouse ( changedFlag:Integer; modLatch:Integer; xPos:Integer;
yPos:Integer; ButtonStatus:Integer) ; Tool $06,$19;
FUNCTION FlushEvents ( eventMask:Integer; stopMask:Integer) : Integer ; Tool
$06,$15;
FUNCTION GetCaretTime : Longint ; Tool $06,$12;
FUNCTION GetDblTime : Longint ; Tool $06,$11;
PROCEDURE GetMouse (VAR mouseLocPtr:Point) ; Tool $06,$0C;
FUNCTION GetNextEvent ( eventMask:Integer;VAR eventPtr:EventRecord) : Boolean ;
Tool $06,$0A;
FUNCTION GetOSEvent ( eventMask:Integer;VAR eventPtr:EventRecord) : Boolean ;
Tool $06,$16;
FUNCTION OSEventAvail ( eventMask:Integer;VAR eventPtr:EventRecord) : Boolean ;
Tool $06,$17;
FUNCTION PostEvent ( eventCode:Integer; eventMsg:Longint) : Integer ; Tool
$06,$14;
PROCEDURE SetEventMask ( sysEventMask:Integer) ; Tool $06,$18;
PROCEDURE SetSwitch ; Tool $06,$13;
FUNCTION StillDown ( buttonNum:Integer) : Boolean ; Tool $06,$0E;
FUNCTION WaitMouseUp ( buttonNum:Integer) : Boolean ; Tool $06,$0F;
FUNCTION TickCount : Longint ; Tool $06,$10;
FUNCTION GetKeyTranslation : Integer ; Tool $06,$1B;
PROCEDURE SetKeyTranslation ( kTransID:Integer) ; Tool $06,$1C;
PROCEDURE SetAutoKeyLimit ( newLimit:Integer) ; Tool $06,$1A;
IMPLEMENTATION
END.

103
pascal/fonts.p Executable file
View File

@ -0,0 +1,103 @@
{********************************************
; File: Fonts.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT FONTS;
INTERFACE
USES TYPES,QUICKDRAW;
CONST
(* *** Toolset Errors ***
fmDupStartUpErr = $1B01; {error - duplicate FMStartUp call }
fmResetErr = $1B02; {error - can't reset the Font Manager }
fmNotActiveErr = $1B03; {error - Font Manager not active }
fmFamNotFndErr = $1B04; {error - family not found }
fmFontNtFndErr = $1B05; {error - font not found }
fmFontMemErr = $1B06; {error - font not in memory }
fmSysFontErr = $1B07; {error - system font cannot be purgeable }
fmBadFamNumErr = $1B08; {error - illegal family number }
fmBadSizeErr = $1B09; {error - illegal size }
fmBadNameErr = $1B0A; {error - illegal name length }
fmMenuErr = $1B0B; {error - fix font menu never called }
fmScaleSizeErr = $1B0C; {error - scaled size of font exeeds limits }
*** Toolset Errors *** *)
newYork = $0002; {Family Number - }
geneva = $0003; {Family Number - }
monaco = $0004; {Family Number - }
venice = $0005; {Family Number - }
london = $0006; {Family Number - }
athens = $0007; {Family Number - }
sanFran = $0008; {Family Number - }
toronto = $0009; {Family Number - }
cairo = $000B; {Family Number - }
losAngeles = $000C; {Family Number - }
times = $0014; {Family Number - }
helvetica = $0015; {Family Number - }
courier = $0016; {Family Number - }
symbol = $0017; {Family Number - }
taliesin = $0018; {Family Number - }
shaston = $FFFE; {Family Number - }
baseOnlyBit = $0020; {FamSpecBits - }
notBaseBit = $0020; {FamStatBits - }
memOnlyBit = $0001; {FontSpecBits - }
realOnlyBit = $0002; {FontSpecBits - }
anyFamBit = $0004; {FontSpecBits - }
anyStyleBit = $0008; {FontSpecBits - }
anySizeBit = $0010; {FontSpecBits - }
memBit = $0001; {FontStatBits - }
unrealBit = $0002; {FontStatBits - }
apFamBit = $0004; {FontStatBits - }
apVarBit = $0008; {FontStatBits - }
purgeBit = $0010; {FontStatBits - }
notDiskBit = $0020; {FontStatBits - }
notFoundBit = $8000; {FontStatBits - }
dontScaleBit = $0001; {Scale Word - }
TYPE
FontStatRecHndl = ^FontStatRecPtr;
FontStatRecPtr = ^FontStatRec;
FontStatRec = RECORD
resultID : FontID;
resultStats : Integer;
END;
PROCEDURE FMBootInit ; Tool $1B,$01;
PROCEDURE FMStartUp ( userID:Integer; dPageAddr:Integer) ; Tool $1B,$02;
PROCEDURE FMShutDown ; Tool $1B,$03;
FUNCTION FMVersion : Integer ; Tool $1B,$04;
PROCEDURE FMReset ; Tool $1B,$05;
FUNCTION FMStatus : Boolean ; Tool $1B,$06;
PROCEDURE AddFamily ( famNum:Integer; famName:Str255) ; Tool $1B,$0D;
PROCEDURE AddFontVar ( fontHandle:FontHndl; newSpecs:Integer) ; Tool $1B,$14;
FUNCTION ChooseFont ( currentID:FontID; famSpecs:Integer) : FontID ; Tool
$1B,$16;
FUNCTION CountFamilies ( famSpecs:Integer) : Integer ; Tool $1B,$09;
FUNCTION CountFonts ( desiredID:FontId; fontSpecs:Integer) : Integer ; Tool
$1B,$10;
FUNCTION FamNum2ItemID ( famNum:Integer) : Integer ; Tool $1B,$1B;
FUNCTION FindFamily ( famSpecs:Integer; positionNum:Integer; famName:Str255) :
Integer ; Tool $1B,$0A;
PROCEDURE FindFontStats ( desiredID:FontId; fontSpecs:Integer;
positionNum:Integer;VAR resultPtr:FontStatRec) ; Tool $1B,$11;
PROCEDURE FixFontMenu ( menuID:Integer; startingID:Integer; famSpecs:Integer)
; Tool $1B,$15;
FUNCTION FMGetCurFID : FontID ; Tool $1B,$1A;
FUNCTION FMGetSysFID : FontID ; Tool $1B,$19;
PROCEDURE FMSetSysFont ( newFontID:FontID) ; Tool $1B,$18;
FUNCTION GetFamInfo ( famNum:Integer; famName:Str255) : Integer ; Tool $1B,$0B;
FUNCTION GetFamNum ( famName:Str255) : Integer ; Tool $1B,$0C;
PROCEDURE InstallFont ( desiredID:FontID; scaleWord:Integer) ; Tool $1B,$0E;
PROCEDURE InstallWithStats ( desiredID:FontID; scaleWord:Integer;
resultPtr:Ptr) ; Tool $1B,$1C;
FUNCTION ItemID2FamNum ( itemID:Integer) : Integer ; Tool $1B,$17;
PROCEDURE LoadFont ( desiredID:FontID; fontSpecs:Integer;
positionNum:Integer;VAR resultPtr:FontStatRec) ; Tool $1B,$12;
PROCEDURE LoadSysFont ; Tool $1B,$13;
PROCEDURE SetPurgeStat ( theFontID:FontID; purgeStat:Integer) ; Tool $1B,$0F;
IMPLEMENTATION
END.

138
pascal/fst.p Executable file
View File

@ -0,0 +1,138 @@
{********************************************
; File: FST.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT FST;
INTERFACE
USES Types,GSOS;
TYPE
BufferControlRecPtr = ^BufferControlRec;
BufferControlRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
refNum : Integer;
flags : Integer;
END;
SpecialOpenForkRecPtr = ^SpecialOpenForkRec;
SpecialOpenForkRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
referenceNum : Integer;
pathname : GSString255Ptr;
accessMode : Integer;
resourceNum : Integer;
END;
ByteRangeLockRecPtr = ^ByteRangeLockRec;
ByteRangeLockRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
referenceNum : Integer;
lockFlag : Integer;
fileOffset : Longint;
rangeLength : Longint;
rangeStart : Longint;
END;
GetAccessRightsRecPtr = ^GetAccessRightsRec;
GetAccessRightsRec = PACKED RECORD
reserved : Byte;
world : Byte;
group : Byte;
owner : Byte;
END;
GetPrivilegesRecPtr = ^GetPrivilegesRec;
GetPrivilegesRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
pathname : GSString255Ptr;
accessRights : GetAccessRightsRec;
ownerName : ResultBuf255Ptr;
groupName : ResultBuf255Ptr;
END;
SetAccessRightsRecPtr = ^SetAccessRightsRec;
SetAccessRightsRec = PACKED RECORD
userSummary : Byte;
world : Byte;
group : Byte;
owner : Byte;
END;
SetPrivilegesRecPtr = ^SetPrivilegesRec;
SetPrivilegesRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
pathname : GSString255Ptr;
accessRights : SetAccessRightsRec;
ownerName : ResultBuf255Ptr;
groupName : ResultBuf255Ptr;
END;
UserInfoRecPtr = ^UserInfoRec;
UserInfoRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
deviceNum : Integer;
userName : ResultBuf255Ptr;
primaryGroupName : ResultBuf255Ptr;
END;
CopyFileRecPtr = ^CopyFileRec;
CopyFileRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
sourcePathname : GSString255Ptr;
destPathname : GSString255Ptr;
END;
GetUserPathRecPtr = ^GetUserPathRec;
GetUserPathRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
prefix : ResultBuf255Ptr;
END;
DesktopRecPtr = ^DesktopRec;
DesktopRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
desktopRefNum : Integer;
pathname : GSString255Ptr;
END;
GetCommentRecPtr = ^GetCommentRec;
GetCommentRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
desktopRefNum : Integer;
pathname : GSString255Ptr;
comment : ResultBuf255Ptr;
END;
SetCommentRecPtr = ^SetCommentRec;
SetCommentRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
desktopRefNum : Integer;
pathname : GSString255Ptr;
comment : GSString255Ptr;
END;
GetServerNameRecPtr = ^GetServerNameRec;
GetServerNameRec = RECORD
pCount : Integer;
fstNum : Integer;
command : Integer;
pathname : GSString255Ptr;
serverName : ResultBuf255Ptr;
zoneName : ResultBuf255Ptr;
END;
IMPLEMENTATION
END.

498
pascal/gsos.p Executable file
View File

@ -0,0 +1,498 @@
{********************************************
; File: GSOS.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT GSOS;
INTERFACE
USES TYPES;
CONST
readEnable = $0001; {access - read enable bit: CreateRec, OpenRec access and
requestAccess fields }
writeEnable = $0002; {access - write enable bit: CreateRec, OpenRec access and
requestAccess fields }
fileInvisible = $0004; {access - Invisible bit }
backupNeeded = $0020; {access - backup needed bit: CreateRec, OpenRec access
field. (Must be 0 in requestAccess field ) }
renameEnable = $0040; {access - rename enable bit: CreateRec, OpenRec access
and requestAccess fields }
destroyEnable = $0080; {access - destroy enable bit: CreateRec, OpenRec access
and requestAccess fields }
startPlus = $0000; {base - > setMark = displacement }
eofMinus = $0001; {base - > setMark = eof - displacement }
markPlus = $0002; {base - > setMark = mark + displacement }
markMinus = $0003; {base - > setMark = mark - displacement }
cacheOff = $0000; {cachePriority - do not cache blocks invloved in this read }
cacheOn = $0001; {cachePriority - cache blocks invloved in this read if
possible }
(* *** Toolset Errors ***
badSystemCall = $0001; {error - bad system call number }
invalidPcount = $0004; {error - invalid parameter count }
gsosActive = $07; {error - GS/OS already active }
devNotFound = $10; {error - device not found }
invalidDevNum = $11; {error - invalid device number }
drvrBadReq = $20; {error - bad request or command }
drvrBadCode = $0021; {error - bad control or status code }
drvrBadParm = $0022; {error - bad call parameter }
drvrNotOpen = $0023; {error - character device not open }
drvrPriorOpen = $0024; {error - character device already open }
irqTableFull = $0025; {error - interrupt table full }
drvrNoResrc = $0026; {error - resources not available }
drvrIOError = $0027; {error - I/O error }
drvrNoDevice = $0028; {error - device not connected }
drvrBusy = $0029; {error - call aborted, driver is busy }
drvrWrtProt = $002B; {error - device is write protected }
drvrBadCount = $002C; {error - invalid byte count }
drvrBadBlock = $002D; {error - invalid block address }
drvrDiskSwitch = $002E; {error - disk has been switched }
drvrOffLine = $002F; {error - device off line/ no media present }
badPathSyntax = $0040; {error - invalid pathname syntax }
invalidRefNum = $0043; {error - invalid reference number }
pathNotFound = $44; {error - subdirectory does not exist }
volNotFound = $0045; {error - volume not found }
fileNotFound = $0046; {error - file not found }
dupPathname = $0047; {error - create or rename with existing name }
volumeFull = $0048; {error - volume full error }
volDirFull = $0049; {error - volume directory full }
badFileFormat = $004A; {error - version error (incompatible file format) }
badStoreType = $004B; {error - unsupported (or incorrect) storage type }
eofEncountered = $004C; {error - end-of-file encountered }
outOfRange = $004D; {error - position out of range }
invalidAccess = $004E; {error - access not allowed }
buffTooSmall = $004F; {error - buffer too small }
fileBusy = $0050; {error - file is already open }
dirError = $0051; {error - directory error }
unknownVol = $0052; {error - unknown volume type }
paramRangeErr = $0053; {error - parameter out of range }
outOfMem = $0054; {error - out of memory }
dupVolume = $0057; {error - duplicate volume name }
notBlockDev = $0058; {error - not a block device }
invalidLevel = $0059; {error - specifield level outside legal range }
damagedBitMap = $005A; {error - block number too large }
badPathNames = $005B; {error - invalid pathnames for ChangePath }
notSystemFile = $005C; {error - not an executable file }
osUnsupported = $005D; {error - Operating System not supported }
stackOverflow = $005F; {error - too many applications on stack }
dataUnavail = $0060; {error - Data unavailable }
endOfDir = $0061; {error - end of directory has been reached }
invalidClass = $0062; {error - invalid FST call class }
resForkNotFound = $0063; {error - file does not contain required resource }
invalidFSTID = $0064; {error - error - FST ID is invalid }
*** Toolset Errors *** *)
(* *** File System IDs ***
proDOSFSID = $0001; {fileSysID - ProDOS/SOS }
dos33FSID = $0002; {fileSysID - DOS 3.3 }
dos32FSID = $0003; {fileSysID - DOS 3.2 }
dos31FSID = $0003; {fileSysID - DOS 3.1 }
appleIIPascalFSID = $0004; {fileSysID - Apple II Pascal }
mfsFSID = $0005; {fileSysID - Macintosh (flat file system) }
hfsFSID = $0006; {fileSysID - Macintosh (hierarchical file system) }
lisaFSID = $0007; {fileSysID - Lisa file system }
appleCPMFSID = $0008; {fileSysID - Apple CP/M }
charFSTFSID = $0009; {fileSysID - Character FST }
msDOSFSID = $000A; {fileSysID - MS/DOS }
highSierraFSID = $000B; {fileSysID - High Sierra }
iso9660FSID = $000C; {fileSysID - ISO 9660 }
appleShareFSID = $000D; {fileSysID - ISO 9660 }
*** File System IDs *** *)
characterFST = $4000; {FSTInfo.attributes - character FST }
ucFST = $8000; {FSTInfo.attributes - SCM should upper case pathnames before
passing them to the FST }
onStack = $8000; {QuitRec.flags - place state information about quitting
program on the quit return stack }
restartable = $4000; {QuitRec.flags - the quitting program is capable of being
restarted from its dormant memory }
seedling = $0001; {storageType - standard file with seedling structure }
standardFile = $0001; {storageType - standard file type (no resource fork) }
sapling = $0002; {storageType - standard file with sapling structure }
tree = $0003; {storageType - standard file with tree structure }
pascalRegion = $0004; {storageType - UCSD Pascal region on a partitioned disk }
extendedFile = $0005; {storageType - extended file type (with resource fork) }
directoryFile = $000D; {storageType - volume directory or subdirectory file }
minorRelNumMask = $00FF; {version - minor release number }
majorRelNumMask = $7F00; {version - major release number }
finalRelNumMask = $8000; {version - final release number }
isFileExtended = $8000; {GetDirEntryGS - }
TYPE
GSString255Hndl = ^GSString255Ptr;
GSString255Ptr = ^GSString255;
GSString255 = RECORD
length : Integer; { Number of Chars in text field }
text : PACKED ARRAY[1..255] OF CHAR;
END;
GSString255HndlPtr = ^GSString255Hndl;
GSString32Hndl = ^GSString32Ptr;
GSString32Ptr = ^GSString32;
GSString32 = RECORD
length : Integer; { Number of characters in text field }
text : PACKED ARRAY[1..32] OF CHAR;
END;
ResultBuf255Hndl = ^ResultBuf255Ptr;
ResultBuf255Ptr = ^ResultBuf255;
ResultBuf255 = RECORD
bufSize : Integer;
bufString : GSString255;
END;
ResultBuf255HndlPtr = ^ResultBuf255Hndl;
ResultBuf32Hndl = ^ResultBuf32Ptr;
ResultBuf32Ptr = ^ResultBuf32;
ResultBuf32 = RECORD
bufSize : Integer;
bufString : GSString32;
END;
ChangePathRecPtrGS = ^ChangePathRecGS;
ChangePathRecGS = RECORD
pCount : Integer;
pathname : GSString255Ptr;
newPathname : GSString255Ptr;
END;
CreateRecPtrGS = ^CreateRecGS;
CreateRecGS = RECORD
pCount : Integer;
pathname : GSString255Ptr;
access : Integer;
fileType : Integer;
auxType : Longint;
storageType : Integer;
eof : Longint;
resourceEOF : Longint;
END;
DAccessRecPtrGS = ^DAccessRecGS;
DAccessRecGS = RECORD
pCount : Integer;
devNum : Integer;
code : Integer;
list : Ptr;
requestCount : Longint;
transferCount : Longint;
END;
DevNumRecPtrGS = ^DevNumRecGS;
DevNumRecGS = RECORD
pCount : Integer;
devName : GSString255Ptr;
devNum : Integer;
END;
DInfoRecPtrGS = ^DInfoRecGS;
DInfoRecGS = RECORD
pCount : Integer; { minimum = 2 }
devNum : Integer;
devName : GSString32Ptr;
characteristics : Integer;
totalBlocks : Longint;
slotNum : Integer;
unitNum : Integer;
version : Integer;
deviceID : Integer;
headLink : Integer;
forwardLink : Integer;
extendedDIBptr : Longint;
END;
DIORecPtrGS = ^DIORecGS;
DIORecGS = RECORD
pCount : Integer;
devNum : Integer;
buffer : Ptr;
requestCount : Longint;
startingBlock : Longint;
blockSize : Integer;
transferCount : Longint;
END;
DirEntryRecPtrGS = ^DirEntryRecGS;
DirEntryRecGS = RECORD
pCount : Integer;
refNum : Integer;
flags : Integer;
base : Integer;
displacement : Integer;
name : Ptr;
entryNum : Integer;
fileType : Integer;
eof : Longint;
blockCount : Longint;
createDateTime : TimeRec;
modDateTime : TimeRec;
access : Integer;
auxType : Longint;
fileSysID : Integer;
optionList : ResultBuf255Ptr;
resourceEOF : Longint;
resourceBlocks : Longint;
END;
ExpandPathRecPtrGS = ^ExpandPathRecGS;
ExpandPathRecGS = RECORD
pCount : Integer;
inputPath : GSString255Ptr;
outputPath : ResultBuf255Ptr;
flags : Integer;
END;
FileInfoRecPtrGS = ^FileInfoRecGS;
FileInfoRecGS = RECORD
pCount : Integer;
pathname : GSString255Ptr;
access : Integer;
fileType : Integer;
auxType : Longint;
storageType : Integer; { must be 0 for SetFileInfo }
createDateTime : TimeRec;
modDateTime : TimeRec;
optionList : Longint;
eof : Longint;
blocksUsed : Longint; { must be 0 for SetFileInfo }
resourceEOF : Longint; { must be 0 for SetFileInfo }
resourceBlocks : Longint; { must be 0 for SetFileInfo }
END;
FormatRecPtrGS = ^FormatRecGS;
FormatRecGS = RECORD
pCount : Integer;
devName : GSString32Ptr; { device name pointer }
volName : GSString32Ptr; { volume name pointer }
fileSysID : Integer; { file system ID }
reqFileSysID : Integer; { in; }
END;
FSTInfoRecPtrGS = ^FSTInfoRecGS;
FSTInfoRecGS = RECORD
pCount : Integer;
fstNum : Integer;
fileSysID : Integer;
fstName : ResultBuf255Ptr;
version : Integer;
attributes : Integer;
blockSize : Integer;
maxVolSize : Longint;
maxFileSize : Longint;
END;
InterruptRecPtrGS = ^InterruptRecGS;
InterruptRecGS = RECORD
pCount : Integer;
intNum : Integer;
vrn : Integer; { used only by BindInt }
intCode : Longint; { used only by BindInt }
END;
IORecPtrGS = ^IORecGS;
IORecGS = RECORD
pCount : Integer;
refNum : Integer;
dataBuffer : Ptr;
requestCount : Longint;
transferCount : Longint;
cachePriority : Integer;
END;
LevelRecPtrGS = ^LevelRecGS;
LevelRecGS = RECORD
pCount : Integer;
level : Integer;
END;
NameRecPtrGS = ^NameRecGS;
NameRecGS = RECORD
pCount : Integer;
pathname : GSString255Ptr; { full pathname or a filename depending on call
}
END;
GetNameRecPtrGS = ^GetNameRecGS;
GetNameRecGS = RECORD
pCount : Integer;
dataBuffer : ResultBuf255Ptr; { full pathname or a filename depending on
call }
END;
NewlineRecPtrGS = ^NewlineRecGS;
NewlineRecGS = RECORD
pCount : Integer;
refNum : Integer;
enableMask : Integer;
numChars : Integer;
newlineTable : Ptr;
END;
OpenRecPtrGS = ^OpenRecGS;
OpenRecGS = RECORD
pCount : Integer;
refNum : Integer;
pathname : GSString255Ptr;
requestAccess : Integer;
resourceNumber : Integer; { For extended files: dataFork/resourceFork }
access : Integer; { Value of file's access attribute }
fileType : Integer; { Value of file's fileType attribute }
auxType : Longint;
storageType : Integer;
createDateTime : TimeRec;
modDateTime : TimeRec;
optionList : IntPtr;
eof : Longint;
blocksUsed : Longint;
resourceEOF : Longint;
resourceBlocks : Longint;
END;
OSShutdownRecPtrGS = ^OSShutdownRecGS;
OSShutdownRecGS = RECORD
pCount : Integer; { in }
shutdownFlag : Integer; { in }
END;
PositionRecPtrGS = ^PositionRecGS;
PositionRecGS = RECORD
pCount : Integer;
refNum : Integer;
position : Longint;
END;
EOFRecPtrGS = ^EOFRecGS;
EOFRecGS = RECORD
pCount : Integer;
refNum : Integer;
eof : Longint;
END;
PrefixRecPtrGS = ^PrefixRecGS;
PrefixRecGS = RECORD
pCount : Integer;
prefixNum : Integer;
CASE INTEGER OF
0: (getPrefix : ResultBuf255Ptr;);
1: (setPrefix : GSString255Ptr;);
END;
QuitRecPtrGS = ^QuitRecGS;
QuitRecGS = RECORD
pCount : Integer;
pathname : GSString255Ptr; { pathname of next app to run }
flags : Integer;
END;
RefnumRecPtrGS = ^RefNumRecGS;
RefNumRecGS = RECORD
pCount : Integer;
refNum : Integer;
END;
SessionStatusRecPtrGS = ^SessionStatusRecGS;
SessionStatusRecGS = RECORD
pCount : Integer; { in: min = 1 }
status : Integer; { out: }
END;
SetPositionRecPtrGS = ^SetPositionRecGS;
SetPositionRecGS = RECORD
pCount : Integer;
refNum : Integer;
base : Integer;
displacement : Longint;
END;
SysPrefsRecPtrGS = ^SysPrefsRecGS;
SysPrefsRecGS = RECORD
pCount : Integer;
preferences : Integer;
END;
VersionRecPtrGS = ^VersionRecGS;
VersionRecGS = RECORD
pCount : Integer;
version : Integer;
END;
VolumeRecPtrGS = ^VolumeRecGS;
VolumeRecGS = RECORD
pCount : Integer;
devName : GSString32Ptr;
volName : ResultBuf255Ptr;
totalBlocks : Longint;
freeBlocks : Longint;
fileSysID : Integer;
blockSize : Integer;
END;
PROCEDURE BeginSessionGS (VAR pblockPtr: SessionStatusRecGS); GSOS $201D ;
PROCEDURE BindIntGS (VAR pblockPtr: InterruptRecGS); GSOS $2031 ;
PROCEDURE ChangePathGS (VAR pblockPtr: ChangePathRecGS); GSOS $2004 ;
PROCEDURE ClearBackupBitGS (VAR pblockPtr: NameRecGS); GSOS $200B ;
PROCEDURE CloseGS (VAR pblockPtr: RefNumRecGS); GSOS $2014 ;
PROCEDURE CreateGS (VAR pblockPtr: CreateRecGS); GSOS $2001 ;
PROCEDURE DControlGS (VAR pblockPtr: DAccessRecGS); GSOS $202E ;
PROCEDURE DestroyGS (VAR pblockPtr: NameRecGS); GSOS $2002 ;
PROCEDURE DInfoGS (VAR pblockPtr: DInfoRecGS); GSOS $202C ;
PROCEDURE DReadGS (VAR pblockPtr: DIORecGS); GSOS $202F ;
PROCEDURE DStatusGS (VAR pblockPtr: DAccessRecGS); GSOS $202D ;
PROCEDURE DWriteGS (VAR pblockPtr: DIORecGS); GSOS $2030 ;
PROCEDURE EndSessionGS (VAR pblockPtr: SessionStatusRecGS); GSOS $201E ;
PROCEDURE EraseDiskGS (VAR pblockPtr: FormatRecGS); GSOS $2025 ;
PROCEDURE ExpandPathGS (VAR pblockPtr: ExpandPathRecGS); GSOS $200E ;
PROCEDURE FlushGS (VAR pblockPtr: RefNumRecGS); GSOS $2015 ;
PROCEDURE FormatGS (VAR pblockPtr: FormatRecGS); GSOS $2024 ;
PROCEDURE GetBootVolGS (VAR pblockPtr: NameRecGS); GSOS $2028 ;
PROCEDURE GetDevNumberGS (VAR pblockPtr: DevNumRecGS); GSOS $2020 ;
PROCEDURE GetDirEntryGS (VAR pblockPtr: DirEntryRecGS); GSOS $201C ;
PROCEDURE GetEOFGS (VAR pblockPtr: EOFRecGS); GSOS $2019 ;
PROCEDURE GetFileInfoGS (VAR pblockPtr: FileInfoRecGS); GSOS $2006 ;
PROCEDURE GetFSTInfoGS (VAR pblockPtr: FSTInfoRecGS); GSOS $202B ;
PROCEDURE GetLevelGS (VAR pblockPtr: LevelRecGS); GSOS $201B ;
PROCEDURE GetMarkGS (VAR pblockPtr: PositionRecGS); GSOS $2017 ;
PROCEDURE GetNameGS (VAR pblockPtr: GetNameRecGS); GSOS $2027 ;
PROCEDURE GetPrefixGS (VAR pblockPtr: PrefixRecGS); GSOS $200A ;
PROCEDURE GetVersionGS (VAR pblockPtr: VersionRecGS); GSOS $202A ;
PROCEDURE GetSysPrefsGS (VAR pblockPtr: SysPrefsRecGS); GSOS $200F ;
PROCEDURE NewlineGS (VAR pblockPtr: NewlineRecGS); GSOS $2011 ;
PROCEDURE NullGS (VAR pblockPtr: IntPtr); GSOS $200D ;
PROCEDURE OpenGS (VAR pblockPtr: OpenRecGS); GSOS $2010 ;
PROCEDURE QuitGS (VAR pblockPtr: QuitRecGS); GSOS $2029 ;
PROCEDURE ReadGS (VAR pblockPtr: IORecGS); GSOS $2012 ;
PROCEDURE ResetCacheGS (VAR pblockPtr: IntPtr); GSOS $2026 ;
PROCEDURE SessionStatusGS (VAR pblockPtr: SessionStatusRecGS); GSOS $201F ;
PROCEDURE SetEOFGS (VAR pblockPtr: SetPositionRecGS); GSOS $2018 ;
PROCEDURE SetFileInfoGS (VAR pblockPtr: FileInfoRecGS); GSOS $2005 ;
PROCEDURE SetLevelGS (VAR pblockPtr: LevelRecGS); GSOS $201A ;
PROCEDURE SetMarkGS (VAR pblockPtr: SetPositionRecGS); GSOS $2016 ;
PROCEDURE SetPrefixGS (VAR pblockPtr: PrefixRecGS); GSOS $2009 ;
PROCEDURE SetSysPrefsGS (VAR pblockPtr: SysPrefsRecGS); GSOS $200C ;
PROCEDURE UnbindIntGS (VAR pblockPtr: InterruptRecGS); GSOS $2032 ;
PROCEDURE VolumeGS (VAR pblockPtr: VolumeRecGS); GSOS $2008 ;
PROCEDURE WriteGS (VAR pblockPtr: IORecGS); GSOS $2013 ;
PROCEDURE OSShutdownGS (VAR pblockPtr: OSShutdownRecGS); GSOS $2003 ;
PROCEDURE FSTSpecific (VAR pBlockPtr: Ptr); GSOS $2033 ;
IMPLEMENTATION
END.

111
pascal/intmath.p Executable file
View File

@ -0,0 +1,111 @@
{********************************************
; File: IntMath.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT INTMATH;
INTERFACE
USES TYPES;
CONST
(* *** Toolset Errors ***
imBadInptParam = $0B01; {error - bad input parameter }
imIllegalChar = $0B02; {error - Illegal character in string }
imOverflow = $0B03; {error - integer or long integer overflow }
imStrOverflow = $0B04; {error - string overflow }
*** Toolset Errors *** *)
minLongint = $80000000; {Limit - minimum negative signed long integer }
minFrac = $80000000; {Limit - pinned value for negative Frac overflow }
minFixed = $80000000; {Limit - pinned value for negative Fixed overflow }
minInt = $8000; {Limit - Minimum negative signed integer }
maxInt = $7FFF; {Limit - Maximum positive signed integer }
maxUInt = $FFFF; {Limit - Maximum positive unsigned integer }
maxLongint = $7FFFFFFF; {Limit - maximum positive signed Longint }
maxFrac = $7FFFFFFF; {Limit - pinned value for positive Frac overflow }
maxFixed = $7FFFFFFF; {Limit - pinned value for positive Fixed overflow }
maxULong = $FFFFFFFF; {Limit - maximum unsigned Long }
unsignedFlag = $0000; {SignedFlag - }
signedFlag = $0001; {SignedFlag - }
TYPE
IntDivRecPtr = ^IntDivRec;
IntDivRec = RECORD
quotient : Integer; { quotient from SDivide }
remainder : Integer; { remainder from SDivide }
END;
LongDivRecPtr = ^LongDivRec;
LongDivRec = RECORD
quotient : Longint; { Quotient from LongDiv }
remainder : Longint; { remainder from LongDiv }
END;
DivRecPtr = ^DivRec; (* for backward compatability *)
DivRec = LongDivRec;
LongMulRecPtr = ^LongMulRec;
LongMulRec = RECORD
lsResult : Longint; { low 2 words of product }
msResult : Longint; { High 2 words of product }
END;
WordDivRecPtr = ^WordDivRec;
WordDivRec = RECORD
quotient : Integer; { Quotient from UDivide }
remainder : Integer; { remainder from UDivide }
END;
PROCEDURE IMBootInit ; Tool $0B,$01;
PROCEDURE IMStartUp ; Tool $0B,$02;
PROCEDURE IMShutDown ; Tool $0B,$03;
FUNCTION IMVersion : Integer ; Tool $0B,$04;
PROCEDURE IMReset ; Tool $0B,$05;
FUNCTION IMStatus : Boolean ; Tool $0B,$06;
FUNCTION Dec2Int ( strPtr:Ptr; strLength:Integer; signedFlag:Boolean) : Integer
; Tool $0B,$28;
FUNCTION Dec2Long ( strPtr:Ptr; strLength:Integer; signedFlag:Boolean) :
Longint ; Tool $0B,$29;
FUNCTION Fix2Frac ( fixedValue:Fixed) : Frac ; Tool $0B,$1C;
FUNCTION Fix2Long ( fixedValue:Fixed) : Longint ; Tool $0B,$1B;
PROCEDURE Fix2X ( fixedValue:Fixed;VAR extendPtr:Extended) ; Tool $0B,$1E;
FUNCTION FixATan2 ( input1:Longint; input2:Longint) : Fixed ; Tool $0B,$17;
FUNCTION FixDiv ( dividend:Longint; divisor:Longint) : Fixed ; Tool $0B,$11;
FUNCTION FixMul ( multiplicand:Fixed; multiplier:Fixed) : Fixed ; Tool $0B,$0F;
FUNCTION FixRatio ( numerator:Integer; denominator:Integer) : Fixed ; Tool
$0B,$0E;
FUNCTION FixRound ( fixedValue:Fixed) : Integer ; Tool $0B,$13;
FUNCTION Frac2Fix ( fracValue:Frac) : Fixed ; Tool $0B,$1D;
PROCEDURE Frac2X ( fracValue:Frac;VAR extendPtr:Extended) ; Tool $0B,$1F;
FUNCTION FracCos ( angle:Fixed) : Frac ; Tool $0B,$15;
FUNCTION FracDiv ( dividend:Longint; divisor:Longint) : Frac ; Tool $0B,$12;
FUNCTION FracMul ( multiplicand:Frac; multiplier:Frac) : Frac ; Tool $0B,$10;
FUNCTION FracSin ( angle:Fixed) : Frac ; Tool $0B,$16;
FUNCTION FracSqrt ( fracValue:Frac) : Frac ; Tool $0B,$14;
FUNCTION Hex2Int ( strPtr:Ptr; strLength:Integer) : Integer ; Tool $0B,$24;
FUNCTION Hex2Long ( strPtr:Ptr; strLength:Integer) : Longint ; Tool $0B,$25;
FUNCTION HexIt ( intValue:Integer) : Longint ; Tool $0B,$2A;
FUNCTION HiWord ( longValue:Longint) : Integer ; Tool $0B,$18;
PROCEDURE Int2Dec ( wordValue:Integer; strPtr:Ptr; strLength:Integer;
signedFlag:Boolean) ; Tool $0B,$26;
PROCEDURE Int2Hex ( intValue:Integer; strPtr:Ptr; strLength:Integer) ; Tool
$0B,$22;
PROCEDURE Long2Dec ( longValue:Longint; strPtr:Ptr; strLength:Integer;
signedFlag:Boolean) ; Tool $0B,$27;
FUNCTION Long2Fix ( longValue:Longint) : Fixed ; Tool $0B,$1A;
PROCEDURE Long2Hex ( longValue:Longint; strPtr:Ptr; strLength:Integer) ; Tool
$0B,$23;
FUNCTION LongDivide ( dividend:Longint; divisor:Longint) : LongDivRec ;
EXTERNAL ;
FUNCTION LongMul ( multiplicand:Longint; multiplier:Longint) : LongMulRec ;
EXTERNAL ;
FUNCTION LoWord ( longValue:Longint) : Integer ; Tool $0B,$19;
FUNCTION Multiply ( multiplicand:Integer; multiplier:Integer) : Longint ; Tool
$0B,$09;
FUNCTION SDivide ( dividend:Integer; divisor:Integer) : IntDivRec ; Tool
$0B,$0A;
FUNCTION UDivide ( dividend:Integer; divisor:Integer) : WordDivRec ; Tool
$0B,$0B;
FUNCTION X2Fix ( extendPtr:ExtendedPtr) : Longint ; Tool $0B,$20;
FUNCTION X2Frac ( extendPtr:ExtendedPtr) : Longint ; Tool $0B,$21;
IMPLEMENTATION
END.

95
pascal/lineedit.p Executable file
View File

@ -0,0 +1,95 @@
{********************************************
; File: LineEdit.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT LINEEDIT;
INTERFACE
USES TYPES,QUICKDRAW,EVENTS;
CONST
(* *** Toolset Errors ***
leDupStrtUpErr = $1401; {error - duplicate LEStartup call }
leResetErr = $1402; {error - can't reset Line Edit }
leNotActiveErr = $1403; {error - Line Edit not active }
leScrapErr = $1404; {error - desk scrap too big to copy }
*** Toolset Errors *** *)
leJustLeft = $0000; {Justification - }
leJustCenter = $0001; {Justification - }
leJustFill = $0002; {Justification - }
leJustRight = $FFFF; {Justification - }
TYPE
LERecHndl = ^LERecPtr;
LERecPtr = ^LERec;
LERec = RECORD
leLineHandle : Handle;
leLength : Integer;
leMaxLength : Integer;
leDestRect : Rect;
leViewRect : Rect;
lePort : GrafPortPtr;
leLineHite : Integer;
leBaseHite : Integer;
leSelStart : Integer;
leSelEnd : Integer;
leActFlg : Integer;
leCarAct : Integer;
leCarOn : Integer;
leCarTime : Longint;
leHiliteHook : VoidProcPtr;
leCaretHook : VoidProcPtr;
leJust : Integer;
lePWChar : Integer;
END;
PROCEDURE LEBootInit ; Tool $14,$01;
PROCEDURE LEStartUp ( userID:Integer; dPageAddr:Integer) ; Tool $14,$02;
PROCEDURE LEShutDown ; Tool $14,$03;
FUNCTION LEVersion : Integer ; Tool $14,$04;
PROCEDURE LEReset ; Tool $14,$05;
FUNCTION LEStatus : Boolean ; Tool $14,$06;
PROCEDURE LEActivate ( leRecHandle:LERecHndl) ; Tool $14,$0F;
PROCEDURE LEClick ( eventPtr:EventRecord; leRecHandle:LERecHndl) ; Tool
$14,$0D;
PROCEDURE LECopy ( leRecHandle:LERecHndl) ; Tool $14,$13;
PROCEDURE LECut ( leRecHandle:LERecHndl) ; Tool $14,$12;
PROCEDURE LEDeactivate ( leRecHandle:LERecHndl) ; Tool $14,$10;
PROCEDURE LEDelete ( leRecHandle:LERecHndl) ; Tool $14,$15;
PROCEDURE LEDispose ( leRecHandle:LERecHndl) ; Tool $14,$0A;
PROCEDURE LEFromScrap ; Tool $14,$19;
FUNCTION LEGetScrapLen : Integer ; Tool $14,$1C;
FUNCTION LEGetTextHand ( leRecHandle:LERecHndl) : Handle ; Tool $14,$22;
FUNCTION LEGetTextLen ( leRecHandle:LERecHndl) : Integer ; Tool $14,$23;
PROCEDURE LEIdle ( leRecHandle:LERecHndl) ; Tool $14,$0C;
PROCEDURE LEInsert ( textPtr:Ptr; textLength:Integer; leRecHandle:LERecHndl) ;
Tool $14,$16;
PROCEDURE LEKey ( theKey:CHAR; modifiers:Integer; leRecHandle:LERecHndl) ;
Tool $14,$11;
FUNCTION LENew ( destRectPtr:Rect; viewRectPtr:Rect; maxTextLen:Integer) :
LERecHndl ; Tool $14,$09;
PROCEDURE LEPaste ( leRecHandle:LERecHndl) ; Tool $14,$14;
FUNCTION LEScrapHandle : Handle ; Tool $14,$1B;
PROCEDURE LESetCaret ( caretProcPtr:VoidProcPtr; leRecHandle:LERecHndl) ; Tool
$14,$1F;
PROCEDURE LESetHilite ( hiliteProcPtr:VoidProcPtr; leRecHandle:LERecHndl) ;
Tool $14,$1E;
PROCEDURE LESetJust ( just:Integer; leRecHandle:LERecHndl) ; Tool $14,$21;
PROCEDURE LESetScrapLen ( newLength:Integer) ; Tool $14,$1D;
PROCEDURE LESetSelect ( selStart:Integer; selEnd:Integer;
leRecHandle:LERecHndl) ; Tool $14,$0E;
PROCEDURE LESetText ( textPtr:Ptr; textLength:Integer; leRecHandle:LERecHndl)
; Tool $14,$0B;
PROCEDURE LETextBox ( textPtr:Ptr; textLength:Integer; rectPtr:Rect;
just:Integer) ; Tool $14,$18;
PROCEDURE LETextBox2 ( textPtr:Ptr; textLength:Integer; rectPtr:Rect;
just:Integer) ; Tool $14,$20;
PROCEDURE LEToScrap ; Tool $14,$1A;
PROCEDURE LEUpdate ( leRecHandle:LERecHndl) ; Tool $14,$17;
FUNCTION GetLEDefProc : Ptr ; Tool $14,$24;
IMPLEMENTATION
END.

106
pascal/lists.p Executable file
View File

@ -0,0 +1,106 @@
{********************************************
; File: Lists.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT LISTS;
INTERFACE
USES TYPES,QUICKDRAW,EVENTS,CONTROLS;
CONST
cString = $0001; {ListType bit mask - null terminated string type }
LIST_STRG = $0001; {ListType bit mask - null terminated string type }
selectOnlyOne = $0002; {ListType bit mask - only one selection allowed }
LIST_SELECT = $0002; {ListType bit mask - single selection only }
memDisabled = $40; {memFlag - Sets member flag to disabled }
memSelected = $80; {memFlag - Sets member flag to selected }
TYPE
LColorTableHndl = ^LColorTablePtr;
LColorTablePtr = ^LColorTable;
LColorTable = RECORD
listFrameClr : Integer; { Frame color }
listNorTextClr : Integer; { Unhighlighted text color }
listSelTextClr : Integer; { Highlighted text color }
listNorBackClr : Integer; { Unhighlighted background color }
listSelBackClr : Integer; { Highlighted backgraound color }
END;
MemRecHndl = ^MemRecPtr;
MemRecPtr = ^MemRec;
MemRec = PACKED RECORD
memPtr : Ptr; { Pointer to string, or custom }
memFlag : Byte; { Bit Flag }
END;
ListCtlRecHndl = ^ListCtlRecPtr;
ListCtlRecPtr = ^ListCtlRec;
ListCtlRec = PACKED RECORD
ctlNext : CtlRecHndl; { Handle of Next Control }
ctlOwner : GrafPortPtr; { Window owner }
ctlRect : Rect; { Enclosing Rect }
ctlFlag : Byte; { Bit 7 visible, Bit 0 string type, Bit 1 multiple }
ctlHilite : Byte; { (not used) }
ctlValue : Integer; { First member in display }
ctlProc : LongProcPtr; { Address of list definition procedure }
ctlAction : LongProcPtr; { Address of list action procedure }
ctlData : Longint; { Low = view size, High = total members }
ctlRefCon : Longint; { Not used }
ctlColor : LColorTablePtr; { Null for default colors }
ctlMemDraw : VoidProcPtr; { Address of routine to draw members }
ctlMemHeight : Integer; { Member's Height in Pixels }
ctlMemSize : Integer; { Bytes in member record }
ctlList : MemRecPtr; { Adress of first member record in array }
ctlListBar : CtlRecHndl; { Handle of list contrlo's scroll bar control }
END;
ListRecHndl = ^ListRecPtr;
ListRecPtr = ^ListRec;
ListRec = RECORD
listRect : Rect; { Enclosing Rectangle }
listSize : Integer; { Number of List Members }
listView : Integer; { Max Viewable members }
listType : Integer; { Bit Flag }
listStart : Integer; { First member in view }
listCtl : CtlRecHndl; { List control's handle }
listDraw : VoidProcPtr; { Address of Custom drawing routine }
listMemHeight : Integer; { Height of list members }
listMemSize : Integer; { Size of Member Records }
listPointer : MemRecPtr; { Pointer to first element in MemRec array }
listRefCon : Longint; { becomes Control's refCon }
listScrollClr : BarColorsPtr; { Color table for list's scroll bar }
END;
PROCEDURE ListBootInit ; Tool $1C,$01;
PROCEDURE ListStartup ; Tool $1C,$02;
PROCEDURE ListShutDown ; Tool $1C,$03;
FUNCTION ListVersion : Integer ; Tool $1C,$04;
PROCEDURE ListReset ; Tool $1C,$05;
FUNCTION ListStatus : Boolean ; Tool $1C,$06;
FUNCTION CreateList ( theWindowPtr:WindowPtr; U__listRecPtr:ListRecPtr) :
ListCtlRecHndl ; Tool $1C,$09;
PROCEDURE DrawMember ( memberPtr:MemRecPtr; U__listRecPtr:ListRecPtr) ; Tool
$1C,$0C;
FUNCTION GetListDefProc : LongProcPtr ; Tool $1C,$0E;
PROCEDURE NewList ( memberPtr:MemRecPtr; U__listRecPtr:ListRecPtr) ; Tool
$1C,$10;
FUNCTION NextMember ( memberPtr:MemRecPtr; U__listRecPtr:ListRecPtr) :
MemRecPtr ; Tool $1C,$0B;
FUNCTION ResetMember ( U__listRecPtr:ListRecPtr) : MemRecPtr ; Tool $1C,$0F;
PROCEDURE SelectMember ( memberPtr:MemRecPtr; U__listRecPtr:ListRecPtr) ; Tool
$1C,$0D;
PROCEDURE SortList ( comparePtr:VoidProcPtr; U__listRecPtr:ListRecPtr) ; Tool
$1C,$0A;
PROCEDURE DrawMember2 ( itemNumber:Integer; ctlHandle:CtlRecHndl) ; Tool
$1C,$11;
FUNCTION NextMember2 ( itemNumber:Integer; ctlHandle:CtlRecHndl) : Integer ;
Tool $1C,$12;
FUNCTION ResetMember2 ( ctlHandle:CtlRecHndl) : Integer ; Tool $1C,$13;
PROCEDURE SelectMember2 ( itemNumber:Integer; ctlHandle:CtlRecHndl) ; Tool
$1C,$14;
PROCEDURE SortList2 ( comparePtr:Ptr; ctlHandle:CtlRecHndl) ; Tool $1C,$15;
PROCEDURE NewList2 ( drawProcPtr:ProcPtr; listStart:Integer; listRef:Ref;
listRefDesc:RefDescriptor; listSize:Integer; ctlHandle:CtlRecHndl) ; Tool
$1C,$16;
IMPLEMENTATION
END.

87
pascal/loader.p Executable file
View File

@ -0,0 +1,87 @@
{********************************************
; File: Loader.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT LOADER;
INTERFACE
USES TYPES;
(* *** Toolset Errors ***
CONST
idNotFound = $1101; {error - segment/application/entry not found }
idNotLoadFile = $1104; {error - file is not a load file }
idBusyErr = $1105; {error - system loader is busy }
idFilVersErr = $1107; {error - file version error }
idUserIDErr = $1108; {error - user ID error }
idSequenceErr = $1109; {error - segnum out of sequence }
idBadRecordErr = $110A; {error - illegal load record found }
idForeignSegErr = $110B; {error - segment is foreign }
*** Toolset Errors *** *)
TYPE
InitialLoadOutputRecPtr = ^InitialLoadOutputRec;
InitialLoadOutputRec = RECORD
userID : Integer;
startAddr : Ptr;
dPageAddr : Integer;
buffSize : Integer;
END;
RestartOutRecPtr = ^RestartOutRec;
RestartOutRec = RECORD
userID : Integer;
startAddr : Ptr;
dPageAddr : Integer;
buffSize : Integer;
END;
LoadSegNameOutPtr = ^LoadSegNameOut;
LoadSegNameOut = RECORD
segAddr : Ptr;
fileNum : Integer;
segNum : Integer;
END;
UnloadSegOutRecPtr = ^UnloadSegOutRec;
UnloadSegOutRec = RECORD
userID : Integer;
fileNum : Integer;
segNum : Integer;
END;
PROCEDURE LoaderInitialization ; Tool $11,$01;
PROCEDURE LoaderStartUp ; Tool $11,$02;
PROCEDURE LoaderShutDown ; Tool $11,$03;
FUNCTION LoaderVersion : Integer ; Tool $11,$04;
PROCEDURE LoaderReset ; Tool $11,$05;
FUNCTION LoaderStatus : Boolean ; Tool $11,$06;
PROCEDURE GetLoadSegInfo ( userID:Integer; loadFileNum:Integer;
loadSegNum:Integer; bufferPtr:Ptr) ; Tool $11,$0F;
FUNCTION GetUserID ( pathNamePtr:Ptr) : Integer ; Tool $11,$10;
FUNCTION GetUserID2 ( pathNamePtr:Ptr) : Integer ; Tool $11,$21;
FUNCTION InitialLoad ( userID:Integer; loadFileNamePtr:Ptr; spMemFlag:Boolean)
: InitialLoadOutputRec ; EXTERNAL ;
FUNCTION InitialLoad2 ( userID:Integer; loadFileNamePtr:Ptr; spMemFlag:Boolean;
inputType:Integer) : InitialLoadOutputRec ; EXTERNAL ;
FUNCTION LGetPathname ( userID:Integer; fileNumber:Integer) : Ptr ; Tool
$11,$11;
FUNCTION LGetPathname2 ( userID:Integer; fileNumber:Integer) : Ptr ; Tool
$11,$22;
FUNCTION GetPathname ( userID:Integer; fileNumber:Integer) : Ptr ; Tool
$11,$11;
FUNCTION GetPathname2 ( userID:Integer; fileNumber:Integer) : Ptr ; Tool
$11,$22;
PROCEDURE RenamePathname ( oldPathname:Ptr; newPathname:Ptr) ; Tool $11,$13;
FUNCTION LoadSegName ( userID:Integer; loadFileNamePtr:Ptr; loadSegNamePtr:Ptr)
: LoadSegNameOut ; EXTERNAL ;
FUNCTION LoadSegNum ( userID:Integer; loadFileNum:Integer; loadSegNum:Integer)
: Ptr ; Tool $11,$0B;
FUNCTION Restart ( userID:Integer) : RestartOutRec ; EXTERNAL ;
FUNCTION UnloadSeg ( segmentPtr:Ptr) : UnloadSegOutRec ; EXTERNAL ;
PROCEDURE UnloadSegNum ( userID:Integer; loadFileNum:Integer;
loadSegNum:Integer) ; Tool $11,$0C;
FUNCTION UserShutDown ( userID:Integer; restartFlag:Integer) : Integer ; Tool
$11,$12;
IMPLEMENTATION
END.

87
pascal/locator.p Executable file
View File

@ -0,0 +1,87 @@
{********************************************
; File: Locator.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT LOCATOR;
INTERFACE
USES TYPES;
CONST
(* *** Toolset Errors ***
toolNotFoundErr = $0001; {error - }
funcNotFoundErr = $0002; {error - }
toolVersionErr = $0110; {error - }
sysStrtMtErr = $0100; {error - can't mount system startup volume }
messNotFoundErr = $0111; {error - }
*** Toolset Errors *** *)
fileInfoType = $0001; {MessageCenter - Message type parameter }
addMessage = $0001; {MessageCenter - action parameter }
getMessage = $0002; {MessageCenter - action parameter }
deleteMessage = $0003; {MessageCenter - action parameter }
mvReturn = $0001; {TLMountVolume - like ok for dialogs }
mvEscape = $0002; {TLMountVolume - like cancel for dialogs }
sysTool = $0000; {Tool Set Spec - }
userTool = $8000; {Tool Set Spec - }
TYPE
MessageRecHndl = ^MessageRecPtr;
MessageRecPtr = ^MessageRec;
MessageRec = RECORD
messageNext : MessageRecHndl;
messageType : Integer;
messageData : Integer;
fileNames : PACKED ARRAY[1..1] OF Str255;
END;
ToolSpec = RECORD
toolNumber : Integer;
minVersion : Integer;
END;
StartStopRecordPtr = ^StartStopRecord;
StartStopRecord = RECORD
flags : Integer;
videoMode : Integer;
resFileID : Integer;
dPageHandle : Handle;
numTools : Integer;
END;
PROCEDURE TLBootInit ; Tool $01,$01;
PROCEDURE TLStartUp ; Tool $01,$02;
PROCEDURE TLShutDown ; Tool $01,$03;
FUNCTION TLVersion : Integer ; Tool $01,$04;
PROCEDURE TLReset ; Tool $01,$05;
FUNCTION TLStatus : Boolean ; Tool $01,$06;
FUNCTION GetFuncPtr ( userOrSystem:Integer; funcTSNum:Integer) : Ptr ; Tool
$01,$0B;
FUNCTION GetTSPtr ( userOrSystem:Integer; tSNum:Integer) : Ptr ; Tool $01,$09;
FUNCTION GetWAP ( userOrSystem:Integer; tSNum:Integer) : Ptr ; Tool $01,$0C;
PROCEDURE LoadOneTool ( toolNumber:Integer; minVersion:Integer) ; Tool
$01,$0F;
PROCEDURE LoadTools ( toolTablePtr:Ptr) ; Tool $01,$0E;
PROCEDURE MessageCenter ( action:Integer; messagetype:Integer;
messageHandle:MessageRecHndl) ; Tool $01,$15;
PROCEDURE RestoreTextState ( stateHandle:Handle) ; Tool $01,$14;
FUNCTION SaveTextState : Handle ; Tool $01,$13;
PROCEDURE SetDefaultTPT ; Tool $01,$16;
PROCEDURE SetTSPtr ( userOrSystem:Integer; tsNum:Integer; fptablePtr:FPTPtr) ;
Tool $01,$0A;
PROCEDURE SetWAP ( userOrSystem:Integer; tSNum:Integer; waptPtr:Ptr) ; Tool
$01,$0D;
FUNCTION TLMountVolume ( whereX:Integer; whereY:Integer; line1:Str255;
line2:Str255; but1:Str255; but2:Str255) : Integer ; Tool $01,$11;
FUNCTION TLTextMountVolume ( line1:Str255; line2:Str255; but1:Str255;
but2:Str255) : Integer ; Tool $01,$12;
PROCEDURE UnloadOneTool ( toolNumber:Integer) ; Tool $01,$10;
FUNCTION StartUpTools ( userID:Integer; startStopRefDesc:RefDescriptor;
startStopRef:Ref) : Ref ; Tool $01,$18;
PROCEDURE ShutDownTools ( startStopDesc:RefDescriptor; startStopRef:Ref) ;
Tool $01,$19;
FUNCTION MessageByName ( createItFlag:Boolean; recordPtr:Ptr) : Longint ; Tool
$01,$17;
IMPLEMENTATION
END.

80
pascal/memory.p Executable file
View File

@ -0,0 +1,80 @@
{********************************************
; File: Memory.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT MEMORY;
INTERFACE
USES TYPES;
CONST
(* *** Toolset Errors ***
memErr = $0201; {error - unable to allocate block }
emptyErr = $0202; {error - illegal operation, empty handle }
notEmptyErr = $0203; {error - an empty handle was expected for this operation }
lockErr = $0204; {error - illegal operation on a locked block }
purgeErr = $0205; {error - attempt to purge an unpurgable block }
handleErr = $0206; {error - an invalid handle was given }
idErr = $0207; {error - an invalid owner ID was given }
attrErr = $0208; {error - operation illegal on block with given attributes }
*** Toolset Errors *** *)
attrNoPurge = $0000; {Handle Attribute Bits - Not purgeable }
attrBank = $0001; {Handle Attribute Bits - fixed bank }
attrAddr = $0002; {Handle Attribute Bits - fixed address }
attrPage = $0004; {Handle Attribute Bits - page aligned }
attrNoSpec = $0008; {Handle Attribute Bits - may not use special memory }
attrNoCross = $0010; {Handle Attribute Bits - may not cross banks }
attrPurge1 = $0100; {Handle Attribute Bits - Purge level 1 }
attrPurge2 = $0200; {Handle Attribute Bits - Purge level 2 }
attrPurge3 = $0300; {Handle Attribute Bits - Purge level 3 }
attrPurge = $0300; {Handle Attribute Bits - test or set both purge bits }
attrHandle = $1000; {Handle Attribute Bits - block of master pointers }
attrSystem = $2000; {Handle Attribute Bits - system handle }
attrFixed = $4000; {Handle Attribute Bits - not movable }
attrLocked = $8000; {Handle Attribute Bits - locked }
PROCEDURE MMBootInit ; Tool $02,$01;
FUNCTION MMStartUp : Integer ; Tool $02,$02;
PROCEDURE MMShutDown ( userID:Integer) ; Tool $02,$03;
FUNCTION MMVersion : Integer ; Tool $02,$04;
PROCEDURE MMReset ; Tool $02,$05;
FUNCTION MMStatus : Boolean ; Tool $02,$06;
PROCEDURE BlockMove ( srcPtr:Ptr; dstPtr:Ptr; count:Longint) ; Tool $02,$2B;
PROCEDURE CheckHandle ( theHandle:Handle) ; Tool $02,$1E;
PROCEDURE CompactMem ; Tool $02,$1F;
PROCEDURE DisposeAll ( userID:Integer) ; Tool $02,$11;
PROCEDURE DisposeHandle ( theHandle:Handle) ; Tool $02,$10;
FUNCTION FindHandle ( locationPtr:Ptr) : Handle ; Tool $02,$1A;
FUNCTION FreeMem : Longint ; Tool $02,$1B;
FUNCTION GetHandleSize ( theHandle:Handle) : Longint ; Tool $02,$18;
PROCEDURE HandToHand ( sourceHandle:Handle; destHandle:Handle; count:Longint)
; Tool $02,$2A;
PROCEDURE HandToPtr ( sourceHandle:Handle; destPtr:Ptr; count:Longint) ; Tool
$02,$29;
PROCEDURE HLock ( theHandle:Handle) ; Tool $02,$20;
PROCEDURE HLockAll ( userID:Integer) ; Tool $02,$21;
PROCEDURE HUnlock ( theHandle:Handle) ; Tool $02,$22;
PROCEDURE HUnlockAll ( userID:Integer) ; Tool $02,$23;
FUNCTION MaxBlock : Longint ; Tool $02,$1C;
FUNCTION NewHandle ( blockSize:Longint; userID:Integer; attributes:Integer;
locationPtr:Ptr) : Handle ; Tool $02,$09;
PROCEDURE PtrToHand ( sourcePtr:Ptr; destHandle:Handle; count:Longint) ; Tool
$02,$28;
PROCEDURE PurgeAll ( userID:Integer) ; Tool $02,$13;
PROCEDURE PurgeHandle ( theHandle:Handle) ; Tool $02,$12;
FUNCTION RealFreeMem : Longint ; Tool $02,$2F;
PROCEDURE ReallocHandle ( blockSize:Longint; userID:Integer;
attributes:Integer; locationPtr:Ptr; theHandle:Handle) ; Tool $02,$0A;
PROCEDURE RestoreHandle ( theHandle:Handle) ; Tool $02,$0B;
PROCEDURE SetHandleSize ( newSize:Longint; theHandle:Handle) ; Tool $02,$19;
PROCEDURE SetPurge ( newPurgeLevel:Integer; theHandle:Handle) ; Tool $02,$24;
PROCEDURE SetPurgeAll ( newPurgeLevel:Integer; userID:Integer) ; Tool $02,$25;
FUNCTION TotalMem : Longint ; Tool $02,$1D;
PROCEDURE AddToOOMQueue ( headerPtr:Ptr) ; Tool $02,$0C;
PROCEDURE DeleteFromOOMQueue ( headerPtr:Ptr) ; Tool $02,$0D;
IMPLEMENTATION
END.

142
pascal/menus.p Executable file
View File

@ -0,0 +1,142 @@
{********************************************
; File: Menus.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT MENUS;
INTERFACE
USES TYPES,QUICKDRAW,EVENTS,CONTROLS,WINDOWS;
CONST
mDrawMsg = $0000; {MenuDefProcCodes - }
mChooseMsg = $0001; {MenuDefProcCodes - }
mSizeMsg = $0002; {MenuDefProcCodes - }
mDrawTitle = $0003; {MenuDefProcCodes - }
mDrawMItem = $0004; {MenuDefProcCodes - }
mGetMItemID = $0005; {MenuDefProcCodes - }
mInvis = $0004; {MenuFlag - }
mCustom = $0010; {MenuFlag - }
mXor = $0020; {MenuFlag - }
mSelected = $0040; {MenuFlag - }
mDisabled = $0080; {MenuFlag - }
customMenu = $0010; {MenuFlagMasks - }
xorMItemHilite = $0020; {MenuFlagMasks - }
xorTitleHilite = $0020; {MenuFlagMasks - }
underMItem = $0040; {MenuFlagMasks - }
disableItem = $0080; {MenuFlagMasks - }
disableMenu = $0080; {MenuFlagMasks - }
enableItem = $FF7F; {MenuFlagMasks - }
enableMenu = $FF7F; {MenuFlagMasks - }
noUnderMItem = $FFBF; {MenuFlagMasks - }
colorMItemHilite = $FFDF; {MenuFlagMasks - }
colorTitleHilite = $FFDF; {MenuFlagMasks - }
colorReplace = $FFDF; {MenuFlagMasks - }
standardMenu = $FFEF; {MenuFlagMasks - }
TYPE
MenuBarRecHndl = ^MenuBarRecPtr;
MenuBarRecPtr = ^MenuBarRec;
MenuBarRec = CtlRec ;
MenuRecHndl = ^MenuRecPtr;
MenuRecPtr = ^MenuRec;
MenuRec = PACKED RECORD
menuID : Integer; { Menu's ID number }
menuWidth : Integer; { Width of menu }
menuHeight : Integer; { Height of menu }
menuProc : WordProcPtr; { Menu's definition procedure }
menuFlag : Integer; { Bit flags }
firstItem : Byte;
numOfItems : Byte;
titleWidth : Integer; { Width of menu's title }
titleName : Ptr;
END;
PROCEDURE MenuBootInit ; Tool $0F,$01;
PROCEDURE MenuStartUp ( userID:Integer; dPageAddr:Integer) ; Tool $0F,$02;
PROCEDURE MenuShutDown ; Tool $0F,$03;
FUNCTION MenuVersion : Integer ; Tool $0F,$04;
PROCEDURE MenuReset ; Tool $0F,$05;
FUNCTION MenuStatus : Boolean ; Tool $0F,$06;
PROCEDURE CalcMenuSize ( newWidth:Integer; newHeight:Integer; menuNum:Integer)
; Tool $0F,$1C;
PROCEDURE CheckMItem ( checkedFlag:Boolean; itemNum:Integer) ; Tool $0F,$32;
FUNCTION CountMItems ( menuNum:Integer) : Integer ; Tool $0F,$14;
PROCEDURE DeleteMenu ( menuNum:Integer) ; Tool $0F,$0E;
PROCEDURE DeleteMItem ( itemNum:Integer) ; Tool $0F,$10;
PROCEDURE DisableMItem ( itemNum:Integer) ; Tool $0F,$31;
PROCEDURE DisposeMenu ( menuHandle:MenuRecHndl) ; Tool $0F,$2E;
PROCEDURE DrawMenuBar ; Tool $0F,$2A;
PROCEDURE EnableMItem ( itemNum:Integer) ; Tool $0F,$30;
FUNCTION FixMenuBar : Integer ; Tool $0F,$13;
PROCEDURE FlashMenuBar ; Tool $0F,$0C;
FUNCTION GetBarColors : Longint ; Tool $0F,$18;
FUNCTION GetMenuBar : MenuBarRecHndl ; Tool $0F,$0A;
FUNCTION GetMenuFlag ( menuNum:Integer) : Integer ; Tool $0F,$20;
FUNCTION GetMenuMgrPort : GrafPortPtr ; Tool $0F,$1B;
FUNCTION GetMenuTitle ( menuNum:Integer) : Ptr ; Tool $0F,$22;
FUNCTION GetMHandle ( menuNum:Integer) : MenuRecHndl ; Tool $0F,$16;
FUNCTION GetMItem ( itemNum:Integer) : StringPtr ; Tool $0F,$25;
FUNCTION GetMItemFlag ( itemNum:Integer) : Integer ; Tool $0F,$27;
FUNCTION GetMItemMark ( itemNum:Integer) : Integer ; Tool $0F,$34;
FUNCTION GetMItemStyle ( itemNum:Integer) : TextStyle ; Tool $0F,$36;
FUNCTION GetMTitleStart : Integer ; Tool $0F,$1A;
FUNCTION GetMTitleWidth ( menuNum:Integer) : Integer ; Tool $0F,$1E;
FUNCTION GetSysBar : MenuBarRecHndl ; Tool $0F,$11;
PROCEDURE HiliteMenu ( hiliteFlag:Boolean; menuNum:Integer) ; Tool $0F,$2C;
PROCEDURE InitPalette ; Tool $0F,$2F;
PROCEDURE InsertMenu ( addMenuHandle:MenuRecHndl; insertAfter:Integer) ; Tool
$0F,$0D;
PROCEDURE InsertMItem ( addItemPtr:Ptr; insertAfter:Integer; menuNum:Integer)
; Tool $0F,$0F;
FUNCTION MenuGlobal ( menuGlobalMask:Integer) : Integer ; Tool $0F,$23;
PROCEDURE MenuKey ( taskRecPtr:WmTaskRec; barHandle:MenuBarRecHndl) ; Tool
$0F,$09;
PROCEDURE MenuNewRes ; Tool $0F,$29;
PROCEDURE MenuRefresh ( redrawRoutinePtr:VoidProcPtr) ; Tool $0F,$0B;
PROCEDURE MenuSelect ( taskRecPtr:WmTaskRec; barHandle:MenuBarRecHndl) ; Tool
$0F,$2B;
FUNCTION NewMenu ( menuStringPtr:Ptr) : MenuRecHndl ; Tool $0F,$2D;
FUNCTION NewMenuBar ( theWindowPtr:WindowPtr) : MenuBarRecHndl ; Tool $0F,$15;
PROCEDURE SetBarColors ( newBarColor:Integer; newInvertColor:Integer;
newOutColor:Integer) ; Tool $0F,$17;
PROCEDURE SetMenuBar ( barHandle:MenuBarRecHndl) ; Tool $0F,$39;
PROCEDURE SetMenuFlag ( newValue:Integer; menuNum:Integer) ; Tool $0F,$1F;
PROCEDURE SetMenuID ( newMenuNum:Integer; curMenuNum:Integer) ; Tool $0F,$37;
PROCEDURE SetMenuTitle ( newStr:Str255; menuNum:Integer) ; Tool $0F,$21;
PROCEDURE SetMItem ( newItemLine:Str255; itemNum:Integer) ; Tool $0F,$24;
PROCEDURE SetMItemBlink ( count:Integer) ; Tool $0F,$28;
PROCEDURE SetMItemFlag ( newValue:Integer; itemNum:Integer) ; Tool $0F,$26;
PROCEDURE SetMItemID ( newItemNum:Integer; curItemNum:Integer) ; Tool $0F,$38;
PROCEDURE SetMItemMark ( mark:Integer; itemNum:Integer) ; Tool $0F,$33;
PROCEDURE SetMItemName ( str:Str255; itemNum:Integer) ; Tool $0F,$3A;
PROCEDURE SetMItemStyle ( theTextStyle:TextStyle; itemNum:Integer) ; Tool
$0F,$35;
PROCEDURE SetMTitleStart ( xStart:Integer) ; Tool $0F,$19;
PROCEDURE SetMTitleWidth ( newWidth:Integer; menuNum:Integer) ; Tool $0F,$1D;
PROCEDURE SetSysBar ( barHandle:MenuBarRecHndl) ; Tool $0F,$12;
FUNCTION PopUpMenuSelect ( selection:Integer; currentLeft:Integer;
currentTop:Integer; flag:Integer; menuHandle:MenuRecHndl) : Integer ; Tool
$0F,$3C;
FUNCTION GetPopUpDefProc : Ptr ; Tool $0F,$3B;
PROCEDURE DrawPopUp ( selection:Integer; flag:Integer; right:Integer;
bottom:Integer; left:Integer; top:Integer; menuHandle:MenuRecHndl) ; Tool
$0F,$3D;
FUNCTION NewMenuBar2 ( refDesc:RefDescriptor; menuBarTemplateRef:Ref;
windowPortPtr:GrafPortPtr) : MenuBarRecHndl ; Tool $0F,$43;
FUNCTION NewMenu2 ( refDesc:RefDescriptor; menuTemplateRef:Ref) : MenuRecHndl ;
Tool $0F,$3E;
PROCEDURE InsertMItem2 ( refDesc:RefDescriptor; menuTemplateRef:Ref;
insertAfter:Integer; menuNum:Integer) ; Tool $0F,$3F;
PROCEDURE SetMenuTitle2 ( refDesc:RefDescriptor; titleRef:Ref; menuNum:Integer)
; Tool $0F,$40;
PROCEDURE SetMItem2 ( refDesc:RefDescriptor; menuItemTempRef:Ref;
menuItemID:Integer) ; Tool $0F,$41;
PROCEDURE SetMItemName2 ( refDesc:RefDescriptor; titleRef:Ref;
menuItemID:Integer) ; Tool $0F,$42;
PROCEDURE HideMenuBar ; Tool $0F,$45;
PROCEDURE ShowMenuBar ; Tool $0F,$46;
IMPLEMENTATION
END.

119
pascal/midi.p Executable file
View File

@ -0,0 +1,119 @@
{********************************************
; File: MIDI.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT MIDI;
INTERFACE
USES TYPES;
CONST
miToolNum = $0020; {Midi - the tool number of the MIDI Tool Set }
miDrvrFileType = $00BB; {Midi - filetype of MIDI device driver }
miNSVer = $0102; {Midi - minimum version of Note Synthesizer required by MIDI
Tool Set }
miSTVer = $0203; {Midi - minimum version of Sound Tools needed by MIDI Tool Set
}
miDrvrAuxType = $0300; {Midi - aux type of MIDI device driver }
(* *** Toolset Errors ***
miStartUpErr = $2000; {Midi - MIDI Tool Set is not started }
miPacketErr = $2001; {Midi - incorrect length for a received MIDI command }
miArrayErr = $2002; {Midi - a designated array had an insufficient or illegal
size }
miFullBufErr = $2003; {Midi - input buffer overflow }
miToolsErr = $2004; {Midi - the required tools were not started up or had
insufficient versions }
miOutOffErr = $2005; {Midi - MIDI output must first be enabled }
miNoBufErr = $2007; {Midi - no buffer is currently allocated }
miDriverErr = $2008; {Midi - the designated file is not a legal MIDI device
driver }
miBadFreqErr = $2009; {Midi - the MIDI clock cannot attain the requested
frequency }
miClockErr = $200A; {Midi - the MIDI clock value wrapped to zero }
miConflictErr = $200B; {Midi - conflicting processes for MIDI input }
miNoDevErr = $200C; {Midi - no MIDI device driver loaded }
miDevNotAvail = $2080; {Midi - the requested device is not available }
miDevSlotBusy = $2081; {Midi - requested slot is already in use }
miDevBusy = $2082; {Midi - the requested device is already in use }
miDevOverrun = $2083; {Midi - device overrun by incoming MIDI data }
miDevNoConnect = $2084; {Midi - no connection to MIDI }
miDevReadErr = $2085; {Midi - framing error in received MIDI data }
miDevVersion = $2086; {Midi - ROM version is incompatible with device driver }
miDevIntHndlr = $2087; {Midi - conflicting interrupt handler is installed }
*** Toolset Errors *** *)
miSetClock = $0000; {MidiClock - set time stamp clock }
miStartClock = $0001; {MidiClock - start time stamp clock }
miStopClock = $0002; {MidiClock - stop time stamp clock }
miSetFreq = $0003; {MidiClock - set clock frequency }
miRawMode = $00000000; {MidiControl - raw mode for MIDI input and output }
miSetRTVec = $0000; {MidiControl - set real-time message vector }
miPacketMode = $00000001; {MidiControl - packet mode for MIDI input and output
}
miSetErrVec = $0001; {MidiControl - set real-time error vector }
miStandardMode = $00000002; {MidiControl - standard mode for MIDI input and
output }
miSetInBuf = $0002; {MidiControl - set input buffer information }
miSetOutBuf = $0003; {MidiControl - set output buffer information }
miStartInput = $0004; {MidiControl - start MIDI input }
miStartOutput = $0005; {MidiControl - start MIDI output }
miStopInput = $0006; {MidiControl - stop MIDI input }
miStopOutput = $0007; {MidiControl - stop MIDI output }
miFlushInput = $0008; {MidiControl - discard contents of input buffer }
miFlushOutput = $0009; {MidiControl - discard contents of output buffer }
miFlushPacket = $000A; {MidiControl - discard next input packet }
miWaitOutput = $000B; {MidiControl - wait for output buffer to empty }
miSetInMode = $000C; {MidiControl - set input mode }
miSetOutMode = $000D; {MidiControl - set output mode }
miClrNotePad = $000E; {MidiControl - clear all notes marked on in the note pad
}
miSetDelay = $000F; {MidiControl - set minimum delay between output packets }
miOutputStat = $0010; {MidiControl - enable/disable output of running-status }
miIgnoreSysEx = $0011; {MidiControl - ignore system exclusive input }
miSelectDrvr = $0000; {MidiDevice - display device driver selection dialog }
miLoadDrvr = $0001; {MidiDevice - load and initialize device driver }
miUnloadDrvr = $0002; {MidiDevice - shutdown MIDI device, unload driver }
miNextPktLen = $0; {MidiInfo - return length of next packet }
miInputChars = $0001; {MidiInfo - return number of characters in input buffer }
miOutputChars = $0002; {MidiInfo - return number of characters in output buffer
}
miMaxInChars = $0003; {MidiInfo - return maximum number of characters in input
buffer }
miMaxOutChars = $0004; {MidiInfo - return maximum number of characters in
output buffer }
miRecordAddr = $0005; {MidiInfo - return current MidiRecordSeq address }
miPlayAddr = $0006; {MidiInfo - return current MidiPlaySeq address }
miClockValue = $0007; {MidiInfo - return current time stamp clock value }
miClockFreq = $0008; {MidiInfo - return number of clock ticks per second }
TYPE
MiBufInfo = RECORD
bufSize : Integer; { size of buffer (0 for default) }
address : Ptr; { address of buffer (0 for auto-allocation) }
END;
MiDriverInfo = RECORD
slot : Integer; { device slot }
external : Integer; { slot internal (=0) / external (=1) }
pathname : PACKED ARRAY[1..65] OF Byte; { device driver pathname }
END;
PROCEDURE MidiBootInit ; Tool $20,$01;
PROCEDURE MidiStartUp ( userID:Integer; directPages:Integer) ; Tool $20,$02;
PROCEDURE MidiShutDown ; Tool $20,$03;
FUNCTION MidiVersion : Integer ; Tool $20,$04;
PROCEDURE MidiReset ; Tool $20,$05;
FUNCTION MidiStatus : Boolean ; Tool $20,$06;
PROCEDURE MidiClock ( funcNum:Integer; arg:Longint) ; Tool $20,$0B;
PROCEDURE MidiControl ( controlCode:Integer) ; Tool $20,$09;
PROCEDURE MidiDevice ( funcNum:Integer; driverInfo:Ptr) ; Tool $20,$0A;
FUNCTION MidiInfo ( funcNum:Integer) : Longint ; Tool $20,$0C;
PROCEDURE MidiInputPoll ; EXTERNAL ;
FUNCTION MidiReadPacket ( arrayAddr:Ptr; arraySize:Integer) : Integer ; Tool
$20,$0D;
FUNCTION MidiWritePacket ( arrayAddr:Ptr) : Integer ; Tool $20,$0E;
IMPLEMENTATION
END.

367
pascal/misctool.p Executable file
View File

@ -0,0 +1,367 @@
{********************************************
; File: MiscTool.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT MISCTOOL;
INTERFACE
USES TYPES;
(* *** Toolset Errors ***
CONST
badInputErr = $0301; {error - bad input parameter }
noDevParamErr = $0302; {error - no device for input parameter }
taskInstlErr = $0303; {error - task already installed error }
noSigTaskErr = $0304; {error - no signature in task header }
queueDmgdErr = $0305; {error - queue has been damaged error }
taskNtFdErr = $0306; {error - task was not found error }
firmTaskErr = $0307; {error - firmware task was unsuccessful }
hbQueueBadErr = $0308; {error - heartbeat queue damaged }
unCnctdDevErr = $0309; {error - attempted to dispatch to unconnected device }
idTagNtAvlErr = $030B; {error - ID tag not available }
pdosUnClmdIntErr = $0001; {System Fail - ProDOS unclaimed interrupt error }
divByZeroErr = $0004; {System Fail - divide by zero error }
pdosVCBErr = $000A; {System Fail - ProDOS VCB unusable }
pdosFCBErr = $000B; {System Fail - ProDOS FCB unusable }
pdosBlk0Err = $000C; {System Fail - ProDOS block zero allocated illegally }
pdosIntShdwErr = $000D; {System Fail - ProDOS interrupt w/ shadowing off }
segLoader1Err = $0015; {System Fail - segment loader error }
sPackage0Err = $0017; {System Fail - can't load a package }
package1Err = $0018; {System Fail - can't load a package }
package2Err = $0019; {System Fail - can't load a package }
package3Err = $001A; {System Fail - can't load a package }
package4Err = $001B; {System Fail - can't load a package }
package5Err = $001C; {System Fail - can't load a package }
package6Err = $001D; {System Fail - can't load a package }
package7Err = $001E; {System Fail - can't load a package }
package8Err = $0020; {System Fail - can't load a package }
package9Err = $0021; {System Fail - can't load a package }
package10Err = $0022; {System Fail - can't load a package }
package11Err = $0023; {System Fail - can't load a package }
package12Err = $0024; {System Fail - can't load a package }
outOfMemErr = $0025; {System Fail - out of memory error }
segLoader2Err = $0026; {System Fail - segment loader error }
fMapTrshdErr = $0027; {System Fail - file map trashed }
stkOvrFlwErr = $0028; {System Fail - stack overflow error }
psInstDiskErr = $0030; {System Fail - Please Insert Disk (file manager alert) }
memMgr1Err = $0032; {System Fail - memory manager error }
memMgr2Err = $0033; {System Fail - memory manager error }
memMgr3Err = $0034; {System Fail - memory manager error }
memMgr4Err = $0035; {System Fail - memory manager error }
memMgr5Err = $0036; {System Fail - memory manager error }
memMgr6Err = $0037; {System Fail - memory manager error }
memMgr7Err = $0038; {System Fail - memory manager error }
memMgr8Err = $0039; {System Fail - memory manager error }
memMgr9Err = $003A; {System Fail - memory manager error }
memMgr10Err = $003B; {System Fail - memory manager error }
memMgr11Err = $003C; {System Fail - memory manager error }
memMgr12Err = $003D; {System Fail - memory manager error }
memMgr13Err = $003E; {System Fail - memory manager error }
memMgr14Err = $003F; {System Fail - memory manager error }
memMgr15Err = $0040; {System Fail - memory manager error }
memMgr16Err = $0041; {System Fail - memory manager error }
memMgr17Err = $0042; {System Fail - memory manager error }
memMgr18Err = $0043; {System Fail - memory manager error }
memMgr19Err = $0044; {System Fail - memory manager error }
memMgr20Err = $0045; {System Fail - memory manager error }
memMgr21Err = $0046; {System Fail - memory manager error }
memMgr22Err = $0047; {System Fail - memory manager error }
memMgr23Err = $0048; {System Fail - memory manager error }
memMgr24Err = $0049; {System Fail - memory manager error }
memMgr25Err = $004A; {System Fail - memory manager error }
memMgr26Err = $004B; {System Fail - memory manager error }
memMgr27Err = $004C; {System Fail - memory manager error }
memMgr28Err = $004D; {System Fail - memory manager error }
memMgr29Err = $004E; {System Fail - memory manager error }
memMgr30Err = $004F; {System Fail - memory manager error }
memMgr31Err = $0050; {System Fail - memory manager error }
memMgr32Err = $0051; {System Fail - memory manager error }
memMgr33Err = $0052; {System Fail - memory manager error }
memMgr34Err = $0053; {System Fail - memory manager error }
stupVolMntErr = $0100; {System Fail - can't mount system startup volume }
*** Toolset Errors *** *)
(* *** Reference Numbers ***
p1PrntModem = $0000; {Battery Ram Parameter Ref Number - }
p1LineLnth = $0001; {Battery Ram Parameter Ref Number - }
p1DelLine = $0002; {Battery Ram Parameter Ref Number - }
p1AddLine = $0003; {Battery Ram Parameter Ref Number - }
p1Echo = $0004; {Battery Ram Parameter Ref Number - }
p1Buffer = $0005; {Battery Ram Parameter Ref Number - }
p1Baud = $0006; {Battery Ram Parameter Ref Number - }
p1DtStpBits = $0007; {Battery Ram Parameter Ref Number - }
p1Parity = $0008; {Battery Ram Parameter Ref Number - }
p1DCDHndShk = $0009; {Battery Ram Parameter Ref Number - }
p1DSRHndShk = $000A; {Battery Ram Parameter Ref Number - }
p1XnfHndShk = $000B; {Battery Ram Parameter Ref Number - }
p2PrntModem = $000C; {Battery Ram Parameter Ref Number - }
p2LineLnth = $000D; {Battery Ram Parameter Ref Number - }
p2DelLine = $000E; {Battery Ram Parameter Ref Number - }
p2AddLine = $000F; {Battery Ram Parameter Ref Number - }
p2Echo = $0010; {Battery Ram Parameter Ref Number - }
p2Buffer = $0011; {Battery Ram Parameter Ref Number - }
p2Baud = $0012; {Battery Ram Parameter Ref Number - }
p2DtStpBits = $0013; {Battery Ram Parameter Ref Number - }
p2Parity = $0014; {Battery Ram Parameter Ref Number - }
p2DCDHndShk = $0015; {Battery Ram Parameter Ref Number - }
p2DSRHndShk = $0016; {Battery Ram Parameter Ref Number - }
p2XnfHndShk = $0017; {Battery Ram Parameter Ref Number - }
dspColMono = $0018; {Battery Ram Parameter Ref Number - }
dsp40or80 = $0019; {Battery Ram Parameter Ref Number - }
dspTxtColor = $001A; {Battery Ram Parameter Ref Number - }
dspBckColor = $001B; {Battery Ram Parameter Ref Number - }
dspBrdColor = $001C; {Battery Ram Parameter Ref Number - }
hrtz50or60 = $001D; {Battery Ram Parameter Ref Number - }
userVolume = $001E; {Battery Ram Parameter Ref Number - }
bellVolume = $001F; {Battery Ram Parameter Ref Number - }
sysSpeed = $0020; {Battery Ram Parameter Ref Number - }
slt1intExt = $0021; {Battery Ram Parameter Ref Number - }
slt2intExt = $0022; {Battery Ram Parameter Ref Number - }
slt3intExt = $0023; {Battery Ram Parameter Ref Number - }
slt4intExt = $0024; {Battery Ram Parameter Ref Number - }
slt5intExt = $0025; {Battery Ram Parameter Ref Number - }
slt6intExt = $0026; {Battery Ram Parameter Ref Number - }
slt7intExt = $0027; {Battery Ram Parameter Ref Number - }
startupSlt = $0028; {Battery Ram Parameter Ref Number - }
txtDspLang = $0029; {Battery Ram Parameter Ref Number - }
kybdLang = $002A; {Battery Ram Parameter Ref Number - }
kyBdBuffer = $002B; {Battery Ram Parameter Ref Number - }
kyBdRepSpd = $002C; {Battery Ram Parameter Ref Number - }
kyBdRepDel = $002D; {Battery Ram Parameter Ref Number - }
dblClkTime = $002E; {Battery Ram Parameter Ref Number - }
flashRate = $002F; {Battery Ram Parameter Ref Number - }
shftCpsLCas = $0030; {Battery Ram Parameter Ref Number - }
fstSpDelKey = $0031; {Battery Ram Parameter Ref Number - }
dualSpeed = $0032; {Battery Ram Parameter Ref Number - }
hiMouseRes = $0033; {Battery Ram Parameter Ref Number - }
dateFormat = $0034; {Battery Ram Parameter Ref Number - }
clockFormat = $0035; {Battery Ram Parameter Ref Number - }
rdMinRam = $0036; {Battery Ram Parameter Ref Number - }
rdMaxRam = $0037; {Battery Ram Parameter Ref Number - }
langCount = $0038; {Battery Ram Parameter Ref Number - }
lang1 = $0039; {Battery Ram Parameter Ref Number - }
lang2 = $003A; {Battery Ram Parameter Ref Number - }
lang3 = $003B; {Battery Ram Parameter Ref Number - }
lang4 = $003C; {Battery Ram Parameter Ref Number - }
lang5 = $003D; {Battery Ram Parameter Ref Number - }
lang6 = $003E; {Battery Ram Parameter Ref Number - }
lang7 = $003F; {Battery Ram Parameter Ref Number - }
lang8 = $0040; {Battery Ram Parameter Ref Number - }
layoutCount = $0041; {Battery Ram Parameter Ref Number - }
layout1 = $0042; {Battery Ram Parameter Ref Number - }
layout2 = $0043; {Battery Ram Parameter Ref Number - }
layout3 = $0044; {Battery Ram Parameter Ref Number - }
layout4 = $0045; {Battery Ram Parameter Ref Number - }
layout5 = $0046; {Battery Ram Parameter Ref Number - }
layout6 = $0047; {Battery Ram Parameter Ref Number - }
layout7 = $0048; {Battery Ram Parameter Ref Number - }
layout8 = $0049; {Battery Ram Parameter Ref Number - }
layout9 = $004A; {Battery Ram Parameter Ref Number - }
layout10 = $004B; {Battery Ram Parameter Ref Number - }
layout11 = $004C; {Battery Ram Parameter Ref Number - }
layout12 = $004D; {Battery Ram Parameter Ref Number - }
layout13 = $004E; {Battery Ram Parameter Ref Number - }
layout14 = $004F; {Battery Ram Parameter Ref Number - }
layout15 = $0050; {Battery Ram Parameter Ref Number - }
layout16 = $0051; {Battery Ram Parameter Ref Number - }
aTalkNodeNo = $0080; {Battery Ram Parameter Ref Number - }
irqIntFlag = $0000; {GetAddr Param Ref No - }
irqDataReg = $0001; {GetAddr Param Ref No - }
irqSerial1 = $0002; {GetAddr Param Ref No - }
irqSerial2 = $0003; {GetAddr Param Ref No - }
irqAplTlkHi = $0004; {GetAddr Param Ref No - }
tickCnt = $0005; {GetAddr Param Ref No - }
irqVolume = $0006; {GetAddr Param Ref No - }
irqActive = $0007; {GetAddr Param Ref No - }
irqSndData = $0008; {GetAddr Param Ref No - }
brkVar = $0009; {GetAddr Param Ref No - }
evMgrData = $000A; {GetAddr Param Ref No - }
mouseSlot = $000B; {GetAddr Param Ref No - }
mouseClamps = $000C; {GetAddr Param Ref No - }
absClamps = $000D; {GetAddr Param Ref No - }
sccIntFlag = $000E; {GetAddr Param Ref No - }
extVGCInt = $01; {Hardware Interrupt Status - Returned by GetIRQEnable }
scanLineInt = $02; {Hardware Interrupt Status - Returned by GetIRQEnable }
adbDataInt = $04; {Hardware Interrupt Status - Returned by GetIRQEnable }
ADTBDataInt = $04; {Hardware Interrupt Status - maintained for compatiblity
with old interfaces }
oneSecInt = $10; {Hardware Interrupt Status - Returned by GetIRQEnable }
quartSecInt = $20; {Hardware Interrupt Status - Returned by GetIRQEnable }
vbInt = $40; {Hardware Interrupt Status - Returned by GetIRQEnable }
kbdInt = $80; {Hardware Interrupt Status - Returned by GetIRQEnable }
kybdEnable = $0000; {Interrupt Ref Number - Parameter to IntSource }
kybdDisable = $0001; {Interrupt Ref Number - Parameter to IntSource }
vblEnable = $0002; {Interrupt Ref Number - Parameter to IntSource }
vblDisable = $0003; {Interrupt Ref Number - Parameter to IntSource }
qSecEnable = $0004; {Interrupt Ref Number - Parameter to IntSource }
qSecDisable = $0005; {Interrupt Ref Number - Parameter to IntSource }
oSecEnable = $0006; {Interrupt Ref Number - Parameter to IntSource }
oSecDisable = $0007; {Interrupt Ref Number - Parameter to IntSource }
adbEnable = $000A; {Interrupt Ref Number - Parameter to IntSource }
adbDisable = $000B; {Interrupt Ref Number - Parameter to IntSource }
scLnEnable = $000C; {Interrupt Ref Number - Parameter to IntSource }
scLnDisable = $000D; {Interrupt Ref Number - Parameter to IntSource }
exVCGEnable = $000E; {Interrupt Ref Number - Parameter to IntSource }
exVCGDisable = $000F; {Interrupt Ref Number - Parameter to IntSource }
mouseOff = $0000; {Mouse Mode Value - }
transparent = $0001; {Mouse Mode Value - }
transParnt = $0001; {Mouse Mode Value - (old name) }
moveIntrpt = $0003; {Mouse Mode Value - }
bttnIntrpt = $0005; {Mouse Mode Value - }
bttnOrMove = $0007; {Mouse Mode Value - }
mouseOffVI = $0008; {Mouse Mode Value - }
transParntVI = $0009; {Mouse Mode Value - (old name) }
transparentVI = $0009; {Mouse Mode Value - }
moveIntrptVI = $000B; {Mouse Mode Value - }
bttnIntrptVI = $000D; {Mouse Mode Value - }
bttnOrMoveVI = $000F; {Mouse Mode Value - }
toolLoc1 = $0000; {Vector Ref Number - }
toolLoc2 = $0001; {Vector Ref Number - }
usrTLoc1 = $0002; {Vector Ref Number - }
usrTLoc2 = $0003; {Vector Ref Number - }
intrptMgr = $0004; {Vector Ref Number - }
copMgr = $0005; {Vector Ref Number - }
abortMgr = $0006; {Vector Ref Number - }
U_sysFailMgr = $0007; {Vector Ref Number - }
aTalkIntHnd = $0008; {Vector Ref Number - }
sccIntHnd = $0009; {Vector Ref Number - }
scLnIntHnd = $000A; {Vector Ref Number - }
sndIntHnd = $000B; {Vector Ref Number - }
vblIntHnd = $000C; {Vector Ref Number - }
mouseIntHnd = $000D; {Vector Ref Number - }
qSecIntHnd = $000E; {Vector Ref Number - }
kybdIntHnd = $000F; {Vector Ref Number - }
adbRBIHnd = $0010; {Vector Ref Number - }
adbSRQHnd = $0011; {Vector Ref Number - }
deskAccHnd = $0012; {Vector Ref Number - }
flshBufHnd = $0013; {Vector Ref Number - }
kybdMicHnd = $0014; {Vector Ref Number - }
oneSecHnd = $0015; {Vector Ref Number - }
extVCGHnd = $0016; {Vector Ref Number - }
otherIntHnd = $0017; {Vector Ref Number - }
crsrUpdtHnd = $0018; {Vector Ref Number - }
incBsyFlag = $0019; {Vector Ref Number - }
decBsyFlag = $001A; {Vector Ref Number - }
bellVector = $001B; {Vector Ref Number - }
breakVector = $001C; {Vector Ref Number - }
traceVector = $001D; {Vector Ref Number - }
stepVector = $001E; {Vector Ref Number - }
ctlYVector = $0028; {Vector Ref Number - }
proDOSVctr = $002A; {Vector Ref Number - }
osVector = $002B; {Vector Ref Number - }
msgPtrVctr = $002C; {Vector Ref Number - }
*** Reference Numbers *** *)
TYPE
ClampRecHndl = ^ClampRecPtr;
ClampRecPtr = ^ClampRec;
ClampRec = RECORD
yMaxClamp : Integer;
yMinClamp : Integer;
xMaxClamp : Integer;
xMinClamp : Integer;
END;
FWRecHndl = ^FWRecPtr;
FWRecPtr = ^FWRec;
FWRec = RECORD
yRegExit : Integer;
xRegExit : Integer;
aRegExit : Integer;
status : Integer;
END;
MouseRecHndl = ^MouseRecPtr;
MouseRecPtr = ^MouseRec;
MouseRec = PACKED RECORD
mouseMode : Byte;
mouseStatus : Byte;
yPos : Integer;
xPos : Integer;
END;
InterruptStateRecHndl = ^InterruptStateRecPtr;
InterruptStateRecPtr = ^InterruptStateRec;
InterruptStateRec = PACKED RECORD
irq_A : Integer;
irq_X : Integer;
irq_Y : Integer;
irq_S : Integer;
irq_D : Integer;
irq_P : Byte;
irq_DB : Byte;
irq_e : Byte;
irq_K : Byte;
irq_PC : Integer;
irq_state : Byte;
irq_shadow : Integer;
irq_mslot : Byte;
END;
PROCEDURE MTBootInit ; Tool $03,$01;
PROCEDURE MTStartUp ; Tool $03,$02;
PROCEDURE MTShutDown ; Tool $03,$03;
FUNCTION MTVersion : Integer ; Tool $03,$04;
PROCEDURE MTReset ; Tool $03,$05;
FUNCTION MTStatus : Boolean ; Tool $03,$06;
PROCEDURE ClampMouse ( xMinClamp:Integer; xMaxClamp:Integer; yMinClamp:Integer;
yMaxClamp:Integer) ; Tool $03,$1C;
PROCEDURE ClearMouse ; Tool $03,$1B;
PROCEDURE ClrHeartBeat ; Tool $03,$14;
PROCEDURE DeleteID ( idTag:Integer) ; Tool $03,$21;
PROCEDURE DelHeartBeat ( taskPtr:Ptr) ; Tool $03,$13;
FUNCTION FWEntry ( aRegValue:Integer; xRegValue:Integer; yRegValue:Integer;
eModeEntryPt:Integer) : FWRec ; EXTERNAL ;
FUNCTION GetAbsClamp : ClampRec ; EXTERNAL ;
FUNCTION GetAddr ( refNum:Integer) : Ptr ; Tool $03,$16;
FUNCTION GetIRQEnable : Integer ; Tool $03,$29;
FUNCTION GetMouseClamp : ClampRec ; EXTERNAL ;
FUNCTION GetNewID ( idTag:Integer) : Integer ; Tool $03,$20;
FUNCTION GetTick : Longint ; Tool $03,$25;
FUNCTION GetVector ( vectorRefNum:Integer) : Ptr ; Tool $03,$11;
PROCEDURE HomeMouse ; Tool $03,$1A;
PROCEDURE InitMouse ( mouseSlot:Integer) ; Tool $03,$18;
PROCEDURE IntSource ( srcRefNum:Integer) ; Tool $03,$23;
FUNCTION Munger ( destPtr:Ptr; destLenPtr:IntPtr; targPtr:Ptr; targLen:Integer;
replPtr:Ptr; replLen:Integer; padPtr:Ptr) : Integer ; Tool $03,$28;
FUNCTION PackBytes (VAR srcBuffer:Ptr;VAR srcSize:Integer; dstBuffer:Ptr;
dstSize:Integer) : Integer ; Tool $03,$26;
PROCEDURE PosMouse ( xPos:Integer; yPos:Integer) ; Tool $03,$1E;
PROCEDURE ReadAsciiTime ( bufferPtr:Ptr) ; Tool $03,$0F;
FUNCTION ReadBParam ( paramRefNum:Integer) : Integer ; Tool $03,$0C;
PROCEDURE ReadBRam ( bufferPtr:Ptr) ; Tool $03,$0A;
FUNCTION ReadMouse : MouseRec ; EXTERNAL ;
FUNCTION ReadTimeHex : TimeRec ; EXTERNAL ;
FUNCTION ServeMouse : Integer ; Tool $03,$1F;
PROCEDURE SetAbsClamp ( xMinClamp:Integer; xMaxClamp:Integer;
yMinClamp:Integer; yMaxClamp:Integer) ; EXTERNAL ;
PROCEDURE SetHeartBeat ( taskPtr:Ptr) ; Tool $03,$12;
PROCEDURE SetMouse ( mouseMode:Integer) ; Tool $03,$19;
PROCEDURE SetVector ( vectorRefNum:Integer; vectorPtr:Ptr) ; Tool $03,$10;
PROCEDURE StatusID ( idTag:Integer) ; Tool $03,$22;
PROCEDURE SysBeep ; Tool $03,$2C;
PROCEDURE SysFailMgr ( errorCode:Integer; str:Str255) ; Tool $03,$15;
FUNCTION UnPackBytes ( srcBuffer:Ptr; srcSize:Integer;VAR dstBuffer:Ptr;VAR
dstSize:Integer) : Integer ; Tool $03,$27;
PROCEDURE WriteBParam ( theData:Integer; paramRefNum:Integer) ; Tool $03,$0B;
PROCEDURE WriteBRam ( bufferPtr:Ptr) ; Tool $03,$09;
PROCEDURE WriteTimeHex ( month:Byte; day:Byte; curYear:Byte; hour:Byte;
minute:Byte; second:Byte) ; EXTERNAL ;
PROCEDURE AddToQueue ( newEntryPtr:Ptr; headerPtr:Ptr) ; Tool $03,$2E;
PROCEDURE DeleteFromQueue ( entryPtr:Ptr; headerPtr:Ptr) ; Tool $03,$2F;
PROCEDURE SetInterruptState ( iStateRec:InterruptStateRec;
bytesDesired:Integer) ; Tool $03,$30;
PROCEDURE GetInterruptState (VAR iStateRec:InterruptStateRec;
bytesDesired:Integer) ; Tool $03,$31;
FUNCTION GetIntStateRecSize : Integer ; Tool $03,$32;
FUNCTION ReadMouse2 : MouseRec ; EXTERNAL ;
FUNCTION GetCodeResConverter : ProcPtr ; Tool $03,$34;
FUNCTION GetRomResource : Ptr ; Tool $03,$35;
IMPLEMENTATION
END.

95
pascal/noteseq.p Executable file
View File

@ -0,0 +1,95 @@
{********************************************
; File: NoteSeq.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT NOTESEQ;
INTERFACE
USES TYPES;
CONST
pitchBend = $0; {Command - }
tempo = $00000001; {Command - }
turnNotesOff = $00000002; {Command - }
jump = $00000003; {Command - }
setVibratoDepth = $00000004; {Command - }
programChange = $00000005; {Command - }
setRegister = $00000006; {Command - }
ifGo = $00000007; {Command - }
incRegister = $00000008; {Command - }
decRegister = $00000009; {Command - }
midiNoteOff = $0000000A; {Command - }
midiNoteOn = $0000000B; {Command - }
midiPolyKey = $0000000C; {Command - }
midiCtlChange = $0000000D; {Command - }
midiProgChange = $0000000E; {Command - }
midiChnlPress = $0000000F; {Command - }
midiPitchBend = $00000010; {Command - }
midiSelChnlMode = $00000011; {Command - }
midiSysExclusive = $00000012; {Command - }
midiSysCommon = $00000013; {Command - }
midiSysRealTime = $00000014; {Command - }
midiSetSysExl = $00000015; {Command - }
commandMask = $0000007F; {Command - }
volumeMask = $0000007F; {Command - }
chord = $00000080; {Command - }
val1Mask = $00007F00; {Command - }
toneMask = $00007F00; {Command - }
noteMask = $00008000; {Command - }
lByte = $00FF0000; {Command - meaning depends on midi command }
durationMask = $07FF0000; {Command - }
trackMask = $78000000; {Command - }
delayMask = $80000000; {Command - }
hByte = $FF000000; {Command - }
(* *** Toolset Errors ***
noRoomMidiErr = $1A00; {error - }
noCommandErr = $1A01; {error - can't understand the current SeqItem }
noRoomErr = $1A02; {error - sequence is more than twelve levels deep }
startedErr = $1A03; {error - Note Sequencer is already started }
noNoteErr = $1A04; {error - can't find the note to be turned off by the current
SeqItem }
noStartErr = $1A05; {error - Note Sequencer not started yet }
instBndsErr = $1A06; {error - Instrument number out of Instrument boundary
range }
nsWrongVer = $1A07; {error - incompatible versions of NoteSequencer and
NoteSynthesizer }
*** Toolset Errors *** *)
TYPE
LocRecHndl = ^LocRecPtr;
LocRecPtr = ^LocRec;
LocRec = RECORD
curPhraseItem : Integer;
curPattItem : Integer;
curLevel : Integer;
END;
PROCEDURE SeqBootInit ; Tool $1A,$01;
PROCEDURE SeqStartUp ( dPageAddr:Integer; mode:Integer; updateRate:Integer;
increment:Integer) ; Tool $1A,$02;
PROCEDURE SeqShutDown ; Tool $1A,$03;
FUNCTION SeqVersion : Integer ; Tool $1A,$04;
PROCEDURE SeqReset ; Tool $1A,$05;
FUNCTION SeqStatus : Boolean ; Tool $1A,$06;
PROCEDURE SeqAllNotesOff ; Tool $1A,$0D;
FUNCTION ClearIncr : Integer ; Tool $1A,$0A;
FUNCTION GetLoc : LocRec ; EXTERNAL ;
FUNCTION GetTimer : Integer ; Tool $1A,$0B;
PROCEDURE SetIncr ( increment:Integer) ; Tool $1A,$09;
PROCEDURE SetInstTable ( instTable:Handle) ; Tool $1A,$12;
PROCEDURE SetTrkInfo ( priority:Integer; instIndex:Integer; trackNum:Integer)
; Tool $1A,$0E;
PROCEDURE StartInts ; Tool $1A,$13;
PROCEDURE StartSeq ( errHndlrRoutine:VoidProcPtr; compRoutine:VoidProcPtr;
sequence:Handle) ; Tool $1A,$0F;
PROCEDURE StepSeq ; Tool $1A,$10;
PROCEDURE StopInts ; Tool $1A,$14;
PROCEDURE StopSeq ( next:Integer) ; Tool $1A,$11;
PROCEDURE StartSeqRel ( errHandlerPtr:ProcPtr; compRoutine:ProcPtr;
sequence:Handle) ; Tool $1A,$15;
IMPLEMENTATION
END.

87
pascal/notesyn.p Executable file
View File

@ -0,0 +1,87 @@
{********************************************
; File: NoteSyn.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT NOTESYN;
INTERFACE
USES TYPES;
(* *** Toolset Errors ***
CONST
nsAlreadyInit = $1901; {error - Note Syn already initialized }
nsSndNotInit = $1902; {error - Sound Tools not initialized }
nsNotAvail = $1921; {error - generator not available }
nsBadGenNum = $1922; {error - bad generator number }
nsNotInit = $1923; {error - Note Syn not initialized }
nsGenAlreadyOn = $1924; {error - generator already on }
soundWrongVer = $1925; {error - incompatible versions of Sound and NoteSyn }
*** Toolset Errors *** *)
TYPE
EnvelopeHndl = ^EnvelopePtr;
EnvelopePtr = ^Envelope;
Envelope = PACKED RECORD
st1BkPt : Byte;
st1Increment : Integer;
st2BkPt : Byte;
st2Increment : Integer;
st3BkPt : Byte;
st3Increment : Integer;
st4BkPt : Byte;
st4Increment : Integer;
st5BkPt : Byte;
st5Increment : Integer;
st6BkPt : Byte;
st6Increment : Integer;
st7BkPt : Byte;
st7Increment : Integer;
st8BkPt : Byte;
st8Increment : Integer;
END;
WaveFormHndl = ^WaveFormPtr;
WaveFormPtr = ^WaveForm;
WaveForm = PACKED RECORD
wfTopKey : Byte;
wfWaveAddress : Byte;
wfWaveSize : Byte;
wfDocMode : Byte;
wfRelPitch : Integer;
END;
InstrumentHndl = ^InstrumentPtr;
InstrumentPtr = ^Instrument;
Instrument = PACKED RECORD
theEnvelope : Envelope;
releaseSegment : Byte;
priorityIncrement : Byte;
pitchBendRange : Byte;
vibratoDepth : Byte;
vibratoSpeed : Byte;
inSpare : Byte;
aWaveCount : Byte;
bWaveCount : Byte;
aWaveList : ARRAY[1..1] OF WaveForm;
bWaveList : ARRAY[1..1] OF WaveForm;
END;
PROCEDURE NSBootInit ; Tool $19,$01;
PROCEDURE NSStartUp ( updateRate:Integer; userUpdateRtnPtr:Ptr) ; Tool
$19,$02;
PROCEDURE NSShutDown ; Tool $19,$03;
FUNCTION NSVersion : Integer ; Tool $19,$04;
PROCEDURE NSReset ; Tool $19,$05;
FUNCTION NSStatus : Boolean ; Tool $19,$06;
PROCEDURE AllNotesOff ; Tool $19,$0D;
FUNCTION AllocGen ( requestPriority:Integer) : Integer ; Tool $19,$09;
PROCEDURE DeallocGen ( genNumber:Integer) ; Tool $19,$0A;
PROCEDURE NoteOff ( genNumber:Integer; semitone:Integer) ; Tool $19,$0C;
PROCEDURE NoteOn ( genNumber:Integer; semitone:Integer; volume:Integer;
instrumentPtr:Ptr) ; Tool $19,$0B;
PROCEDURE NSSetUpdateRate ( updateRate:Integer) ; Tool $19,$0E;
FUNCTION NSSetUserUpdateRtn ( updateRtn:VoidProcPtr) : VoidProcPtr ; Tool
$19,$0F;
IMPLEMENTATION
END.

165
pascal/print.p Executable file
View File

@ -0,0 +1,165 @@
{********************************************
; File: Print.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT PRINT;
INTERFACE
USES TYPES,QUICKDRAW,EVENTS,CONTROLS,WINDOWS,LINEEDIT,DIALOGS;
CONST
(* *** Toolset Errors ***
pntrConFailed = $1308; {error - connection to the printer failed }
memFullErr = $FF80; {errors - }
ioAbort = $FFE5; {errors - }
prAbort = $0080; {errors - }
missingDriver = $1301; {errors - specified driver not in system/drivers }
portNotOn = $1302; {errors - specified port not selected in ctl panel }
noPrintRecord = $1303; {errors - no print record was given }
badLaserPrep = $1304; {errors - laser prep in laser writer incompatible }
badLPFile = $1305; {errors - laser prep in system/drivers incompatible }
papConnNotOpen = $1306; {errors - cannot connect to laser writer }
papReadWriteErr = $1307; {errors - apple talk PAPRead or PAPWrite error }
ptrConnFailed = $1308; {errors - cannot establish connection with imagewriter }
badLoadParam = $1309; {errors - parameter for load/unload is invalid }
callNotSupported = $130A; {errors - toolcall made is not supported by this
version }
startUpAlreadyMade = $1321; {errors - low level startup already made }
invalidCtlVal = $1322; {errors - invalid control value had been spec'd }
*** Toolset Errors *** *)
kReset = $0001; {LLDControl - Printer control value - reset printer }
kFormFeed = $0002; {LLDControl - Printer control value - form feed }
kLineFeed = $0003; {LLDControl - Printer control value - line feed }
bothDrivers = $0; {whichDriver - input to PMLoadDriver and PMUnloadDriver }
printerDriver = $0001; {whichDriver - input to PMLoadDriver and PMUnloadDriver
}
portDriver = $0002; {whichDriver - input to PMLoadDriver and PMUnloadDriver }
prPortrait = $0000; { - }
prLandscape = $0001; { - }
prImageWriter = $0001; { - }
prImageWriterLQ = $0002; { - }
prLaserWriter = $0003; { - }
prEpson = $0004; { - }
prBlackWhite = $0001; { - }
prColor = $0002; { - }
bDraftLoop = $0000; { - }
bSpoolLoop = $0080; { - }
TYPE
PrPrinterSpecRec = RECORD
prPrinterType : Integer;
prCharacteristics : Integer;
END;
PrInfoRecHndl = ^PrInfoRecPtr;
PrInfoRecPtr = ^PrInfoRec;
PrInfoRec = RECORD
iDev : Integer; { reserved for internal use }
iVRes : Integer; { vertical resolution of printer }
iHRes : Integer; { horizontal resolution of printer }
rPage : Rect; { defining page rectangle }
END;
PrJobRecPtr = ^PrJobRec;
PrJobRec = PACKED RECORD
iFstPage : Integer; { first page to print }
iLstPage : Integer; { last page to print }
iCopies : Integer; { number of copies }
bJDocLoop : Byte; { printing method }
fFromUser : Byte; { used internally }
pIdleProc : WordProcPtr; { background procedure }
pFileName : Ptr; { spool file name }
iFileVol : Integer; { spool file volume reference number }
bFileVers : Byte; { spool file version number }
bJobX : Byte; { used internally }
END;
PrStyleRecHndl = ^PrStyleRecPtr;
PrStyleRecPtr = ^PrStyleRec;
PrStyleRec = RECORD
wDev : Integer; { output quality information }
internA : ARRAY[1..3] OF Integer; { for internal use }
feed : Integer; { paper feed type }
paperType : Integer; { paper type }
crWidth : Integer; { carriage Width for image writer or vertical sizing for
lazer writer }
reduction : Integer; { % reduction, laser writer only }
internB : Integer; { for internal use }
END;
PrRecHndl = ^PrRecPtr;
PrRecPtr = ^PrRec;
PrRec = RECORD
prVersion : Integer; { print manager version }
prInfo : PrInfoRec; { printer infomation subrecord }
rPaper : Rect; { Defining paper rectangle }
prStl : PrStyleRec; { style subrecord }
prInfoPT : PACKED ARRAY[1..14] OF Byte; { reserved for internal use }
prXInfo : PACKED ARRAY[1..24] OF Byte; { reserved for internal use }
prJob : PrJobRec; { job subrecord }
printX : PACKED ARRAY[1..38] OF Byte; { reserved for future use }
iReserved : Integer; { reserved for internal use }
END;
PrStatusRecHndl = ^PrStatusRecPtr;
PrStatusRecPtr = ^PrStatusRec;
PrStatusRec = RECORD
iTotPages : Integer; { number of pages in spool file }
iCurPage : Integer; { page being printed }
iTotCopies : Integer; { number of copies requested }
iCurCopy : Integer; { copy being printed }
iTotBands : Integer; { reserved for internal use }
iCurBand : Integer; { reserved for internal use }
fPgDirty : Integer; { TRUE if started printing page }
fImaging : Integer; { reserved for internal use }
hPrint : PrRecHndl; { handle of print record }
pPrPort : GrafPortPtr; { pointer to grafport being use for printing }
hPic : Longint; { reserved for internal use }
END;
PROCEDURE PMBootInit ; Tool $13,$01;
PROCEDURE PMStartUp ( userID:Integer; dPageAddr:Integer) ; Tool $13,$02;
PROCEDURE PMShutDown ; Tool $13,$03;
FUNCTION PMVersion : Integer ; Tool $13,$04;
PROCEDURE PMReset ; Tool $13,$05;
FUNCTION PMStatus : Boolean ; Tool $13,$06;
PROCEDURE LLDBitMap ( bitMapPtr:Ptr; rectPtr:Rect; userID:Integer) ; Tool
$13,$1C;
PROCEDURE LLDControl ( printerControlValue:Integer) ; Tool $13,$1B;
PROCEDURE LLDShutDown ( userID:Integer) ; Tool $13,$1A;
PROCEDURE LLDStartUp ( dPageAddr:Integer; userID:Integer) ; Tool $13,$19;
PROCEDURE LLDText ( textPtr:Ptr; textLength:Integer; userID:Integer) ; Tool
$13,$1D;
PROCEDURE PMLoadDriver ( whichDriver:Integer) ; Tool $13,$35;
PROCEDURE PMUnloadDriver ( whichDriver:Integer) ; Tool $13,$34;
FUNCTION PrChoosePrinter : Boolean ; Tool $13,$16;
FUNCTION PrChooser : Boolean ; Tool $13,$16;
PROCEDURE PrCloseDoc ( printGrafPortPtr:GrafPortPtr) ; Tool $13,$0F;
PROCEDURE PrClosePage ( printGrafPortPtr:GrafPortPtr) ; Tool $13,$11;
PROCEDURE PrDefault ( printRecordHandle:PrRecHndl) ; Tool $13,$09;
FUNCTION PrDriverVer : Integer ; Tool $13,$23;
FUNCTION PrError : Integer ; Tool $13,$14;
FUNCTION PrJobDialog ( printRecordHandle:PrRecHndl) : Boolean ; Tool $13,$0C;
FUNCTION PrOpenDoc ( printRecordHandle:PrRecHndl; printGrafPortPtr:GrafPortPtr)
: GrafPortPtr ; Tool $13,$0E;
PROCEDURE PrOpenPage ( printGrafPortPtr:GrafPortPtr; pageFramePtr:RectPtr) ;
Tool $13,$10;
PROCEDURE PrPicFile ( printRecordHandle:PrRecHndl;
printGrafPortPtr:GrafPortPtr; statusRecPtr:PrStatusRecPtr) ; Tool $13,$12;
PROCEDURE PrPixelMap ( srcLocPtr:LocInfoPtr; srcRectPtr:Rect;
colorFlag:Integer) ; Tool $13,$0D;
FUNCTION PrPortVer : Integer ; Tool $13,$24;
PROCEDURE PrSetError ( errorNumber:Integer) ; Tool $13,$15;
FUNCTION PrStlDialog ( printRecordHandle:PrRecHndl) : Boolean ; Tool $13,$0B;
FUNCTION PrValidate ( printRecordHandle:PrRecHndl) : Boolean ; Tool $13,$0A;
PROCEDURE PrSetDocName ( DocNamePtr:StringPtr) ; Tool $13,$37;
FUNCTION PrGetDocName : StringPtr ; Tool $13,$36;
FUNCTION PrGetPgOrientation ( prRecordHandle:PrRecHndl) : Integer ; Tool
$13,$38;
FUNCTION PrGetPrinterSpecs : PrPrinterSpecRec ; Tool $13,$18;
PROCEDURE PrGetZoneName (VAR ZoneNamePtr:Str255) ; Tool $13,$25;
PROCEDURE PrGetPrinterDvrName (VAR DvrNamePtr:Str255) ; Tool $13,$28;
PROCEDURE PrGetPortDvrName (VAR DvrNamePtr:Str255) ; Tool $13,$29;
PROCEDURE PrGetUserName (VAR UserNamePtr:Str255) ; Tool $13,$2A;
PROCEDURE PrGetNetworkName (VAR NetworkNamePtr:Str255) ; Tool $13,$2B;
IMPLEMENTATION
END.

211
pascal/prodos16.p Normal file
View File

@ -0,0 +1,211 @@
FileAccess: mask Word {
7: destroyEnable
6: renameEnable
5: backupNeeded
1: writeEnable
0: readEnable
}
FileDate: mask Word {
15-9: year
8-5: month
4-0: day
}
FileTime: mask Word {
12-8: hour
5-0: minute
}
StorageType: enum Word {
inactive: $0
seedling: $1
sapling: $2
tree: $3
pascal: $4
directory: $d
}
CREATE_PB: record {
pathname: ^String // 00
access: FileAccess // 04
file_type: Word // 06
aux_type: Long // 08
storage_type: StorageType // 0c
create_date: FileDate // 0e
create_time: FileTime // 10
}
DESTROY_PB: record {
pathname: ^String // 00
}
CHANGE_PATH_PB: record {
pathname: ^String // 00
new_pathname: ^String // 04
}
SET_FILE_INFO_PB: record {
pathname: ^String // 00
access: FileAccess // 04
file_type: Word // 06
aux_type: Long // 08
unused: Word // 0c
create_date: FileDate // 0e
create_time: FileTime // 10
mod_date: FileDate // 12
mod_time: FileTime // 14
}
GET_FILE_INFO_PB: record {
pathname: ^String // 00
access: FileAccess // 04
file_type: Word // 06
aux_type: Long // 08
storage_type: StorageType // 0c
create_date: FileDate // 0e
create_time: FileTime // 10
mod_date: FileDate // 12
mod_time: FileTime // 14
blocks_used: Long // 16
}
VOLUME_PB: record {
dev_name: ^String // 00
vol_name: ^String // 04
total_blocks: Long // 08
free_blocks: Long // 0c
file_sys_id: Word // 10
}
SET_PREFIX_PB: record {
prefix_num: Word // 00
prefix: ^String // 02
}
GET_PREFIX_PB: record {
prefix_num: Word // 00
prefix: ^String // 02
}
CLEAR_BACKUP_BIT_PB: record {
pathname: ^String // 00
}
OPEN_PB: record {
ref_num: Word // 00
pathname: ^String // 02
io_buffer: Ptr // 06
}
NEWLINE_PB: record {
ref_num: Word // 00
enable_Mask: Word // 02
newline_char: Word // 04
}
READ_PB: record {
ref_num: Word // 00
data_buffer: Ptr // 02
request_count: Long // 06
transfer_count: Long // 0a
}
WRITE_PB: record {
ref_num: Word // 00
data_buffer: Ptr // 02
request_count: Long // 06
transfer_count: Long // 0a
}
CLOSE_PB: record {
ref_num: Word // 00
}
FLUSH_PB: record {
ref_num: Word // 00
}
SET_MARK_PB: record {
ref_num: Word // 00
position: Long // 02
}
GET_MARK_PB: record {
ref_num: Word // 00
position: Long // 02
}
SET_EOF_PB: record {
ref_num: Word // 00
eof: Long // 02
}
GET_EOF_PB: record {
ref_num: Word // 00
eof: Long // 02
}
SET_LEVEL_PB: record {
level: Word // 00
}
GET_LEVEL_PB: record {
level: Word // 00
}
GET_DEV_NUM_PB: record {
dev_name: ^String // 00
dev_num: Word // 04
}
GET_LAST_DEV_PB: record {
dev_num: Word // 00
}
READ_BLOCK_PB: record {
dev_num: Word // 00
data_buffer: Ptr // 02
block_num: Long // 06
}
WRITE_BLOCK_PB: record {
dev_num: Word // 00
data_buffer: Ptr // 02
block_num: Long // 06
}
FORMAT_PB: record {
dev_name: ^String // 00
vol_name: ^String // 04
file_sys_id: Word // 08
}
GET_NAME_PB: record {
data_buffer: ^String // 00
}
GET_BOOT_VOL_PB: record {
data_buffer: ^String // 00
}
QUIT_PB: record {
pathname: ^String // 00
flags: mask Word { // 04
15: returnUserID
14: restartable
}
}
GET_VERSION_PB: record {
version: Word // 00
}
ALLOC_INTERRUPT_PB: record {
int_num: Word // 00
int_code: Ptr // 02
}
DEALLOC_INTERRUPT_PB: record {
int_num: Word // 00
}

119
pascal/qdaux.p Executable file
View File

@ -0,0 +1,119 @@
{********************************************
; File: QDAux.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT QDAUX;
INTERFACE
USES TYPES,QUICKDRAW;
CONST
(* *** Private Constants ***
frameVerb = $00; {PicInfo - PRIVATE - for reference only }
picNop = $00; {PicInfo - PRIVATE - for reference only }
drawCharVerb = $00; {PicInfo - PRIVATE - for reference only }
paintVerb = $01; {PicInfo - PRIVATE - for reference only }
picClipRgn = $01; {PicInfo - PRIVATE - for reference only }
drawTextVerb = $01; {PicInfo - PRIVATE - for reference only }
eraseVerb = $02; {PicInfo - PRIVATE - for reference only }
picBkPat = $02; {PicInfo - PRIVATE - for reference only }
drawCStrVerb = $02; {PicInfo - PRIVATE - for reference only }
invertVerb = $03; {PicInfo - PRIVATE - for reference only }
picTxFont = $03; {PicInfo - PRIVATE - for reference only }
fillVerb = $04; {PicInfo - PRIVATE - for reference only }
picTxFace = $04; {PicInfo - PRIVATE - for reference only }
picTxMode = $05; {PicInfo - PRIVATE - for reference only }
picSpExtra = $06; {PicInfo - PRIVATE - for reference only }
picPnSize = $07; {PicInfo - PRIVATE - for reference only }
picPnMode = $08; {PicInfo - PRIVATE - for reference only }
picPnPat = $09; {PicInfo - PRIVATE - for reference only }
picThePat = $0A; {PicInfo - PRIVATE - for reference only }
picOvSize = $0B; {PicInfo - PRIVATE - for reference only }
picOrigin = $0C; {PicInfo - PRIVATE - for reference only }
picTxSize = $0D; {PicInfo - PRIVATE - for reference only }
picFGColor = $0E; {PicInfo - PRIVATE - for reference only }
picBGColor = $0F; {PicInfo - PRIVATE - for reference only }
picTxRatio = $10; {PicInfo - PRIVATE - for reference only }
picVersion = $11; {PicInfo - PRIVATE - for reference only }
lineNoun = $20; {PicInfo - PRIVATE - for reference only }
picLine = $20; {PicInfo - PRIVATE - for reference only }
picLineFrom = $21; {PicInfo - PRIVATE - for reference only }
picShortL = $22; {PicInfo - PRIVATE - for reference only }
picShortLFrom = $23; {PicInfo - PRIVATE - for reference only }
picLongText = $28; {PicInfo - PRIVATE - for reference only }
picDHText = $29; {PicInfo - PRIVATE - for reference only }
picDVText = $2A; {PicInfo - PRIVATE - for reference only }
picDVDHText = $2B; {PicInfo - PRIVATE - for reference only }
rectNoun = $30; {PicInfo - PRIVATE - for reference only }
rRectNoun = $40; {PicInfo - PRIVATE - for reference only }
ovalNoun = $50; {PicInfo - PRIVATE - for reference only }
arcNoun = $60; {PicInfo - PRIVATE - for reference only }
polyNoun = $70; {PicInfo - PRIVATE - for reference only }
rgnNoun = $80; {PicInfo - PRIVATE - for reference only }
mapNoun = $90; {PicInfo - PRIVATE - for reference only }
picBitsRect = $90; {PicInfo - PRIVATE - for reference only }
picBitsRgn = $91; {PicInfo - PRIVATE - for reference only }
picPBitsRect = $98; {PicInfo - PRIVATE - for reference only }
picPBitsRgn = $99; {PicInfo - PRIVATE - for reference only }
picShortComment = $A0; {PicInfo - PRIVATE - for reference only }
picLongComment = $A1; {PicInfo - PRIVATE - for reference only }
picEnd = $FF; {PicInfo - PRIVATE - for reference only }
*** Private Constants *** *)
resMode640PMask = $00; {SeedFill/CalcMask - }
resMode640DMask = $01; {SeedFill/CalcMask - }
resMode320Mask = $02; {SeedFill/CalcMask - }
destModeCopyMask = $0000; {SeedFill/CalcMask - }
destModeLeaveMask = $1000; {SeedFill/CalcMask - }
destModeOnesMask = $2000; {SeedFill/CalcMask - }
destModeZerosMask = $3000; {SeedFill/CalcMask - }
destModeError = $1212; {Error - }
TYPE
QDIconRecordHndl = ^QDIconRecordPtr;
QDIconRecordPtr = ^QDIconRecord;
QDIconRecord = RECORD
iconType : Integer;
iconSize : Integer;
iconHeight : Integer;
iconWidth : Integer;
iconImage : PACKED ARRAY[1..1] OF Byte;
iconMask : PACKED ARRAY[1..1] OF Byte;
END;
PicHndl = ^PicPtr;
PicPtr = ^Picture;
Picture = RECORD
picSCB : Integer;
picFrame : Rect; { Followed by picture opcodes }
END;
PROCEDURE QDAuxBootInit ; Tool $12,$01;
PROCEDURE QDAuxStartUp ; Tool $12,$02;
PROCEDURE QDAuxShutDown ; Tool $12,$03;
FUNCTION QDAuxVersion : Integer ; Tool $12,$04;
PROCEDURE QDAuxReset ; Tool $12,$05;
FUNCTION QDAuxStatus : Boolean ; Tool $12,$06;
PROCEDURE CopyPixels ( srcLocPtr:LocInfo; destLocPtr:LocInfo; srcRect:Rect;
destRect:Rect; xferMode:Integer; makeRgn:RgnHandle) ; Tool $12,$09;
PROCEDURE DrawIcon ( iconPtr:QDIconRecord; displayMode:Integer; xPos:Integer;
yPos:Integer) ; Tool $12,$0B;
PROCEDURE SpecialRect ( rectPtr:Rect; frameColor:Integer; fillColor:Integer) ;
Tool $12,$0C;
PROCEDURE WaitCursor ; Tool $12,$0A;
PROCEDURE SeedFill ( srcLocInfoPtr:LocInfo; srcRect:Rect;
dstLocInfoPtr:LocInfo; dstRect:Rect; seedH:Integer; seedV:Integer;
resMode:Integer; U__patternPtr:PatternPtr; leakTblPtr:Ptr) ; Tool $12,$0D;
PROCEDURE CalcMask ( srcLocInfoPtr:LocInfo; srcRect:Rect;
dstLocInfoPtr:LocInfo; dstRect:Rect; resMode:Integer; U__patternPtr:PatternPtr;
leakTblPtr:Ptr) ; Tool $12,$0E;
PROCEDURE PicComment ( kind:Integer; dataSize:Integer; dataHandle:Handle) ;
Tool $04,$B8;
PROCEDURE ClosePicture ; Tool $04,$B9;
PROCEDURE DrawPicture ( picHandle:PicHndl; destRect:Rect) ; Tool $04,$BA;
PROCEDURE KillPicture ( pichandle:PicHndl) ; Tool $04,$BB;
FUNCTION OpenPicture ( picFrame:Rect) : PicHndl ; Tool $04,$B7;
IMPLEMENTATION
END.

510
pascal/quickdraw.p Executable file
View File

@ -0,0 +1,510 @@
{********************************************
; File: Quickdraw.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT QUICKDRAW;
INTERFACE
USES TYPES;
CONST
(* *** Toolset Errors ***
alreadyInitialized = $0401; {error - Quickdraw already initialized }
cannotReset = $0402; {error - never used }
notInitialized = $0403; {error - Quickdraw not initialized }
screenReserved = $0410; {error - screen reserved }
badRect = $0411; {error - bad rectangle }
notEqualChunkiness = $0420; {error - Chunkiness is not equal }
rgnAlreadyOpen = $0430; {error - region is already open }
rgnNotOpen = $0431; {error - region is not open }
rgnScanOverflow = $0432; {error - region scan overflow }
rgnFull = $0433; {error - region is full }
polyAlreadyOpen = $0440; {error - poly is already open }
polyNotOpen = $0441; {error - poly is not open }
polyTooBig = $0442; {error - poly is too big }
badTableNum = $0450; {error - bad table number }
badColorNum = $0451; {error - bad color number }
badScanLine = $0452; {error - bad scan line }
notImplemented = $04FF; {error - not implemented }
*** Toolset Errors *** *)
tsNumber = $04; { - }
U_colorTable = $0F; {AnSCBByte - Mask for SCB color table }
scbReserved = $10; {AnSCBByte - Mask for SCB reserved bit }
scbFill = $20; {AnSCBByte - Mask for SCB fill bit }
scbInterrupt = $40; {AnSCBByte - Mask for SCB interrupt bit }
scbColorMode = $80; {AnSCBByte - Mask for SCB color mode bit }
table320 = $32; {ColorData - (val=size) }
table640 = $32; {ColorData - (val=size) }
blueMask = $000F; {ColorValue - Mask for Blue nibble }
greenMask = $00F0; {ColorValue - Mask for green nibble }
redMask = $0F00; {ColorValue - Mask for red nibble }
widMaxSize = $0001; {FontFlags - }
zeroSize = $0002; {FontFlags - }
maskSize = $08; {GrafPort - Mask Size (val=size) }
locSize = $10; {GrafPort - Loc Size (val=size) }
patsize = $20; {GrafPort - Pattern Size (val=size) }
pnStateSize = $32; {GrafPort - Pen State Size (Val=size) }
portSize = $AA; {GrafPort - Size of GrafPort }
black = $000; {MasterColors - These work in 320 and 640 mode }
blue = $00F; {MasterColors - These work in 320 and 640 mode }
darkGreen320 = $080; {MasterColors - These work in 320 mode }
green320 = $0E0; {MasterColors - These work in 320 mode }
green640 = $0F0; {MasterColors - These work in 640 mode }
lightBlue320 = $4DF; {MasterColors - These work in 320 mode }
purple320 = $72C; {MasterColors - These work in 320 mode }
darkGray320 = $777; {MasterColors - These work in 320 mode }
periwinkleBlue320 = $78F; {MasterColors - These work in 320 mode }
brown320 = $841; {MasterColors - These work in 320 mode }
lightGray320 = $0CCC; {MasterColors - These work in 320 mode }
red320 = $0D00; {MasterColors - These work in 320 mode }
lilac320 = $0DAF; {MasterColors - These work in 320 mode }
red640 = $0F00; {MasterColors - These work in 640 mode }
orange320 = $0F70; {MasterColors - These work in 320 mode }
flesh320 = $0FA9; {MasterColors - These work in 320 mode }
yellow = $0FF0; {MasterColors - These work in 320 and 640 mode }
white = $0FFF; {MasterColors - These work in 320 and 640 mode }
modeCopy = $0000; {PenModeDATA - }
modeOR = $0001; {PenModeDATA - }
modeXOR = $0002; {PenModeDATA - }
modeBIC = $0003; {PenModeDATA - }
modeForeCopy = $0004; {PenModeDATA - }
modeForeOR = $0005; {PenModeDATA - }
modeForeXOR = $0006; {PenModeDATA - }
modeForeBIC = $0007; {PenModeDATA - }
modeNOT = $8000; {PenModeDATA - }
notCopy = $8000; {PenModeDATA - }
notOR = $8001; {PenModeDATA - }
notXOR = $8002; {PenModeDATA - }
notBIC = $8003; {PenModeDATA - }
notForeCOPY = $8004; {PenModeDATA - }
notForeOR = $8005; {PenModeDATA - }
notForeXOR = $8006; {PenModeDATA - }
notForeBIC = $8007; {PenModeDATA - }
mode320 = $0000; {QDStartup - Argument to QDStartup }
mode640 = $0080; {QDStartup - Argument to QDStartup }
plainMask = $0000; {TextStyle - Mask for plain text bit }
boldMask = $0001; {TextStyle - Mask for bold bit }
italicMask = $0002; {TextStyle - Mask for italic bit }
underlineMask = $0004; {TextStyle - Mask for underline bit }
outlineMask = $0008; {TextStyle - Mask for outline bit }
shadowMask = $0010; {TextStyle - Mask for shadow bit }
TYPE
TextStyle = Integer ;
ColorValue = Integer ;
AnSCBByte = Byte ;
PatternPtr = ^Pattern;
Pattern = PACKED ARRAY[1..32] of Byte ;
Mask = PACKED ARRAY[1..8] OF Byte;
CursorHndl = ^CursorPtr;
CursorPtr = ^Cursor;
Cursor = RECORD
cursorHeight : Integer; { size in bytes }
cursorWidth : Integer; { enclosing rectangle }
cursorData : ARRAY[1..1,1..1] OF Integer;
cursorMask : ARRAY[1..1,1..1] OF Integer;
cursorHotSpot : Point;
END;
RgnHandle = ^RgnPtr;
RgnPtr = ^Region;
Region = RECORD
rgnSize : Integer; { size in bytes }
rgnBBox : Rect; { enclosing rectangle }
END;
BufDimRecHndl = ^BufDimRecPtr;
BufDimRecPtr = ^BufDimRec;
BufDimRec = RECORD
maxWidth : Integer;
textBufHeight : Integer;
textBufferWords : Integer;
fontWidth : Integer;
END;
FontHndl = ^FontPtr;
FontPtr = ^Font;
Font = RECORD
offseToMF : Integer; { fully defined front of the Font record. }
family : Integer;
style : TextStyle;
size : Integer;
version : Integer;
fbrExtent : Integer;
END;
FontGlobalsRecHndl = ^FontGlobalsRecPtr;
FontGlobalsRecPtr = ^FontGlobalsRecord;
FontGlobalsRecord = RECORD
fgFontID : Integer; { currently 12 bytes long, but may be expanded }
fgStyle : TextStyle;
fgSize : Integer;
fgVersion : Integer;
fgWidMax : Integer;
fgFBRExtent : Integer;
END;
FontIDHndl = ^FontIDPtr;
FontIDPtr = ^FontID;
FontID = PACKED RECORD
famNum : Integer;
fontStyle : Byte;
fontSize : Byte;
END;
FontInfoRecHndl = ^FontInfoRecPtr;
FontInfoRecPtr = ^FontInfoRecord;
FontInfoRecord = RECORD
ascent : Integer;
descent : Integer;
widMax : Integer;
leading : Integer;
END;
LocInfoHndl = ^LocInfoPtr;
LocInfoPtr = ^LocInfo;
LocInfo = RECORD
portSCB : Integer; { SCBByte in low byte }
ptrToPixImage : Ptr; { ImageRef }
width : Integer; { Width }
boundsRect : Rect; { BoundsRect }
END;
QDProcsHndl = ^QDProcsPtr;
QDProcsPtr = ^QDProcs;
QDProcs = RECORD
stdText : VoidProcPtr;
stdLine : VoidProcPtr;
stdRect : VoidProcPtr;
stdRRect : VoidProcPtr;
stdOval : VoidProcPtr;
stdArc : VoidProcPtr;
stdPoly : VoidProcPtr;
stdRgn : VoidProcPtr;
stdPixels : VoidProcPtr;
stdComment : VoidProcPtr;
stdTxMeas : VoidProcPtr;
stdTxBnds : VoidProcPtr;
stdGetPic : VoidProcPtr;
stdPutPic : VoidProcPtr;
END;
GrafPortHndl = ^GrafPortPtr;
GrafPortPtr = ^GrafPort;
GrafPort = RECORD
portInfo : LocInfo;
portRect : Rect; { PortRect }
clipRgn : RgnHandle; { Clip Rgn. Pointer }
visRgn : RgnHandle; { Vis. Rgn. Pointer }
bkPat : Pattern; { BackGround Pattern }
pnLoc : Point; { Pen Location }
pnSize : Point; { Pen Size }
pnMode : Integer; { Pen Mode }
pnPat : Pattern; { Pen Pattern }
pnMask : Mask; { Pen Mask }
pnVis : Integer; { Pen Visable }
fontHandle : FontHndl;
gfontID : FontID; { Font ID }
fontFlags : Integer; { FontFlags }
txSize : Integer; { Text Size }
txFace : TextStyle; { Text Face }
txMode : Integer; { Text Mode }
spExtra : Fixed; { Fixed Point Value }
chExtra : Fixed; { Fixed Point Value }
fgColor : Integer; { ForeGround Color }
bgColor : Integer; { BackGround Color }
picSave : Handle; { PicSave }
rgnSave : Handle; { RgnSave }
polySave : Handle; { PolySave }
grafProcs : QDProcsPtr;
arcRot : Integer; { ArcRot }
userField : Longint; { UserField }
sysField : Longint; { SysField }
END;
PaintParamHndl = ^PaintParamPtr;
PaintParamPtr = ^PaintParam;
PaintParam = RECORD
ptrToSourceLocInfo : LocInfoPtr;
ptrToDestLocInfo : LocInfoPtr;
ptrToSourceRect : RectPtr;
ptrToDestPoint : PointPtr;
mode : Integer;
maskHandle : Handle; { clip region }
END;
PenStateHndl = ^PenStatePtr;
PenStatePtr = ^PenState;
PenState = RECORD
psPnSize : Point;
psPnMode : Integer;
psPnPat : Pattern;
psPnMask : Mask;
END;
RomFontRecHndl = ^RomFontRecPtr;
RomFontRecPtr = ^RomFontRec;
RomFontRec = RECORD
rfFamNum : Integer;
rfFamStyle : Integer;
rfSize : Integer;
rfFontHandle : FontHndl;
rfNamePtr : Ptr;
rfFBRExtent : Integer;
END;
ColorTableHndl = ^ColorTablePtr;
ColorTablePtr = ^ColorTable;
ColorTable = RECORD
entries : ARRAY[1..16] OF Integer;
END;
PROCEDURE QDBootInit ; Tool $04,$01;
PROCEDURE QDStartUp ( dPageAddr:Integer; masterSCB:Integer; maxWidth:Integer;
userID:Integer) ; Tool $04,$02;
PROCEDURE QDShutDown ; Tool $04,$03;
FUNCTION QDVersion : Integer ; Tool $04,$04;
PROCEDURE QDReset ; Tool $04,$05;
FUNCTION QDStatus : Boolean ; Tool $04,$06;
PROCEDURE AddPt (VAR srcPtPtr:Point;VAR destPtPtr:Point) ; Tool $04,$80;
PROCEDURE CharBounds ( theChar:CHAR;VAR resultPtr:Rect) ; Tool $04,$AC;
FUNCTION CharWidth ( theChar:CHAR) : Integer ; Tool $04,$A8;
PROCEDURE ClearScreen ( colorWord:Integer) ; Tool $04,$15;
PROCEDURE ClipRect ( rectPtr:Rect) ; Tool $04,$26;
PROCEDURE ClosePoly ; Tool $04,$C2;
PROCEDURE ClosePort ( portPtr:GrafPortPtr) ; Tool $04,$1A;
PROCEDURE CloseRgn ( aRgnHandle:RgnHandle) ; Tool $04,$6E;
PROCEDURE CopyRgn ( srcRgnHandle:RgnHandle; destRgnHandle:RgnHandle) ; Tool
$04,$69;
PROCEDURE CStringBounds ( cStringPtr:Ptr;VAR resultRect:Rect) ; Tool $04,$AE;
FUNCTION CStringWidth ( cStringPtr:Ptr) : Integer ; Tool $04,$AA;
PROCEDURE DiffRgn ( rgn1Handle:RgnHandle; rgn2Handle:RgnHandle;
diffRgnHandle:RgnHandle) ; Tool $04,$73;
PROCEDURE DisposeRgn ( aRgnHandle:RgnHandle) ; Tool $04,$68;
PROCEDURE DrawChar ( theChar:CHAR) ; Tool $04,$A4;
PROCEDURE DrawCString ( cStrPtr:CStringPtr) ; Tool $04,$A6;
PROCEDURE DrawString ( str:Str255) ; Tool $04,$A5;
PROCEDURE DrawText ( textPtr:Ptr; textLength:Integer) ; Tool $04,$A7;
FUNCTION NotEmptyRect ( rectPtr:Rect) : Boolean ; Tool $04,$52;
FUNCTION EmptyRgn ( aRgnHandle:RgnHandle) : Boolean ; Tool $04,$78;
FUNCTION EqualPt (VAR point1Ptr:Point;VAR point2Ptr:Point) : Boolean ; Tool
$04,$83;
FUNCTION EqualRect ( rect1Ptr:Rect; rect2Ptr:Rect) : Boolean ; Tool $04,$51;
FUNCTION EqualRgn ( rgn1Handle:RgnHandle; rgn2Handle:RgnHandle) : Boolean ;
Tool $04,$77;
PROCEDURE EraseArc ( rectPtr:Rect; startAngle:Integer; arcAngle:Integer) ;
Tool $04,$64;
PROCEDURE EraseOval ( rectPtr:Rect) ; Tool $04,$5A;
PROCEDURE ErasePoly ( polyHandle:Handle) ; Tool $04,$BE;
PROCEDURE EraseRect ( rectPtr:Rect) ; Tool $04,$55;
PROCEDURE EraseRgn ( aRgnHandle:RgnHandle) ; Tool $04,$7B;
PROCEDURE EraseRRect ( rectPtr:Rect; ovalWidth:Integer; ovalHeight:Integer) ;
Tool $04,$5F;
PROCEDURE FillArc ( rectPtr:Rect; startAngle:Integer; arcAngle:Integer;
patternPtr:Pattern) ; Tool $04,$66;
PROCEDURE FillOval ( rectPtr:Rect; patternPtr:Pattern) ; Tool $04,$5C;
PROCEDURE FillPoly ( polyHandle:Handle; patternPtr:Pattern) ; Tool $04,$C0;
PROCEDURE FillRect ( rectPtr:Rect; patternPtr:Pattern) ; Tool $04,$57;
PROCEDURE FillRgn ( aRgnHandle:RgnHandle; patternPtr:Pattern) ; Tool $04,$7D;
PROCEDURE FillRRect ( rectPtr:Rect; ovalWidth:Integer; ovalHeight:Integer;
patternPtr:Pattern) ; Tool $04,$61;
PROCEDURE ForceBufDims ( maxWidth:Integer; maxFontHeight:Integer;
maxFBRExtent:Integer) ; Tool $04,$CC;
PROCEDURE FrameArc ( rectPtr:Rect; startAngle:Integer; arcAngle:Integer) ;
Tool $04,$62;
PROCEDURE FrameOval ( rectPtr:Rect) ; Tool $04,$58;
PROCEDURE FramePoly ( polyHandle:Handle) ; Tool $04,$BC;
PROCEDURE FrameRect ( rectPtr:Rect) ; Tool $04,$53;
PROCEDURE FrameRgn ( aRgnHandle:RgnHandle) ; Tool $04,$79;
PROCEDURE FrameRRect ( rectPtr:Rect; ovalWidth:Integer; ovalHeight:Integer) ;
Tool $04,$5D;
FUNCTION GetAddress ( tableID:Integer) : Ptr ; Tool $04,$09;
FUNCTION GetArcRot : Integer ; Tool $04,$B1;
FUNCTION GetBackColor : Integer ; Tool $04,$A3;
PROCEDURE GetBackPat (VAR patternPtr:Pattern) ; Tool $04,$35;
FUNCTION GetCharExtra : Fixed ; Tool $04,$D5;
PROCEDURE GetClip ( aRgnHandle:RgnHandle) ; Tool $04,$25;
FUNCTION GetClipHandle : RgnHandle ; Tool $04,$C7;
FUNCTION GetColorEntry ( tableNumber:Integer; entryNumber:Integer) : Integer ;
Tool $04,$11;
PROCEDURE GetColorTable ( tableNumber:Integer;VAR destTablePtr:ColorTable) ;
Tool $04,$0F;
FUNCTION GetCursorAdr : CursorPtr ; Tool $04,$8F;
FUNCTION GetFGSize : Integer ; Tool $04,$CF;
FUNCTION GetFont : FontHndl ; Tool $04,$95;
FUNCTION GetFontFlags : Integer ; Tool $04,$99;
PROCEDURE GetFontGlobals (VAR fgRecPtr:FontGlobalsRecord) ; Tool $04,$97;
FUNCTION GetFontID : FontID ; Tool $04,$D1;
PROCEDURE GetFontInfo (VAR fontInfoRecPtr:FontInfoRecord) ; Tool $04,$96;
FUNCTION GetFontLore (VAR recordPtr:FontGlobalsRecord; recordSize:Integer) :
Integer ; Tool $04,$D9;
FUNCTION GetForeColor : Integer ; Tool $04,$A1;
FUNCTION GetGrafProcs : QDProcsPtr ; Tool $04,$45;
FUNCTION GetMasterSCB : Integer ; Tool $04,$17;
PROCEDURE GetPen (VAR pointPtr:Point) ; Tool $04,$29;
PROCEDURE GetPenMask (VAR maskPtr:Mask) ; Tool $04,$33;
FUNCTION GetPenMode : Integer ; Tool $04,$2F;
PROCEDURE GetPenPat (VAR patternPtr:Pattern) ; Tool $04,$31;
PROCEDURE GetPenSize (VAR pointPtr:Point) ; Tool $04,$2D;
PROCEDURE GetPenState (VAR U__penStatePtr:PenState) ; Tool $04,$2B;
FUNCTION GetPicSave : Longint ; Tool $04,$3F;
FUNCTION GetPixel ( h:Integer; v:Integer) : Integer ; Tool $04,$88;
FUNCTION GetPolySave : Longint ; Tool $04,$43;
FUNCTION GetPort : GrafPortPtr ; Tool $04,$1C;
PROCEDURE GetPortLoc (VAR locInfoPtr:LocInfo) ; Tool $04,$1E;
PROCEDURE GetPortRect (VAR U__rectPtr:Rect) ; Tool $04,$20;
FUNCTION GetRgnSave : Longint ; Tool $04,$41;
PROCEDURE GetROMFont (VAR recordPtr:RomFontRec) ; Tool $04,$D8;
FUNCTION GetSCB ( scanLine:Integer) : Integer ; Tool $04,$13;
FUNCTION GetSpaceExtra : Fixed ; Tool $04,$9F;
FUNCTION GetStandardSCB : Integer ; Tool $04,$0C;
FUNCTION GetSysField : Longint ; Tool $04,$49;
FUNCTION GetSysFont : FontHndl ; Tool $04,$B3;
FUNCTION GetTextFace : TextStyle ; Tool $04,$9B;
FUNCTION GetTextMode : Integer ; Tool $04,$9D;
FUNCTION GetTextSize : Integer ; Tool $04,$D3;
FUNCTION GetUserField : Longint ; Tool $04,$47;
FUNCTION GetVisHandle : RgnHandle ; Tool $04,$C9;
PROCEDURE GetVisRgn ( aRgnHandle:RgnHandle) ; Tool $04,$B5;
PROCEDURE GlobalToLocal (VAR pointPtr:Point) ; Tool $04,$85;
PROCEDURE GrafOff ; Tool $04,$0B;
PROCEDURE GrafOn ; Tool $04,$0A;
PROCEDURE HideCursor ; Tool $04,$90;
PROCEDURE HidePen ; Tool $04,$27;
PROCEDURE InflateTextBuffer ( newWidth:Integer; newHeight:Integer) ; Tool
$04,$D7;
PROCEDURE InitColorTable (VAR tablePtr:ColorTable) ; Tool $04,$0D;
PROCEDURE InitCursor ; Tool $04,$CA;
PROCEDURE InitPort ( portPtr:GrafPortPtr) ; Tool $04,$19;
PROCEDURE InsetRect (VAR U__rectPtr:Rect; deltaH:Integer; deltaV:Integer) ;
Tool $04,$4C;
PROCEDURE InsetRgn ( aRgnHandle:RgnHandle; dH:Integer; dV:Integer) ; Tool
$04,$70;
PROCEDURE InvertArc ( rectPtr:Rect; startAngle:Integer; arcAngle:Integer) ;
Tool $04,$65;
PROCEDURE InvertOval ( rectPtr:Rect) ; Tool $04,$5B;
PROCEDURE InvertPoly ( polyHandle:Handle) ; Tool $04,$BF;
PROCEDURE InvertRect ( rectPtr:Rect) ; Tool $04,$56;
PROCEDURE InvertRgn ( aRgnHandle:RgnHandle) ; Tool $04,$7C;
PROCEDURE InvertRRect ( rectPtr:Rect; ovalWidth:Integer; ovalHeight:Integer) ;
Tool $04,$60;
PROCEDURE KillPoly ( polyHandle:Handle) ; Tool $04,$C3;
PROCEDURE Line ( dH:Integer; dV:Integer) ; Tool $04,$3D;
PROCEDURE LineTo ( h:Integer; v:Integer) ; Tool $04,$3C;
PROCEDURE LocalToGlobal (VAR pointPtr:Point) ; Tool $04,$84;
PROCEDURE MapPoly ( polyHandle:Handle; srcRectPtr:Rect; destRectPtr:Rect) ;
Tool $04,$C5;
PROCEDURE MapPt (VAR pointPtr:Point; srcRectPtr:Rect; destRectPtr:Rect) ; Tool
$04,$8A;
PROCEDURE MapRect (VAR rectPtr:Rect; srcRectPtr:Rect; destRectPtr:Rect) ; Tool
$04,$8B;
PROCEDURE MapRgn ( aRgnHandle:RgnHandle; srcRectPtr:Rect; destdRectPtr:Rect) ;
Tool $04,$8C;
PROCEDURE Move ( dH:Integer; dV:Integer) ; Tool $04,$3B;
PROCEDURE MovePortTo ( h:Integer; v:Integer) ; Tool $04,$22;
PROCEDURE MoveTo ( h:Integer; v:Integer) ; Tool $04,$3A;
FUNCTION NewRgn : RgnHandle ; Tool $04,$67;
PROCEDURE ObscureCursor ; Tool $04,$92;
PROCEDURE OffsetPoly ( polyHandle:Handle; dH:Integer; dV:Integer) ; Tool
$04,$C4;
PROCEDURE OffsetRect (VAR U__rectPtr:Rect; deltaH:Integer; deltaV:Integer) ;
Tool $04,$4B;
PROCEDURE OffsetRgn ( aRgnHandle:RgnHandle; dH:Integer; dV:Integer) ; Tool
$04,$6F;
FUNCTION OpenPoly : handle ; Tool $04,$C1;
PROCEDURE OpenPort ( portPtr:GrafPortPtr) ; Tool $04,$18;
PROCEDURE OpenRgn ; Tool $04,$6D;
PROCEDURE PaintArc ( rectPtr:Rect; startAngle:Integer; arcAngle:Integer) ;
Tool $04,$63;
PROCEDURE PaintOval ( rectPtr:Rect) ; Tool $04,$59;
PROCEDURE PaintPixels ( U__paintParamPtr:PaintParam) ; Tool $04,$7F;
PROCEDURE PaintPoly ( polyHandle:Handle) ; Tool $04,$BD;
PROCEDURE PaintRect ( rectPtr:Rect) ; Tool $04,$54;
PROCEDURE PaintRgn ( aRgnHandle:RgnHandle) ; Tool $04,$7A;
PROCEDURE PaintRRect ( rectPtr:Rect; ovalWidth:Integer; ovalHeight:Integer) ;
Tool $04,$5E;
PROCEDURE PenNormal ; Tool $04,$36;
PROCEDURE PPToPort ( srcLocPtr:LocInfoPtr; srcRectPtr:Rect; destX:Integer;
destY:Integer; transferMode:Integer) ; Tool $04,$D6;
PROCEDURE Pt2Rect (VAR point1Ptr:Point;VAR point2Ptr:Point;VAR U__rectPtr:Rect)
; Tool $04,$50;
FUNCTION PtInRect (VAR pointPtr:Point; rectPtr:Rect) : Boolean ; Tool $04,$4F;
FUNCTION PtInRgn (VAR pointPtr:Point; aRgnHandle:RgnHandle) : Boolean ; Tool
$04,$75;
FUNCTION Random : Integer ; Tool $04,$86;
FUNCTION RectInRgn ( rectPtr:Rect; aRgnHandle:RgnHandle) : Boolean ; Tool
$04,$76;
PROCEDURE RectRgn ( aRgnHandle:RgnHandle; rectPtr:Rect) ; Tool $04,$6C;
PROCEDURE RestoreBufDims ( sizeInfoPtr:BufDimRecPtr) ; Tool $04,$CE;
PROCEDURE SaveBufDims (VAR sizeInfoPtr:BufDimRec) ; Tool $04,$CD;
PROCEDURE ScalePt (VAR pointPtr:Point; srcRectPtr:Rect; destRectPtr:Rect) ;
Tool $04,$89;
PROCEDURE ScrollRect ( rectPtr:Rect; dH:Integer; dV:Integer;
aRgnHandle:RgnHandle) ; Tool $04,$7E;
FUNCTION SectRect ( rect1Ptr:Rect; rect2Ptr:Rect;VAR intersectRectPtr:Rect) :
Boolean ; Tool $04,$4D;
PROCEDURE SectRgn ( rgn1Handle:RgnHandle; rgn2Handle:RgnHandle;
destRgnHandle:RgnHandle) ; Tool $04,$71;
PROCEDURE SetAllSCBs ( newSCB:Integer) ; Tool $04,$14;
PROCEDURE SetArcRot ; Tool $04,$B0;
PROCEDURE SetBackColor ( backColor:Integer) ; Tool $04,$A2;
PROCEDURE SetBackPat ( patternPtr:Pattern) ; Tool $04,$34;
PROCEDURE SetBufDims ( maxWidth:Integer; maxFontHeight:Integer;
maxFBRExtent:Integer) ; Tool $04,$CB;
PROCEDURE SetCharExtra ( charExtra:Fixed) ; Tool $04,$D4;
PROCEDURE SetClip ( aRgnHandle:RgnHandle) ; Tool $04,$24;
PROCEDURE SetClipHandle ( aRgnHandle:RgnHandle) ; Tool $04,$C6;
PROCEDURE SetColorEntry ( tableNumber:Integer; entryNumber:Integer;
newColor:ColorValue) ; Tool $04,$10;
PROCEDURE SetColorTable ( tableNumber:Integer; srcTablePtr:ColorTable) ; Tool
$04,$0E;
PROCEDURE SetCursor ( theCursorPtr:Cursor) ; Tool $04,$8E;
PROCEDURE SetEmptyRgn ( aRgnHandle:RgnHandle) ; Tool $04,$6A;
PROCEDURE SetFont ( newFontHandle:FontHndl) ; Tool $04,$94;
PROCEDURE SetFontFlags ( fontFlags:Integer) ; Tool $04,$98;
PROCEDURE SetFontID (VAR U__fontID:FontID) ; Tool $04,$D0;
PROCEDURE SetForeColor ( foreColor:Integer) ; Tool $04,$A0;
PROCEDURE SetGrafProcs ( grafProcsPtr:QDProcsPtr) ; Tool $04,$44;
PROCEDURE SetIntUse ( useInt:Integer) ; Tool $04,$B6;
PROCEDURE SetMasterSCB ( masterSCB:Integer) ; Tool $04,$16;
PROCEDURE SetOrigin ( h:Integer; v:Integer) ; Tool $04,$23;
PROCEDURE SetPenMask ( maskPtr:Mask) ; Tool $04,$32;
PROCEDURE SetPenMode ( penMode:Integer) ; Tool $04,$2E;
PROCEDURE SetPenPat ( patternPtr:Pattern) ; Tool $04,$30;
PROCEDURE SetPenSize ( penWidth:Integer; penHeight:Integer) ; Tool $04,$2C;
PROCEDURE SetPenState (VAR U__penStatePtr:PenState) ; Tool $04,$2A;
PROCEDURE SetPicSave ( picSaveValue:Longint) ; Tool $04,$3E;
PROCEDURE SetPolySave ( polySaveValue:Longint) ; Tool $04,$42;
PROCEDURE SetPort ( portPtr:GrafPortPtr) ; Tool $04,$1B;
PROCEDURE SetPortLoc ( U__locInfoPtr:LocInfo) ; Tool $04,$1D;
PROCEDURE SetPortRect ( rectPtr:Rect) ; Tool $04,$1F;
PROCEDURE SetPortSize ( portWidth:Integer; portHeight:Integer) ; Tool $04,$21;
PROCEDURE SetPt (VAR srcPtPtr:Point; h:Integer; v:Integer) ; Tool $04,$82;
PROCEDURE SetRandSeed ( randomSeed:Longint) ; Tool $04,$87;
PROCEDURE SetRect (VAR aRectPtr:Rect; left:Integer; top:Integer; right:Integer;
bottom:Integer) ; Tool $04,$4A;
PROCEDURE SetRectRgn ( aRgnHandle:RgnHandle; left:Integer; top:Integer;
right:Integer; bottom:Integer) ; Tool $04,$6B;
PROCEDURE SetRgnSave ( rgnSaveValue:Longint) ; Tool $04,$40;
PROCEDURE SetSCB ( scanLine:Integer; newSCB:Integer) ; Tool $04,$12;
PROCEDURE SetSolidBackPat ( colorNum:Integer) ; Tool $04,$38;
PROCEDURE SetSolidPenPat ( colorNum:Integer) ; Tool $04,$37;
PROCEDURE SetSpaceExtra ( spaceExtra:Fixed) ; Tool $04,$9E;
PROCEDURE SetStdProcs ( stdProcRecPtr:QDProcsPtr) ; Tool $04,$8D;
PROCEDURE SetSysField ( sysFieldValue:Longint) ; Tool $04,$48;
PROCEDURE SetSysFont ( fontHandle:FontHndl) ; Tool $04,$B2;
PROCEDURE SetTextFace ( textFace:TextStyle) ; Tool $04,$9A;
PROCEDURE SetTextMode ( textMode:Integer) ; Tool $04,$9C;
PROCEDURE SetTextSize ( textSize:Integer) ; Tool $04,$D2;
PROCEDURE SetUserField ( userFieldValue:Longint) ; Tool $04,$46;
PROCEDURE SetVisHandle ( aRgnHandle:RgnHandle) ; Tool $04,$C8;
PROCEDURE SetVisRgn ( aRgnHandle:RgnHandle) ; Tool $04,$B4;
PROCEDURE ShowCursor ; Tool $04,$91;
PROCEDURE ShowPen ; Tool $04,$28;
PROCEDURE SolidPattern ( colorNum:Integer;VAR patternPtr:Pattern) ; Tool
$04,$39;
PROCEDURE StringBounds ( str:Str255;VAR resultPtr:Rect) ; Tool $04,$AD;
FUNCTION StringWidth ( str:Str255) : Integer ; Tool $04,$A9;
PROCEDURE SubPt (VAR srcPtPtr:Point;VAR destPtPtr:Point) ; Tool $04,$81;
PROCEDURE TextBounds ( textPtr:Ptr; textLength:Integer;VAR resultPtr:Rect) ;
Tool $04,$AF;
FUNCTION TextWidth ( textPtr:Ptr; textLength:Integer) : Integer ; Tool $04,$AB;
PROCEDURE UnionRect ( rect1Ptr:Rect; rect2Ptr:Rect;VAR unionRectPtr:Rect) ;
Tool $04,$4E;
PROCEDURE UnionRgn ( rgn1Handle:RgnHandle; rgn2Handle:RgnHandle;
unionRgnHandle:RgnHandle) ; Tool $04,$72;
PROCEDURE XorRgn ( rgn1Handle:RgnHandle; rgn2Handle:RgnHandle;
xorRgnHandle:RgnHandle) ; Tool $04,$74;
IMPLEMENTATION
END.

184
pascal/resources.p Executable file
View File

@ -0,0 +1,184 @@
{********************************************
; File: Resources.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT RESOURCES;
INTERFACE
USES TYPES,MEMORY,GSOS;
CONST
resLogOut = $0; {ResourceConverter - }
resLogIn = $1; {ResourceConverter - }
resLogApp = $0; {ResourceConverter - }
resLogSys = $2; {ResourceConverter - }
(* *** Toolset Errors ***
resForkUsed = $1E01; {Error - Resource fork not empty }
resBadFormat = $1E02; {Error - Format of resource fork is unknown }
resForkEmpty = $1E03; {Error - Resource fork is empty }
resNoCurFile = $1E04; {Error - there are no current open resource files }
resDupID = $1E05; {Error - ID is already used }
resNotFound = $1E06; {Error - resource was not found }
resFileNotFound = $1E07; {Error - resource file not found }
resBadAppID = $1E08; {Error - User ID not found, please call ResourceStartup }
resNoUniqueID = $1E09; {Error - a unique ID was not found }
resBadAttr = $1E0A; {Error - reseved bits in attributes word are not zero }
resHashGone = $1E0B; {Error - the hash count table is no longer valid }
resIndexRange = $1E0D; {Error - index is out of range }
resNoCurApp = $1E0E; {Error - no current application, please call
ResourceStartup }
*** Toolset Errors *** *)
resChanged = $0020; {Resources - }
resPreLoad = $0040; {Resources - }
resProtected = $0080; {Resources - }
resAbsLoad = $0400; {Resources - }
resConverter = $0800; {Resources - }
resMemAttr = $C3F1; {Resources - }
systemMap = $0001; {Resources - }
mapChanged = $0002; {Resources - }
romMap = $0004; {Resources - }
resNameOffset = $10000; {Resources - type holding names }
resNameVersion = $0001; {Resources - }
rIcon = $8001; {Resources - resource type holding names }
rPicture = $8002; {Resources - resource type holding names }
rControlList = $8003; {Resources - resource type holding names }
rControlTemplate = $8004; {Resources - resource type holding names }
rWindow = $8005; {Resources - resource type holding names }
rString = $8006; {Resources - resource type holding names }
rStringList = $8007; {Resources - resource type holding names }
rMenuBar = $8008; {Resources - resource type holding names }
rMenu = $8009; {Resources - resource type holding names }
rMenuItem = $800A; {Resources - resource type holding names }
rTextForLETextBox2 = $800B; {Resources - resource type holding names }
rCtlDefProc = $800C; {Resources - resource type holding names }
rCtlColorTbl = $800D; {Resources - resource type holding names }
rWindParam1 = $800E; {Resources - resource type holding names }
rWindParam2 = $800F; {Resources - resource type holding names }
rWindColor = $8010; {Resources - resource type holding names }
rResName = $8014; {Resources - resource type holding names }
TYPE
ResID = Longint ;
ResType = Integer ;
ResAttr = Integer ;
ResHeaderRec = RECORD
rFileVersion : Longint; { Format version of resource fork }
rFileToMap : Longint; { Offset from start to resource map record }
rFileMapSize : Longint; { Number of bytes map occupies in file }
rFileMemo : PACKED ARRAY[1..128] OF Byte; { Reserved space for application
}
rFileRecSize : Longint; { Size of ResHeaderRec Record }
END;
FreeBlockRec = RECORD
blkOffset : Longint;
blkSize : Longint;
END;
ResMapHandle = ^ResMapPtr;
ResMapPtr = ^ResMap;
ResMap = RECORD
mapNext : ResMapHandle; { Handle to next resource map }
mapFlag : Integer; { Bit Flags }
mapOffset : Longint; { Map's file position }
mapSize : Longint; { Number of bytes map occupies in file }
mapToIndex : Integer;
mapFileNum : Integer;
mapID : Integer;
mapIndexSize : Longint;
mapIndexUsed : Longint;
mapFreeListSize : Integer;
mapFreeListUsed : Integer;
mapFreeList : ARRAY[1..1] OF FreeBlockRec; { n bytes (array of free block
records) }
END;
ResRefRecPtr = ^ResRefRec;
ResRefRec = RECORD
fResType : ResType;
fResID : ResID;
fResOffset : Longint;
fResAttr : ResAttr;
fResSize : Longint;
fResHandle : Handle;
END;
ResourceSpec = RECORD
resourceType : ResType;
resourceID : ResID;
END;
ResNameEntryPtr = ^ResNameEntry;
ResNameEntry = RECORD
namedResID : ResID;
resName : Str255;
END;
ResNameRecordHandle = ^ResNameRecordPtr;
ResNameRecordPtr = ^ResNameRecord;
ResNameRecord = RECORD
version : Integer;
nameCount : Longint;
resNameEntries : ARRAY[1..1] OF ResNameEntry;
END;
PROCEDURE ResourceBootInit ; Tool $1E,$01;
PROCEDURE ResourceStartup ( userID:Integer) ; Tool $1E,$02;
PROCEDURE ResourceShutdown ; Tool $1E,$03;
FUNCTION ResourceVersion : Integer ; Tool $1E,$04;
PROCEDURE ResourceReset ; Tool $1E,$05;
FUNCTION ResourceStatus : Boolean ; Tool $1E,$06;
PROCEDURE AddResource ( resourceHandle:Handle; resourceAttr:ResAttr;
resourceType:ResType; resourceID:ResID) ; Tool $1E,$0C;
PROCEDURE CloseResourceFile ( fileID:Integer) ; Tool $1E,$0B;
FUNCTION CountResources ( resourceType:ResType) : Longint ; Tool $1E,$22;
FUNCTION CountTypes : Integer ; Tool $1E,$20;
PROCEDURE CreateResourceFile ( auxType:Longint; fileType:Integer;
fileAccess:Integer; fileName:GSString255Ptr) ; Tool $1E,$09;
PROCEDURE DetachResource ( resourceType:ResType; resourceID:ResID) ; Tool
$1E,$18;
FUNCTION GetCurResourceApp : Integer ; Tool $1E,$14;
FUNCTION GetCurResourceFile : Integer ; Tool $1E,$12;
FUNCTION GetIndResource ( resourceType:ResType; resourceIndex:Longint) : ResID
; Tool $1E,$23;
FUNCTION GetIndType ( typeIndex:Integer) : ResType ; Tool $1E,$21;
FUNCTION GetMapHandle ( fileID:Integer) : ResMapHandle ; Tool $1E,$26;
FUNCTION GetOpenFileRefNum ( fileID:Integer) : Integer ; Tool $1E,$1F;
FUNCTION GetResourceAttr ( resourceType:ResType; resourceID:ResID) : ResAttr ;
Tool $1E,$1B;
FUNCTION GetResourceSize ( resourceType:ResType; currentID:ResID) : Longint ;
Tool $1E,$1D;
FUNCTION HomeResourceFile ( resourceType:ResType; resourceID:ResID) : Integer ;
Tool $1E,$15;
FUNCTION LoadAbsResource ( loadAddress:Longint; maxSize:Longint;
resourceType:ResType; resourceID:ResID) : Handle ; Tool $1E,$27;
FUNCTION LoadResource ( resourceType:ResType; resourceID:ResID) : Handle ; Tool
$1E,$0E;
PROCEDURE MarkResourceChange ( U__changeFlag:Boolean; resourceType:ResType;
resourceID:ResID) ; Tool $1E,$10;
PROCEDURE MatchResourceHandle ( foundRec:Ptr; resourceHandle:Handle) ; Tool
$1E,$1E;
FUNCTION OpenResourceFile ( openAccess:Integer; resourceMapPtr:ResMapPtr;
fileName:GSString255Ptr) : Integer ; Tool $1E,$0A;
PROCEDURE ReleaseResource ( purgeLevel:Integer; resourceType:ResType;
resourceID:ResID) ; Tool $1E,$17;
PROCEDURE RemoveResource ( resourceType:ResType; resourceID:ResID) ; Tool
$1E,$0F;
PROCEDURE ResourceConverter ( converterProc:ProcPtr; resourceType:ResType;
logFlags:Integer) ; Tool $1E,$28;
PROCEDURE SetCurResourceApp ( userID:Integer) ; Tool $1E,$13;
PROCEDURE SetCurResourceFile ( fileID:Integer) ; Tool $1E,$11;
PROCEDURE SetResourceAttr ( resourceAttr:ResAttr; resourceType:ResType;
currentID:ResID) ; Tool $1E,$1C;
FUNCTION SetResourceFileDepth ( searchDepth:Integer) : Integer ; Tool $1E,$25;
PROCEDURE SetResourceID ( newID:ResID; resourceType:ResType; currentID:ResID)
; Tool $1E,$1A;
FUNCTION SetResourceLoad ( readFlag:Integer) : Integer ; Tool $1E,$24;
FUNCTION UniqueResourceID ( IDrange:Integer; resourceType:ResType) : ResID ;
Tool $1E,$19;
PROCEDURE UpdateResourceFile ( fileID:Integer) ; Tool $1E,$0D;
PROCEDURE WriteResource ( resourceType:ResType; resourceID:ResID) ; Tool
$1E,$16;
IMPLEMENTATION
END.

222
pascal/sane.p Executable file
View File

@ -0,0 +1,222 @@
UNIT SANE;
{ Apple IIGS SANE Interfaces
See the Apple Numerics Manual for complete documentation
Copyright (c) 1986-1988 by TML Systems, Inc. All Rights Reserved.
}
{ The SANE environment word (Integer) is defined as follows:
}
INTERFACE
CONST DecStrLen = 255;
TYPE
{ Standard housekeeping routines }
PROCEDURE SANEStartUp
PROCEDURE SANEShutDown;
FUNCTION SANEVersion: Integer;
PROCEDURE SANEReset;
FUNCTION SANEStatus: Integer;
{ Conversions between numeric binary types }
FUNCTION Num2Integer
FUNCTION Num2Longint
FUNCTION Num2Real
FUNCTION Num2Double
FUNCTION Num2Extended
FUNCTION Num2Comp
{ Conversions between binary and decimal }
PROCEDURE Num2Dec
FUNCTION Dec2Num
{ Conversions between decimal formats }
PROCEDURE Str2Dec
PROCEDURE CStr2Dec
PROCEDURE Dec2Str
{ Arithmetic, auxiliary and elementary functions }
FUNCTION Remainder
FUNCTION Rint
FUNCTION Scalb
FUNCTION Logb
FUNCTION Log2
FUNCTION Ln1
FUNCTION Exp2
FUNCTION Exp1
FUNCTION Tan
FUNCTION CopySign
FUNCTION NextExtended
FUNCTION XpwrI
FUNCTION XpwrY
FUNCTION Compound
FUNCTION Annuity
FUNCTION RandomX
{ Inquirty routines }
FUNCTION ClassReal
FUNCTION ClassDouble
FUNCTION ClassComp
FUNCTION ClassExtended
FUNCTION SignNum
{ NaN function }
FUNCTION NAN
{ Environment control routines }
FUNCTION GetHaltVector: Integer;
PROCEDURE SetHaltVector
{ Environment access routines }
PROCEDURE SetEnvironment
PROCEDURE GetEnvironment
PROCEDURE ProcEntry
PROCEDURE ProcExit
{ Comparison routine }
FUNCTION Relation
IMPLEMENTATION
END.

22
pascal/scheduler.p Executable file
View File

@ -0,0 +1,22 @@
{********************************************
; File: Scheduler.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT SCHEDULER;
INTERFACE
USES TYPES;
PROCEDURE SchBootInit ; Tool $07,$01;
PROCEDURE SchStartUp ; Tool $07,$02;
PROCEDURE SchShutDown ; Tool $07,$03;
FUNCTION SchVersion : Integer ; Tool $07,$04;
PROCEDURE SchReset ; Tool $07,$05;
FUNCTION SchStatus : Boolean ; Tool $07,$06;
FUNCTION SchAddTask ( taskPtr:VoidProcPtr) : Boolean ; Tool $07,$09;
PROCEDURE SchFlush ; Tool $07,$0A;
IMPLEMENTATION
END.

40
pascal/scrap.p Executable file
View File

@ -0,0 +1,40 @@
{********************************************
; File: Scrap.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT SCRAP;
INTERFACE
USES TYPES;
CONST
(* *** Toolset Errors ***
badScrapType = $1610; {error - No scrap of this type. }
*** Toolset Errors *** *)
textScrap = $0000; {scrapType - }
picScrap = $0001; {scrapType - }
PROCEDURE ScrapBootInit ; Tool $16,$01;
PROCEDURE ScrapStartUp ; Tool $16,$02;
PROCEDURE ScrapShutDown ; Tool $16,$03;
FUNCTION ScrapVersion : Integer ; Tool $16,$04;
PROCEDURE ScrapReset ; Tool $16,$05;
FUNCTION ScrapStatus : Boolean ; Tool $16,$06;
PROCEDURE GetScrap ( destHandle:Handle; scrapType:Integer) ; Tool $16,$0D;
FUNCTION GetScrapCount : Integer ; Tool $16,$12;
FUNCTION GetScrapHandle ( scrapType:Integer) : handle ; Tool $16,$0E;
FUNCTION GetScrapPath : Ptr ; Tool $16,$10;
FUNCTION GetScrapSize ( scrapType:Integer) : Longint ; Tool $16,$0F;
FUNCTION GetScrapState : Integer ; Tool $16,$13;
PROCEDURE LoadScrap ; Tool $16,$0A;
PROCEDURE PutScrap ( numBytes:Longint; scrapType:Integer; srcPtr:Ptr) ; Tool
$16,$0C;
PROCEDURE SetScrapPath ( path:Str255) ; Tool $16,$11;
PROCEDURE UnloadScrap ; Tool $16,$09;
PROCEDURE ZeroScrap ; Tool $16,$0B;
IMPLEMENTATION
END.

115
pascal/sound.p Executable file
View File

@ -0,0 +1,115 @@
{********************************************
; File: Sound.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT SOUND;
INTERFACE
USES TYPES;
CONST
(* *** Toolset Errors ***
noDOCFndErr = $0810; {error - no DOC chip found }
docAddrRngErr = $0811; {error - DOC address range error }
noSAppInitErr = $0812; {error - no SAppInit call made }
invalGenNumErr = $0813; {error - invalid generator number }
synthModeErr = $0814; {error - synthesizer mode error }
genBusyErr = $0815; {error - generator busy error }
mstrIRQNotAssgnErr = $0817; {error - master IRQ not assigned }
sndAlreadyStrtErr = $0818; {error - sound tools already started }
unclaimedSndIntErr = $08FF; {error - sound tools already started }
*** Toolset Errors *** *)
ffSynthMode = $0001; {channelGenMode - Free form synthesizer mode }
noteSynthMode = $0002; {channelGenMode - Note synthesizer mode. }
gen0off = $0001; {genMask - param to FFStopSound }
gen1off = $0002; {genMask - param to FFStopSound }
gen2off = $0004; {genMask - param to FFStopSound }
gen3off = $0008; {genMask - param to FFStopSound }
gen4off = $0010; {genMask - param to FFStopSound }
gen5off = $0020; {genMask - param to FFStopSound }
gen6off = $0040; {genMask - param to FFStopSound }
gen7off = $0080; {genMask - param to FFStopSound }
gen8off = $0100; {genMask - param to FFStopSound }
gen9off = $0200; {genMask - param to FFStopSound }
gen10off = $0400; {genMask - param to FFStopSound }
gen11off = $0800; {genMask - param to FFStopSound }
gen12off = $1000; {genMask - param to FFStopSound }
gen13off = $2000; {genMask - param to FFStopSound }
gen14off = $4000; {genMask - param to FFStopSound }
genAvail = $0000; {genStatus - Generator available status }
ffSynth = $0100; {genStatus - Free Form Synthesizer status }
noteSynth = $0200; {genStatus - Note Synthesizer status }
lastBlock = $8000; {genStatus - Last block of wave }
smReadRegister = $00; {Jump Table Offset - Read Register routine }
smWriteRegister = $04; {Jump Table Offset - Write Register routine }
smReadRam = $08; {Jump Table Offset - Read Ram routine }
smWriteRam = $0C; {Jump Table Offset - Write Ram routine }
smReadNext = $10; {Jump Table Offset - Read Next routine }
smWriteNext = $14; {Jump Table Offset - Write Next routine }
smOscTable = $18; {Jump Table Offset - Pointer to Oscillator table }
smGenTable = $1C; {Jump Table Offset - Pointer to generator table }
smGcbAddrTable = $20; {Jump Table Offset - Pointer to GCB address table }
smDisableInc = $24; {Jump Table Offset - Disable Increment routine }
TYPE
SoundPBHndl = ^SoundPBPtr;
SoundPBPtr = ^SoundParamBlock;
SoundParamBlock = RECORD
waveStart : Ptr; { starting address of wave }
waveSize : Integer; { waveform size in pages }
freqOffset : Integer; { ? formula to be provided }
docBuffer : Integer; { DOC buffer start address, low byte = 0 }
bufferSize : Integer; { DOC buffer start address, low byte = 0 }
nextWavePtr : SoundPBPtr; { Pointer to start of next wave's parameter block
}
volSetting : Integer; { DOC volume setting. High byte = 0 }
END;
DocRegParamBlkPtr = ^DocRegParamBlk;
DocRegParamBlk = PACKED RECORD
oscGenType : Integer;
freqLow1 : Byte;
freqHigh1 : Byte;
vol1 : Byte;
tablePtr1 : Byte;
control1 : Byte;
tableSize1 : Byte;
freqLow2 : Byte;
freqHigh2 : Byte;
vol2 : Byte;
tablePtr2 : Byte;
control2 : Byte;
tableSize2 : Byte;
END;
PROCEDURE SoundBootInit ; Tool $08,$01;
PROCEDURE SoundStartUp ( dPageAddr:Integer) ; Tool $08,$02;
PROCEDURE SoundShutDown ; Tool $08,$03;
FUNCTION SoundVersion : Integer ; Tool $08,$04;
PROCEDURE SoundReset ; Tool $08,$05;
FUNCTION SoundToolStatus : Boolean ; Tool $08,$06;
FUNCTION FFGeneratorStatus ( genNumber:Integer) : Integer ; Tool $08,$11;
FUNCTION FFSoundDoneStatus ( genNumber:Integer) : Boolean ; Tool $08,$14;
FUNCTION FFSoundStatus : Integer ; Tool $08,$10;
PROCEDURE FFStartSound ( genNumFFSynth:Integer; pBlockPtr:SoundPBPtr) ; Tool
$08,$0E;
PROCEDURE FFStopSound ( genMask:Integer) ; Tool $08,$0F;
FUNCTION GetSoundVolume ( genNumber:Integer) : Integer ; Tool $08,$0C;
FUNCTION GetTableAddress : Ptr ; Tool $08,$0B;
PROCEDURE ReadRamBlock ( destPtr:Ptr; docStart:Integer; byteCount:Integer) ;
Tool $08,$0A;
PROCEDURE SetSoundMIRQV ( sMasterIRQ:Longint) ; Tool $08,$12;
PROCEDURE SetSoundVolume ( volume:Integer; genNumber:Integer) ; Tool $08,$0D;
FUNCTION SetUserSoundIRQV ( userIRQVector:Longint) : Ptr ; Tool $08,$13;
PROCEDURE WriteRamBlock ( srcPtr:Ptr; docStart:Integer; byteCount:Integer) ;
Tool $08,$09;
PROCEDURE FFSetUpSound ( channelGen:Integer; paramBlockPtr:SoundPBPtr) ; Tool
$08,$15;
PROCEDURE FFStartPlaying ( genWord:Integer) ; Tool $08,$16;
PROCEDURE SetDOCReg ( pBlockPtr:DocRegParamBlk) ; Tool $08,$17;
PROCEDURE ReadDOCReg (VAR pBlockPtr:DocRegParamBlk) ; Tool $08,$18;
IMPLEMENTATION
END.

154
pascal/stdfile.p Executable file
View File

@ -0,0 +1,154 @@
{********************************************
; File: StdFile.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT STDFILE;
INTERFACE
USES Types, QuickDraw, Events, Controls, Windows, LineEdit, Dialogs;
CONST
noDisplay = $0000; {filterProc result - file not to be displayed }
noSelect = $0001; {filterProc result - file displayed, but not selectable }
displaySelect = $0002; {filterProc result - file displayed and selectable }
sfMatchFileType = $8000; { - }
sfMatchAuxType = $4000; { - }
sfDisplayGrey = $2000; { - }
TYPE
SFReplyRecPtr = ^SFReplyRec;
SFReplyRec = RECORD
good : Boolean;
fileType : Integer;
auxFileType : Integer;
filename : String[15];
fullPathname : String[128];
END;
SFReplyRec2Hndl = ^SFReplyRec2Ptr;
SFReplyRec2Ptr = ^SFReplyRec2;
SFReplyRec2 = RECORD
good : Boolean;
filetype : Integer;
auxType : Longint;
nameDesc : RefDescriptor;
nameRef : Ref;
pathDesc : RefDescriptor;
pathRef : Ref;
END;
multiReplyRecord = RECORD
good : Integer;
namesHandle : Handle;
END;
SFTypeListHandle = ^SFTypeListPtr;
SFTypeListPtr = ^SFTypeList;
SFTypeList = PACKED RECORD
numEntries : Byte;
fileTypeEntries : PACKED ARRAY[1..5] OF Byte;
END;
TypeSelector2 = RECORD
flags : Integer;
fileType : Integer;
auxType : Longint;
END;
SFTypeList2Ptr = ^SFTypeList2;
SFTypeList2 = RECORD
numEntries : Integer;
fileTypeEntries : ARRAY[1..5] OF TypeSelector2;
END;
PROCEDURE SFBootInit ; Tool $17,$01;
PROCEDURE SFStartUp ( userID:Integer; dPageAddr:Integer) ; Tool $17,$02;
PROCEDURE SFShutDown ; Tool $17,$03;
FUNCTION SFVersion : Integer ; Tool $17,$04;
PROCEDURE SFReset ; Tool $17,$05;
FUNCTION SFStatus : Boolean ; Tool $17,$06;
PROCEDURE SFAllCaps ( allCapsFlag:Boolean) ; Tool $17,$0D;
PROCEDURE SFGetFile
PROCEDURE SFGetFile2
PROCEDURE SFMultiGet2 ( whereX:Integer;
PROCEDURE SFPGetFile ( whereX:Integer;
PROCEDURE SFPGetFile2 ( whereX:Integer;
PROCEDURE SFPMultiGet2 ( whereX:Integer;
PROCEDURE SFPPutFile ( whereX:Integer;
PROCEDURE SFPPutFile2
PROCEDURE SFPutFile ( whereX:Integer;
PROCEDURE SFPutFile2 ( whereX:Integer;
FUNCTION SFShowInvisible ( invisibleState:Boolean) : Boolean ; Tool $17,$12;
PROCEDURE SFReScan ( filterProcPtr:ProcPtr; typeListPtr:SFTypeList2Ptr) ; Tool
$17,$13;
IMPLEMENTATION
END.

343
pascal/textedit.p Executable file
View File

@ -0,0 +1,343 @@
{********************************************
; File: TextEdit.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT TEXTEDIT;
INTERFACE
USES TYPES,MEMORY,QUICKDRAW,EVENTS,CONTROLS,FONTS,GSOS,RESOURCES;
CONST
(* *** Toolset Errors ***
teAlreadyStarted = $2201; {error - }
teNotStarted = $2202; {error - }
teInvalidHandle = $2203; {error - }
teInvalidVerb = $2204; {error - }
teInvalidFlag = $2205; {error - }
teInvalidPCount = $2206; {error - }
teInvalidRect = $2207; {error - }
teBufferOverflow = $2208; {error - }
teInvalidLine = $2209; { - }
teInvalidCall = $220A; { - }
*** Toolset Errors *** *)
NullVerb = $0; {TE - }
PStringVerb = $0001; {TE - }
CStringVerb = $0002; {TE - }
C1InputVerb = $0003; {TE - }
C1OutputVerb = $0004; {TE - }
HandleVerb = $0005; {TE - }
PointerVerb = $0006; {TE - }
NewPStringVerb = $0007; {TE - }
fEqualLineSpacing = $8000; {TE - }
fShowInvisibles = $4000; {TE - }
teInvalidDescriptor = $2204; { - }
teInvalidParameter = $220B; { - }
teInvalidTextBox2 = $220C; { - }
teEqualLineSpacing = $8000; { - }
teShowInvisibles = $4000; { - }
teJustLeft = $0; { - }
teJustRight = $1; { - }
teJustCenter = $2; { - }
teJustFull = $3; { - }
teNoTabs = $0; { - }
teColumnTabs = $1; { - }
teAbsoluteTabs = $2; { - }
teLeftTab = $0; { - }
teCenterTab = $1; { - }
teRightTab = $2; { - }
teDecimalTab = $3; { - }
teInvis = $4000; { - }
teCtlColorIsPtr = $0000; { - }
teCtlColorIsHandle = $0004; { - }
teCtlColorIsResource = $0008; { - }
teCtlStyleIsPtr = $0000; { - }
teCtlStyleIsHandle = $0001; { - }
teCtlStyleIsResource = $0002; { - }
teNotControl = $80000000; { - }
teSingleFormat = $40000000; { - }
teSingleStyle = $20000000; { - }
teNoWordWrap = $10000000; { - }
teNoScroll = $08000000; { - }
teReadOnly = $04000000; { - }
teSmartCutPaste = $02000000; { - }
teTabSwitch = $01000000; { - }
teDrawBounds = $00800000; { - }
teColorHilite = $00400000; { - }
teRefIsPtr = $0000; { - }
teRefIsHandle = $0001; { - }
teRefIsResource = $0002; { - }
teRefIsNewHandle = $0003; { - }
teDataIsPString = $0000; { - }
teDataIsCString = $0001; { - }
teDataIsC1Input = $0002; { - }
teDataIsC1Output = $0003; { - }
teDataIsTextBox2 = $0004; { - }
teDataIsTextBlock = $0005; { - }
teTextIsPtr = $0000; { - }
teTextIsHandle = $0008; { - }
teTextIsResource = $0010; { - }
teTextIsNewHandle = $0018; { - }
tePartialLines = $8000; { - }
teDontDraw = $4000; { - }
teUseFont = $0020; { - }
teUseSize = $0010; { - }
teUseForeColor = $0008; { - }
teUseBackColor = $0004; { - }
teUseUserData = $0002; { - }
teUseAttributes = $0001; { - }
teReplaceFont = $0040; { - }
teReplaceSize = $0020; { - }
teReplaceForeColor = $0010; { - }
teReplaceBackColor = $0008; { - }
teReplaceUserField = $0004; { - }
teReplaceAttributes = $0002; { - }
teSwitchAttributes = $0001; { - }
teEraseRect = $0001; { - }
teEraseBuffer = $0002; { - }
teRectChanged = $0003; { - }
doEraseRect = $0001; { - }
doEraseBuffer = $0002; { - }
doRectChanged = $0003; { - }
doKeyStroke = $0004; { - }
TYPE
TEColorTablePtr = ^TEColorTable;
TEColorTable = RECORD
contentColor : Integer;
outlineColor : Integer;
pageBoundaryColor : Integer;
hiliteForeColor : Integer;
hiliteBackColor : Integer;
vertColorDescriptor : Integer;
vertColorRef : Longint;
horzColorDescriptor : Integer;
horzColorRef : Longint;
growColorDescriptor : Integer;
growColorRef : Longint;
END;
TEBlockEntry = RECORD
text : Handle;
length : Handle;
flags : Integer;
END;
TEBlocksHndl = ^TEBlocksPtr;
TEBlocksPtr = ^TEBlocksRecord;
TEBlocksRecord = RECORD
start : Longint;
index : Integer;
blocks : ARRAY[1..1] OF TEBlockEntry;
END;
TEHandle = ^TERecordPtr;
TERecordPtr = ^TERecord;
TERecord = PACKED RECORD
ctlNext : CtlRecHndl;
ctlOwner : WindowPtr;
ctlRect : Rect;
ctlFlag : Byte;
ctlHilite : Byte;
ctlValue : Integer;
ctlProc : ProcPtr;
ctlAction : ProcPtr;
ctlData : Longint;
ctlRefCon : Longint;
ctlColorRef : TEColorTablePtr;
ctlID : Longint;
ctlMoreFlags : Integer;
ctlVersion : Integer;
theChar : Integer;
theModifiers : Integer;
extendFlag : Integer;
moveByWord : Integer;
inputPtr : Ptr;
inputLength : Longint;
theRect : Rect;
END;
TETabItem = RECORD
tabKind : Integer;
tabData : Integer;
END;
TERuler = RECORD
leftMargin : Integer;
leftIndent : Integer;
rightMargin : Integer;
just : Integer;
extraLS : Integer;
flags : Integer;
userData : Integer;
tabType : Integer;
tabs : ARRAY[1..1] OF TETabItem;
tabTerminator : Integer;
END;
TEStyle = RECORD
teFont : FontID;
foreColor : Integer;
backColor : Integer;
reserved : Longint;
END;
TEStyleGroupHndl = ^TEStyleGroupPtr;
TEStyleGroupPtr = ^TEStyleGroup;
TEStyleGroup = RECORD
count : Integer;
styles : ARRAY[1..1] OF TEStyle;
END;
TEStyleItem = RECORD
length : Longint;
offset : Longint;
END;
TEFormatHndl = ^TEFormatPtr;
TEFormatPtr = ^TEFormat;
TEFormat = RECORD
version : Integer;
rulerListLength : Longint;
theRulerList : ARRAY[1..1] OF TERuler;
styleListLength : Longint;
theStyleList : ARRAY[1..1] OF TEStyle;
numberOfStyles : Longint;
theStyles : ARRAY[1..1] OF TEStyleItem;
END;
TETextRef = RECORD CASE INTEGER OF
$0000:(textIsPStringPtr:StringPtr);
$0001:(textIsCStringPtr:CStringPtr);
$0002:(textIsC1InputPtr:GSString255Ptr);
$0003:(textIsC1OutputPtr:ResultBuf255Ptr);
$0004:(textIsTB2Ptr:Ptr);
$0005:(textIsRawPtr:Ptr);
$0008:(textIsPStringHandle:String255Hndl);
$0009:(textIsCStringHandle:CStringHndl);
$000A:(textIsC1InputHandle:GSString255Hndl);
$000B:(textIsC1OutputHandle:ResultBuf255Hndl);
$000C:(textIsTB2Handle:Handle);
$000D:(textIsRawHandle:Handle);
$0010:(textIsPStringResource: ResID);
$0011:(textIsCStringResource: ResID);
$0012:(textIsC1InputResource: ResID);
$0013:(textIsC1OutputResource: ResID);
$0014:(textIsTB2Resource: ResID);
$0015:(textIsRawResource: ResID);
$0018:(textIsPStringNewH:String255HndlPtr);
$0019:(textIsCStringNewH:CStringHndlPtr);
$001A:(textIsC1InputNewH:GSString255HndlPtr);
$001B:(textIsC1OutputNewH:ResultBuf255HndlPtr);
$001C:(textIsTB2NewH:HandlePtr);
$001D:(textIsRawNewH:HandlePtr);
END;
TEStyleRef = RECORD CASE INTEGER OF
$0000:(styleIsPtr:TEFormatPtr);
$0001:(styleIsHandle:TEFormatHndl);
$0002:(styleIsResource:ResID);
$0003:(styleIsNewH:^TEFormatHndl);
END;
TEParamBlockHndl = ^TEParamBlockPtr;
TEParamBlockPtr = ^TEParamBlock;
TEParamBlock = RECORD
pCount : Integer;
controlID : Longint;
boundsRect : Rect;
procRef : Longint;
flags : Integer;
moreflags : Integer;
refCon : Longint;
textFlags : Longint;
indentRect : Rect;
vertBar : CtlRecHndl;
vertScroll : Integer;
horzBar : CtlRecHndl;
horzScroll : Integer;
styleRef : TEStyleRef;
textDescriptor : Integer;
textRef : TETextRef;
textLength : Longint;
maxChars : Longint;
maxLines : Longint;
maxHeight : Integer;
pageHeight : Integer;
headerHeight : Integer;
footerHeight : Integer;
pageBoundary : Integer;
colorRef : Longint;
drawMode : Integer;
filterProcPtr : ProcPtr;
END;
TEInfoRec = RECORD
charCount : Longint;
lineCount : Longint;
formatMemory : Longint;
totalMemory : Longint;
styleCount : Longint;
rulerCount : Longint;
END;
TEHooks = RECORD
charFilter : ProcPtr;
wordWrap : ProcPtr;
wordBreak : ProcPtr;
drawText : ProcPtr;
eraseText : ProcPtr;
END;
PROCEDURE TEBootInit ; Tool $22,$01;
PROCEDURE TEStartup ( userId:Integer; directPage:Integer) ; Tool $22,$02;
PROCEDURE TEShutdown ; Tool $22,$03;
FUNCTION TEVersion : Integer ; Tool $22,$04;
PROCEDURE TEReset ; Tool $22,$05;
FUNCTION TEStatus : Integer ; Tool $22,$06;
PROCEDURE TEActivate ( teH:TEHandle) ; Tool $22,$0F;
PROCEDURE TEClear ( teH:TEHandle) ; Tool $22,$19;
PROCEDURE TEClick (VAR theEventPtr:EventRecord; teH:TEHandle) ; Tool $22,$11;
PROCEDURE TECut ( teH:TEHandle) ; Tool $22,$16;
PROCEDURE TECopy ( teH:TEHandle) ; Tool $22,$17;
PROCEDURE TEDeactivate ( teH:TEHandle) ; Tool $22,$10;
FUNCTION TEGetDefProc : ProcPtr ; Tool $22,$22;
PROCEDURE TEGetHooks (VAR hooks:TEHooks; count:Integer; teH:TEHandle) ; Tool
$22,$20;
PROCEDURE TEGetSelection (VAR selStart:Longint;VAR selEnd:Longint;
teH:TEHandle) ; Tool $22,$1C;
FUNCTION TEGetSelectionStyle (VAR commonStyle:TEStyle;
styleHandle:TEStyleGroupHndl; teH:TEHandle) : Integer ; Tool $22,$1E;
FUNCTION TEGetText ( bufferDesc:Integer; bufferRef:TETextRef;
bufferLength:Longint; styleDesc:Integer; styleRef:TEStyleRef; teH:TEHandle) :
Longint ; Tool $22,$0C;
PROCEDURE TEGetTextInfo (VAR infoRec:TEInfoRec; pCount:Integer; teH:TEHandle)
; Tool $22,$0D;
PROCEDURE TEIdle ( teH:TEHandle) ; Tool $22,$0E;
PROCEDURE TEInsert ( textDesc:Integer; textRef:TETextRef; textLength:Longint;
styleDesc:Integer; styleRef:TEStyleRef; teH:TEHandle) ; Tool $22,$1A;
PROCEDURE TEInsertPageBreak ( teH:TEHandle) ; Tool $22,$15;
PROCEDURE TEKey ( theEventPtr:EventRecord; teH:TEHandle) ; Tool $22,$14;
PROCEDURE TEKill ( teH:TEHandle) ; Tool $22,$0A;
FUNCTION TENew ( theParms:TEParamBlock) : TEHandle ; Tool $22,$09;
FUNCTION TEPaintText ( thePort:GrafPortPtr; start:Longint; destRect:rect;
paintFlags:Integer; teH:TEHandle) : Longint ; Tool $22,$13;
PROCEDURE TEPaste ( teH:TEHandle) ; Tool $22,$18;
PROCEDURE TEReplace ( textDesc:Integer; textRef:TETextRef; textLength:Longint;
styleDesc:Integer; styleRef:TEStyleRef; teH:TEHandle) ; Tool $22,$1B;
PROCEDURE TESetHooks ( hooks:TEHooks; count:Integer; teH:TEHandle) ; Tool
$22,$21;
PROCEDURE TESetSelection ( selStart:Longint; selEnd:Longint; teH:TEHandle) ;
Tool $22,$1D;
PROCEDURE TESetText ( textDesc:Integer; textRef:TETextRef; textLength:Longint;
styleDesc:Integer; styleRef:TEStyleRef; teH:TEHandle) ; Tool $22,$0B;
PROCEDURE TEStyleChange ( flags:Integer; newStyle:TEStyle; teH:TEHandle) ;
Tool $22,$1F;
PROCEDURE TEUpdate ( teH:TEHandle) ; Tool $22,$12;
PROCEDURE TEGetRuler ( rulerDescriptor:Integer; rulerRef:Ref; teH:TEHandle) ;
Tool $22,$23;
PROCEDURE TEOffsetToPoint ( textOffset:Longint; vertPosPtr:Ptr; horzPosPtr:Ptr;
teH:TEHandle) ; Tool $22,$20;
FUNCTION TEPointToOffset ( vertPosPtr:Ptr; horzPosPtr:Ptr; teH:TEHandle) :
Longint ; Tool $22,$21;
FUNCTION TEScroll ( scrollDescriptor:Integer; vertAmount:Longint;
horzAmount:Longint; teH:TEHandle) : Longint ; Tool $22,$25;
PROCEDURE TESetRuler ( rulerDescriptor:Integer; rulerRef:Ref; teH:TEHandle);
Tool $22,$24;
IMPLEMENTATION
END.

104
pascal/types.p Executable file
View File

@ -0,0 +1,104 @@
{********************************************
; File: Types.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT TYPES;
INTERFACE
CONST
noError = $0000;
refIsPointer = $0000; {RefDescriptor - }
refIsHandle = $0001; {RefDescriptor - }
refIsResource = $0002; {RefDescriptor - }
refIsNewHandle = $0003; {RefDescriptor - }
TYPE
Byte = 0..255;
Fixed = Longint ;
Frac = Longint ;
ExtendedPtr = ^Extended;
SignedByte = -128..127;
PackedByte = PACKED ARRAY [1..1] of SignedByte;
Ptr = ^PackedByte;
PointerPtr = ^Ptr;
Handle = ^Ptr;
HandlePtr = ^Handle;
CStringPtr = Ptr;
CStringHndl = ^CStringPtr;
CStringHndlPtr = ^CStringHndl;
ProcPtr = Ptr;
VoidProcPtr = ProcPtr;
WordProcPtr = ProcPtr;
LongProcPtr = ProcPtr;
IntPtr = ^Integer;
FPTPtr = Ptr ;
String255 = STRING[255];
String255Ptr = ^String255;
String255Hndl = ^String255Ptr;
String255HndlPtr = ^String255Hndl;
Str255 = String255;
StringPtr = String255Ptr;
StringHandle = ^StringPtr;
String32 = STRING[32];
String32Ptr = ^String32;
String32Handle = ^String32Ptr;
Str32 = String32;
PointPtr = ^Point;
Point = RECORD
v : Integer;
h : Integer;
END;
RectHndl = ^RectPtr;
RectPtr = ^Rect;
Rect = RECORD
CASE INTEGER OF
1:
(top: Integer;
left: Integer;
bottom: Integer;
right: Integer);
2:
(topLeft: Point;
botRight: Point);
3: (
v1 : Integer;
h1 : Integer;
v2 : Integer;
h2 : Integer);
END;
TimeRecHndl = ^TimeRecPtr;
TimeRecPtr = ^TimeRec;
TimeRec = PACKED RECORD
second : Byte;
minute : Byte;
hour : Byte;
year : Byte;
day : Byte;
month : Byte;
extra : Byte;
weekDay : Byte;
END;
RefDescriptor = Integer;
Ref = RECORD
CASE Integer OF
refIsPointer : ( refIsPointer : Ptr ) ;
refIsHandle : ( refIsHandle : Handle ) ;
refIsResource : ( refIsResource : Longint ) ;
refIsNewHandle : ( refIsNewHandle : Handle ) ;
END;
IMPLEMENTATION
END.

119
pascal/video.p Executable file
View File

@ -0,0 +1,119 @@
{********************************************
; File: Video.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT VIDEO;
INTERFACE
USES TYPES;
CONST
vdVideoOverlay = $01; { - }
vdFrameGrabber = $02; { - }
vdInVStandards = $03; { - }
vdOutVStandards = $04; { - }
vdKeyDissLevels = $05; { - }
vdNKeyDissLevels = $06; { - }
vdAdjSideEffect = $07; { - }
vdKeyColorBits = $08; { - }
vdInHueAdj = $09; { - }
vdInSatAdj = $0A; { - }
vdInContrastAdj = $0B; { - }
vdInBrightAdj = $0C; { - }
vdOutSetup = $0D; { - }
vdOutChromaFilter = $0E; { - }
vdOutExtBlank = $0F; { - }
vdKeyEnhDiss = $10; { - }
vdLineInterrupt = $11; { - }
vdGGBus = $12; { - }
vdDualOut = $13; { - }
vdTextMonoOver = $14; { - }
vdGenlock = $32; { - }
vdVideoDetect = $33; { - }
vdGenlocked = $34; { - }
vdAdjInc = $50; { - }
vdAdjDec = $51; { - }
vdAdjSave = $52; { - }
vdAvail = $01; { - }
vdNotAvail = $00; { - }
vdYes = $01; { - }
vdNo = $00; { - }
vdOn = $01; { - }
vdOff = $00; { - }
vdKColorEnable = $64; { - }
vdVerticalBlank = $82; { - }
vdMainPageLin = $C8; { - }
vdRAMPageSel = $C9; { - }
vdVBLInterrupt = $CA; { - }
vdInterlaceMode = $CB; { - }
vdClearVBLInt = $CC; { - }
vdClearLineInt = $CD; { - }
vdDisplayField = $CE; { - }
vdVBLIntRequest = $CF; { - }
vdLineIntRequest = $D0; { - }
vdNone = $00; { - }
vdNTSC = $01; { - }
vdPAL = $02; { - }
vdSECAM = $04; { - }
vdSNTSC = $08; { - }
vdSPAL = $10; { - }
vdSSECAM = $20; { - }
vdRGB60 = $40; { - }
vdRGB50 = $80; { - }
vdAux = $00; { - }
vdMain = $10; { - }
vdInterlace = $30; { - }
vdField1 = $01; { - }
vdField0 = $00; { - }
vdEnable = $01; { - }
vdDisable = $00; { - }
vdExternal = $00; { - }
vdGraphics = $01; { - }
vdVBlank = $01; { - }
vdActiveVideo = $00; { - }
vdNoVideoDevice = $2110; {Error - no video device was found }
vdAlreadyStarted = $2111; {Error - Video tool set already started }
vdInvalidSelector = $2112; {Error - an invalid selector was specified }
vdInvalidParam = $2113; {Error - an invalid parameter was specified }
vdUnImplemented = $21FF; {Error - an unimplemented tool set routine was called
}
PROCEDURE VDBootInit ; Tool $21,$01;
PROCEDURE VDStartUp ; Tool $21,$02;
PROCEDURE VDShutdown ; Tool $21,$03;
FUNCTION VDVersion : Integer ; Tool $21,$04;
PROCEDURE VDReset ; Tool $21,$05;
FUNCTION VDStatus : Boolean ; Tool $21,$06;
FUNCTION VDGetFeatures ( videoSelector:Integer) : Integer ; Tool $21,$1B;
PROCEDURE VDInControl ( videoSelector:Integer; inputCtlValue:Integer) ; Tool
$21,$1C;
FUNCTION VDInStatus ( videoSelector:Integer) : Integer ; Tool $21,$09;
PROCEDURE VDInSetStd ( inputStandard:Integer) ; Tool $21,$0A;
FUNCTION VDInGetStd : Integer ; Tool $21,$0B;
PROCEDURE VDInConvAdj ( videoSelector:Integer; adjustFunction:Integer) ; Tool
$21,$0C;
PROCEDURE VDKeyControl ( videoSelector:Integer; keyerCtlValue:Integer) ; Tool
$21,$0D;
FUNCTION VDKeyStatus ( videoSelector:Integer) : Integer ; Tool $21,$0E;
PROCEDURE VDKeySetKCol ( redValue:Integer; greenValue:Integer;
blueValue:Integer) ; Tool $21,$0F;
FUNCTION VDKeyGetRCol : Integer ; Tool $21,$10;
FUNCTION VDKeyGetGCol : Integer ; Tool $21,$11;
FUNCTION VDKeyGetBCol : Integer ; Tool $21,$12;
PROCEDURE VDKeySetKDiss ( kDissolve:Integer) ; Tool $21,$13;
FUNCTION VDKeyGetKDiss : Integer ; Tool $21,$14;
PROCEDURE VDKeySetNKDiss ( nonKeyDissolve:Integer) ; Tool $21,$15;
FUNCTION VDKeyGetNKDiss : Integer ; Tool $21,$16;
PROCEDURE VDOutSetStd ( outStandard:Integer) ; Tool $21,$17;
FUNCTION VDOutGetStd : Integer ; Tool $21,$18;
PROCEDURE VDOutControl ( videoSelector:Integer; outCtlValue:Integer) ; Tool
$21,$19;
FUNCTION VDOutStatus ( videoSelector:Integer) : Integer ; Tool $21,$1A;
PROCEDURE VDGGControl ( videoSelector:Integer; gGCtlValue:Integer) ; Tool
$21,$1D;
FUNCTION VDGGStatus ( videoSelector:Integer) : Integer ; Tool $21,$1E;
IMPLEMENTATION
END.

301
pascal/windows.p Executable file
View File

@ -0,0 +1,301 @@
{********************************************
; File: Windows.p
;
;
; Copyright Apple Computer, Inc. 1986-89
; All Rights Reserved
;
********************************************}
UNIT WINDOWS;
INTERFACE
USES TYPES,QUICKDRAW,EVENTS,CONTROLS;
CONST
(* *** Toolset Errors ***
paramLenErr = $0E01; {error - first word of parameter list is the wrong size }
allocateErr = $0E02; {error - unable to allocate window record }
taskMaskErr = $0E03; {error - bits 12-15 are not clear in WmTaskMask field of
EventRecord }
*** Toolset Errors *** *)
wNoConstraint = $0000; {Axis parameter - No constraint on movement. }
wHAxisOnly = $0001; {Axis parameter - Horizontal axis only. }
wVAxisOnly = $0002; {Axis parameter - Vertical axis only. }
FromDesk = $00; {Desktop Command - Subtract region from desktop }
ToDesk = $1; {Desktop Command - Add region to desktop }
GetDesktop = $2; {Desktop Command - Get Handle of Desktop region }
SetDesktop = $3; {Desktop Command - Set Handle of Desktop region }
GetDeskPat = $4; {Desktop command - Address of pattern or drawing routine }
SetDeskPat = $5; {Desktop command - Change Address of pattern or drawing
routine }
GetVisDesktop = $6; {Desktop command - Get destop region less visible windows.
}
BackGroundRgn = $7; {Desktop command - For drawing directly on desktop. }
toBottom = $FFFFFFFE; {SendBehind value - To send window to bottom. }
topMost = $FFFFFFFF; {SendBehind value - To make window top. }
bottomMost = $0000; {SendBehind value - To make window bottom. }
tmMenuKey = $0001; {Task Mask - }
tmUpdate = $0002; {Task Mask - }
tmFindW = $0004; {Task Mask - }
tmMenuSel = $0008; {Task Mask - }
tmOpenNDA = $0010; {Task Mask - }
tmSysClick = $0020; {Task Mask - }
tmDragW = $0040; {Task Mask - }
tmContent = $0080; {Task Mask - }
tmClose = $0100; {Task Mask - }
tmZoom = $0200; {Task Mask - }
tmGrow = $0400; {Task Mask - }
tmScroll = $0800; {Task Mask - }
tmSpecial = $1000; {Task Mask - }
tmCRedraw = $2000; {Task Mask - }
tmInactive = $4000; {Task Mask - }
tmInfo = $8000; {Task Mask - }
wNoHit = $0000; {TaskMaster codes - retained for back compatibility. }
inNull = $0000; {TaskMaster codes - retained for back compatibility }
inKey = $0003; {TaskMaster codes - retained for back compatibility }
inButtDwn = $0001; {TaskMaster codes - retained for back compatibility }
inUpdate = $0006; {TaskMaster codes - retained for back compatibility }
wInDesk = $0010; {TaskMaster codes - On Desktop }
wInMenuBar = $0011; {TaskMaster codes - On system menu bar }
wClickCalled = $0012; {TaskMaster codes - system click called }
wInContent = $0013; {TaskMaster codes - In content region }
wInDrag = $0014; {TaskMaster codes - In drag region }
wInGrow = $0015; {TaskMaster codes - In grow region, active window only }
wInGoAway = $0016; {TaskMaster codes - In go-away region, active window only }
wInZoom = $0017; {TaskMaster codes - In zoom region, active window only }
wInInfo = $0018; {TaskMaster codes - In information bar }
wInSpecial = $0019; {TaskMaster codes - Item ID selected was 250 - 255 }
wInDeskItem = $001A; {TaskMaster codes - Item ID selected was 1 - 249 }
wInFrame = $1B; {TaskMaster codes - in Frame, but not on anything else }
wInactMenu = $1C; {TaskMaster codes - "selection" of inactive menu item }
wClosedNDA = $001D; {TaskMaster codes - desk accessory closed }
wCalledSysEdit = $001E; {TaskMaster codes - inactive menu item selected }
wInSysWindow = $8000; {TaskMaster codes - hi bit set for system windows }
wDraw = $00; {VarCode - Draw window frame command. }
wHit = $01; {VarCode - Hit test command. }
wCalcRgns = $02; {VarCode - Compute regions command. }
wNew = $03; {VarCode - Initialization command. }
wDispose = $04; {VarCode - Dispose command. }
fHilited = $0001; {WFrame - Window is highlighted. }
fZoomed = $0002; {WFrame - Window is zoomed. }
fAllocated = $0004; {WFrame - Window record was allocated. }
fCtlTie = $0008; {WFrame - Window state tied to controls. }
fInfo = $0010; {WFrame - Window has an information bar. }
fVis = $0020; {WFrame - Window is visible. }
fQContent = $0040; {WFrame - }
fMove = $0080; {WFrame - Window is movable. }
fZoom = $0100; {WFrame - Window is zoomable. }
fFlex = $0200; {WFrame - }
fGrow = $0400; {WFrame - Window has grow box. }
fBScroll = $0800; {WFrame - Window has horizontal scroll bar. }
fRScroll = $1000; {WFrame - Window has vertical scroll bar. }
fAlert = $2000; {WFrame - }
fClose = $4000; {WFrame - Window has a close box. }
fTitle = $8000; {WFrame - Window has a title bar. }
windSize = $145; {WindRec - Size of WindRec. }
wmTaskRecSize = $0046; {WmTaskRec - Size of WmTaskRec. }
wTrackZoom = $001F; { - }
wHitFrame = $0020; { - }
wInControl = $0021; { - }
TYPE
WmTaskRec = EventRecord ;
WmTaskRecPtr = EventRecordPtr ;
WindColorHndl = ^WindColorPtr;
WindColorPtr = ^WindColor;
WindColor = RECORD
frameColor : Integer; { Color of window frame. }
titleColor : Integer; { Color of title and bar. }
tBarColor : Integer; { Color/pattern of title bar. }
growColor : Integer; { Color of grow box. }
infoColor : Integer; { Color of information bar. }
END;
WindRecPtr = ^WindRec;
WindRec = RECORD
port : GrafPort; { Window's port }
wDefProc : ProcPtr;
wRefCon : Longint;
wContDraw : ProcPtr;
wReserved : Longint; { Space for future expansion }
wStrucRgn : RgnHandle; { Region of frame plus content. }
wContRgn : RgnHandle; { Content region. }
wUpdateRgn : RgnHandle; { Update region. }
wControls : CtlRecHndl; { Window's control list. }
wFrameCtrls : CtlRecHndl; { Window frame's control list. }
wFrame : Integer;
END;
WindowChainPtr = ^WindowChain;
WindowChain = RECORD
wNext : WindowChainPtr;
theWindow : WindRec;
END;
ParamListHndl = ^ParamListPtr;
ParamListPtr = ^ParamList;
ParamList = RECORD
paramLength : Integer; { Parameter to NewWindow. }
wFrameBits : Integer; { Parameter to NewWindow. }
wTitle : Ptr; { Parameter to NewWindow. }
wRefCon : Longint; { Parameter to NewWindow. }
wZoom : Rect; { Parameter to NewWindow. }
wColor : WindColorPtr; { Parameter to NewWindow. }
wYOrigin : Integer; { Parameter to NewWindow. }
wXOrigin : Integer; { Parameter to NewWindow. }
wDataH : Integer; { Parameter to NewWindow. }
wDataW : Integer; { Parameter to NewWindow. }
wMaxH : Integer; { Parameter to NewWindow. }
wMaxW : Integer; { Parameter to NewWindow. }
wScrollVer : Integer; { Parameter to NewWindow. }
wScrollHor : Integer; { Parameter to NewWindow. }
wPageVer : Integer; { Parameter to NewWindow. }
wPageHor : Integer; { Parameter to NewWindow. }
wInfoRefCon : Longint; { Parameter to NewWindow. }
wInfoHeight : Integer; { height of information bar }
wFrameDefProc : LongProcPtr; { Parameter to NewWindow. }
wInfoDefProc : VoidProcPtr; { Parameter to NewWindow. }
wContDefProc : VoidProcPtr; { Parameter to NewWindow. }
wPosition : Rect; { Parameter to NewWindow. }
wPlane : WindowPtr; { Parameter to NewWindow. }
wStorage : WindowChainPtr; { Parameter to NewWindow. }
END;
DeskMessageRecordPtr = ^DeskMessageRecord;
DeskMessageRecord = RECORD
reserved : Longint;
messageType : Integer;
drawType : Integer;
END;
FUNCTION AlertWindow ( alertFlags:Integer; subStrPtr:Ptr; alertStrPtr:Ref) :
Integer ; Tool $0E,$59;
PROCEDURE DrawInfoBar ( theWindowPtr:WindowPtr) ; Tool $0E,$55;
PROCEDURE EndFrameDrawing ; Tool $0E,$5B;
FUNCTION GetWindowMgrGlobals : Longint ; Tool $0E,$58;
PROCEDURE ResizeWindow ( hiddenFlag:Integer; U__rectPtr:Rect;
theWindowPtr:WindowPtr) ; Tool $0E,$5C;
PROCEDURE StartFrameDrawing ( windowPtr:Longint) ; Tool $0E,$5A;
PROCEDURE WindBootInit ; Tool $0E,$01;
PROCEDURE WindStartUp ( userID:Integer) ; Tool $0E,$02;
PROCEDURE WindShutDown ; Tool $0E,$03;
FUNCTION WindVersion : Integer ; Tool $0E,$04;
PROCEDURE WindReset ; Tool $0E,$05;
FUNCTION WindStatus : Boolean ; Tool $0E,$06;
PROCEDURE BeginUpdate ( theWindowPtr:WindowPtr) ; Tool $0E,$1E;
PROCEDURE BringToFront ( theWindowPtr:WindowPtr) ; Tool $0E,$24;
FUNCTION CheckUpdate ( theEventPtr:EventRecordPtr) : Boolean ; Tool $0E,$0A;
PROCEDURE CloseWindow ( theWindowPtr:WindowPtr) ; Tool $0E,$0B;
FUNCTION Desktop ( deskTopOP:Integer; dtParam:Longint) : Ptr ; Tool $0E,$0C;
PROCEDURE DragWindow ( grid:Integer; startX:Integer; startY:Integer;
grace:Integer; boundsRectPtr:RectPtr; theWindowPtr:WindowPtr) ; Tool $0E,$1A;
PROCEDURE EndInfoDrawing ; Tool $0E,$51;
PROCEDURE EndUpdate ( theWindowPtr:WindowPtr) ; Tool $0E,$1F;
FUNCTION FindWindow (VAR theWindowPtr:WindowPtr; pointX:Integer;
pointY:Integer) : Integer ; Tool $0E,$17;
FUNCTION FrontWindow : WindowPtr ; Tool $0E,$15;
FUNCTION GetContentDraw ( theWindowPtr:WindowPtr) : VoidProcPtr ; Tool $0E,$48;
FUNCTION GetContentOrigin ( theWindowPtr:WindowPtr) : Point ; Tool $0E,$3E;
FUNCTION GetContentRgn ( theWindowPtr:WindowPtr) : RgnHandle ; Tool $0E,$2F;
FUNCTION GetDataSize ( theWindowPtr:WindowPtr) : Longint ; Tool $0E,$40;
FUNCTION GetDefProc ( theWindowPtr:WindowPtr) : LongProcPtr ; Tool $0E,$31;
FUNCTION GetFirstWindow : WindowPtr ; Tool $0E,$52;
PROCEDURE GetFrameColor (VAR colorPtr:WindColorPtr; theWindowPtr:WindowPtr) ;
Tool $0E,$10;
FUNCTION GetInfoDraw ( theWindowPtr:WindowPtr) : VoidProcPtr ; Tool $0E,$4A;
FUNCTION GetInfoRefCon ( theWindowPtr:WindowPtr) : Longint ; Tool $0E,$35;
FUNCTION GetMaxGrow ( theWindowPtr:WindowPtr) : Longint ; Tool $0E,$42;
FUNCTION GetNextWindow ( theWindowPtr:WindowPtr) : WindowPtr ; Tool $0E,$2A;
FUNCTION GetPage ( theWindowPtr:WindowPtr) : Longint ; Tool $0E,$46;
PROCEDURE GetRectInfo (VAR infoRectPtr:Rect; theWindowPtr:WindowPtr) ; Tool
$0E,$4F;
FUNCTION GetScroll ( theWindowPtr:WindowPtr) : Longint ; Tool $0E,$44;
FUNCTION GetStructRgn ( theWindowPtr:WindowPtr) : RgnHandle ; Tool $0E,$2E;
FUNCTION GetSysWFlag ( theWindowPtr:WindowPtr) : Boolean ; Tool $0E,$4C;
FUNCTION GetUpdateRgn ( theWindowPtr:WindowPtr) : RgnHandle ; Tool $0E,$30;
FUNCTION GetWControls ( theWindowPtr:WindowPtr) : CtlRecHndl ; Tool $0E,$33;
FUNCTION GetWFrame ( theWindowPtr:WindowPtr) : Integer ; Tool $0E,$2C;
FUNCTION GetWKind ( theWindowPtr:WindowPtr) : Integer ; Tool $0E,$2B;
FUNCTION GetWMgrPort : WindowPtr ; Tool $0E,$20;
FUNCTION GetWRefCon ( theWindowPtr:WindowPtr) : Longint ; Tool $0E,$29;
FUNCTION GetWTitle ( theWindowPtr:WindowPtr) : Ptr ; Tool $0E,$0E;
FUNCTION GetZoomRect ( theWindowPtr:WindowPtr) : RectPtr ; Tool $0E,$37;
FUNCTION GrowWindow ( minWidth:Integer; minHeight:Integer; startX:Integer;
startY:Integer; theWindowPtr:WindowPtr) : Longint ; Tool $0E,$1B;
PROCEDURE HideWindow ( theWindowPtr:WindowPtr) ; Tool $0E,$12;
PROCEDURE HiliteWindow ( fHiliteFlag:Boolean; theWindowPtr:WindowPtr) ; Tool
$0E,$22;
PROCEDURE InvalRect ( badRectPtr:Rect) ; Tool $0E,$3A;
PROCEDURE InvalRgn ( badRgnHandle:RgnHandle) ; Tool $0E,$3B;
PROCEDURE MoveWindow ( newX:Integer; newY:Integer; theWindowPtr:WindowPtr) ;
Tool $0E,$19;
FUNCTION NewWindow ( theParamListPtr:ParamList) : WindowPtr ; Tool $0E,$09;
FUNCTION PinRect ( theXPt:Integer; theYPt:Integer; theRectPtr:Rect) : Point ;
Tool $0E,$21;
PROCEDURE RefreshDesktop ( redrawRect:RectPtr) ; Tool $0E,$39;
PROCEDURE SelectWindow ( theWindowPtr:WindowPtr) ; Tool $0E,$11;
PROCEDURE SendBehind ( behindWindowPtr:WindowPtr; theWindowPtr:WindowPtr) ;
Tool $0E,$14;
PROCEDURE SetContentDraw ( contentDrawPtr:VoidProcPtr; theWindowPtr:WindowPtr)
; Tool $0E,$49;
PROCEDURE SetContentOrigin ( xOrigin:Integer; yOrigin:Integer;
theWindowPtr:WindowPtr) ; Tool $0E,$3F;
PROCEDURE SetContentOrigin2 ( scrollFlag:Integer; xOrigin:Integer;
yOrigin:Integer; theWindowPtr:WindowPtr) ; Tool $0E,$57;
PROCEDURE SetDataSize ( dataWidth:Integer; dataHeight:Integer;
theWindowPtr:WindowPtr) ; Tool $0E,$41;
PROCEDURE SetDefProc ( wDefProcPtr:LongProcPtr; theWindowPtr:WindowPtr) ; Tool
$0E,$32;
PROCEDURE SetFrameColor ( newColorPtr:WindColorPtr; theWindowPtr:WindowPtr) ;
Tool $0E,$0F;
PROCEDURE SetInfoDraw ( infoRecCon:VoidProcPtr; theWindowPtr:WindowPtr) ; Tool
$0E,$16;
PROCEDURE SetInfoRefCon ( infoRefCon:Longint; theWindowPtr:WindowPtr) ; Tool
$0E,$36;
PROCEDURE SetMaxGrow ( maxWidth:Integer; maxHeight:Integer;
theWindowPtr:WindowPtr) ; Tool $0E,$43;
PROCEDURE SetOriginMask ( originMask:Integer; theWindowPtr:WindowPtr) ; Tool
$0E,$34;
PROCEDURE SetPage ( hPage:Integer; vPage:Integer; theWindowPtr:WindowPtr) ;
Tool $0E,$47;
PROCEDURE SetScroll ( hScroll:Integer; vScroll:Integer; theWindowPtr:WindowPtr)
; Tool $0E,$45;
PROCEDURE SetSysWindow ( theWindowPtr:WindowPtr) ; Tool $0E,$4B;
PROCEDURE SetWFrame ( wFrame:Integer; theWindowPtr:WindowPtr) ; Tool $0E,$2D;
FUNCTION SetWindowIcons ( newFontHandle:FontHndl) : FontHndl ; Tool $0E,$4E;
PROCEDURE SetWRefCon ( wRefCon:Longint; theWindowPtr:WindowPtr) ; Tool
$0E,$28;
PROCEDURE SetWTitle ( title:Str255; theWindowPtr:WindowPtr) ; Tool $0E,$0D;
PROCEDURE SetZoomRect ( wZoomSizePtr:Rect; theWindowPtr:WindowPtr) ; Tool
$0E,$38;
PROCEDURE ShowHide ( showFlag:Boolean; theWindowPtr:WindowPtr) ; Tool $0E,$23;
PROCEDURE ShowWindow ( theWindowPtr:WindowPtr) ; Tool $0E,$13;
PROCEDURE SizeWindow ( newWidth:Integer; newHeight:Integer;
theWindowPtr:WindowPtr) ; Tool $0E,$1C;
PROCEDURE StartDrawing ( theWindowPtr:WindowPtr) ; Tool $0E,$4D;
PROCEDURE StartInfoDrawing (VAR infoRectPtr:Rect; theWindowPtr:WindowPtr) ;
Tool $0E,$50;
FUNCTION TaskMaster ( taskMask:Integer; taskRecPtr:WmTaskRec) : Integer ; Tool
$0E,$1D;
FUNCTION TrackGoAway ( startX:Integer; startY:Integer; theWindowPtr:WindowPtr)
: Boolean ; Tool $0E,$18;
FUNCTION TrackZoom ( startX:Integer; startY:Integer; theWindowPtr:WindowPtr) :
Boolean ; Tool $0E,$26;
PROCEDURE ValidRect ( goodRectPtr:Rect) ; Tool $0E,$3C;
PROCEDURE ValidRgn ( goodRgnHandle:RgnHandle) ; Tool $0E,$3D;
FUNCTION WindDragRect ( actionProcPtr:VoidProcPtr; dragPatternPtr:Pattern;
startX:Integer; startY:Integer; dragRectPtr:Rect; limitRectPtr:Rect;
slopRectPtr:Rect; dragFlag:Integer) : Longint ; Tool $0E,$53;
PROCEDURE WindNewRes ; Tool $0E,$25;
FUNCTION WindowGlobal ( WindowGlobalMask:Integer) : Integer ; Tool $0E,$56;
PROCEDURE ZoomWindow ( theWindowPtr:WindowPtr) ; Tool $0E,$27;
FUNCTION TaskMasterDA ( eventMask:Integer; taskRecPtr:Ptr) : Integer ; Tool
$0E,$5F;
FUNCTION CompileText ( subType:Integer; subStringsPtr:Ptr; srcStringPtr:Ptr;
srcSize:Integer) : Handle ; Tool $0E,$60;
FUNCTION NewWindow2 ( titlePtr:StringPtr; refCon:Longint;
contentDrawPtr:ProcPtr; defProcPtr:ProcPtr; paramTableDesc:RefDescriptor;
paramTableRef:Ref; resourceType:Integer) : WindowPtr ; Tool $0E,$61;
FUNCTION ErrorWindow ( subType:Integer; subStringPtr:Ptr; errNum:Integer) :
Integer ; Tool $0E,$62;
IMPLEMENTATION
END.

144
prodos16.h Normal file
View File

@ -0,0 +1,144 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* The ProDOS 16 tool calls
*/
typedef struct {
uint16_t call;
const char *name;
} Prodos16;
static Prodos16 prodos16[] = {
{0x0001, "CREATE"},
{0x0002, "DESTROY"},
{0x0004, "CHANGE_PATH"},
{0x0005, "SET_FILE_INFO"},
{0x0006, "GET_FILE_INFO"},
{0x0008, "VOLUME"},
{0x0009, "SET_PREFIX"},
{0x000a, "GET_PREFIX"},
{0x000b, "CLEAR_BACKUP_BIT"},
{0x0010, "OPEN"},
{0x0011, "NEWLINE"},
{0x0012, "READ"},
{0x0013, "WRITE"},
{0x0014, "CLOSE"},
{0x0015, "FLUSH"},
{0x0016, "SET_MARK"},
{0x0017, "GET_MARK"},
{0x0018, "SET_EOF"},
{0x0019, "GET_EOF"},
{0x001a, "SET_LEVEL"},
{0x001b, "GET_LEVEL"},
{0x001c, "GET_DIR_ENTRY"},
{0x0020, "GET_DEV_NUM"},
{0x0021, "GET_LAST_DEV"},
{0x0022, "READ_BLOCK"},
{0x0023, "WRITE_BLOCK"},
{0x0024, "FORMAT"},
{0x0025, "ERASE_DISK"},
{0x0027, "GET_NAME"},
{0x0028, "GET_BOOT_VOL"},
{0x0029, "QUIT"},
{0x002a, "GET_VERSION"},
{0x002c, "D_INFO"},
{0x0031, "ALLOC_INTERRUPT"},
{0x0032, "DEALLOCATE_INTERRUPT"},
{0x0101, "Get_LInfo"},
{0x0102, "Set_LInfo"},
{0x0103, "Get_Lang"},
{0x0104, "Set_Lang"},
{0x0105, "Error"},
{0x0106, "Set_Variable"},
{0x0107, "Version"},
{0x0108, "Read_Indexed"},
{0x0109, "Init_Wildcard"},
{0x010a, "Next_Wildcard"},
{0x010b, "Read_Variable"},
{0x010c, "ChangeVector"},
{0x010d, "Execute"},
{0x010e, "FastFile"},
{0x010f, "Direction"},
{0x0110, "Redirect"},
{0x0113, "Stop"},
{0x0114, "ExpandDevices"},
{0x0115, "UnsetVariable"},
{0x0116, "Export"},
{0x0117, "PopVariables"},
{0x0118, "PushVariables"},
{0x0119, "SetStopFlag"},
{0x011a, "ConsoleOut"},
{0x011b, "SetIODevices"},
{0x011c, "GetIODevices"},
{0x011d, "GetCommand"},
{0x2001, "Create"},
{0x2002, "Destroy"},
{0x2003, "OSShutdown"},
{0x2004, "ChangePath"},
{0x2005, "SetFileInfo"},
{0x2006, "GetFileInfo"},
{0x2007, "JudgeName"},
{0x2008, "Volume"},
{0x2009, "SetPrefix"},
{0x200a, "GetPrefix"},
{0x200b, "ClearBackup"},
{0x200c, "SetSysPrefs"},
{0x200d, "Null"},
{0x200e, "ExpandPath"},
{0x200f, "GetSysPrefs"},
{0x2010, "Open"},
{0x2011, "NewLine"},
{0x2012, "Read"},
{0x2013, "Write"},
{0x2014, "Close"},
{0x2015, "Flush"},
{0x2016, "SetMark"},
{0x2017, "GetMark"},
{0x2018, "SetEOF"},
{0x2019, "GetEOF"},
{0x201a, "SetLevel"},
{0x201b, "GetLevel"},
{0x201c, "GetDirEntry"},
{0x201d, "BeginSession"},
{0x201e, "EndSession"},
{0x201f, "SessionStatus"},
{0x2020, "GetDevNumber"},
{0x2024, "Format"},
{0x2025, "EraseDisk"},
{0x2026, "ResetCache"},
{0x2027, "GetName"},
{0x2028, "GetBoolVol"},
{0x2029, "Quit"},
{0x202a, "GetVersion"},
{0x202b, "GetFSTInfo"},
{0x202c, "DInfo"},
{0x202d, "DStatus"},
{0x202e, "DControl"},
{0x202f, "DRead"},
{0x2030, "DWrite"},
{0x2031, "BindInt"},
{0x2032, "UnbindInt"},
{0x2033, "FSTSpecific"},
{0x2034, "AddNotifyProc"},
{0x2035, "DelNotifyProc"},
{0x2036, "DRename"},
{0x2037, "GetStdRefNum"},
{0x2038, "GetRefNum"},
{0x2039, "GetRefInfo"},
{0x203a, "SetStdRefNum"}
};
#define numProdos16 (sizeof(prodos16) / sizeof(prodos16[0]))
static const char *prodos16Lookup(uint16_t call) {
for (int i = 0; i < numProdos16; i++) {
if (prodos16[i].call >= call) {
if (prodos16[i].call == call)
return prodos16[i].name;
break;
}
}
return NULL;
}

56
prodos8.h Normal file
View File

@ -0,0 +1,56 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* Defines the ProDOS 8 tool calls
*/
typedef struct {
uint16_t call;
const char *name;
} Prodos8;
static Prodos8 prodos8[] = {
{0x0040, "ALLOC_INTERRUPT"},
{0x0041, "DEALLOC_INTERRUPT"},
{0x0042, "AppleTalk"},
{0x0043, "SpecialOpenFork"},
{0x0044, "ByteRangeLock"},
{0x0065, "QUIT"},
{0x0080, "READ_BLOCK"},
{0x0081, "WRITE_BLOCK"},
{0x0082, "GET_TIME"},
{0x00c0, "CREATE"},
{0x00c1, "DESTROY"},
{0x00c2, "RENAME"},
{0x00c3, "SetFileInfo"},
{0x00c4, "GetFileInfo"},
{0x00c5, "ONLINE"},
{0x00c6, "SET_PREFIX"},
{0x00c7, "GET_PREFIX"},
{0x00c8, "OPEN"},
{0x00c9, "NEWLINE"},
{0x00ca, "READ"},
{0x00cb, "WRITE"},
{0x00cc, "CLOSE"},
{0x00cd, "FLUSH"},
{0x00ce, "SET_MARK"},
{0x00cf, "GET_MARK"},
{0x00d0, "SET_EOF"},
{0x00d1, "GET_EOF"},
{0x00d2, "SET_BUF"},
{0x00d3, "GET_BUF"}
};
#define numProdos8 (sizeof(prodos8) / sizeof(prodos8[0]))
static const char *prodos8Lookup(uint16_t call) {
for (int i = 0; i < numProdos8; i++) {
if (prodos8[i].call >= call) {
if (prodos8[i].call == call)
return prodos8[i].name;
break;
}
}
return NULL;
}

120
regs.c Normal file
View File

@ -0,0 +1,120 @@
/**
* @copyright 2018 Sean Kasun
* The main disassembler
*/
#include <argp.h>
#include "handle.h"
#include "scan.h"
#include "disasm.h"
const char *argp_program_version = "regs 0.1";
const char *argp_program_bug_address = "sean@seancode.com";
static char doc[] = "Disassemble Apple IIgs software";
static char args_doc[] = "FILE or MAP";
static struct argp_option options[] = {
{"org", 'o', "ADDRESS", 0,
"Starting address of the binary file, in hex"},
{"m", 'm', 0, OPTION_ARG_OPTIONAL,
"Start with 8-bit accumulator"},
{"x", 'x', 0, OPTION_ARG_OPTIONAL,
"Start with 8-bit indices"},
{"e", 'e', 0, OPTION_ARG_OPTIONAL,
"Start in emulation mode"},
{ 0 }
};
struct arguments {
char *filename;
uint32_t org;
MapFlags flags;
};
static inline uint32_t parseNum(const char *s) {
uint32_t res = 0;
while (isspace(*s)) {
s++;
}
while (isxdigit(*s)) {
res <<= 4;
if (*s >= '0' && *s <= '9') {
res |= *s - '0';
} else if (*s >= 'a' && *s <= 'f') {
res |= *s - 'a' + 10;
} else if (*s >= 'A' && *s <= 'F') {
res |= *s - 'A' + 10;
}
s++;
}
return res;
}
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
struct arguments *arguments = state->input;
switch (key) {
case 'o':
if (arg) {
arguments->org = parseNum(arg);
}
break;
case 'm':
if (arg) {
arguments->flags |= IsM8;
}
break;
case 'x':
if (arg) {
arguments->flags |= IsX8;
}
break;
case 'e':
if (arg) {
arguments->flags |= IsEmu;
}
break;
case ARGP_KEY_ARG:
if (state->arg_num >= 1) {
argp_usage(state);
}
arguments->filename = arg;
break;
case ARGP_KEY_END:
if (state->arg_num < 1) {
argp_usage(state);
}
break;
default:
return ARGP_ERR_UNKNOWN;
}
return 0;
}
static struct argp argp = { options, parse_opt, args_doc, doc };
int main(int argc, char **argv) {
struct arguments arguments;
arguments.filename = "";
arguments.org = 0x300;
arguments.flags = IsOpcode;
argp_parse(&argp, argc, argv, 0, 0, &arguments);
// load the map, if it exists
Map *map = loadMap(arguments.filename, arguments.org, arguments.flags);
// load the file
FILE *f = fopen(map->filename, "rb");
if (!f) {
fprintf(stderr, "Failed to open '%s'\n", map->filename);
return -1;
}
fseek(f, 0, SEEK_END);
size_t len = ftell(f);
fseek(f, 0, SEEK_SET);
uint8_t *data = malloc(len);
fread(data, len, 1, f);
fclose(f);
scan(data, len, map);
disassemble(data, len, map);
free(data);
}

185
scan.c Normal file
View File

@ -0,0 +1,185 @@
/**
* @copyright 2018 Sean Kasun
* The tracing scanner.
*/
#include "scan.h"
#include "65816.h"
#include "handle.h"
typedef struct {
uint32_t address;
MapFlags flags;
} Scan;
typedef struct {
uint32_t max;
uint32_t num;
Scan *values;
} List;
static void initList(List *list) {
list->max = 1024;
list->num = 0;
list->values = malloc(sizeof(Scan) * list->max);
}
static void freeList(List *list) {
free(list->values);
}
static void appendList(List *list, uint32_t address, MapFlags flags) {
list->values[list->num].address = address;
list->values[list->num].flags = flags;
list->num++;
if (list->num == list->max) {
list->max *= 1.6;
list->values = realloc(list->values, sizeof(Scan) * list->max);
}
}
static uint32_t fillMem(uint32_t address, int len, MapFlags flags, Map *map) {
for (int i = 0; i < len; i++) {
map->mem[address++ - map->minMemory] = flags;
}
return address;
}
void scan(uint8_t *data, size_t len, Map *map) {
List toScan;
initList(&toScan);
map->maxMemory = map->minMemory + len;
map->mem = calloc(len, sizeof(MapFlags));
for (Rule *rule = map->rules; rule != NULL; rule = rule->next) {
appendList(&toScan, rule->address, rule->flags);
}
while (toScan.num > 0) {
toScan.num--;
MapFlags flags = toScan.values[toScan.num].flags;
uint32_t address = toScan.values[toScan.num].address;
while (address < map->maxMemory) {
uint8_t *ptr = data + address - map->minMemory;
uint8_t opcode = *ptr++;
if (map->mem[address - map->minMemory] & IsOperand) {
// we jumped into the middle of an opcode.. go backward to clear it
uint32_t offset = (address - map->minMemory) - 1;
while (offset > 0 && (map->mem[offset] & IsOperand)) {
map->mem[offset--] = IsData;
}
map->mem[offset] = IsData; // overwrite the opcode too.
}
Address mode = opcodes[opcode].address;
OpType type = opcodes[opcode].type;
if (address + addressSizes[mode] > map->maxMemory) {
mode = DB;
}
uint16_t width = addressSizes[mode];
if (mode == IMMM && (flags & (IsEmu | IsM8))) {
width--;
}
if (mode == IMMX && (flags & (IsEmu | IsX8))) {
width--;
}
if (mode == DB) {
map->mem[address++ - map->minMemory] = IsData;
} else {
map->mem[address++ - map->minMemory] = IsOpcode |
(flags & (IsEmu | IsX8 | IsM8));
address = fillMem(address, width - 1, IsOperand, map);
}
uint32_t val = 0;
int8_t delta;
int16_t delta16;
switch (mode) {
case IMM:
val = *ptr++;
if (opcode == 0xe2) {
flags |= val;
} else if (opcode == 0xc2) {
flags &= ~val;
}
break;
case IMMM:
if (flags & (IsEmu | IsM8)) {
val = *ptr++;
} else {
val = r16(ptr); ptr += 2;
}
break;
case IMMX:
if (flags & (IsEmu | IsX8)) {
val = *ptr++;
} else {
val = r16(ptr); ptr += 2;
}
break;
case IMMS:
val = r16(ptr); ptr += 2;
break;
case ABS:
val = r16(ptr); ptr += 2;
val |= address & 0xff0000;
break;
case ABL:
val = r24(ptr); ptr += 3;
break;
case REL:
delta = *ptr++;
val = delta + address;
break;
case RELL:
delta16 = r16(ptr); ptr += 2;
val = delta16 + address;
break;
default:
break;
}
if (opcode == 0x18 && *ptr == 0xfb) { // clc xce
flags &= ~IsEmu; // 16-bit
}
if (opcode == 0x38 && *ptr == 0xfb) { // sec xce
flags |= IsEmu; // 8-bit
}
if (opcode == 0x20) { // jsr
if ((val & 0xffff) == 0xc50d || (val & 0xffff) == 0xc70d) { // disk
address = fillMem(address, 3, IsData, map); // db, dw
if (*ptr++ >= 0x40) {
address = fillMem(address, 2, IsData, map); // dw
}
}
if ((val & 0xffff) == 0xbf00) { // prodos8
address = fillMem(address, 3, IsData, map); // db, dw
}
}
if (opcode == 0x22) { // jsl
if (val == 0xe100a8) {
address = fillMem(address, 6, IsData, map); // dw, dd
}
}
if (type == BRANCH || (type == CALL && mode != AIX) ||
(type == JUMP && mode != IND && mode != AIX)) {
if (val >= map->minMemory && val < map->maxMemory &&
!(map->mem[val - map->minMemory] & IsOpcode)) {
appendList(&toScan, val, flags);
}
}
if (type == BREAK || type == RETURN || type == JUMP) {
break;
}
}
}
freeList(&toScan);
}

11
scan.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* The tracing scanner.
*/
#include "map.h"
#include <stdlib.h>
extern void scan(uint8_t *data, size_t len, Map *map);

47
smartport.h Normal file
View File

@ -0,0 +1,47 @@
#pragma once
/**
* @copyright 2018 Sean Kasun
* Defines the SmartPort tool calls
*/
typedef struct {
uint8_t call;
const char *name;
} SmartPort;
static SmartPort smartport[] = {
{0x00, "Status"},
{0x01, "Read"},
{0x02, "Write"},
{0x03, "Format"},
{0x04, "Control"},
{0x05, "Init"},
{0x06, "Open"},
{0x07, "Close"},
{0x08, "Read"},
{0x09, "Write"},
{0x40, "Status"},
{0x41, "Read"},
{0x42, "Write"},
{0x43, "Format"},
{0x44, "Control"},
{0x45, "Init"},
{0x46, "Open"},
{0x47, "Close"},
{0x48, "Read"},
{0x49, "Write"}
};
#define numSmartPort (sizeof(smartport) / sizeof(smartport[0]))
static const char *smartportLookup(uint8_t call) {
for (int i = 0; i < numSmartPort; i++) {
if (smartport[i].call >= call) {
if (smartport[i].call == call)
return smartport[i].name;
break;
}
}
return NULL;
}

1290
tools.h Normal file
View File

File diff suppressed because it is too large Load Diff