#include <config.h>
#include <stdio.h>
#include <errno.h>
#include <utime.h>
#include <dirent.h>
#include <sys/stat.h>
#include <string.h>
#include <pwd.h>
#include <sys/param.h>
#if __MWERKS__
#include <unistd.h>
#endif
#include <Files.h>
#include <MacTypes.h>
#include <TextUtils.h>
#include <Folders.h>
#include <Resources.h>
#include <Aliases.h>
#include <FixMath.h>
#include <Timer.h>
#include <OSA.h>
#include <AppleScript.h>
#include "lisp.h"
#include "process.h"
#include "sysselect.h"
#include "systime.h"
Lisp_Object QCLIPBOARD;
static ComponentInstance as_scripting_component;
static OSAID as_script_context;
void
string_cat_and_replace (char *s1, const char *s2, int n, char a, char b)
{
int l1 = strlen (s1);
int l2 = strlen (s2);
char *p = s1 + l1;
int i;
strncat (s1, s2, n);
for (i = 0; i < l2; i++)
{
if (*p == a)
*p = b;
p++;
}
}
int
mac_to_posix_pathname (const char *mfn, char *ufn, int ufnbuflen)
{
const char *p, *q, *pe;
strcpy (ufn, "");
if (*mfn == '\0')
return 1;
p = strchr (mfn, ':');
if (p != 0 && p != mfn)
strcat (ufn, "/");
p = mfn;
if (*p == ':')
p++;
pe = mfn + strlen (mfn);
while (p < pe)
{
q = strchr (p, ':');
if (q)
{
if (q == p)
{
if (strlen (ufn) + 3 >= ufnbuflen)
return 0;
strcat (ufn, "../");
}
else
{
if (strlen (ufn) + (q - p) + 1 >= ufnbuflen)
return 0;
string_cat_and_replace (ufn, p, q - p, '/', ':');
strcat (ufn, "/");
}
p = q + 1;
}
else
{
if (strlen (ufn) + (pe - p) >= ufnbuflen)
return 0;
string_cat_and_replace (ufn, p, pe - p, '/', ':');
p = pe;
}
}
return 1;
}
extern char *get_temp_dir_name ();
int
posix_to_mac_pathname (const char *ufn, char *mfn, int mfnbuflen)
{
const char *p, *q, *pe;
char expanded_pathname[MAXPATHLEN+1];
strcpy (mfn, "");
if (*ufn == '\0')
return 1;
p = ufn;
if (*p == '/' && strchr (p+1, '/') == NULL && strcmp (p, "/.emacs") != 0)
{
if (strlen (p) + 1 > mfnbuflen)
return 0;
strcpy (mfn, p+1);
strcat (mfn, ":");
return 1;
}
if (strncmp (p, "~emacs/", 7) == 0)
{
struct passwd *pw = getpwnam ("emacs");
p += 7;
if (strlen (pw->pw_dir) + strlen (p) > MAXPATHLEN)
return 0;
strcpy (expanded_pathname, pw->pw_dir);
strcat (expanded_pathname, p);
p = expanded_pathname;
}
else if (strncmp (p, "/tmp/", 5) == 0)
{
char *t = get_temp_dir_name ();
p += 5;
if (strlen (t) + strlen (p) > MAXPATHLEN)
return 0;
strcpy (expanded_pathname, t);
strcat (expanded_pathname, p);
p = expanded_pathname;
}
else if (*p != '/')
strcat (mfn, ":");
if (*p == '/')
p++;
pe = p + strlen (p);
while (p < pe)
{
q = strchr (p, '/');
if (q)
{
if (q - p == 2 && *p == '.' && *(p+1) == '.')
{
if (strlen (mfn) + 1 >= mfnbuflen)
return 0;
strcat (mfn, ":");
}
else
{
if (strlen (mfn) + (q - p) + 1 >= mfnbuflen)
return 0;
string_cat_and_replace (mfn, p, q - p, ':', '/');
strcat (mfn, ":");
}
p = q + 1;
}
else
{
if (strlen (mfn) + (pe - p) >= mfnbuflen)
return 0;
string_cat_and_replace (mfn, p, pe - p, ':', '/');
p = pe;
}
}
return 1;
}
#define MAC_UNIX_EPOCH_DIFF ((365L * 66 + 17) * 24 * 60 * 60)
#ifdef __MWERKS__
#ifndef CODEWARRIOR_VERSION_6
#define CW_OR_MPW_UNIX_EPOCH_DIFF ((365L * 70 + 17) * 24 * 60 * 60)
#else
#define CW_OR_MPW_UNIX_EPOCH_DIFF ((365L * 66 + 17) * 24 * 60 * 60)
#endif
#elif __MRC__
#define CW_OR_MPW_UNIX_EPOCH_DIFF ((365L * 66 + 17) * 24 * 60 * 60)
#else
You lose!!!
#endif
int
stat_noalias (const char *path, struct stat *buf)
{
char mac_pathname[MAXPATHLEN+1];
CInfoPBRec cipb;
if (posix_to_mac_pathname (path, mac_pathname, MAXPATHLEN+1) == 0)
return -1;
c2pstr (mac_pathname);
cipb.hFileInfo.ioNamePtr = mac_pathname;
cipb.hFileInfo.ioVRefNum = 0;
cipb.hFileInfo.ioDirID = 0;
cipb.hFileInfo.ioFDirIndex = 0;
errno = PBGetCatInfo (&cipb, false);
if (errno == -43)
errno = ENOENT;
if (errno != noErr)
return -1;
if (cipb.hFileInfo.ioFlAttrib & 0x10)
{
buf->st_mode = S_IFDIR | S_IREAD | S_IEXEC;
if (!(cipb.hFileInfo.ioFlAttrib & 0x1))
buf->st_mode |= S_IWRITE;
buf->st_ino = cipb.dirInfo.ioDrDirID;
buf->st_dev = cipb.dirInfo.ioVRefNum;
buf->st_size = cipb.dirInfo.ioDrNmFls;
buf->st_atime
= buf->st_mtime
= cipb.dirInfo.ioDrMdDat - MAC_UNIX_EPOCH_DIFF;
buf->st_ctime = cipb.dirInfo.ioDrCrDat - MAC_UNIX_EPOCH_DIFF;
}
else
{
buf->st_mode = S_IFREG | S_IREAD;
if (!(cipb.hFileInfo.ioFlAttrib & 0x1))
buf->st_mode |= S_IWRITE;
if (cipb.hFileInfo.ioFlFndrInfo.fdType == 'APPL')
buf->st_mode |= S_IEXEC;
buf->st_ino = cipb.hFileInfo.ioDirID;
buf->st_dev = cipb.hFileInfo.ioVRefNum;
buf->st_size = cipb.hFileInfo.ioFlLgLen;
buf->st_atime
= buf->st_mtime
= cipb.hFileInfo.ioFlMdDat - MAC_UNIX_EPOCH_DIFF;
buf->st_ctime = cipb.hFileInfo.ioFlCrDat - MAC_UNIX_EPOCH_DIFF;
}
if (cipb.hFileInfo.ioFlFndrInfo.fdFlags & 0x8000)
{
buf->st_mode &= ~S_IFREG;
buf->st_mode |= S_IFLNK;
}
buf->st_nlink = 1;
buf->st_uid = getuid ();
buf->st_gid = getgid ();
buf->st_rdev = 0;
return 0;
}
int
lstat (const char *path, struct stat *buf)
{
int result;
char true_pathname[MAXPATHLEN+1];
if ((result = stat_noalias (path, buf)) >= 0)
return result;
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
return stat_noalias (true_pathname, buf);
}
int
stat (const char *path, struct stat *sb)
{
int result;
char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
if ((result = stat_noalias (path, sb)) >= 0 &&
! (sb->st_mode & S_IFLNK))
return result;
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
{
fully_resolved_name[len] = '\0';
return lstat (fully_resolved_name, sb);
}
else
return lstat (true_pathname, sb);
}
#if __MRC__
int
fstat (int fildes, struct stat *buf)
{
buf->st_dev = 0;
buf->st_ino = fildes;
buf->st_mode = S_IFREG;
return 0;
}
#endif
int
mkdir (const char *dirname, int mode)
{
#pragma unused(mode)
HFileParam hfpb;
char true_pathname[MAXPATHLEN+1], mac_pathname[MAXPATHLEN+1];
if (find_true_pathname (dirname, true_pathname, MAXPATHLEN+1) == -1)
return -1;
if (posix_to_mac_pathname (true_pathname, mac_pathname, MAXPATHLEN+1) == 0)
return -1;
c2pstr (mac_pathname);
hfpb.ioNamePtr = mac_pathname;
hfpb.ioVRefNum = 0;
hfpb.ioDirID = 0;
errno = PBDirCreate ((HParmBlkPtr) &hfpb, false);
return errno == noErr ? 0 : -1;
}
#undef rmdir
sys_rmdir (const char *dirname)
{
HFileParam hfpb;
char mac_pathname[MAXPATHLEN+1];
if (posix_to_mac_pathname (dirname, mac_pathname, MAXPATHLEN+1) == 0)
return -1;
c2pstr (mac_pathname);
hfpb.ioNamePtr = mac_pathname;
hfpb.ioVRefNum = 0;
hfpb.ioDirID = 0;
errno = PBHDelete ((HParmBlkPtr) &hfpb, false);
return errno == noErr ? 0 : -1;
}
#ifdef __MRC__
int
execvp (const char *path, ...)
{
return -1;
}
#endif
int
utime (const char *path, const struct utimbuf *times)
{
char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
CInfoPBRec cipb;
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
else
strcpy (fully_resolved_name, true_pathname);
if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
return -1;
c2pstr (mac_pathname);
cipb.hFileInfo.ioNamePtr = mac_pathname;
cipb.hFileInfo.ioVRefNum = 0;
cipb.hFileInfo.ioDirID = 0;
cipb.hFileInfo.ioFDirIndex = 0;
errno = PBGetCatInfo (&cipb, false);
if (errno != noErr)
return -1;
if (cipb.hFileInfo.ioFlAttrib & 0x10)
{
if (times)
cipb.dirInfo.ioDrMdDat = times->modtime + MAC_UNIX_EPOCH_DIFF;
else
GetDateTime (&cipb.dirInfo.ioDrMdDat);
}
else
{
if (times)
cipb.hFileInfo.ioFlMdDat = times->modtime + MAC_UNIX_EPOCH_DIFF;
else
GetDateTime (&cipb.hFileInfo.ioFlMdDat);
}
errno = PBSetCatInfo (&cipb, false);
return errno == noErr ? 0 : -1;
}
#ifndef F_OK
#define F_OK 0
#endif
#ifndef X_OK
#define X_OK 1
#endif
#ifndef W_OK
#define W_OK 2
#endif
int
access (const char *path, int mode)
{
char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
CInfoPBRec cipb;
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
else
strcpy (fully_resolved_name, true_pathname);
if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
return -1;
c2pstr (mac_pathname);
cipb.hFileInfo.ioNamePtr = mac_pathname;
cipb.hFileInfo.ioVRefNum = 0;
cipb.hFileInfo.ioDirID = 0;
cipb.hFileInfo.ioFDirIndex = 0;
errno = PBGetCatInfo (&cipb, false);
if (errno != noErr)
return -1;
if (mode == F_OK)
return 0;
if (mode & X_OK)
if (cipb.hFileInfo.ioFlAttrib & 0x10)
return 0;
else
{
if (cipb.hFileInfo.ioFlFndrInfo.fdType == 'APPL')
return 0;
else
return -1;
}
if (mode & W_OK)
return (cipb.hFileInfo.ioFlAttrib & 0x1) ? -1 : 0;
return -1;
}
#define DEV_NULL_FD 0x10000
#undef open
int
sys_open (const char *path, int oflag)
{
char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
if (strcmp (path, "/dev/null") == 0)
return DEV_NULL_FD;
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
else
strcpy (fully_resolved_name, true_pathname);
if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
return -1;
else
{
#ifdef __MRC__
int res = open (mac_pathname, oflag);
if (oflag & O_CREAT)
fsetfileinfo (mac_pathname, 'EMAx', 'TEXT');
return res;
#else
return open (mac_pathname, oflag);
#endif
}
}
#undef creat
int
sys_creat (const char *path, mode_t mode)
{
char true_pathname[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
if (!posix_to_mac_pathname (true_pathname, mac_pathname, MAXPATHLEN+1))
return -1;
else
{
#ifdef __MRC__
int result = creat (mac_pathname);
fsetfileinfo (mac_pathname, 'EMAx', 'TEXT');
return result;
#else
return creat (mac_pathname, mode);
#endif
}
}
#undef unlink
int
sys_unlink (const char *path)
{
char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
return -1;
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
else
strcpy (fully_resolved_name, true_pathname);
if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
return -1;
else
return unlink (mac_pathname);
}
#undef read
int
sys_read (int fildes, char *buf, int count)
{
if (fildes == 0)
return -1;
else
#ifdef CODEWARRIOR_VERSION_6
return _read (fildes, buf, count);
#else
return read (fildes, buf, count);
#endif
}
#undef write
int
sys_write (int fildes, const char *buf, int count)
{
if (fildes == DEV_NULL_FD)
return count;
else
#ifdef CODEWARRIOR_VERSION_6
return _write (fildes, buf, count);
#else
return write (fildes, buf, count);
#endif
}
#undef rename
int
sys_rename (const char * old_name, const char * new_name)
{
char true_old_pathname[MAXPATHLEN+1], true_new_pathname[MAXPATHLEN+1];
char fully_resolved_old_name[MAXPATHLEN+1];
int len;
char mac_old_name[MAXPATHLEN+1], mac_new_name[MAXPATHLEN+1];
if (find_true_pathname (old_name, true_old_pathname, MAXPATHLEN+1) == -1)
return -1;
len = readlink (true_old_pathname, fully_resolved_old_name, MAXPATHLEN);
if (len > -1)
fully_resolved_old_name[len] = '\0';
else
strcpy (fully_resolved_old_name, true_old_pathname);
if (find_true_pathname (new_name, true_new_pathname, MAXPATHLEN+1) == -1)
return -1;
if (strcmp (fully_resolved_old_name, true_new_pathname) == 0)
return 0;
if (!posix_to_mac_pathname (fully_resolved_old_name,
mac_old_name,
MAXPATHLEN+1))
return -1;
if (!posix_to_mac_pathname(true_new_pathname, mac_new_name, MAXPATHLEN+1))
return -1;
(void) unlink (mac_new_name);
return rename (mac_old_name, mac_new_name);
}
#undef fopen
extern FILE *fopen (const char *name, const char *mode);
FILE *
sys_fopen (const char *name, const char *mode)
{
char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
int len;
char mac_pathname[MAXPATHLEN+1];
if (find_true_pathname (name, true_pathname, MAXPATHLEN+1) == -1)
return 0;
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
else
strcpy (fully_resolved_name, true_pathname);
if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
return 0;
else
{
#ifdef __MRC__
if (mode[0] == 'w' || mode[0] == 'a')
fsetfileinfo (mac_pathname, 'EMAx', 'TEXT');
#endif
return fopen (mac_pathname, mode);
}
}
#include <Events.h>
long target_ticks = 0;
#ifdef __MRC__
__sigfun alarm_signal_func = (__sigfun) 0;
#elif __MWERKS__
__signal_func_ptr alarm_signal_func = (__signal_func_ptr) 0;
#else
You lose!!!
#endif
void
check_alarm ()
{
if (target_ticks && TickCount () > target_ticks)
{
target_ticks = 0;
if (alarm_signal_func)
(*alarm_signal_func)(SIGALRM);
}
}
int
select(n, rfds, wfds, efds, timeout)
int n;
SELECT_TYPE *rfds;
SELECT_TYPE *wfds;
SELECT_TYPE *efds;
struct timeval *timeout;
{
EMACS_TIME end_time, now;
EventRecord e;
if (n > 1 || wfds || efds)
return -1;
EMACS_GET_TIME (end_time);
EMACS_ADD_TIME (end_time, end_time, *timeout);
do
{
if (FD_ISSET (0, rfds) && EventAvail (everyEvent, &e))
return 1;
{
Point mouse_pos;
static Point old_mouse_pos = {-1, -1};
GetMouse (&mouse_pos);
if (!EqualPt (mouse_pos, old_mouse_pos))
{
old_mouse_pos = mouse_pos;
return 1;
}
}
WaitNextEvent (0, &e, 1UL, NULL);
EMACS_GET_TIME (now);
EMACS_SUB_TIME (now, end_time, now);
}
while (!EMACS_TIME_NEG_P (now));
return 0;
}
int
pause ()
{
EventRecord e;
unsigned long tick;
if (!target_ticks)
return -1;
if ( (tick = TickCount ()) < target_ticks )
WaitNextEvent (0, &e, target_ticks - tick, NULL);
target_ticks = 0;
if (alarm_signal_func)
(*alarm_signal_func)(SIGALRM);
return 0;
}
int
alarm (int seconds)
{
long remaining = target_ticks ? (TickCount () - target_ticks) / 60 : 0;
target_ticks = seconds ? TickCount () + 60 * seconds : 0;
return (remaining < 0) ? 0 : (unsigned int) remaining;
}
#undef signal
#ifdef __MRC__
extern __sigfun signal (int signal, __sigfun signal_func);
__sigfun
sys_signal (int signal_num, __sigfun signal_func)
#elif __MWERKS__
extern __signal_func_ptr signal (int signal, __signal_func_ptr signal_func);
__signal_func_ptr
sys_signal (int signal_num, __signal_func_ptr signal_func)
#else
You lose!!!
#endif
{
if (signal_num != SIGALRM)
return signal (signal_num, signal_func);
else
{
#ifdef __MRC__
__sigfun old_signal_func;
#elif __MWERKS__
__signal_func_ptr old_signal_func;
#else
You lose!!!
#endif
old_signal_func = alarm_signal_func;
alarm_signal_func = signal_func;
return old_signal_func;
}
}
int
gettimeofday (tp)
struct timeval *tp;
{
static inited = 0;
static wide wall_clock_at_epoch, clicks_at_epoch;
UnsignedWide uw_microseconds;
wide w_microseconds;
time_t sys_time (time_t *);
if (!inited)
{
time_t systime;
inited = 1;
systime = sys_time (NULL);
WideMultiply (systime, 1000000L, &wall_clock_at_epoch);
Microseconds (&uw_microseconds);
clicks_at_epoch.hi = uw_microseconds.hi;
clicks_at_epoch.lo = uw_microseconds.lo;
}
Microseconds (&uw_microseconds);
w_microseconds.hi = uw_microseconds.hi;
w_microseconds.lo = uw_microseconds.lo;
WideSubtract (&w_microseconds, &clicks_at_epoch);
WideAdd (&w_microseconds, &wall_clock_at_epoch);
tp->tv_sec = WideDivide (&w_microseconds, 1000000L, &tp->tv_usec);
return 0;
}
#ifdef __MRC__
unsigned int
sleep (unsigned int seconds)
{
unsigned long time_up;
EventRecord e;
time_up = TickCount () + seconds * 60;
while (TickCount () < time_up)
{
WaitNextEvent (0, &e, 30, NULL);
}
return (0);
}
#endif
#undef gmtime
extern struct tm *gmtime (const time_t *);
struct tm *
sys_gmtime (const time_t *timer)
{
time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
return gmtime (&unix_time);
}
#undef localtime
extern struct tm *localtime (const time_t *);
struct tm *
sys_localtime (const time_t *timer)
{
#ifdef CODEWARRIOR_VERSION_6
time_t unix_time = *timer;
#else
time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
#endif
return localtime (&unix_time);
}
#undef ctime
extern char *ctime (const time_t *);
char *
sys_ctime (const time_t *timer)
{
#ifdef CODEWARRIOR_VERSION_6
time_t unix_time = *timer;
#else
time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
#endif
return ctime (&unix_time);
}
#undef time
extern time_t time (time_t *);
time_t
sys_time (time_t *timer)
{
#ifdef CODEWARRIOR_VERSION_6
time_t mac_time = time (NULL);
#else
time_t mac_time = time (NULL) - CW_OR_MPW_UNIX_EPOCH_DIFF;
#endif
if (timer)
*timer = mac_time;
return mac_time;
}
#ifdef __MRC__
#undef strftime
#include <time.h>
size_t
sys_strftime (char * s, size_t maxsize, const char * format,
const struct tm * timeptr)
{
if (strcmp (format, "%p") == 0)
{
if (maxsize < 3)
return 0;
if (timeptr->tm_hour < 12)
{
strcpy (s, "AM");
return 2;
}
else
{
strcpy (s, "PM");
return 2;
}
}
else
return strftime (s, maxsize, format, timeptr);
}
#endif
int
wait (int pid)
{
return 0;
}
void
croak (char *badfunc)
{
printf ("%s not yet implemented\r\n", badfunc);
exit (1);
}
char *
index (const char * str, int chr)
{
return strchr (str, chr);
}
char *
mktemp (char *template)
{
int len, k;
static seqnum = 0;
len = strlen (template);
k = len - 1;
while (k >= 0 && template[k] == 'X')
k--;
k++;
if (k < len)
{
sprintf (&template[k], "%0*d", len-k, seqnum++);
return template;
}
else
return 0;
}
#define PASSWD_FIELD_SIZE 256
static char my_passwd_name[PASSWD_FIELD_SIZE];
static char my_passwd_dir[MAXPATHLEN+1];
static struct passwd my_passwd =
{
my_passwd_name,
my_passwd_dir,
};
char emacs_passwd_dir[MAXPATHLEN+1];
char *
getwd (char *);
void
init_emacs_passwd_dir ()
{
int found = false;
if (getwd (emacs_passwd_dir) && getwd (my_passwd_dir))
{
int len = strlen (emacs_passwd_dir);
int j = len - 1;
int i = j - 1;
while (i >= 0 && !found)
{
while (i >= 0 && emacs_passwd_dir[i] != '/')
i--;
if (emacs_passwd_dir[i] == '/' && i+5 < len)
found = (strncmp (&(emacs_passwd_dir[i+1]), "emacs", 5) == 0);
if (found)
emacs_passwd_dir[j+1] = '\0';
else
{
j = i;
i = j - 1;
}
}
}
if (!found)
{
strcpy (emacs_passwd_dir, "/");
strcpy (my_passwd_dir, "/");
}
}
static struct passwd emacs_passwd =
{
"emacs",
emacs_passwd_dir,
};
static int my_passwd_inited = 0;
static void
init_my_passwd ()
{
char **owner_name;
owner_name = (char **) GetResource ('STR ',-16096);
if (owner_name)
{
HLock (owner_name);
BlockMove ((unsigned char *) *owner_name,
(unsigned char *) my_passwd_name,
*owner_name[0]+1);
HUnlock (owner_name);
p2cstr ((unsigned char *) my_passwd_name);
}
else
my_passwd_name[0] = 0;
}
struct passwd *
getpwuid (uid_t uid)
{
if (!my_passwd_inited)
{
init_my_passwd ();
my_passwd_inited = 1;
}
return &my_passwd;
}
struct passwd *
getpwnam (const char *name)
{
if (strcmp (name, "emacs") == 0)
return &emacs_passwd;
if (!my_passwd_inited)
{
init_my_passwd ();
my_passwd_inited = 1;
}
return &my_passwd;
}
int
fork ()
{
return -1;
}
int
kill (int x, int y)
{
return -1;
}
void
sys_subshell ()
{
error ("Can't spawn subshell");
}
int
sigsetmask (int x)
{
return 0;
}
int
sigblock (int mask)
{
return 0;
}
void
request_sigio (void)
{
}
void
unrequest_sigio (void)
{
}
int
setpgrp ()
{
return 0;
}
int
pipe (int _fildes[2])
{
errno = EACCES;
return -1;
}
int
symlink (const char *name1, const char *name2)
{
errno = ENOENT;
return -1;
}
int
link (const char *name1, const char *name2)
{
errno = ENOENT;
return -1;
}
int
path_from_vol_dir_name (char *path, int man_path_len, short vol_ref_num,
long dir_id, ConstStr255Param name)
{
Str255 dir_name;
CInfoPBRec cipb;
OSErr err;
if (strlen (name) > man_path_len)
return 0;
memcpy (dir_name, name, name[0]+1);
memcpy (path, name, name[0]+1);
p2cstr (path);
cipb.dirInfo.ioDrParID = dir_id;
cipb.dirInfo.ioNamePtr = dir_name;
do
{
cipb.dirInfo.ioVRefNum = vol_ref_num;
cipb.dirInfo.ioFDirIndex = -1;
cipb.dirInfo.ioDrDirID = cipb.dirInfo.ioDrParID;
err = PBGetCatInfo (&cipb, false);
if (err != noErr)
return 0;
p2cstr (dir_name);
if (strlen (dir_name) + strlen (path) + 1 >= man_path_len)
return 0;
strcat (dir_name, ":");
strcat (dir_name, path);
strcpy (path, dir_name);
}
while (cipb.dirInfo.ioDrDirID != fsRtDirID);
return 1;
}
int
readlink (const char *path, char *buf, int bufsiz)
{
char mac_sym_link_name[MAXPATHLEN+1];
OSErr err;
FSSpec fsspec;
Boolean target_is_folder, was_aliased;
Str255 directory_name, mac_pathname;
CInfoPBRec cipb;
if (posix_to_mac_pathname (path, mac_sym_link_name, MAXPATHLEN+1) == 0)
return -1;
c2pstr (mac_sym_link_name);
err = FSMakeFSSpec (0, 0, mac_sym_link_name, &fsspec);
if (err != noErr)
{
errno = ENOENT;
return -1;
}
err = ResolveAliasFile (&fsspec, true, &target_is_folder, &was_aliased);
if (err != noErr || !was_aliased)
{
errno = ENOENT;
return -1;
}
if (path_from_vol_dir_name (mac_pathname, 255, fsspec.vRefNum, fsspec.parID,
fsspec.name) == 0)
{
errno = ENOENT;
return -1;
}
if (mac_to_posix_pathname (mac_pathname, buf, bufsiz) == 0)
{
errno = ENOENT;
return -1;
}
return strlen (buf);
}
static int
find_true_pathname (const char *path, char *buf, int bufsiz)
{
char *q, temp[MAXPATHLEN+1];
const char *p;
int len;
if (bufsiz <= 0 || path == 0 || path[0] == '\0')
return -1;
buf[0] = '\0';
p = path;
if (*p == '/')
q = strchr (p + 1, '/');
else
q = strchr (p, '/');
len = 0;
while (q)
{
strcpy (temp, buf);
strncat (temp, p, q - p);
len = readlink (temp, buf, bufsiz);
if (len <= -1)
{
if (strlen (temp) + 1 > bufsiz)
return -1;
strcpy (buf, temp);
}
strcat (buf, "/");
len++;
p = q + 1;
q = strchr(p, '/');
}
if (len + strlen (p) + 1 >= bufsiz)
return -1;
strcat (buf, p);
return len + strlen (p);
}
mode_t
umask (mode_t numask)
{
static mode_t mask = 022;
mode_t oldmask = mask;
mask = numask;
return oldmask;
}
int
chmod (const char *path, mode_t mode)
{
return 0;
}
int
dup (int oldd)
{
#ifdef __MRC__
return fcntl (oldd, F_DUPFD, 0);
#elif __MWERKS__
return fcntl (oldd, F_DUPFD);
#else
You lose!!!
#endif
}
int
dup2 (int oldd, int newd)
{
int fd, ret;
close (newd);
fd = dup (oldd);
if (fd == -1)
return -1;
if (fd == newd)
return newd;
ret = dup2 (oldd, newd);
close (fd);
return ret;
}
char *
sbrk (int incr)
{
return (char *) -1;
}
int
fsync (int fd)
{
return 0;
}
int
ioctl (int d, int request, void *argp)
{
return -1;
}
#ifdef __MRC__
int
isatty (int fildes)
{
if (fildes >=0 && fildes <= 2)
return 1;
else
return 0;
}
int
getgid ()
{
return 100;
}
int
getegid ()
{
return 100;
}
int
getuid ()
{
return 200;
}
int
geteuid ()
{
return 200;
}
#endif
#ifdef __MWERKS__
#ifndef CODEWARRIOR_VERSION_6
#undef getpid
int
getpid ()
{
return 9999;
}
#endif
#endif
static char *
get_temp_dir_name ()
{
static char *temp_dir_name = NULL;
short vol_ref_num;
long dir_id;
OSErr err;
Str255 dir_name, full_path;
CInfoPBRec cpb;
char unix_dir_name[MAXPATHLEN+1];
DIR *dir;
if (!temp_dir_name)
{
err = FindFolder (kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
&vol_ref_num, &dir_id);
if (err != noErr)
return NULL;
if (!path_from_vol_dir_name (full_path, 255, vol_ref_num, dir_id, "\p"))
return NULL;
if (strlen (full_path) + 6 <= MAXPATHLEN)
strcat (full_path, "Emacs:");
else
return NULL;
if (!mac_to_posix_pathname (full_path, unix_dir_name, MAXPATHLEN+1))
return NULL;
dir = opendir (unix_dir_name);
if (dir)
closedir (dir);
else if (mkdir (unix_dir_name, 0700) != 0)
return NULL;
temp_dir_name = (char *) malloc (strlen (unix_dir_name) + 1);
strcpy (temp_dir_name, unix_dir_name);
}
return temp_dir_name;
}
void
get_string_list (char ***t, short string_list_id)
{
Handle h;
Ptr p;
int i, num_strings;
h = GetResource ('STR#', string_list_id);
if (h)
{
HLock (h);
p = *h;
num_strings = * (short *) p;
p += sizeof(short);
*t = (char **) malloc (sizeof (char *) * (num_strings + 1));
for (i = 0; i < num_strings; i++)
{
short length = *p++;
(*t)[i] = (char *) malloc (length + 1);
strncpy ((*t)[i], p, length);
(*t)[i][length] = '\0';
p += length;
}
(*t)[num_strings] = 0;
HUnlock (h);
}
else
{
*t = (char **) malloc (sizeof (char *));
(*t)[0] = 0;
}
}
static char *
get_path_to_system_folder ()
{
short vol_ref_num;
long dir_id;
OSErr err;
Str255 dir_name, full_path;
CInfoPBRec cpb;
static char system_folder_unix_name[MAXPATHLEN+1];
DIR *dir;
err = FindFolder (kOnSystemDisk, kSystemFolderType, kDontCreateFolder,
&vol_ref_num, &dir_id);
if (err != noErr)
return NULL;
if (!path_from_vol_dir_name (full_path, 255, vol_ref_num, dir_id, "\p"))
return NULL;
if (!mac_to_posix_pathname (full_path, system_folder_unix_name, MAXPATHLEN+1))
return NULL;
return system_folder_unix_name;
}
char **environ;
#define ENVIRON_STRING_LIST_ID 128
void
init_environ ()
{
int i;
get_string_list (&environ, ENVIRON_STRING_LIST_ID);
i = 0;
while (environ[i])
i++;
if (getenv ("HOME") == NULL)
{
environ = (char **) realloc (environ, sizeof (char *) * (i + 2));
if (environ)
{
environ[i] = (char *) malloc (strlen (my_passwd_dir) + 6);
if (environ[i])
{
strcpy (environ[i], "HOME=");
strcat (environ[i], my_passwd_dir);
}
environ[i+1] = 0;
i++;
}
}
if (getenv ("MAIL") == NULL)
{
environ = (char **) realloc (environ, sizeof (char *) * (i + 2));
if (environ)
{
char * path_to_system_folder = get_path_to_system_folder ();
environ[i] = (char *) malloc (strlen (path_to_system_folder) + 22);
if (environ[i])
{
strcpy (environ[i], "MAIL=");
strcat (environ[i], path_to_system_folder);
strcat (environ[i], "Eudora Folder/In");
}
environ[i+1] = 0;
}
}
}
char *
getenv (const char *name)
{
int length = strlen(name);
char **e;
for (e = environ; *e != 0; e++)
if (strncmp(*e, name, length) == 0 && (*e)[length] == '=')
return &(*e)[length + 1];
if (strcmp (name, "TMPDIR") == 0)
return get_temp_dir_name ();
return 0;
}
#ifdef __MRC__
char *sys_siglist[] =
{
"Zero is not a signal!!!",
"Abort",
"Interactive user interrupt", "?",
"Floating point exception", "?", "?", "?",
"Illegal instruction", "?", "?", "?", "?", "?", "?", "?",
"Segment violation", "?", "?", "?", "?", "?", "?", "?",
"?", "?", "?", "?", "?", "?", "?", "?",
"Terminal"
};
#elif __MWERKS__
char *sys_siglist[] =
{
"Zero is not a signal!!!",
"Abort",
"Floating point exception",
"Illegal instruction",
"Interactive user interrupt",
"Segment violation",
"Terminal"
};
#else
You lose!!!
#endif
#include <utsname.h>
int
uname (struct utsname *name)
{
char **system_name;
system_name = GetString (-16413);
if (system_name)
{
BlockMove (*system_name, name->nodename, (*system_name)[0]+1);
p2cstr (name->nodename);
return 0;
}
else
return -1;
}
#include <Processes.h>
#include <EPPC.h>
const OSType kEmacsSubprocessSend = 'ESND';
const OSType kEmacsSubprocessReply = 'ERPY';
char *
mystrchr (char *s, char c)
{
while (*s && *s != c)
{
if (*s == '\\')
s++;
s++;
}
if (*s)
{
*s = '\0';
return s;
}
else
return NULL;
}
char *
mystrtok (char *s)
{
while (*s)
s++;
return s + 1;
}
void
mystrcpy (char *to, char *from)
{
while (*from)
{
if (*from == '\\')
from++;
*to++ = *from++;
}
*to = '\0';
}
int
run_mac_command (argv, workdir, infn, outfn, errfn)
unsigned char **argv;
const char *workdir;
const char *infn, *outfn, *errfn;
{
char macappname[MAXPATHLEN+1], macworkdir[MAXPATHLEN+1];
char macinfn[MAXPATHLEN+1], macoutfn[MAXPATHLEN+1], macerrfn[MAXPATHLEN+1];
int paramlen, argc, newargc, j, retries;
char **newargv, *param, *p;
OSErr iErr;
FSSpec spec;
LaunchParamBlockRec lpbr;
EventRecord send_event, reply_event;
RgnHandle cursor_region_handle;
TargetID targ;
unsigned long ref_con, len;
if (posix_to_mac_pathname (workdir, macworkdir, MAXPATHLEN+1) == 0)
return -1;
if (posix_to_mac_pathname (infn, macinfn, MAXPATHLEN+1) == 0)
return -1;
if (posix_to_mac_pathname (outfn, macoutfn, MAXPATHLEN+1) == 0)
return -1;
if (posix_to_mac_pathname (errfn, macerrfn, MAXPATHLEN+1) == 0)
return -1;
paramlen = strlen (macworkdir) + strlen (macinfn) + strlen (macoutfn)
+ strlen (macerrfn) + 4;
argc = 0;
while (argv[argc])
argc++;
if (argc == 0)
return -1;
j = strlen (argv[0]);
if (j >= 3 && strcmp (argv[0]+j-3, "/sh") == 0
&& argc == 3 && strcmp (argv[1], "-c") == 0)
{
char *command, *t, tempmacpathname[MAXPATHLEN+1];
command = (char *) alloca (strlen (argv[2])+2);
strcpy (command, argv[2]);
if (command[strlen (command) - 1] != ' ')
strcat (command, " ");
t = command;
newargc = 0;
t = mystrchr (t, ' ');
while (t)
{
newargc++;
t = mystrchr (t+1, ' ');
}
newargv = (char **) alloca (sizeof (char *) * newargc);
t = command;
for (j = 0; j < newargc; j++)
{
newargv[j] = (char *) alloca (strlen (t) + 1);
mystrcpy (newargv[j], t);
t = mystrtok (t);
paramlen += strlen (newargv[j]) + 1;
}
if (strncmp (newargv[0], "~emacs/", 7) == 0)
{
if (posix_to_mac_pathname (newargv[0], tempmacpathname, MAXPATHLEN+1)
== 0)
return -1;
}
else
{
#if 0
char *t = (char *) alloca (strlen (newargv[0]) + 7 + 1);
strcpy (t, "~emacs/");
strcat (t, newargv[0]);
#endif
Lisp_Object path;
openp (Vexec_path, build_string (newargv[0]), EXEC_SUFFIXES, &path,
1);
if (NILP (path))
return -1;
if (posix_to_mac_pathname (XSTRING (path)->data, tempmacpathname,
MAXPATHLEN+1) == 0)
return -1;
}
strcpy (macappname, tempmacpathname);
}
else
{
if (posix_to_mac_pathname (argv[0], macappname, MAXPATHLEN+1) == 0)
return -1;
newargv = (char **) alloca (sizeof (char *) * argc);
newargc = argc;
for (j = 1; j < argc; j++)
{
if (strncmp (argv[j], "~emacs/", 7) == 0)
{
char *t = strchr (argv[j], ' ');
if (t)
{
char tempcmdname[MAXPATHLEN+1], tempmaccmdname[MAXPATHLEN+1];
strncpy (tempcmdname, argv[j], t-argv[j]);
tempcmdname[t-argv[j]] = '\0';
if (posix_to_mac_pathname (tempcmdname, tempmaccmdname,
MAXPATHLEN+1) == 0)
return -1;
newargv[j] = (char *) alloca (strlen (tempmaccmdname)
+ strlen (t) + 1);
strcpy (newargv[j], tempmaccmdname);
strcat (newargv[j], t);
}
else
{
char tempmaccmdname[MAXPATHLEN+1];
if (posix_to_mac_pathname (argv[j], tempmaccmdname,
MAXPATHLEN+1) == 0)
return -1;
newargv[j] = (char *) alloca (strlen (tempmaccmdname)+1);
strcpy (newargv[j], tempmaccmdname);
}
}
else
newargv[j] = argv[j];
paramlen += strlen (newargv[j]) + 1;
}
}
param = (char *) malloc (paramlen + 1);
if (!param)
return -1;
p = param;
*p++ = newargc;
strcpy (p, macworkdir);
p += strlen (macworkdir);
*p++ = '\0';
strcpy (p, macinfn);
p += strlen (macinfn);
*p++ = '\0';
strcpy (p, macoutfn);
p += strlen (macoutfn);
*p++ = '\0';
strcpy (p, macerrfn);
p += strlen (macerrfn);
*p++ = '\0';
for (j = 1; j < newargc; j++)
{
strcpy (p, newargv[j]);
p += strlen (newargv[j]);
*p++ = '\0';
}
c2pstr (macappname);
iErr = FSMakeFSSpec (0, 0, macappname, &spec);
if (iErr != noErr)
{
free (param);
return -1;
}
lpbr.launchBlockID = extendedBlock;
lpbr.launchEPBLength = extendedBlockLen;
lpbr.launchControlFlags = launchContinue + launchNoFileFlags;
lpbr.launchAppSpec = &spec;
lpbr.launchAppParameters = NULL;
iErr = LaunchApplication (&lpbr);
if (iErr != noErr)
{
free (param);
return -1;
}
send_event.what = kHighLevelEvent;
send_event.message = kEmacsSubprocessSend;
retries = 3;
do
{
iErr = PostHighLevelEvent (&send_event, &lpbr.launchProcessSN, 0, param,
paramlen + 1, receiverIDisPSN);
}
while (iErr == sessClosedErr && retries-- > 0);
if (iErr != noErr)
{
free (param);
return -1;
}
cursor_region_handle = NewRgn ();
while (1)
if (WaitNextEvent (highLevelEventMask, &reply_event, 180,
cursor_region_handle)
&& reply_event.message == kEmacsSubprocessReply)
break;
iErr = AcceptHighLevelEvent (&targ, &ref_con, NULL, &len);
if (iErr != noErr)
{
DisposeHandle ((Handle) cursor_region_handle);
free (param);
return -1;
}
DisposeHandle ((Handle) cursor_region_handle);
free (param);
return ref_con;
}
DIR *
opendir (const char *dirname)
{
char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
char mac_pathname[MAXPATHLEN+1], vol_name[MAXPATHLEN+1];
DIR *dirp;
CInfoPBRec cipb;
HVolumeParam vpb;
int len, vol_name_len;
if (find_true_pathname (dirname, true_pathname, MAXPATHLEN+1) == -1)
return 0;
len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
if (len > -1)
fully_resolved_name[len] = '\0';
else
strcpy (fully_resolved_name, true_pathname);
dirp = (DIR *) malloc (sizeof(DIR));
if (!dirp)
return 0;
if (strcmp (fully_resolved_name, "/") == 0)
{
dirp->getting_volumes = 1;
dirp->current_index = 1;
return dirp;
}
if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
return 0;
len = strlen (mac_pathname);
if (mac_pathname[len - 1] != ':' && len < MAXPATHLEN)
strcat (mac_pathname, ":");
vol_name_len = strchr (mac_pathname, ':') - mac_pathname;
strncpy (vol_name, mac_pathname, vol_name_len);
vol_name[vol_name_len] = '\0';
strcat (vol_name, ":");
c2pstr (mac_pathname);
cipb.hFileInfo.ioNamePtr = mac_pathname;
cipb.hFileInfo.ioVRefNum = 0;
cipb.hFileInfo.ioDirID = 0;
cipb.hFileInfo.ioFDirIndex = 0;
errno = PBGetCatInfo (&cipb, false);
if (errno != noErr)
{
errno = ENOENT;
return 0;
}
if (!(cipb.hFileInfo.ioFlAttrib & 0x10))
return 0;
dirp->dir_id = cipb.dirInfo.ioDrDirID;
dirp->getting_volumes = 0;
dirp->current_index = 1;
c2pstr (vol_name);
vpb.ioNamePtr = vol_name;
vpb.ioVRefNum = 0;
vpb.ioVolIndex = -1;
errno = PBHGetVInfo ((union HParamBlockRec *) &vpb, false);
if (errno != noErr)
{
errno = ENOENT;
return 0;
}
dirp->vol_ref_num = vpb.ioVRefNum;
return dirp;
}
int
closedir (DIR *dp)
{
free (dp);
return 0;
}
struct dirent *
readdir (DIR *dp)
{
HParamBlockRec hpblock;
CInfoPBRec cipb;
static struct dirent s_dirent;
static Str255 s_name;
int done;
char *p;
if (dp->getting_volumes)
{
hpblock.volumeParam.ioNamePtr = s_name;
hpblock.volumeParam.ioVRefNum = 0;
hpblock.volumeParam.ioVolIndex = dp->current_index;
errno = PBHGetVInfo (&hpblock, false);
if (errno != noErr)
{
errno = ENOENT;
return 0;
}
p2cstr (s_name);
strcat (s_name, "/");
dp->current_index++;
s_dirent.d_ino = hpblock.volumeParam.ioVRefNum;
s_dirent.d_name = s_name;
return &s_dirent;
}
else
{
cipb.hFileInfo.ioVRefNum = dp->vol_ref_num;
cipb.hFileInfo.ioNamePtr = s_name;
done = false;
while (!done)
{
cipb.hFileInfo.ioDirID = dp->dir_id;
cipb.hFileInfo.ioFDirIndex = dp->current_index;
errno = PBGetCatInfo (&cipb, false);
if (errno != noErr)
{
errno = ENOENT;
return 0;
}
if (cipb.hFileInfo.ioFlAttrib & 0x10)
done = !(cipb.dirInfo.ioDrUsrWds.frFlags & fInvisible);
else
done = !(cipb.hFileInfo.ioFlFndrInfo.fdFlags & fInvisible);
dp->current_index++;
}
p2cstr (s_name);
p = s_name;
while (*p)
{
if (*p == '/')
*p = ':';
p++;
}
s_dirent.d_ino = cipb.dirInfo.ioDrDirID;
s_dirent.d_name = s_name;
return &s_dirent;
}
}
char *
getwd (char *path)
{
char mac_pathname[MAXPATHLEN+1];
Str255 directory_name;
OSErr errno;
CInfoPBRec cipb;
if (path_from_vol_dir_name (mac_pathname, 255, 0, 0, "\p") == 0)
return NULL;
if (mac_to_posix_pathname (mac_pathname, path, MAXPATHLEN+1) == 0)
return 0;
else
return path;
}
void
initialize_applescript ()
{
AEDesc null_desc;
OSAError osaerror;
as_scripting_component = OpenDefaultComponent (kOSAComponentType,
kAppleScriptSubtype);
null_desc.descriptorType = typeNull;
null_desc.dataHandle = 0;
osaerror = OSAMakeContext (as_scripting_component, &null_desc,
kOSANullScript, &as_script_context);
if (osaerror)
as_script_context = kOSANullScript;
}
void terminate_applescript()
{
OSADispose (as_scripting_component, as_script_context);
CloseComponent (as_scripting_component);
}
static long
do_applescript (char *script, char **result)
{
AEDesc script_desc, result_desc, error_desc;
OSErr error;
OSAError osaerror;
long length;
*result = 0;
error = AECreateDesc (typeChar, script, strlen(script), &script_desc);
if (error)
return error;
osaerror = OSADoScript (as_scripting_component, &script_desc, kOSANullScript,
typeChar, kOSAModeNull, &result_desc);
if (osaerror == errOSAScriptError)
{
if (!OSAScriptError (as_scripting_component, kOSAErrorMessage, typeChar,
&error_desc))
{
HLock (error_desc.dataHandle);
length = GetHandleSize(error_desc.dataHandle);
*result = (char *) xmalloc (length + 1);
if (*result)
{
memcpy (*result, *(error_desc.dataHandle), length);
*(*result + length) = '\0';
}
HUnlock (error_desc.dataHandle);
AEDisposeDesc (&error_desc);
}
}
else if (osaerror == noErr)
{
HLock (result_desc.dataHandle);
length = GetHandleSize(result_desc.dataHandle);
*result = (char *) xmalloc (length + 1);
if (*result)
{
memcpy (*result, *(result_desc.dataHandle), length);
*(*result + length) = '\0';
}
HUnlock (result_desc.dataHandle);
}
AEDisposeDesc (&script_desc);
AEDisposeDesc (&result_desc);
return osaerror;
}
DEFUN ("do-applescript", Fdo_applescript, Sdo_applescript, 1, 1, 0,
"Compile and execute AppleScript SCRIPT and retrieve and return the\n\
result. If compilation and execution are successful, the resulting script\n\
value is returned as a string. Otherwise the function aborts and\n\
displays the error message returned by the AppleScript scripting\n\
component.")
(script)
Lisp_Object script;
{
char *result, *temp;
Lisp_Object lisp_result;
long status;
CHECK_STRING (script, 0);
status = do_applescript (XSTRING (script)->data, &result);
if (status)
{
if (!result)
error ("AppleScript error %ld", status);
else
{
temp = (char *) alloca (strlen (result) + 1);
strcpy (temp, result);
xfree (result);
error (temp);
}
}
else
{
lisp_result = build_string (result);
xfree (result);
return lisp_result;
}
}
DEFUN ("mac-file-name-to-posix", Fmac_file_name_to_posix, Smac_file_name_to_posix, 1,
1, 0,
"Convert Macintosh filename to Posix form.")
(mac_filename)
Lisp_Object mac_filename;
{
char posix_filename[MAXPATHLEN+1];
CHECK_STRING (mac_filename, 0);
if (mac_to_posix_pathname (XSTRING (mac_filename)->data, posix_filename,
MAXPATHLEN))
return build_string (posix_filename);
else
return Qnil;
}
DEFUN ("posix-file-name-to-mac", Fposix_file_name_to_mac, Sposix_file_name_to_mac, 1,
1, 0,
"Convert Unix filename to Mac form.")
(posix_filename)
Lisp_Object posix_filename;
{
char mac_filename[MAXPATHLEN+1];
CHECK_STRING (posix_filename, 0);
if (posix_to_mac_pathname (XSTRING (posix_filename)->data, mac_filename,
MAXPATHLEN))
return build_string (mac_filename);
else
return Qnil;
}
DEFUN ("mac-paste-function", Fmac_paste_function, Smac_paste_function, 0, 0, 0,
"Return the contents of the Mac clipboard as a string.")
()
{
Lisp_Object value;
Handle my_handle;
long scrap_offset, rc, i;
my_handle = NewHandle (0);
rc = GetScrap (my_handle, 'TEXT', &scrap_offset);
if (rc < 0)
return Qnil;
HLock (my_handle);
for (i = 0; i < rc; i++)
if ((*my_handle)[i] == '\r')
(*my_handle)[i] = '\n';
value = make_string (*my_handle, rc);
HUnlock (my_handle);
DisposeHandle (my_handle);
return value;
}
DEFUN ("mac-cut-function", Fmac_cut_function, Smac_cut_function, 1, 2, 0,
"Put the value of the string parameter to the Mac clipboard.")
(value, push)
Lisp_Object value, push;
{
char *buf;
int len, i;
CHECK_STRING (value, 0);
len = XSTRING (value)->size;
buf = (char *) alloca (len);
bcopy(XSTRING (value)->data, buf, len);
for (i = 0; i < len; i++)
if (buf[i] == '\n')
buf[i] = '\r';
ZeroScrap ();
PutScrap (len, 'TEXT', buf);
return Qnil;
}
DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
0, 1, 0,
"Whether there is an owner for the given X Selection.\n\
The arg should be the name of the selection in question, typically one of\n\
the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
\(Those are literal upper-case symbol names, since that's what X expects.)\n\
For convenience, the symbol nil is the same as `PRIMARY',\n\
and t is the same as `SECONDARY'.")
(selection)
Lisp_Object selection;
{
CHECK_SYMBOL (selection, 0);
if (EQ (selection, QCLIPBOARD))
{
Lisp_Object val = Qnil;
Lisp_Object value;
Handle my_handle;
long rc, scrap_offset;
my_handle = NewHandle (0);
rc = GetScrap (my_handle, 'TEXT', &scrap_offset);
if (rc >= 0)
val = Qt;
DisposeHandle (my_handle);
return val;
}
return Qnil;
}
void
syms_of_mac ()
{
QCLIPBOARD = intern ("CLIPBOARD");
staticpro (&QCLIPBOARD);
defsubr (&Smac_paste_function);
defsubr (&Smac_cut_function);
defsubr (&Sx_selection_exists_p);
defsubr (&Sdo_applescript);
defsubr (&Smac_file_name_to_posix);
defsubr (&Sposix_file_name_to_mac);
}