home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / C / Applications / MacPerl 5.0.3 / MacPerl Source ƒ / Perl5 / missing.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-27  |  9.8 KB  |  532 lines  |  [TEXT/MPS ]
  1. /* $Header: tyrathect:Development:Perl::RCS:missing.c,v 1.2 1994/05/04 02:12:43 neeri Exp $
  2.  *
  3.  *    Copyright (c) 1991-1994 Matthias Neeracher
  4.  *
  5.  *    You may distribute under the terms of the Perl Artistic License,
  6.  *    as specified in the README file.
  7.  *
  8.  * $Log: missing.c,v $
  9.  * Revision 1.2  1994/05/04  02:12:43  neeri
  10.  * Added gmtime(), enabled utime(), reduced spinning.
  11.  *
  12.  * Revision 1.1  1994/03/01  23:38:17  neeri
  13.  * Initial revision
  14.  *
  15.  */
  16.  
  17. /* NEVER try including perl.h here ! */
  18.  
  19. /* DISPATCH_START */
  20. #define MAC_CONTEXT
  21. #define MP_EXT
  22. #define MP_INIT(x) = x
  23.  
  24. #include <time.h>
  25. #include <stdio.h>
  26. #include <Folders.h>
  27. #include <Events.h>
  28. #include <OSUtils.h>
  29. #include <LowMem.h>
  30. #include <GUSI.h>
  31. #include <TFileSpec.h>
  32. #include <TFileGlob.h>
  33. #include <fp.h>
  34. #include <LowMem.h>
  35.  
  36. #define MEM_SIZE    Size_t
  37.  
  38. #include "config.h"
  39. #include "handy.h"
  40. #include "macish.h"
  41. #include "SubLaunch.h"
  42. /* DISPATCH_END */
  43.  
  44. /* Calls that don't exist on the mac */
  45.  
  46. /* Borrowed from msdos.c
  47.  * Just pretend that everyone is a superuser
  48.  */
  49. /* DISPATCH_START */
  50. #define ROOT_UID    0
  51. #define ROOT_GID    0
  52. int
  53. (getuid)(void)
  54. {
  55.     return ROOT_UID;
  56. }
  57.  
  58. int
  59. (geteuid)(void)
  60. {
  61.     return ROOT_UID;
  62. }
  63.  
  64. int
  65. (getgid)(void)
  66. {
  67.     return ROOT_GID;
  68. }
  69.  
  70. int
  71. (getegid)(void)
  72. {
  73.     return ROOT_GID;
  74. }
  75.  
  76. int
  77. (setuid)(int uid)
  78. { 
  79.     return (uid==ROOT_UID?0:-1);
  80. }
  81.  
  82. int
  83. setgid(int gid)
  84. { 
  85.     return (gid==ROOT_GID?0:-1); 
  86. }
  87.  
  88. #undef execv
  89.  
  90. (execv)()
  91. {
  92.     croak("execv() not implemented on the Macintosh");
  93. }
  94.  
  95. #undef execvp
  96.  
  97. (execvp)()
  98. {
  99.     croak("execvp() not implemented on the Macintosh");
  100. }
  101.  
  102. kill()
  103. {
  104.     croak("kill() not implemented on the Macintosh");
  105. }
  106. /* DISPATCH_END */
  107.  
  108. char **environ;
  109. static    char *    gEnvpool;
  110. extern int StandAlone;
  111.  
  112. char ** init_env(char ** env)
  113. {
  114.     int        envcnt    =    0;
  115.     int        envsize    =    0;
  116.     int        varlen;
  117.     char *    envpool;
  118.     FILE *    envfile    =    0;
  119.     
  120.     for (envcnt = 0; env[envcnt]; envcnt++)    {
  121.         varlen    = strlen(env[envcnt]);
  122.         envsize    +=    varlen+strlen(env[envcnt]+varlen+1)+2;
  123.     }
  124.     
  125.     if (gEnvpool) {
  126.         Safefree(environ);
  127.         Safefree(gEnvpool);
  128.     }
  129.     
  130.     New(50, environ, envcnt+1, char *);
  131.     New(50, gEnvpool, envsize, char);
  132.     
  133.     envpool = gEnvpool;
  134.     for (envcnt = 0; env[envcnt]; envcnt++)    {
  135.         environ[envcnt]     = envpool;
  136.         varlen                = strlen(env[envcnt]);
  137.         strcpy(envpool, env[envcnt]);
  138.         envpool              += varlen+1;
  139.         envpool[-1]            = '=';
  140.         strcpy(envpool, env[envcnt]+varlen+1);
  141.         envpool              += strlen(env[envcnt]+varlen+1)+1;
  142.     }
  143.  
  144.     environ[envcnt] = 0;
  145.     
  146.     return environ;
  147. }    
  148.  
  149. typedef struct PD {
  150.     struct PD *    next;
  151.     FILE *        tempFile;
  152.     FSSpec        pipeFile;
  153.     char *        execute;
  154.     long            status;
  155. } PipeDescr, *PipeDescrPtr;
  156.  
  157. static PipeDescrPtr    pipes        =    nil;
  158. static Boolean            sweeper    =    false;
  159.  
  160. void sweep()
  161. {
  162.     while (pipes)
  163.         my_pclose(pipes->tempFile);
  164.     sweeper = false;
  165. }
  166.  
  167. typedef struct WEPDesc {
  168.     struct WEPDesc *    next;
  169.     const char *                            command;
  170.     EmulationProc                             proc;
  171. } WEPDesc, * WEPDescPtr;
  172.  
  173. static WEPDescPtr         gEmulators[128];
  174. static Boolean            gHasEmulators = false;
  175.  
  176. void AddWriteEmulationProc(const char * command, EmulationProc proc)
  177. {
  178.     WEPDescPtr    wepdesc     = (WEPDescPtr) malloc(sizeof(WEPDesc));
  179.     
  180.     wepdesc->next             =     gEmulators[*command];
  181.     wepdesc->command        =    command;
  182.     wepdesc->proc            =    proc;
  183.     gEmulators[*command]    =    wepdesc;
  184. }
  185.  
  186. EmulationProc FindWriteEmulationProc(char * command, char ** rest)
  187. {
  188.     char *         end;
  189.     WEPDescPtr    queue;
  190.     
  191.     for (end = command; isalnum(*end); ++end);
  192.     
  193.     if (end == command || (*command & 0x80))
  194.         return nil;
  195.     
  196.     for (queue = gEmulators[*command]; queue; queue = queue->next)
  197.         if (!strncmp(command, queue->command, end-command))
  198.             if (!queue->command[end-command]) {
  199.                 while (isspace(*end))
  200.                     ++end;
  201.                 *rest = end;
  202.                 
  203.                 return queue->proc;
  204.             }
  205.     
  206.     return nil;
  207. }
  208.  
  209. static int EmulatePwd(FILE * tempFile, char * command)
  210. {
  211.     char curdir[256];
  212.     
  213.     if (!getcwd(curdir, 256)) 
  214.         return -1;
  215.     
  216.     fprintf(tempFile, "%s\n", curdir);
  217.     
  218.     return 0;
  219. }
  220.  
  221. static int EmulateHostname(FILE * tempFile, char * command)
  222. {
  223.     char curhostname[256];
  224.     
  225.     if (gethostname(curhostname, 256)) 
  226.         return -1;
  227.     
  228.     fprintf(tempFile, "%s\n", curhostname);
  229.     
  230.     return 0;
  231. }
  232.  
  233. static int EmulateGlob(FILE * tempFile, char * command)
  234. {
  235.     char             curbuf[256];
  236.     char *        curcmd;
  237.     Boolean        relativePath;
  238.     int            colonCount;
  239.     FileGlobRef    glob;
  240.     FSSpec         spec;
  241.     FSSpec        curDir;
  242.     
  243.     for (curcmd = curbuf; !isspace(*command); )
  244.         if (!(*curcmd++ = *command++))
  245.             break;
  246.  
  247.     if (!(glob = NewFileGlob(curbuf)))
  248.         return -1;
  249.     
  250.     relativePath = true;
  251.     
  252.     if (curbuf[0] == ':') {
  253.         /* Explicitely relative path, e.g. <:*.c> */
  254.         char     ch;
  255.         
  256.         for (curcmd = curbuf+1; *curcmd == ':'; ++curcmd)
  257.             ;
  258.         
  259.         ch             = *curcmd; 
  260.         *curcmd        = 0;
  261.         Path2FSSpec(curbuf, &curDir);
  262.         *curcmd        = ch;
  263.         colonCount     =    curcmd - curbuf;
  264.     } else if (!strchr(curbuf, ':')) {
  265.         /* Implicitely relative path, e.g. <*.c> */
  266.         colonCount     =     0;
  267.         Path2FSSpec(":", &curDir);
  268.     } else
  269.         relativePath = false;
  270.         
  271.     while (FileGlob2FSSpec(glob, &spec)) {
  272.         if (relativePath) {
  273.             curcmd = FSp2DirRelPath(&spec, &curDir);
  274.             if (colonCount) {
  275.                 int i = colonCount - (*curcmd == ':');
  276.                 while (i--)
  277.                     putc(':', tempFile);
  278.             }
  279.         } else
  280.             curcmd = FSp2FullPath(&spec);
  281.         
  282.         fprintf(tempFile, "%s\n", curcmd);
  283.         NextFileGlob(glob);
  284.     }
  285.     DisposeFileGlob(glob);
  286.     
  287.     return 0;
  288. }
  289.  
  290. FILE * my_popen(char * command, char * mode)
  291. {
  292.     PipeDescrPtr    pipe;
  293.     
  294.     if (!gHasEmulators) {
  295.         gHasEmulators = true;
  296.         AddWriteEmulationProc("pwd", EmulatePwd);
  297.         AddWriteEmulationProc("directory", EmulatePwd);
  298.         AddWriteEmulationProc("Directory", EmulatePwd);
  299.         AddWriteEmulationProc("hostname", EmulateHostname);
  300.         AddWriteEmulationProc("glob", EmulateGlob);
  301.     }
  302.     
  303.     if (!strcmp(command, "-"))
  304.         croak("Implicit fork() on a Mac? No forking chance");
  305.     
  306.     New(666, pipe, 1, PipeDescr);
  307.     
  308.     if (!pipe)
  309.         return NULL;
  310.         
  311.     if (FSpMakeTempFile(&pipe->pipeFile))
  312.         goto failed;
  313.     pipe->execute    =    nil;
  314.     
  315.     switch(*mode)    {
  316.     case 'r':
  317.         {
  318.             /* Ugh ! A hardcoded command  ! */
  319.             EmulationProc proc = FindWriteEmulationProc(command, &command);
  320.             
  321.             if (proc) {
  322.                 if (!(pipe->tempFile    = fopen(FSp2FullPath(&pipe->pipeFile), "w")))
  323.                     goto delete;
  324.                 if (proc(pipe->tempFile, command))
  325.                     goto delete;
  326.                 fclose(pipe->tempFile);
  327.             } else if (SubLaunch(command, nil, &pipe->pipeFile, &pipe->pipeFile, &pipe->status))
  328.                 goto delete;
  329.             
  330.             if (!(pipe->tempFile    = fopen(FSp2FullPath(&pipe->pipeFile), "r")))
  331.                 goto delete;
  332.             break;
  333.         }
  334.     case 'w':
  335.         New(667, pipe->execute, strlen(command)+1, char);
  336.         if (!pipe->execute || !(pipe->tempFile    = fopen(FSp2FullPath(&pipe->pipeFile), "w")))
  337.             goto delete;
  338.         strcpy(pipe->execute, command);
  339.         break;
  340.     }
  341.     
  342.     pipe->next    =    pipes;
  343.     pipes            =    pipe;
  344.     
  345.     if (!sweeper)    {
  346.         atexit(sweep);
  347.         sweeper    =    true;
  348.     }
  349.  
  350.     return pipe->tempFile;
  351. delete:
  352.     if (pipe->execute)
  353.         Safefree(pipe->execute);
  354.     HDelete(pipe->pipeFile.vRefNum, pipe->pipeFile.parID, pipe->pipeFile.name);
  355. failed:
  356.     Safefree(pipe);
  357.     
  358.     return NULL;
  359. }
  360.  
  361. int my_pclose(FILE *    f)
  362. {
  363.     OSErr                err;
  364.     PipeDescrPtr *    prev;
  365.     PipeDescrPtr    pipe;
  366.     
  367.     for (prev = (PipeDescrPtr *) &pipes; pipe = *prev; prev = &pipe->next)
  368.         if (pipe->tempFile == f)
  369.             break;
  370.     
  371.     if (!pipe)
  372.         return -1;
  373.     
  374.     *prev = pipe->next;
  375.     
  376.     fclose(f);
  377.     
  378.     if (pipe->execute)
  379.         err = SubLaunch(pipe->execute, &pipe->pipeFile, nil, nil, &pipe->status);
  380.     else
  381.         err = noErr;
  382.         
  383.     HDelete(pipe->pipeFile.vRefNum, pipe->pipeFile.parID, pipe->pipeFile.name);
  384.     if (pipe->execute)
  385.         Safefree(pipe->execute);
  386.     Safefree(pipe);
  387.     
  388.     return err? -1 : (int) pipe->status;    
  389. }
  390.  
  391. void SpinMacCursor()
  392. {
  393.     static long lastSpin = 0;
  394.         
  395.     if (LMGetTicks() - lastSpin < 5)
  396.         return;
  397.         
  398.     lastSpin = LMGetTicks();
  399.         
  400.     (GUSIGetSpin())(SP_AUTO_SPIN, 1);
  401. }
  402.  
  403. /* DISPATCH_START */
  404. struct tm * gmtime(const time_t * timer)
  405. {
  406.     MachineLocation     loc;
  407.     struct tm *            swatch;
  408.     long                    delta;
  409.     time_t                rolex;
  410.     
  411.     ReadLocation(&loc);
  412.     
  413.     if (!loc.latitude && !loc.longitude)
  414.         return localtime(timer);    /* This is incorrect unless you live in Greenwich */
  415.     
  416.     delta = loc.u.gmtDelta & 0xFFFFFF;
  417.     
  418.     if (delta & 0x800000)
  419.         delta = (long) ((unsigned long) delta | 0xFF000000);
  420.         
  421.     rolex = (unsigned long) ((long) *timer - delta);
  422.     
  423.     swatch = localtime(&rolex);
  424.     
  425.     swatch->tm_isdst = (loc.u.dlsDelta & 0x80) != 0;
  426.     
  427.     return swatch;
  428.  }
  429. /* DISPATCH_END */
  430.  
  431. void mac_times(struct tms * t)
  432. {
  433.     t->tms_utime = clock() - gStartClock;
  434.     t->tms_stime = 0;
  435.     t->tms_cutime = 0;
  436.     t->tms_cstime = 0;
  437. }
  438.  
  439. #undef atof
  440.  
  441. double mac_atof(const char * nptr)
  442. {
  443.     /* The Mac returns NaN(17) on undefined strings, which is not acceptable
  444.        for Perl
  445.     */
  446.     double res = atof(nptr);
  447.     
  448.     if (isnan(res) /* This doesn't work: && res == nan("17") */)
  449.         return 0.0;
  450.     else
  451.         return res;
  452. }
  453.  
  454. void CopyC2PStr(char * cstr, StringPtr pstr)
  455. {
  456.     int    len;
  457.     
  458.     for (len = 0; *cstr && len<256; )
  459.         pstr[++len] = *cstr++;
  460.     
  461.     pstr[0] = len;
  462. }
  463.  
  464.  
  465. char * MPWFileName(char * file)
  466. {
  467.     if (!strcmp(file, "Dev:Pseudo"))
  468.         return gPseudoFileName;
  469.     else if (!strncmp(file, "Dev:Pseudo:", 11))
  470.         return file + 11;
  471.     else
  472.         return file;
  473. }
  474.  
  475. char * MPWPosIndication(char * buf, char * file, long line)
  476. {
  477.     file = MPWFileName(file);
  478.  
  479.     if (gFirstErrorLine == -1 && !Path2FSSpec(file, &gFirstErrorFile))
  480.         gFirstErrorLine = line;
  481.     
  482.     strcpy(buf, "File '"); 
  483.     buf += 6;
  484.     
  485.     while (*file) 
  486.         if (*file == '\'') {
  487.         strcpy(buf, "'∂''");
  488.         buf += 3;
  489.         ++file;
  490.     } else
  491.         *buf++ = *file++;
  492.         
  493.     if (buf[-1] == '\'' && buf[-2] == '\'')
  494.         --buf;
  495.     else
  496.         *buf++ = '\'';
  497.  
  498.     return buf + sprintf(buf, "; Line %ld", line);
  499. }
  500.  
  501. int OverrideExtract(char * origname)
  502. {
  503.     char         file[256];
  504.     
  505.     strcpy(file+1, MPWFileName(origname));
  506.     file[0] = strlen(file+1);
  507.     ParamText((StringPtr) file, "\p", "\p", "\p");
  508.     
  509.     return Alert(270, (ModalFilterUPP) nil) == 1;
  510. }
  511.  
  512. #define STACK_INTERVENTION_LIMIT    8192
  513.  
  514. void StackAttack()
  515. {
  516.     if (StackSpace() < STACK_INTERVENTION_LIMIT)
  517.         croak("Stack space getting low ! Aborting script for your own good...\n");
  518. }
  519.  
  520. void mac_initminiperl()
  521. {
  522.     InitGraf((Ptr) &qd.thePort);
  523.     gStartClock      = LMGetTicks();
  524. }
  525.  
  526. /* DISPATCH_START */
  527. pid_t (getpid)()
  528. {
  529.     return 1;
  530. }
  531. /* DISPATCH_END */
  532.