home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / Python 1.3 / source code / Mac / macmodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-12-17  |  9.6 KB  |  552 lines  |  [TEXT/R*ch]
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its 
  8. documentation for any purpose and without fee is hereby granted, 
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in 
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI not be used in advertising or publicity pertaining to
  13. distribution of the software without specific, written prior permission.
  14.  
  15. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
  16. THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  17. FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
  18. FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19. WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20. ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  21. OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22.  
  23. ******************************************************************/
  24.  
  25. /* Mac module implementation */
  26.  
  27. #include "allobjects.h"
  28. #include "modsupport.h"
  29. #include "ceval.h"
  30.  
  31. #include <stdio.h>
  32. #include <string.h>
  33. #include <errno.h>
  34.  
  35. #ifdef THINK_C
  36. #include "unix.h"
  37. #undef S_IFMT
  38. #undef S_IFDIR
  39. #undef S_IFCHR
  40. #undef S_IFBLK
  41. #undef S_IFREG
  42. #undef S_ISDIR
  43. #undef S_ISREG
  44. #endif
  45.  
  46. #include "macstat.h"
  47.  
  48. #ifdef __MWERKS__
  49. /* For CodeWarrior 4 also define CW4 */
  50. #include <unix.h>
  51. #else
  52. #include <fcntl.h>
  53. #endif
  54.  
  55. #if defined(__MWERKS__) && defined(__powerc)
  56. #define MALLOC_DEBUG
  57. #endif
  58.  
  59. #include "macdefs.h"
  60. #include "dirent.h"
  61.  
  62. #ifndef MAXPATHLEN
  63. #define MAXPATHLEN 1024
  64. #endif
  65.  
  66. /* Prototypes for Unix simulation on Mac */
  67.  
  68. int chdir PROTO((const char *path));
  69. char *getbootvol PROTO((void));
  70. char *getwd PROTO((char *));
  71. int mkdir PROTO((const char *path, int mode));
  72. DIR * opendir PROTO((char *));
  73. void closedir PROTO((DIR *));
  74. struct dirent * readdir PROTO((DIR *));
  75. int rmdir PROTO((const char *path));
  76. int sync PROTO((void));
  77. #if defined(THINK_C) || defined(__SC__)
  78. int unlink PROTO((char *));
  79. #else
  80. int unlink PROTO((const char *));
  81. #endif
  82.  
  83.  
  84.  
  85. static object *MacError; /* Exception mac.error */
  86.  
  87. /* Set a MAC-specific error from errno, and return NULL */
  88.  
  89. static object * 
  90. mac_error() 
  91. {
  92.     return err_errno(MacError);
  93. }
  94.  
  95. /* MAC generic methods */
  96.  
  97. static object *
  98. mac_1str(args, func)
  99.     object *args;
  100.     int (*func) FPROTO((const char *));
  101. {
  102.     char *path1;
  103.     int res;
  104.     if (!getargs(args, "s", &path1))
  105.         return NULL;
  106.     BGN_SAVE
  107.     res = (*func)(path1);
  108.     END_SAVE
  109.     if (res < 0)
  110.         return mac_error();
  111.     INCREF(None);
  112.     return None;
  113. }
  114.  
  115. static object *
  116. mac_2str(args, func)
  117.     object *args;
  118.     int (*func) FPROTO((const char *, const char *));
  119. {
  120.     char *path1, *path2;
  121.     int res;
  122.     if (!getargs(args, "(ss)", &path1, &path2))
  123.         return NULL;
  124.     BGN_SAVE
  125.     res = (*func)(path1, path2);
  126.     END_SAVE
  127.     if (res < 0)
  128.         return mac_error();
  129.     INCREF(None);
  130.     return None;
  131. }
  132.  
  133. static object *
  134. mac_strint(args, func)
  135.     object *args;
  136.     int (*func) FPROTO((const char *, int));
  137. {
  138.     char *path;
  139.     int i;
  140.     int res;
  141.     if (!getargs(args, "(si)", &path, &i))
  142.         return NULL;
  143.     BGN_SAVE
  144.     res = (*func)(path, i);
  145.     END_SAVE
  146.     if (res < 0)
  147.         return mac_error();
  148.     INCREF(None);
  149.     return None;
  150. }
  151.  
  152. static object *
  153. mac_chdir(self, args)
  154.     object *self;
  155.     object *args;
  156. {
  157.     return mac_1str(args, chdir);
  158. }
  159.  
  160. #ifndef CW4
  161. static object *
  162. mac_close(self, args)
  163.     object *self;
  164.     object *args;
  165. {
  166.     int fd, res;
  167.     if (!getargs(args, "i", &fd))
  168.         return NULL;
  169.     BGN_SAVE
  170.     res = close(fd);
  171.     END_SAVE
  172.     if (res < 0)
  173.         return mac_error();
  174.     INCREF(None);
  175.     return None;
  176. }
  177. #endif /* !__MWERKS__ */
  178.  
  179. #ifdef MPW
  180.  
  181. static object *
  182. mac_dup(self, args)
  183.     object *self;
  184.     object *args;
  185. {
  186.     int fd;
  187.     if (!getargs(args, "i", &fd))
  188.         return NULL;
  189.     BGN_SAVE
  190.     fd = dup(fd);
  191.     END_SAVE
  192.     if (fd < 0)
  193.         return mac_error();
  194.     return newintobject((long)fd);
  195. }
  196.  
  197. #endif /* MPW */
  198.  
  199. #ifndef __MWERKS__
  200. static object *
  201. mac_fdopen(self, args)
  202.     object *self;
  203.     object *args;
  204. {
  205.     extern int fclose PROTO((FILE *));
  206.     int fd;
  207.     char *mode;
  208.     FILE *fp;
  209.     if (!getargs(args, "(is)", &fd, &mode))
  210.         return NULL;
  211.     BGN_SAVE
  212.     fp = fdopen(fd, mode);
  213.     END_SAVE
  214.     if (fp == NULL)
  215.         return mac_error();
  216.     return newopenfileobject(fp, "(fdopen)", mode, fclose);
  217. }
  218. #endif
  219.  
  220. static object *
  221. mac_getbootvol(self, args)
  222.     object *self;
  223.     object *args;
  224. {
  225.     char *res;
  226.     if (!getnoarg(args))
  227.         return NULL;
  228.     BGN_SAVE
  229.     res = getbootvol();
  230.     END_SAVE
  231.     if (res == NULL)
  232.         return mac_error();
  233.     return newstringobject(res);
  234. }
  235.  
  236. static object *
  237. mac_getcwd(self, args)
  238.     object *self;
  239.     object *args;
  240. {
  241.     char path[MAXPATHLEN];
  242.     char *res;
  243.     if (!getnoarg(args))
  244.         return NULL;
  245.     BGN_SAVE
  246.     res = getwd(path);
  247.     END_SAVE
  248.     if (res == NULL) {
  249.         err_setstr(MacError, path);
  250.         return NULL;
  251.     }
  252.     return newstringobject(res);
  253. }
  254.  
  255. static object *
  256. mac_listdir(self, args)
  257.     object *self;
  258.     object *args;
  259. {
  260.     char *name;
  261.     object *d, *v;
  262.     DIR *dirp;
  263.     struct dirent *ep;
  264.     if (!getargs(args, "s", &name))
  265.         return NULL;
  266.     BGN_SAVE
  267.     if ((dirp = opendir(name)) == NULL) {
  268.         RET_SAVE
  269.         return mac_error();
  270.     }
  271.     if ((d = newlistobject(0)) == NULL) {
  272.         closedir(dirp);
  273.         RET_SAVE
  274.         return NULL;
  275.     }
  276.     while ((ep = readdir(dirp)) != NULL) {
  277.         v = newstringobject(ep->d_name);
  278.         if (v == NULL) {
  279.             DECREF(d);
  280.             d = NULL;
  281.             break;
  282.         }
  283.         if (addlistitem(d, v) != 0) {
  284.             DECREF(v);
  285.             DECREF(d);
  286.             d = NULL;
  287.             break;
  288.         }
  289.         DECREF(v);
  290.     }
  291.     closedir(dirp);
  292.     END_SAVE
  293.  
  294.     return d;
  295. }
  296.  
  297. #ifndef CW4
  298. static object *
  299. mac_lseek(self, args)
  300.     object *self;
  301.     object *args;
  302. {
  303.     int fd;
  304.     int where;
  305.     int how;
  306.     long res;
  307.     if (!getargs(args, "(iii)", &fd, &where, &how))
  308.         return NULL;
  309.     BGN_SAVE
  310.     res = lseek(fd, (long)where, how);
  311.     END_SAVE
  312.     if (res < 0)
  313.         return mac_error();
  314.     return newintobject(res);
  315. }
  316. #endif /* !CW4 */
  317.  
  318. static object *
  319. mac_mkdir(self, args)
  320.     object *self;
  321.     object *args;
  322. {
  323.     return mac_strint(args, mkdir);
  324. }
  325.  
  326. #ifndef CW4
  327. static object *
  328. mac_open(self, args)
  329.     object *self;
  330.     object *args;
  331. {
  332.     char *path;
  333.     int mode;
  334.     int fd;
  335.     if (!getargs(args, "(si)", &path, &mode))
  336.         return NULL;
  337.     BGN_SAVE
  338.     fd = open(path, mode);
  339.     END_SAVE
  340.     if (fd < 0)
  341.         return mac_error();
  342.     return newintobject((long)fd);
  343. }
  344.  
  345. static object *
  346. mac_read(self, args)
  347.     object *self;
  348.     object *args;
  349. {
  350.     int fd, size;
  351.     object *buffer;
  352.     if (!getargs(args, "(ii)", &fd, &size))
  353.         return NULL;
  354.     buffer = newsizedstringobject((char *)NULL, size);
  355.     if (buffer == NULL)
  356.         return NULL;
  357.     BGN_SAVE
  358.     size = read(fd, getstringvalue(buffer), size);
  359.     END_SAVE
  360.     if (size < 0) {
  361.         DECREF(buffer);
  362.         return mac_error();
  363.     }
  364.     resizestring(&buffer, size);
  365.     return buffer;
  366. }
  367. #endif /* !__MWERKS */
  368.  
  369. static object *
  370. mac_rename(self, args)
  371.     object *self;
  372.     object *args;
  373. {
  374.     return mac_2str(args, rename);
  375. }
  376.  
  377. static object *
  378. mac_rmdir(self, args)
  379.     object *self;
  380.     object *args;
  381. {
  382.     return mac_1str(args, rmdir);
  383. }
  384.  
  385. static object *
  386. mac_stat(self, args)
  387.     object *self;
  388.     object *args;
  389. {
  390.     struct macstat st;
  391.     char *path;
  392.     int res;
  393.     if (!getargs(args, "s", &path))
  394.         return NULL;
  395.     BGN_SAVE
  396.     res = macstat(path, &st);
  397.     END_SAVE
  398.     if (res != 0)
  399.         return mac_error();
  400.     return mkvalue("(llllllllll)",
  401.             (long)st.st_mode,
  402.             (long)st.st_ino,
  403.             (long)st.st_dev,
  404.             (long)st.st_nlink,
  405.             (long)st.st_uid,
  406.             (long)st.st_gid,
  407.             (long)st.st_size,
  408.             (long)st.st_atime,
  409.             (long)st.st_mtime,
  410.             (long)st.st_ctime);
  411. }
  412.  
  413. static object *
  414. mac_xstat(self, args)
  415.     object *self;
  416.     object *args;
  417. {
  418.     struct macstat st;
  419.     char *path;
  420.     int res;
  421.     if (!getargs(args, "s", &path))
  422.         return NULL;
  423.     BGN_SAVE
  424.     res = macstat(path, &st);
  425.     END_SAVE
  426.     if (res != 0)
  427.         return mac_error();
  428.     return mkvalue("(llllllllllls#s#)",
  429.             (long)st.st_mode,
  430.             (long)st.st_ino,
  431.             (long)st.st_dev,
  432.             (long)st.st_nlink,
  433.             (long)st.st_uid,
  434.             (long)st.st_gid,
  435.             (long)st.st_size,
  436.             (long)st.st_atime,
  437.             (long)st.st_mtime,
  438.             (long)st.st_ctime,
  439.             (long)st.st_rsize,
  440.             st.st_creator, 4,
  441.             st.st_type, 4);
  442. }
  443.  
  444. static object *
  445. mac_sync(self, args)
  446.     object *self;
  447.     object *args;
  448. {
  449.     int res;
  450.     if (!getnoarg(args))
  451.         return NULL;
  452.     BGN_SAVE
  453.     res = sync();
  454.     END_SAVE
  455.     if (res != 0)
  456.         return mac_error();
  457.     INCREF(None);
  458.     return None;
  459. }
  460.  
  461. static object *
  462. mac_unlink(self, args)
  463.     object *self;
  464.     object *args;
  465. {
  466.     return mac_1str(args, (int (*)(const char *))unlink);
  467. }
  468.  
  469. #ifndef CW4
  470. static object *
  471. mac_write(self, args)
  472.     object *self;
  473.     object *args;
  474. {
  475.     int fd, size;
  476.     char *buffer;
  477.     if (!getargs(args, "(is#)", &fd, &buffer, &size))
  478.         return NULL;
  479.     BGN_SAVE
  480.     size = write(fd, buffer, size);
  481.     END_SAVE
  482.     if (size < 0)
  483.         return mac_error();
  484.     return newintobject((long)size);
  485. }
  486. #endif /* !__MWERKS__ */
  487.  
  488. #ifdef MALLOC_DEBUG
  489. static object *
  490. mac_mstats(self, args)
  491.     object*self;
  492.     object *args;
  493. {
  494.     mstats("python");
  495.     INCREF(None);
  496.     return None;
  497. }
  498. #endif MALLOC_DEBUG
  499.  
  500. static struct methodlist mac_methods[] = {
  501.     {"chdir",    mac_chdir},
  502. #ifndef CW4
  503.     {"close",    mac_close},
  504. #endif
  505. #ifdef MPW
  506.     {"dup",        mac_dup},
  507. #endif
  508. #ifndef __MWERKS__
  509.     {"fdopen",    mac_fdopen},
  510. #endif
  511.     {"getbootvol",    mac_getbootvol}, /* non-standard */
  512.     {"getcwd",    mac_getcwd},
  513.     {"listdir",    mac_listdir, 0},
  514. #ifndef CW4
  515.     {"lseek",    mac_lseek},
  516. #endif
  517.     {"mkdir",    mac_mkdir},
  518. #ifndef CW4
  519.     {"open",    mac_open},
  520.     {"read",    mac_read},
  521. #endif
  522.     {"rename",    mac_rename},
  523.     {"rmdir",    mac_rmdir},
  524.     {"stat",    mac_stat},
  525.     {"xstat",    mac_xstat},
  526.     {"sync",    mac_sync},
  527.     {"unlink",    mac_unlink},
  528. #ifndef CW4
  529.     {"write",    mac_write},
  530. #endif
  531. #ifdef MALLOC_DEBUG
  532.     {"mstats",    mac_mstats},
  533. #endif
  534.  
  535.     {NULL,        NULL}         /* Sentinel */
  536. };
  537.  
  538.  
  539. void
  540. initmac()
  541. {
  542.     object *m, *d;
  543.     
  544.     m = initmodule("mac", mac_methods);
  545.     d = getmoduledict(m);
  546.     
  547.     /* Initialize mac.error exception */
  548.     MacError = newstringobject("mac.error");
  549.     if (MacError == NULL || dictinsert(d, "error", MacError) != 0)
  550.         fatal("can't define mac.error");
  551. }
  552.