WebSVN – SvarDOS – Diff – //tree/trunk/tree.c

   /* Use FindFirstFileEx when available (falls back to FindFirstFile).
    * Allows us to limit returned results to just directories
    * if supported by underlying filesystem.
    */
   hnd = FindFirstFile(buffer, &findData);
-  if (hnd == INVALID_HANDLE_VALUE) {
+  if (hnd == NULL) {
     showInvalidPath(path); /* Display error message */
-    return -1L;
+    return(-1);
+  }
   /*  cycle through entries counting directories found until no more entries */
   do {
     if (((findData.attrib & FILE_A_DIR) != 0) &&
         ((findData.attrib &
          (FILE_A_HIDDEN | FILE_A_SYSTEM)) == 0 || dspAll) ) {
     free (temp->currentpath);
     free (temp->dsubdir);
     free(temp);
     return NULL;
+  }
-  temp->findnexthnd = INVALID_HANDLE_VALUE;
+  temp->findnexthnd = NULL;
   return temp;
+}
 /**
  * Extends the padding with the necessary 4 characters.
  * Returns the pointer to the padding.
  * padding should be large enough to hold the additional
  * characters and '\0', moreSubdirsFollow specifies if
   /* get handle for files in current directory (using wildcard spec) */
   strcpy(buffer, path);
   strcat(buffer, "*");
   dir = FindFirstFile(buffer, &entry);
-  if (dir == INVALID_HANDLE_VALUE)
+  if (dir == NULL) return(-1);
-    return -1;
   addPadding(padding, hasMoreSubdirs);
   /* cycle through directory printing out files. */
   do
  * Common portion of findFirstSubdir and findNextSubdir
  * Checks current FindFile results to determine if a valid directory
  * was found, and if so copies appropriate data into subdir and dsubdir.
  * It will repeat until a valid subdirectory is found or no more
  * are found, at which point it closes the FindFile search handle and
- * return INVALID_HANDLE_VALUE.  If successful, returns FindFile handle.
+ * return NULL.  If successful, returns FindFile handle.
  */
 static struct FFDTA *cycleFindResults(struct FFDTA *findnexthnd, struct WIN32_FIND_DATA *entry, char *subdir, char *dsubdir) {
   /* cycle through directory until 1st non . or .. directory is found. */
   do
+  {
     /* skip files & hidden or system directories */
     if ((((entry->attrib & FILE_A_DIR) == 0) ||
          ((entry->attrib &
           (FILE_A_HIDDEN | FILE_A_SYSTEM)) != 0  && !dspAll) ) ||
         (entry->cFileName[0] == '.')) {
-      if (FindNextFile(findnexthnd, entry) == 0)
+      if (FindNextFile(findnexthnd, entry) == 0) {
-      {
         FindClose(findnexthnd);      // prevent resource leaks
-        return INVALID_HANDLE_VALUE; // no subdirs found
+        return(NULL); // no subdirs found
+      }
-    }
-    else
+    } else {
-    {
       /* set display name */
       strcpy(dsubdir, entry->cFileName);
       strcpy(subdir, entry->cFileName);
       strcat(subdir, "\\");
  * The subdirectory found is stored in subdir.
  * subdir is cleared on error or no subdirectories.
  * Returns the findfirst search HANDLE, which should be passed to
  * findclose when directory has finished processing, and can be
  * passed to findnextsubdir to find subsequent subdirectories.
- * Returns INVALID_HANDLE_VALUE on error.
+ * Returns NULL on error.
  * currentpath must end in \
  */
 static struct FFDTA *findFirstSubdir(char *currentpath, char *subdir, char *dsubdir) {
   static char buffer[MAXBUF];
   struct FFDTA *dir;         /* Current directory entry working with      */
   /* get handle for files in current directory (using wildcard spec) */
   strcpy(buffer, currentpath);
   strcat(buffer, "*");
   dir = FindFirstFile(buffer, &findSubdir_entry);
-  if (dir == INVALID_HANDLE_VALUE) {
+  if (dir == NULL) {
     showInvalidPath(currentpath);
-    return INVALID_HANDLE_VALUE;
+    return(NULL);
+  }
   /* clear result path */
   strcpy(subdir, "");
   /* clear result path */
   strcpy(subdir, "");
   if (FindNextFile(findnexthnd, &findSubdir_entry) == 0) return 1; // no subdirs found
-  if (cycleFindResults(findnexthnd, &findSubdir_entry, subdir, dsubdir) == INVALID_HANDLE_VALUE)
+  if (cycleFindResults(findnexthnd, &findSubdir_entry, subdir, dsubdir) == NULL) {
     return 1;
-  else
+  }
-    return 0;
+  return 0;
+}
 /**
  * Given an initial path, displays the directory tree with
  * a non-recursive function using a Stack.
   STACK s;
   stackDefaults(&s);
   stackInit(&s);
-  if ( (sdi = newSubdirInfo(NULL, initialpath, initialpath)) == NULL)
+  if ( (sdi = newSubdirInfo(NULL, initialpath, initialpath)) == NULL) {
-    return 0L;
+    return(0);
+  }
   stackPushItem(&s, sdi);
   /* Store count of subdirs in initial path so can display message if none. */
   subdirsInInitialpath = sdi->subdircnt;
   do
+  {
     sdi = (SUBDIRINFO *)stackPopItem(&s);
-    if (sdi->findnexthnd == INVALID_HANDLE_VALUE)  // findfirst not called yet
+    if (sdi->findnexthnd == NULL) { // findfirst not called yet
-    {
       // 1st time this subdirectory processed, so display its name & possibly files
       if (sdi->parent == NULL) // if initial path
+      {
         // display initial path
         showCurrentPath(/*sdi->dsubdir*/initialpath, NULL, -1, &(sdi->ddata));
+    }
     if (sdi->subdircnt > 0) /* if (there are more subdirectories to process) */
+    {
       int flgErr;
-      if (sdi->findnexthnd == INVALID_HANDLE_VALUE)
+      if (sdi->findnexthnd == NULL) {
-      {
         sdi->findnexthnd = findFirstSubdir(sdi->currentpath, subdir, dsubdir);
-        flgErr = (sdi->findnexthnd == INVALID_HANDLE_VALUE);
+        flgErr = (sdi->findnexthnd == NULL);
-      }
-      else
+      } else {
-      {
         flgErr = findNextSubdir(sdi->findnexthnd, subdir, dsubdir);
+      }
       if (flgErr) // don't add invalid paths to stack
+      {

Subversion Repositories SvarDOS

(root)//tree/trunk/tree.c – Rev 2047 → 2048