mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-07-24 11:44:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

Has been dead so long that there's no use keeping it in the active bit of the repository.

Browse source
This commit is contained in:
Jack Jansen 2001-05-10 12:17:03 +00:00
parent 95bf9390a4
commit d454b578e2
27 changed files with 0 additions and 8246 deletions
Download patch file Download diff file Expand all files Collapse all files

369
Mac/Unsupported/GUSI1-mods/GUSI.h
View file

@ -1,369 +0,0 @@
/*********************************************************************
Project : GUSI - Grand Unified Socket Interface
File : GUSI.h - Socket calls
Author : Matthias Neeracher
Language : MPW C/C++
$Log$
Revision 1.1 2000/09/12 20:24:50 jack
Moved to Unsupported.
Revision 1.1 1998/08/18 14:52:33 jack
Putting Python-specific GUSI modifications under CVS.
Revision 1.2 1994/12/31 01:45:54 neeri
Fix alignment.
Revision 1.1 1994/02/25 02:56:49 neeri
Initial revision
Revision 0.15 1993/06/27 00:00:00 neeri
f?truncate
Revision 0.14 1993/06/20 00:00:00 neeri
Changed sa_constr_ppc
Revision 0.13 1993/02/14 00:00:00 neeri
AF_PAP
Revision 0.12 1992/12/08 00:00:00 neeri
getcwd()
Revision 0.11 1992/11/15 00:00:00 neeri
remove netdb.h definitions
Revision 0.10 1992/09/26 00:00:00 neeri
Separate dirent and stat
Revision 0.9 1992/09/12 00:00:00 neeri
Hostname stuff
Revision 0.8 1992/09/07 00:00:00 neeri
readlink()
Revision 0.7 1992/08/03 00:00:00 neeri
sa_constr_ppc
Revision 0.6 1992/07/21 00:00:00 neeri
sockaddr_atlk_sym
Revision 0.5 1992/06/26 00:00:00 neeri
choose()
Revision 0.4 1992/05/18 00:00:00 neeri
PPC stuff
Revision 0.3 1992/04/27 00:00:00 neeri
getsockopt()
Revision 0.2 1992/04/19 00:00:00 neeri
C++ compatibility
Revision 0.1 1992/04/17 00:00:00 neeri
bzero()
*********************************************************************/
#ifndef _GUSI_
#define _GUSI_
#include <sys/types.h>
/* Feel free to increase FD_SETSIZE as needed */
#define GUSI_MAX_FD FD_SETSIZE
#include <sys/cdefs.h>
#include <compat.h>
#include <sys/ioctl.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#include <dirent.h>
#include <Types.h>
#include <Events.h>
#include <Files.h>
#include <AppleTalk.h>
#include <CTBUtilities.h>
#include <Packages.h>
#include <PPCToolBox.h>
#include <StandardFile.h>
#include <stdio.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/un.h>
#include <unistd.h>
#include <machine/endian.h>
typedef enum spin_msg {
SP_MISC, /* some weird thing, usually just return immediately if you get this */
SP_SELECT, /* in a select call */
SP_NAME, /* getting a host by name */
SP_ADDR, /* getting a host by address */
SP_STREAM_READ, /* Stream read call */
SP_STREAM_WRITE, /* Stream write call */
SP_DGRAM_READ, /* Datagram read call */
SP_DGRAM_WRITE, /* Datagram write call */
SP_SLEEP, /* sleeping, passes ticks left to sleep */
SP_AUTO_SPIN /* Autospin, passes argument to SpinCursor */
} spin_msg;
typedef int (*GUSISpinFn)(spin_msg msg, long param);
typedef void (*GUSIEvtHandler)(EventRecord * ev);
typedef GUSIEvtHandler GUSIEvtTable[24];
/*
* Address families, defined in sys/socket.h
*
#define AF_UNSPEC 0 // unspecified
#define AF_UNIX 1 // local to host (pipes, portals)
#define AF_INET 2 // internetwork: UDP, TCP, etc.
#define AF_CTB 3 // Apple Comm Toolbox (not yet supported)
#define AF_FILE 4 // Normal File I/O (used internally)
#define AF_PPC 5 // PPC Toolbox
#define AF_PAP 6 // Printer Access Protocol (client only)
#define AF_APPLETALK 16 // Apple Talk
*/
#define ATALK_SYMADDR 272 /* Symbolic Address for AppleTalk */
/*
* Some Implementations of GUSI require you to call GUSISetup for the
* socket families you'd like to have defined. It's a good idea to call
* this for *all* implementations.
*
* GUSIDefaultSetup() will include all socket families.
*
* Never call any of the GUSIwithXXX routines directly.
*/
__BEGIN_DECLS
void GUSIwithAppleTalkSockets();
void GUSIwithInternetSockets();
void GUSIwithPAPSockets();
void GUSIwithPPCSockets();
void GUSIwithUnixSockets();
void GUSIwithSIOUXSockets();
void GUSIwithMPWSockets();
void GUSISetup(void (*socketfamily)());
void GUSIDefaultSetup();
void GUSILoadConfiguration(Handle);
__END_DECLS
/*
* Types, defined in sys/socket.h
*
#define SOCK_STREAM 1 // stream socket
#define SOCK_DGRAM 2 // datagram socket
*/
/*
* Defined in sys/un.h
*
struct sockaddr_un {
short sun_family;
char sun_path[108];
};
*/
#ifndef PRAGMA_ALIGN_SUPPORTED
#error Apple had some fun with the conditional macros again
#endif
#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=mac68k
#endif
struct sockaddr_atlk {
short family;
AddrBlock addr;
};
struct sockaddr_atlk_sym {
short family;
EntityName name;
};
struct sockaddr_ppc {
short family;
LocationNameRec location;
PPCPortRec port;
};
/* Definitions for choose() */
#define CHOOSE_DEFAULT 1 /* Use *name as default name */
#define CHOOSE_NEW 2 /* Choose new entity name, not existing one */
#define CHOOSE_DIR 4 /* Choose a directory name, not a file */
typedef struct {
short numTypes;
SFTypeList types;
} sa_constr_file;
typedef struct {
short numTypes;
NLType types;
} sa_constr_atlk;
/* Definitions for sa_constr_ppc */
#define PPC_CON_NEWSTYLE 0x8000 /* Required */
#define PPC_CON_MATCH_NAME 0x0001 /* Match name */
#define PPC_CON_MATCH_TYPE 0x0002 /* Match port type */
#define PPC_CON_MATCH_NBP 0x0004 /* Match NBP type */
typedef struct {
short flags;
Str32 nbpType;
PPCPortRec match;
} sa_constr_ppc;
#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=reset
#endif
__BEGIN_DECLS
/*
* IO/Socket stuff, defined elsewhere (unistd.h, sys/socket.h
*
int socket(int domain, int type, short protocol);
int bind(int s, void *name, int namelen);
int connect(int s, void *addr, int addrlen);
int listen(int s, int qlen);
int accept(int s, void *addr, int *addrlen);
int close(int s);
int read(int s, char *buffer, unsigned buflen);
int readv(int s, struct iovec *iov, int count);
int recv(int s, void *buffer, int buflen, int flags);
int recvfrom(int s, void *buffer, int buflen, int flags, void *from, int *fromlen);
int recvmsg(int s,struct msghdr *msg,int flags);
int write(int s, const char *buffer, unsigned buflen);
int writev(int s, struct iovec *iov, int count);
int send(int s, void *buffer, int buflen, int flags);
int sendto (int s, void *buffer, int buflen, int flags, void *to, int tolen);
int sendmsg(int s,struct msghdr *msg,int flags);
int select(int width, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
int getdtablesize(void);
int getsockname(int s, void *name, int *namelen);
int getpeername(int s, struct sockaddr *name, int *namelen);
int shutdown(int s, int how);
int fcntl(int s, unsigned int cmd, int arg);
int dup(int s);
int dup2(int s, int s1);
int ioctl(int d, unsigned int request, long *argp);
int getsockopt(int s, int level, int optname, char *optval, int * optlen);
int setsockopt(int s, int level, int optname, char *optval, int optlen);
int isatty(int);
int remove(const char *filename);
int rename(const char *oldname, const char *newname);
int creat(const char*);
int faccess(char*, unsigned int, long*);
long lseek(int, long, int);
int open(const char*, int);
int unlink(char*);
int symlink(char* linkto, char* linkname);
int readlink(char* path, char* buf, int bufsiz);
int truncate(char *path, long length);
int ftruncate(int fd, long length);
int chdir(char * path);
int mkdir(char * path);
int rmdir(char * path);
char * getcwd(char * buf, int size);
*/
/*
* Defined in stdio.h
*/
#ifdef __MWERKS__
void fsetfileinfo (char *filename, unsigned long newcreator, unsigned long newtype);
#endif
void fgetfileinfo (char *filename, unsigned long * creator, unsigned long * type);
#ifdef __MWERKS__
FILE *fdopen(int fd, const char *mode);
int fwalk(int (*func)(FILE * stream));
#endif
int choose(
int domain,
int type,
char * prompt,
void * constraint,
int flags,
void * name,
int * namelen);
/*
* Hostname routines, defined in netdb.h
*
struct hostent * gethostbyname(char *name);
struct hostent * gethostbyaddr(struct in_addr *addrP, int, int);
int gethostname(char *machname, long buflen);
struct servent * getservbyname (char * name, char * proto);
struct protoent * getprotobyname(char * name);
*/
char * inet_ntoa(struct in_addr inaddr);
struct in_addr inet_addr(char *address);
/*
* GUSI supports a number of hooks. Every one of them has a different prototype, but needs
* to be passed as a GUSIHook
*/
typedef enum {
GUSI_SpinHook, /* A GUSISpinFn, to be called when a call blocks */
GUSI_ExecHook, /* Boolean (*hook)(const GUSIFileRef & ref), decides if file is executable */
GUSI_FTypeHook,/* Boolean (*hook)(const FSSpec & spec) sets a default file type */
GUSI_SpeedHook /* A long integer, to be added to the cursor spin variable */
} GUSIHookCode;
typedef void (*GUSIHook)(void);
void GUSISetHook(GUSIHookCode code, GUSIHook hook);
GUSIHook GUSIGetHook(GUSIHookCode code);
/*
* What to do when a routine blocks
*/
/* Defined for compatibility */
#define GUSISetSpin(routine) GUSISetHook(GUSI_SpinHook, (GUSIHook)routine)
#define GUSIGetSpin() (GUSISpinFn) GUSIGetHook(GUSI_SpinHook)
int GUSISetEvents(GUSIEvtTable table);
GUSIEvtHandler * GUSIGetEvents(void);
extern GUSIEvtHandler GUSISIOWEvents[];
#define SIGPIPE 13
#define SIGALRM 14
/*
* BSD memory routines, defined in compat.h
*
#define index(a, b) strchr(a, b)
#define rindex(a, b) strrchr(a, b)
#define bzero(from, len) memset(from, 0, len)
#define bcopy(from, to, len) memcpy(to, from, len)
#define bcmp(s1, s2, len) memcmp(s1, s2, len)
#define bfill(from, len, x) memset(from, x, len)
*/
__END_DECLS
#endif /* !_GUSI_ */

171
Mac/Unsupported/GUSI1-mods/GUSI.r
View file

@ -1,171 +0,0 @@
/*********************************************************************
Project : GUSI - Grand Unified Socket Interface
File : GUSI.r - Include this
Author : Matthias Neeracher
Language : MPW Rez 3.0
$Log$
Revision 1.1 2000/09/12 20:24:45 jack
Moved to Unsupported.
Revision 1.1 1998/08/18 14:52:37 jack
Putting Python-specific GUSI modifications under CVS.
Revision 1.3 1994/12/30 19:33:34 neeri
Enlargened message box for select folder dialog.
Revision 1.2 1994/08/10 00:34:18 neeri
Sanitized for universal headers.
Revision 1.1 1994/02/25 02:12:04 neeri
Initial revision
Revision 0.5 1993/05/21 00:00:00 neeri
suffixes
Revision 0.4 1993/01/31 00:00:00 neeri
Daemon
Revision 0.3 1993/01/03 00:00:00 neeri
autoSpin
Revision 0.2 1992/09/24 00:00:00 neeri
Don't include CKID, create GUSIRsrc_P.h
Revision 0.1 1992/07/13 00:00:00 neeri
.rsrc
*********************************************************************/
#include "Types.r"
#include "GUSIRsrc_P.h"
include "GUSI.rsrc" not 'ckid';
/* Define a resource ('GU…I', GUSIRsrcID) to override GUSI defaults
To avoid having to change the Rez file every time I introduce another
feature, the preprocessor variable GUSI_PREF_VERSION by default keeps
everything compatible with version 1.0.2. Just define GUSI_PREF_VERSION
to be the version you want to use.
*/
#ifndef GUSI_PREF_VERSION
#define GUSI_PREF_VERSION '0102'
#endif
type 'GU…I' {
literal longint text = 'TEXT'; /* Type for creat'ed files */
literal longint mpw = 'MPS '; /* Creator for creat'ed files */
byte noAutoSpin, autoSpin; /* Automatically spin cursor ? */
#if GUSI_PREF_VERSION > '0102'
boolean useChdir, dontUseChdir; /* Use chdir() ? */
boolean approxStat, accurateStat; /* statbuf.st_nlink = # of subdirectories ? */
#if GUSI_PREF_VERSION >= '0181'
boolean noDelayConsole, DelayConsole; /* Delay opening console window until needed? */
fill bit[1];
#else
boolean noTCPDaemon, isTCPDaemon; /* Inetd client ? */
boolean noUDPDaemon, isUDPDaemon;
#endif
#if GUSI_PREF_VERSION >= '0150'
#if GUSI_PREF_VERSION >= '0181'
boolean wantAppleEvents, noAppleEvents; /* Always solicit AppleEvents */
#else
boolean noConsole, hasConsole; /* Are we providing our own dev:console ? (Obsolete) */
#endif
#if GUSI_PREF_VERSION >= '0180'
boolean autoInitGraf, noAutoInitGraf; /* Automatically do InitGraf ? */
boolean exclusiveOpen, sharedOpen; /* Shared open() ? */
boolean noSigPipe, sigPipe; /* raise SIGPIPE on write to closed PIPE */
#else
fill bit[3];
#endif
#else
fill bit[4];
#endif
literal longint = GUSI_PREF_VERSION;
#if GUSI_PREF_VERSION >= '0120'
integer = $$Countof(SuffixArray);
wide array SuffixArray {
literal longint; /* Suffix of file */
literal longint; /* Type for file */
literal longint; /* Creator for file */
};
#endif
#endif
};
type 'TMPL' {
wide array {
pstring;
literal longint;
};
};
resource 'TMPL' (GUSIRsrcID, "GU…I") {
{
"Type of created files", 'TNAM',
"Creator of created files", 'TNAM',
"Automatically spin cursor", 'DBYT',
#if GUSI_PREF_VERSION > '0102'
"Not using chdir()", 'BBIT',
"Accurate stat()", 'BBIT',
"TCP daemon", 'BBIT',
"UDP daemon", 'BBIT',
#if GUSI_PREF_VERSION >= '0150'
"Own Console", 'BBIT',
#else
"Reserved", 'BBIT',
#endif
#if GUSI_PREF_VERSION >= '0180'
"Don't initialize QuickDraw", 'BBIT',
"Open files shared", 'BBIT',
"Raise SIGPIPE", 'BBIT',
#else
"Reserved", 'BBIT',
"Reserved", 'BBIT',
"Reserved", 'BBIT',
#endif
"Version (don't change)", 'TNAM',
#if GUSI_PREF_VERSION >= '0120'
"NumSuffices", 'OCNT',
"*****", 'LSTC',
"Suffix", 'TNAM',
"Type for suffix", 'TNAM',
"Creator for suffix", 'TNAM',
"*****", 'LSTE',
#endif
#endif
}
};
resource 'DLOG' (GUSIRsrcID, "Get Directory") {
{0, 0, 217, 348},
dBoxProc,
invisible,
noGoAway,
0x0,
10240,
"",
alertPositionMainScreen
};
resource 'DITL' (GUSIRsrcID, "Get Directory") {
{
{ 142, 256, 160, 336}, Button {enabled,"Open"},
{1152, 59, 1232, 77}, Button {enabled,"Hidden"},
{ 193, 256, 211, 336}, Button {enabled,"Cancel"},
{ 43, 232, 63, 347}, UserItem {disabled},
{ 72, 256, 90, 336}, Button {enabled,"Eject"},
{ 97, 256, 115, 336}, Button {enabled,"Drive"},
{ 43, 12, 189, 230}, UserItem {enabled},
{ 43, 229, 189, 246}, UserItem {enabled},
{ 128, 252, 129, 340}, UserItem {disabled},
{1044, 20, 1145, 116}, StaticText {disabled,""},
{ 167, 256, 185, 336}, Button {enabled,"Directory"},
{ 0, 30, 18, 215}, Button {enabled,"Select Current Directory:"},
{ 200, 20, 1145, 222}, StaticText {disabled,"Select a Folder"}
}
};

1437
Mac/Unsupported/GUSI1-mods/GUSIDispatch.cp
View file

File diff suppressed because it is too large Load diff

582
Mac/Unsupported/GUSI1-mods/GUSINetDB.cp
View file

@ -1,582 +0,0 @@
/*********************************************************************
Project : GUSI - Grand Unified Socket Interface
File : GUSINetDB.cp - Convert internet names to adresses
Author : Matthias Neeracher
This file was derived from the socket library by
Charlie Reiman <creiman@ncsa.uiuc.edu> and
Tom Milligan <milligan@madhaus.utcs.utoronto.ca>
Language : MPW C++
$Log$
Revision 1.1 2000/09/12 20:24:49 jack
Moved to Unsupported.
Revision 1.1 1998/08/18 14:52:38 jack
Putting Python-specific GUSI modifications under CVS.
Revision 1.3 1994/08/10 00:07:30 neeri
Sanitized for universal headers.
Revision 1.2 1994/05/01 23:43:31 neeri
getservbyname() without /etc/services would fail.
Revision 1.1 1994/02/25 02:29:36 neeri
Initial revision
Revision 0.5 1993/10/31 00:00:00 neeri
Deferred opening of resolver
Revision 0.4 1993/07/29 00:00:00 neeri
Real getservent code (adapted from Sak Wathanasin)
Revision 0.3 1993/01/19 00:00:00 neeri
Can't set aliases to NULL.
Revision 0.2 1992/11/21 00:00:00 neeri
Remove force_active
Revision 0.1 1992/09/14 00:00:00 neeri
Maybe it works, maybe it doesn't
*********************************************************************/
#include "GUSIINET_P.h"
#include "TFileSpec.h"
#include "Folders.h"
#include "PLStringFuncs.h"
#ifdef __MWERKS__
//
// I disapprove of the way dnr.c is written
// This disapproval gets stronger with every version
//
#include "dnr.c"
#pragma require_prototypes reset
#pragma cplusplus reset
#endif
#if GENERATING68K
#pragma segment GUSIINET
#endif
static pascal void DNRDone(struct hostInfo *, Boolean * done)
{
*done = true;
}
#if GENERATINGCFM
RoutineDescriptor uDNRDone =
BUILD_ROUTINE_DESCRIPTOR(uppResultProcInfo, DNRDone);
#else
#define uDNRDone DNRDone
#endif
int h_errno;
/*
* Gethostbyname and gethostbyaddr each return a pointer to an
* object with the following structure describing an Internet
* host referenced by name or by address, respectively. This
* structure contains the information obtained from the MacTCP
* name server.
*
* struct hostent
* {
* char *h_name;
* char **h_aliases;
* int h_addrtype;
* int h_length;
* char **h_addr_list;
* };
* #define h_addr h_addr_list[0]
*
* The members of this structure are:
*
* h_name Official name of the host.
*
* h_aliases A zero terminated array of alternate names for the host.
*
* h_addrtype The type of address being returned; always AF_INET.
*
* h_length The length, in bytes, of the address.
*
* h_addr_list A zero terminated array of network addresses for the host.
*
* Error return status from gethostbyname and gethostbyaddr is
* indicated by return of a null pointer. The external integer
* h_errno may then be checked to see whether this is a
* temporary failure or an invalid or unknown host. The
* routine herror can be used to print an error message
* describing the failure. If its argument string is non-NULL,
* it is printed, followed by a colon and a space. The error
* message is printed with a trailing newline.
*
* h_errno can have the following values:
*
* HOST_NOT_FOUND No such host is known.
*
* TRY_AGAIN This is usually a temporary error and
* means that the local server did not
* receive a response from an authoritative
* server. A retry at some later time may
* succeed.
*
* NO_RECOVERY Some unexpected server failure was encountered.
* This is a non-recoverable error.
*
* NO_DATA The requested name is valid but does not
* have an IP address; this is not a
* temporary error. This means that the name
* is known to the name server but there is
* no address associated with this name.
* Another type of request to the name server
* using this domain name will result in an
* answer; for example, a mail-forwarder may
* be registered for this domain.
* (NOT GENERATED BY THIS IMPLEMENTATION)
*/
static struct hostInfo macHost;
#define MAXALIASES 0
static char *aliasPtrs[MAXALIASES+1] = {NULL};
static ip_addr *addrPtrs[NUM_ALT_ADDRS+1];
static struct hostent unixHost =
{
macHost.cname,
aliasPtrs,
AF_INET,
sizeof(ip_addr),
(char **) addrPtrs
};
inline struct in_addr make_in_addr(ip_addr addr)
{
struct in_addr res;
res.s_addr = addr;
return res;
}
struct hostent * gethostbyname(char *name)
{
Boolean done;
int i;
if (!strcmp(name, "localhost")) {
in_addr ipaddr;
ipaddr = make_in_addr(ip_addr(gethostid()));
if (ipaddr.s_addr)
return gethostbyaddr((char *) &ipaddr, sizeof(in_addr), AF_INET);
h_errno = HOST_NOT_FOUND;
return NULL;
}
if (INETSockets.Resolver()) {
h_errno = NO_RECOVERY;
return NULL;
}
for (i=0; i<NUM_ALT_ADDRS; i++)
macHost.addr[i] = 0;
done = false;
if (StrToAddr(name, &macHost, ResultUPP(&uDNRDone), (char *) &done) == cacheFault)
SPINP(!done,SP_NAME,0L);
switch (macHost.rtnCode) {
case noErr: break;
case nameSyntaxErr: h_errno = HOST_NOT_FOUND; return(NULL);
case cacheFault: h_errno = NO_RECOVERY; return(NULL);
case noResultProc: h_errno = NO_RECOVERY; return(NULL);
case noNameServer: h_errno = HOST_NOT_FOUND; return(NULL);
case authNameErr: h_errno = HOST_NOT_FOUND; return(NULL);
case noAnsErr: h_errno = TRY_AGAIN; return(NULL);
case dnrErr: h_errno = NO_RECOVERY; return(NULL);
case outOfMemory: h_errno = TRY_AGAIN; return(NULL);
default: h_errno = NO_RECOVERY; return(NULL);
}
/* was the 'name' an IP address? */
if (macHost.cname[0] == 0) {
h_errno = HOST_NOT_FOUND;
return(NULL);
}
/* for some reason there is a dot at the end of the name */
i = int(strlen(macHost.cname)) - 1;
if (macHost.cname[i] == '.')
macHost.cname[i] = 0;
for (i=0; i<NUM_ALT_ADDRS && macHost.addr[i]!=0; i++)
addrPtrs[i] = (ip_addr *) &macHost.addr[i];
addrPtrs[i] = NULL;
return &unixHost;
}
struct hostent * gethostbyaddr(const char *addrP, int, int)
{
Boolean done;
int i;
if (INETSockets.Resolver()) {
h_errno = NO_RECOVERY;
return NULL;
}
for (i=0; i<NUM_ALT_ADDRS; i++)
macHost.addr[i] = 0;
done = false;
ip_addr addr = FIX_LOOPBACK(*(ip_addr *)addrP);
if (AddrToName(addr, &macHost, ResultUPP(&uDNRDone), (char *) &done) == cacheFault)
SPINP(!done,SP_ADDR,0L);
switch (macHost.rtnCode) {
case noErr: break;
case cacheFault: h_errno = NO_RECOVERY; return(NULL);
case noNameServer: h_errno = HOST_NOT_FOUND; return(NULL);
case authNameErr: h_errno = HOST_NOT_FOUND; return(NULL);
case noAnsErr: h_errno = TRY_AGAIN; return(NULL);
case dnrErr: h_errno = NO_RECOVERY; return(NULL);
case outOfMemory: h_errno = TRY_AGAIN; return(NULL);
default: h_errno = NO_RECOVERY; return(NULL);
}
/* for some reason there is a dot at the end of the name */
i = int(strlen(macHost.cname)) - 1;
if (macHost.cname[i] == '.')
macHost.cname[i] = 0;
/* For some reason, the IP address usually seems to be set to 0 */
if (!macHost.addr[0])
macHost.addr[0] = addr;
for (i=0; i<NUM_ALT_ADDRS; i++)
addrPtrs[i] = (ip_addr *) &macHost.addr[i];
addrPtrs[NUM_ALT_ADDRS] = NULL;
return &unixHost;
}
char * inet_ntoa(struct in_addr inaddr)
{
if (INETSockets.Resolver()) {
h_errno = NO_RECOVERY;
return NULL;
}
(void) AddrToStr(inaddr.s_addr, macHost.cname);
return macHost.cname;
}
struct in_addr inet_addr(char *address)
{
if (INETSockets.Resolver()) {
h_errno = NO_RECOVERY;
return make_in_addr(0xFFFFFFFF);
}
if (StrToAddr(address,&macHost,NULL,NULL) != noErr)
return make_in_addr(0xFFFFFFFF);
/* was the 'address' really a name? */
if (macHost.cname[0] != 0)
return make_in_addr(0xFFFFFFFF);
return make_in_addr(macHost.addr[0]);
}
/*
* gethostid()
*
* Get internet address of current host
*/
long gethostid()
{
static long sHostID = 0;
if (sHostID)
return sHostID;
struct GetAddrParamBlock pbr;
pbr.ioCRefNum = INETSockets.Driver();
pbr.csCode = ipctlGetAddr;
if (PBControlSync(ParmBlkPtr(&pbr)))
return 0;
else
return sHostID = (long)pbr.ourAddress;
}
/*
* gethostname()
*
* Try to get my host name from DNR. If it fails, just return my
* IP address as ASCII. This is non-standard, but it's a mac,
* what do you want me to do?
*/
int gethostname(char *machname, int buflen)
{
static char * sHostName = nil;
if (!sHostName) {
in_addr ipaddr;
struct hostent *hp;
ipaddr = make_in_addr(ip_addr(gethostid()));
if (!ipaddr.s_addr) // TCP/IP not up at all
return GUSI_error(ENETDOWN);
hp = gethostbyaddr((char *) &ipaddr, sizeof(in_addr), AF_INET);
if (!hp) {
// No good name
if (buflen < 16) // Not enough space
return GUSI_error(EINVAL);
sprintf(machname, "%d.%d.%d.%d",
ipaddr.s_addr>>24,
ipaddr.s_addr>>16 & 0xff,
ipaddr.s_addr>>8 & 0xff,
ipaddr.s_addr & 0xff);
return 0;
} else {
// We only cache satisfactory replies in sHostName
sHostName = new char[strlen(hp->h_name)+1];
strcpy(sHostName, hp->h_name);
}
}
strncpy(machname, sHostName, unsigned(buflen));
machname[buflen-1] = 0; /* extra safeguard */
return 0;
}
/*
* getservbybname()
*
*/
static char * servlist[] =
{
"echo 7/udp",
"discard 9/udp",
"time 37/udp",
"domain 53/udp",
"sunrpc 111/udp",
"tftp 69/udp",
"biff 512/udp",
"who 513/udp",
"talk 517/udp",
"ftp-data 20/tcp",
"ftp 21/tcp",
"telnet 23/tcp",
"smtp 25/tcp",
"time 37/tcp",
"whois 43/tcp",
"domain 53/tcp",
"hostnames 101/tcp",
"nntp 119/tcp",
"finger 79/tcp",
"ntp 123/tcp",
"uucp 540/tcp",
NULL
};
static char servline[128];
static struct servent serv;
static FILE * servfil;
static int servptr;
static char * servalias[8];
static int servstay = 0;
void setservent(int stayopen)
{
if (servfil && servfil != (FILE *) -1) {
rewind(servfil);
}
servptr = 0;
servstay = servstay || stayopen;
}
void endservent()
{
if (servfil && servfil != (FILE *) -1) {
fclose(servfil);
servfil = NULL;
}
servstay = 0;
}
struct servent * getservent()
{
char * p;
int aliascount;
if (!servfil) {
TFileSpec serv;
if (!FindFolder(
kOnSystemDisk,
kPreferencesFolderType,
kDontCreateFolder,
&serv.vRefNum,
&serv.parID)
) {
PLstrcpy(serv.name, (StringPtr) "\p/etc/services");
if (servfil = fopen(serv.FullPath(), "r"))
goto retry;
}
servfil = (FILE *) -1;
servptr = 0;
}
retry:
if (servfil == (FILE *) -1)
if (!servlist[servptr])
return (struct servent *) NULL;
else
strcpy(servline, servlist[servptr++]);
else if (!(fgets(servline, 128, servfil)))
return (struct servent *) NULL;
if (p = strpbrk(servline, "#\n\r"))
*p = 0;
if (!servline[0])
goto retry;
if (!(serv.s_name = strtok(servline, " \t")))
goto retry;
if (!(p = strtok(NULL, " \t")))
goto retry;
if (!(serv.s_proto = strpbrk(p, "/,")))
goto retry;
*serv.s_proto++ = 0;
serv.s_port = htons(atoi(p));
serv.s_aliases = servalias;
for (aliascount = 0; aliascount < 7; )
if (!(servalias[aliascount++] = strtok(NULL, " \t")))
break;
servalias[aliascount] = NULL;
return &serv;
}
struct servent * getservbyname(const char * name, const char * proto)
{
struct servent * ent;
char ** al;
setservent(0);
while (ent = getservent()) {
if (!strcmp(name, ent->s_name))
goto haveName;
for (al = ent->s_aliases; *al; ++al)
if (!strcmp(name, *al))
goto haveName;
continue;
haveName:
if (!proto || !strcmp(proto, ent->s_proto))
break;
}
if (!servstay)
endservent();
return ent;
}
struct servent * getservbyport(int port, const char * proto)
{
struct servent * ent;
setservent(0);
while (ent = getservent())
if (port == ent->s_port && (!proto || !strcmp(proto, ent->s_proto)))
break;
if (!servstay)
endservent();
return ent;
}
static char tcp[] = "tcp";
static char udp[] = "udp";
#define MAX_PROTOENT 10
static struct protoent protoents[MAX_PROTOENT];
static int protoent_count=0;
struct protoent * getprotobyname(const char * name)
{
struct protoent *pe;
pe = &protoents[protoent_count];
if (strcmp(name, "udp") == 0) {
pe->p_name = udp;
pe->p_proto = IPPROTO_UDP;
} else if (strcmp (name, "tcp") == 0) {
pe->p_name = tcp;
pe->p_proto = IPPROTO_TCP;
} else {
errno = EPROTONOSUPPORT;
return NULL;
}
pe->p_aliases = aliasPtrs;
protoent_count = (protoent_count +1) % MAX_PROTOENT;
return pe;
}
struct protoent * getprotobynumber(int proto)
{
struct protoent *pe;
pe = &protoents[protoent_count];
if (proto == IPPROTO_UDP) {
pe->p_name = udp;
pe->p_proto = IPPROTO_UDP;
} else if (proto == IPPROTO_TCP) {
pe->p_name = tcp;
pe->p_proto = IPPROTO_TCP;
} else {
errno = EPROTONOSUPPORT;
return NULL;
}
pe->p_aliases = aliasPtrs;
protoent_count = (protoent_count +1) % MAX_PROTOENT;
return pe;
}

249
Mac/Unsupported/GUSI1-mods/GUSISIOUX.cp
View file

@ -1,249 +0,0 @@
/*********************************************************************
Project : GUSI - Grand unified socket interface
File : GUSISIOUX.cp - Interface to Metrowerks SIOUX library
Author : Matthias Neeracher
Language : MPW C/C++
$Log$
Revision 1.1 2000/09/12 20:24:49 jack
Moved to Unsupported.
Revision 1.1 1998/08/18 14:52:38 jack
Putting Python-specific GUSI modifications under CVS.
*********************************************************************/
#include <GUSIFile_P.h>
#include <ioctl.h>
#include <console.h>
#include <Events.h>
#include <LowMem.h>
/************************ SIOUXSocket members ************************/
/* This declaration lies about the return type */
extern "C" void SIOUXHandleOneEvent(EventRecord *userevent);
GUSIEvtHandler GUSISIOUXEvents[] = {
SIOUXHandleOneEvent, // nullEvent
SIOUXHandleOneEvent, // mouseDown
SIOUXHandleOneEvent, // mouseUp
nil, // keyDown
nil,
nil, // autoKey
SIOUXHandleOneEvent, // updateEvt
SIOUXHandleOneEvent, // diskEvt
SIOUXHandleOneEvent, // activateEvt
nil,
nil,
nil,
nil,
nil,
nil,
SIOUXHandleOneEvent, // osEvt
nil,
nil,
nil,
nil,
nil,
nil,
nil,
nil,
};
/************************ Declaration of SIOUXSocket ************************/
class SIOUXSocket : public Socket {
friend class SIOUXSocketDomain;
SIOUXSocket();
virtual ~SIOUXSocket();
protected:
int initialized;
void DoInitialize(void);
public:
virtual int read(void * buffer, int buflen);
virtual int write(void * buffer, int buflen);
virtual int select(Boolean * canRead, Boolean * canWrite, Boolean * exception);
virtual int ioctl(unsigned int request, void *argp);
virtual int isatty();
};
class SIOUXSocketDomain : public FileSocketDomain {
SIOUXSocket * singleton;
public:
SIOUXSocketDomain() : FileSocketDomain(AF_UNSPEC, true, false), singleton(nil) { }
virtual Boolean Yours(const GUSIFileRef & ref, Request request);
virtual Socket * open(const GUSIFileRef & ref, int oflag);
};
#if GENERATING68K
#pragma segment SIOUX
#endif
/************************ SIOUXSocket members ************************/
void SIOUXSocket::DoInitialize()
{
if ( initialized ) return;
initialized++;
InstallConsole(0);
GUSISetEvents(GUSISIOUXEvents);
}
SIOUXSocket::SIOUXSocket()
{
initialized = 0;
if ( !GUSIConfig.DelayConsole() )
DoInitialize();
}
SIOUXSocket::~SIOUXSocket()
{
RemoveConsole();
}
int SIOUXSocket::ioctl(unsigned int request, void *)
{
if ( !initialized) DoInitialize();
switch (request) {
case FIOINTERACTIVE:
return 0;
default:
return GUSI_error(EOPNOTSUPP);
}
}
int SIOUXSocket::read(void * buffer, int buflen)
{
if ( !initialized) DoInitialize();
fflush(stdout);
return ReadCharsFromConsole((char *) buffer, buflen);
}
int SIOUXSocket::write(void * buffer, int buflen)
{
if ( !initialized) DoInitialize();
return WriteCharsToConsole((char *) buffer, buflen);
}
static Boolean input_pending()
{
QHdrPtr eventQueue = LMGetEventQueue();
EvQElPtr element = (EvQElPtr)eventQueue->qHead;
// now, count the number of pending keyDown events.
while (element != nil) {
if (element->evtQWhat == keyDown || element->evtQWhat == autoKey)
return true;
element = (EvQElPtr)element->qLink;
}
return false;
}
int SIOUXSocket::select(Boolean * canRead, Boolean * canWrite, Boolean * exception)
{
int goodies = 0;
if ( !initialized) DoInitialize();
fflush(stdout);
if (canRead)
if (*canRead = input_pending())
++goodies;
if (canWrite) {
*canWrite = true;
++goodies;
}
if (exception)
*exception = false;
return goodies;
}
int SIOUXSocket::isatty()
{
return 1;
}
/********************* SIOUXSocketDomain members **********************/
#ifdef MSLGUSI
#ifndef SFIOGUSI
extern void GUSISetupMSLSIOUX();
#endif
#endif
extern "C" void GUSIwithSIOUXSockets()
{
static SIOUXSocketDomain SIOUXSockets;
SIOUXSockets.DontStrip();
#ifdef MSLGUSI
#ifndef SFIOGUSI
GUSISetupMSLSIOUX();
#endif
#endif
}
Boolean SIOUXSocketDomain::Yours(const GUSIFileRef & ref, FileSocketDomain::Request request)
{
if (ref.spec || (request != willOpen && request != willStat))
return false;
switch (ref.name[4] | 0x20) {
case 's':
if ((ref.name[5] | 0x20) != 't' || (ref.name[6] | 0x20) != 'd')
return false;
switch (ref.name[7] | 0x20) {
case 'i':
if ((ref.name[8] | 0x20) != 'n' || ref.name[9])
return false;
return true;
case 'o':
if ((ref.name[8] | 0x20) != 'u' || (ref.name[9] | 0x20) != 't' || ref.name[10])
return false;
return true;
case 'e':
if ((ref.name[8] | 0x20) != 'r' || (ref.name[9] | 0x20) != 'r' || ref.name[10])
return false;
return true;
default:
return false;
}
case 'c':
if ( (ref.name[5] | 0x20) != 'o' || (ref.name[6] | 0x20) != 'n'
|| (ref.name[7] | 0x20) != 's' || (ref.name[8] | 0x20) != 'o'
|| (ref.name[9] | 0x20) != 'l' || (ref.name[10] | 0x20) != 'e')
return false;
switch (ref.name[11]) {
case 0:
return true;
default:
return false;
}
default:
return false;
}
}
Socket * SIOUXSocketDomain::open(const GUSIFileRef &, int)
{
if (!singleton)
singleton = new SIOUXSocket();
++*singleton;
return singleton;
}

474
Mac/Unsupported/GUSI1-mods/GUSI_P.h
View file

@ -1,474 +0,0 @@
/*********************************************************************
Project : GUSI - Grand Unified Socket Interface
File : GUSI_P.h - Private stuff
Author : Matthias Neeracher
Language : MPW C/C++
$Log$
Revision 1.1 2000/09/12 20:24:46 jack
Moved to Unsupported.
Revision 1.1 1998/08/18 14:52:33 jack
Putting Python-specific GUSI modifications under CVS.
Revision 1.3 1994/12/31 01:30:26 neeri
Reorganize filename dispatching.
Revision 1.2 1994/08/10 00:41:05 neeri
Sanitized for universal headers.
Revision 1.1 1994/02/25 02:57:01 neeri
Initial revision
Revision 0.22 1993/07/17 00:00:00 neeri
GUSIRingBuffer::proc -> defproc
Revision 0.21 1993/07/17 00:00:00 neeri
GUSIO_MAX_DOMAIN -> AF_MAX
Revision 0.20 1993/06/27 00:00:00 neeri
Socket::{pre,post}_select
Revision 0.19 1993/06/27 00:00:00 neeri
Socket::ftruncate
Revision 0.18 1993/02/09 00:00:00 neeri
Socket::lurking, Socket::lurkdescr
Revision 0.17 1993/01/31 00:00:00 neeri
GUSIConfiguration::daemon
Revision 0.16 1993/01/17 00:00:00 neeri
Destructors for Socketdomain
Revision 0.15 1993/01/17 00:00:00 neeri
SAFESPIN
Revision 0.14 1993/01/03 00:00:00 neeri
GUSIConfig
Revision 0.13 1992/09/24 00:00:00 neeri
Include GUSIRsrc_P.h
Revision 0.12 1992/09/13 00:00:00 neeri
SPINVOID didn't return
Revision 0.11 1992/08/30 00:00:00 neeri
AppleTalkIdentity()
Revision 0.10 1992/08/03 00:00:00 neeri
RingBuffer
Revision 0.9 1992/07/30 00:00:00 neeri
Initializer Features
Revision 0.8 1992/07/26 00:00:00 neeri
UnixSockets.choose()
Revision 0.7 1992/07/13 00:00:00 neeri
Make AppleTalkSockets global
Revision 0.6 1992/06/27 00:00:00 neeri
choose(), hasNewSF
Revision 0.5 1992/06/07 00:00:00 neeri
Feature
Revision 0.4 1992/05/21 00:00:00 neeri
Implemented select()
Revision 0.3 1992/04/19 00:00:00 neeri
C++ rewrite
Revision 0.2 1992/04/18 00:00:00 neeri
changed read/write/send/recv dispatchers
Revision 0.1 1992/04/18 00:00:00 neeri
ppc Domain
*********************************************************************/
#ifndef __GUSI_P__
#define __GUSI_P__
#define __useAppleExts__
#include <GUSI.h>
#include <GUSIRsrc_P.h>
#include <TFileSpec.h>
#include <sys/errno.h>
#include <sys/uio.h>
#include <sys/socket.h>
extern "C" {
#include <stdio.h>
#include <string.h>
int GUSI_error(int err);
void * GUSI_error_nil(int err);
}
#include <Memory.h>
#include <Gestalt.h>
#include <Traps.h>
#include <AppleEvents.h>
#include <Processes.h>
#include <MixedMode.h>
#if MSLGUSI
using namespace std;
#endif
#if GENERATING68K
#pragma segment GUSI
#endif
#define GUSI_MAX_DOMAIN AF_MAX
#define DEFAULT_BUFFER_SIZE 4096
/*
* In use and shutdown status.
*/
#define SOCK_STATUS_USED 0x1 /* Used socket table entry */
#define SOCK_STATUS_NOREAD 0x2 /* No more reading allowed from socket */
#define SOCK_STATUS_NOWRITE 0x4 /* No more writing allowed to socket */
/*
* Socket connection states.
*/
#define SOCK_STATE_NO_STREAM 0 /* Socket doesn't have a MacTCP stream yet */
#define SOCK_STATE_UNCONNECTED 1 /* Socket is unconnected. */
#define SOCK_STATE_LISTENING 2 /* Socket is listening for connection. */
#define SOCK_STATE_LIS_CON 3 /* Socket is in transition from listen to connected. */
#define SOCK_STATE_CONNECTING 4 /* Socket is initiating a connection. */
#define SOCK_STATE_CONNECTED 5 /* Socket is connected. */
#define SOCK_STATE_CLOSING 6 /* Socket is closing */
#define SOCK_STATE_LIS_CLOSE 7 /* Socket closed while listening */
#define min(a,b) ( (a) < (b) ? (a) : (b))
#define max(a,b) ( (a) > (b) ? (a) : (b))
extern GUSISpinFn GUSISpin;
extern "C" int GUSIDefaultSpin(spin_msg, long);
extern int GUSICheckAlarm();
#define GUSI_INTERRUPT(mesg,param) (GUSICheckAlarm() || (GUSISpin && (*GUSISpin)(mesg,param)))
/* SPIN returns a -1 on user cancel for fn returning integers */
#define SPIN(cond,mesg,param) \
do { \
if (GUSI_INTERRUPT(mesg,param)) \
return GUSI_error(EINTR); \
} while(cond)
/* SPINP returns a NULL on user cancel, for fn returning pointers */
#define SPINP(cond,mesg,param) \
do { \
if (GUSI_INTERRUPT(mesg,param)) { \
GUSI_error(EINTR); \
return NULL; \
} \
} while(cond)
/* SPINVOID just returns on user cancel, for fn returning void */
#define SPINVOID(cond,mesg,param) \
do { \
if (GUSI_INTERRUPT(mesg,param)) { \
GUSI_error(EINTR); \
return; \
} \
} while(cond)
/* SAFESPIN doesn't return, you have to check errno */
#define SAFESPIN(cond,mesg,param) \
do { \
if (GUSI_INTERRUPT(mesg,param)) { \
GUSI_error(EINTR); \
break; \
} else \
errno = 0; \
} while(cond)
//
// Library functions are never allowed to clear errno, so we have to save
//
class ErrnoSaver {
public:
ErrnoSaver() { fSavedErrno = ::errno; ::errno = 0; }
~ErrnoSaver() { if (!::errno) ::errno = fSavedErrno; }
private:
int fSavedErrno;
};
#define SAVE_AND_CLEAR_ERRNO ErrnoSaver saveErrno
class SocketTable;
#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=mac68k
#endif
class Socket {
friend class SocketTable;
short refCount;
protected:
Socket();
public:
virtual int bind(void * name, int namelen);
virtual int connect(void * address, int addrlen);
virtual int listen(int qlen);
virtual Socket * accept(void * address, int * addrlen);
virtual int read(void * buffer, int buflen);
virtual int write(void * buffer, int buflen);
virtual int recvfrom(void * buffer, int buflen, int flags, void * from, int * fromlen);
virtual int sendto(void * buffer, int buflen, int flags, void * to, int tolen);
virtual int getsockname(void * name, int * namelen);
virtual int getpeername(void * name, int * namelen);
virtual int getsockopt(int level, int optname, void *optval, int * optlen);
virtual int setsockopt(int level, int optname, void *optval, int optlen);
virtual int fcntl(unsigned int cmd, int arg);
virtual int ioctl(unsigned int request, void *argp);
virtual int fstat(struct stat * buf);
virtual long lseek(long offset, int whence);
virtual int ftruncate(long offset);
virtual int isatty();
virtual int shutdown(int how);
virtual void pre_select(Boolean wantRead, Boolean wantWrite, Boolean wantExcept);
virtual int select(Boolean * canRead, Boolean * canWrite, Boolean * exception);
virtual void post_select(Boolean wantRead, Boolean wantWrite, Boolean wantExcept);
virtual ~Socket();
void operator++() { ++refCount; }
void operator--() { if (!--refCount) delete this; }
};
#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=reset
#endif
class SocketDomain {
static SocketDomain * domains[GUSI_MAX_DOMAIN];
static ProcessSerialNumber process;
protected:
SocketDomain(int domain);
virtual ~SocketDomain();
public:
inline static SocketDomain * Domain(int domain);
static void Ready();
// Optionally override the following
virtual Socket * socket(int type, short protocol);
// Optionally override the following
virtual int socketpair(int type, short protocol, Socket * sockets[]);
// Optionally define the following
virtual int choose(
int type,
char * prompt,
void * constraint,
int flags,
void * name,
int * namelen);
// Never override the following
void DontStrip();
};
class SocketTable {
Socket * sockets[GUSI_MAX_FD];
Boolean needsConsole;
public:
SocketTable();
~SocketTable();
void InitConsole();
int Install(Socket * sock, int start = 0);
int Remove(int fd);
Socket * operator[](int fd);
};
struct GUSISuffix {
char suffix[4];
OSType suffType;
OSType suffCreator;
};
#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=mac68k
#endif
//
// I learned the hard way not to rely on bit field alignments
//
struct GUSIConfigRsrc {
OSType defaultType;
OSType defaultCreator;
char autoSpin;
unsigned char flags;
OSType version;
short numSuffices;
GUSISuffix suffices[1];
};
#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=reset
#endif
struct GUSIConfiguration {
OSType defaultType;
OSType defaultCreator;
char autoSpin;
Boolean noChdir; // Set current directory without chdir()
Boolean accurStat; // Return # of subdirectories + 2 in st_nlink
Boolean hasConsole; // Do we have our own console ?
Boolean noAutoInitGraf; // Never automatically do InitGraf
Boolean sharedOpen; // Open files with shared permissions
Boolean sigPipe; // raise SIGPIPE on write to closed socket
Boolean noAppleEvents; // Don't solicit AppleEvents for MPW tools
Boolean delayConsole; // Do not open console until needed
OSType version;
short numSuffices;
GUSISuffix * suffices;
GUSIConfiguration();
void GUSILoadConfiguration(Handle config);
void SetDefaultFType(const TFileSpec & name) const;
void DoAutoSpin() const;
void AutoInitGraf() const { if (!noAutoInitGraf) DoAutoInitGraf(); }
void DoAutoInitGraf() const;
Boolean DelayConsole() const;
private:
static Boolean firstTime;
static short we;
};
extern GUSIConfiguration GUSIConfig;
extern SocketTable Sockets;
typedef pascal OSErr (*OSErrInitializer)();
typedef pascal void (*voidInitializer)();
class Feature {
Boolean good;
public:
Feature(unsigned short trapNum, TrapType tTyp);
Feature(OSType type, long value);
Feature(OSType type, long mask, long value);
Feature(const Feature & precondition, OSErrInitializer init);
Feature(OSErrInitializer init);
Feature(const Feature & precondition, voidInitializer init);
Feature(voidInitializer init);
Feature(const Feature & cond1, const Feature & cond2);
operator void*() const { return (void *) good; }
};
extern Feature hasMakeFSSpec;
extern Feature hasAlias;
extern Feature hasNewSF;
extern Feature hasProcessMgr;
extern Feature hasCRM;
extern Feature hasCTB;
extern Feature hasStdNBP;
extern Feature hasCM;
extern Feature hasFT;
extern Feature hasTM;
extern Feature hasPPC;
extern Feature hasRevisedTimeMgr;
class ScattGath {
Handle scratch;
protected:
void * buf;
int len;
int count;
const struct iovec * io;
ScattGath(const struct iovec *iov, int cnt);
virtual ~ScattGath();
public:
void * buffer() { return buf; }
int buflen() { return len; }
int length(int l) { return len = l; }
operator void *() { return buf; }
};
class Scatterer : public ScattGath {
public:
Scatterer(const struct iovec *iov, int count);
virtual ~Scatterer();
};
class Gatherer : public ScattGath {
public:
Gatherer(const struct iovec *iov, int count);
virtual ~Gatherer();
};
typedef pascal void (*Deferred)(void *);
class RingBuffer {
// Valid bytes are between consume and produce
// Free bytes are between produce and consume
// bytes between endbuf-spare and endbuf are neither
Ptr buffer;
Ptr endbuf;
Ptr consume;
Ptr produce;
u_short free;
u_short valid;
u_short spare;
Boolean lock;
Deferred defproc;
void * arg;
public:
RingBuffer(u_short bufsiz);
~RingBuffer();
Ptr Producer(long & len); // Find continuous memory for producer
Ptr Consumer(long & len); // Find continuous memory for consumer
void Validate(long len); // Validate this, unallocate rest
void Invalidate(long len);
void Produce(Ptr from, long & len);// Allocate, copy & validate
void Consume(Ptr to, long & len); // Copy & invalidate
long Free() { return free; }
long Valid() { return valid; }
void Defer() { lock = true; }
void Undefer() { lock = false; if (defproc) defproc(arg);}
Boolean Locked() { return lock; }
void Later(Deferred def, void * ar){ defproc = def; arg = ar; }
operator void *() { return buffer; }
};
Boolean GUSIInterrupt();
Boolean CopyIconFamily(short srcResFile, short srcID, short dstResFile, short dstID);
pascal OSErr PPCInit_P();
OSErr AppleTalkIdentity(short & net, short & node);
void CopyC2PStr(const char * cstr, StringPtr pstr);
#endif

62
Mac/Unsupported/mactcp/MACTCPconst.py
View file

@ -1,62 +0,0 @@
#
# MACTCP - event codes for the mactcp module
#
# UDP asr event codes
UDPDataArrival=1 # A datagram has arrived
UDPICMPReceived=2 # An ICMP error was received
# TCP asr event codes
TCPClosing=1 # All incoming data has been received and read.
TCPULPTimeout=2 # No response from remote process.
TCPTerminate=3 # Connection terminated. Has a detail parameter.
TCPDataArrival=4 # Data has arrived (and no Rcv call is outstanding)
TCPUrgent=5 # Urgent data is outstanding
TCPICMPReceived=6 # An ICMP error was received
PassiveOpenDone=32766 # (python only) a PassiveOpen has completed.
# TCP termination reasons
TCPRemoteAbort=2
TCPNetworkFailure=3
TCPSecPrecMismatch=4
TCPULPTimeoutTerminate=5
TCPULPAbort=6
TCPULPClose=7
TCPServiceError=8
# MacTCP/DNR errors
ipBadLapErr = -23000 # bad network configuration
ipBadCnfgErr = -23001 # bad IP configuration error
ipNoCnfgErr = -23002 # missing IP or LAP configuration error
ipLoadErr = -23003 # error in MacTCP load
ipBadAddr = -23004 # error in getting address
connectionClosing = -23005 # connection is closing
invalidLength = -23006
connectionExists = -23007 # request conflicts with existing connection
connectionDoesntExist = -23008 # connection does not exist
insufficientResources = -23009 # insufficient resources to perform request
invalidStreamPtr = -23010
streamAlreadyOpen = -23011
connectionTerminated = -23012
invalidBufPtr = -23013
invalidRDS = -23014
invalidWDS = -23014
openFailed = -23015
commandTimeout = -23016
duplicateSocket = -23017
# Error codes from internal IP functions
ipDontFragErr = -23032 # Packet too large to send w/o fragmenting
ipDestDeadErr = -23033 # destination not responding
icmpEchoTimeoutErr = -23035 # ICMP echo timed-out
ipNoFragMemErr = -23036 # no memory to send fragmented pkt
ipRouteErr = -23037 # can't route packet off-net
nameSyntaxErr = -23041
cacheFault = -23042
noResultProc = -23043
noNameServer = -23044
authNameErr = -23045
noAnsErr = -23046
dnrErr = -23047
outOfMemory = -23048

35
Mac/Unsupported/mactcp/MacTCPerrors.py
View file

@ -1,35 +0,0 @@
ipBadLapErr = -23000 # bad network configuration
ipBadCnfgErr = -23001 # bad IP configuration error
ipNoCnfgErr = -23002 # missing IP or LAP configuration error
ipLoadErr = -23003 # error in MacTCP load
ipBadAddr = -23004 # error in getting address
connectionClosing = -23005 # connection is closing
invalidLength = -23006
connectionExists = -23007 # request conflicts with existing connection
connectionDoesntExist = -23008 # connection does not exist
insufficientResources = -23009 # insufficient resources to perform request
invalidStreamPtr = -23010
streamAlreadyOpen = -23011
connectionTerminated = -23012
invalidBufPtr = -23013
invalidRDS = -23014
invalidWDS = -23014
openFailed = -23015
commandTimeout = -23016
duplicateSocket = -23017
# Error codes from internal IP functions
ipDontFragErr = -23032 # Packet too large to send w/o fragmenting
ipDestDeadErr = -23033 # destination not responding
icmpEchoTimeoutErr = -23035 # ICMP echo timed-out
ipNoFragMemErr = -23036 # no memory to send fragmented pkt
ipRouteErr = -23037 # can't route packet off-net
nameSyntaxErr = -23041
cacheFault = -23042
noResultProc = -23043
noNameServer = -23044
authNameErr = -23045
noAnsErr = -23046
dnrErr = -23047
outOfMemory = -23048

459
Mac/Unsupported/mactcp/macdnrmodule.c
View file

@ -1,459 +0,0 @@
/***********************************************************
Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
The Netherlands.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
#include "allobjects.h"
#include "modsupport.h" /* For getargs() etc. */
#include "macglue.h"
#include <AddressXlation.h>
#include <Desk.h>
#ifndef HAVE_UNIVERSAL_HEADERS
#define ResultUPP ResultProcPtr
#define NewResultProc(x) (x)
#define ResultProc2UPP ResultProc2Ptr
#define NewResultProc2Proc(x) (x)
#endif
static object *ErrorObject;
/* ----------------------------------------------------- */
/* Declarations for objects of type MacTCP DNR Result */
/* Types of records we have */
#define DNR_ADDR 0
#define DNR_HINFO 1
#define DNR_MX 2
typedef struct {
OB_HEAD
int type; /* DNR_XXX */
int waiting; /* True while completion proc not called */
struct returnRec hinfo;
} dnrrobject;
staticforward typeobject Dnrrtype;
#define is_dnrrobject(v) ((v)->ob_type == &Dnrrtype)
/* ---------------------------------------------------------------- */
static pascal void
dnrr_done(rrp, udp)
struct hostInfo *rrp; /* Unused */
dnrrobject *udp;
{
if ( !udp->waiting ) {
printf("macdnr: dnrr_done: spurious completion call!\n");
return;
}
udp->waiting = 0;
DECREF(udp);
}
static int dnrwait(self)
dnrrobject *self;
{
while ( self->waiting ) {
if ( PyMac_Idle() )
return 0;
}
return 1;
}
static object *
dnrr_wait(self, args)
dnrrobject *self;
object *args;
{
if (!newgetargs(args, ""))
return NULL;
if ( !dnrwait(self) ) {
/* XXX An interrupt is pending -- is this correct? */
INCREF(None);
return None;
}
if ( self->hinfo.rtnCode ) {
PyErr_Mac(ErrorObject, self->hinfo.rtnCode);
return NULL;
}
INCREF(None);
return None;
}
static object *
dnrr_isdone(self, args)
dnrrobject *self;
object *args;
{
if (!newgetargs(args, ""))
return NULL;
return newintobject(!self->waiting);
}
static struct methodlist dnrr_methods[] = {
{"wait", (method)dnrr_wait, 1},
{"isdone", (method)dnrr_isdone, 1},
{NULL, NULL} /* sentinel */
};
/* ---------- */
static dnrrobject *
newdnrrobject(tp)
int tp;
{
dnrrobject *self;
self = NEWOBJ(dnrrobject, &Dnrrtype);
if (self == NULL)
return NULL;
self->type = tp;
self->waiting = 0;
memset(&self->hinfo, 0, sizeof(self->hinfo));
return self;
}
static void
dnrr_dealloc(self)
dnrrobject *self;
{
self->waiting = 0; /* Not really needed, since we incref for completion */
DEL(self);
}
/* Code to access structure members by accessing attributes */
#include "structmember.h"
#define OFF(x) offsetof(struct returnRec, x)
static struct memberlist dnrr_memberlist_addr[] = {
{ "rtnCode", T_INT, OFF(rtnCode), RO},
{ "cname", T_STRING_INPLACE, OFF(cname), RO},
{ "ip0", T_UINT, OFF(rdata.addr[0]), RO},
{ "ip1", T_UINT, OFF(rdata.addr[1]), RO},
{ "ip2", T_UINT, OFF(rdata.addr[2]), RO},
{ "ip3", T_UINT, OFF(rdata.addr[3]), RO},
{NULL} /* Sentinel */
};
static struct memberlist dnrr_memberlist_hinfo[] = {
{ "rtnCode", T_INT, OFF(rtnCode), RO},
{ "cname", T_STRING_INPLACE, OFF(cname), RO},
{ "cpuType", T_STRING_INPLACE, OFF(rdata.hinfo.cpuType), RO},
{ "osType", T_STRING_INPLACE, OFF(rdata.hinfo.osType), RO},
{NULL} /* Sentinel */
};
static struct memberlist dnrr_memberlist_mx[] = {
{ "rtnCode", T_INT, OFF(rtnCode), RO},
{ "cname", T_STRING_INPLACE, OFF(cname), RO},
{ "preference", T_USHORT, OFF(rdata.mx.preference), RO},
{ "exchange", T_STRING_INPLACE, OFF(rdata.mx.exchange), RO},
{NULL} /* Sentinel */
};
static struct memberlist *dnrr_mlists[3] = {
dnrr_memberlist_addr,
dnrr_memberlist_hinfo,
dnrr_memberlist_mx
};
static object *
dnrr_getattr(self, name)
dnrrobject *self;
char *name;
{
object *rv;
int tp;
rv = findmethod(dnrr_methods, (object *)self, name);
if ( rv ) return rv;
err_clear();
if ( self->waiting )
if ( !dnrwait(self) ) {
/* XXX An interrupt is pending -- is this correct? */
err_setstr(ErrorObject, "Resolver busy");
return NULL;
}
tp = self->type;
return getmember((char *)&self->hinfo, dnrr_mlists[tp], name);
}
static typeobject Dnrrtype = {
OB_HEAD_INIT(&Typetype)
0, /*ob_size*/
"MacTCP DNR Result", /*tp_name*/
sizeof(dnrrobject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)dnrr_dealloc, /*tp_dealloc*/
(printfunc)0, /*tp_print*/
(getattrfunc)dnrr_getattr, /*tp_getattr*/
(setattrfunc)0, /*tp_setattr*/
(cmpfunc)0, /*tp_compare*/
(reprfunc)0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
(hashfunc)0, /*tp_hash*/
};
/* End of code for MacTCP DNR Result objects */
/* -------------------------------------------------------- */
int dnr_is_open;
static int
opendnr(fn)
char *fn;
{
OSErr err;
if ( dnr_is_open ) return 1;
if ( (err=OpenResolver(fn)) ) {
PyErr_Mac(ErrorObject, err);
return 0;
}
dnr_is_open = 1;
return 1;
}
static object *
dnr_Open(self, args)
object *self; /* Not used */
object *args;
{
char *fn = NULL;
if (!newgetargs(args, "|s", &fn))
return NULL;
if ( dnr_is_open ) {
err_setstr(ErrorObject, "DNR already open");
return NULL;
}
if ( !opendnr(fn) )
return NULL;
INCREF(None);
return None;
}
static object *
dnr_Close(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
if (!newgetargs(args, ""))
return NULL;
dnr_is_open = 0;
if ( (err=CloseResolver()) ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
INCREF(None);
return None;
}
static object *
dnr_StrToAddr(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
char *hostname;
dnrrobject *rv;
ResultUPP cb_upp = NewResultProc(dnrr_done);
if (!newgetargs(args, "s", &hostname))
return NULL;
if ( !opendnr(NULL) )
return NULL;
if ( (rv=newdnrrobject(DNR_ADDR)) == NULL )
return NULL;
err = StrToAddr(hostname, (struct hostInfo *)&rv->hinfo, cb_upp, (char *)rv);
if ( err == cacheFault ) {
rv->waiting++;
INCREF(rv);
} else if ( err ) {
DECREF(rv);
PyErr_Mac(ErrorObject, err);
return NULL;
}
return (object *)rv;
}
static object *
dnr_AddrToName(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
unsigned long ipaddr;
dnrrobject *rv;
ResultUPP cb_upp = NewResultProc(dnrr_done);
if (!newgetargs(args, "l", &ipaddr))
return NULL;
if ( !opendnr(NULL) )
return NULL;
if ( (rv=newdnrrobject(DNR_ADDR)) == NULL )
return NULL;
err = AddrToName(ipaddr, (struct hostInfo *)&rv->hinfo, cb_upp, (char *)rv);
if ( err == cacheFault ) {
rv->waiting++;
INCREF(rv);
} else if ( err ) {
DECREF(rv);
PyErr_Mac(ErrorObject, err);
return NULL;
}
return (object *)rv;
}
static object *
dnr_AddrToStr(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
unsigned long ipaddr;
char ipname[16];
if (!newgetargs(args, "l", &ipaddr))
return NULL;
if ( !opendnr(NULL) )
return NULL;
if ( (err=AddrToStr(ipaddr, ipname)) ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
return newstringobject(ipname);
}
static object *
dnr_HInfo(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
char *hostname;
dnrrobject *rv;
ResultProc2UPP cb_upp = NewResultProc2Proc(dnrr_done);
if (!newgetargs(args, "s", &hostname))
return NULL;
if ( !opendnr(NULL) )
return NULL;
if ( (rv=newdnrrobject(DNR_HINFO)) == NULL )
return NULL;
err = HInfo(hostname, &rv->hinfo, cb_upp, (char *)rv);
if ( err == cacheFault ) {
rv->waiting++;
INCREF(rv);
} else if ( err ) {
DECREF(rv);
PyErr_Mac(ErrorObject, err);
return NULL;
}
return (object *)rv;
if (!newgetargs(args, ""))
return NULL;
INCREF(None);
return None;
}
static object *
dnr_MXInfo(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
char *hostname;
dnrrobject *rv;
ResultProc2UPP cb_upp = NewResultProc2Proc(dnrr_done);
if (!newgetargs(args, "s", &hostname))
return NULL;
if ( !opendnr(NULL) )
return NULL;
if ( (rv=newdnrrobject(DNR_MX)) == NULL )
return NULL;
err = MXInfo(hostname, &rv->hinfo, cb_upp, (char *)rv);
if ( err == cacheFault ) {
rv->waiting++;
INCREF(rv);
} else if ( err ) {
DECREF(rv);
PyErr_Mac(ErrorObject, err);
return NULL;
}
return (object *)rv;
}
/* List of methods defined in the module */
static struct methodlist dnr_methods[] = {
{"Open", dnr_Open, 1},
{"Close", dnr_Close, 1},
{"StrToAddr", dnr_StrToAddr, 1},
{"AddrToStr", dnr_AddrToStr, 1},
{"AddrToName", dnr_AddrToName, 1},
{"HInfo", dnr_HInfo, 1},
{"MXInfo", dnr_MXInfo, 1},
{NULL, NULL} /* sentinel */
};
/* Initialization function for the module (*must* be called initmacdnr) */
void
initmacdnr()
{
object *m, *d;
/* Create the module and add the functions */
m = initmodule("macdnr", dnr_methods);
/* Add some symbolic constants to the module */
d = getmoduledict(m);
ErrorObject = newstringobject("macdnr.error");
dictinsert(d, "error", ErrorObject);
#if 0
/* Not needed, after all */
#define CONST(name, value) o = newintobject(value); dictinsert(d, name, o);
CONST("ADDR", DNR_ADDR);
CONST("HINFO", DNR_HINFO);
CONST("MX", DNR_MX);
#endif
/* Check for errors */
if (err_occurred())
fatal("can't initialize module macdnr");
}

990
Mac/Unsupported/mactcp/mactcpmodule.c
View file

@ -1,990 +0,0 @@
/***********************************************************
Copyright 1991, 1992, 1993, 1994 by Stichting Mathematisch Centrum,
Amsterdam, The Netherlands.
All Rights Reserved
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation, and that the names of Stichting Mathematisch
Centrum or CWI not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior permission.
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
******************************************************************/
#include "allobjects.h"
#include "modsupport.h" /* For getargs() etc. */
#include "macglue.h"
#include "tcpglue.h"
#include <Desk.h>
/* State of a tcp stream, in the connectionState field */
#define STATE_CLOSED 0
#define STATE_LISTEN 2
#define STATE_ESTAB 8
#define STATE_CWAIT 18
/* Python code has an additional reason for asr call: open done */
#define MY_OPEN_DONE 32766
static object *ErrorObject;
TCPIOCompletionUPP upp_tcp_done;
TCPNotifyUPP upp_tcp_asr;
#if 0
UDPIOCompletionUPP upp_udp_done;
#endif
UDPNotifyUPP upp_udp_asr;
/* ----------------------------------------------------- */
/* Declarations for objects of type MacTCP connection status */
typedef struct {
OB_HEAD
TCPStatusPB status;
} tcpcsobject;
staticforward typeobject Tcpcstype;
#define is_tcpcsobject(v) ((v)->ob_type == &Tcpcstype)
/* ---------------------------------------------------------------- */
/* Declarations for objects of type MacTCP global status */
#ifdef TCP_GS
typedef struct {
OB_HEAD
TCPParam *ptr;
} tcpgsobject;
staticforward typeobject Tcpgstype;
#define is_tcpgsobject(v) ((v)->ob_type == &Tcpgstype)
#endif /* TCP_GS */
/* ---------------------------------------------------------------- */
/* Declarations for objects of type MacTCP TCP stream */
typedef struct {
OB_HEAD
TCPiopb iop;
long localhost; /* Our IP address */
short localport; /* Our port number */
object *asr; /* Optional async notification routine */
int asr_ec; /* error code parameter to asr */
int asr_reason; /* detail for some errors */
int async_busy; /* True when completion routine pending */
int async_err; /* the error for the async call */
} tcpsobject;
staticforward typeobject Tcpstype;
#define is_tcpsobject(v) ((v)->ob_type == &Tcpstype)
/* ---------------------------------------------------------------- */
/* Declarations for objects of type MacTCP UDP stream */
typedef struct {
OB_HEAD
UDPiopb iop;
object *asr;
int asr_ec; /* error code parameter to asr */
ip_port port;
} udpsobject;
staticforward typeobject Udpstype;
#define is_udpsobject(v) ((v)->ob_type == &Udpstype)
/* ---------------------------------------------------------------- */
static tcpcsobject *
newtcpcsobject(ptr)
TCPStatusPB *ptr;
{
tcpcsobject *self;
self = NEWOBJ(tcpcsobject, &Tcpcstype);
if (self == NULL)
return NULL;
self->status = *ptr;
return self;
}
static void
tcpcs_dealloc(self)
tcpcsobject *self;
{
DEL(self);
}
/* Code to access structure members by accessing attributes */
#include "structmember.h"
#define OFF(x) offsetof(TCPStatusPB, x)
static struct memberlist tcpcs_memberlist[] = {
{"remoteHost", T_ULONG, OFF(remoteHost), RO},
{"remotePort", T_USHORT, OFF(remotePort), RO},
{"localHost", T_UINT, OFF(localHost), RO},
{"localPort", T_USHORT, OFF(localPort), RO},
{"tosFlags", T_BYTE, OFF(tosFlags), RO},
#if 0 /* Bug in header file: cannot access precedence */
{"precedence" T_BYTE, OFF(precedence), RO},
#endif
{"connectionState", T_BYTE, OFF(connectionState), RO},
{"sendWindow", T_USHORT, OFF(sendWindow), RO},
{"rcvWindow", T_USHORT, OFF(rcvWindow), RO},
{"amtUnackedData", T_USHORT, OFF(amtUnackedData), RO},
{"amtUnreadData", T_USHORT, OFF(amtUnreadData), RO},
{"sendUnacked", T_UINT, OFF(sendUnacked), RO},
{"sendNext", T_UINT, OFF(sendNext), RO},
{"congestionWindow", T_UINT, OFF(congestionWindow), RO},
{"rcvNext", T_UINT, OFF(rcvNext), RO},
{"srtt", T_UINT, OFF(srtt), RO},
{"lastRTT", T_UINT, OFF(lastRTT), RO},
{"sendMaxSegSize", T_UINT, OFF(sendMaxSegSize), RO},
{NULL} /* Sentinel */
};
static object *
tcpcs_getattr(self, name)
tcpcsobject *self;
char *name;
{
return getmember((char *)&self->status, tcpcs_memberlist, name);
}
static typeobject Tcpcstype = {
OB_HEAD_INIT(&Typetype)
0, /*ob_size*/
"MacTCP connection status", /*tp_name*/
sizeof(tcpcsobject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)tcpcs_dealloc, /*tp_dealloc*/
(printfunc)0, /*tp_print*/
(getattrfunc)tcpcs_getattr, /*tp_getattr*/
(setattrfunc)0, /*tp_setattr*/
(cmpfunc)0, /*tp_compare*/
(reprfunc)0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
(hashfunc)0, /*tp_hash*/
};
/* End of code for MacTCP connection status objects */
/* -------------------------------------------------------- */
#ifdef TCP_GS
static tcpgsobject *
newtcpgsobject(ptr)
TCPParam *ptr;
{
tcpgsobject *self;
self = NEWOBJ(tcpgsobject, &Tcpgstype);
if (self == NULL)
return NULL;
self->ptr = ptr;
return self;
}
static void
tcpgs_dealloc(self)
tcpgsobject *self;
{
DEL(self);
}
/* Code to access structure members by accessing attributes */
#undef OFF
#define OFF(x) offsetof(TCPParam, x)
static struct memberlist tcpgs_memberlist[] = {
{"RtoA", T_UINT, OFF(tcpRtoA), RO},
{"RtoMin", T_UINT, OFF(tcpRtoMin), RO},
{"RtoMax", T_UINT, OFF(tcpRtoMax), RO},
{"MaxSegSize", T_UINT, OFF(tcpMaxSegSize), RO},
{"MaxConn", T_UINT, OFF(tcpMaxConn), RO},
{"MaxWindow", T_UINT, OFF(tcpMaxWindow), RO},
{NULL} /* Sentinel */
};
static object *
tcpgs_getattr(self, name)
tcpgsobject *self;
char *name;
{
object *rv;
return getmember((char *)self->ptr, tcpgs_memberlist, name);
}
static typeobject Tcpgstype = {
OB_HEAD_INIT(&Typetype)
0, /*ob_size*/
"MacTCP global status", /*tp_name*/
sizeof(tcpgsobject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)tcpgs_dealloc, /*tp_dealloc*/
(printfunc)0, /*tp_print*/
(getattrfunc)tcpgs_getattr, /*tp_getattr*/
(setattrfunc)0, /*tp_setattr*/
(cmpfunc)0, /*tp_compare*/
(reprfunc)0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
(hashfunc)0, /*tp_hash*/
};
#endif /* TCP_GS */
/* End of code for MacTCP global status objects */
/* -------------------------------------------------------- */
static int
tcps_checkstate(self, state, state2)
tcpsobject *self;
int state, state2;
{
OSErr err;
TCPStatusPB *pb;
char buf[80];
if ( self->async_busy ) {
err_setstr(ErrorObject, "Operation not allowed, PassiveOpen in progress");
return -1;
}
if ( state < 0 && state2 < 0 )
return 0;
err = xTCPStatus(&self->iop, &pb);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return -1;
}
if ( state == pb->connectionState ||
state2 == pb->connectionState )
return 0;
sprintf(buf, "Operation not allowed, connection state=%d", pb->connectionState);
err_setstr(ErrorObject, buf);
return -1;
}
static int
tcps_asr_safe(arg)
void *arg;
{
tcpsobject *self = (tcpsobject *)arg;
object *args, *rv;
if ( self->asr == None )
return 0;
args = mkvalue("(ii)", self->asr_ec, self->asr_reason);
rv = call_object(self->asr, args);
DECREF(args);
if ( rv ) {
DECREF(rv);
return 0;
}
return -1;
}
static pascal void
tcps_asr(str, ec, self, reason, icmp)
StreamPtr str;
unsigned short ec;
tcpsobject *self;
unsigned short reason;
struct ICMPReport icmp;
{
if ( self->asr == None )
return;
self->asr_ec = ec;
self->asr_reason = reason;
Py_AddPendingCall(tcps_asr_safe, (void *)self);
}
static void
tcps_done(pb)
TCPiopb *pb;
{
tcpsobject *self = (tcpsobject *)pb->csParam.open.userDataPtr;
if ( pb != &self->iop || !self->async_busy ) {
/* Oops... problems */
printf("tcps_done: unexpected call\n");
return;
}
self->async_busy = 0;
self->async_err = pb->ioResult;
/* Extension of mactcp semantics: also call asr on open complete */
if ( self->asr == None )
return;
self->asr_ec = MY_OPEN_DONE;
self->asr_reason = 0;
Py_AddPendingCall(tcps_asr_safe, (void *)self);
}
static object *
tcps_isdone(self, args)
tcpsobject *self;
object *args;
{
if (!newgetargs(args, ""))
return NULL;
return newintobject(!self->async_busy);
}
static object *
tcps_wait(self, args)
tcpsobject *self;
object *args;
{
if (!newgetargs(args, ""))
return NULL;
while ( self->async_busy ) {
if ( PyMac_Idle() ) {
INCREF(None);
return None;
}
}
if ( self->async_err ) {
PyErr_Mac(ErrorObject, self->async_err);
self->async_err = 0;
return NULL;
}
INCREF(None);
return None;
}
static object *
tcps_PassiveOpen(self, args)
tcpsobject *self;
object *args;
{
short port;
OSErr err;
if (!newgetargs(args, "h", &port))
return NULL;
if ( tcps_checkstate(self, -1, -1) < 0 )
return NULL;
self->async_busy = 1;
self->async_err = 0;
err = xTCPPassiveOpen(&self->iop, port, upp_tcp_done,
(void *)self);
if ( err ) {
self->async_busy = 0;
PyErr_Mac(ErrorObject, err);
return NULL;
}
self->localhost = self->iop.csParam.open.localHost;
self->localport = self->iop.csParam.open.localPort;
INCREF(None);
return None;
}
static object *
tcps_ActiveOpen(self, args)
tcpsobject *self;
object *args;
{
short lport, rport;
long rhost;
OSErr err;
if (!newgetargs(args, "hlh", &lport, &rhost, &rport))
return NULL;
if ( tcps_checkstate(self, -1, -1) < 0 )
return NULL;
err = xTCPActiveOpen(&self->iop, lport, rhost, rport, (TCPIOCompletionUPP)0);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
self->localhost = self->iop.csParam.open.localHost;
self->localport = self->iop.csParam.open.localPort;
INCREF(None);
return None;
}
static object *
tcps_Send(self, args)
tcpsobject *self;
object *args;
{
char *buf;
int bufsize;
int push = 0, urgent = 0;
OSErr err;
miniwds wds;
if (!newgetargs(args, "s#|ii", &buf, &bufsize, &push, &urgent))
return NULL;
if ( tcps_checkstate(self, STATE_ESTAB, STATE_CWAIT) < 0 )
return NULL;
wds.length = bufsize;
wds.ptr = buf;
wds.terminus = 0;
err = xTCPSend(&self->iop, (wdsEntry *)&wds, (Boolean)push, (Boolean)urgent,
(TCPIOCompletionUPP)0);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
INCREF(None);
return None;
}
static object *
tcps_Rcv(self, args)
tcpsobject *self;
object *args;
{
int timeout;
rdsEntry rds[2];
OSErr err;
object *rv;
int urgent, mark;
if (!newgetargs(args, "i", &timeout))
return NULL;
if ( tcps_checkstate(self, -1, -1) < 0 )
return NULL;
memset((char *)&rds, 0, sizeof(rds));
err = xTCPNoCopyRcv(&self->iop, rds, 1, timeout, (TCPIOCompletionUPP)0);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
urgent = self->iop.csParam.receive.urgentFlag;
mark = self->iop.csParam.receive.markFlag;
rv = newsizedstringobject((char *)rds[0].ptr, rds[0].length);
err = xTCPBufReturn(&self->iop, rds, (TCPIOCompletionUPP)0);
if ( err ) {
/* Should not happen */printf("mactcp module: BufReturn failed?\n");
PyErr_Mac(ErrorObject, err);
DECREF(rv);
return NULL;
}
return mkvalue("(Oii)", rv, urgent, mark);
}
static object *
tcps_Close(self, args)
tcpsobject *self;
object *args;
{
OSErr err;
if (!newgetargs(args, ""))
return NULL;
err = xTCPClose(&self->iop, (TCPIOCompletionUPP)0);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
INCREF(None);
return None;
}
static object *
tcps_Abort(self, args)
tcpsobject *self;
object *args;
{
OSErr err;
if (!newgetargs(args, ""))
return NULL;
err = xTCPAbort(&self->iop);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
INCREF(None);
return None;
}
static object *
tcps_Status(self, args)
tcpsobject *self;
object *args;
{
OSErr err;
TCPStatusPB *pb;
if (!newgetargs(args, ""))
return NULL;
if ( tcps_checkstate(self, -1, -1) < 0 )
return NULL;
err = xTCPStatus(&self->iop, &pb);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
return (object *)newtcpcsobject(pb);
}
static object *
tcps_GetSockName(self, args)
tcpsobject *self;
object *args;
{
/* This routine is needed so we can get at the local port even when
** a PassiveOpen is in progress (when we can't do a Status call).
** This is needed for socket listen(); getsockname(); accept() emulation
** as used by ftp and the like.
*/
if (!newgetargs(args, ""))
return NULL;
return mkvalue("(lh)", self->localhost, self->localport);
}
static struct methodlist tcps_methods[] = {
{"isdone", (method)tcps_isdone, 1},
{"wait", (method)tcps_wait, 1},
{"PassiveOpen", (method)tcps_PassiveOpen, 1},
{"ActiveOpen", (method)tcps_ActiveOpen, 1},
{"Send", (method)tcps_Send, 1},
{"Rcv", (method)tcps_Rcv, 1},
{"Close", (method)tcps_Close, 1},
{"Abort", (method)tcps_Abort, 1},
{"Status", (method)tcps_Status, 1},
{"GetSockName", (method)tcps_GetSockName, 1},
{NULL, NULL} /* sentinel */
};
/* ---------- */
static object *
tcps_getattr(self, name)
tcpsobject *self;
char *name;
{
if ( strcmp(name, "asr") == 0 ) {
INCREF(self->asr);
return self->asr;
}
return findmethod(tcps_methods, (object *)self, name);
}
static int
tcps_setattr(self, name, value)
tcpsobject *self;
char *name;
object *value;
{
if ( strcmp(name, "asr") != 0 || value == NULL )
return -1;
self->asr = value; /* XXXX Assuming I don't have to incref */
return 0;
}
static tcpsobject *
newtcpsobject(bufsize)
int bufsize;
{
tcpsobject *self;
OSErr err;
self = NEWOBJ(tcpsobject, &Tcpstype);
if (self == NULL)
return NULL;
memset((char *)&self->iop, 0, sizeof(self->iop));
err= xTCPCreate(bufsize, upp_tcp_asr, (void *)self, &self->iop);
if ( err ) {
DEL(self);
PyErr_Mac(ErrorObject, err);
return NULL;
}
INCREF(None);
self->localhost = 0;
self->localport = 0;
self->asr = None;
self->async_busy = 0;
self->async_err = 0;
return self;
}
static void
tcps_dealloc(self)
tcpsobject *self;
{
if ( self->async_busy ) {
printf("mactcp module: error: dealloc with async busy\n");
return;
}
xTCPRelease(&self->iop);
DEL(self);
}
static typeobject Tcpstype = {
OB_HEAD_INIT(&Typetype)
0, /*ob_size*/
"MacTCP TCP stream", /*tp_name*/
sizeof(tcpsobject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)tcps_dealloc, /*tp_dealloc*/
(printfunc)0, /*tp_print*/
(getattrfunc)tcps_getattr, /*tp_getattr*/
(setattrfunc)tcps_setattr, /*tp_setattr*/
(cmpfunc)0, /*tp_compare*/
(reprfunc)0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
(hashfunc)0, /*tp_hash*/
};
/* End of code for MacTCP TCP stream objects */
/* -------------------------------------------------------- */
static int
udps_asr_safe(arg)
void *arg;
{
udpsobject *self = (udpsobject *)arg;
object *args, *rv;
if ( self->asr == None )
return 0;
args = mkvalue("(i)", self->asr_ec);
rv = call_object(self->asr, args);
DECREF(args);
if ( rv ) {
DECREF(rv);
return 0;
}
return -1;
}
static pascal void
udps_asr(str, ec, self, icmp)
StreamPtr str;
unsigned short ec;
udpsobject *self;
struct ICMPReport icmp;
{
if ( self->asr == None )
return;
self->asr_ec = ec;
Py_AddPendingCall(udps_asr_safe, (void *)self);
}
static object *
udps_Read(self, args)
udpsobject *self;
object *args;
{
OSErr err;
object *rv;
int timeout;
if (!newgetargs(args, "i", &timeout))
return NULL;
err = xUDPRead(&self->iop, timeout, (UDPIOCompletionUPP)0);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
rv = newsizedstringobject((char *)self->iop.csParam.receive.rcvBuff,
self->iop.csParam.receive.rcvBuffLen);
err = xUDPBfrReturn(&self->iop, self->iop.csParam.receive.rcvBuff);
if ( err ) {
PyErr_Mac(ErrorObject, err);
DECREF(rv);
return NULL;
}
return rv;
}
static object *
udps_Write(self, args)
udpsobject *self;
object *args;
{
unsigned long host;
unsigned short port;
char *buf;
int bufsize;
OSErr err;
miniwds wds;
if (!newgetargs(args, "lhs#", &host, &port, &buf, &bufsize))
return NULL;
wds.length = bufsize;
wds.ptr = buf;
wds.terminus = 0;
err = xUDPWrite(&self->iop, host, port, &wds, (UDPIOCompletionUPP)0);
if ( err ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
INCREF(None);
return None;
}
static struct methodlist udps_methods[] = {
{"Read", (method)udps_Read, 1},
{"Write", (method)udps_Write, 1},
{NULL, NULL} /* sentinel */
};
/* ---------- */
static object *
udps_getattr(self, name)
udpsobject *self;
char *name;
{
if ( strcmp(name, "asr") == 0 ) {
INCREF(self->asr);
return self->asr;
}
if ( strcmp(name, "port") == 0 )
return newintobject((int)self->port);
return findmethod(udps_methods, (object *)self, name);
}
static int
udps_setattr(self, name, value)
udpsobject *self;
char *name;
object *value;
{
if ( strcmp(name, "asr") != 0 || value == NULL )
return -1;
self->asr = value; /* XXXX Assuming I don't have to incref */
return 0;
}
static udpsobject *
newudpsobject(bufsize, port)
int bufsize;
int port;
{
udpsobject *self;
OSErr err;
self = NEWOBJ(udpsobject, &Udpstype);
if (self == NULL)
return NULL;
memset((char *)&self->iop, 0, sizeof(self->iop));
self->port = port;
err= xUDPCreate(&self->iop, bufsize, &self->port, upp_udp_asr,
(void *)self);
if ( err ) {
DEL(self);
PyErr_Mac(ErrorObject, err);
return NULL;
}
INCREF(None);
self->asr = None;
return self;
}
static void
udps_dealloc(self)
udpsobject *self;
{
xUDPRelease(&self->iop);
DEL(self);
}
static typeobject Udpstype = {
OB_HEAD_INIT(&Typetype)
0, /*ob_size*/
"MacTCP UDP stream", /*tp_name*/
sizeof(udpsobject), /*tp_basicsize*/
0, /*tp_itemsize*/
/* methods */
(destructor)udps_dealloc, /*tp_dealloc*/
(printfunc)0, /*tp_print*/
(getattrfunc)udps_getattr, /*tp_getattr*/
(setattrfunc)udps_setattr, /*tp_setattr*/
(cmpfunc)0, /*tp_compare*/
(reprfunc)0, /*tp_repr*/
0, /*tp_as_number*/
0, /*tp_as_sequence*/
0, /*tp_as_mapping*/
(hashfunc)0, /*tp_hash*/
};
/* End of code for MacTCP UDP stream objects */
/* -------------------------------------------------------- */
static object *
mactcp_TCPCreate(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
object *rv;
int bufsize;
if (!newgetargs(args, "i", &bufsize))
return NULL;
if ( (err = xOpenDriver()) != noErr ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
rv = (object *)newtcpsobject(bufsize);
return rv;
}
static object *
mactcp_UDPCreate(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
object *rv;
int bufsize, port;
if (!newgetargs(args, "ii", &bufsize, &port))
return NULL;
if ( (err = xOpenDriver()) != noErr ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
rv = (object *)newudpsobject(bufsize, port);
return rv;
}
static object *
mactcp_MTU(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
unsigned short mtu;
if (!newgetargs(args, ""))
return NULL;
if ( (err = xOpenDriver()) != noErr ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
mtu = xMaxMTU();
return newintobject((int)mtu);
}
static object *
mactcp_IPAddr(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
unsigned long rv;
if (!newgetargs(args, ""))
return NULL;
if ( (err = xOpenDriver()) != noErr ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
rv = xIPAddr();
return newintobject((int)rv);
}
static object *
mactcp_NetMask(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
unsigned long rv;
if (!newgetargs(args, ""))
return NULL;
if ( (err = xOpenDriver()) != noErr ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
rv = xNetMask();
return newintobject((int)rv);
}
#ifdef TCP_GS
static object *
mactcp_GlobalInfo(self, args)
object *self; /* Not used */
object *args;
{
OSErr err;
if (!newgetargs(args, ""))
return NULL;
if ( (err = xOpenDriver()) != noErr ) {
PyErr_Mac(ErrorObject, err);
return NULL;
}
/* XXXX Allocate, fill */
INCREF(None);
return None;
}
#endif /* TCP_GS */
/* List of methods defined in the module */
static struct methodlist mactcp_methods[] = {
{"TCPCreate", mactcp_TCPCreate, 1},
{"UDPCreate", mactcp_UDPCreate, 1},
{"MTU", mactcp_MTU, 1},
{"IPAddr", mactcp_IPAddr, 1},
{"NetMask", mactcp_NetMask, 1},
#ifdef TCP_GS
{"GlobalInfo", mactcp_GlobalInfo, 1},
#endif
{NULL, NULL} /* sentinel */
};
/* Initialization function for the module (*must* be called initmactcp) */
void
initmactcp()
{
object *m, *d;
/* Create the module and add the functions */
m = initmodule("mactcp", mactcp_methods);
/* Add some symbolic constants to the module */
d = getmoduledict(m);
ErrorObject = newstringobject("mactcp.error");
dictinsert(d, "error", ErrorObject);
upp_tcp_done = NewTCPIOCompletionProc(tcps_done);
upp_tcp_asr = NewTCPNotifyProc(tcps_asr);
#if 0
upp_udp_done = NewUDPIOCompletionProc(udps_done);
#endif
upp_udp_asr = NewUDPNotifyProc(udps_asr);
/* XXXX Add constants here */
/* Check for errors */
if (err_occurred())
fatal("can't initialize module mactcp");
}

2
Mac/Unsupported/mactcp/mactcpmodules.mu.exp
View file

@ -1,2 +0,0 @@
initmacdnr
initmactcp

212
Mac/Unsupported/mactcp/mactcpmodules.mu.hqx
View file

@ -1,212 +0,0 @@
(This file must be converted with BinHex 4.0)
:%'eKBh4MF'e[C(9XCA-ZEA8!68e38N0A588!N!3Dd!!!+q@Mh@0[Ef`!!!!"!!!
!(!!!'Q3!!"U!!!!!8!!!!!3!!!"S!!)!-!!#!"`(8fpeFQ0PFpf3#!#3'3)!-!!
#!#J*6'PLFQ&bD@9chC!'!*!C!J!!!!)!+!P-D@*bBA*TCA2GN!B!N"d#!#J!q2r
`!*!&!G58!*!'-XB!!!!"!*5fU!#3$3)!!-c-!$,-c*Q3"!!cc-bCQ@CQ!$6-c*Q
C-c-!0Fc-QCN!!!!fc-aQC[rr!$I-c'CQc-`!1-c-CQB!!`!"3!F!N!3-5@jdCA*
QB@0P6'PL!*!6V%qP3!'"Fh4eBUa2T8!!!J!$!*!%$QeKBf4ZFQe[C(9XC5jM!*!
4VA-b@3'"9%9B9+ec-PN!!`!$!*!%$QeKBh4MF'e[C(9XC5jM!*!4VA-b@J'"9%9
B9+ec-PS!"!!$!*!%#A4MF'GXG@8ZB`#3&Uec-PS"J94&@&5YFc*D!!8!!`#3"!a
KE'a[BQTPBh4c,QJ!N"1Z#C!!13'!9%9B9+i*N!!j!!B!!`#3"!KMEfjQD@FZD!#
3&kec-NF"J&4&@&5YFc*(!!G!!`#3"!GcG'4TEbjS!*!BV6qZp!#!9%9B9+drV[3
!#%!$!*!%"hPfB@ac,QJ!N"LYXp4*!)"849K8VE2853!*3!-!N!3)Fh4bD@jR,QJ
!N"HY2kld!)"849K8V6qZp!!+3!-!N!3(CA*bEQmZD!#3'+drV[)!J&4&@&5Y2kl
b!!X!!`#3"!PYHA"bEh4[,QJ!N"DYFc)H!B"849K8VA-b(J!-!!-!N!3*FQ9ZB@e
P-LjS!*!@VJQ3!$N"J&4&@&5Z#C!!13!0!!-!N!3)Ef*UC@0d,QJ!N"HZ#C!!13'
!9%9B9+i*N!!j!!i!!`#3"!P[BQTTEA"X,QJ!N"DYFc)H!B"849K8VA-b(J!2!!-
!N!31B@0MCA0cEf*UC@0d,QJ!N"'YFc)C!B"849K8VA-b'3!3!!-!N!3,D@jdEf*
UC@0d,QJ!N"5YFc)F!B"849K8VA-b(!!4!!-!N!3-E'pZCfpLDQ9MG#jS!*!6VA-
b(3'!9%9B9+ec-Kd!%J!$!*!%$@CXEf&dEf*UC@0d,QJ!N"+YFc)E!B"849K8VA-
b'`!6!!-!N!30FQ&ZCf9[BQTPBh3ZD!#3%Uec-Km"J&4&@&5YFc)I!"3!!`#3"!j
cG(*TEQG[BQTPBh3ZD!#3%Dec-Km"J&4&@&5YFc)I!"8!!`#3"!edGA"XC@pLDQ9
MG#jS!*!5VA-b)!'!9%9B9+ec-L!!&J!$!*!%$'aTFh4[BQTPBh3ZD!#3%kec-Kd
"J&4&@&5YFc)G!"F!!`#3"!pYBA"`D@jREf*UC@0d,QJ!N"#YFc)G!B"849K8VA-
b(3!B!!-!N!31E@9dD'pNEf*UC@0d,QJ!N"'YFc)G!B"849K8VA-b(3!C!!-!N!3
1E@pNG@aPEf*UC@0d,QJ!N"'YFc)G!B"849K8VA-b(3!D!!-!N!3-CR9ZBfpLDQ9
MG#jS!*!6VA-b(!'!9%9B9+ec-K`!'`!$!*!%$@0XBA0cEf*UC@0d,QJ!N"+YFc)
D!B"849K8VA-b'J!F!!-!N!3-CQPXC@pLDQ9MG#jS!*!6VJQ3!$N"J&4&@&5Z#C!
!13!G!!-!N!3+EAPYB@aXEf-ZD!#3&Dec-Ki"J&4&@&5YFc)H!"j!!`#3"!KcG'4
XD@)ZD!#3&kdrV[3!J&4&@&5Y2kld!"m!!`#3"!aYEf4cGA"`Eh*d,QJ!N"1YFc)
G!B"849K8VA-b(3!J3!-!N!3)Fh4NBA*R,QJ!N"HY2kqp!)"849K8V6q[[3!K3!-
!N!3*Ah0dC'&bCbjS!*!@UX`2e`#!9%9B9+V-$pF!)J!$!*!%"f0PGQ&X,QJ!N"L
YFc)D!B"849K8VA-b'J!M!!-!N!3+B@*cG(*KBh3ZD!#3&Dec-KN"J&4&@&5YFc)
C!#3!!`#3"!PYB@0RE(9P,QJ!N"DZ*8AF!B"849K8VL9&h!!P3!B!N!3(9(P`CA-
ZD!#3'+fY'UN!J&4&@&5YV4UT!#C!"J#3""0$EfjNDA4TEfjKE%eKBh*[FbjS!*!
-V4rb3!#!9%9B9+dImN!!*d!'!*!%"dCTE'9c,QJ!N"LX)B$!!)"849K8V#'!`!!
S3!B!N!3,6@PiC@40Ef4P,QJ!N"5Y8ec!!)"849K8V90F`!!T3!B!N!3*6e09G'P
XFbjS!*!@VE291`#!9%9B9+fce6X!+N!'!*!%#%ePE@pbH5jS!*!AV#'!`!#!9%9
B9+`KJ-!!+d!'!*!%#%9fC@jdFbjS!*!AV4rb3!#!9%9B9+dImN!!,%!'!*!%#e&
eD@0VC(*KGbjS!*!8V')D3!#!9%9B9+aL'N!!,8!'!*!%$e&eD@0VC(*KGe4PH(3
ZD!#3%+`KJ-!!J&4&@&5X)B$!!#j!"J#3"!j6G'&ZC'&bC%CTE'8ZD!#3%D`KJ-!
!J&4&@&5X)B$!!#p!"J#3"!P%D@&XEfGc,QJ!N"DX)B$!!)"849K8V#'!`!!`3!B
!N!3)4A*bEh*c,QJ!N"HY(r*!!)"849K8V4rb3!!a3!B!N!3(6@9ZGA-ZD!#3'+`
KJ-!!J&4&@&5X)B$!!$*!"J#3"!T$EfjdFQpXFbjS!*!9V#'!`!#!9%9B9+`KJ-!
!-d!'!*!%#9GTEQ4[Gh-ZD!#3&UaL'N!!J&4&@&5XBKT!!$4!"J#3"!T8CAKd4@4
TG#jS!*!9V#'!`!#!9%9B9+`KJ-!!08!&!*!%%%&NC(*PFh0BE'&dD@pZ,QJ!N!q
VZre!!)"849K8Ul[p3!!f3!B!N!3)6@&M9%03,QJ!N"HYQ6a!!)"849K8VCNm3!!
h3!B!N!3,3A"`E'98B@aV,QJ!N"5X)B$!!)"849K8V#'!`!!i3!B!N!3'4'9cDbj
S!*!CV#'!`!#!9%9B9+`KJ-!!18!'!*!%#84PGQPMCA-ZD!#3&UdImN!!J&4&@&5
Y(r*!!$S!!`#3"!jcG(*eBh4YC@eLCA)ZD!#3%Dec-Km"J&4&@&5YFc)I!$X!!`#
3"!PdBh"RE(9P,QJ!N"DYFc*E!B"849K8VA-b@`!m3!8!N!366@&M9%033fpYE@p
Z9(P`CA-ZD!#3$+X%`dB!J&4&@&5V"-0'!$e!"3#3"!e(CA40H8P33@4NFLjS!*!
5U`6$83#!9%9B9+X%`e%!2N!&!*!%"e4$8&"#,QJ!N"LV"--T!)"849K8U`6$+3!
r3!8!N!3(98438%)ZD!#3'+X%`b!!J&4&@&5V"--J!%!!"!#3"!PbG@jdD@eP,Q-
!N"DXVa"e!B"849K8V+m3G3""!!-!N!3@EAGPFQYcAh"XG@GTEPpMEfjQD@FZD!#
3#Dec-QX"J&4&@&5YFc*V!%)!!`#3"!pMEfe`E'9iEf*UC@0d,QJ!N"#Z#C!!13'
!9%9B9+i*N!!j!%-!!`#3"!PMEf*UC@0d,QJ!N"DYFc)D!B"849K8VA-b'J"%!!)
!N!36E@&MG'0`E@pNG@aPFbke,Q9iF!#3$+cq!28"J&4&@&5XrJ$e!%8!!`#3"!T
`H@9bFQpbFbjS!*!9VA-b(`'!9%9B9+ec-Km!4J!$!*!%#P"jG'K[EN0[FQ8!N"@
Z*RYp!B"cD'aLVLClI3"(!!-!N!3*F(PNC@*eCbjS!*!@VJQ3!$N"J&4&@&5Z#C!
!13")!!-!N!3,G(*KBf9LB@0V,QJ!N"5YFc)J!B"849K8VA-b)!"*!!-!N!3,F(P
dD'pZFR9Z,QJ!N"5Z#C!!13'!9%9B9+i*N!!j!%S!!`#3"!YcHA0YEf4eE'8ZD!#
3&+i*N!!j!B"849K8VJQ3!$N!5`!$!*!%#fPZG(*MD'9MDbjS!*!8VKP0'!'!9%9
B9+iC64J!6!!$!*!%#'PYF'pbG#jS!*!AVJQ3!$N"J&4&@&5Z#C!!13"0!!-!N!3
0BQadD@jYEf4eE'8ZD!#3%Ui*N!!j!B"849K8VJQ3!$N!6N!'!*!%#%YPFQjPE#j
S!*!AV4rb3!#!9%9B9+dImN!!6d!'!*!%%deKBfKTEQ9&H'0PF(4TEfjc,QJ!N!b
X)B$!!)"849K8V#'!`!"33!B!N!316Q&YC9*PCfPcG(*j,QJ!N"'Y(r*!!)"849K
8V4rb3!"43!B!N!323fpNC8CbB@GYC@jdFbjS!*!3V#'!`!#!9%9B9+`KJ-!!!!K
-!!F#G!!!!%B!!3#3#!)!N!81E@&MC'jbE@pNG@aP,Q-!N"S#!*!(0DZlr8!!!3!
hV#'!`!!"!&'X)B$!!!%!*UdImN!!!3!bV#'!`!!"!$LX)B$!!!%!1DdImN!!!3!
[V#'!`!!"!!UY2klb!!%!-+dImN!!!3!VV4rb3!!"!#HX)B$!!!%!6UdImN!!!3"
2V#'!`!!"!$DYQ6a!!!%!+U`KJ-!!!3!aV#'!`!!"!#LY8ec!!!%!8+dImN!!!3!
TVE291`!"!#bXBKT!!!%!,D`KJ-!!!3!ZV#'!`!!"!##Y2kqp!!%!"kdrV[3!!3!
HV6qZp!!"!!QY2kld!!%!0+`KJ-!!!3!PVDdDU3!"!$1XBKT!!!%!#+fce%N!!3!
KUX`2e`!"!#1YFc)C!!%!$kec-KN!!3!&VJQ3!$N!!3"0VJQ3!$N!!3!LVA-b'J!
"!"ZYFc)D!!%!3kec-KS!!3"#VJQ3!$N!!3!'VA-b4`!"!"bZ#C!!13!"!"+YFc)
E!!%!'Uec-K`!!3"-VJQ3!$N!!3!3VA-b(!!"!%ZZ'8dB!!%!&Uec-Kd!!3!4VA-
b(3!"!#5Z*8AF!!%!&kec-Kd!!3!BVA-b(3!"!"qYFc)G!!%!'Dec-Kd!!3""VA-
bD`!"!"fYFc)H!!%!#kec-Ki!!3!0VJQ3!$N!!3!1VA-b(J!"!%HZ#C!!13!"!%@
YFc)I!!%!5Di*N!!j!!%!%kec-Km!!3!-VJQ3!$N!!3!8VA-b(`!"!$UYFc)I!!%
!5Ui*N!!j!!%!5+ec-L!!!3!9VA-b)!!"!TB#Q!+D!T`!!!",!!%!N!J#!*!&$Qe
KBh4MF'e[C(9XC5jM!*!D!`#3"c@VZre!!!%!0k`KJ-!!!3"4V#'!`!!"!#DY(r*
!!!%!-U`KJ-!!!3!iV#'!`!!"!$QY(r*!!!%!,k`KJ-!!!3!+V6qZmJ!"!$#Y(r*
!!!%!+kdImN!!!3!RV#'!`!!"!$fV"-04!!%!6UdImN!!!3"2V#'!`!!"!$DYQ6a
!!!%!2+X%`dB!!3!UV#'!`!!"!$'X)B$!!!%!++e6A-!!!3"3V4rb3!!"!#QYXp8
l!!%!,+aL'N!!!3!YV#'!`!!"!#kX)B$!!!%!)+drVld!!3!(V6qZp!!"!"kY2kl
d!!%!#DdrV[3!!3!qU`6$+3!"!$5X)B$!!!%!*DfY'UN!!3!rU`6$)!!"!$1XBKT
!!!%!#+fce%N!!3!KUX`2e`!"!#1YFc)C!!%!$kec-KN!!3!&VJQ3!$N!!3"0VJQ
3!$N!!3!LVA-b'J!"!"ZYFc)D!!%!3kec-KS!!3"#VJQ3!$N!!3!'VA-b4`!"!"b
Z#C!!13!"!"+YFc)E!!%!'Uec-K`!!3"-VJQ3!$N!!3!3VA-b(!!"!%ZZ'8dB!!%
!&Uec-Kd!!3!4VA-b(3!"!#5Z*8AF!!%!&kec-Kd!!3!BVA-b(3!"!"qYFc)G!!%
!'Dec-Kd!!3""VA-bD`!"!"fYFc)H!!%!#kec-Ki!!3!0VJQ3!$N!!3!1VA-b(J!
"!%HZ#C!!13!"!%@YFc)I!!%!5Di*N!!j!!%!%kec-Km!!3!-VJQ3!$N!!3!8VA-
b(`!"!$UYFc)I!!%!5Ui*N!!j!!%!1kec-PX!!3")VA-b)!!"!"@YFc)J!!%",J%
`!6)"0!!!!"i!!3#3#!)!N!8*G'0`CfaeC5jM!*!I"!#3"c@VZre!!!%!0k`KJ-!
!!3"4V#'!`!!"!#DY(r*!!!%!-U`KJ-!!!3!jV4rb3!!"!#qX)B$!!!%!-+dImN!
!!3!VV4rb3!!"!#HX)B$!!!%!2DX%`e%!!3"1V4rb3!!"!%qX)B$!!!%!0UfC2%!
!!3!mU`6$4J!"!#UX)B$!!!%!-D`KJ-!!!3!SV90F`!!"!&#Y(r*!!!%!+Dfce6X
!!3!XV')D3!!"!#fX)B$!!!%!2UX%`bN!!3!dV#'!`!!"!#@YV4UT!!%!2kX%`b!
!!3!cV')D3!!"!%'YFc*V!!%!1kec-PX!!3%1!4!"%J%8!!!!!3!"!*!)!J%!N!3
6E@&MG'0`E@pNG@aPFbke,Q9iF!#3&83!N!G'!%Mp33!"!$HX)3&4FD!!N!BLN!!
"8C6!J-)!!3!jV#'!`J!"!8I!8)$#!!%!-+`KJ-)!!3!VV#'!`J!"!#HX)B$#!!%
!2DX%`e%!!3!fV#'!`3!"!$bV"-0'!!%!+U`KJ-)!!3!aV#'!`J!"!#LX)B$#!!%
!+D`KJ-)!!3!XV#'!`J!"!#fX)B$#!!%!2UX%`bN!!3!dV#'!`J!"!#@XDI6b!!%
!2kX%`b!!!3!cV#'!`J!"!%'Xrbq[!!%!1kY#c6)!!3"'!%J!5J"-!qF!!3!#!*!
)!J%!N!3+8(PdD'pZ3fpbC3#3(NB!N!G'!%J!5J"-!qF!!3!#!*!)!J#3"3a*ER4
PFQCKBf9-D@)!N"`"!*!(6J"3!&)!9!!!!!)!!J#3#!)"!*!%#A*eER4TE@8ZB`#
3(d!!N!G"VA-bD`!"!*!)!YkYQ!!!!4i!!"%@8%CXF`#3"!,HVY3!!")d!!!)6&"
-Fh3!N!S"(!!!!!*38f9Rrrm!N!NF!!!"!&"6C@F!!3!!GM)!!!%!!!!T-`!!+$-
!!!+b!!3!+!!+!F)#J!!S!!S"`J+!!*!1%'eKBh4MF'e[C(9XCA-ZEA9X!J!!!%e
08&*$9dP&!*!%68e38N0A588!N"LZUS!V!!!Dd!!!+q9S!*!B#J!#!*!,"!!##!#
3"-3!"0!!N%&TEQPdH(J!N!X#!!B!!!!+!!3!N!X`!!B"!2rr!*!)rrm"N!8!N!3
H!3%!N!LCQ3!!2rmrrcrr!3#3"%S!!3!*"Qe[EQ&ME`#3(!3!+!!+!F)#J!!S!!S
"`J+!!*!3!3#3"!)!N!88!!%!@!#Z!-m"d3#3"%S6!!!G0`!!!"S!!`!!QCN!N!4
rr`#3"(rr!*!%Irm!N!3+-!!%!!!!!`!(!3J!!3%kA*%!jNMN!!j[K'&cDb!!!!!
F!*!*[XUQ!,l,P!#qbk`!N!@r%e`!N!@r%e`!%#5!!*!Sc*!)!1C!d!$Q3'$GN!K
rrhrr!1C!K!#3"%#(!*!%"B3!!+%LrJ)!N!IQ30!!!cNb!*!6!3#qbf)![XY#!,m
(b!!!A*%!jNMN!!!!!f&cDb!!!!!F!*!*[XUQ!,l,P!#qbk`!N!@r%e`![iPF!,m
6'%e33d-"#!!"!MSkN3$Q513!$Qq%BA0V)!!!!"`!N!QqbUB![XZ8!,l,V!#3"Em
6A!#3"Em6A!!3*)!!N#M-N!J!jN$3!1C!B0f3#(rrIrm!jN#%!*!%3)F!N!3&K!!
!S5,q!J#3"qC!d!!$16)!N"-"!,l,BJ#qbd)![`I)!!"FN3$Q513!!!!$BA0V)!!
!!"`!N!QqbUB![XZ8!,l,V!#3"Em6A!#rL9`![a-B69"$3`'i!!)h1NeKBdp6)&0
eF("[FR3k6'PLFQ&bD@9c1P*eER4TE@8k8R9ZG'PYC5"38%-k+&0[GA*MCA-T1J!
!!"2[E!#3)!'MHpJ!N!A6%83!N!3"Sh[B!!)!!!(6ha!"V8(S!*!KjJ"c!2J!b!'
Y4r`!"!!i!G2J5!!!%83"dpp`,k$Gh3!2k#!!!2r"!$2#d!!6lf`!D`%r!'X"2`(
FF`J"h(48!GaBV!(FFd3"h&,X!GaJZ!!!!2m"I`#qrmIMIJ(6h`!"d`%!!!%B1MS
k3eG(990*)$%Z0Lid1QPZBfaeC'8k-!!6qC3!1D3)!!!dY!#3#Irrr`()p6J"b24
33J!#"2rGB'`"X@6*!FMdB!!#9E!"XAP3!D)Xd!()p(!!!P@`!"'lj!!e,`!!4!)
!!!%!!3!"!!%!!!!$!FMdX!#3"2rDi)3!!!!"!FMe!!!5qR`"Q)q`!E&Nc!()p-!
!%[Tm!"(+&!()pG)"b26!!!*9X2r8FF!!!+%L!FMdm!!$-8Mrf`1)!*!%!FMf%!!
6fI`!%pR`!FMf@J()p2!!%qCSrpe#1'Mrpd!"b28!!",h+!!4U&!"X@5S!2rrr`!
90c3"d3%!!!)N1NeKBdp6)&0eF("[FR3k5'9KC'9bFcT"6P0*)%KPB@4PFR-k!*!
LjN33!*!(!3!0HPJN!!J%!1C$N!!!%#33!1C&6!#3'4!J[!#3"HC&J!#3"3ekT!#
qk#"!RI&3!"!N%!#3"HC&KJ#3"4!NJ!!!S"`!N"AQ4*!!!*!*$ATB*)!)"!$Q4"!
!%#33!*!H!3!!!L3k6@&M6e-J8h9`F'pbG$T)C@&NCA*c1P"33b"6F'9MD@CTBcS
!N#,Q4"!!N!F"!!ek@#3!#!3!jN13!!!3*"!!jN9-!*!C%##m!*!&jN@!!*!&$AU
N!,lS)%#Gm9!!%#33!*!&jN@'!*!&%#5!!!#J(!#3&HC%N!!!N!N0HPJNJ!J%!1C
%%!!3*"!!N"i"!!!#2$T0B@028b"6GA"`Eh*d1NKPB@4PFR-k8hPcG'9Y)%9iG(*
KFb")C@&NCA*c1NeKBe4$8#")C@&NCA*c1J#3#ZC%%!#3"`%!$ATB*!!)"!$Q3j!
!!"!N%!$Q48`!N"N3),`!N!AQ4B!!N!80HU3![ZJJ3*ha8!!3*"!!N!AQ4BB!N!8
3*)!!!+!F!*!9jN53!!#3#3ek@#5!#!3!jN33!"!N%!#3(J%!!!)T1NeKBdp6)&0
eF("[FR3k5'9KC'9bFcT9EQPfCA*cB@`J5'9KC'9bFcS!N"hQ4"!!N!F"!!ek@#3
!#!3!jN13!!!3*"!!jN9-!*!C%##m!*!&jN@!!*!&$AUN!,lS)%#Gm9!!%#33!*!
&jN@'!*!&%#5!!!#J(!#3&HC%N!!!N!N0HPJNJ!J%!1C%%!!3*"!!N"i"!!!#*MT
0B@028b"6GA"`Eh*d1NaTBR*KFQPPFcT0B@028b"$EfeYEfik!*!JjN33!*!(!3!
0HPJN!!J%!1C$N!!!%#33!1C&6!#3'4!J[!#3"HC&J!#3"3ekT!#qk#"!RI&3!"!
N%!#3"HC&KJ#3"4!NJ!!!S"`!N"AQ4*!!!*!*$ATB*)!)"!$Q4"!!%#33!*!H!3!
!!Ldk6@&M6e-J8h9`F'pbG$T-D@*bBA*TCA-k8R9ZG'PYC6T5G@jdD@eP)&"33cS
!N"RQ4"!!N!F"!!ek@#3!#!3!jN13!!!3*"!!jN9-!*!C%##m!*!&jN@!!*!&$AU
N!,lS)%#Gm9!!%#33!*!&jN@'!*!&%#5!!!#J(!#3&HC%N!!!N!N0HPJNJ!J%!1C
%%!!3*"!!N#!8P!!'%%eKBdp6)&"33b"-D@jVCA)!N"!%%%eKBdp6)&"33b"-D@j
VCA)!N$!D39"36!#33'!!!!""F("X!*"!B!!!!%e06%)!N#!16'PL)%PYF'pbG#"
38%-!N"908%a'!*!J$NaTBL"*EA"[FR3J8&"$!*!969G$4!#33'!!!!"58e*$!*"
!B!!!!&4&@&3$,Q*SBmUV8!!$--J!&+h3!!!"IJ(+Ue!!&'A!!!!#eJa#B@aXEfp
Z)%KPE(!!N!8G"!(+Ui!!&'A!!BH@e!#3"&4&@&3#,Q-!N"d-69FJ3bp$+bXJ8&"
$!*!A9%9B9!3ZBbXV!*!E$%eA)%-[3bXV)&"33`#3&e4&@&3$,Q0M!*!F$%eA)%-
[3bXV)&"33`#3&e4&@&3$,Q0`!*!F$%eA)%-[3bXV)&"33`#3&e4&@&3%,Q0`F!#
3'`a09b"$,d-V+b"38%-!N"G849K8"#jPH(!!N$p849K8!LjS!*!G$%eA)%-[3bX
V)&"33`#3%a!!!!"849K8!Lj`!*!G$8eA)&"KFf0KE#"38%-!N"C849K8"#j`BA-
!N"X069FJ8'&cBf&X)&"33`#3&P4&@&3%,R"MD!#3'`a09b"$,d-V+b"38%-!N"1
!!!!!9%9B9!BZF'0S+bX!N"N-69FJ3bp$+bXJ8&"$!*!6J!!!!&4&@&3#,R)!N"d
'69FJ8Q9k!*!G9%9B9!)ZFfKMbUY3!!-`b!!8VG!!!!&q!FUV8!!8CF!!!!,@"P"
33d&cE@iJ5'9X!*!'(33"bUZ!!"4P`!'(PY3!N!4B3dp'!*!J%&K$6dC')%PYF'p
bG#"38%-!N"0NEf0e!*"!B!!!!(*cFQ-!N%"J!!!!FfKXBJ#3)!j348BJ5@e`Eh*
d)&"33`#3&A0dG@)!N#!18%9')%PYF'pbG#"38%-!N"N%,Q4[B`#31e!!!!!36@&
M6e-J0MK,)%aTEQYPFJ#3-"T"8&"-!*"!B!!!!%&`F'`!N%"J!!!!68e-3J#3)!j
-D@)J5@e`Eh*d)$Bi5`#3&8e36%B!N#!16'PL)%PYF'pbG#!f1%X!N"909d0%!*"
!B!!!!%p#5L!!N#!169"A)%PYF'pbG#!f1%X!N"958e*$!*"!B!!!!&4&@&3$,Q*
SBmUV8!!$--J!&+h3!!!"IJ(+Ue!!&'A!!!!#eJa#B@aXEfpZ)%KPE(!!N!8G"!(
+Ui!!&'A!!BH@e!#3"&4&@&3#,Q-!N"d-69FJ3bp$+bXJ0MK,!*!A9%9B9!3ZBbX
V!*!E$%eA)%-[3bXV)$Bi5`#3&e4&@&3$,Q0M!*!F$%eA)%-[3bXV)$Bi5`#3&e4
&@&3$,Q0`!*!F$%eA)%-[3bXV)$Bi5`#3&e4&@&3%,Q0`F!#3'`a09b"$,d-V+b!
f1%X!N"G849K8"#jPH($+Ue!!!c$)!"5Yd!!!!Ai"bUY3!"4P`!!!!YB!abTdP%L
VJ!(+VN3!%j98!!!G"!(+Ui!!&'A!!BHL2!#3"&4&@&3#,QJ!N"d-69FJ3bp$+bX
J0MK,!*!6%!!!!&4&@&3#,R!!N"d069FJ8'&cBf&X)$Bi5`#3&P4&@&3%,R"KF`#
3'`e09b"3BA0MB@`J0MK,!*!@9%9B9!3ZF'0S!*!E$%eA)%-[3bXV)$Bi5`#3%i!
!!!"849K8"Lj`BfJV+`#3'3a09b"$,d-V+b!f1%X!N"1!!!!!9%9B9!)ZFJ#3(3C
09b"5CAS!N"e849K8"#jcC@I+Ue!!!c$)!"5Yd!!!!Ai"bUY3!"4P`!!!!YB!abT
dP%LVJ!(+VN3!%j98!!!G"!(+Ui!!&'A!!BHL2!#3"'4[Bh8!N%"J!!!!FR0bB`#
33'!!!!"cD'aL!*!J$P"&4L"*EA"[FR3J0MKV!*!9Fh4eBJ#3)!j348BJ5@e`Eh*
d)$BiD`#3'33ZC'pM!*!l8!!!!""AD@ic-L"i1$BJ6'PZDf9b!*!`#94&@&3#,Q-
!N"d-69FJ3bp$+bXJH$Jf!*!A9%9B9!3ZBbXV!*!E$%eA)%-[3bXV)(Ji0J#3&e4
&@&3$,Q0`!*!F$%eA)%-[3bXV)(Ji0J#3&e4&@&3%,Q0`F!#3'`a09b"$,d-V+b"
i1$B!N"G849K8"#j`BfJ!N"X-69FJ3bp$+bXJH$Jf!*!6J!!!!&4&@&3',R"MD#X
V!*!C$%eA)%-[3bXV)(Ji0J#3%i!!!!"849K8!bjbB`#3(!K09b"AD@j53`#3(`3
ZE'PL!*!E$NaTBL"*EA"[FR3JH$Jf!*!C"#j[BQS!N"X16f*U)%PYF'pbG#"i1$B
!N"8*68-J6'PZDf9b!*!h#%e03dJ!N%4849K8!LjM!*!G#%e$)%-[3bXV!*!E9%9
B9!3ZBfac!*!E%8e$)%0XBA0c)%0[EA"TE'9b!*!1J!!!!&4&@&3%,Q4PCJ#32e4
&@&3%,Q4[B`#31a!!!!"849K8!LjS!*!p%!!!!&4&@&3%,R"MD!#3'`K03b"$,d-
V+`#3&i!!!!"849K8!bjdF`#33`B!!3%!N!B8!!3"!*!(!3#3$!S!!3%!!!%"!!%
!N!31!!F"!!%"!!%"!!!!!3#3"-B!"`#33Mq3"%&38%`!!!'!@)!!N%)rN!3!N!P
9!C!!!3)#H`#3"3)!!!!8!*!%!B!!N"%i!!N!N!F@EAGPFQYcAh"XG@GTEPpMEfj
QD@FZD!#3$!%!N!i-!!-!N!`"fJ!%!*!3!3#3r`#34&pIFh4KFR3!N(`"!!!!0J!
-!*!(!3#3*3%!N!8"!!!!$3!#!*!1&!!$!J!"!3!!!3%$!3#3#`S!!3%"!!!"!3!
"!!!!a!!'`J#3``%8!!8!!3!!-XJ!!$,)!!!bb!#3"!eYB@0dBh"YEf4eE'9c!*$
eZJ!%!!%4E@&MG'0`E@pNG@aPFbjcE')!N!j3HA4SFfKXBJ#3F3%rN!3!N!GA!+i
!kJ(4!3!!!!Y@!!"FN3!!!#i!!J!!!!)!!J#3+!)-!!)!8!!"!!%!!3!"!*$r!"3
R3dp%45FJ*d4"9%%R)#G35808*`#3lJS!"!#3#J%!!!!T-`!!+$-!!!+b!YkX@#H
U!!!!(!&k!!*`FQ9Q!"J!'R"@CA)!!!&'8e45)`!!!9)%X!!3!!!!"J#3"$U5!"d
!!!!8!*!%FFi!*!!!!%J!N!4E@J!T!!!!R!#3"(Pd!$J!!!#d!*!%$A-!5!!!!0)
!N!32PJ"9!!!,"J#3"&e+!&`!!"qH!*!%*k8!D3!!(kJ!N!3-a!"e!!!I`!#3"#H
U!)B!!"r1!*!%3hX!N3!!(q!!N!4&S`#G!!!JUJ#3"!hN!+`!!#$Q!*!%*ZJ!Z`!
!)2B!N!4kF3$#!!!Le!#3"'@X!0)!!#-1!*!%(YF!iJ!!)am!N!30V3$Z!!!M0`#
3"$#-!2m!!#0&!*!%@MF"#J!!*!d!N!3,L3%5!!!P*3#3"(I+!4i!!#AM!*!%F-F
"+`!!*K8!N!A)rrm!!#JP!*!3'i$rr`!!!*B!N!328(*[DQ9MG#"@CA*cD@pZ$&"
bEfTPBh3J6@PcB`C&C'PdEh)%4QpZG!j3FQpUC@0d)%9iG(*KF`p$GA0dEfdJ5f9
jGfpbC(--3@0MCA0c)&"KG'Kc"P4KFQGPG!a#G@PXC#"&H(4bBA-,0MK,)%0[C'9
(C@i30MK,)%4TFf&cFf9YBQaPFJSf1%XJ6'PZDf9b#cBi5b"3FQpUC@0d$N-[3bX
V)%0[EA"TE'9b$N-[3bXV)&GKFQjTEQGc"N0'66Bi5`p3BA0MB@`J3fpYF'PXCA)
28'&cBf&X)&GKFQjTEQGc#e"33b"$Ef4P4f9Z%&"33b"%DA0KFh0PE@*XCA)+8&"
$)%aTEQYPFJG38%-J8%9'#e"33b"3FQpUC@0d$&"33d&cE5"3B@jPE!a5CASJ3fp
YF'PXCA+qM`:

304
Mac/Unsupported/mactcp/socket.py
View file

@ -1,304 +0,0 @@
"""socket.py for mac - Emulate socket module with mactcp and macdnr
Currently only implements TCP sockets (AF_INET, SOCK_STREAM).
Esoteric things like socket options don't work,
but getpeername() and makefile() do work; everything used by ftplib works!
"""
# Jack Jansen, CWI, November 1994 (initial version)
# Guido van Rossum, CWI, March 1995 (bug fixes and lay-out)
import mactcp
import MACTCPconst
import macdnr
# Exported constants
_myerror = 'socket_wrapper.error'
error = (mactcp.error, macdnr.error, _myerror)
SOCK_DGRAM = 1
SOCK_STREAM = 2
AF_INET = 1
# Internal constants
_BUFSIZE = 15*1024 # Size of TCP/UDP input buffer
_myaddress = None
_myname = None
_myaddrstr = None
def _myipaddress():
global _myaddress
if _myaddress == None:
_myaddress = mactcp.IPAddr()
return _myaddress
def _ipaddress(str):
if type(str) == type(1):
return str # Already numeric
ptr = macdnr.StrToAddr(str)
ptr.wait()
return ptr.ip0
def gethostbyname(str):
id = _ipaddress(str)
return macdnr.AddrToStr(id)
def gethostbyaddr(str):
id = _ipaddress(str)
ptr = macdnr.AddrToName(id)
ptr.wait()
name = ptr.cname
if name[-1:] == '.': name = name[:-1]
names, addresses = [], [str]
return name, names, addresses
def gethostname():
global _myname
if _myname == None:
id = _myipaddress()
ptr = macdnr.AddrToName(id)
ptr.wait()
_myname = ptr.cname
return _myname
def _gethostaddress():
global _myaddrstr
if _myaddrstr == None:
id = _myipaddress()
_myaddrstr = macdnr.AddrToStr(id)
return _myaddrstr
def socket(family, type, *which):
if family <> AF_INET:
raise _myerror, 'Protocol family %d not supported' % type
if type == SOCK_DGRAM:
return _udpsocket()
elif type == SOCK_STREAM:
return _tcpsocket()
raise _myerror, 'Protocol type %d not supported' % type
def fromfd(*args):
raise _myerror, 'Operation not supported on a mac'
class _socket:
def unsupported(self, *args):
raise _myerror, 'Operation not supported on this socket'
accept = unsupported
bind = unsupported
close = unsupported
connect = unsupported
fileno = unsupported
getpeername = unsupported
getsockname = unsupported
getsockopt = unsupported
listen = unsupported
recv = unsupported
recvfrom = unsupported
send = unsupported
sendto = unsupported
setblocking = unsupported
setsockopt = unsupported
shutdown = unsupported
class _tcpsocket(_socket):
def __init__(self):
self.stream = mactcp.TCPCreate(_BUFSIZE)
##self.stream.asr = self.asr
self.databuf = ''
self.udatabuf = ''
self.port = 0
self.accepted = 0
self.listening = 0
def accept(self):
if not self.listening:
raise _myerror, 'Not listening'
self.listening = 0
self.stream.wait()
self.accepted = 1
return self, self.getsockname()
# bind has two ways of calling: s.bind(host, port) or s.bind((host, port));
# the latter is more proper but the former more common
def bind(self, a1, a2=None):
if a2 is None:
host, port = a1
else:
host, port = a1, a2
self.port = port
def close(self):
if self.accepted:
self.accepted = 0
return
self.stream.Abort()
# connect has the same problem as bind (see above)
def connect(self, a1, a2=None):
if a2 is None:
host, port = a1
else:
host, port = a1, a2
self.stream.ActiveOpen(self.port, _ipaddress(host), port)
def getsockname(self):
host, port = self.stream.GetSockName()
host = macdnr.AddrToStr(host)
return host, port
def getpeername(self):
st = self.stream.Status()
host = macdnr.AddrToStr(st.remoteHost)
return host, st.remotePort
def listen(self, backlog):
self.stream.PassiveOpen(self.port)
self.listening = 1
def makefile(self, rw = 'r', bs = 512):
return _socketfile(self, rw, bs)
def recv(self, bufsize, flags=0):
if flags:
raise _myerror, 'recv flags not yet supported on mac'
if not self.databuf:
try:
self.databuf, urg, mark = self.stream.Rcv(0)
except mactcp.error, arg:
if arg[0] != MACTCPconst.connectionClosing:
raise mactcp.error, arg
rv = self.databuf[:bufsize]
self.databuf = self.databuf[bufsize:]
return rv
def send(self, buf):
self.stream.Send(buf)
return len(buf)
def shutdown(self, how):
if how == 0:
return
self.stream.Close()
def bytes_readable(self):
st = self.stream.Status()
return st.amtUnreadData
def bytes_writeable(self):
st = self.stream.Status()
return st.sendWindow - st.sendUnacked;
class _udpsocket(_socket):
def __init__(self):
pass
class _socketfile:
def __init__(self, sock, rw, bs):
if rw[1:] == 'b': rw = rw[:1]
if rw not in ('r', 'w'): raise _myerror, "mode must be 'r' or 'w'"
self.sock = sock
self.rw = rw
self.bs = bs
self.buf = ''
def read(self, length = -1):
if length < 0:
length = 0x7fffffff
while len(self.buf) < length:
new = self.sock.recv(0x7fffffff)
if not new:
break
self.buf = self.buf + new
rv = self.buf[:length]
self.buf = self.buf[length:]
return rv
def readline(self):
import string
while not '\n' in self.buf:
new = self.sock.recv(0x7fffffff)
if not new:
break
self.buf = self.buf + new
if not '\n' in self.buf:
rv = self.buf
self.buf = ''
else:
i = string.index(self.buf, '\n')
rv = self.buf[:i+1]
self.buf = self.buf[i+1:]
return rv
def readlines(self):
list = []
line = self.readline()
while line:
list.append(line)
line = self.readline()
return list
def write(self, buf):
BS = self.bs
if len(buf) >= BS:
self.flush()
self.sock.send(buf)
elif len(buf) + len(self.buf) >= BS:
self.flush()
self.buf = buf
else:
self.buf = self.buf + buf
def writelines(self, list):
for line in list:
self.write(line)
def flush(self):
if self.buf and self.rw == 'w':
self.sock.send(self.buf)
self.buf = ''
def close(self):
self.flush()
##self.sock.close()
del self.sock
def __test_tcp():
s = socket(AF_INET, SOCK_STREAM)
s.connect('poseidon.cwi.nl', 13)
rv = s.recv(1000)
print 'Time/date:', rv
rv = s.recv(1000)
if rv:
print 'Unexpected extra data:', rv
s.close()
def __test_udp():
s = socket(AF_INET, SOCK_DGRAM)
print 'Sending data... (hello world)'
s.sendto(('poseidon.cwi.nl', 7), 'hello world')
rv, host = s.recvfrom(1000)
print 'Got from ', host, ':', rv

477
Mac/Unsupported/mactcp/tcpglue.c
View file

@ -1,477 +0,0 @@
/*
* Glue routines for mactcp module.
* Jack Jansen, CWI, 1994.
*
* Adapted from mactcp socket library, which was in turn
* adapted from ncsa telnet code.
*
* Original authors: Tom Milligan, Charlie Reiman
*/
# include <Memory.h>
# include <Files.h>
# include <Errors.h>
#include "tcpglue.h"
#include <Devices.h>
static short driver = 0;
#ifndef __powerc
/*
* Hack fix for MacTCP 1.0.X bug
*
* This hack doesn't work on the PPC. But then, people with new machines
* shouldn't run ancient buggy software. -- Jack.
*/
pascal char *ReturnA5(void) = {0x2E8D};
#endif /* !__powerc */
OSErr xOpenDriver()
{
if (driver == 0)
{
ParamBlockRec pb;
OSErr io;
pb.ioParam.ioCompletion = 0L;
pb.ioParam.ioNamePtr = "\p.IPP";
pb.ioParam.ioPermssn = fsCurPerm;
io = PBOpen(&pb,false);
if (io != noErr)
return(io);
driver = pb.ioParam.ioRefNum;
}
return noErr;
}
/*
* create a TCP stream
*/
OSErr xTCPCreate(buflen,notify,udp, pb)
int buflen;
TCPNotifyUPP notify;
void *udp;
TCPiopb *pb;
{
pb->ioCRefNum = driver;
pb->csCode = TCPCreate;
pb->csParam.create.rcvBuff = (char *)NewPtr(buflen);
pb->csParam.create.rcvBuffLen = buflen;
pb->csParam.create.notifyProc = notify;
pb->csParam.create.userDataPtr = udp;
return (xPBControlSync(pb));
}
/*
* start listening for a TCP connection
*/
OSErr xTCPPassiveOpen(TCPiopb *pb, short port, TCPIOCompletionUPP completion,
void *udp)
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = TCPPassiveOpen;
pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
pb->csParam.open.ulpTimeoutValue = 255 /* seconds */;
pb->csParam.open.ulpTimeoutAction = 0 /* 1:abort 0:report */;
pb->csParam.open.commandTimeoutValue = 0 /* infinity */;
pb->csParam.open.remoteHost = 0;
pb->csParam.open.remotePort = 0;
pb->csParam.open.localHost = 0;
pb->csParam.open.localPort = port;
pb->csParam.open.dontFrag = 0;
pb->csParam.open.timeToLive = 0;
pb->csParam.open.security = 0;
pb->csParam.open.optionCnt = 0;
pb->csParam.open.userDataPtr = udp;
return (xPBControl(pb,completion));
}
/*
* connect to a remote TCP
*/
OSErr xTCPActiveOpen(TCPiopb *pb, short port, long rhost, short rport,
TCPIOCompletionUPP completion)
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = TCPActiveOpen;
pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
pb->csParam.open.ulpTimeoutValue = 60 /* seconds */;
pb->csParam.open.ulpTimeoutAction = 1 /* 1:abort 0:report */;
pb->csParam.open.commandTimeoutValue = 0;
pb->csParam.open.remoteHost = rhost;
pb->csParam.open.remotePort = rport;
pb->csParam.open.localHost = 0;
pb->csParam.open.localPort = port;
pb->csParam.open.dontFrag = 0;
pb->csParam.open.timeToLive = 0;
pb->csParam.open.security = 0;
pb->csParam.open.optionCnt = 0;
return (xPBControl(pb,completion));
}
OSErr xTCPNoCopyRcv(pb,rds,rdslen,timeout,completion)
TCPiopb *pb;
rdsEntry *rds;
int rdslen;
int timeout;
TCPIOCompletionUPP completion;
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = TCPNoCopyRcv;
pb->csParam.receive.commandTimeoutValue = timeout; /* seconds, 0 = blocking */
pb->csParam.receive.rdsPtr = (Ptr)rds;
pb->csParam.receive.rdsLength = rdslen;
return (xPBControl(pb,completion));
}
OSErr xTCPBufReturn(TCPiopb *pb,rdsEntry *rds,TCPIOCompletionUPP completion)
{
pb->ioCRefNum = driver;
pb->csCode = TCPRcvBfrReturn;
pb->csParam.receive.rdsPtr = (Ptr)rds;
return (xPBControl(pb,completion));
}
/*
* send data
*/
OSErr xTCPSend(TCPiopb *pb, wdsEntry *wds, Boolean push, Boolean urgent, TCPIOCompletionUPP completion)
{
if (driver == 0)
return invalidStreamPtr;
pb->ioCRefNum = driver;
pb->csCode = TCPSend;
pb->csParam.send.validityFlags = timeoutValue | timeoutAction;
pb->csParam.send.ulpTimeoutValue = 60 /* seconds */;
pb->csParam.send.ulpTimeoutAction = 0 /* 0:abort 1:report */;
pb->csParam.send.pushFlag = push;
pb->csParam.send.urgentFlag = urgent;
pb->csParam.send.wdsPtr = (Ptr)wds;
return (xPBControl(pb,completion));
}
/*
* close a connection
*/
OSErr xTCPClose(TCPiopb *pb,TCPIOCompletionUPP completion)
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = TCPClose;
pb->csParam.close.validityFlags = timeoutValue | timeoutAction;
pb->csParam.close.ulpTimeoutValue = 60 /* seconds */;
pb->csParam.close.ulpTimeoutAction = 1 /* 1:abort 0:report */;
return (xPBControl(pb,completion));
}
/*
* abort a connection
*/
OSErr xTCPAbort(TCPiopb *pb)
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = TCPAbort;
return (xPBControlSync(pb));
}
/*
* close down a TCP stream (aborting a connection, if necessary)
*/
OSErr xTCPRelease(pb)
TCPiopb *pb;
{
OSErr io;
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = TCPRelease;
io = xPBControlSync(pb);
if (io == noErr)
DisposPtr(pb->csParam.create.rcvBuff); /* there is no release pb */
return(io);
}
#if 0
int
xTCPBytesUnread(sp)
SocketPtr sp;
{
TCPiopb *pb;
OSErr io;
if (!(pb = sock_fetch_pb(sp)))
return -1; /* panic */
if (driver == 0)
return(-1);
pb->ioCRefNum = driver;
pb->csCode = TCPStatus;
io = xPBControlSync(pb);
if (io != noErr)
return(-1);
return(pb->csParam.status.amtUnreadData);
}
int
xTCPBytesWriteable(sp)
SocketPtr sp;
{
TCPiopb *pb;
OSErr io;
long amount;
if (!(pb = sock_fetch_pb(sp)))
return -1; /* panic */
if (driver == 0)
return(-1);
pb->ioCRefNum = driver;
pb->csCode = TCPStatus;
io = xPBControlSync(pb);
if (io != noErr)
return(-1);
amount = pb->csParam.status.sendWindow-pb->csParam.status.amtUnackedData;
if (amount < 0)
amount = 0;
return amount;
}
int xTCPWriteBytesLeft(SocketPtr sp)
{
TCPiopb *pb;
OSErr io;
if (!(pb = sock_fetch_pb(sp)))
return -1; /* panic */
if (driver == 0)
return(-1);
pb->ioCRefNum = driver;
pb->csCode = TCPStatus;
io = xPBControlSync(pb);
if (io != noErr)
return(-1);
return (pb->csParam.status.amtUnackedData);
}
#endif
OSErr xTCPStatus(TCPiopb *pb, TCPStatusPB **spb)
{
OSErr io;
if (driver == 0)
return(-1);
pb->ioCRefNum = driver;
pb->csCode = TCPStatus;
io = xPBControlSync(pb);
if (io == noErr)
*spb = &pb->csParam.status;
return(io);
}
/*
* create a UDP stream, hook it to a socket.
*/
OSErr xUDPCreate(UDPiopb *pb,int buflen,ip_port *port, UDPNotifyUPP asr, void *udp)
{
OSErr io;
pb->ioCRefNum = driver;
pb->csCode = UDPCreate;
pb->csParam.create.rcvBuff = (char *)NewPtr(buflen);
pb->csParam.create.rcvBuffLen = buflen;
pb->csParam.create.notifyProc = asr;
pb->csParam.create.userDataPtr = udp;
pb->csParam.create.localPort = *port;
if ( (io = xPBControlSync( (TCPiopb *)pb ) ) != noErr)
return io;
*port = pb->csParam.create.localPort;
return noErr;
}
/*
* ask for incoming data
*/
OSErr xUDPRead(UDPiopb *pb, int timeout, UDPIOCompletionUPP completion)
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = UDPRead;
pb->csParam.receive.timeOut = timeout;
pb->csParam.receive.secondTimeStamp = 0/* must be zero */;
return (xPBControl ( (TCPiopb *)pb, (TCPIOCompletionUPP)completion ));
}
OSErr xUDPBfrReturn(UDPiopb *pb, char *buff)
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = UDPBfrReturn;
pb->csParam.receive.rcvBuff = buff;
return ( xPBControl( (TCPiopb *)pb,(TCPIOCompletionUPP)-1 ) );
}
/*
* send data
*/
OSErr xUDPWrite(UDPiopb *pb,ip_addr host,ip_port port,miniwds *wds,
UDPIOCompletionUPP completion)
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = UDPWrite;
pb->csParam.send.remoteHost = host;
pb->csParam.send.remotePort = port;
pb->csParam.send.wdsPtr = (Ptr)wds;
pb->csParam.send.checkSum = true;
pb->csParam.send.sendLength = 0/* must be zero */;
return (xPBControl( (TCPiopb *)pb, (TCPIOCompletionUPP)completion));
}
/*
* close down a UDP stream (aborting a read, if necessary)
*/
OSErr xUDPRelease(UDPiopb *pb) {
OSErr io;
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = UDPRelease;
io = xPBControlSync( (TCPiopb *)pb );
if (io == noErr) {
DisposPtr(pb->csParam.create.rcvBuff);
}
return(io);
}
ip_addr xIPAddr(void)
{
struct GetAddrParamBlock pbr;
OSErr io;
pbr.ioCRefNum = driver;
pbr.csCode = ipctlGetAddr;
io = xPBControlSync( (TCPiopb *)&pbr );
if (io != noErr)
return(0);
return(pbr.ourAddress);
}
long xNetMask()
{
struct GetAddrParamBlock pbr;
OSErr io;
pbr.ioCRefNum = driver;
pbr.csCode = ipctlGetAddr;
io = xPBControlSync( (TCPiopb *)&pbr);
if (io != noErr)
return(0);
return(pbr.ourNetMask);
}
unsigned short xMaxMTU()
{
struct UDPiopb pbr;
OSErr io;
pbr.ioCRefNum = driver;
pbr.csCode = UDPMaxMTUSize;
pbr.csParam.mtu.remoteHost = xIPAddr();
io = xPBControlSync( (TCPiopb *)&pbr );
if (io != noErr)
return(0);
return(pbr.csParam.mtu.mtuSize);
}
OSErr xPBControlSync(TCPiopb *pb)
{
(pb)->ioCompletion = 0L;
return PBControl((ParmBlkPtr)(pb),false);
}
#pragma segment SOCK_RESIDENT
OSErr xTCPRcv(pb,buf,buflen,timeout,completion)
TCPiopb *pb;
Ptr buf;
int buflen;
int timeout;
TCPIOCompletionUPP completion;
{
if (driver == 0)
return(invalidStreamPtr);
pb->ioCRefNum = driver;
pb->csCode = TCPRcv;
pb->csParam.receive.commandTimeoutValue = timeout; /* seconds, 0 = blocking */
pb->csParam.receive.rcvBuff = buf;
pb->csParam.receive.rcvBuffLen = buflen;
return (xPBControl(pb,completion));
}
OSErr xPBControl(TCPiopb *pb,TCPIOCompletionUPP completion)
{
#ifndef __MWERKS__
pb->ioNamePtr = ReturnA5();
#endif
if (completion == 0L)
{
(pb)->ioCompletion = 0L;
return(PBControl((ParmBlkPtr)(pb),false)); /* sync */
}
else if (completion == (TCPIOCompletionUPP)-1L)
{
(pb)->ioCompletion = 0L;
return(PBControl((ParmBlkPtr)(pb),true)); /* async */
}
else
{
(pb)->ioCompletion = completion;
return(PBControl((ParmBlkPtr)(pb),true)); /* async */
}
}

68
Mac/Unsupported/mactcp/tcpglue.h
View file

@ -1,68 +0,0 @@
/*
* Prototypes for mactcpglue routines and includes/structures needed
* by those.
*
* Jack Jansen, CWI, 1994.
*
* Adapted from mac socket library, which has in turn adapted from ncsa telnet.
* Original authors: Tom Milligan, Charlie Reiman
*/
#include <MacTCPCommonTypes.h>
#include <GetMyIPAddr.h>
#include <TCPPB.h>
#include <UDPPB.h>
#include <AddressXlation.h>
#ifndef __MWERKS__
#define TCPIOCompletionUPP TCPIOCompletionProc
#define TCPNotifyUPP TCPNotifyProc
#define UDPIOCompletionUPP UDPIOCompletionProc
#define UDPNotifyUPP UDPNotifyProc
#define NewTCPIOCompletionProc(x) (x)
#define NewTCPNotifyProc(x) (x)
#define NewUDPIOCompletionProc(x) (x)
#define NewUDPNotifyProc(x) (x)
#endif /* __MWERKS__ */
#if defined(powerc) || defined (__powerc)
#pragma options align=mac68k
#endif
typedef struct miniwds
{
unsigned short length;
char * ptr;
unsigned short terminus; /* must be zero'd for use */
} miniwds;
#if defined(powerc) || defined(__powerc)
#pragma options align=reset
#endif
OSErr xOpenDriver(void);
OSErr xPBControl(TCPiopb *pb, TCPIOCompletionUPP completion);
OSErr xPBControlSync(TCPiopb *pb);
OSErr xTCPCreate(int buflen, TCPNotifyUPP notify, void *udp, TCPiopb *pb);
OSErr xTCPPassiveOpen(TCPiopb *pb, short port, TCPIOCompletionUPP completion, void *udp);
OSErr xTCPActiveOpen(TCPiopb *pb, short port, long rhost, short rport, TCPIOCompletionUPP completion);
OSErr xTCPRcv(TCPiopb *pb, char *buf, int buflen, int timeout, TCPIOCompletionUPP completion);
OSErr xTCPNoCopyRcv(TCPiopb *,rdsEntry *,int,int,TCPIOCompletionUPP);
OSErr xTCPBufReturn(TCPiopb *pb,rdsEntry *rds,TCPIOCompletionUPP completion);
OSErr xTCPSend(TCPiopb *pb, wdsEntry *wds, Boolean push, Boolean urgent, TCPIOCompletionUPP completion);
OSErr xTCPClose(TCPiopb *pb,TCPIOCompletionUPP completion);
OSErr xTCPAbort(TCPiopb *pb);
OSErr xTCPRelease(TCPiopb *pb);
OSErr xUDPCreate(UDPiopb *pb,int buflen,ip_port *port, UDPNotifyUPP asr, void *udp);
OSErr xUDPRead(UDPiopb *pb,int timeout, UDPIOCompletionUPP completion);
OSErr xUDPBfrReturn(UDPiopb *pb, char *buff);
OSErr xUDPWrite(UDPiopb *pb,ip_addr host,ip_port port,miniwds *wds,
UDPIOCompletionUPP completion);
OSErr xUDPRelease(UDPiopb *pb);
ip_addr xIPAddr(void);
long xNetMask(void);
unsigned short xMaxMTU(void);

241
Mac/Unsupported/stdwinmodule.mu.exp
View file

@ -1,241 +0,0 @@
Drawingtype
initstdwin
ewpaste
ewcopy
ewundo
ewreplace
ewcloseall
ewsaveall
ewevent
ewwritefile
ewsetdimensions
ewreadfile
ewrevert
ewsaveprompt
ewsavecopy
ewsaveas
ewsave
ewclose
ewopen
ewnew
ewcreate
ewcount
ewfind
wparheight
wdrawpar
tesetbuf
tegetlen
tegettext
tegetnlines
tegetfoc2
tegetfoc1
tesetfocus
tenoview
tesetview
temovenew
temove
tegetbottom
tegetright
tegettop
tegetleft
teclicknew
tebackspace
tearrow
teevent
tereplace
tetextround
tewhereis
tewhichline
tewhichpoint
tesetcaret
teemptygap
tegrowgapby
temovegapto
tedrawnew
tedraw
techangefocus
tehidefocus
teshowfocus
tesetactive
tefree
tedestroy
tesetup
tecreate
tealloc
zrealloc
zmalloc
tedrawtext
tetextbreak
tetextwidth
wcprintf
wprintf
about_message
do_about
wargs_argv
wargs_argc
wargs
InitAEHandlers
wnocaret
wsetcaret
blinkcaret
rmcaret
wfetchcolor
_w_cursor
set_hand
set_applcursor
set_watch
set_arrow
wsetwincursor
wfetchcursor
std_type
wasktypelist
waskntypes
wperror
waskstr
waskync
wmessage
waskfile
dprintf
_w_fgcolor
_w_bgcolor
_w_font
_w_size
_w_usebgcolor
_w_usefgcolor
wsetbgcolor
wsetfgcolor
wgetbgcolor
wgetfgcolor
wnoclip
wcliprect
wxorpoly
wfillpoly
wdrawpoly
wxorelarc
wfillelarc
wdrawelarc
wxorcircle
wfillcircle
wdrawcircle
wshade
wpaint
winvert
w_erase
wdrawbox
wxorline
wdrawline
getwinrect
makerect
wdrawchar
wdrawtext
wcharwidth
wtextwidth
wbaseline
wlineheight
wsethilite
wsetunderline
wsetbolditalic
wsetitalic
wsetbold
wsetinverse
wsetplain
wsetstyle_
wsetsize
wsetfont
wlistfontnames
wsetwintextattr
wgetwintextattr
wsettextattr
wgettextattr
initwattr
wenddrawing
wbegindrawing
wupdate
_wupdate
scrollby
wscroll
wchange
_wm_down
active
_w_high_level_event_proc
_w_idle_proc
wgetactive
wsetactive
_wresetmouse
valid_border
inval_border
wgetevent
wpollevent
wungetevent
fullpath
getdirname
about_item
_wmenuhilite
setup_menus
_wdo_menu
rmlocalmenus
addlocalmenus
killmbar
initmbar
wmenusetdeflocal
wmenudetach
wmenuattach
wmenucheck
wmenuenable
wmenusetitem
wmenuadditem
wmenudelete
wmenucreate
PSTRING
wrotatecutbuffers
wgetcutbuffer
wsetcutbuffer
wresetselection
wgetselection
wsetselection
wsetclip
wgetclip
_wfreeclip
_wgrowicon
movescrollbars
hidescrollbars
showscrollbars
makescrollbars
dragscroll
autoscroll
do_scroll
_wfixorigin
wgetdocsize
wsetdocsize
wshow
wgetorigin
wsetorigin
wattr
screen
wgetdefscrollbars
wsetdefscrollbars
wgetdefwinsize
wsetdefwinsize
wgetdefwinpos
wsetdefwinpos
wsetmaxwinsize
wfleep
wgettitle
wsettitle
wsetwinpos
wgetwinpos
wsetwinsize
wgetwinsize
wclose
wopen
whichwin
wgetmouseconfig
wgetscrmm
wgetscrsize
wdone
winit
winitargs
strdup
checktimer
wsettimer
wtextbreak

182
Mac/Unsupported/stdwinmodule.mu.hqx
View file

@ -1,182 +0,0 @@
(This file must be converted with BinHex 4.0)
:$h0dC(GTEQe[C(9XC5jYG3"069"53eG*43#3""11!!!Vj9k[Bfp[E!!!!!%!!!!
F!!!6)J!!%ci!!!"3!!!!"!!!!'J!!J!`!!)!(!G6Eh9bBf9chC!)!*!C!J!`!!)
!+!P-D@*bBA*TCA2GN!B!N"N#!!!!!J!S#8aTBR*KFQPPFpf3"J#3(3)!+!$irr!
!N!8"e*3!N!BbaJ!!!!%!P,DS!*!0!J!!c-`!-Xc-QC!%!$2-c*QCCQB!0-c-QCN
c-`!ec-bCQ3!!!$E-c'CQrrm!0mc-CQE-c!!ic-aQCJ!$!!&!"J#3"!a*ER4PFQC
KBf9-D@)!N"1X6k9!!B&cG(9LV%qP3!!#!!3!N!31Fh4NGfPZ)&"33bj-D@)!N"'
Y6P"G!B&08%a'V8j3A3!$!!-!N!31Fh4NGfPZE@pNG@aP,Q-!N"'YFc++!B&849K
8VA-bLJ!%!!3!N!33G'9iG'9NDA3J8&"$,NaTBJ#3$ke18)%"J8e36%DY6P#"!!8
!!`#3"!aKE'a[BQTPBh4c,QJ!N"1Z#C!!13'!9%9B9+i*N!!j!!B!!`#3"!KMEfj
QD@FZD!#3&kec-NF"J&4&@&5YFc*(!!G!!`#3"!GcG'4TEbjS!*!BV6qZp!#!9%9
B9+drV[3!#%!$!*!%"hPfB@ac,QJ!N"LYXp4*!)"849K8VE2853!*3!-!N!3)Fh4
bD@jR,QJ!N"HY2kld!)"849K8V6qZp!!+3!-!N!3(CA*bEQmZD!#3'+drV[)!J&4
&@&5Y2klb!!X!!`#3"!PYHA"bEh4[,QJ!N"DYFc)H!B"849K8VA-b(J!-!!-!N!3
*FQ9ZB@eP-LjS!*!@VJQ3!$N"J&4&@&5Z#C!!13!0!!-!N!3)Ef*UC@0d,QJ!N"H
Z#C!!13'!9%9B9+i*N!!j!!i!!`#3"!P[BQTTEA"X,QJ!N"DYFc)H!B"849K8VA-
b(J!2!!-!N!31B@0MCA0cEf*UC@0d,QJ!N"'YFc)C!B"849K8VA-b'3!3!!-!N!3
,D@jdEf*UC@0d,QJ!N"5YFc)F!B"849K8VA-b(!!4!!-!N!3-E'pZCfpLDQ9MG#j
S!*!6VA-b(3'!9%9B9+ec-Kd!%J!$!*!%$@CXEf&dEf*UC@0d,QJ!N"+YFc)E!B"
849K8VA-b'`!6!!-!N!30FQ&ZCf9[BQTPBh3ZD!#3%Uec-Km"J&4&@&5YFc)I!"3
!!`#3"!jcG(*TEQG[BQTPBh3ZD!#3%Dec-Km"J&4&@&5YFc)I!"8!!`#3"!edGA"
XC@pLDQ9MG#jS!*!5VA-b)!'!9%9B9+ec-L!!&J!$!*!%$'aTFh4[BQTPBh3ZD!#
3%kec-Kd"J&4&@&5YFc)G!"F!!`#3"!pYBA"`D@jREf*UC@0d,QJ!N"#YFc)G!B"
849K8VA-b(3!B!!-!N!31E@9dD'pNEf*UC@0d,QJ!N"'YFc)G!B"849K8VA-b(3!
C!!-!N!31E@pNG@aPEf*UC@0d,QJ!N"'YFc)G!B"849K8VA-b(3!D!!-!N!3-CR9
ZBfpLDQ9MG#jS!*!6VA-b(!'!9%9B9+ec-K`!'`!$!*!%$@0XBA0cEf*UC@0d,QJ
!N"+YFc)D!B"849K8VA-b'J!F!!-!N!3-CQPXC@pLDQ9MG#jS!*!6VJQ3!$N"J&4
&@&5Z#C!!13!G!!-!N!3+EAPYB@aXEf-ZD!#3&Dec-Ki"J&4&@&5YFc)H!"j!!`#
3"!KcG'4XD@)ZD!#3&kdrV[3!J&4&@&5Y2kld!"m!!`#3"!aYEf4cGA"`Eh*d,QJ
!N"1YFc)G!B"849K8VA-b(3!J3!-!N!3)Fh4NBA*R,QJ!N"HY2kqp!)"849K8V6q
[[3!K3!-!N!3*Ah0dC'&bCbjS!*!@UX`2e`#!9%9B9+V-$pF!)J!$!*!%"f0PGQ&
X,QJ!N"LYFc)D!B"849K8VA-b'J!M!!-!N!3+B@*cG(*KBh3ZD!#3&Dec-KN"J&4
&@&5YFc)C!#3!!`#3"!YcHA0YEf4eE'8ZD!#3&+i*N!!j!B"849K8VJQ3!$N!*3!
$!*!%#@eKBfGXG@8ZD!#3&UiP4G`"J&4&@&5Z*8AF!#C!"3#3"!G8HA"PFbjS!*!
BVDdDU3#!9%9B9+fY'UN!*d!&!*!%%d0[EQ4TG'P[EQ&X6@&MFQpc,QJ!N!bY(r*
!!)"849K8V4rb3!!S3!8!N!3(4QPXCA-ZD!#3'+`KJ-!!J&4&@&5X)B$!!#P!"3#
3"!Y0DAKPC%e[C'8ZD!#3&+e6A-!!J&4&@&5Y8ec!!#T!"3#3"!P28e9dD@ac,QJ
!N"DYXp8l!)"849K8VE291`!V3!8!N!3)6@9YEh*j,QJ!N"HX)B$!!)"849K8V#'
!`!!X3!8!N!3)4ACPER4c,QJ!N"HY(r*!!)"849K8V4rb3!!Y3!8!N!3,8A9TBfY
NFQ&h,QJ!N"5XBKT!!)"849K8V')D3!!Z3!8!N!328A9TBfYNFQ&h9'9iG#jS!*!
3V#'!`!#!9%9B9+`KJ-!!,d!&!*!%$P0dB@jNBA*N4QPXC5jS!*!4V#'!`!#!9%9
B9+`KJ-!!-%!&!*!%#84TB@a[Ch-ZD!#3&U`KJ-!!J&4&@&5X)B$!!$&!"3#3"!K
&FR*[FR-ZD!#3&kdImN!!J&4&@&5Y(r*!!$*!"3#3"!G0C@jeFbjS!*!BV#'!`!#
!9%9B9+`KJ-!!-d!&!*!%#N0[ER4bEfac,QJ!N"@X)B$!!)"849K8V#'!`!!d3!8
!N!3*9fPZC'phFbjS!*!@V')D3!#!9%9B9+aL'N!!08!&!*!%#P4PH(4&C'Pd,QJ
!N"@X)B$!!)"849K8V#'!`!!f!!)!N!381MSkFh4NGfPZ1NJkFh4NGfPZ,QJ!N!m
"J&4&@&3!N!8h!!3!N!3(Ad&54e-ZD!#3'+cr2r!"J&4&@&5Xrcr`!$J!"!#3"!T
cG'4hG'9iG#jS!*!9V2mrm3'!9%9B9+cr2r%!13!&!*!%#A*eER4TE@8ZB`#3&Ub
[%(8"J&4&@&5XVa"e!$S!!`#3""CYGf9bDh0IF'aeCfPZAf0[EQCTCbjS!*!*VA-
bD`'!9%9B9+ec-QX!1`!$!*!%$f0[EA"XCAK[BQTPBh3ZD!#3%+i*N!!j!B"849K
8VJQ3!$N!2!!$!*!%#@0[BQTPBh3ZD!#3&Uec-KS"J&4&@&5YFc)D!$d!!`#3"!T
`H@9bFQpbFbjS!*!9VA-b(`'!9%9B9+ec-Km!2J!$!*!%#P"jG'K[EN0[FQ8!N"@
Z*RYp!B"cD'aLVLClI3!r!!-!N!3*F(PNC@*eCbjS!*!@VJQ3!$N"J&4&@&5Z#C!
!13"!!!-!N!3,G(*KBf9LB@0V,QJ!N"5YFc)J!B"849K8VA-b)!""!!-!N!3,F(P
dD'pZFR9Z,QJ!N"5Z#C!!13'!9%9B9+i*N!!j!%)!!`#3"!YTER4bBfKPBfXZD!#
3&+iC64J"J&4&@&5Z'8dB!%-!!`#3"!KTEA"[FR3ZD!#3&ki*N!!j!B"849K8VJQ
3!$N!4!!$!*!%$@*XG'PZE@pNG@aP,QJ!N"+Z#C!!13'!9%9B9+i*N!!j!!!$b!!
'!M`!!!!r!!%!N!J#!*!&$R0dC(GTEQe[C(9XC5jM!*!D!`#3"bHY(r*!!!%!-k`
KJ-!!!3!`V#'!`!!"!!UY2klb!!%!-DdImN!!!3!XV4rb3!!"!#LX)B$!!!%!+k`
KJ-!!!3!bV#'!`!!"!#QY8ec!!!%!+Ufce6X!!3!YV')D3!!"!#kX)B$!!!%!,k`
KJ-!!!3!JV6q[[3!"!!HY2kld!!%!(UdrV[3!!3!*V6qZp!!"!$@X)B$!!!%!*Uf
Y'UN!!3!dV')D3!!"!!LYXp4*!!%!)DV-$pF!!3!fV2mrm3!"!#1YFc)C!!%!$ke
c-KN!!3!&VJQ3!$N!!3"%VJQ3!$N!!3!LVA-b'J!"!"ZYFc)D!!%!2+ec-KS!!3!
lVJQ3!$N!!3!'VA-b4`!"!"bZ#C!!13!"!"+YFc)E!!%!'Uec-K`!!3"$VJQ3!$N
!!3!3VA-b(!!"!%+Z'8dB!!%!&Uec-Kd!!3!4VA-b(3!"!#@Z*8AF!!%!&kec-Kd
!!3!BVA-b(3!"!"qYFc)G!!%!'Dec-Kd!!3!kVA-bD`!"!"fYFc)H!!%!#kec-Ki
!!3!0VJQ3!$N!!3!1VA-b(J!"!$qZ#C!!13!"!$fYFc)I!!%!3Di*N!!j!!%!%ke
c-Km!!3!-VJQ3!$N!!3!iV2mrm3!"!"5YFc)I!!%!*+i*N!!j!!%!3+ec-L!!!3!
9VA-b)!!"!$HXrcr`!!%!4J")!%S!6!2R!!%!!3#3#!)!N!83G'9iG'9NDA3J8&"
$,NaTBJ#3'!3!N!G'!%J!5J"-!qF!!3!"!*!)!J#3"3jcG'4hD@iJ8&"$,NaTBJ#
3'J)!N!G'!%J!5J"-!qF!!3!#!*!)!J%!N!3+8(PdD'pZ3fpbC3#3(Mi!N!G'!%J
!5J"-!qF!!3!#!*!)!J%!N!3-5@jdCA*QB@0P6'PL!*!F!3#3"di!8!"5!&3!!!!
#!!)!N!J#!3#3"!PbG@jdD@eP,Q-!N"mj!*!(1Uec-QX!!3#3#!,HVZ!!!!%H!!!
1@&"'E(-!N!3#hUii!!!2GJ!!!mK36(0d!*!+!4`!!!!#8&0PCrrr!*!*(!!!!3"
38f9R!!%!!"3l!!!"!!!!+6-!!#Jc!!!#XN4'E'F!!!M14(*'FJ!!#0T*ENCX!!!
)jNa%48B!!!Mb$h0dC(GTEQe[C(9XC5jYG3)!!!"069"53eG*43!!!$3!!%e08&*
$9dP&!!!!0!#!!*!5VUU!+`!!%ii!!#[P#Ej*3diM!!)*bQPME$J!!!RZD@0X0!!
!#IT#6N4-!!!+"P08-$%!!!S54P*&4J!!#KjcEQ3J!!!++RNB!*!+HAcrrb!!#cX
!N!4jIIrr)!!1e!#3"(RP!'d!!"8-!*!%HH%!R`!!&q)!N!4ji`$L!!!JA!#3"`)
!"J!!!!S!"!#3#c!!"J%!rrm!N!Mrr`'3"3#3""i"!3#3#*QC!!!rrcrr2rm"!*!
%5J!"!!N'E@pZB@0[!*!F"!!S!!S"`J+!!#J!#J(#!S!!N"!"!*!%!J#3"43!!3"
B!+i!c`(4!*!%5K-!!"df!!!!'J!$!!#CQ3#3"(rr!*!%Irm!N!4rr`#3"!S`!!3
!!!!%!!B"#!!"!6TFN3$Q513!$Qq%BA0V)!!!!"`!N!QqbUB![XZ8!,l,V!#3"Em
5J!#3"Em5J!!3*)!!N#M-N!J!jN$3!1C!B0f3#(rrIrm!jN#%!*!%3)F!N!3&K!!
!S5,q!J#3"qC!d!!$16)!N"-"!,l,BJ#qbd)![`I)!!"FN3$Q513!!!!$BA0V)!!
!!"`!N!QqbUB![XZ8!,l,V!#3"Em5J!#r&J`![a%!69"$3`%)!!%#1MU4!1C)j!!
1Ei4KFfXJ!!!!(!#3#El+TJ#qbj3![XZX!*!&[a+!!*!&[a+!!"!NJ!#3+-b3#!$
Q30!!jN"JhC!)Irprr`$Q3)3!N!4!K`#3"!@%!!#K)[i#!*!(jN$3!!-j-J#3%`%
![XYL!,l,3J#r"mJ!!&b4!1C)j!!!!!0KFfXJ!!!!(!#3#El+TJ#qbj3![XZX!*!
&[a+!!,m@$!#r%3"08%0$!3J!!3Sk1MTcG'4hD@ikK'&cDb!!!!!F!*!*[XUQ!,l
,P!#qbk`!N!@r%S!!N!@r%S!!%#5!!*!Sc*!)!1C!d!$Q3'$GN!Krrhrr!1C!K!#
3"%#(!*!%"B3!!+%LrJ)!N!IQ30!!!cNb!*!6!3#qbf)![XY#!,m(b!!!A*%!jNM
N!!!!!f&cDb!!!!!F!*!*[XUQ!,l,P!#qbk`!N!@r%S!![aB-!,m4!%e33d-"B!!
#0cT0B@028b"6GA"`Eh*d1NaTBR*KFQPPFcT5G@jdD@eP1P*eER4TE@8J8&"$1LK
6Eh9bBf9c+6VHd%)!!J6rh@"X!E9C+3(6hZ!!!P@`!E9U)!'Y53`"dpl`!!*9X!!
3Gb3!0"E!!%E&N!!!!3!"!!%!!3!!!!-"dpm`!*!%rpVJK!!!!!%"dpq!!"'eV!'
MHP!"Y9NX!G2I3!!4YD`!%)98!G2J8J(6hd!!!P@`rp4a`!!!S5)"dpp`!!-a52r
E!iJ!N!3"dq#3!!!8*b`!&#FJ!G2JfJ(6hh!!&$1Brpe#1'Mrpd!"dpq!!"'b@!!
3Bj!!!E9C#!$rrrm!%rMN!G`"i!!"'$Sk1N0A4e9655!a,MBZ0$TTEQ0XG@4P1M!
!%rQ8!$QN#!!!0,3!N!Rrrrm"b28i!FMd8%)!!J6rh@"X!E,EL3()p'!!!P@`!E,
[S!'L,!J"b24`!!*9X!!4Zq3!05m!!%3#!!!"!!%!!3!"!!!!!`()p,!!N!6rfZ#
%!!!!!3()p3!!%[Tm!CL2X!'bfi`"b26!!",kI!!4bK3"b2A5!FMd`!!#9E$re((
!!!#K)J()p2!!!c&)rpX$L!#3"!()pK!!%pRm!"2Cm!()pPS"b26`!"2QD2rG3MK
SrrG!!FMe!!!5pbJ!%DK3!E,ED!$rrrm!&6Fd!G%"!!!#*$T0B@028b"6GA"`Eh*
d1NKPB@4PFR-k38j655")C@&NCA*c1J#3)ZC%%!#3"`%!$ATB*!!)"!$Q3j!!!"!
N%!$Q48`!N"N3),`!N!AQ4B!!N!80HU3![ZJJ3*ha8!!3*"!!N!AQ4BB!N!83*)!
!!+!F!*!9jN53!!#3#3ek@#5!#!3!jN33!"!N%!#3(J%!!!)N1NeKBdp6)&0eF("
[FR3k5'9KC'9bFcT38%-J8h"PBfPQD@-k!*!LjN33!*!(!3!0HPJN!!J%!1C$N!!
!%#33!1C&6!#3'4!J[!#3"HC&J!#3"3ekT!#qk#"!RI&3!"!N%!#3"HC&KJ#3"4!
NJ!!!S"`!N"AQ4*!!!*!*$ATB*)!)"!$Q4"!!%#33!*!H!3!!!LNk6@&M6e-J8h9
`F'pbG$T)C@&NCA*c1P9ZDACPFR0KE#")C@&NCA*c1J#3(HC%%!#3"`%!$ATB*!!
)"!$Q3j!!!"!N%!$Q48`!N"N3),`!N!AQ4B!!N!80HU3![ZJJ3*ha8!!3*"!!N!A
Q4BB!N!83*)!!!+!F!*!9jN53!!#3#3ek@#5!#!3!jN33!"!N%!#3(J%!!!)Q1Ne
KBdp6)&0eF("[FR3k6'PLFQ&bD@9c1NeKBdp6)%0[E@e[EMS!N#$Q4"!!N!F"!!e
k@#3!#!3!jN13!!!3*"!!jN9-!*!C%##m!*!&jN@!!*!&$AUN!,lS)%#Gm9!!%#3
3!*!&jN@'!*!&%#5!!!#J(!#3&HC%N!!!N!N0HPJNJ!J%!1C%%!!3*"!!N"i"!!!
#)6T0B@028b"6GA"`Eh*d1NaTBR*KFQPPFcT5G@jdD@eP1J#3*!%"bC!!!3IqX!!
!!!%!$e!i*!!)"!%"b4!!%J$J!3(+c!#3'4(pM!#3"!%"b`!""rk`!!p3K!$DE@!
!"*Lm!")!i!#3"!%"b`B!N!85!9!!!+!F!*!8!3(+%!#3#3p31#5!#!3"!FQ3!!!
5!1!!N#!8P!!'%%eKBdp6)&"33b"-D@jVCA)!N"!%%%eKBdp6)&"33b"-D@jVCA)
!N$!D39"36!#33'!!!!""F("X!*"!B!!!!%e06%)!N#!16'PL)%PYF'pbG#"38%-
!N"908%a'!*!J$NaTBL"*EA"[FR3J8&"$!*!969G$4!#33'!!!!"58e*$!*"!B!!
!!&4&@&3$,Q*SBmUV8!!$--J!&+h3!!!"IJ(+Ue!!&'A!!!!#eJa#B@aXEfpZ)%K
PE(!!N!8G"!(+Ui!!&'A!!BH@e!#3"&4&@&3#,Q-!N"d-69FJ3bp$+bXJ8&"$!*!
A9%9B9!3ZBbXV!*!E$%eA)%-[3bXV)&"33`#3&e4&@&3$,Q0M!*!F$%eA)%-[3bX
V)&"33`#3&e4&@&3$,Q0`!*!F$%eA)%-[3bXV)&"33`#3&e4&@&3%,Q0`F!#3'`a
09b"$,d-V+b"38%-!N"G849K8"#jPH(!!N$p849K8!LjS!*!G$%eA)%-[3bXV)&"
33`#3%a!!!!"849K8!Lj`!*!G$8eA)&"KFf0KE#"38%-!N"C849K8"#j`BA-!N"X
069FJ8'&cBf&X)&"33`#3&P4&@&3%,R"MD!#3'`a09b"$,d-V+b"38%-!N"1!!!!
!9%9B9!BZF'0S+bX!N"N-69FJ3bp$+bXJ8&"$!*!6J!!!!&4&@&3#,R)!N"d'69F
J8Q9k!*!G9%9B9!)ZFfKMbUY3!!-`b!!8VG!!!!&q!FUV8!!8CF!!!!,@"P"33d&
cE@iJ5'9X!*!'(33"bUZ!!"4P`!'(PY3!N!4B3dp'!*!J%&K$6dC')%PYF'pbG#"
38%-!N"0NEf0e!*"!B!!!!(*cFQ-!N%"J!!!!FfKXBJ#3)!j348BJ5@e`Eh*d)&"
33`#3&A0dG@)!N#!18%9')%PYF'pbG#"38%-!N"N%,Q4[B`#31e!!!!!36@&M6e-
J0MK,)%aTEQYPFJ#3-"T"8&"-!*"!B!!!!%&`F'`!N%"J!!!!68e-3J#3)!j-D@)
J5@e`Eh*d)$Bi5`#3&8e36%B!N#!16'PL)%PYF'pbG#!f1%X!N"909d0%!*"!B!!
!!%p#5L!!N#!169"A)%PYF'pbG#!f1%X!N"958e*$!*"!B!!!!&4&@&3$,Q*SBmU
V8!!$--J!&+h3!!!"IJ(+Ue!!&'A!!!!#eJa#B@aXEfpZ)%KPE(!!N!8G"!(+Ui!
!&'A!!BH@e!#3"&4&@&3#,Q-!N"d-69FJ3bp$+bXJ0MK,!*!A9%9B9!3ZBbXV!*!
E$%eA)%-[3bXV)$Bi5`#3&e4&@&3$,Q0M!*!F$%eA)%-[3bXV)$Bi5`#3&e4&@&3
$,Q0`!*!F$%eA)%-[3bXV)$Bi5`#3&e4&@&3%,Q0`F!#3'`a09b"$,d-V+b!f1%X
!N"G849K8"#jPH($+Ue!!!c$)!"5Yd!!!!Ai"bUY3!"4P`!!!!YB!abTdJjLVJ!(
+VN3!%j98!!!G"!(+Ui!!&'A!!BHL2!#3"&4&@&3#,QJ!N"d-69FJ3bp$+bXJ0MK
,!*!6%!!!!&4&@&3#,R!!N"d069FJ8'&cBf&X)$Bi5`#3&P4&@&3%,R"KF`#3'`e
09b"3BA0MB@`J0MK,!*!@9%9B9!3ZF'0S!*!E$%eA)%-[3bXV)$Bi5`#3%i!!!!"
849K8"Lj`BfJV+`#3'3a09b"$,d-V+b!f1%X!N"1!!!!!9%9B9!)ZFJ#3(3C09b"
5CAS!N"e849K8"#jcC@I+Ue!!!c$)!"5Yd!!!!Ai"bUY3!"4P`!!!!YB!abTdJjL
VJ!(+VN3!%j98!!!G"!(+Ui!!&'A!!BHL2!#3"'4[Bh8!N%"J!!!!FR0bB`#33'!
!!!"cD'aL!*!J$P"&4L"*EA"[FR3J0MKV!*!9Fh4eBJ#3)!j348BJ5@e`Eh*d)$B
iD`#3'33ZC'pM!*!l8!!!!""AD@ic-L"i1$BJ6'PZDf9b!*!`#94&@&3#,Q-!N"d
-69FJ3bp$+bXJH$Jf!*!A9%9B9!3ZBbXV!*!E$%eA)%-[3bXV)(Ji0J#3&e4&@&3
$,Q0`!*!F$%eA)%-[3bXV)(Ji0J#3&e4&@&3%,Q0`F!#3'`a09b"$,d-V+b"i1$B
!N"G849K8"#j`BfJ!N"X-69FJ3bp$+bXJH$Jf!*!6J!!!!&4&@&3',R"MD#XV!*!
C$%eA)%-[3bXV)(Ji0J#3%i!!!!"849K8!bjbB`#3(!K09b"AD@j53`#3(`3ZE'P
L!*!E$NaTBL"*EA"[FR3JH$Jf!*!C"#j[BQS!N"X16f*U)%PYF'pbG#"i1$B!N"8
*68-J6'PZDf9b!*!h#%e03dJ!N%4849K8!LjM!*!G#%e$)%-[3bXV!*!E9%9B9!3
ZBfac!*!E%8e$)%0XBA0c)%0[EA"TE'9b!*!1J!!!!&4&@&3%,Q4PCJ#32e4&@&3
%,Q4[B`#31a!!!!"849K8!LjS!*!p%!!!!&4&@&3%,R"MD!#3'`K03b"$,d-V+`#
3&i!!!!"849K8!bjdF`#33`B!!3%!N!B8!!3"!*!(!3#3$!S!!3%!!!%"!!%!N!3
1!!F"!!%"!!%"!!!!!3#3"-B!"`#33Mq3"%&38%`!!!'!@)!!N%)rN!3!N!P9!C!
!!3)#H`#3"3)!!!!8!*!%!B!!N"%i!!N!N!F@EAGPFQYcAh"XG@GTEPpMEfjQD@F
ZD!#3$!%!N!i-!!-!N!`"fJ!%!*!3!3#3r`#34&pIFh4KFR3!N(`"!!!!0J!-!*!
(!3#3*3%!N!8"!!!!$3!#!*!1&!!$!!!"!3!!!3%$!3#3#`S!!3%"!!!"!3!"!!!
!a!!'`J#33@PZDA4cG'4hD@i!N(J"&!!&!!%!!$,)!!!bb!!!-XJ!N!3'Fh4NGfP
Z!*$mZJ!%!!%3Fh4NGfPZE@pNG@aP,R0XBJ#3$e"jG'KcD'aL!*"a!6q3"!#3"eF
!VJ$U!G%"!!!!#eB!!&b4!!!!,J!#!!!!!J!#!*!S!J`!!J"3!!%!!3!"!!%!N2m
!&#G$6d4&*b!R4%&835FJ*e"*3e3R!*$Z#J!%!*!+!3!!!#Nc!!!S-`!!!V)#hUc
8*kS!!!!F!AS!!R"bC@B!'!!DF&CPFJ!!!8C69&)M!!!"8J5`!"!!!!!'!*!%3Li
!(3!!!"3!N!3a%J!N!!!!5!#3"'SC!#N!!!#F!*!%9lJ!1!!!!,3!N!3JIJ")!!!
!dJ#3"(%@!&8!!!X'!*!%EjJ!A!!!(ji!N!3+1J"T!!!IU!#3"(4#!(8!!"r!!*!
%C[B!KJ!!(mi!N!3lkJ#4!!!Ii!#3"(c'!*d!!##U!*!%5P!!V!!!)1B!N!36#`#
l!!!JpJ#3"'+S!-)!!#,8!*!%$qd!dJ!!)`i!N!4-P!$L!!!M(`#3""ca!1i!!#-
h!*!%)S3!r`!!)d8!N!30XJ%+!!!N$3#3"#8#!4)!!#8P!*!%8&!"(J!!*H-!N!3
mf`%V!!!Q&3#3"FMrr`!!+#8!N"!EJ2rr!!!!PJ#3"!p3FQpUC@0d)&CPFR0TEfi
-8(*[DQ9MG#"0DA0M"N9NDA4[FJ4'Efjd$P"bEfTPBh3J4AKdFQ&c$d0eFh4[E5"
,CAPhEh*NF`a"Bf0PFh-J8'&dD(-'9'&bCf9d$%*eD@aN)%9iG(*KF`Xf1%XJ3fp
NC8GPEK!f1%XJ4'PcBA0cC@eLE'9b#MBi5b"-D@jVCA),0MK,)&"bEfTPBh313bp
$+bXJ3fpYF'PXCA)13bp$+bXJ9f&bEQPZCh-'3dC00MK,$e"KFf0KE#"$Efe`D@a
PFJp3BA0MB@`J9f&bEQPZCh-,8&"$)%0[C'9(C@i38&"$)%4TFf&cFf9YBQaPFJT
38%-J6'PZDf9b"e"33b"348B,8&"$)&"bEfTPBh3-8&"$3A0Y)&"KEQ9X$&*PHL"
$Efe`D@aPFVA(:

549
Mac/Unsupported/twit/TwitCore.py
View file

@ -1,549 +0,0 @@
# Window-interface-independent part of twit
import sys
import types
import bdb
import types
import os
SIMPLE_TYPES=(
types.NoneType,
types.IntType,
types.LongType,
types.FloatType,
types.ComplexType,
types.StringType
)
# XXXX Mac-specific
ICON_NORMAL=500
ICON_RETURN=503
ICON_CALL=504
ICON_ZERO=505
ICON_DEAD=506
class DebuggerStuff(bdb.Bdb):
def __init__(self, parent):
bdb.Bdb.__init__(self)
self.parent = parent
self.exception_info = (None, None)
self.reason = 'Not running'
self.icon = ICON_NORMAL
self.reset()
def reset(self):
bdb.Bdb.reset(self)
self.forget()
def forget(self):
self.lineno = None
self.stack = []
self.curindex = 0
self.curframe = None
def run(self, cmd, locals, globals):
self.reason = 'Running'
bdb.Bdb.run(self, cmd, locals, globals)
print 'RETURN from run'
self.reason = 'Not running'
def setup(self, f, t):
self.forget()
self.stack, self.curindex = self.get_stack(f, t)
self.curframe = self.stack[self.curindex][0]
def interaction(self, frame, traceback):
self.setup(frame, traceback)
self.parent.interact()
self.exception_info = (None, None)
# def user_call(self, frame, argument_list):
# self.reason = 'Calling'
# self.icon = ICON_CALL
# self.interaction(frame, None)
def user_line(self, frame):
self.reason = 'Stopped'
self.icon = ICON_NORMAL
self.interaction(frame, None)
def user_return(self, frame, return_value):
self.reason = 'Returning'
self.icon = ICON_RETURN
self.interaction(frame, None)
def user_exception(self, frame, (exc_type, exc_value, exc_traceback)):
self.reason = 'Exception occurred'
self.icon = ICON_DEAD
self.parent.setstate('tb')
self.exception_info = (exc_type, exc_value)
self.interaction(frame, exc_traceback)
def getexception(self):
tp, value = self.exception_info
if tp <> None and type(tp) <> type(''):
tp = tp.__name__
if value <> None and type(value) <> type(''):
value = `value`
return tp, value
def getstacktrace(self):
names, locations = [], []
for frame, lineno in self.stack:
name = frame.f_code.co_name
if not name:
name = "<lambda>"
elif name == '?':
name = "<not a function>"
else:
name = name + '()'
names.append(name)
if lineno == -1:
lineno = getframelineno(frame)
modname = getframemodname(frame)
if not modname: modname = "<unknown>"
locations.append("%s:%d" % (modname, lineno))
return names, locations
def getframe(self, number):
if number < 0 or number >= len(self.stack):
return None
return self.stack[number][0]
def getframevars(self, number, show_complex=1, show_system=1):
frame = self.getframe(number)
if not frame:
return [], []
return getvarsfromdict(frame.f_locals, show_complex, show_system)
def getframevar(self, number, var):
frame = self.getframe(number)
return frame.f_locals[var]
def getframefilepos(self, frameno):
if frameno == None or frameno < 0 or frameno >= len(self.stack):
return None, None, None
frame, line = self.stack[frameno]
if line == -1:
line = getframelineno(frame)
modname = getframemodname(frame)
filename = frame.f_code.co_filename
return filename, modname, line
def getprogramstate(self):
return self.reason
class Application:
"""Base code for the application"""
def mi_init(self, sessiontype, arg):
self.dbg = DebuggerStuff(self)
self.run_dialog = self.new_stack_browser(self)
self.run_dialog.open()
self.module_dialog = None
self.initial_cmd = None
self.cur_string_name = None
if sessiontype == 'tb':
while arg.tb_next <> None:
arg = arg.tb_next
self.dbg.setup(arg.tb_frame, arg)
self.run_dialog.setup()
elif sessiontype == 'run':
self.initial_cmd = arg
def breaks_changed(self, filename):
self.run_dialog.breaks_changed(filename)
if self.module_dialog:
self.module_dialog.breaks_changed(filename)
def to_debugger(self):
cmd = self.initial_cmd
self.initial_cmd = None
self.setstate('run')
self.switch_to_app()
apply(self.dbg.run, cmd)
self.setstate('none')
self.switch_to_dbg()
self.run_dialog.update_views()
if self.module_dialog:
self.module_dialog.update_views()
def interact(self):
# Interact with user. First, display correct info
self.switch_to_dbg()
self.run_dialog.update_views()
if self.module_dialog:
self.module_dialog.update_views()
# Next, go into mainloop
self.one_mainloop()
# Finally (before we start the debuggee again) show state
self.switch_to_app()
self.run_dialog.show_it_running()
def quit_bdb(self):
self.dbg.set_quit()
def run(self):
cmd = self.AskString('Statement to execute:')
self.runstring(cmd)
def runfile(self, path):
dir, file = os.path.split(path)
try:
os.chdir(dir)
except os.error, arg:
self.Message("%s: %s"%(dir, arg))
return
ns = {'__name__':'__main__', '__file__':path}
cmd = "execfile('%s')"%file
self.runstring(cmd, ns, ns)
def runstring(self, cmd, globals={}, locals={}):
self.cur_string_name = '<string: "%s">'%cmd
try:
cmd = compile(cmd, self.cur_string_name, 'exec')
except SyntaxError, arg:
self.Message('Syntax error: %s'%`arg`)
return
self.initial_cmd = (cmd, globals, locals)
self.exit_mainloop()
def cont(self):
self.dbg.set_continue()
self.exit_mainloop()
def step(self, frame):
self.dbg.set_next(frame)
self.exit_mainloop()
def step_in(self):
self.dbg.set_step()
self.exit_mainloop()
def step_out(self, frame):
self.dbg.set_return(frame)
self.exit_mainloop()
def kill(self):
self.dbg.set_quit()
self.exit_mainloop()
def quit(self):
self.do_quit()
def browse(self, module):
if not self.module_dialog:
self.module_dialog = self.new_module_browser(self)
self.module_dialog.open(module)
else:
self.module_dialog.focus(module)
def browse_var(self, var):
b = self.new_var_browser(self, var)
class StackBrowser:
"""Base code for stack browser"""
def mi_open(self):
"""Setup initial data structures"""
self.cur_stackitem = None
self.cur_source = None
self.cur_modname = None
self.cur_line = None
self.show_complex = 1
self.show_system = 0
self.setup()
# create_items(self) should create self.modules, self.vars and self.source
def setup(self):
self.parent.SetWatch()
"""Fill the various widgets with values"""
name, value = self.parent.dbg.getexception()
self.setexception(name, value)
self.setprogramstate(self.parent.dbg.getprogramstate())
names, locations = self.parent.dbg.getstacktrace()
self.stack_setcontent(names, locations)
self.cur_stackitem = len(names)-1
self.stack_select(self.cur_stackitem)
self.setup_frame()
def setup_frame(self):
"""Setup frame-dependent widget data"""
self.parent.SetWatch()
self.cont_varnames, self.cont_varvalues = \
self.parent.dbg.getframevars(self.cur_stackitem,
self.show_complex, self.show_system)
self.setvars()
self.set_var_buttons()
msg = ""
if self.cur_stackitem == None:
self.cur_source = None
self.cur_modname = None
self.cur_line = None
msg = "No stackframe selected"
else:
self.cur_source, self.cur_modname, optnextline = \
self.parent.dbg.getframefilepos(self.cur_stackitem)
if optnextline >= 0:
self.cur_line = optnextline
if self.cur_source == '<string>':
self.cur_source = None
msg = "Executing from unknown <string>"
elif type(self.cur_source) == types.StringType and \
self.cur_source[:8] == '<string:':
msg = "Executing from "+self.cur_source
self.cur_source = None
self.setsource(msg)
if not self.cur_line:
self.source_setline(1, ICON_ZERO)
else:
self.source_setline(self.cur_line, self.parent.dbg.icon)
self.breaks_changed(self.cur_source)
self.parent.SetCursor()
# setsource(msg) should display cur_source+content, or msg if None
def show_it_running(self):
self.setprogramstate("Running")
def update_views(self):
self.setup()
def click_stack(self, number, *dummy):
if number == self.cur_stackitem: return
self.cur_stackitem = number
self.stack_select(self.cur_stackitem)
self.setup_frame()
def click_var(self, var, *dummy):
v = self.parent.dbg.getframevar(self.cur_stackitem, var)
self.parent.browse_var(v)
def click_source(self, lineno, inborder):
if not inborder:
self.source_select(lineno)
self.cur_line = lineno
if lineno == None or not self.cur_source or not inborder:
return
if self.parent.dbg.get_break(self.cur_source, lineno):
self.parent.dbg.clear_break(self.cur_source, lineno)
else:
self.parent.dbg.set_break(self.cur_source, lineno)
self.parent.breaks_changed(self.cur_source)
def breaks_changed(self, filename):
if filename == self.cur_source:
list = self.parent.dbg.get_file_breaks(filename)
self.source_setbreaks(list)
def click_quit(self):
self.parent.quit()
def click_run(self):
self.parent.run()
def click_continue(self):
self.parent.cont()
def click_step(self):
if self.cur_stackitem <> None:
frame = self.parent.dbg.getframe(self.cur_stackitem)
self.parent.step(frame)
else:
self.parent.step_in()
def click_step_in(self):
self.parent.step_in()
def click_step_out(self):
if self.cur_stackitem <> None:
frame = self.parent.dbg.getframe(self.cur_stackitem)
self.parent.step_out(frame)
else:
self.parent.step_in()
def click_kill(self):
self.parent.kill()
def click_browse(self):
self.parent.browse(self.cur_modname)
def click_edit(self):
lino = self.cur_line
if not lino:
lino = 1
if self.cur_source:
self.parent.edit(self.cur_source, lino)
class ModuleBrowser:
"""Base code for a module-browser"""
def mi_open(self, module):
"""Setup initial data structures"""
self.cur_module = module
self.cur_source = None
self.cur_line = None
self.cont_modules = []
self.value_windows = []
self.setup()
# create_items(self) should create self.modules, self.vars and self.source
def setup(self):
"""Fill the various widgets with values"""
self.parent.SetWatch()
modnames = getmodulenames()
if not self.cur_module in modnames:
self.cur_module = None
if modnames <> self.cont_modules:
self.cont_modules = modnames
self.setmodulenames()
if self.cur_module:
self.module_select(self.cont_modules.index(self.cur_module))
else:
self.module_select(None)
self.setup_module()
def setup_module(self):
"""Setup module-dependent widget data"""
self.parent.SetWatch()
if not self.cur_module:
self.cont_varnames = []
self.cont_varvalues = []
else:
self.cont_varnames, self.cont_varvalues = getmodulevars(self.cur_module)
self.setvars()
msg = ""
if not self.cur_module:
self.cur_source = None
msg = "No module selected"
else:
m = sys.modules[self.cur_module]
try:
self.cur_source = m.__file__
except AttributeError:
self.cur_source = None
msg = "Not a python module"
self.cur_lineno = 0
self.setsource(msg)
self.source_select(self.cur_line)
self.breaks_changed(self.cur_source)
self.parent.SetCursor()
# setsource(msg) should display cur_source+content, or msg if None
def update_views(self):
self.setup_module()
def click_module(self, module, *dummy):
if not module or module == self.cur_module: return
self.focus(module)
def focus(self, module):
self.cur_module = module
self.setup()
def click_var(self, var, *dummy):
if not var: return
m = sys.modules[self.cur_module]
dict = m.__dict__
self.parent.browse_var(dict[var])
def click_source(self, lineno, inborder):
if not inborder:
self.source_select(lineno)
self.cur_lineno = lineno
if lineno == None or not self.cur_source or not inborder:
return
if self.parent.dbg.get_break(self.cur_source, lineno):
self.parent.dbg.clear_break(self.cur_source, lineno)
else:
self.parent.dbg.set_break(self.cur_source, lineno)
self.parent.breaks_changed(self.cur_source)
def breaks_changed(self, filename):
if filename == self.cur_source:
list = self.parent.dbg.get_file_breaks(filename)
self.source_setbreaks(list)
def click_edit(self):
lino = self.cur_lineno
if not lino:
lino = 1
if self.cur_source:
self.parent.edit(self.cur_source, lino)
def getmodulenames():
"""Return a list of all current modules, sorted"""
list = sys.modules.keys()[:]
list.sort()
return list
def getmodulevars(name):
"""For given module return lists with names and values"""
m = sys.modules[name]
try:
dict = m.__dict__
except AttributeError:
dict = {}
return getvarsfromdict(dict)
def getvarsfromdict(dict, show_complex=1, show_system=1):
allnames = dict.keys()[:]
allnames.sort()
names = []
for n in allnames:
if not show_complex:
if not type(dict[n]) in SIMPLE_TYPES:
continue
if not show_system:
if n[:2] == '__' and n[-2:] == '__':
continue
names.append(n)
values = []
for n in names:
v = pretty(dict[n])
values.append(v)
return names, values
def pretty(var):
t = type(var)
if t == types.FunctionType: return '<function>'
if t == types.ClassType: return '<class>'
return `var`
def getframelineno(frame):
"""Given a frame return the line number"""
return getcodelineno(frame.f_code)
def getfunclineno(func):
"""Given a function return the line number"""
return getcodelineno(func.func_code)
def getcodelineno(cobj):
"""Given a code object return the line number"""
code = cobj.co_code
lineno = -1
if ord(code[0]) == 127: # SET_LINENO instruction
lineno = ord(code[1]) | (ord(code[2]) << 8)
return lineno
def getframemodname(frame):
"""Given a frame return the module name"""
globals = frame.f_globals
if globals.has_key('__name__'):
return globals['__name__']
return None

317
Mac/Unsupported/twit/mac_widgets.py
View file

@ -1,317 +0,0 @@
from FrameWork import *
import Win
import Qd
import Controls
import Ctl
import TE
import List
import os
import string
import macfs
SCROLLBAR=16
MARGIN=2
ICONSIZE=16
TEXTWIDTH=4096 # More-or-less random value
TEXTFONT=4
TEXTSIZE=9
# Resource numbers
PIC_CURRENT=500
PIC_BREAK=501
picture_cache={}
class MT_TextWidget:
def __init__(self, wid, r):
self.wid = wid
self.rect = r
left, top, right, bottom = r
self.terect = left+MARGIN+ICONSIZE, top+MARGIN, \
right-(MARGIN+SCROLLBAR), bottom-(MARGIN+SCROLLBAR)
dr = self.terect[0], self.terect[1], TEXTWIDTH, self.terect[3]
Qd.SetPort(wid)
Qd.TextFont(TEXTFONT)
Qd.TextSize(TEXTSIZE)
self.ted = TE.TENew(dr, self.terect)
self.ted.TEAutoView(1)
self.activate(1)
rect = right-SCROLLBAR, top, right, bottom-SCROLLBAR+1
self.bary = Ctl.NewControl(self.wid, rect, "", 1, 0, 0, 0, 16, 0)
rect = left, bottom-SCROLLBAR, right-SCROLLBAR+1, bottom
self.barx = Ctl.NewControl(self.wid, rect, "", 1, 0, 0, 0, 16, 0)
self.have_data = 0
self.line_index = []
def close(self):
del self.barx
del self.bary
del self.ted
def scrollbars(self):
pass
def setcontent(self, file):
self.line_index = []
if file == None:
data = ''
self.have_data = 0
else:
try:
fp = open(file, 'rb') # NOTE the binary
data = fp.read()
self.have_data = 1
except IOError, arg:
data = 'Cannot open file:\r'+`arg`
self.have_data = 0
if len(data) > 32767:
self.have_data = 0
data = 'File too big'
self.ted.TESetText(data)
if self.have_data:
cur = 0
while 1:
self.line_index.append(cur)
try:
cur = string.index(data, '\r', cur+1)
except ValueError:
break
self.line_index.append(len(data))
self.wid.InvalWindowRect(self.rect)
self.ted.TESetSelect(0,0)
self.ted.TECalText()
self.ted.TESelView()
self.setscrollbars()
def setscrollbars(self):
docleft, doctop, docright, docbot = self.ted.destRect
winleft, wintop, winright, winbot = self.ted.viewRect
docbot = self.ted.nLines*self.ted.lineHeight + doctop
self.setbar(self.barx, docleft, docright, winleft, winright)
self.setbar(self.bary, doctop, docbot, wintop, winbot)
def setbar(self, bar, minmin, maxmax, curmin, curmax):
if maxmax-minmin > 32767 or (curmin <= minmin and curmax >= maxmax):
bar.SetControlMinimum(0)
bar.SetControlMaximum(0)
bar.SetControlValue(0)
return
bar.SetControlMinimum(minmin)
bar.SetControlMaximum(maxmax-(curmax-curmin))
bar.SetControlValue(curmin)
def update(self, rgn):
Qd.EraseRect(self.terect)
Qd.FrameRect(self.rect)
self.ted.TEUpdate(self.terect)
def activate(self, onoff):
if onoff:
self.ted.TEActivate()
else:
self.ted.TEDeactivate()
def select(self, line):
if line == None or line <= 0 or not self.have_data:
self.ted.TESetSelect(0,0)
else:
line = line - 1
if line > len(self.line_index)-1: line = len(self.line_index)-1
if line == 1:
self.ted.TESetSelect(0, self.line_index[1])
else:
self.ted.TESetSelect(self.line_index[line]+1, self.line_index[line+1])
self.setscrollbars()
def click(self, where, modifiers):
# First check scrollbars
ctltype, control = Ctl.FindControl(where, self.wid)
if ctltype and control:
partcode = control.TrackControl(where)
if partcode:
self.controlhit(control, partcode)
return None, 0
off = self.ted.TEGetOffset(where)
inborder = where[0] < self.terect[0]
l, t, r, b = self.terect
if l <= where[0] <= r and t <= where[1] <= b or inborder:
return self.offsettoline(off), inborder
return None, 0 # In the grow box or something.
def offsettoline(self, offset):
for i in range(len(self.line_index)):
if offset < self.line_index[i]:
return i # Not i-1: 1-based line numbers in files
return None
def controlhit(self, control, partcode):
if partcode <> Controls.inThumb:
if control == self.barx:
if partcode == Controls.inUpButton:
delta = -10
if partcode == Controls.inDownButton:
delta = 10
if partcode == Controls.inPageUp:
delta = 10-(self.terect[2]-self.terect[0])
if partcode == Controls.inPageDown:
delta = (self.terect[2]-self.terect[0])-10
old = control.GetControlValue()
control.SetControlValue(old+delta)
if control == self.bary:
if partcode == Controls.inUpButton:
delta = -self.ted.lineHeight
if partcode == Controls.inDownButton:
delta = self.ted.lineHeight
if partcode == Controls.inPageUp:
delta = self.ted.lineHeight-(self.terect[3]-self.terect[1])
if partcode == Controls.inPageDown:
delta = (self.terect[3]-self.terect[1])-self.ted.lineHeight
old = control.GetControlValue()
control.SetControlValue(old+delta)
newx = self.barx.GetControlValue()
newy = self.bary.GetControlValue()
oldx = self.ted.viewRect[0]
oldy = self.ted.viewRect[1]
self.ted.TEPinScroll(oldx-newx, oldy-newy)
self.setscrollbars() # XXXX Bibbert, maar hoe anders?
class MT_IconTextWidget(MT_TextWidget):
def __init__(self, wid, r):
MT_TextWidget.__init__(self, wid, r)
self.breakpointlist = []
self.curline = None
self.iconrect = (self.rect[0]+1, self.rect[1]+1,
self.terect[0]-1, self.rect[3]-SCROLLBAR)
self.curlinerange = (self.terect[1]+self.ted.lineHeight,
self.terect[3]-2*self.ted.lineHeight)
self.piccurrent = PIC_CURRENT
def setbreaks(self, list):
self.breakpointlist = list[:]
Qd.SetPort(self.wid)
self.wid.InvalWindowRect(self.iconrect)
def setcurline(self, line, pic=PIC_CURRENT):
self.curline = line
self.piccurrent = pic
Qd.SetPort(self.wid)
self.showline(line)
def showline(self, line):
if line <= 0: line = 1
if line >= len(self.line_index): line = len(self.line_index)-1
if line < 0: return
off = self.line_index[line]
x, y = self.ted.TEGetPoint(off)
if self.curlinerange[0] <= y <= self.curlinerange[1]:
return # It is in view
middle = (self.curlinerange[0]+self.curlinerange[1])/2
self.ted.TEPinScroll(0, middle-y) # Of andersom?
self.setscrollbars()
def setscrollbars(self):
MT_TextWidget.setscrollbars(self)
self.wid.InvalWindowRect(self.iconrect)
def update(self, rgn):
MT_TextWidget.update(self, rgn)
self.drawallicons()
def drawallicons(self):
Qd.EraseRect(self.iconrect)
Qd.MoveTo(self.iconrect[2], self.iconrect[1])
Qd.LineTo(self.iconrect[2], self.iconrect[3])
topoffset = self.ted.TEGetOffset((self.terect[0], self.terect[1]))
botoffset = self.ted.TEGetOffset((self.terect[0], self.terect[3]))
topline = self.offsettoline(topoffset)
botline = self.offsettoline(botoffset)
if topline == None: topline = 1 # ???
if botline == None: botline = len(self.line_index)
for i in self.breakpointlist:
if topline <= i <= botline:
self.draw1icon(i, PIC_BREAK)
if self.curline <> None and topline <= self.curline <= botline:
self.draw1icon(self.curline, self.piccurrent)
def draw1icon(self, line, which):
offset = self.line_index[line]
botx, boty = self.ted.TEGetPoint(offset)
rect = self.rect[0]+2, boty-self.ted.lineHeight, \
self.rect[0]+ICONSIZE-2, boty
if not picture_cache.has_key(which):
picture_cache[which] = Qd.GetPicture(which)
self.drawicon(rect, picture_cache[which])
def drawicon(self, rect, which):
Qd.DrawPicture(which, rect)
class MT_IndexList:
def __init__(self, wid, rect, width):
# wid is the window (dialog) where our list is going to be in
# rect is it's item rectangle (as in dialog item)
self.rect = rect
rect2 = rect[0]+1, rect[1]+1, rect[2]-16, rect[3]-1
self.list = List.LNew(rect2, (0, 0, width, 0), (0,0), 0, wid,
0, 1, 0, 1)
self.wid = wid
self.width = width
def setcontent(self, *content):
self.list.LDelRow(0, 1)
self.list.LSetDrawingMode(0)
self.list.LAddRow(len(content[0]), 0)
for x in range(len(content)):
column = content[x]
for y in range(len(column)):
self.list.LSetCell(column[y], (x, y))
self.list.LSetDrawingMode(1)
self.wid.InvalWindowRect(self.rect)
def deselectall(self):
while 1:
ok, pt = self.list.LGetSelect(1, (0,0))
if not ok: return
self.list.LSetSelect(0, pt)
def select(self, num):
self.deselectall()
if num < 0:
return
for i in range(self.width):
self.list.LSetSelect(1, (i, num))
def click(self, where, modifiers):
is_double = self.list.LClick(where, modifiers)
ok, (x, y) = self.list.LGetSelect(1, (0, 0))
if ok:
return y, is_double
else:
return None, is_double
# draw a frame around the list, List Manager doesn't do that
def drawframe(self):
Qd.SetPort(self.wid)
Qd.FrameRect(self.rect)
def update(self, rgn):
self.drawframe()
self.list.LUpdate(rgn)
def activate(self, onoff):
self.list.LActivate(onoff)
class MT_AnyList(MT_IndexList):
def click(self, where, modifiers):
is_double = self.list.LClick(where, modifiers)
ok, (x, y) = self.list.LGetSelect(1, (0, 0))
if ok:
self.select(y)
field0 = self.list.LGetCell(1000,(0,y))
else:
field0 = None
return field0, is_double

267
Mac/Unsupported/twit/mactwit_app.py
View file

@ -1,267 +0,0 @@
import FrameWork
import MiniAEFrame
import EasyDialogs
import AE
import AppleEvents
import Res
import sys
import Qd
import Evt
import Events
import Dlg
import Win
import Menu
import TwitCore
import mactwit_mod
import mactwit_stack
import mactwit_browser
import mactwit_edit
import macfs
import string
# Resource-id (for checking existence)
ID_MODULES=500
ID_ABOUT=502
_arrow = Qd.qd.arrow
_watch = Qd.GetCursor(4).data
class Twit(FrameWork.Application, TwitCore.Application, MiniAEFrame.AEServer):
"""The twit main class - mac-dependent part"""
def __init__(self, sessiontype, arg=None):
# First init menus, etc.
self.app_menu_bar = Menu.GetMenuBar()
FrameWork.Application.__init__(self)
MiniAEFrame.AEServer.__init__(self)
AE.AESetInteractionAllowed(AppleEvents.kAEInteractWithAll)
self.installaehandler('aevt', 'odoc', self.ae_open_doc)
self.installaehandler('aevt', 'quit', self.do_quit)
self.installaehandler('pyth', 'EXEC', self.do_bbpyexec) # BBpy execute event
self.dbg_menu_bar = Menu.GetMenuBar()
self.setstate(sessiontype)
self._quitting = 0
self.real_quit = 0
self.window_aware = 1
# Next create our dialogs
self.mi_init(sessiontype, arg)
while 1:
if self.real_quit:
break
if self.initial_cmd:
self.to_debugger() # Will get to mainloop via debugger
else:
self.one_mainloop() # Else do it ourselves.
def switch_to_app(self):
if not self.window_aware:
return
self.dbg_menu_bar = Menu.GetMenuBar()
Menu.SetMenuBar(self.app_menu_bar)
Menu.DrawMenuBar()
def switch_to_dbg(self):
if not self.window_aware:
return
self.app_menu_bar = Menu.GetMenuBar()
Menu.SetMenuBar(self.dbg_menu_bar)
Menu.DrawMenuBar()
self.run_dialog.force_redraw()
if self.module_dialog:
self.module_dialog.force_redraw()
def makeusermenus(self):
self.filemenu = m = FrameWork.Menu(self.menubar, "Debug")
self._openitem = FrameWork.MenuItem(m, "Run File...", "O", self.do_open)
self._runitem = FrameWork.MenuItem(m, "Run String...", "R", self.do_run)
FrameWork.Separator(m)
self._awareitem = FrameWork.MenuItem(m, "Window-aware", "", self.do_aware)
self._awareitem.check(1)
FrameWork.Separator(m)
self._quititem = FrameWork.MenuItem(m, "Quit", "Q", self.do_quit)
self.controlmenu = m = FrameWork.Menu(self.menubar, "Control")
self._stepitem = FrameWork.MenuItem(m, "Step Next", "N", self.do_step)
self._stepinitem = FrameWork.MenuItem(m, "Step In", "S", self.do_stepin)
self._stepoutitem = FrameWork.MenuItem(m, "Step Out", "U", self.do_stepout)
self._continueitem = FrameWork.MenuItem(m, "Continue", "G", self.do_continue)
FrameWork.Separator(m)
self._killitem = FrameWork.MenuItem(m, "Kill", "K", self.do_kill)
def setstate(self, state):
self.state = state
if state == 'run':
self._stepitem.enable(1)
self._stepoutitem.enable(1)
self._stepinitem.enable(1)
self._continueitem.enable(1)
self._killitem.enable(1)
else:
self._stepitem.enable(0)
self._stepoutitem.enable(0)
self._stepinitem.enable(0)
self._continueitem.enable(0)
self._killitem.enable(0)
def asknewsession(self):
if self.state == 'none':
return 1
if EasyDialogs.AskYesNoCancel("Abort current debug session?") == 1:
self.quit_bdb()
return 1
return 0
def do_about(self, id, item, window, event):
import time
d = Dlg.GetNewDialog(ID_ABOUT, -1)
if not d:
return
w = d.GetDialogWindow()
port = w.GetWindowPort()
l, t, r, b = port.portRect
sl, st, sr, sb = Qd.qd.screenBits.bounds
x = ((sr-sl) - (r-l)) / 2
y = ((sb-st-16) - (b-t)) / 5
w.MoveWindow(x, y, 0)
w.ShowWindow()
d.DrawDialog()
tp, h, rect = d.GetDialogItem(2)
x0, y0, x1, y1 = rect
ybot = y0 + 32
rgn = Qd.NewRgn()
Qd.SetPort(d)
ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, 1)
if ok: return
(what, message, when, where, modifiers) = event
delta_t = 128
nexttime = when+delta_t
while ybot < y1:
# Do the animation, if it is time
if when > nexttime:
Qd.ScrollRect((x0, y0, x1, ybot), 0, 1, rgn)
y0 = y0 + 1
ybot = ybot + 1
# And update next time
delta_t = int(delta_t*0.6)-1
if delta_t < 0:
delta_t = 0
nexttime = when + delta_t
# Check for an event.
ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, 0)
if ok: return
(what, message, when, where, modifiers) = evt
while 1:
ok, evt = self.getevent(Events.mDownMask|Events.keyDownMask, -1)
if ok: return
def do_open(self, *args):
if not self.asknewsession():
return
fss, ok = macfs.StandardGetFile('TEXT')
if not ok: return
self.runfile(fss.as_pathname())
def ae_open_doc(self, object=None, **args):
if not object: return
if self.state <> 'none':
if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0:
if not self.asknewsession():
return
if type(object) == type([]):
object = object[0]
fss, changed = object.Resolve()
self.runfile(fss.as_pathname())
def do_bbpyexec(self, object=None, NAME=None, **args):
if type(object) <> type(''):
if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0:
EasyDialogs.Message('EXEC AppleEvent arg should be a string')
return
if self.state <> 'none':
if AE.AEInteractWithUser(AppleEvents.kAEDefaultTimeout) == 0:
if not self.asknewsession():
return
stuff = string.splitfields(object, '\r')
stuff = string.joinfields(stuff, '\n')
self.runstring(stuff)
def do_run(self, *args):
if not self.asknewsession():
return
self.run()
def do_aware(self, *args):
self.window_aware = not self.window_aware
self._awareitem.check(self.window_aware)
def do_quit(self, *args):
self._quit() # Signal FrameWork.Application to stop
self.real_quit = 1
self.quit_bdb() # Tell debugger to quit.
def do_step(self, *args):
self.run_dialog.click_step()
def do_stepin(self, *args):
self.run_dialog.click_step_in()
def do_stepout(self, *args):
self.run_dialog.click_step_out()
def do_continue(self, *args):
self.run_dialog.click_continue()
def do_kill(self, *args):
self.run_dialog.click_kill()
def exit_mainloop(self):
self._quit() # Signal FrameWork.Application to stop
self.real_quit = 0
def one_mainloop(self):
self.quitting = 0
self.mainloop()
def SetCursor(self):
Qd.SetCursor(_arrow)
def SetWatch(self):
Qd.SetCursor(_watch)
def AskString(self, *args):
return apply(EasyDialogs.AskString, args)
def Message(self, *args):
return apply(EasyDialogs.Message, args)
def new_module_browser(self, parent):
return mactwit_mod.ModuleBrowser(parent)
def new_stack_browser(self, parent):
return mactwit_stack.StackBrowser(parent)
def new_var_browser(self, parent, var):
return mactwit_browser.VarBrowser(parent).open(var)
def edit(self, file, line):
return mactwit_edit.edit(file, line)
def Initialize():
try:
# if this doesn't raise an error, we are an applet containing the
# necessary resources or we have been initialized already
# so we don't have to bother opening the resource file
dummy = Res.GetResource('DLOG', ID_MODULES)
except Res.Error:
try:
Res.FSpOpenResFile("Twit.rsrc", 1)
except Res.Error, arg:
EasyDialogs.Message("Cannot open Twit.rsrc: "+arg[1])
sys.exit(1)

429
Mac/Unsupported/twit/mactwit_browser.py
View file

@ -1,429 +0,0 @@
"""A simple Mac-only browse utility to peek at the inner data structures of Python."""
# Minor modifications by Jack to facilitate incorporation in twit.
# june 1996
# Written by Just van Rossum <just@knoware.nl>, please send comments/improvements.
# Loosely based on Jack Jansens's PICTbrowse.py, but depends on his fabulous FrameWork.py
# XXX Some parts are *very* poorly solved. Will fix. Guido has to check if all the
# XXX "python-peeking" is done correctly. I kindof reverse-engineered it ;-)
# disclaimer: although I happen to be the brother of Python's father, programming is
# not what I've been trained to do. So don't be surprised if you find anything that's not
# as nice as it could be...
# XXX to do:
# Arrow key support
# Copy & Paste?
# MAIN_TEXT item should not contain (type); should be below or something.
# MAIN_TEXT item should check if a string is binary or not: convert to '/000' style
# or convert newlines.
version = "1.0"
import FrameWork
import EasyDialogs
import Dlg
import Res
import Qd
import List
import sys
from Types import *
from QuickDraw import *
import string
import time
import os
# The initial object to start browsing with. Can be anything, but 'sys' makes kindof sense.
start_object = sys
# Resource definitions
ID_MAIN = 503
NUM_LISTS = 4 # the number of lists used. could be changed, but the dlg item numbers should be consistent
MAIN_TITLE = 3 # this is only the first text item, the other three ID's should be 5, 7 and 9
MAIN_LIST = 4 # this is only the first list, the other three ID's should be 6, 8 and 10
MAIN_TEXT = 11
MAIN_LEFT = 1
MAIN_RIGHT = 2
MAIN_RESET = 12
MAIN_CLOSE = 13
MAIN_LINE = 14
def Initialize():
# this bit ensures that this module will also work as an applet if the resources are
# in the resource fork of the applet
# stolen from Jack, so it should work(?!;-)
try:
# if this doesn't raise an error, we are an applet containing the necessary resources
# so we don't have to bother opening the resource file
dummy = Res.GetResource('DLOG', ID_MAIN)
except Res.Error:
savewd = os.getcwd()
ourparentdir = os.path.split(openresfile.func_code.co_filename)[0]
os.chdir(ourparentdir)
try:
Res.FSpOpenResFile("mactwit_browse.rsrc", 1)
except Res.Error, arg:
EasyDialogs.Message("Cannot open mactwit_browse.rsrc: "+arg[1])
sys.exit(1)
os.chdir(savewd)
def main():
Initialize()
PythonBrowse()
# this is all there is to it to make an application.
class PythonBrowse(FrameWork.Application):
def __init__(self):
FrameWork.Application.__init__(self)
VarBrowser(self).open(start_object)
self.mainloop()
def do_about(self, id, item, window, event):
EasyDialogs.Message(self.__class__.__name__ + " version " + version + "\rby Just van Rossum")
def quit(self, *args):
raise self
class MyList:
def __init__(self, wid, rect, itemnum):
# wid is the window (dialog) where our list is going to be in
# rect is it's item rectangle (as in dialog item)
# itemnum is the itemnumber in the dialog
self.rect = rect
rect2 = rect[0]+1, rect[1]+1, rect[2]-16, rect[3]-1 # Scroll bar space, that's 15 + 1, Jack!
self.list = List.LNew(rect2, (0, 0, 1, 0), (0,0), 0, wid,
0, 1, 0, 1)
self.wid = wid
self.active = 0
self.itemnum = itemnum
def setcontent(self, content, title = ""):
# first, gather some stuff
keylist = []
valuelist = []
thetype = type(content)
if thetype == DictType:
keylist = content.keys()
keylist.sort()
for key in keylist:
valuelist.append(content[key])
elif thetype == ListType:
keylist = valuelist = content
elif thetype == TupleType:
keylist = valuelist = []
for i in content:
keylist.append(i)
else:
# XXX help me! is all this correct? is there more I should consider???
# XXX is this a sensible way to do it in the first place????
# XXX I'm not familiar enough with Python's guts to be sure. GUIDOOOOO!!!
if hasattr(content, "__dict__"):
keylist = keylist + content.__dict__.keys()
if hasattr(content, "__methods__"):
keylist = keylist + content.__methods__
if hasattr(content, "__members__"):
keylist = keylist + content.__members__
if hasattr(content, "__class__"):
keylist.append("__class__")
if hasattr(content, "__bases__"):
keylist.append("__bases__")
if hasattr(content, "__name__"):
title = content.__name__
if "__name__" not in keylist:
keylist.append("__name__")
keylist.sort()
for key in keylist:
valuelist.append(getattr(content, key))
if content <> None:
title = title + "\r" + cleantype(content)
# now make that list!
tp, h, rect = self.wid.GetDialogItem(self.itemnum - 1)
Dlg.SetDialogItemText(h, title[:255])
self.list.LDelRow(0, 1)
self.list.LSetDrawingMode(0)
self.list.LAddRow(len(keylist), 0)
for i in range(len(keylist)):
self.list.LSetCell(str(keylist[i]), (0, i))
self.list.LSetDrawingMode(1)
self.list.LUpdate(self.wid.GetWindowPort().visRgn)
self.content = content
self.keylist = keylist
self.valuelist = valuelist
self.title = title
# draw a frame around the list, List Manager doesn't do that
def drawframe(self):
Qd.SetPort(self.wid)
Qd.FrameRect(self.rect)
rect2 = Qd.InsetRect(self.rect, -3, -3)
save = Qd.GetPenState()
Qd.PenSize(2, 2)
if self.active:
Qd.PenPat(Qd.qd.black)
else:
Qd.PenPat(Qd.qd.white)
# draw (or erase) an extra frame to indicate this is the acive list (or not)
Qd.FrameRect(rect2)
Qd.SetPenState(save)
class VarBrowser(FrameWork.DialogWindow):
def open(self, start_object, title = ""):
FrameWork.DialogWindow.open(self, ID_MAIN)
if title <> "":
windowtitle = self.wid.GetWTitle()
self.wid.SetWTitle(windowtitle + " >> " + title)
else:
if hasattr(start_object, "__name__"):
windowtitle = self.wid.GetWTitle()
self.wid.SetWTitle(windowtitle + " >> " + str(getattr(start_object, "__name__")) )
self.SetPort()
Qd.TextFont(3)
Qd.TextSize(9)
self.lists = []
self.listitems = []
for i in range(NUM_LISTS):
self.listitems.append(MAIN_LIST + 2 * i) # dlg item numbers... have to be consistent
for i in self.listitems:
tp, h, rect = self.wid.GetDialogItem(i)
list = MyList(self.wid, rect, i)
self.lists.append(list)
self.leftover = []
self.rightover = []
self.setup(start_object, title)
def close(self):
self.lists = []
self.listitems = []
self.do_postclose()
def setup(self, start_object, title = ""):
# here we set the starting point for our expedition
self.start = start_object
self.lists[0].setcontent(start_object, title)
for list in self.lists[1:]:
list.setcontent(None)
def do_listhit(self, event, item):
(what, message, when, where, modifiers) = event
Qd.SetPort(self.wid)
where = Qd.GlobalToLocal(where)
for list in self.lists:
list.active = 0
list = self.lists[self.listitems.index(item)]
list.active = 1
for l in self.lists:
l.drawframe()
point = (0,0)
ok, point = list.list.LGetSelect(1, point)
if ok:
oldsel = point[1]
else:
oldsel = -1
# This should be: list.list.LClick(where, modifiers)
# Since the selFlags field of the list is not accessible from Python I have to do it like this.
# The effect is that you can't select more items by using shift or command.
list.list.LClick(where, 0)
index = self.listitems.index(item) + 1
point = (0,0)
ok, point = list.list.LGetSelect(1, point)
if oldsel == point[1]:
return # selection didn't change, do nothing.
if not ok:
for i in range(index, len(self.listitems)):
self.lists[i].setcontent(None)
self.rightover = []
return
if point[1] >= len(list.keylist):
return # XXX is this still necessary? is ok really true?
key = str(list.keylist[point[1]])
value = list.valuelist[point[1]]
self.settextitem("")
thetype = type(value)
if thetype == ListType or \
thetype == TupleType or \
thetype == DictType or \
hasattr(value, "__dict__") or \
hasattr(value, "__methods__") or \
hasattr(value, "__members__"): # XXX or, or... again: did I miss something?
if index >= len(self.listitems):
# we've reached the right side of our dialog. move everything to the left
# (by pushing the rightbutton...)
self.do_rightbutton(1)
index = index - 1
newlist = self.lists[index]
newlist.setcontent(value, key)
else:
index = index - 1
self.settextitem( str(value) + "\r" + cleantype(value))
for i in range(index + 1, len(self.listitems)):
self.lists[i].setcontent(None)
self.rightover = []
# helper to set the big text item at the bottom of the dialog.
def settextitem(self, text):
tp, h, rect = self.wid.GetDialogItem(MAIN_TEXT)
Dlg.SetDialogItemText(h, text[:255])
def do_rawupdate(self, window, event):
Qd.SetPort(self.wid)
iType, iHandle, iRect = window.GetDialogItem(MAIN_LINE)
Qd.FrameRect(iRect)
for list in self.lists:
Qd.FrameRect(list.rect)
if list.active:
# see MyList.drawframe
rect2 = Qd.InsetRect(list.rect, -3, -3)
save = Qd.GetPenState()
Qd.PenSize(2, 2)
Qd.FrameRect(rect2)
Qd.SetPenState(save)
for list in self.lists:
list.list.LUpdate(self.wid.GetWindowPort().visRgn)
def do_activate(self, activate, event):
for list in self.lists:
list.list.LActivate(activate)
# scroll everything one 'unit' to the left
# XXX I don't like the way this works. Too many 'manual' assignments
def do_rightbutton(self, force = 0):
if not force and self.rightover == []:
return
self.scroll(-1)
point = (0, 0)
ok, point = self.lists[0].list.LGetSelect(1, point)
self.leftover.append((point, self.lists[0].content, self.lists[0].title, self.lists[0].active))
for i in range(len(self.lists)-1):
point = (0, 0)
ok, point = self.lists[i+1].list.LGetSelect(1, point)
self.lists[i].setcontent(self.lists[i+1].content, self.lists[i+1].title)
self.lists[i].list.LSetSelect(ok, point)
self.lists[i].list.LAutoScroll()
self.lists[i].active = self.lists[i+1].active
self.lists[i].drawframe()
if len(self.rightover) > 0:
point, content, title, active = self.rightover[-1]
self.lists[-1].setcontent(content, title)
self.lists[-1].list.LSetSelect(1, point)
self.lists[-1].list.LAutoScroll()
self.lists[-1].active = active
self.lists[-1].drawframe()
del self.rightover[-1]
else:
self.lists[-1].setcontent(None)
self.lists[-1].active = 0
for list in self.lists:
list.drawframe()
# scroll everything one 'unit' to the right
def do_leftbutton(self):
if self.leftover == []:
return
self.scroll(1)
if self.lists[-1].content <> None:
point = (0, 0)
ok, point = self.lists[-1].list.LGetSelect(1, point)
self.rightover.append((point, self.lists[-1].content, self.lists[-1].title, self.lists[-1].active ))
for i in range(len(self.lists)-1, 0, -1):
point = (0, 0)
ok, point = self.lists[i-1].list.LGetSelect(1, point)
self.lists[i].setcontent(self.lists[i-1].content, self.lists[i-1].title)
self.lists[i].list.LSetSelect(ok, point)
self.lists[i].list.LAutoScroll()
self.lists[i].active = self.lists[i-1].active
self.lists[i].drawframe()
if len(self.leftover) > 0:
point, content, title, active = self.leftover[-1]
self.lists[0].setcontent(content, title)
self.lists[0].list.LSetSelect(1, point)
self.lists[0].list.LAutoScroll()
self.lists[0].active = active
self.lists[0].drawframe()
del self.leftover[-1]
else:
self.lists[0].setcontent(None)
self.lists[0].active = 0
# create some visual feedback when 'scrolling' the lists to the left or to the right
def scroll(self, leftright): # leftright should be 1 or -1
# first, build a region containing all list rectangles
myregion = Qd.NewRgn()
mylastregion = Qd.NewRgn()
for list in self.lists:
AddRect2Rgn(list.rect, myregion)
AddRect2Rgn(list.rect, mylastregion)
# set the pen, but save it's state first
self.SetPort()
save = Qd.GetPenState()
Qd.PenPat(Qd.qd.gray)
Qd.PenMode(srcXor)
# how far do we have to scroll?
distance = self.lists[1].rect[0] - self.lists[0].rect[0]
step = 30
lasttime = time.clock() # for delay
# do it
for i in range(0, distance, step):
if i <> 0:
Qd.FrameRgn(mylastregion) # erase last region
Qd.OffsetRgn(mylastregion, step * leftright, 0)
# draw gray region
Qd.FrameRgn(myregion)
Qd.OffsetRgn(myregion, step * leftright, 0)
while time.clock() - lasttime < 0.05:
pass # delay
lasttime = time.clock()
# clean up after your dog
Qd.FrameRgn(mylastregion)
Qd.SetPenState(save)
def reset(self):
for list in self.lists:
point = (0,0)
ok, point = list.list.LGetSelect(1, point)
if ok:
sel = list.keylist[point[1]]
list.setcontent(list.content, list.title)
if ok:
list.list.LSetSelect(1, (0, list.keylist.index(sel)))
list.list.LAutoScroll()
def do_itemhit(self, item, event):
if item in self.listitems:
self.do_listhit(event, item)
elif item == MAIN_LEFT:
self.do_leftbutton()
elif item == MAIN_RIGHT:
self.do_rightbutton()
elif item == MAIN_CLOSE:
self.close()
elif item == MAIN_RESET:
self.reset()
# helper function that returns a short string containing the type of an arbitrary object
# eg: cleantype("wat is dit nu weer?") -> '(string)'
def cleantype(obj):
# type() typically returns something like: <type 'string'>
items = string.split(str(type(obj)), "'")
if len(items) == 3:
return '(' + items[1] + ')'
else:
# just in case, I don't know.
return str(type(obj))
# helper for VarBrowser.scroll
def AddRect2Rgn(theRect, theRgn):
rRgn = Qd.NewRgn()
Qd.RectRgn(rRgn, theRect)
Qd.UnionRgn(rRgn, theRgn, theRgn)
if __name__ == "__main__":
main()

24
Mac/Unsupported/twit/mactwit_edit.py
View file

@ -1,24 +0,0 @@
"""Edit a file using the MetroWerks editor. Modify to suit your needs"""
import MacOS
import aetools
import Metrowerks_Shell_Suite
import Required_Suite
_talker = None
class MWShell(aetools.TalkTo,
Metrowerks_Shell_Suite.Metrowerks_Shell_Suite,
Required_Suite.Required_Suite):
pass
def edit(file, line):
global _talker
if _talker == None:
_talker = MWShell('CWIE', start=1)
try:
_talker.open(file)
_talker.Goto_Line(line)
except "(MacOS.Error, aetools.Error)":
pass

114
Mac/Unsupported/twit/mactwit_mod.py
View file

@ -1,114 +0,0 @@
# A stab at a python debugger
import Res
import Qd
import Dlg
import Win
import FrameWork
import EasyDialogs
import sys
import TwitCore
from mac_widgets import MT_AnyList, MT_IconTextWidget
# Our dialogs
ID_MODULES=500
I_MODULES_TITLE=1
I_MODULES=2
I_VARS_TITLE=3
I_VARS=4
I_SOURCE_TITLE=5
I_SOURCE=6
I_RULER=7
I_EDIT=8
class ModuleBrowser(FrameWork.DialogWindow, TwitCore.ModuleBrowser):
"""The module-browser dialog - mac-dependent part"""
def open(self, module):
FrameWork.DialogWindow.open(self, ID_MODULES)
self.SetPort()
Qd.TextFont(3)
Qd.TextSize(9)
tp, h, rect = self.wid.GetDialogItem(I_MODULES)
self.modules = MT_AnyList(self.wid, rect, 1)
tp, h, rect = self.wid.GetDialogItem(I_VARS)
self.vars = MT_AnyList(self.wid, rect, 2)
tp, h, rect = self.wid.GetDialogItem(I_SOURCE)
self.source = MT_IconTextWidget(self.wid, rect)
self.mi_open(module)
def setsource(self, msg):
tp, h, rect = self.wid.GetDialogItem(I_SOURCE_TITLE)
if self.cur_source:
Dlg.SetDialogItemText(h, self.cur_source)
else:
Dlg.SetDialogItemText(h, msg)
self.source.setcontent(self.cur_source)
def source_setbreaks(self, list):
self.source.setbreaks(list)
def source_setline(self, lineno, icon):
self.source.setcurline(lineno, icon)
def source_select(self, lineno):
self.source.select(lineno)
def setmodulenames(self):
self.modules.setcontent(self.cont_modules)
def module_select(self, number):
self.modules.select(number)
def setvars(self):
self.vars.setcontent(self.cont_varnames, self.cont_varvalues)
def do_itemhit(self, item, event):
(what, message, when, where, modifiers) = event
Qd.SetPort(self.wid)
where = Qd.GlobalToLocal(where)
if item == I_MODULES:
new_module, double = self.modules.click(where, 0)
self.click_module(new_module)
elif item == I_VARS:
new_var, double = self.vars.click(where, 0)
if double:
self.click_var(new_var)
elif item == I_SOURCE:
lineno, inborder = self.source.click(where, 0)
if lineno <> None and lineno >= 0:
self.click_source(lineno, inborder)
elif item == I_EDIT:
self.click_edit()
def do_rawupdate(self, window, event):
Qd.SetPort(self.wid)
rgn = self.wid.GetWindowPort().visRgn
tp, h, rect = self.wid.GetDialogItem(I_RULER)
Qd.MoveTo(rect[0], rect[1])
Qd.LineTo(rect[2], rect[1])
self.modules.update(rgn)
self.vars.update(rgn)
self.source.update(rgn)
def force_redraw(self):
Qd.SetPort(self.wid)
self.wid.InvalWindowRgn(self.wid.GetWindowPort().visRgn)
def do_activate(self, activate, event):
self.modules.activate(activate)
self.vars.activate(activate)
self.source.activate(activate)
def close(self):
self.parent.module_dialog = None
self.source.close()
del self.modules
del self.vars
del self.source
self.do_postclose()
if __name__ == '__main__':
main()

159
Mac/Unsupported/twit/mactwit_stack.py
View file

@ -1,159 +0,0 @@
# A stab at a python debugger
import Res
import Qd
import Dlg
import Win
import FrameWork
import EasyDialogs
import sys
import TwitCore
from mac_widgets import MT_AnyList, MT_IndexList, MT_IconTextWidget
# Our dialogs
ID_STACK=501
I_STACK_TITLE=1
I_STACK=2
I_VARS_TITLE=3
I_VARS=4
I_SOURCE_TITLE=5
I_SOURCE=6
I_EXC_TITLE=7
I_EXC=8
I_EXCVALUE_TITLE=9
I_EXCVALUE=10
I_BROWSE=11
I_RULER1=12
I_RULER2=13
I_STATE_TITLE=14
I_STATE=15
I_SHOW_COMPLEX=16
I_SHOW_SYSTEM=17
I_EDIT=18
class StackBrowser(FrameWork.DialogWindow, TwitCore.StackBrowser):
"""The stack-browser dialog - mac-dependent part"""
def open(self):
FrameWork.DialogWindow.open(self, ID_STACK)
self.SetPort()
Qd.TextFont(3)
Qd.TextSize(9)
tp, h, rect = self.wid.GetDialogItem(I_STACK)
self.stack = MT_IndexList(self.wid, rect, 2)
tp, h, rect = self.wid.GetDialogItem(I_VARS)
self.vars = MT_AnyList(self.wid, rect, 2)
tp, h, rect = self.wid.GetDialogItem(I_SOURCE)
self.source = MT_IconTextWidget(self.wid, rect)
self.mi_open()
def setsource(self, msg):
tp, h, rect = self.wid.GetDialogItem(I_SOURCE_TITLE)
if self.cur_source:
Dlg.SetDialogItemText(h, self.cur_source)
else:
Dlg.SetDialogItemText(h, msg)
self.source.setcontent(self.cur_source)
def source_setbreaks(self, list):
self.source.setbreaks(list)
def source_setline(self, lineno, icon):
self.source.setcurline(lineno, icon)
def source_select(self, lineno):
self.source.select(lineno)
def stack_setcontent(self, names, locations):
self.stack.setcontent(names, locations)
def stack_select(self, number):
self.stack.select(number)
def setvars(self):
self.vars.setcontent(self.cont_varnames, self.cont_varvalues)
def setexception(self, name, value):
if name == None:
self.wid.HideDialogItem(I_EXC)
self.wid.HideDialogItem(I_EXC_TITLE)
value = None
else:
self.wid.ShowDialogItem(I_EXC)
self.wid.ShowDialogItem(I_EXC_TITLE)
tp, h, rect = self.wid.GetDialogItem(I_EXC)
Dlg.SetDialogItemText(h, name)
if value == None:
self.wid.HideDialogItem(I_EXCVALUE)
self.wid.HideDialogItem(I_EXCVALUE_TITLE)
else:
self.wid.ShowDialogItem(I_EXCVALUE)
self.wid.ShowDialogItem(I_EXCVALUE_TITLE)
tp, h, rect = self.wid.GetDialogItem(I_EXCVALUE)
Dlg.SetDialogItemText(h, value)
def setprogramstate(self, msg):
tp, h, rect = self.wid.GetDialogItem(I_STATE)
Dlg.SetDialogItemText(h, msg)
def do_itemhit(self, item, event):
(what, message, when, where, modifiers) = event
Qd.SetPort(self.wid)
where = Qd.GlobalToLocal(where)
if item == I_STACK:
new_stackitem, double = self.stack.click(where, 0)
self.click_stack(new_stackitem)
elif item == I_VARS:
new_var, double = self.vars.click(where, 0)
if double:
self.click_var(new_var)
elif item == I_SOURCE:
lineno, inborder = self.source.click(where, 0)
if lineno <> None and lineno >= 0:
self.click_source(lineno, inborder)
elif item == I_BROWSE:
self.click_browse()
elif item == I_SHOW_COMPLEX:
self.show_complex = not self.show_complex
self.setup_frame()
elif item == I_SHOW_SYSTEM:
self.show_system = not self.show_system
self.setup_frame()
elif item == I_EDIT:
self.click_edit()
def set_var_buttons(self):
tp, h, rect = self.wid.GetDialogItem(I_SHOW_COMPLEX)
h.as_Control().SetControlValue(self.show_complex)
tp, h, rect = self.wid.GetDialogItem(I_SHOW_SYSTEM)
h.as_Control().SetControlValue(self.show_system)
def do_rawupdate(self, window, event):
Qd.SetPort(self.wid)
rgn = self.wid.GetWindowPort().visRgn
tp, h, rect = self.wid.GetDialogItem(I_RULER1)
Qd.MoveTo(rect[0], rect[1])
Qd.LineTo(rect[2], rect[1])
tp, h, rect = self.wid.GetDialogItem(I_RULER2)
Qd.MoveTo(rect[0], rect[1])
Qd.LineTo(rect[2], rect[1])
self.stack.update(rgn)
self.vars.update(rgn)
self.source.update(rgn)
def force_redraw(self):
Qd.SetPort(self.wid)
self.wid.InvalWindowRgn(self.wid.GetWindowPort().visRgn)
def do_activate(self, activate, event):
self.stack.activate(activate)
self.vars.activate(activate)
self.source.activate(activate)
def close(self):
self.source.close()
del self.stack
del self.vars
del self.source
self.do_postclose()

59
Mac/Unsupported/twit/twit.py
View file

@ -1,59 +0,0 @@
"""twit - The Window-Independent Tracer.
Interface:
twit.main() Enter debugger in inactive interactive state
twit.run(stmt, globals, locals) Enter debugger and start running stmt
twit.post_mortem(traceback) Enter debugger in post-mortem mode on traceback
twit.pm() Enter debugger in pm-mode on sys.last_traceback
main program: nothing but a bit of glue to put it all together.
Jack Jansen, CWI, August 1996."""
import os
import sys
# Add our directory to path, if needed
dirname = os.path.split(__file__)[0]
if not dirname in sys.path:
sys.path.append(dirname)
if os.name == 'mac':
import MacOS
MacOS.splash(502) # Try to show the splash screen
import mactwit_app; twit_app = mactwit_app
else:
try:
import _tkinter
have_tk = 1
except ImportError:
have_tk = 0
if have_tk:
import tktwit_app; twit_app = tktwit_app
else:
print 'Please implementent machine-dependent code and try again:-)'
sys.exit(1)
import sys
def main():
twit_app.Initialize()
if os.name == 'mac':
MacOS.splash()
twit_app.Twit('none', None)
def run(statement, globals=None, locals=None):
twit_app.Initialize()
twit_app.Twit('run', (statement, globals, locals))
def post_mortem(t):
Initialize()
twit_app.Twit('pm', t)
def pm():
post_mortem(sys.last_traceback)
if __name__ == '__main__':
main()

1
Mac/Unsupported/twit/twit.rsrc
View file

File diff suppressed because one or more lines are too long

13
Mac/Unsupported/twit/twittest.py
View file

@ -1,13 +0,0 @@
# Test program
def foo(arg1, arg2):
bar(arg1+arg2)
bar(arg1-arg2)
foo(arg1+1, arg2-1)
def bar(arg):
rv = 10/arg
print rv
foo(0,10)