home *** CD-ROM | disk | FTP | other *** search
/ World of A1200 / World_Of_A1200.iso / programs / compress / misc / xfh / source.lha / src / options.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-09  |  18.7 KB  |  702 lines
  1. /* options.c - Routines to handle the setting of user options.
  2.    Copyright (C) 1991, 1992, 1993 Kristian Nielsen.
  3.  
  4.    This file is part of XFH, the compressing file system handler.
  5.  
  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 2 of the License, or
  9.    (at your option) any later version.
  10.  
  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License
  17.    along with this program; if not, write to the Free Software
  18.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.            */
  19.  
  20. #include "CFS.h"
  21. #include <dossupport.h>
  22.  
  23. #include <libraries/filehandler.h>
  24.  
  25. #include <proto/exec.h>
  26. #include <proto/icon.h>
  27.  
  28. #include <ctype.h>
  29. #include <string.h>
  30. #include <stdlib.h>
  31. #include <stdio.h>
  32.  
  33.  
  34. #define EOL '\n'         /* Seperates lines in option files. */
  35. #define STARTUP_SEP '!'  /* Seperates entries ("lines") in startup string. */
  36. #define QUOTE_CHAR '\"'  /* Will be stripped from startup string. ("*"->*) */
  37. #define DEFCHAR '='
  38. #define FAKEDEFCHAR '&'  /* Chars usable in options ('optname * option').  */
  39.  
  40. struct Library *IconBase;
  41.  
  42. static BOOL parse_bool_opt(glb glob, char *opt, BOOL *var){
  43.   debug(("parse_bool_opt(): '%s'.\n",opt));
  44.   if(MatchToolValue(opt, "OFF")) *var = FALSE;
  45.   else if(MatchToolValue(opt, "NO")) *var = FALSE;
  46.   else if(MatchToolValue(opt, "ON")) *var = TRUE;
  47.   else if(MatchToolValue(opt, "YES")) *var = TRUE;
  48.   else{
  49.     debug(("Illegal bolean value.\n"));
  50.     return FALSE;
  51.   }
  52.   debug(("Result: %ld.\n",*var));
  53.   return TRUE;
  54. }
  55.  
  56. /* This function can be used to set a boolean option. */
  57.  
  58. static BOOL bool_opt(glb glob, char *opt, BOOL *var, BOOL default_val){
  59.    if(!opt){
  60.       *var = default_val;
  61.       return TRUE;
  62.    }else{
  63.       return parse_bool_opt(glob, opt, var);
  64.    }
  65. }
  66.  
  67. /* These two functions can be used to set/sleanup string options. */
  68.  
  69. static void string_cleanup(glb glob, char **var){
  70.    if(*var){
  71.       dosfree(*var);
  72.       *var = NULL;
  73.    }
  74. }
  75.  
  76. static BOOL string_opt(glb glob, char *opt, char **var, char *default_val){
  77.    int len;
  78.    char *p;
  79.    
  80.    if(!opt){
  81.       /* Check for a default value of NULL. */
  82.       if(!default_val){
  83.          string_cleanup(glob, var);
  84.          *var = default_val;
  85.          return TRUE;
  86.       }else{
  87.          opt = default_val;
  88.       }
  89.    }
  90.    len = strlen(opt)+1;
  91.    if(!(p = dosalloc(len))){
  92.       OUTOFMEM;
  93.       return FALSE;
  94.    }
  95.    strcpy(p,opt);
  96.    string_cleanup(glob, var);
  97.    *var = p;
  98.    return TRUE;
  99. }
  100.  
  101. /* The option setting functions.
  102.  * Each function is passed the remainder of the options string as
  103.  * entered by the user, and is expected to set the appropriate option
  104.  * and return a boolean succes/failure.
  105.  *
  106.  * If called with a NULL argument, should set a default option.
  107.  *
  108.  * NOTE: A cleanup function will not be called without the corresponding
  109.  * set function being called first.
  110.  */
  111.  
  112. static BOOL opt_rootdir(glb glob, char *opt){
  113.    char default_name[MAXFILENAME+4];
  114.    
  115.    /* Get assign name to directory to serve as our default root. Obtained
  116.     * by pruning the first char of the device name (ie. XDH0:->DH0:). */
  117.    if(!glob->devname || !glob->devname[0]
  118.                      || strlen(glob->devname)>MAXFILENAME+1){
  119.       debug(("PANIC: Bad device name.\n"));
  120.       return FALSE;
  121.    }
  122.    strncpy(default_name,&glob->devname[1],MAXFILENAME+2);
  123.    strcat(default_name,":");
  124.    
  125.    return string_opt(glob, opt, &glob->xRootName, default_name);
  126. }
  127.  
  128. static void cleanup_rootdir(glb glob){
  129.    string_cleanup(glob, &glob->xRootName);
  130. }
  131.  
  132.  
  133. /* Option 'VOLUMENAME'. */
  134. static void cleanup_volname(glb glob){
  135.    string_cleanup(glob, &glob->uservolname);
  136. }
  137.  
  138. static BOOL opt_volname(glb glob, char *opt){
  139.   /* The default is NULL - this will signify to createvolnode() that it
  140.    * should create a default volume name.
  141.    */
  142.   cleanup_volname(glob);
  143.   if(!string_opt(glob, opt, &glob->uservolname, NULL)) return FALSE;
  144.   if(glob->volnode){
  145.     return SetVolumeNameVolNode(glob, glob->uservolname);
  146.   }else{
  147.     return TRUE;   /* createvolnode will set name. */
  148.   }
  149. }
  150.  
  151.  
  152. /* Option 'AUTOCOMPRESS'. */
  153. static BOOL opt_autocompress(glb glob, char *opt){
  154.    return bool_opt(glob, opt, &glob->autocompress, FALSE);
  155. }
  156.  
  157.  
  158. /* Option 'STEPDOWN'. */
  159. static BOOL opt_stepdown(glb glob, char *opt){
  160.    return bool_opt(glob, opt, &glob->stepdown, FALSE);
  161. }
  162.  
  163.  
  164. /* Option 'PACKMODE'. */
  165. static BOOL opt_packmode(glb glob, char *opt){
  166.    return string_opt(glob, opt, &glob->packmode, "NUKE");
  167. }
  168.  
  169. static void cleanup_packmode(glb glob){
  170.    string_cleanup(glob, &glob->packmode);
  171. }
  172.  
  173.  
  174. /* Option 'PASSWORD'. */
  175. static BOOL opt_password(glb glob, char *opt){
  176.    /* The default is NULL - no password (valid acc. to 'xpk.doc'). */
  177.    return string_opt(glob, opt, &glob->xpkpassword, NULL);
  178. }
  179.  
  180. static void cleanup_password(glb glob){
  181.    return string_cleanup(glob, &glob->xpkpassword);
  182. }
  183.  
  184.  
  185. /* Option 'TRUNCATEONPACK'. */
  186. static BOOL opt_truncateonpack(glb glob, char *opt){
  187.    return bool_opt(glob, opt, &glob->truncateonpack, FALSE);
  188. }
  189.  
  190.  
  191. /* Option 'XPKPRIORITY'. */
  192. static BOOL opt_xpkpriority(glb glob, char *opt){
  193.    if(opt){
  194.       glob->xpksetpri = TRUE;
  195.       glob->xpkpri = atoi(opt);
  196.    }else{
  197.       glob->xpksetpri = FALSE;
  198.    }
  199.    return TRUE;
  200. }
  201.  
  202.  
  203. /* Option 'CREATEVOLUME'. */
  204. static BOOL opt_createvol(glb glob, char *opt){
  205.    return bool_opt(glob, opt, &glob->createvolnode, TRUE);
  206. }
  207.  
  208.  
  209. /* Option 'FAILONEXNEXT'. */
  210. static BOOL opt_failonexnext(glb glob, char *opt){
  211.    return bool_opt(glob, opt, &glob->FailOnExNext, TRUE);
  212. }
  213.  
  214.  
  215. /* Option 'COMPRESSREADWRITE'. */
  216. static BOOL opt_compressrw(glb glob, char *opt){
  217.    return bool_opt(glob, opt, &glob->compressreadwrite, TRUE);
  218. }
  219.       
  220.      
  221. /* Option 'ALLOWAPPEND'. */
  222. static BOOL opt_allowappend(glb glob, char *opt){
  223.    return bool_opt(glob, opt, &glob->allowappend, TRUE);
  224. }
  225.       
  226.      
  227. /* Option 'KILLSTARTUP'. */
  228. static void cleanup_kstartup(glb glob){
  229.    DevNode_Stuff_Startup_String(glob, glob->bcplstartup);
  230. }
  231.  
  232.  
  233. static BOOL opt_killstartup(glb glob, char *opt){
  234.    BOOL tmp;
  235.  
  236.    if(!bool_opt(glob, opt, &tmp, TRUE)){
  237.       return FALSE;
  238.    }
  239.    if(tmp){
  240.       DevNode_Stuff_Startup_String(glob, 0L);
  241.    }else{
  242.       cleanup_kstartup(glob);
  243.    }
  244.    return TRUE;
  245. }
  246.  
  247.  
  248. /* Option 'PORTNAME'. */
  249. static BOOL opt_arexxportname(glb glob, char *opt){
  250.    return string_opt(glob, opt, &glob->userarexxportname, NULL);
  251. }
  252.  
  253. static void cleanup_arexxpname(glb glob){
  254.    string_cleanup(glob, &glob->userarexxportname);
  255. }
  256.  
  257.  
  258. /* The 'options table'. */
  259.  
  260. static struct opttable{
  261.    char *opt;
  262.    BOOL (*set)(glb, char *);     /* 'set' function. */
  263.    void (*cleanup)(glb);         /* 'cleanup' function. */
  264.    BOOL persistent;              /* True -> option can be set only once. */
  265. } opttable[] = {
  266.    "ROOTDIR",           opt_rootdir,         cleanup_rootdir,   TRUE,
  267.    "VOLUMENAME",        opt_volname,         cleanup_volname,   FALSE,
  268.    "AUTOCOMPRESS",      opt_autocompress,    NULL,              FALSE,
  269.    "STEPDOWN",          opt_stepdown,        NULL,              FALSE,
  270.    "PACKMODE",          opt_packmode,        cleanup_packmode,  FALSE,
  271.    "PASSWORD",          opt_password,        cleanup_password,  FALSE,
  272.    "TRUNCATEONPACK",    opt_truncateonpack,  NULL,              FALSE,
  273.    "XPKPRIORITY",       opt_xpkpriority,     NULL,              FALSE,
  274.    "CREATEVOLUME",      opt_createvol,       NULL,              TRUE,
  275.    "FAILONEXNEXT",      opt_failonexnext,    NULL,              FALSE,
  276.    "KILLSTARTUP",    opt_killstartup,     cleanup_kstartup,  FALSE,
  277.    "COMPRESSREADWRITE", opt_compressrw,      NULL,              FALSE,
  278.    "ALLOWAPPEND",       opt_allowappend,     NULL,              FALSE,
  279.    "PORTNAME",          opt_arexxportname,   cleanup_arexxpname,TRUE,
  280.    NULL
  281. };
  282.  
  283.  
  284. /* This function sets the options according to an option file (in
  285.  * char ** form as returned by buf2array()). The first time it is called
  286.  * initial should be TRUE to set default and persistent options.
  287.  * And initial should be TRUE ONLY the first time this is called!!!
  288.  */
  289. static BOOL SetOptions(glb glob, char **opts, BOOL initial){
  290.   struct opttable *p,*r;
  291.   char *q;
  292.   
  293.   {char **p;for(p=opts;*p;p++) debug(("'%s'\n",*p));}
  294.   for(p=opttable;p->opt;p++){
  295.     q = FindToolType((UBYTE **)opts, p->opt);
  296.     debug(("Setting option '%s': (%ld).\n",p->opt,!!q));
  297.     if((q && !p->persistent) || initial){
  298.       if( !(*p->set)(glob, q) ){
  299.     debug(("Error occured seting option '%s'.\n",p->opt));
  300.     goto optionerror;
  301.       }
  302.     }
  303.   }
  304.   /* All options successfull. */
  305.   if(initial) glob->optionsset = TRUE;
  306.   return TRUE;
  307.   
  308.  optionerror:
  309.   /* An error occured during option setting. Cleanup any set options
  310.    * if nessesary and return, reporting failure.
  311.    */
  312.   glob->badoption = p->opt;     /* For error report. */
  313.   if(initial){
  314.     glob->optionsset = FALSE;  /* Just to be safe. */
  315.     for(r=opttable;r<p;r++){
  316.       if(r->cleanup) (*r->cleanup)(glob);
  317.     }
  318.   }
  319.   return FALSE;
  320. }
  321.  
  322.  
  323. /* Set a single option. This is done by faking an option file with a single
  324.  * entry.
  325.  */
  326. BOOL set_option(glb glob, char *p){
  327.    char *array[2];
  328.    
  329.    debug(("set_option() received '%s'.\n",p));
  330.    array[0]=p;
  331.    array[1]=NULL;
  332.    return SetOptions(glob, array, FALSE);
  333. }
  334.  
  335.  
  336. /* Set a single option using an opt/val pair. */
  337. BOOL set_option_value(glb glob, char *opt, char *val){
  338.   char *p;
  339.   BOOL res;
  340.  
  341.   if(!(p=dosalloc(strlen(opt)+strlen("=")+strlen(val)+1))){
  342.     debug(("set_option_value(): no mem.\n"));
  343.     OUTOFMEM;
  344.     return FALSE;
  345.   }
  346.   strcpy(p,opt);
  347.   strcat(p,"=");
  348.   strcat(p,val);
  349.   res = set_option(glob, p);
  350.   dosfree(p);
  351.   return res;
  352. }
  353. static void CleanupAllOptions(glb glob){
  354.    struct opttable *p;
  355.    
  356.    if(glob->optionsset){
  357.       for(p=opttable; p->opt; p++){
  358.          if(p->cleanup) (*p->cleanup)(glob);
  359.       }
  360.       glob->optionsset = FALSE;
  361.    }
  362. }
  363.  
  364. /* Create string array (char**) from buffer (changing "sep" chars to '\0').
  365.  * Also removes whitespace at end of lines.
  366.  * The buffer MUST be (at least) 1 byte longer than 'len'.
  367.  * Returns NULL if not enough memory available.
  368.  */
  369. static char **buf2array(glb glob, char *buf, int len, char sep){
  370.   int i,j;
  371.   int numlines=0;
  372.   char **p,**q;
  373.   
  374.   debug(("String: '%s'.\n",buf));
  375.   for(i=0;i<len;i++) if(buf[i]==sep) numlines++;
  376.   /* The array size is numlines+2: one extra 'safe' line, and a 
  377.    * NULL-terminator. */
  378.   if(!(p=q=dosalloc(sizeof(*p)*(numlines+2)))){
  379.     OUTOFMEM;
  380.     return NULL;
  381.   }
  382.   *q++ = buf;
  383.   for(i=0;i<len;i++){
  384.     if(buf[i]==sep){
  385.       for(j=i-1; (j>=0) && buf[j] && isspace(buf[j]); j--){
  386.     debug(("Skipping '%lc'.\n",buf[j]));
  387.       }
  388.       buf[j+1]='\0';
  389.       *q++=&buf[i+1];
  390.     }
  391.   }
  392.   /* Fix the last line (may not be "sep" terminated). */
  393.   for(j=i-1; (j>=0) && buf[j] && isspace(buf[j]); j--);
  394.   buf[j+1]='\0';
  395.   if(!**(q-1)) *(q-1) = NULL; /* Remove last line if empty. */
  396.   return p;
  397. }
  398.  
  399.  
  400. static void deleteoptionfromarray(glb glob, char **array, char *opt){
  401.   char *p;
  402.   char **q;
  403.  
  404.   p = FindToolType((UBYTE **)array, opt);
  405.   if(!p) return;
  406.   /* Delete the entry corresponding to p. */
  407.   for(q=array; *q; q++){
  408.     if(*q<=p && (!q[1] || q[1] > p)) goto deleteit;
  409.   }
  410.   debug(("Strange: Bugus pointer returned by FindToolType().\n"));
  411.   return;
  412.  deleteit:
  413.   while(q[0] = q[1]) q++;
  414.   return;
  415. }
  416.  
  417.  
  418. static BOOL writearraytofile(glb glob, char **array, struct FileHandle *fh){
  419.   char **p;
  420.  
  421.   for(p=array; *p; p++){
  422.     if(!xWriteStr(glob, fh, *p)) return FALSE;
  423.     if(!xWriteStr(glob, fh, "\n")) return FALSE;
  424.   }
  425.   return TRUE;
  426. }
  427.  
  428.  
  429. /* Attempt to read an option file. If the file could be read, it sets
  430.  * the arg to point to a buffer containing the data. This buffer must
  431.  * be deallocated by the caller (using dosfree()).
  432.  * Returns TRUE if the file was found, FALSE otherwise.
  433.  * NOTE: The arg may be returned NULL even if TRUE is returned.
  434.  * This signifies an 'out of memory' condition.
  435.  */
  436. static BOOL ReadOptFile(glb glob, struct FileLock *parent, char *name,
  437.                         char **buf, LONG *size){
  438.    struct FileHandle *fh;
  439.    
  440.    *buf=NULL;
  441.    if(!(fh = xOpen(glob, parent, name, MODE_OLDFILE))) return FALSE;
  442.    *size = xSeek(glob, fh, 0, OFFSET_END);
  443.    if(*size==-1L){
  444.       xClose(glob, fh);
  445.       return FALSE;
  446.    }
  447.    *size = xSeek(glob, fh, 0, OFFSET_BEGINNING);
  448.    if(*size==-1L){
  449.       xClose(glob, fh);
  450.       return FALSE;
  451.    }
  452.    if(!(*buf = dosalloc(*size+1))){
  453.       OUTOFMEM;
  454.       xClose(glob, fh);
  455.       return TRUE;
  456.    }
  457.    if(*size != xRead(glob, fh, *buf, *size)){
  458.       xClose(glob, fh);
  459.       dosfree(buf);
  460.       *buf = NULL;
  461.       return FALSE;
  462.    }
  463.    xClose(glob, fh);
  464.    return TRUE;
  465. }
  466.  
  467.  
  468. static BOOL writeoption(glb glob, struct FileHandle *fh, char *opt, char *val){
  469.   if(!xWriteStr(glob, fh, opt)) return FALSE;
  470.   if(!xWriteStr(glob, fh, "=")) return FALSE;
  471.   if(!xWriteStr(glob, fh, val)) return FALSE;
  472.   if(!xWriteStr(glob, fh, "\n"))return FALSE;
  473.   return TRUE;
  474. }
  475.  
  476.  
  477. /* Set a single option, but make it permanent (in :.xfhrc).
  478.  *
  479.  * A little magic is neede here since we share the .xfhrc file with
  480.  * the user. So, first read it, find existing entry (if any), then
  481.  * write back the file, changing the entry in the process.
  482.  */
  483. BOOL SetOptionPermanent(glb glob, char *opt, char *val){
  484.   struct FileHandle *fh;
  485.   char *buf;
  486.   LONG len;
  487.   char **array;
  488.   BOOL res;
  489.   
  490.   if(!ReadOptFile(glob, glob->xrootlock, ALTOPTIONPATH, &buf, &len)){
  491.     debug((".xfhrc file nonexisting, creating new.\n"));
  492.     if(!(fh=xOpen(glob, glob->xrootlock, ALTOPTIONPATH, MODE_NEWFILE))){
  493.       debug(("Error: Unable to open file: %ld.\n",glob->ioerr));
  494.       return FALSE;
  495.     }
  496.     if(writeoption(glob, fh, opt, val)){
  497.       if(!xClose(glob, fh)) return FALSE;
  498.       return set_option_value(glob, opt, val);
  499.     }else{
  500.       SAVEIOERR;
  501.       xClose(glob, fh);
  502.       RESTIOERR;
  503.       return FALSE;
  504.     }
  505.   }
  506.   if(!buf) return FALSE;
  507.   /* Ok, there's a file there already. Change it. */
  508.   if(!(array = buf2array(glob, buf, len, EOL))){
  509.     dosfree(buf);
  510.     return FALSE;
  511.   }
  512.   deleteoptionfromarray(glob, array, opt);
  513.   if(!(fh=xOpen(glob, glob->xrootlock, ALTOPTIONPATH, MODE_NEWFILE))){
  514.     debug(("Error: Unable to open file again: %ld.\n",glob->ioerr));
  515.     dosfree(array);
  516.     dosfree(buf);
  517.     return FALSE;
  518.   }
  519.   res = writearraytofile(glob, array, fh);
  520.   dosfree(array);
  521.   dosfree(buf);
  522.   if(!res){
  523.     SAVEIOERR;
  524.     xClose(glob, fh);
  525.     RESTIOERR;
  526.     return FALSE;
  527.   }
  528.   if(!writeoption(glob, fh, opt, val)){
  529.     SAVEIOERR;
  530.     xClose(glob, fh);
  531.     RESTIOERR;
  532.     return FALSE;
  533.   }
  534.   if(!xClose(glob, fh)) return FALSE;
  535.   return set_option_value(glob, opt, val);
  536. }
  537.  
  538.  
  539. /* Called to read additional option files (after setting the initial
  540.  * options).
  541.  */
  542. BOOL SetOptionsFromFile(glb glob, struct FileLock *lock, char *name){
  543.    char *buf;
  544.    LONG len;
  545.    char **array;
  546.    BOOL res;
  547.    
  548.    if(!ReadOptFile(glob, lock, name, &buf, &len)) return TRUE;
  549.    if(!buf) return FALSE;
  550.    if(!(array = buf2array(glob, buf, len, EOL))){
  551.       dosfree(buf);
  552.       return FALSE;
  553.    }
  554.    res = SetOptions(glob, array, FALSE);
  555.    dosfree(array);
  556.    dosfree(buf);
  557.    return res;
  558. }
  559.  
  560.  
  561. /* Set options given in the "Startup" keyword in the mountlist.
  562.  * NOTE: this function will modify "startup".
  563.  * ONLY called by SetOptionsDayOne() !!!
  564.  */
  565. static BOOL SetOptionsFromStartup(glb glob, char *startup){
  566.   char **array;
  567.   char *p;
  568.   BOOL res;
  569.  
  570.   /* Change FAKEDEFCHAR to DEFCHAR (hack to fix bug in mount cmd). */
  571.   for(p=startup;*p;p++){
  572.     if(*p==FAKEDEFCHAR) *p=DEFCHAR;
  573.   }
  574.   if(!(array = buf2array(glob, startup, strlen(startup), STARTUP_SEP))){
  575.     return FALSE;
  576.   }
  577.   res = SetOptions(glob, array, TRUE);
  578.   debug(("SetOptions(): result %ld\n",res));
  579.   dosfree(array);
  580.   return res;
  581. }
  582.  
  583.  
  584. /* Set all options to their default, since there wasn't an option file.
  585.   * ONLY called by SetOptionsDayOne() !!!
  586.  */
  587. static BOOL SetDefaultOptions(glb glob){
  588.    static char *fakeopts[] = {NULL};
  589.    
  590.    /* Just pass SetOptions a fake, empty option file. */
  591.    return SetOptions(glob, fakeopts, TRUE);
  592. }
  593.  
  594.  
  595. /* Set options from primary option file.
  596.  * ONLY called by SetOptionsDayOne() !!!
  597.  */
  598. static BOOL SetOptionsFromPrimary(glb glob, char *filename){
  599.    char *buf;
  600.    LONG len;
  601.    char **array;
  602.    struct MsgPort *procid;
  603.    struct FileLock *lock;
  604.    BPTR bcpllock;
  605.    BOOL res;
  606.  
  607.    /* ToDo: This won't work with multi-assigns. */
  608.    procid = DoDeviceProc( (LONG *)&bcpllock, filename, glob );
  609.    /* ToDo: Nasty case if we get a non-null procid but a null lock.
  610.     * For now this is regarded as an error.
  611.     */
  612.    if( !procid || !bcpllock ){
  613.       return SetDefaultOptions(glob);
  614.    }
  615.    lock = b2c(bcpllock);
  616.  
  617.    if(!ReadOptFile(glob, lock, filename, &buf, &len)){
  618.        return SetDefaultOptions(glob);
  619.    }
  620.    if(!buf) return FALSE;
  621.    if(!(array = buf2array(glob, buf, len, EOL))){
  622.       dosfree(buf);
  623.       return FALSE;
  624.    }
  625.    res = SetOptions(glob, array, TRUE);
  626.    dosfree(array);
  627.    dosfree(buf);
  628.    return res;
  629. }
  630.  
  631.  
  632. /* Called ONCE to set the initial options.
  633.  * These may either come directly in the "Startup" string, or in an
  634.  * option file. */
  635. static BOOL SetOptionsDayOne(glb glob){
  636.    char *startup, *s2;
  637.    BOOL res;
  638.  
  639.    /* Check for missing startup string. */
  640.    if(!glob->bcplstartup) return SetDefaultOptions(glob);
  641.    if(!(startup = copybstr(glob->bcplstartup))){
  642.       debug(("Error: No memory for STARTUP string.\n"));
  643.       OUTOFMEM;
  644.       return FALSE;
  645.    }
  646.    /* Check for an empty startup string (""). */
  647.    if(!strcmp("",startup) || !strcmp("\"\"",startup)){
  648.       res = SetDefaultOptions(glob);
  649.    }else{
  650.       /* Check for a quoted string (ie. "foo" -> foo). */
  651.       if(startup[0]==startup[strlen(startup)-1] && startup[0]==QUOTE_CHAR){
  652.          startup[strlen(startup)-1] = '\0';
  653.          s2 = &startup[1];
  654.       }else{
  655.          s2 = startup;
  656.       }
  657.       debug(("Startup string: '%s'\n",s2));
  658.  
  659.       /* If the first character of the STARTUP string is STARTUP_SEP, the
  660.        * string is taken to be a list of option commands seperated by
  661.        * STARTUP_SEP. Otherwise, it is taken to be the name of an option
  662.        * file (which should have an absolute path).
  663.        */
  664.       if(s2[0]==STARTUP_SEP){
  665.          debug(("Setting options from string.\n"));
  666.          res = SetOptionsFromStartup(glob, &s2[1]);
  667.       }else{
  668.          debug(("Setting options from option file '%s'.\n",s2));
  669.          res = SetOptionsFromPrimary(glob, s2);
  670.       }
  671.    }
  672.    freestr(startup);
  673.    return res;
  674. }
  675.  
  676.  
  677. BOOL InitOptions(glb glob){
  678.  
  679.    glob->optionsset = FALSE;
  680.    
  681.    if(!(glob->IconBase = OpenLibrary("icon.library",0L))){
  682.       debug(("Error: InitOptions: Cannot open icon.library.\n"));
  683.       return FALSE;
  684.    }
  685.    IconBase = glob->IconBase;
  686.    
  687.    SetOptionsDayOne(glob);
  688. }
  689.  
  690. void CleanupOptions(glb glob){
  691.    
  692.    CleanupAllOptions(glob);
  693.    
  694.    if(glob->IconBase){
  695.       CloseLibrary(IconBase);
  696.       glob->IconBase = NULL;
  697.    }
  698. }
  699.  
  700.  
  701. /* End of options.c */
  702.