home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2276 / cannoname.c next >
Encoding:
C/C++ Source or Header  |  1990-12-28  |  3.9 KB  |  167 lines
  1. /* This file contains routines which put a file name into cannonical
  2.  * form.
  3.  */
  4.  
  5. #define NULL 0
  6.  
  7. /* define special name components */
  8.  
  9. static char slash[]  = "/" ;
  10. static char dot[]    = "." ;
  11. static char dotdot[] = ".." ;
  12.  
  13. /* nextc points to the next character to look at in the string or is
  14.  * null if the end of string was reached.
  15.  *
  16.  * namep points to buffer that holds the components.
  17.  */
  18. static char * nextc = NULL ;
  19. static char * namep ;
  20.  
  21. /* lexname - Return next name component. Uses global variables initialized
  22.  * by cannoname to figure out what it is scanning.
  23.  */
  24. static char *
  25. lexname()
  26. {
  27.    char   c ;
  28.    char * d ;
  29.  
  30.    if (nextc) {
  31.       c = *nextc++ ;
  32.       if (c == '\0') {
  33.          nextc = NULL ;
  34.          return(NULL) ;
  35.       }
  36.       if (c == '/') {
  37.          return(&slash[0]) ;
  38.       }
  39.       if (c == '.') {
  40.          if ((*nextc == '/') || (*nextc == '\0')) return(&dot[0]) ;
  41.          if (*nextc == '.' && (*(nextc+1) == '/' || *(nextc+1) == '\0')) {
  42.             ++nextc ;
  43.             return(&dotdot[0]) ;
  44.          }
  45.       }
  46.       d = namep;
  47.       *namep++ = c;
  48.       while ((c = *nextc) != '/') {
  49.          *namep++ = c ;
  50.          if (c == '\0') {
  51.             nextc = NULL ;
  52.             return(d) ;
  53.          }
  54.          ++nextc;
  55.       }
  56.       *namep++ = '\0' ;
  57.       return(d) ;
  58.    } else {
  59.       return(NULL) ;
  60.    }
  61. }
  62.  
  63. /* cannoname - Put a file name in cannonical form. Looks for all the
  64.  * whacky wonderful things a demented *ni* programmer might put
  65.  * in a file name and reduces the name to cannonical form.
  66.  */
  67. void
  68. cannoname(n)
  69.    char * n;
  70. {
  71.    char *  components[1024] ;
  72.    char ** cap = &components[0] ;
  73.    char ** cad ;
  74.    char *  cp ;
  75.    char    namebuf[2048] ;
  76.    char *  s ;
  77.  
  78.    /* initialize scanner */
  79.    nextc = n ;
  80.    namep = &namebuf[0] ;
  81.  
  82.    /* break the file name into individual components */
  83.    while ((cp = lexname()) != NULL) {
  84.       *cap++ = cp ;
  85.    }
  86.  
  87.    /* If name is empty, leave it that way */
  88.    if (cap == &components[0]) return ;
  89.  
  90.    /* flag end of component list */
  91.    *cap = NULL ;
  92.  
  93.    /* remove all trailing slashes and dots */
  94.    while ((--cap != &components[0]) &&
  95.           ((*cap == &slash[0]) || (*cap == &dot[0]))) *cap = NULL ;
  96.  
  97.    /* squeeze out all . / component sequences */
  98.    cap = &components[0] ;
  99.    cad = cap ;
  100.    while (*cap != NULL) {
  101.       if ((*cap == &dot[0]) && (*(cap+1) == &slash[0])) {
  102.          cap += 2;
  103.       } else {
  104.          *cad++ = *cap++ ;
  105.       }
  106.    }
  107.    *cad++ = NULL ;
  108.  
  109.    /* find multiple // and use last slash as root */
  110.    s = NULL ;
  111.    cap = &components[0] ;
  112.    cad = cap ;
  113.    while (*cap != NULL) {
  114.       if ((s == &slash[0]) && (*cap == &slash[0])) {
  115.          cad = &components[0];
  116.       }
  117.       s = *cap++;
  118.       *cad++ = s;
  119.    }
  120.    *cad = NULL ;
  121.  
  122.    /* if this is absolute name get rid of any /.. at beginning */
  123.    if ((components[0] == &slash[0]) && (components[1] == &dotdot[0])) {
  124.       cap = &components[1] ;
  125.       cad = cap ;
  126.       while (*cap == &dotdot[0]) {
  127.          ++cap;
  128.          if (*cap == NULL) break ;
  129.          if (*cap == &slash[0]) ++cap ;
  130.       }
  131.       while (*cap != NULL) {
  132.          *cad++ = *cap++ ;
  133.       }
  134.       *cad = NULL ;
  135.    }
  136.  
  137.    /* squeeze out any name/.. sequences (but leave leading ../..) */
  138.    cap = &components[0] ;
  139.    cad = cap ;
  140.    while (*cap != NULL) {
  141.       if ((*cap == &dotdot[0]) &&
  142.           ((cad-2) >= &components[0]) &&
  143.           ((*(cad-2)) != &dotdot[0])) {
  144.          cad -= 2 ;
  145.          ++cap;
  146.          if (*cap != NULL) ++cap;
  147.       } else {
  148.          *cad++ = *cap++ ;
  149.       }
  150.    }
  151.    /* squeezing out a trailing /.. can leave unsightly trailing /s */
  152.    if ((cad >= &components[2]) && ((*(cad-1)) == &slash[0])) --cad ;
  153.    *cad = NULL ;
  154.    /* if it was just name/.. it now becomes . */
  155.    if (components[0] == NULL) {
  156.       components[0] = &dot[0] ;
  157.       components[1] = NULL ;
  158.    }
  159.  
  160.    /* re-assemble components */
  161.    cap = &components[0] ;
  162.    while ((s = *cap++) != NULL) {
  163.       while (*s != NULL) *n++ = *s++;
  164.    }
  165.    *n++ = '\0' ;
  166. }
  167.