home *** CD-ROM | disk | FTP | other *** search
/ Black Box 4 / BlackBox.cdr / genapps / hp22de.arj / EXTERN / GLOBALS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-04-16  |  3.6 KB  |  179 lines
  1. #include "extern.h"        /* Extensions need these! */
  2. #include "io.h"
  3.  
  4. #define ID        0x1234        /* unique ID for this file type */
  5.  
  6. /*
  7. ** This routine saves all of the global variables to a file.
  8. **
  9. ** To call this handler from HyperPAD:
  10. **
  11. **    readGlobals;
  12. */
  13. int ReadGlobals(int NumArgs,HANDLE hFileName)
  14.  
  15. {
  16.     HANDLE hName,hValue;
  17.     int handle;
  18.     WORD w;
  19.  
  20.     if (NumArgs != 1) return(STOP);
  21.  
  22.     /* open the file, check to see if it opened successfully */
  23.     handle = open(deref(hFileName),READ);
  24.     if (handle == -1) return(STOP);
  25.  
  26.     /* read the ID and check if it is valid */
  27.     read(handle,&w,sizeof(w));
  28.     if (w != ID) goto closeit;
  29.  
  30.     /* read the size of the first name */
  31.     read(handle,&w,sizeof(w));
  32.  
  33.     while (w != 0xffff) {
  34.  
  35.         /* allocate and read in the name of the global variable */
  36.         hName = NewHandle(w + 1);
  37.         read(handle,deref(hName),w);
  38.         deref(hName)[w] = '\0';
  39.  
  40.         /* read in the size of the value */
  41.         read(handle,&w,sizeof(w));
  42.  
  43.         /* allocate and read in the value */
  44.         hValue = NewHandle(w + 1);
  45.         read(handle,deref(hValue),w);
  46.         deref(hValue)[w] = '\0';
  47.  
  48.         /* set the global in HyperPAD */
  49.         SetGlobal(hName,hValue);
  50.  
  51.         /* free the name (don't deallocate the value) */
  52.         FreeHandle(hName);
  53.  
  54.         /* read in the size of the next global's name (0xFFFF == EOF) */
  55.         read(handle,&w,sizeof(w));
  56.     }
  57.  
  58. closeit:
  59.  
  60.     close(handle);
  61.     return(STOP);
  62. }
  63.  
  64. /*
  65. ** This routine saves all of the global variables to a file.
  66. **
  67. ** To call this handler from HyperPAD:
  68. **
  69. **    saveGlobals "globals.dat";
  70. */
  71. int SaveGlobals(int NumArgs,HANDLE hFileName)
  72.  
  73. {
  74.     HANDLE hdl;
  75.     PTR p,n;
  76.     int handle;
  77.     HANDLE hName,hValue;
  78.     WORD w;
  79.  
  80.     if (NumArgs != 1) return(STOP);
  81.  
  82.     /* create the file, check to see if the open was successful */
  83.     handle = create(deref(hFileName));
  84.     if (handle < 0) return(STOP);
  85.  
  86.     /* get a comma-delimited list of global variable names */
  87.     hdl = GetGlobals();
  88.  
  89.     /* allocate space for a single name */
  90.     hName = NewHandle(50);
  91.     p = LockHandle(hdl);
  92.  
  93.     /* write the unique ID to the file */
  94.     w = ID;
  95.     write(handle,&w,sizeof(w));
  96.  
  97.     while (TRUE) {
  98.  
  99.         // figure out the end of the name
  100.         n = deref(hName);
  101.         while (*p && *p != ',') *n++ = *p++;
  102.         *n = '\0';
  103.  
  104.         /* write the length of the name to the file */
  105.         w = strlen(deref(hName));
  106.         write(handle,&w,sizeof(w));
  107.  
  108.         /* write the name to the file */
  109.         write(handle,deref(hName),w);
  110.  
  111.         /* get the global's value */
  112.         hValue = GetGlobal(hName);
  113.  
  114.         /* write the value's length to the file */
  115.         w = strlen(deref(hValue));
  116.         write(handle,&w,sizeof(w));
  117.  
  118.         /* write the value to the file */
  119.         write(handle,deref(hValue),w);
  120.  
  121.         /* free the value (we are done with it) */
  122.         FreeHandle(hValue);
  123.  
  124.         /* end of global name list? */
  125.         if (*p) p++;
  126.         else break;
  127.     }
  128.  
  129.     /* write the end-of-file marking */
  130.     w = 0xffff;
  131.     write(handle,&w,sizeof(w));
  132.  
  133.     close(handle);
  134.  
  135.     /* free the global variable name list and the temporary name holder */
  136.     FreeHandle(hdl);
  137.     FreeHandle(hName);
  138.  
  139.     return(STOP);
  140. }
  141.  
  142. /*
  143. ** This routine returns a comma-delimited list of global variable names to
  144. ** HyperPAD.
  145. **
  146. ** To call this function:
  147. **
  148. **    put the globals into page field 1;
  149. **
  150. **    if "firstLine" is in globals() then beep;
  151. */
  152. GlobalNames(int NumArgs)
  153.  
  154. {
  155.     ReturnValue(GetGlobals());
  156.     return(STOP);
  157. }
  158.  
  159. POOL pascal Pool[] = {
  160.     {    "GetGlobals",
  161.         ReadGlobals,
  162.         0,
  163.         HANDLER},
  164.  
  165.     {    "PutGlobals",
  166.         SaveGlobals,
  167.         0,
  168.         HANDLER},
  169.  
  170.     {    "Globals",
  171.         GlobalNames,
  172.         0,
  173.         FUNCTION},
  174.  
  175.     {    NULL,
  176.         NULL,
  177.         0,
  178.         0}    };
  179.