aboutsummaryrefslogtreecommitdiffstats
path: root/mac/src/mac.c
diff options
context:
space:
mode:
authorAndrew Choi2002-04-26 23:39:06 +0000
committerAndrew Choi2002-04-26 23:39:06 +0000
commite0f712ba55fa0d073f6ab93606e428f61fc7caf2 (patch)
tree7dc6d3403fafcbee1a83288ac840f7eba1d92b44 /mac/src/mac.c
parent501d8923ae2cdec4ef50f050bb66d3715ba2a8f6 (diff)
downloademacs-e0f712ba55fa0d073f6ab93606e428f61fc7caf2.tar.gz
emacs-e0f712ba55fa0d073f6ab93606e428f61fc7caf2.zip
Patch for building Emacs on Mac OS X. April 26, 2002. See ChangeLog,
lisp/ChangeLog, and src/ChangeLog for list of changes.
Diffstat (limited to 'mac/src/mac.c')
-rw-r--r--mac/src/mac.c2649
1 files changed, 0 insertions, 2649 deletions
diff --git a/mac/src/mac.c b/mac/src/mac.c
deleted file mode 100644
index 473273f13b7..00000000000
--- a/mac/src/mac.c
+++ /dev/null
@@ -1,2649 +0,0 @@
1/* Unix emulation routines for GNU Emacs on the Mac OS.
2 Copyright (C) 2000 Free Software Foundation, Inc.
3
4This file is part of GNU Emacs.
5
6GNU Emacs is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU Emacs is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU Emacs; see the file COPYING. If not, write to
18the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
20
21/* Contributed by Andrew Choi (akochoi@users.sourceforge.net). */
22
23#include <config.h>
24
25#include <stdio.h>
26#include <errno.h>
27#include <utime.h>
28#include <dirent.h>
29#include <sys/stat.h>
30#include <string.h>
31#include <pwd.h>
32#include <sys/param.h>
33#if __MWERKS__
34#include <unistd.h>
35#endif
36
37#include <Files.h>
38#include <MacTypes.h>
39#include <TextUtils.h>
40#include <Folders.h>
41#include <Resources.h>
42#include <Aliases.h>
43#include <FixMath.h>
44#include <Timer.h>
45#include <OSA.h>
46#include <AppleScript.h>
47
48#include "lisp.h"
49#include "process.h"
50#include "sysselect.h"
51#include "systime.h"
52
53Lisp_Object QCLIPBOARD;
54
55/* An instance of the AppleScript component. */
56static ComponentInstance as_scripting_component;
57/* The single script context used for all script executions. */
58static OSAID as_script_context;
59
60
61/* When converting from Mac to Unix pathnames, /'s in folder names are
62 converted to :'s. This function, used in copying folder names,
63 performs a strncat and converts all character a to b in the copy of
64 the string s2 appended to the end of s1. */
65
66void
67string_cat_and_replace (char *s1, const char *s2, int n, char a, char b)
68{
69 int l1 = strlen (s1);
70 int l2 = strlen (s2);
71 char *p = s1 + l1;
72 int i;
73
74 strncat (s1, s2, n);
75 for (i = 0; i < l2; i++)
76 {
77 if (*p == a)
78 *p = b;
79 p++;
80 }
81}
82
83
84/* Convert a Mac pathname to Unix form. A Mac full pathname is one
85 that does not begin with a ':' and contains at least one ':'. A Mac
86 full pathname causes an '/' to be prepended to the Unix pathname.
87 The algorithm for the rest of the pathname is as follows:
88 For each segment between two ':',
89 if it is non-null, copy as is and then add a '/' at the end,
90 otherwise, insert a "../" into the Unix pathname.
91 Returns 1 if successful; 0 if fails. */
92
93int
94mac_to_posix_pathname (const char *mfn, char *ufn, int ufnbuflen)
95{
96 const char *p, *q, *pe;
97
98 strcpy (ufn, "");
99
100 if (*mfn == '\0')
101 return 1;
102
103 p = strchr (mfn, ':');
104 if (p != 0 && p != mfn) /* full pathname */
105 strcat (ufn, "/");
106
107 p = mfn;
108 if (*p == ':')
109 p++;
110
111 pe = mfn + strlen (mfn);
112 while (p < pe)
113 {
114 q = strchr (p, ':');
115 if (q)
116 {
117 if (q == p)
118 { /* two consecutive ':' */
119 if (strlen (ufn) + 3 >= ufnbuflen)
120 return 0;
121 strcat (ufn, "../");
122 }
123 else
124 {
125 if (strlen (ufn) + (q - p) + 1 >= ufnbuflen)
126 return 0;
127 string_cat_and_replace (ufn, p, q - p, '/', ':');
128 strcat (ufn, "/");
129 }
130 p = q + 1;
131 }
132 else
133 {
134 if (strlen (ufn) + (pe - p) >= ufnbuflen)
135 return 0;
136 string_cat_and_replace (ufn, p, pe - p, '/', ':');
137 /* no separator for last one */
138 p = pe;
139 }
140 }
141
142 return 1;
143}
144
145
146extern char *get_temp_dir_name ();
147
148
149/* Convert a Unix pathname to Mac form. Approximately reverse of the
150 above in algorithm. */
151
152int
153posix_to_mac_pathname (const char *ufn, char *mfn, int mfnbuflen)
154{
155 const char *p, *q, *pe;
156 char expanded_pathname[MAXPATHLEN+1];
157
158 strcpy (mfn, "");
159
160 if (*ufn == '\0')
161 return 1;
162
163 p = ufn;
164
165 /* Check for and handle volume names. Last comparison: strangely
166 somewhere "/.emacs" is passed. A temporary fix for now. */
167 if (*p == '/' && strchr (p+1, '/') == NULL && strcmp (p, "/.emacs") != 0)
168 {
169 if (strlen (p) + 1 > mfnbuflen)
170 return 0;
171 strcpy (mfn, p+1);
172 strcat (mfn, ":");
173 return 1;
174 }
175
176 /* expand to emacs dir found by init_emacs_passwd_dir */
177 if (strncmp (p, "~emacs/", 7) == 0)
178 {
179 struct passwd *pw = getpwnam ("emacs");
180 p += 7;
181 if (strlen (pw->pw_dir) + strlen (p) > MAXPATHLEN)
182 return 0;
183 strcpy (expanded_pathname, pw->pw_dir);
184 strcat (expanded_pathname, p);
185 p = expanded_pathname;
186 /* now p points to the pathname with emacs dir prefix */
187 }
188 else if (strncmp (p, "/tmp/", 5) == 0)
189 {
190 char *t = get_temp_dir_name ();
191 p += 5;
192 if (strlen (t) + strlen (p) > MAXPATHLEN)
193 return 0;
194 strcpy (expanded_pathname, t);
195 strcat (expanded_pathname, p);
196 p = expanded_pathname;
197 /* now p points to the pathname with emacs dir prefix */
198 }
199 else if (*p != '/') /* relative pathname */
200 strcat (mfn, ":");
201
202 if (*p == '/')
203 p++;
204
205 pe = p + strlen (p);
206 while (p < pe)
207 {
208 q = strchr (p, '/');
209 if (q)
210 {
211 if (q - p == 2 && *p == '.' && *(p+1) == '.')
212 {
213 if (strlen (mfn) + 1 >= mfnbuflen)
214 return 0;
215 strcat (mfn, ":");
216 }
217 else
218 {
219 if (strlen (mfn) + (q - p) + 1 >= mfnbuflen)
220 return 0;
221 string_cat_and_replace (mfn, p, q - p, ':', '/');
222 strcat (mfn, ":");
223 }
224 p = q + 1;
225 }
226 else
227 {
228 if (strlen (mfn) + (pe - p) >= mfnbuflen)
229 return 0;
230 string_cat_and_replace (mfn, p, pe - p, ':', '/');
231 p = pe;
232 }
233 }
234
235 return 1;
236}
237
238
239/* The following functions with "sys_" prefix are stubs to Unix
240 functions that have already been implemented by CW or MPW. The
241 calls to them in Emacs source course are #define'd to call the sys_
242 versions by the header files s-mac.h. In these stubs pathnames are
243 converted between their Unix and Mac forms. */
244
245
246/* Unix epoch is Jan 1, 1970 while Mac epoch is Jan 1, 1904: 66 years
247 + 17 leap days. These are for adjusting time values returned by
248 MacOS Toolbox functions. */
249
250#define MAC_UNIX_EPOCH_DIFF ((365L * 66 + 17) * 24 * 60 * 60)
251
252#ifdef __MWERKS__
253#ifndef CODEWARRIOR_VERSION_6
254/* CW Pro 5 epoch is Jan 1, 1900 (aaarghhhhh!); remember, 1900 is not
255 a leap year! This is for adjusting time_t values returned by MSL
256 functions. */
257#define CW_OR_MPW_UNIX_EPOCH_DIFF ((365L * 70 + 17) * 24 * 60 * 60)
258#else
259/* CW changes Pro 6 to following Unix! */
260#define CW_OR_MPW_UNIX_EPOCH_DIFF ((365L * 66 + 17) * 24 * 60 * 60)
261#endif
262#elif __MRC__
263/* MPW library functions follow Unix (confused?). */
264#define CW_OR_MPW_UNIX_EPOCH_DIFF ((365L * 66 + 17) * 24 * 60 * 60)
265#else
266You lose!!!
267#endif
268
269
270/* Define our own stat function for both MrC and CW. The reason for
271 doing this: "stat" is both the name of a struct and function name:
272 can't use the same trick like that for sys_open, sys_close, etc. to
273 redirect Emacs's calls to our own version that converts Unix style
274 filenames to Mac style filename because all sorts of compilation
275 errors will be generated if stat is #define'd to be sys_stat. */
276
277int
278stat_noalias (const char *path, struct stat *buf)
279{
280 char mac_pathname[MAXPATHLEN+1];
281 CInfoPBRec cipb;
282
283 if (posix_to_mac_pathname (path, mac_pathname, MAXPATHLEN+1) == 0)
284 return -1;
285
286 c2pstr (mac_pathname);
287 cipb.hFileInfo.ioNamePtr = mac_pathname;
288 cipb.hFileInfo.ioVRefNum = 0;
289 cipb.hFileInfo.ioDirID = 0;
290 cipb.hFileInfo.ioFDirIndex = 0;
291 /* set to 0 to get information about specific dir or file */
292
293 errno = PBGetCatInfo (&cipb, false);
294 if (errno == -43) /* -43: fnfErr defined in Errors.h */
295 errno = ENOENT;
296 if (errno != noErr)
297 return -1;
298
299 if (cipb.hFileInfo.ioFlAttrib & 0x10) /* bit 4 = 1 for directories */
300 {
301 buf->st_mode = S_IFDIR | S_IREAD | S_IEXEC;
302
303 if (!(cipb.hFileInfo.ioFlAttrib & 0x1))
304 buf->st_mode |= S_IWRITE; /* bit 1 = 1 for locked files/directories */
305 buf->st_ino = cipb.dirInfo.ioDrDirID;
306 buf->st_dev = cipb.dirInfo.ioVRefNum;
307 buf->st_size = cipb.dirInfo.ioDrNmFls;
308 /* size of dir = number of files and dirs */
309 buf->st_atime
310 = buf->st_mtime
311 = cipb.dirInfo.ioDrMdDat - MAC_UNIX_EPOCH_DIFF;
312 buf->st_ctime = cipb.dirInfo.ioDrCrDat - MAC_UNIX_EPOCH_DIFF;
313 }
314 else
315 {
316 buf->st_mode = S_IFREG | S_IREAD;
317 if (!(cipb.hFileInfo.ioFlAttrib & 0x1))
318 buf->st_mode |= S_IWRITE; /* bit 1 = 1 for locked files/directories */
319 if (cipb.hFileInfo.ioFlFndrInfo.fdType == 'APPL')
320 buf->st_mode |= S_IEXEC;
321 buf->st_ino = cipb.hFileInfo.ioDirID;
322 buf->st_dev = cipb.hFileInfo.ioVRefNum;
323 buf->st_size = cipb.hFileInfo.ioFlLgLen;
324 buf->st_atime
325 = buf->st_mtime
326 = cipb.hFileInfo.ioFlMdDat - MAC_UNIX_EPOCH_DIFF;
327 buf->st_ctime = cipb.hFileInfo.ioFlCrDat - MAC_UNIX_EPOCH_DIFF;
328 }
329
330 if (cipb.hFileInfo.ioFlFndrInfo.fdFlags & 0x8000)
331 {
332 /* identify alias files as symlinks */
333 buf->st_mode &= ~S_IFREG;
334 buf->st_mode |= S_IFLNK;
335 }
336
337 buf->st_nlink = 1;
338 buf->st_uid = getuid ();
339 buf->st_gid = getgid ();
340 buf->st_rdev = 0;
341
342 return 0;
343}
344
345
346int
347lstat (const char *path, struct stat *buf)
348{
349 int result;
350 char true_pathname[MAXPATHLEN+1];
351
352 /* Try looking for the file without resolving aliases first. */
353 if ((result = stat_noalias (path, buf)) >= 0)
354 return result;
355
356 if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
357 return -1;
358
359 return stat_noalias (true_pathname, buf);
360}
361
362
363int
364stat (const char *path, struct stat *sb)
365{
366 int result;
367 char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
368 int len;
369
370 if ((result = stat_noalias (path, sb)) >= 0 &&
371 ! (sb->st_mode & S_IFLNK))
372 return result;
373
374 if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
375 return -1;
376
377 len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
378 if (len > -1)
379 {
380 fully_resolved_name[len] = '\0';
381 /* in fact our readlink terminates strings */
382 return lstat (fully_resolved_name, sb);
383 }
384 else
385 return lstat (true_pathname, sb);
386}
387
388
389#if __MRC__
390/* CW defines fstat in stat.mac.c while MPW does not provide this
391 function. Without the information of how to get from a file
392 descriptor in MPW StdCLib to a Mac OS file spec, it should be hard
393 to implement this function. Fortunately, there is only one place
394 where this function is called in our configuration: in fileio.c,
395 where only the st_dev and st_ino fields are used to determine
396 whether two fildes point to different i-nodes to prevent copying
397 a file onto itself equal. What we have here probably needs
398 improvement. */
399
400int
401fstat (int fildes, struct stat *buf)
402{
403 buf->st_dev = 0;
404 buf->st_ino = fildes;
405 buf->st_mode = S_IFREG; /* added by T.I. for the copy-file */
406 return 0; /* success */
407}
408#endif /* __MRC__ */
409
410
411/* Adapted from Think Reference code example. */
412
413int
414mkdir (const char *dirname, int mode)
415{
416#pragma unused(mode)
417
418 HFileParam hfpb;
419 char true_pathname[MAXPATHLEN+1], mac_pathname[MAXPATHLEN+1];
420
421 if (find_true_pathname (dirname, true_pathname, MAXPATHLEN+1) == -1)
422 return -1;
423
424 if (posix_to_mac_pathname (true_pathname, mac_pathname, MAXPATHLEN+1) == 0)
425 return -1;
426
427 c2pstr (mac_pathname);
428 hfpb.ioNamePtr = mac_pathname;
429 hfpb.ioVRefNum = 0; /* ignored unless name is invalid */
430 hfpb.ioDirID = 0; /* parent is the root */
431
432 errno = PBDirCreate ((HParmBlkPtr) &hfpb, false);
433 /* just return the Mac OSErr code for now */
434 return errno == noErr ? 0 : -1;
435}
436
437
438#undef rmdir
439sys_rmdir (const char *dirname)
440{
441 HFileParam hfpb;
442 char mac_pathname[MAXPATHLEN+1];
443
444 if (posix_to_mac_pathname (dirname, mac_pathname, MAXPATHLEN+1) == 0)
445 return -1;
446
447 c2pstr (mac_pathname);
448 hfpb.ioNamePtr = mac_pathname;
449 hfpb.ioVRefNum = 0; /* ignored unless name is invalid */
450 hfpb.ioDirID = 0; /* parent is the root */
451
452 errno = PBHDelete ((HParmBlkPtr) &hfpb, false);
453 return errno == noErr ? 0 : -1;
454}
455
456
457#ifdef __MRC__
458/* No implementation yet. */
459int
460execvp (const char *path, ...)
461{
462 return -1;
463}
464#endif /* __MRC__ */
465
466
467int
468utime (const char *path, const struct utimbuf *times)
469{
470 char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
471 int len;
472 char mac_pathname[MAXPATHLEN+1];
473 CInfoPBRec cipb;
474
475 if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
476 return -1;
477
478 len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
479 if (len > -1)
480 fully_resolved_name[len] = '\0';
481 else
482 strcpy (fully_resolved_name, true_pathname);
483
484 if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
485 return -1;
486
487 c2pstr (mac_pathname);
488 cipb.hFileInfo.ioNamePtr = mac_pathname;
489 cipb.hFileInfo.ioVRefNum = 0;
490 cipb.hFileInfo.ioDirID = 0;
491 cipb.hFileInfo.ioFDirIndex = 0;
492 /* set to 0 to get information about specific dir or file */
493
494 errno = PBGetCatInfo (&cipb, false);
495 if (errno != noErr)
496 return -1;
497
498 if (cipb.hFileInfo.ioFlAttrib & 0x10) /* bit 4 = 1 for directories */
499 {
500 if (times)
501 cipb.dirInfo.ioDrMdDat = times->modtime + MAC_UNIX_EPOCH_DIFF;
502 else
503 GetDateTime (&cipb.dirInfo.ioDrMdDat);
504 }
505 else
506 {
507 if (times)
508 cipb.hFileInfo.ioFlMdDat = times->modtime + MAC_UNIX_EPOCH_DIFF;
509 else
510 GetDateTime (&cipb.hFileInfo.ioFlMdDat);
511 }
512
513 errno = PBSetCatInfo (&cipb, false);
514 return errno == noErr ? 0 : -1;
515}
516
517
518#ifndef F_OK
519#define F_OK 0
520#endif
521#ifndef X_OK
522#define X_OK 1
523#endif
524#ifndef W_OK
525#define W_OK 2
526#endif
527
528/* Like stat, but test for access mode in hfpb.ioFlAttrib */
529int
530access (const char *path, int mode)
531{
532 char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
533 int len;
534 char mac_pathname[MAXPATHLEN+1];
535 CInfoPBRec cipb;
536
537 if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
538 return -1;
539
540 len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
541 if (len > -1)
542 fully_resolved_name[len] = '\0';
543 else
544 strcpy (fully_resolved_name, true_pathname);
545
546 if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
547 return -1;
548
549 c2pstr (mac_pathname);
550 cipb.hFileInfo.ioNamePtr = mac_pathname;
551 cipb.hFileInfo.ioVRefNum = 0;
552 cipb.hFileInfo.ioDirID = 0;
553 cipb.hFileInfo.ioFDirIndex = 0;
554 /* set to 0 to get information about specific dir or file */
555
556 errno = PBGetCatInfo (&cipb, false);
557 if (errno != noErr)
558 return -1;
559
560 if (mode == F_OK) /* got this far, file exists */
561 return 0;
562
563 if (mode & X_OK)
564 if (cipb.hFileInfo.ioFlAttrib & 0x10) /* path refers to a directory */
565 return 0;
566 else
567 {
568 if (cipb.hFileInfo.ioFlFndrInfo.fdType == 'APPL')
569 return 0;
570 else
571 return -1;
572 }
573
574 if (mode & W_OK)
575 return (cipb.hFileInfo.ioFlAttrib & 0x1) ? -1 : 0;
576 /* don't allow if lock bit is on */
577
578 return -1;
579}
580
581
582#define DEV_NULL_FD 0x10000
583
584#undef open
585int
586sys_open (const char *path, int oflag)
587{
588 char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
589 int len;
590 char mac_pathname[MAXPATHLEN+1];
591
592 if (strcmp (path, "/dev/null") == 0)
593 return DEV_NULL_FD; /* some bogus fd to be ignored in write */
594
595 if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
596 return -1;
597
598 len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
599 if (len > -1)
600 fully_resolved_name[len] = '\0';
601 else
602 strcpy (fully_resolved_name, true_pathname);
603
604 if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
605 return -1;
606 else
607 {
608#ifdef __MRC__
609 int res = open (mac_pathname, oflag);
610 /* if (oflag == O_WRONLY || oflag == O_RDWR) */
611 if (oflag & O_CREAT)
612 fsetfileinfo (mac_pathname, 'EMAx', 'TEXT');
613 return res;
614#else
615 return open (mac_pathname, oflag);
616#endif
617 }
618}
619
620
621#undef creat
622int
623sys_creat (const char *path, mode_t mode)
624{
625 char true_pathname[MAXPATHLEN+1];
626 int len;
627 char mac_pathname[MAXPATHLEN+1];
628
629 if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
630 return -1;
631
632 if (!posix_to_mac_pathname (true_pathname, mac_pathname, MAXPATHLEN+1))
633 return -1;
634 else
635 {
636#ifdef __MRC__
637 int result = creat (mac_pathname);
638 fsetfileinfo (mac_pathname, 'EMAx', 'TEXT');
639 return result;
640#else
641 return creat (mac_pathname, mode);
642#endif
643 }
644}
645
646
647#undef unlink
648int
649sys_unlink (const char *path)
650{
651 char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
652 int len;
653 char mac_pathname[MAXPATHLEN+1];
654
655 if (find_true_pathname (path, true_pathname, MAXPATHLEN+1) == -1)
656 return -1;
657
658 len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
659 if (len > -1)
660 fully_resolved_name[len] = '\0';
661 else
662 strcpy (fully_resolved_name, true_pathname);
663
664 if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
665 return -1;
666 else
667 return unlink (mac_pathname);
668}
669
670
671#undef read
672int
673sys_read (int fildes, char *buf, int count)
674{
675 if (fildes == 0) /* this should not be used for console input */
676 return -1;
677 else
678#ifdef CODEWARRIOR_VERSION_6
679 return _read (fildes, buf, count);
680#else
681 return read (fildes, buf, count);
682#endif
683}
684
685
686#undef write
687int
688sys_write (int fildes, const char *buf, int count)
689{
690 if (fildes == DEV_NULL_FD)
691 return count;
692 else
693#ifdef CODEWARRIOR_VERSION_6
694 return _write (fildes, buf, count);
695#else
696 return write (fildes, buf, count);
697#endif
698}
699
700
701#undef rename
702int
703sys_rename (const char * old_name, const char * new_name)
704{
705 char true_old_pathname[MAXPATHLEN+1], true_new_pathname[MAXPATHLEN+1];
706 char fully_resolved_old_name[MAXPATHLEN+1];
707 int len;
708 char mac_old_name[MAXPATHLEN+1], mac_new_name[MAXPATHLEN+1];
709
710 if (find_true_pathname (old_name, true_old_pathname, MAXPATHLEN+1) == -1)
711 return -1;
712
713 len = readlink (true_old_pathname, fully_resolved_old_name, MAXPATHLEN);
714 if (len > -1)
715 fully_resolved_old_name[len] = '\0';
716 else
717 strcpy (fully_resolved_old_name, true_old_pathname);
718
719 if (find_true_pathname (new_name, true_new_pathname, MAXPATHLEN+1) == -1)
720 return -1;
721
722 if (strcmp (fully_resolved_old_name, true_new_pathname) == 0)
723 return 0;
724
725 if (!posix_to_mac_pathname (fully_resolved_old_name,
726 mac_old_name,
727 MAXPATHLEN+1))
728 return -1;
729
730 if (!posix_to_mac_pathname(true_new_pathname, mac_new_name, MAXPATHLEN+1))
731 return -1;
732
733 /* If a file with new_name already exists, rename deletes the old
734 file in Unix. CW version fails in these situation. So we add a
735 call to unlink here. */
736 (void) unlink (mac_new_name);
737
738 return rename (mac_old_name, mac_new_name);
739}
740
741
742#undef fopen
743extern FILE *fopen (const char *name, const char *mode);
744FILE *
745sys_fopen (const char *name, const char *mode)
746{
747 char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
748 int len;
749 char mac_pathname[MAXPATHLEN+1];
750
751 if (find_true_pathname (name, true_pathname, MAXPATHLEN+1) == -1)
752 return 0;
753
754 len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
755 if (len > -1)
756 fully_resolved_name[len] = '\0';
757 else
758 strcpy (fully_resolved_name, true_pathname);
759
760 if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
761 return 0;
762 else
763 {
764#ifdef __MRC__
765 if (mode[0] == 'w' || mode[0] == 'a')
766 fsetfileinfo (mac_pathname, 'EMAx', 'TEXT');
767#endif
768 return fopen (mac_pathname, mode);
769 }
770}
771
772
773#include <Events.h>
774
775long target_ticks = 0;
776
777#ifdef __MRC__
778__sigfun alarm_signal_func = (__sigfun) 0;
779#elif __MWERKS__
780__signal_func_ptr alarm_signal_func = (__signal_func_ptr) 0;
781#else
782You lose!!!
783#endif
784
785
786/* These functions simulate SIG_ALRM. The stub for function signal
787 stores the signal handler function in alarm_signal_func if a
788 SIG_ALRM is encountered. check_alarm is called in XTread_socket,
789 which emacs calls periodically. A pending alarm is represented by
790 a non-zero target_ticks value. check_alarm calls the handler
791 function pointed to by alarm_signal_func if one has been set up and
792 an alarm is pending. */
793
794void
795check_alarm ()
796{
797 if (target_ticks && TickCount () > target_ticks)
798 {
799 target_ticks = 0;
800 if (alarm_signal_func)
801 (*alarm_signal_func)(SIGALRM);
802 }
803}
804
805
806int
807select(n, rfds, wfds, efds, timeout)
808 int n;
809 SELECT_TYPE *rfds;
810 SELECT_TYPE *wfds;
811 SELECT_TYPE *efds;
812 struct timeval *timeout;
813{
814 EMACS_TIME end_time, now;
815 EventRecord e;
816
817 /* Can only handle wait for keyboard input. */
818 if (n > 1 || wfds || efds)
819 return -1;
820
821 EMACS_GET_TIME (end_time);
822 EMACS_ADD_TIME (end_time, end_time, *timeout);
823
824 do
825 {
826 /* Also return true if an event other than a keyDown has
827 occurred. This causes kbd_buffer_get_event in keyboard.c to
828 call read_avail_input which in turn calls XTread_socket to
829 poll for these events. Otherwise these never get processed
830 except but a very slow poll timer. */
831 if (FD_ISSET (0, rfds) && EventAvail (everyEvent, &e))
832 return 1;
833
834 /* Also check movement of the mouse. */
835 {
836 Point mouse_pos;
837 static Point old_mouse_pos = {-1, -1};
838
839 GetMouse (&mouse_pos);
840 if (!EqualPt (mouse_pos, old_mouse_pos))
841 {
842 old_mouse_pos = mouse_pos;
843 return 1;
844 }
845 }
846
847 WaitNextEvent (0, &e, 1UL, NULL); /* Accept no event; wait 1 tic. by T.I.*/
848
849 EMACS_GET_TIME (now);
850 EMACS_SUB_TIME (now, end_time, now);
851 }
852 while (!EMACS_TIME_NEG_P (now));
853
854 return 0;
855}
856
857
858/* Called in sys_select to wait for an alarm signal to arrive. */
859
860int
861pause ()
862{
863 EventRecord e;
864 unsigned long tick;
865
866 if (!target_ticks) /* no alarm pending */
867 return -1;
868
869 if ( (tick = TickCount ()) < target_ticks )
870 WaitNextEvent (0, &e, target_ticks - tick, NULL); /* Accept no event; just wait. by T.I.*/
871
872 target_ticks = 0;
873 if (alarm_signal_func)
874 (*alarm_signal_func)(SIGALRM);
875
876 return 0;
877}
878
879
880int
881alarm (int seconds)
882{
883 long remaining = target_ticks ? (TickCount () - target_ticks) / 60 : 0;
884
885 target_ticks = seconds ? TickCount () + 60 * seconds : 0;
886
887 return (remaining < 0) ? 0 : (unsigned int) remaining;
888}
889
890
891#undef signal
892#ifdef __MRC__
893extern __sigfun signal (int signal, __sigfun signal_func);
894__sigfun
895sys_signal (int signal_num, __sigfun signal_func)
896#elif __MWERKS__
897extern __signal_func_ptr signal (int signal, __signal_func_ptr signal_func);
898__signal_func_ptr
899sys_signal (int signal_num, __signal_func_ptr signal_func)
900#else
901 You lose!!!
902#endif
903{
904 if (signal_num != SIGALRM)
905 return signal (signal_num, signal_func);
906 else
907 {
908#ifdef __MRC__
909 __sigfun old_signal_func;
910#elif __MWERKS__
911 __signal_func_ptr old_signal_func;
912#else
913 You lose!!!
914#endif
915 old_signal_func = alarm_signal_func;
916 alarm_signal_func = signal_func;
917 return old_signal_func;
918 }
919}
920
921
922/* gettimeofday should return the amount of time (in a timeval
923 structure) since midnight today. The toolbox function Microseconds
924 returns the number of microseconds (in a UnsignedWide value) since
925 the machine was booted. Also making this complicated is WideAdd,
926 WideSubtract, etc. take wide values. */
927
928int
929gettimeofday (tp)
930 struct timeval *tp;
931{
932 static inited = 0;
933 static wide wall_clock_at_epoch, clicks_at_epoch;
934 UnsignedWide uw_microseconds;
935 wide w_microseconds;
936 time_t sys_time (time_t *);
937
938 /* If this function is called for the first time, record the number
939 of seconds since midnight and the number of microseconds since
940 boot at the time of this first call. */
941 if (!inited)
942 {
943 time_t systime;
944 inited = 1;
945 systime = sys_time (NULL);
946 /* Store microseconds since midnight in wall_clock_at_epoch. */
947 WideMultiply (systime, 1000000L, &wall_clock_at_epoch);
948 Microseconds (&uw_microseconds);
949 /* Store microseconds since boot in clicks_at_epoch. */
950 clicks_at_epoch.hi = uw_microseconds.hi;
951 clicks_at_epoch.lo = uw_microseconds.lo;
952 }
953
954 /* Get time since boot */
955 Microseconds (&uw_microseconds);
956
957 /* Convert to time since midnight*/
958 w_microseconds.hi = uw_microseconds.hi;
959 w_microseconds.lo = uw_microseconds.lo;
960 WideSubtract (&w_microseconds, &clicks_at_epoch);
961 WideAdd (&w_microseconds, &wall_clock_at_epoch);
962 tp->tv_sec = WideDivide (&w_microseconds, 1000000L, &tp->tv_usec);
963
964 return 0;
965}
966
967
968#ifdef __MRC__
969unsigned int
970sleep (unsigned int seconds)
971{
972 unsigned long time_up;
973 EventRecord e;
974
975 time_up = TickCount () + seconds * 60;
976 while (TickCount () < time_up)
977 {
978 /* Accept no event; just wait. by T.I. */
979 WaitNextEvent (0, &e, 30, NULL);
980 }
981
982 return (0);
983}
984#endif /* __MRC__ */
985
986
987/* The time functions adjust time values according to the difference
988 between the Unix and CW epoches. */
989
990#undef gmtime
991extern struct tm *gmtime (const time_t *);
992struct tm *
993sys_gmtime (const time_t *timer)
994{
995 time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
996
997 return gmtime (&unix_time);
998}
999
1000
1001#undef localtime
1002extern struct tm *localtime (const time_t *);
1003struct tm *
1004sys_localtime (const time_t *timer)
1005{
1006#ifdef CODEWARRIOR_VERSION_6
1007 time_t unix_time = *timer;
1008#else
1009 time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
1010#endif
1011
1012 return localtime (&unix_time);
1013}
1014
1015
1016#undef ctime
1017extern char *ctime (const time_t *);
1018char *
1019sys_ctime (const time_t *timer)
1020{
1021#ifdef CODEWARRIOR_VERSION_6
1022 time_t unix_time = *timer;
1023#else
1024 time_t unix_time = *timer + CW_OR_MPW_UNIX_EPOCH_DIFF;
1025#endif
1026
1027 return ctime (&unix_time);
1028}
1029
1030
1031#undef time
1032extern time_t time (time_t *);
1033time_t
1034sys_time (time_t *timer)
1035{
1036#ifdef CODEWARRIOR_VERSION_6
1037 time_t mac_time = time (NULL);
1038#else
1039 time_t mac_time = time (NULL) - CW_OR_MPW_UNIX_EPOCH_DIFF;
1040#endif
1041
1042 if (timer)
1043 *timer = mac_time;
1044
1045 return mac_time;
1046}
1047
1048
1049/* MPW strftime broken for "%p" format */
1050#ifdef __MRC__
1051#undef strftime
1052#include <time.h>
1053size_t
1054sys_strftime (char * s, size_t maxsize, const char * format,
1055 const struct tm * timeptr)
1056{
1057 if (strcmp (format, "%p") == 0)
1058 {
1059 if (maxsize < 3)
1060 return 0;
1061 if (timeptr->tm_hour < 12)
1062 {
1063 strcpy (s, "AM");
1064 return 2;
1065 }
1066 else
1067 {
1068 strcpy (s, "PM");
1069 return 2;
1070 }
1071 }
1072 else
1073 return strftime (s, maxsize, format, timeptr);
1074}
1075#endif /* __MRC__ */
1076
1077
1078/* no subprocesses, empty wait */
1079
1080int
1081wait (int pid)
1082{
1083 return 0;
1084}
1085
1086
1087void
1088croak (char *badfunc)
1089{
1090 printf ("%s not yet implemented\r\n", badfunc);
1091 exit (1);
1092}
1093
1094
1095char *
1096index (const char * str, int chr)
1097{
1098 return strchr (str, chr);
1099}
1100
1101
1102char *
1103mktemp (char *template)
1104{
1105 int len, k;
1106 static seqnum = 0;
1107
1108 len = strlen (template);
1109 k = len - 1;
1110 while (k >= 0 && template[k] == 'X')
1111 k--;
1112
1113 k++; /* make k index of first 'X' */
1114
1115 if (k < len)
1116 {
1117 /* Zero filled, number of digits equal to the number of X's. */
1118 sprintf (&template[k], "%0*d", len-k, seqnum++);
1119
1120 return template;
1121 }
1122 else
1123 return 0;
1124}
1125
1126
1127/* Emulate getpwuid, getpwnam and others. */
1128
1129#define PASSWD_FIELD_SIZE 256
1130
1131static char my_passwd_name[PASSWD_FIELD_SIZE];
1132static char my_passwd_dir[MAXPATHLEN+1];
1133
1134static struct passwd my_passwd =
1135{
1136 my_passwd_name,
1137 my_passwd_dir,
1138};
1139
1140
1141/* Initialized by main () in macterm.c to pathname of emacs directory. */
1142
1143char emacs_passwd_dir[MAXPATHLEN+1];
1144
1145char *
1146getwd (char *);
1147
1148void
1149init_emacs_passwd_dir ()
1150{
1151 int found = false;
1152
1153 if (getwd (emacs_passwd_dir) && getwd (my_passwd_dir))
1154 {
1155 /* Need pathname of first ancestor that begins with "emacs"
1156 since Mac emacs application is somewhere in the emacs-*
1157 tree. */
1158 int len = strlen (emacs_passwd_dir);
1159 int j = len - 1;
1160 /* j points to the "/" following the directory name being
1161 compared. */
1162 int i = j - 1;
1163 while (i >= 0 && !found)
1164 {
1165 while (i >= 0 && emacs_passwd_dir[i] != '/')
1166 i--;
1167 if (emacs_passwd_dir[i] == '/' && i+5 < len)
1168 found = (strncmp (&(emacs_passwd_dir[i+1]), "emacs", 5) == 0);
1169 if (found)
1170 emacs_passwd_dir[j+1] = '\0';
1171 else
1172 {
1173 j = i;
1174 i = j - 1;
1175 }
1176 }
1177 }
1178
1179 if (!found)
1180 {
1181 /* Setting to "/" probably won't work but set it to something
1182 anyway. */
1183 strcpy (emacs_passwd_dir, "/");
1184 strcpy (my_passwd_dir, "/");
1185 }
1186}
1187
1188
1189static struct passwd emacs_passwd =
1190{
1191 "emacs",
1192 emacs_passwd_dir,
1193};
1194
1195static int my_passwd_inited = 0;
1196
1197
1198static void
1199init_my_passwd ()
1200{
1201 char **owner_name;
1202
1203 /* Note: my_passwd_dir initialized in int_emacs_passwd_dir to
1204 directory where Emacs was started. */
1205
1206 owner_name = (char **) GetResource ('STR ',-16096);
1207 if (owner_name)
1208 {
1209 HLock (owner_name);
1210 BlockMove ((unsigned char *) *owner_name,
1211 (unsigned char *) my_passwd_name,
1212 *owner_name[0]+1);
1213 HUnlock (owner_name);
1214 p2cstr ((unsigned char *) my_passwd_name);
1215 }
1216 else
1217 my_passwd_name[0] = 0;
1218}
1219
1220
1221struct passwd *
1222getpwuid (uid_t uid)
1223{
1224 if (!my_passwd_inited)
1225 {
1226 init_my_passwd ();
1227 my_passwd_inited = 1;
1228 }
1229
1230 return &my_passwd;
1231}
1232
1233
1234struct passwd *
1235getpwnam (const char *name)
1236{
1237 if (strcmp (name, "emacs") == 0)
1238 return &emacs_passwd;
1239
1240 if (!my_passwd_inited)
1241 {
1242 init_my_passwd ();
1243 my_passwd_inited = 1;
1244 }
1245
1246 return &my_passwd;
1247}
1248
1249
1250/* The functions fork, kill, sigsetmask, sigblock, request_sigio,
1251 setpgrp, setpriority, and unrequest_sigio are defined to be empty
1252 as in msdos.c. */
1253
1254
1255int
1256fork ()
1257{
1258 return -1;
1259}
1260
1261
1262int
1263kill (int x, int y)
1264{
1265 return -1;
1266}
1267
1268
1269void
1270sys_subshell ()
1271{
1272 error ("Can't spawn subshell");
1273}
1274
1275
1276int
1277sigsetmask (int x)
1278{
1279 return 0;
1280}
1281
1282
1283int
1284sigblock (int mask)
1285{
1286 return 0;
1287}
1288
1289
1290void
1291request_sigio (void)
1292{
1293}
1294
1295
1296void
1297unrequest_sigio (void)
1298{
1299}
1300
1301
1302int
1303setpgrp ()
1304{
1305 return 0;
1306}
1307
1308
1309/* No pipes yet. */
1310
1311int
1312pipe (int _fildes[2])
1313{
1314 errno = EACCES;
1315 return -1;
1316}
1317
1318
1319/* Hard and symbolic links. */
1320
1321int
1322symlink (const char *name1, const char *name2)
1323{
1324 errno = ENOENT;
1325 return -1;
1326}
1327
1328
1329int
1330link (const char *name1, const char *name2)
1331{
1332 errno = ENOENT;
1333 return -1;
1334}
1335
1336
1337/* Determine the path name of the file specified by VREFNUM, DIRID,
1338 and NAME and place that in the buffer PATH of length
1339 MAXPATHLEN. */
1340int
1341path_from_vol_dir_name (char *path, int man_path_len, short vol_ref_num,
1342 long dir_id, ConstStr255Param name)
1343{
1344 Str255 dir_name;
1345 CInfoPBRec cipb;
1346 OSErr err;
1347
1348 if (strlen (name) > man_path_len)
1349 return 0;
1350
1351 memcpy (dir_name, name, name[0]+1);
1352 memcpy (path, name, name[0]+1);
1353 p2cstr (path);
1354
1355 cipb.dirInfo.ioDrParID = dir_id;
1356 cipb.dirInfo.ioNamePtr = dir_name;
1357
1358 do
1359 {
1360 cipb.dirInfo.ioVRefNum = vol_ref_num;
1361 cipb.dirInfo.ioFDirIndex = -1;
1362 cipb.dirInfo.ioDrDirID = cipb.dirInfo.ioDrParID;
1363 /* go up to parent each time */
1364
1365 err = PBGetCatInfo (&cipb, false);
1366 if (err != noErr)
1367 return 0;
1368
1369 p2cstr (dir_name);
1370 if (strlen (dir_name) + strlen (path) + 1 >= man_path_len)
1371 return 0;
1372
1373 strcat (dir_name, ":");
1374 strcat (dir_name, path);
1375 /* attach to front since we're going up directory tree */
1376 strcpy (path, dir_name);
1377 }
1378 while (cipb.dirInfo.ioDrDirID != fsRtDirID);
1379 /* stop when we see the volume's root directory */
1380
1381 return 1; /* success */
1382}
1383
1384
1385int
1386readlink (const char *path, char *buf, int bufsiz)
1387{
1388 char mac_sym_link_name[MAXPATHLEN+1];
1389 OSErr err;
1390 FSSpec fsspec;
1391 Boolean target_is_folder, was_aliased;
1392 Str255 directory_name, mac_pathname;
1393 CInfoPBRec cipb;
1394
1395 if (posix_to_mac_pathname (path, mac_sym_link_name, MAXPATHLEN+1) == 0)
1396 return -1;
1397
1398 c2pstr (mac_sym_link_name);
1399 err = FSMakeFSSpec (0, 0, mac_sym_link_name, &fsspec);
1400 if (err != noErr)
1401 {
1402 errno = ENOENT;
1403 return -1;
1404 }
1405
1406 err = ResolveAliasFile (&fsspec, true, &target_is_folder, &was_aliased);
1407 if (err != noErr || !was_aliased)
1408 {
1409 errno = ENOENT;
1410 return -1;
1411 }
1412
1413 if (path_from_vol_dir_name (mac_pathname, 255, fsspec.vRefNum, fsspec.parID,
1414 fsspec.name) == 0)
1415 {
1416 errno = ENOENT;
1417 return -1;
1418 }
1419
1420 if (mac_to_posix_pathname (mac_pathname, buf, bufsiz) == 0)
1421 {
1422 errno = ENOENT;
1423 return -1;
1424 }
1425
1426 return strlen (buf);
1427}
1428
1429
1430/* Convert a path to one with aliases fully expanded. */
1431
1432static int
1433find_true_pathname (const char *path, char *buf, int bufsiz)
1434{
1435 char *q, temp[MAXPATHLEN+1];
1436 const char *p;
1437 int len;
1438
1439 if (bufsiz <= 0 || path == 0 || path[0] == '\0')
1440 return -1;
1441
1442 buf[0] = '\0';
1443
1444 p = path;
1445 if (*p == '/')
1446 q = strchr (p + 1, '/');
1447 else
1448 q = strchr (p, '/');
1449 len = 0; /* loop may not be entered, e.g., for "/" */
1450
1451 while (q)
1452 {
1453 strcpy (temp, buf);
1454 strncat (temp, p, q - p);
1455 len = readlink (temp, buf, bufsiz);
1456 if (len <= -1)
1457 {
1458 if (strlen (temp) + 1 > bufsiz)
1459 return -1;
1460 strcpy (buf, temp);
1461 }
1462 strcat (buf, "/");
1463 len++;
1464 p = q + 1;
1465 q = strchr(p, '/');
1466 }
1467
1468 if (len + strlen (p) + 1 >= bufsiz)
1469 return -1;
1470
1471 strcat (buf, p);
1472 return len + strlen (p);
1473}
1474
1475
1476mode_t
1477umask (mode_t numask)
1478{
1479 static mode_t mask = 022;
1480 mode_t oldmask = mask;
1481 mask = numask;
1482 return oldmask;
1483}
1484
1485
1486int
1487chmod (const char *path, mode_t mode)
1488{
1489 /* say it always succeed for now */
1490 return 0;
1491}
1492
1493
1494int
1495dup (int oldd)
1496{
1497#ifdef __MRC__
1498 return fcntl (oldd, F_DUPFD, 0);
1499#elif __MWERKS__
1500 /* current implementation of fcntl in fcntl.mac.c simply returns old
1501 descriptor */
1502 return fcntl (oldd, F_DUPFD);
1503#else
1504You lose!!!
1505#endif
1506}
1507
1508
1509/* This is from the original sysdep.c. Emulate BSD dup2. First close
1510 newd if it already exists. Then, attempt to dup oldd. If not
1511 successful, call dup2 recursively until we are, then close the
1512 unsuccessful ones. */
1513
1514int
1515dup2 (int oldd, int newd)
1516{
1517 int fd, ret;
1518
1519 close (newd);
1520
1521 fd = dup (oldd);
1522 if (fd == -1)
1523 return -1;
1524 if (fd == newd)
1525 return newd;
1526 ret = dup2 (oldd, newd);
1527 close (fd);
1528 return ret;
1529}
1530
1531
1532/* let it fail for now */
1533
1534char *
1535sbrk (int incr)
1536{
1537 return (char *) -1;
1538}
1539
1540
1541int
1542fsync (int fd)
1543{
1544 return 0;
1545}
1546
1547
1548int
1549ioctl (int d, int request, void *argp)
1550{
1551 return -1;
1552}
1553
1554
1555#ifdef __MRC__
1556int
1557isatty (int fildes)
1558{
1559 if (fildes >=0 && fildes <= 2)
1560 return 1;
1561 else
1562 return 0;
1563}
1564
1565
1566int
1567getgid ()
1568{
1569 return 100;
1570}
1571
1572
1573int
1574getegid ()
1575{
1576 return 100;
1577}
1578
1579
1580int
1581getuid ()
1582{
1583 return 200;
1584}
1585
1586
1587int
1588geteuid ()
1589{
1590 return 200;
1591}
1592#endif /* __MRC__ */
1593
1594
1595#ifdef __MWERKS__
1596#ifndef CODEWARRIOR_VERSION_6
1597#undef getpid
1598int
1599getpid ()
1600{
1601 return 9999;
1602}
1603#endif
1604#endif /* __MWERKS__ */
1605
1606
1607/* Return the path to the directory in which Emacs can create
1608 temporary files. The MacOS "temporary items" directory cannot be
1609 used because it removes the file written by a process when it
1610 exits. In that sense it's more like "/dev/null" than "/tmp" (but
1611 again not exactly). And of course Emacs needs to read back the
1612 files written by its subprocesses. So here we write the files to a
1613 directory "Emacs" in the Preferences Folder. This directory is
1614 created if it does not exist. */
1615
1616static char *
1617get_temp_dir_name ()
1618{
1619 static char *temp_dir_name = NULL;
1620 short vol_ref_num;
1621 long dir_id;
1622 OSErr err;
1623 Str255 dir_name, full_path;
1624 CInfoPBRec cpb;
1625 char unix_dir_name[MAXPATHLEN+1];
1626 DIR *dir;
1627
1628 /* Cache directory name with pointer temp_dir_name.
1629 Look for it only the first time. */
1630 if (!temp_dir_name)
1631 {
1632 err = FindFolder (kOnSystemDisk, kPreferencesFolderType, kCreateFolder,
1633 &vol_ref_num, &dir_id);
1634 if (err != noErr)
1635 return NULL;
1636
1637 if (!path_from_vol_dir_name (full_path, 255, vol_ref_num, dir_id, "\p"))
1638 return NULL;
1639
1640 if (strlen (full_path) + 6 <= MAXPATHLEN)
1641 strcat (full_path, "Emacs:");
1642 else
1643 return NULL;
1644
1645 if (!mac_to_posix_pathname (full_path, unix_dir_name, MAXPATHLEN+1))
1646 return NULL;
1647
1648 dir = opendir (unix_dir_name); /* check whether temp directory exists */
1649 if (dir)
1650 closedir (dir);
1651 else if (mkdir (unix_dir_name, 0700) != 0) /* create it if not */
1652 return NULL;
1653
1654 temp_dir_name = (char *) malloc (strlen (unix_dir_name) + 1);
1655 strcpy (temp_dir_name, unix_dir_name);
1656 }
1657
1658 return temp_dir_name;
1659}
1660
1661
1662/* Allocate and construct an array of pointers to strings from a list
1663 of strings stored in a 'STR#' resource. The returned pointer array
1664 is stored in the style of argv and environ: if the 'STR#' resource
1665 contains numString strings, an pointer array with numString+1
1666 elements is returned in which the last entry contains a null
1667 pointer. The pointer to the pointer array is passed by pointer in
1668 parameter t. The resource ID of the 'STR#' resource is passed in
1669 parameter StringListID.
1670 */
1671
1672void
1673get_string_list (char ***t, short string_list_id)
1674{
1675 Handle h;
1676 Ptr p;
1677 int i, num_strings;
1678
1679 h = GetResource ('STR#', string_list_id);
1680 if (h)
1681 {
1682 HLock (h);
1683 p = *h;
1684 num_strings = * (short *) p;
1685 p += sizeof(short);
1686 *t = (char **) malloc (sizeof (char *) * (num_strings + 1));
1687 for (i = 0; i < num_strings; i++)
1688 {
1689 short length = *p++;
1690 (*t)[i] = (char *) malloc (length + 1);
1691 strncpy ((*t)[i], p, length);
1692 (*t)[i][length] = '\0';
1693 p += length;
1694 }
1695 (*t)[num_strings] = 0;
1696 HUnlock (h);
1697 }
1698 else
1699 {
1700 /* Return no string in case GetResource fails. Bug fixed by
1701 Ikegami Tsutomu. Caused MPW build to crash without sym -on
1702 option (no sym -on implies -opt local). */
1703 *t = (char **) malloc (sizeof (char *));
1704 (*t)[0] = 0;
1705 }
1706}
1707
1708
1709static char *
1710get_path_to_system_folder ()
1711{
1712 short vol_ref_num;
1713 long dir_id;
1714 OSErr err;
1715 Str255 dir_name, full_path;
1716 CInfoPBRec cpb;
1717 static char system_folder_unix_name[MAXPATHLEN+1];
1718 DIR *dir;
1719
1720 err = FindFolder (kOnSystemDisk, kSystemFolderType, kDontCreateFolder,
1721 &vol_ref_num, &dir_id);
1722 if (err != noErr)
1723 return NULL;
1724
1725 if (!path_from_vol_dir_name (full_path, 255, vol_ref_num, dir_id, "\p"))
1726 return NULL;
1727
1728 if (!mac_to_posix_pathname (full_path, system_folder_unix_name, MAXPATHLEN+1))
1729 return NULL;
1730
1731 return system_folder_unix_name;
1732}
1733
1734
1735char **environ;
1736
1737#define ENVIRON_STRING_LIST_ID 128
1738
1739/* Get environment variable definitions from STR# resource. */
1740
1741void
1742init_environ ()
1743{
1744 int i;
1745
1746 get_string_list (&environ, ENVIRON_STRING_LIST_ID);
1747
1748 i = 0;
1749 while (environ[i])
1750 i++;
1751
1752 /* Make HOME directory the one Emacs starts up in if not specified
1753 by resource. */
1754 if (getenv ("HOME") == NULL)
1755 {
1756 environ = (char **) realloc (environ, sizeof (char *) * (i + 2));
1757 if (environ)
1758 {
1759 environ[i] = (char *) malloc (strlen (my_passwd_dir) + 6);
1760 if (environ[i])
1761 {
1762 strcpy (environ[i], "HOME=");
1763 strcat (environ[i], my_passwd_dir);
1764 }
1765 environ[i+1] = 0;
1766 i++;
1767 }
1768 }
1769
1770 /* Make HOME directory the one Emacs starts up in if not specified
1771 by resource. */
1772 if (getenv ("MAIL") == NULL)
1773 {
1774 environ = (char **) realloc (environ, sizeof (char *) * (i + 2));
1775 if (environ)
1776 {
1777 char * path_to_system_folder = get_path_to_system_folder ();
1778 environ[i] = (char *) malloc (strlen (path_to_system_folder) + 22);
1779 if (environ[i])
1780 {
1781 strcpy (environ[i], "MAIL=");
1782 strcat (environ[i], path_to_system_folder);
1783 strcat (environ[i], "Eudora Folder/In");
1784 }
1785 environ[i+1] = 0;
1786 }
1787 }
1788}
1789
1790
1791/* Return the value of the environment variable NAME. */
1792
1793char *
1794getenv (const char *name)
1795{
1796 int length = strlen(name);
1797 char **e;
1798
1799 for (e = environ; *e != 0; e++)
1800 if (strncmp(*e, name, length) == 0 && (*e)[length] == '=')
1801 return &(*e)[length + 1];
1802
1803 if (strcmp (name, "TMPDIR") == 0)
1804 return get_temp_dir_name ();
1805
1806 return 0;
1807}
1808
1809
1810#ifdef __MRC__
1811/* see Interfaces&Libraries:Interfaces:CIncludes:signal.h */
1812char *sys_siglist[] =
1813{
1814 "Zero is not a signal!!!",
1815 "Abort", /* 1 */
1816 "Interactive user interrupt", /* 2 */ "?",
1817 "Floating point exception", /* 4 */ "?", "?", "?",
1818 "Illegal instruction", /* 8 */ "?", "?", "?", "?", "?", "?", "?",
1819 "Segment violation", /* 16 */ "?", "?", "?", "?", "?", "?", "?",
1820 "?", "?", "?", "?", "?", "?", "?", "?",
1821 "Terminal" /* 32 */
1822};
1823#elif __MWERKS__
1824char *sys_siglist[] =
1825{
1826 "Zero is not a signal!!!",
1827 "Abort",
1828 "Floating point exception",
1829 "Illegal instruction",
1830 "Interactive user interrupt",
1831 "Segment violation",
1832 "Terminal"
1833};
1834#else
1835You lose!!!
1836#endif
1837
1838
1839#include <utsname.h>
1840
1841int
1842uname (struct utsname *name)
1843{
1844 char **system_name;
1845 system_name = GetString (-16413); /* IM - Resource Manager Reference */
1846 if (system_name)
1847 {
1848 BlockMove (*system_name, name->nodename, (*system_name)[0]+1);
1849 p2cstr (name->nodename);
1850 return 0;
1851 }
1852 else
1853 return -1;
1854}
1855
1856
1857#include <Processes.h>
1858#include <EPPC.h>
1859
1860/* Event class of HLE sent to subprocess. */
1861const OSType kEmacsSubprocessSend = 'ESND';
1862
1863/* Event class of HLE sent back from subprocess. */
1864const OSType kEmacsSubprocessReply = 'ERPY';
1865
1866
1867char *
1868mystrchr (char *s, char c)
1869{
1870 while (*s && *s != c)
1871 {
1872 if (*s == '\\')
1873 s++;
1874 s++;
1875 }
1876
1877 if (*s)
1878 {
1879 *s = '\0';
1880 return s;
1881 }
1882 else
1883 return NULL;
1884}
1885
1886
1887char *
1888mystrtok (char *s)
1889{
1890 while (*s)
1891 s++;
1892
1893 return s + 1;
1894}
1895
1896
1897void
1898mystrcpy (char *to, char *from)
1899{
1900 while (*from)
1901 {
1902 if (*from == '\\')
1903 from++;
1904 *to++ = *from++;
1905 }
1906 *to = '\0';
1907}
1908
1909
1910/* Start a Mac subprocess. Arguments for it is passed in argv (null
1911 terminated). The process should run with the default directory
1912 "workdir", read input from "infn", and write output and error to
1913 "outfn" and "errfn", resp. The Process Manager call
1914 LaunchApplication is used to start the subprocess. We use high
1915 level events as the mechanism to pass arguments to the subprocess
1916 and to make Emacs wait for the subprocess to terminate and pass
1917 back a result code. The bulk of the code here packs the arguments
1918 into one message to be passed together with the high level event.
1919 Emacs also sometimes starts a subprocess using a shell to perform
1920 wildcard filename expansion. Since we don't really have a shell on
1921 the Mac, this case is detected and the starting of the shell is
1922 by-passed. We really need to add code here to do filename
1923 expansion to support such functionality. */
1924
1925int
1926run_mac_command (argv, workdir, infn, outfn, errfn)
1927 unsigned char **argv;
1928 const char *workdir;
1929 const char *infn, *outfn, *errfn;
1930{
1931 char macappname[MAXPATHLEN+1], macworkdir[MAXPATHLEN+1];
1932 char macinfn[MAXPATHLEN+1], macoutfn[MAXPATHLEN+1], macerrfn[MAXPATHLEN+1];
1933 int paramlen, argc, newargc, j, retries;
1934 char **newargv, *param, *p;
1935 OSErr iErr;
1936 FSSpec spec;
1937 LaunchParamBlockRec lpbr;
1938 EventRecord send_event, reply_event;
1939 RgnHandle cursor_region_handle;
1940 TargetID targ;
1941 unsigned long ref_con, len;
1942
1943 if (posix_to_mac_pathname (workdir, macworkdir, MAXPATHLEN+1) == 0)
1944 return -1;
1945 if (posix_to_mac_pathname (infn, macinfn, MAXPATHLEN+1) == 0)
1946 return -1;
1947 if (posix_to_mac_pathname (outfn, macoutfn, MAXPATHLEN+1) == 0)
1948 return -1;
1949 if (posix_to_mac_pathname (errfn, macerrfn, MAXPATHLEN+1) == 0)
1950 return -1;
1951
1952 paramlen = strlen (macworkdir) + strlen (macinfn) + strlen (macoutfn)
1953 + strlen (macerrfn) + 4; /* count nulls at end of strings */
1954
1955 argc = 0;
1956 while (argv[argc])
1957 argc++;
1958
1959 if (argc == 0)
1960 return -1;
1961
1962 /* If a subprocess is invoked with a shell, we receive 3 arguments
1963 of the form: "<path to emacs bins>/sh" "-c" "<path to emacs
1964 bins>/<command> <command args>" */
1965 j = strlen (argv[0]);
1966 if (j >= 3 && strcmp (argv[0]+j-3, "/sh") == 0
1967 && argc == 3 && strcmp (argv[1], "-c") == 0)
1968 {
1969 char *command, *t, tempmacpathname[MAXPATHLEN+1];
1970
1971 /* The arguments for the command in argv[2] are separated by
1972 spaces. Count them and put the count in newargc. */
1973 command = (char *) alloca (strlen (argv[2])+2);
1974 strcpy (command, argv[2]);
1975 if (command[strlen (command) - 1] != ' ')
1976 strcat (command, " ");
1977
1978 t = command;
1979 newargc = 0;
1980 t = mystrchr (t, ' ');
1981 while (t)
1982 {
1983 newargc++;
1984 t = mystrchr (t+1, ' ');
1985 }
1986
1987 newargv = (char **) alloca (sizeof (char *) * newargc);
1988
1989 t = command;
1990 for (j = 0; j < newargc; j++)
1991 {
1992 newargv[j] = (char *) alloca (strlen (t) + 1);
1993 mystrcpy (newargv[j], t);
1994
1995 t = mystrtok (t);
1996 paramlen += strlen (newargv[j]) + 1;
1997 }
1998
1999 if (strncmp (newargv[0], "~emacs/", 7) == 0)
2000 {
2001 if (posix_to_mac_pathname (newargv[0], tempmacpathname, MAXPATHLEN+1)
2002 == 0)
2003 return -1;
2004 }
2005 else
2006 { /* sometimes Emacs call "sh" without a path for the command */
2007#if 0
2008 char *t = (char *) alloca (strlen (newargv[0]) + 7 + 1);
2009 strcpy (t, "~emacs/");
2010 strcat (t, newargv[0]);
2011#endif
2012 Lisp_Object path;
2013 openp (Vexec_path, build_string (newargv[0]), Vexec_suffixes, &path,
2014 1);
2015
2016 if (NILP (path))
2017 return -1;
2018 if (posix_to_mac_pathname (XSTRING (path)->data, tempmacpathname,
2019 MAXPATHLEN+1) == 0)
2020 return -1;
2021 }
2022 strcpy (macappname, tempmacpathname);
2023 }
2024 else
2025 {
2026 if (posix_to_mac_pathname (argv[0], macappname, MAXPATHLEN+1) == 0)
2027 return -1;
2028
2029 newargv = (char **) alloca (sizeof (char *) * argc);
2030 newargc = argc;
2031 for (j = 1; j < argc; j++)
2032 {
2033 if (strncmp (argv[j], "~emacs/", 7) == 0)
2034 {
2035 char *t = strchr (argv[j], ' ');
2036 if (t)
2037 {
2038 char tempcmdname[MAXPATHLEN+1], tempmaccmdname[MAXPATHLEN+1];
2039 strncpy (tempcmdname, argv[j], t-argv[j]);
2040 tempcmdname[t-argv[j]] = '\0';
2041 if (posix_to_mac_pathname (tempcmdname, tempmaccmdname,
2042 MAXPATHLEN+1) == 0)
2043 return -1;
2044 newargv[j] = (char *) alloca (strlen (tempmaccmdname)
2045 + strlen (t) + 1);
2046 strcpy (newargv[j], tempmaccmdname);
2047 strcat (newargv[j], t);
2048 }
2049 else
2050 {
2051 char tempmaccmdname[MAXPATHLEN+1];
2052 if (posix_to_mac_pathname (argv[j], tempmaccmdname,
2053 MAXPATHLEN+1) == 0)
2054 return -1;
2055 newargv[j] = (char *) alloca (strlen (tempmaccmdname)+1);
2056 strcpy (newargv[j], tempmaccmdname);
2057 }
2058 }
2059 else
2060 newargv[j] = argv[j];
2061 paramlen += strlen (newargv[j]) + 1;
2062 }
2063 }
2064
2065 /* After expanding all the arguments, we now know the length of the
2066 parameter block to be sent to the subprocess as a message
2067 attached to the HLE. */
2068 param = (char *) malloc (paramlen + 1);
2069 if (!param)
2070 return -1;
2071
2072 p = param;
2073 *p++ = newargc;
2074 /* first byte of message contains number of arguments for command */
2075 strcpy (p, macworkdir);
2076 p += strlen (macworkdir);
2077 *p++ = '\0';
2078 /* null terminate strings sent so it's possible to use strcpy over there */
2079 strcpy (p, macinfn);
2080 p += strlen (macinfn);
2081 *p++ = '\0';
2082 strcpy (p, macoutfn);
2083 p += strlen (macoutfn);
2084 *p++ = '\0';
2085 strcpy (p, macerrfn);
2086 p += strlen (macerrfn);
2087 *p++ = '\0';
2088 for (j = 1; j < newargc; j++)
2089 {
2090 strcpy (p, newargv[j]);
2091 p += strlen (newargv[j]);
2092 *p++ = '\0';
2093 }
2094
2095 c2pstr (macappname);
2096
2097 iErr = FSMakeFSSpec (0, 0, macappname, &spec);
2098
2099 if (iErr != noErr)
2100 {
2101 free (param);
2102 return -1;
2103 }
2104
2105 lpbr.launchBlockID = extendedBlock;
2106 lpbr.launchEPBLength = extendedBlockLen;
2107 lpbr.launchControlFlags = launchContinue + launchNoFileFlags;
2108 lpbr.launchAppSpec = &spec;
2109 lpbr.launchAppParameters = NULL;
2110
2111 iErr = LaunchApplication (&lpbr); /* call the subprocess */
2112 if (iErr != noErr)
2113 {
2114 free (param);
2115 return -1;
2116 }
2117
2118 send_event.what = kHighLevelEvent;
2119 send_event.message = kEmacsSubprocessSend;
2120 /* Event ID stored in "where" unused */
2121
2122 retries = 3;
2123 /* OS may think current subprocess has terminated if previous one
2124 terminated recently. */
2125 do
2126 {
2127 iErr = PostHighLevelEvent (&send_event, &lpbr.launchProcessSN, 0, param,
2128 paramlen + 1, receiverIDisPSN);
2129 }
2130 while (iErr == sessClosedErr && retries-- > 0);
2131
2132 if (iErr != noErr)
2133 {
2134 free (param);
2135 return -1;
2136 }
2137
2138 cursor_region_handle = NewRgn ();
2139
2140 /* Wait for the subprocess to finish, when it will send us a ERPY
2141 high level event. */
2142 while (1)
2143 if (WaitNextEvent (highLevelEventMask, &reply_event, 180,
2144 cursor_region_handle)
2145 && reply_event.message == kEmacsSubprocessReply)
2146 break;
2147
2148 /* The return code is sent through the refCon */
2149 iErr = AcceptHighLevelEvent (&targ, &ref_con, NULL, &len);
2150 if (iErr != noErr)
2151 {
2152 DisposeHandle ((Handle) cursor_region_handle);
2153 free (param);
2154 return -1;
2155 }
2156
2157 DisposeHandle ((Handle) cursor_region_handle);
2158 free (param);
2159
2160 return ref_con;
2161}
2162
2163
2164DIR *
2165opendir (const char *dirname)
2166{
2167 char true_pathname[MAXPATHLEN+1], fully_resolved_name[MAXPATHLEN+1];
2168 char mac_pathname[MAXPATHLEN+1], vol_name[MAXPATHLEN+1];
2169 DIR *dirp;
2170 CInfoPBRec cipb;
2171 HVolumeParam vpb;
2172 int len, vol_name_len;
2173
2174 if (find_true_pathname (dirname, true_pathname, MAXPATHLEN+1) == -1)
2175 return 0;
2176
2177 len = readlink (true_pathname, fully_resolved_name, MAXPATHLEN);
2178 if (len > -1)
2179 fully_resolved_name[len] = '\0';
2180 else
2181 strcpy (fully_resolved_name, true_pathname);
2182
2183 dirp = (DIR *) malloc (sizeof(DIR));
2184 if (!dirp)
2185 return 0;
2186
2187 /* Handle special case when dirname is "/": sets up for readir to
2188 get all mount volumes. */
2189 if (strcmp (fully_resolved_name, "/") == 0)
2190 {
2191 dirp->getting_volumes = 1; /* special all mounted volumes DIR struct */
2192 dirp->current_index = 1; /* index for first volume */
2193 return dirp;
2194 }
2195
2196 /* Handle typical cases: not accessing all mounted volumes. */
2197 if (!posix_to_mac_pathname (fully_resolved_name, mac_pathname, MAXPATHLEN+1))
2198 return 0;
2199
2200 /* Emacs calls opendir without the trailing '/', Mac needs trailing ':' */
2201 len = strlen (mac_pathname);
2202 if (mac_pathname[len - 1] != ':' && len < MAXPATHLEN)
2203 strcat (mac_pathname, ":");
2204
2205 /* Extract volume name */
2206 vol_name_len = strchr (mac_pathname, ':') - mac_pathname;
2207 strncpy (vol_name, mac_pathname, vol_name_len);
2208 vol_name[vol_name_len] = '\0';
2209 strcat (vol_name, ":");
2210
2211 c2pstr (mac_pathname);
2212 cipb.hFileInfo.ioNamePtr = mac_pathname;
2213 /* using full pathname so vRefNum and DirID ignored */
2214 cipb.hFileInfo.ioVRefNum = 0;
2215 cipb.hFileInfo.ioDirID = 0;
2216 cipb.hFileInfo.ioFDirIndex = 0;
2217 /* set to 0 to get information about specific dir or file */
2218
2219 errno = PBGetCatInfo (&cipb, false);
2220 if (errno != noErr)
2221 {
2222 errno = ENOENT;
2223 return 0;
2224 }
2225
2226 if (!(cipb.hFileInfo.ioFlAttrib & 0x10)) /* bit 4 = 1 for directories */
2227 return 0; /* not a directory */
2228
2229 dirp->dir_id = cipb.dirInfo.ioDrDirID; /* used later in readdir */
2230 dirp->getting_volumes = 0;
2231 dirp->current_index = 1; /* index for first file/directory */
2232
2233 c2pstr (vol_name);
2234 vpb.ioNamePtr = vol_name;
2235 /* using full pathname so vRefNum and DirID ignored */
2236 vpb.ioVRefNum = 0;
2237 vpb.ioVolIndex = -1;
2238 errno = PBHGetVInfo ((union HParamBlockRec *) &vpb, false);
2239 if (errno != noErr)
2240 {
2241 errno = ENOENT;
2242 return 0;
2243 }
2244
2245 dirp->vol_ref_num = vpb.ioVRefNum;
2246
2247 return dirp;
2248}
2249
2250int
2251closedir (DIR *dp)
2252{
2253 free (dp);
2254
2255 return 0;
2256}
2257
2258
2259struct dirent *
2260readdir (DIR *dp)
2261{
2262 HParamBlockRec hpblock;
2263 CInfoPBRec cipb;
2264 static struct dirent s_dirent;
2265 static Str255 s_name;
2266 int done;
2267 char *p;
2268
2269 /* Handle the root directory containing the mounted volumes. Call
2270 PBHGetVInfo specifying an index to obtain the info for a volume.
2271 PBHGetVInfo returns an error when it receives an index beyond the
2272 last volume, at which time we should return a nil dirent struct
2273 pointer. */
2274 if (dp->getting_volumes)
2275 {
2276 hpblock.volumeParam.ioNamePtr = s_name;
2277 hpblock.volumeParam.ioVRefNum = 0;
2278 hpblock.volumeParam.ioVolIndex = dp->current_index;
2279
2280 errno = PBHGetVInfo (&hpblock, false);
2281 if (errno != noErr)
2282 {
2283 errno = ENOENT;
2284 return 0;
2285 }
2286
2287 p2cstr (s_name);
2288 strcat (s_name, "/"); /* need "/" for stat to work correctly */
2289
2290 dp->current_index++;
2291
2292 s_dirent.d_ino = hpblock.volumeParam.ioVRefNum;
2293 s_dirent.d_name = s_name;
2294
2295 return &s_dirent;
2296 }
2297 else
2298 {
2299 cipb.hFileInfo.ioVRefNum = dp->vol_ref_num;
2300 cipb.hFileInfo.ioNamePtr = s_name;
2301 /* location to receive filename returned */
2302
2303 /* return only visible files */
2304 done = false;
2305 while (!done)
2306 {
2307 cipb.hFileInfo.ioDirID = dp->dir_id;
2308 /* directory ID found by opendir */
2309 cipb.hFileInfo.ioFDirIndex = dp->current_index;
2310
2311 errno = PBGetCatInfo (&cipb, false);
2312 if (errno != noErr)
2313 {
2314 errno = ENOENT;
2315 return 0;
2316 }
2317
2318 /* insist on an visibile entry */
2319 if (cipb.hFileInfo.ioFlAttrib & 0x10) /* directory? */
2320 done = !(cipb.dirInfo.ioDrUsrWds.frFlags & fInvisible);
2321 else
2322 done = !(cipb.hFileInfo.ioFlFndrInfo.fdFlags & fInvisible);
2323
2324 dp->current_index++;
2325 }
2326
2327 p2cstr (s_name);
2328
2329 p = s_name;
2330 while (*p)
2331 {
2332 if (*p == '/')
2333 *p = ':';
2334 p++;
2335 }
2336
2337 s_dirent.d_ino = cipb.dirInfo.ioDrDirID;
2338 /* value unimportant: non-zero for valid file */
2339 s_dirent.d_name = s_name;
2340
2341 return &s_dirent;
2342 }
2343}
2344
2345
2346char *
2347getwd (char *path)
2348{
2349 char mac_pathname[MAXPATHLEN+1];
2350 Str255 directory_name;
2351 OSErr errno;
2352 CInfoPBRec cipb;
2353
2354 if (path_from_vol_dir_name (mac_pathname, 255, 0, 0, "\p") == 0)
2355 return NULL;
2356
2357 if (mac_to_posix_pathname (mac_pathname, path, MAXPATHLEN+1) == 0)
2358 return 0;
2359 else
2360 return path;
2361}
2362
2363
2364void
2365initialize_applescript ()
2366{
2367 AEDesc null_desc;
2368 OSAError osaerror;
2369
2370 /* if open fails, as_scripting_component is set to NULL. Its
2371 subsequent use in OSA calls will fail with badComponentInstance
2372 error. */
2373 as_scripting_component = OpenDefaultComponent (kOSAComponentType,
2374 kAppleScriptSubtype);
2375
2376 null_desc.descriptorType = typeNull;
2377 null_desc.dataHandle = 0;
2378 osaerror = OSAMakeContext (as_scripting_component, &null_desc,
2379 kOSANullScript, &as_script_context);
2380 if (osaerror)
2381 as_script_context = kOSANullScript;
2382 /* use default context if create fails */
2383}
2384
2385
2386void terminate_applescript()
2387{
2388 OSADispose (as_scripting_component, as_script_context);
2389 CloseComponent (as_scripting_component);
2390}
2391
2392
2393/* Compile and execute the AppleScript SCRIPT and return the error
2394 status as function value. A zero is returned if compilation and
2395 execution is successful, in which case RESULT returns a pointer to
2396 a string containing the resulting script value. Otherwise, the Mac
2397 error code is returned and RESULT returns a pointer to an error
2398 string. In both cases the caller should deallocate the storage
2399 used by the string pointed to by RESULT if it is non-NULL. For
2400 documentation on the MacOS scripting architecture, see Inside
2401 Macintosh - Interapplication Communications: Scripting Components. */
2402
2403static long
2404do_applescript (char *script, char **result)
2405{
2406 AEDesc script_desc, result_desc, error_desc;
2407 OSErr error;
2408 OSAError osaerror;
2409 long length;
2410
2411 *result = 0;
2412
2413 error = AECreateDesc (typeChar, script, strlen(script), &script_desc);
2414 if (error)
2415 return error;
2416
2417 osaerror = OSADoScript (as_scripting_component, &script_desc, kOSANullScript,
2418 typeChar, kOSAModeNull, &result_desc);
2419
2420 if (osaerror == errOSAScriptError)
2421 {
2422 /* error executing AppleScript: retrieve error message */
2423 if (!OSAScriptError (as_scripting_component, kOSAErrorMessage, typeChar,
2424 &error_desc))
2425 {
2426 HLock (error_desc.dataHandle);
2427 length = GetHandleSize(error_desc.dataHandle);
2428 *result = (char *) xmalloc (length + 1);
2429 if (*result)
2430 {
2431 memcpy (*result, *(error_desc.dataHandle), length);
2432 *(*result + length) = '\0';
2433 }
2434 HUnlock (error_desc.dataHandle);
2435 AEDisposeDesc (&error_desc);
2436 }
2437 }
2438 else if (osaerror == noErr) /* success: retrieve resulting script value */
2439 {
2440 HLock (result_desc.dataHandle);
2441 length = GetHandleSize(result_desc.dataHandle);
2442 *result = (char *) xmalloc (length + 1);
2443 if (*result)
2444 {
2445 memcpy (*result, *(result_desc.dataHandle), length);
2446 *(*result + length) = '\0';
2447 }
2448 HUnlock (result_desc.dataHandle);
2449 }
2450
2451 AEDisposeDesc (&script_desc);
2452 AEDisposeDesc (&result_desc);
2453
2454 return osaerror;
2455}
2456
2457
2458DEFUN ("do-applescript", Fdo_applescript, Sdo_applescript, 1, 1, 0,
2459 "Compile and execute AppleScript SCRIPT and retrieve and return the\n\
2460result. If compilation and execution are successful, the resulting script\n\
2461value is returned as a string. Otherwise the function aborts and\n\
2462displays the error message returned by the AppleScript scripting\n\
2463component.")
2464 (script)
2465 Lisp_Object script;
2466{
2467 char *result, *temp;
2468 Lisp_Object lisp_result;
2469 long status;
2470
2471 CHECK_STRING (script, 0);
2472
2473 status = do_applescript (XSTRING (script)->data, &result);
2474 if (status)
2475 {
2476 if (!result)
2477 error ("AppleScript error %ld", status);
2478 else
2479 {
2480 /* Unfortunately only OSADoScript in do_applescript knows how
2481 how large the resulting script value or error message is
2482 going to be and therefore as caller memory must be
2483 deallocated here. It is necessary to free the error
2484 message before calling error to avoid a memory leak. */
2485 temp = (char *) alloca (strlen (result) + 1);
2486 strcpy (temp, result);
2487 xfree (result);
2488 error (temp);
2489 }
2490 }
2491 else
2492 {
2493 lisp_result = build_string (result);
2494 xfree (result);
2495 return lisp_result;
2496 }
2497}
2498
2499
2500DEFUN ("mac-file-name-to-posix", Fmac_file_name_to_posix, Smac_file_name_to_posix, 1,
2501 1, 0,
2502 "Convert Macintosh filename to Posix form.")
2503 (mac_filename)
2504 Lisp_Object mac_filename;
2505{
2506 char posix_filename[MAXPATHLEN+1];
2507
2508 CHECK_STRING (mac_filename, 0);
2509
2510 if (mac_to_posix_pathname (XSTRING (mac_filename)->data, posix_filename,
2511 MAXPATHLEN))
2512 return build_string (posix_filename);
2513 else
2514 return Qnil;
2515}
2516
2517
2518DEFUN ("posix-file-name-to-mac", Fposix_file_name_to_mac, Sposix_file_name_to_mac, 1,
2519 1, 0,
2520 "Convert Unix filename to Mac form.")
2521 (posix_filename)
2522 Lisp_Object posix_filename;
2523{
2524 char mac_filename[MAXPATHLEN+1];
2525
2526 CHECK_STRING (posix_filename, 0);
2527
2528 if (posix_to_mac_pathname (XSTRING (posix_filename)->data, mac_filename,
2529 MAXPATHLEN))
2530 return build_string (mac_filename);
2531 else
2532 return Qnil;
2533}
2534
2535
2536/* set interprogram-paste-function to mac-paste-function in mac-win.el
2537 to enable Emacs to obtain the contents of the Mac clipboard. */
2538DEFUN ("mac-paste-function", Fmac_paste_function, Smac_paste_function, 0, 0, 0,
2539 "Return the contents of the Mac clipboard as a string.")
2540 ()
2541{
2542 Lisp_Object value;
2543 Handle my_handle;
2544 long scrap_offset, rc, i;
2545
2546 my_handle = NewHandle (0); /* allocate 0-length data area */
2547
2548 rc = GetScrap (my_handle, 'TEXT', &scrap_offset);
2549 if (rc < 0)
2550 return Qnil;
2551
2552 HLock (my_handle);
2553
2554 /* Emacs expects clipboard contents have Unix-style eol's */
2555 for (i = 0; i < rc; i++)
2556 if ((*my_handle)[i] == '\r')
2557 (*my_handle)[i] = '\n';
2558
2559 value = make_string (*my_handle, rc);
2560
2561 HUnlock (my_handle);
2562
2563 DisposeHandle (my_handle);
2564
2565 return value;
2566}
2567
2568
2569/* set interprogram-cut-function to mac-cut-function in mac-win.el
2570 to enable Emacs to write the top of the kill-ring to the Mac clipboard. */
2571DEFUN ("mac-cut-function", Fmac_cut_function, Smac_cut_function, 1, 2, 0,
2572 "Put the value of the string parameter to the Mac clipboard.")
2573 (value, push)
2574 Lisp_Object value, push;
2575{
2576 char *buf;
2577 int len, i;
2578
2579 /* fixme: ignore the push flag for now */
2580
2581 CHECK_STRING (value, 0);
2582
2583 len = XSTRING (value)->size;
2584 buf = (char *) alloca (len);
2585 bcopy(XSTRING (value)->data, buf, len);
2586
2587 /* convert to Mac-style eol's before sending to clipboard */
2588 for (i = 0; i < len; i++)
2589 if (buf[i] == '\n')
2590 buf[i] = '\r';
2591
2592 ZeroScrap ();
2593 PutScrap (len, 'TEXT', buf);
2594
2595 return Qnil;
2596}
2597
2598
2599DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
2600 0, 1, 0,
2601 "Whether there is an owner for the given X Selection.\n\
2602The arg should be the name of the selection in question, typically one of\n\
2603the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
2604\(Those are literal upper-case symbol names, since that's what X expects.)\n\
2605For convenience, the symbol nil is the same as `PRIMARY',\n\
2606and t is the same as `SECONDARY'.")
2607 (selection)
2608 Lisp_Object selection;
2609{
2610 CHECK_SYMBOL (selection, 0);
2611
2612 /* Return nil for PRIMARY and SECONDARY selections; for CLIPBOARD, check
2613 if the clipboard currently has valid text format contents. */
2614
2615 if (EQ (selection, QCLIPBOARD))
2616 {
2617 Lisp_Object val = Qnil;
2618 Lisp_Object value;
2619 Handle my_handle;
2620 long rc, scrap_offset;
2621
2622 my_handle = NewHandle (0);
2623
2624 rc = GetScrap (my_handle, 'TEXT', &scrap_offset);
2625 if (rc >= 0)
2626 val = Qt;
2627
2628 DisposeHandle (my_handle);
2629
2630 return val;
2631 }
2632 return Qnil;
2633}
2634
2635
2636void
2637syms_of_mac ()
2638{
2639 QCLIPBOARD = intern ("CLIPBOARD");
2640 staticpro (&QCLIPBOARD);
2641
2642 defsubr (&Smac_paste_function);
2643 defsubr (&Smac_cut_function);
2644 defsubr (&Sx_selection_exists_p);
2645
2646 defsubr (&Sdo_applescript);
2647 defsubr (&Smac_file_name_to_posix);
2648 defsubr (&Sposix_file_name_to_mac);
2649}
generated by cgit v1.2.1 (git 2.18.0) at 2026-02-25 01:27:29 +0000