home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / program / lynxlib / pathname.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-23  |  9.8 KB  |  358 lines
  1. /* This source file is part of the LynxLib miscellaneous library by
  2. Robert Fischer, and is Copyright 1990 by Robert Fischer.  It costs no
  3. money, and you may not make money off of it, but you may redistribute
  4. it.  It comes with ABSOLUTELY NO WARRANTY.  See the file LYNXLIB.DOC
  5. for more details.
  6. To contact the author:
  7.     Robert Fischer \\80 Killdeer Rd \\Hamden, CT   06517   USA
  8.     (203) 288-9599     fischer-robert@cs.yale.edu                 */
  9.  
  10. #include <e_osbind.h>
  11. #include <ctype.h>
  12. #include <nstring.h>
  13.  
  14. add_slash(name)
  15. char *name;
  16. {
  17. register int i;
  18.     i = strlen(name) - 1;
  19.     if (name[i] != '\\') {
  20.         name[i+1] = '\\';
  21.         name[i+2] = '\0';
  22.     }
  23. }
  24. /* ---------------------------------------------------------------- */
  25. trim_slash(name)
  26. char *name;
  27. {
  28. register int i;
  29.     i = strlen(name) - 1;
  30.     if (name[i] == '\\')
  31.         name[i] = '\0';
  32. }
  33. /* ---------------------------------------------------------------- */
  34. ppath(path, drvltr, dir, leaf)
  35. /* Parses a path name and returns its component parts    */
  36. char *path;        /* Input path name                        */
  37. char *drvltr;    /* Output: drive letter of path            */
  38.                 /* 0 = default, 'A' = drive A, ...        */
  39. char *dir;        /* Directory part of name:                */
  40.     /* '.\'        - default directory                        */
  41.     /* '\'        - root directory                        */
  42.     /* '.\xxx\'    - subfolder of default dir                */
  43.     /* '\xxx\'    - subfolder of root                        */
  44. char *leaf;        /* Leaf name or wildcard pattern        */
  45. {
  46. char s[80];
  47. int i;
  48.     *drvltr = _toupper(path[0]);
  49.  
  50.     /* Get drive specifier */
  51.     if (strlen(path) >= 2 && path[1] == ':' &&
  52.         'A' <= *drvltr && *drvltr <= 'P') {
  53.         strcpy(s, path + 2);
  54.     } else {
  55.         *drvltr = 0;
  56.         strcpy(s, path);
  57.     }
  58.  
  59.     /* Split directory name into two parts */
  60.     i = strlen(s);
  61.     while (i > -1 && s[i] != '\\') i--;
  62.     if (i == -1) {        /* No backslashes in pathname */
  63.         strcpy(dir, ".\\");
  64.         strcpy(leaf, s);
  65.     } else {        /* Name contains a '\\' */
  66.         if (s[0] != '\\') {
  67.             dir[0] = '.'; dir[1] = '\\';
  68.             s[i] = NIL;
  69.             strcpy(dir + 2, s);
  70.         } else {
  71.             s[i] = NIL;
  72.             strcpy(dir, s);
  73.         }
  74.         strcpy(leaf, s + i+1);
  75.     }
  76.  
  77.     /* Add a trailing slash */
  78.     add_slash(dir);
  79. }
  80. /* ---------------------------------------------------------------- */
  81. resolve_pname(ipath, dflt)
  82. /* Converts path to fully specified form, supplying current default        */
  83. /*       drive and directory.                                                */
  84. /* Eliminates all occurrences of '.' and '..'                            */
  85. /* BUGS: The default directory given in dflt is used as the default
  86.          for ALL drives.  For example, if ipath=c:x and dflt=e:\r\,
  87.          then ipath is resolved to c:\r\x                                */
  88. char *ipath;    /* Path name to be resolved.  Output returned here, too */
  89. char *dflt;        /* Default pathname to use for ambiguous things. */
  90.     /* If defalt is '', use GEMDOS's defaults */
  91. {
  92. char drvltr;        /* Drive letter */
  93. fle_name dir;        /* Directory path */
  94. leaf_name leaf;        /* Leaf part of ipath */
  95. int i,j;
  96. fle_name ddir;        /* Path of default */
  97. leaf_name dleaf;
  98. char ddrv;            /* Drive letter of default */
  99. fle_name s;
  100.     ppath(ipath, &drvltr, dir, leaf);
  101.  
  102.     /* Get the defaults correct */
  103.     if (dflt[0] == NIL) {
  104.         ddrv = 'A' + Dgetdrv();
  105.         if (drvltr == 0) Dgetpath(ddir, 0);
  106.         else Dgetpath(ddir, drvltr - 'A' + 1);
  107.         add_slash(ddir);
  108.     } else {
  109.         resolve_pname(dflt, "");
  110.         ppath(dflt, &ddrv, ddir, dleaf);
  111.         strcat(ddir, dleaf);
  112.         add_slash(ddir);
  113.     }
  114.  
  115.     /* Resolve drive */
  116.     if (drvltr == 0) drvltr = ddrv;
  117.  
  118.     /* Resolve path */
  119.     if (dir[0] == '.') {
  120.         strcpy(s, dir);            /* dir := concat(ddir, dir); */
  121.         pstrcpy(pstrcpy(dir, ddir), s);
  122.     }
  123.  
  124.     /* Combine names */
  125.     ipath[0] = drvltr;
  126.     ipath[1] = ':';
  127.     pstrcpy(pstrcpy(ipath + 2, dir), leaf);
  128.  
  129.     /* Remove '.' and '..' from ipath */
  130.     for (i = j = 0; ipath[i] != NIL; ) {
  131.         if (ipath[i] == '\\' && ipath[i+1] == '.' && ipath[i+2] == '\\') {
  132.             i += 2;
  133.         } else ipath[j++] = ipath[i++];
  134.     }
  135.     ipath[j] = NIL;
  136.  
  137.     for (i = 0; i < 3; i++) if (ipath[i] == NIL) goto skip;        /* No possibility for '..' in name */
  138.     for (j = 3; ipath[i] != NIL; ) {
  139.         if (ipath[i] == '\\' && ipath[i+1] == '.' &&
  140.             ipath[i+2] == '.' && ipath[i+3] == '\\') {
  141.             i += 3;
  142.             if (j > 2) for (j--; ipath[j] != '\\'; j--) ;    /* Scan to last '\' */
  143.         } else ipath[j++] = ipath[i++];
  144.     }
  145.     ipath[j] = NIL;
  146. skip:
  147.  
  148.     /* Force result to upper case */
  149.     pstrupper(ipath);
  150. }
  151. /* ---------------------------------------------------------------- */
  152. resolve_dname(idir, dflt)
  153. /* Resolves a directory name */
  154. char *idir;
  155. char *dflt;
  156. {
  157. char *c;
  158.     if (idir[0] != NIL) add_slash(idir);
  159.     strcat(idir, "x");    /* Make a dummy file name */
  160.     resolve_pname(idir, dflt);
  161.     c = pstrlen(idir);
  162.     *(c-1) = NIL;    /* Remove dummy file name */
  163. }
  164. /* ---------------------------------------------------------------- */
  165. get_curdir(pname)   /* gets the current directory */
  166. char *pname;
  167. {
  168.     Dgetpath(&pname[2], 0);
  169.     pname[0] = Dgetdrv() + 'A';
  170.     pname[1] = ':';
  171.     add_slash(pname);
  172. }
  173. /* ---------------------------------------------------------------- */
  174. trim_leaf(pname)    /* Removes the leaf from a name */
  175. /* E:\C turnes to E:\, E:\C\ turns to E:\C\ */
  176. register char *pname;
  177. {
  178. register int i;
  179.     for (i = strlen(pname); pname[i] != '\\' && i > 0; i--) ;
  180.     if (i != 0) pname[i+1] = '\0';
  181. }
  182. /* ---------------------------------------------------------------- */
  183. BOOLEAN g_file_attrib(name, modebits, td, size)
  184. /* Gets the file attributes according to directory */
  185. char *name;         /* name of file */
  186. WORD *modebits;     /* File's modebits */
  187. GEMDOS_TD_REC *td;  /* Files date and time */
  188. long *size;         /* Filesize */
  189. {
  190. TRANS_BUF trans, *old_trans;
  191. int err;
  192.     old_trans = Fgetdta();  /* Save old DTA, set new one */
  193.     Fsetdta(&trans);
  194.     err = Fsfirst(name, READ_ONLY | CLOSED);
  195.     Fsetdta(old_trans);
  196.     if (err != E_OK) return FALSE;
  197.  
  198.     /* Take out the information */
  199.     td->td.date = trans.date;
  200.     td->td.time = trans.time;
  201.     *modebits = trans.attrib & 0xFF;
  202.     *size = trans.size;
  203.     return TRUE;
  204. }
  205. /* ---------------------------------------------------------------- */
  206. BOOLEAN s_file_attrib(name, modebits, td)
  207. char *name;
  208. WORD modebits;
  209. GEMDOS_TD_REC td;
  210. {
  211. GFILE f;
  212.     /* Set the date and time, opening the file */
  213.     f = Fopen(name, G_RW);
  214.     if (f <= 0) return FALSE;
  215.     Fdatime(&td, f, SET_FDTM);
  216.     if (Fclose(f) != E_OK) return FALSE;
  217.  
  218.     /* Set the attributes, only requiring the name */
  219.     Fattrib(name, SET_ATTRIB, modebits);
  220.  
  221.     return TRUE;
  222. }
  223. /* ---------------------------------------------------------------- */
  224. BOOLEAN cd(d, odrive, opath)
  225. /* Changes current directory to dir.  Returns the previous default
  226. drive in odrive and the previous default path on the drive specified
  227. in d in opath.  Returns TRUE on success */
  228. char *d;
  229. int *odrive;
  230. char *opath;
  231. {
  232. int i;
  233.     *odrive = Dgetdrv();
  234.     Dgetpath(opath, 0);
  235.  
  236.     /* Look for drive letter */
  237.     if (d[0] != NIL && d[1] == ':') {  /* We've found a drive letter! */
  238.         i = _toupper(d[0]) - 'A';
  239.  
  240.         /* If the drive set doesn't really exist */
  241.         if (i > 15 || (Drvmap() & (1 << i)) == 0) return FALSE;
  242.         Dsetdrv(i);
  243.         Dgetpath(opath, 0);
  244.  
  245.         d += 2;
  246.     }
  247.  
  248.     /* Now, test the non-drive part */
  249.     return (Dsetpath(d) == E_OK);
  250. }
  251. /* ---------------------------------------------------------------- */
  252. BOOLEAN existd(d)       /* Sees if a directory exists */
  253. char *d;
  254. {
  255. fle_name defpath;   /* Saved default path */
  256. int defdrive;       /* Saved default drive */
  257. BOOLEAN ret;
  258.  
  259.     ret = cd(d, &defdrive, defpath);
  260.  
  261.     /* Restore defaults */
  262.     if (defpath[0] == NIL) add_slash(defpath);
  263.     Dsetpath(defpath);
  264.     Dsetdrv(defdrive);
  265.  
  266.     return ret;
  267. }
  268. /* ---------------------------------------------------------------- */
  269. BOOLEAN create_dir(d)   /* Creates a directory if it doesn't already exist */
  270. /* d may be a file-name.  Then the dir. of that name will be created */
  271. char *d;
  272. {
  273. int i;
  274.     for (i = 0; d[i] != NIL; i++) {
  275.         if (d[i] == '\\') {
  276.             d[i] = NIL;
  277.             if (existf(d)) return FALSE;
  278.             if (!existd(d)) Dcreate(d);
  279.             d[i] = '\\';
  280.         }
  281.     }
  282.     if (existf(d)) return FALSE;
  283.     if (!existd(d)) Dcreate(d);
  284.     return TRUE;
  285. }
  286. /*---------------------------------------------------------------- */
  287. pleaf(leaf, root, ext)
  288. /* Parses a leaf into a root and extender */
  289. char *leaf, *root, *ext;
  290. {
  291. char *c;
  292.     c = rindex(leaf, '.');
  293.     if (c == NULL) {
  294.         ext[0] = NIL;
  295.         strcpy(root, leaf);
  296.     } else {
  297.         *c = NIL;
  298.         strcpy(root, leaf);
  299.         strcpy(ext, c+1);
  300.         *c = '.';
  301.     }
  302. }
  303. /*---------------------------------------------------------------- */
  304. remove_leaf(s, leaf)
  305. /* Removes the leafname off of s, and puts it into leaf */
  306. /* If there's no backslash, it's assumed to be an entire leafname */
  307. char *s;
  308. char *leaf;
  309. {
  310. char *c;
  311.     c = rindex(s, '\\');
  312.     if (c == NULL) {
  313.         strcpy(leaf, s);
  314.         strcpy(s, ".\\");            /* The entire thing is a leaf */
  315.     } else {
  316.         strcpy(leaf, c+1);
  317.         *(c+1) = NIL;
  318.     }
  319. }
  320. /*---------------------------------------------------------------- */
  321. force_ext(s, ext)
  322. /* Forces the extender on a name to be ext (ext contains no dot) */
  323. /* Appends the extender ext if there is none. */
  324. char *s;
  325. char *ext;
  326. {
  327. char *c, *end;
  328.     c = end = pstrlen(s);
  329.     while (TRUE) {
  330.         if (*c == '\\' || c == s) { /* No extender */
  331.             *(end++) = '.';
  332.             strcpy(end, ext);
  333.             break;
  334.         }
  335.         if (*c == '.') {    /* Extender to replace */
  336.             strcpy(c+1, ext);
  337.             break;
  338.         }
  339.         c--;
  340.     }
  341. }
  342. /* --------------------------------------------------------------- */
  343. /*---------------------------------------------------------------- */
  344. #if 0
  345. main()
  346. {
  347. char s[80], d[80];
  348.     while (TRUE) {
  349.         printf("Enter your pathname: ");
  350.         gets(s);
  351.         printf("Enter your default: ");
  352.         gets(d);
  353.         resolve_pname(s, d);
  354.         printf("Resolved name is: %s\n", s);
  355.     }
  356. }
  357. #endif
  358.