Rename node field flags to attrib.

[android-x86/external-exfat.git] / libexfat / node.c

diff --git a/libexfat/node.c b/libexfat/node.c
index 5b623be..d64ae29 100644 (file)
--- a/libexfat/node.c
+++ b/libexfat/node.c
@@ -53,7 +53,7 @@ void exfat_put_node(struct exfat* ef, struct exfat_node* node)
        }
        else if (node->references == 0 && node != ef->root)
        {
-               if (node->flags & EXFAT_ATTRIB_DIRTY)
+               if (node->is_dirty)
                {
                        exfat_get_name(node, buffer);
                        exfat_warn("dirty node '%s' with zero references", buffer);
@@ -73,7 +73,7 @@ int exfat_cleanup_node(struct exfat* ef, struct exfat_node* node)
                exfat_bug("unable to cleanup a node with %d references",
                                node->references);
 
-       if (node->flags & EXFAT_ATTRIB_UNLINKED)
+       if (node->is_unlinked)
        {
                /* free all clusters and node structure itself */
                rc = exfat_truncate(ef, node, 0, true);
@@ -96,7 +96,7 @@ static int opendir(struct exfat* ef, const struct exfat_node* dir,
 {
        char buffer[EXFAT_UTF8_NAME_BUFFER_MAX];
 
-       if (!(dir->flags & EXFAT_ATTRIB_DIR))
+       if (!(dir->attrib & EXFAT_ATTRIB_DIR))
        {
                exfat_get_name(dir, buffer);
                exfat_bug("'%s' is not a directory", buffer);
@@ -181,7 +181,7 @@ static struct exfat_node* allocate_node(void)
 static void init_node_meta1(struct exfat_node* node,
                const struct exfat_entry_meta1* meta1)
 {
-       node->flags = le16_to_cpu(meta1->attrib);
+       node->attrib = le16_to_cpu(meta1->attrib);
        node->mtime = exfat_exfat2unix(meta1->mdate, meta1->mtime,
                        meta1->mtime_cs);
        /* there is no centiseconds field for atime */
@@ -194,8 +194,7 @@ static void init_node_meta2(struct exfat_node* node,
        node->size = le64_to_cpu(meta2->size);
        node->start_cluster = le32_to_cpu(meta2->start_cluster);
        node->fptr_cluster = node->start_cluster;
-       if (meta2->flags & EXFAT_FLAG_CONTIGUOUS)
-               node->flags |= EXFAT_ATTRIB_CONTIGUOUS;
+       node->is_contiguous = ((meta2->flags & EXFAT_FLAG_CONTIGUOUS) != 0);
 }
 
 static const struct exfat_entry* get_entry_ptr(const struct exfat* ef,
@@ -259,16 +258,16 @@ static bool check_node(const struct exfat_node* node, uint16_t actual_checksum,
        }
 
        /* Empty file or directory must be marked as non-contiguous. */
-       if (node->size == 0 && (node->flags & EXFAT_ATTRIB_CONTIGUOUS))
+       if (node->size == 0 && node->is_contiguous)
        {
                exfat_get_name(node, buffer);
-               exfat_error("'%s' is empty but marked as contiguous (%#x)", buffer,
-                               node->flags);
+               exfat_error("'%s' is empty but marked as contiguous (%#hx)", buffer,
+                               node->attrib);
                ret = false;
        }
 
        /* Directory size must be aligned on at cluster boundary. */
-       if ((node->flags & EXFAT_ATTRIB_DIR) && node->size % cluster_size != 0)
+       if ((node->attrib & EXFAT_ATTRIB_DIR) && node->size % cluster_size != 0)
        {
                exfat_get_name(node, buffer);
                exfat_error("'%s' directory size %"PRIu64" is not divisible by %d", buffer,
@@ -564,7 +563,7 @@ int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir)
        struct exfat_node* node;
        struct exfat_node* current = NULL;
 
-       if (dir->flags & EXFAT_ATTRIB_CACHED)
+       if (dir->is_cached)
                return 0; /* already cached */
 
        rc = opendir(ef, dir, &it);
@@ -597,7 +596,7 @@ int exfat_cache_directory(struct exfat* ef, struct exfat_node* dir)
                return rc;
        }
 
-       dir->flags |= EXFAT_ATTRIB_CACHED;
+       dir->is_cached = true;
        return 0;
 }
 
@@ -636,14 +635,14 @@ static void reset_cache(struct exfat* ef, struct exfat_node* node)
                tree_detach(p);
                free(p);
        }
-       node->flags &= ~EXFAT_ATTRIB_CACHED;
+       node->is_cached = false;
        if (node->references != 0)
        {
                exfat_get_name(node, buffer);
                exfat_warn("non-zero reference counter (%d) for '%s'",
                                node->references, buffer);
        }
-       if (node != ef->root && (node->flags & EXFAT_ATTRIB_DIRTY))
+       if (node != ef->root && node->is_dirty)
        {
                exfat_get_name(node, buffer);
                exfat_bug("node '%s' is dirty", buffer);
@@ -682,7 +681,7 @@ int exfat_flush_node(struct exfat* ef, struct exfat_node* node)
        struct exfat_entry_meta1 meta1;
        struct exfat_entry_meta2 meta2;
 
-       if (!(node->flags & EXFAT_ATTRIB_DIRTY))
+       if (!node->is_dirty)
                return 0; /* no need to flush */
 
        if (ef->ro)
@@ -705,7 +704,7 @@ int exfat_flush_node(struct exfat* ef, struct exfat_node* node)
        }
        if (meta1.type != EXFAT_ENTRY_FILE)
                exfat_bug("invalid type of meta1: 0x%hhx", meta1.type);
-       meta1.attrib = cpu_to_le16(node->flags);
+       meta1.attrib = cpu_to_le16(node->attrib);
        exfat_unix2exfat(node->mtime, &meta1.mdate, &meta1.mtime, &meta1.mtime_cs);
        exfat_unix2exfat(node->atime, &meta1.adate, &meta1.atime, NULL);
 
@@ -720,7 +719,7 @@ int exfat_flush_node(struct exfat* ef, struct exfat_node* node)
        meta2.start_cluster = cpu_to_le32(node->start_cluster);
        meta2.flags = EXFAT_FLAG_ALWAYS1;
        /* empty files must not be marked as contiguous */
-       if (node->size != 0 && IS_CONTIGUOUS(*node))
+       if (node->size != 0 && node->is_contiguous)
                meta2.flags |= EXFAT_FLAG_CONTIGUOUS;
        /* name hash remains unchanged, no need to recalculate it */
 
@@ -737,7 +736,7 @@ int exfat_flush_node(struct exfat* ef, struct exfat_node* node)
                return -EIO;
        }
 
-       node->flags &= ~EXFAT_ATTRIB_DIRTY;
+       node->is_dirty = false;
        return exfat_flush(ef);
 }
 
@@ -787,9 +786,9 @@ static int shrink_directory(struct exfat* ef, struct exfat_node* dir,
        uint64_t entries = 0;
        uint64_t new_size;
 
-       if (!(dir->flags & EXFAT_ATTRIB_DIR))
+       if (!(dir->attrib & EXFAT_ATTRIB_DIR))
                exfat_bug("attempted to shrink a file");
-       if (!(dir->flags & EXFAT_ATTRIB_CACHED))
+       if (!dir->is_cached)
                exfat_bug("attempted to shrink uncached directory");
 
        for (last_node = node = dir->child; node; node = node->next)
@@ -839,7 +838,7 @@ static int delete(struct exfat* ef, struct exfat_node* node)
        exfat_update_mtime(parent);
        tree_detach(node);
        rc = shrink_directory(ef, parent, deleted_offset);
-       node->flags |= EXFAT_ATTRIB_UNLINKED;
+       node->is_unlinked = true;
        if (rc != 0)
        {
                exfat_flush_node(ef, parent);
@@ -853,7 +852,7 @@ static int delete(struct exfat* ef, struct exfat_node* node)
 
 int exfat_unlink(struct exfat* ef, struct exfat_node* node)
 {
-       if (node->flags & EXFAT_ATTRIB_DIR)
+       if (node->attrib & EXFAT_ATTRIB_DIR)
                return -EISDIR;
        return delete(ef, node);
 }
@@ -862,7 +861,7 @@ int exfat_rmdir(struct exfat* ef, struct exfat_node* node)
 {
        int rc;
 
-       if (!(node->flags & EXFAT_ATTRIB_DIR))
+       if (!(node->attrib & EXFAT_ATTRIB_DIR))
                return -ENOTDIR;
        /* check that directory is empty */
        rc = exfat_cache_directory(ef, node);
@@ -1167,7 +1166,7 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path)
        }
 
        /* check that target is not a subdirectory of the source */
-       if (node->flags & EXFAT_ATTRIB_DIR)
+       if (node->attrib & EXFAT_ATTRIB_DIR)
        {
                struct exfat_node* p;
 
@@ -1187,16 +1186,16 @@ int exfat_rename(struct exfat* ef, const char* old_path, const char* new_path)
                /* remove target if it's not the same node as source */
                if (existing != node)
                {
-                       if (existing->flags & EXFAT_ATTRIB_DIR)
+                       if (existing->attrib & EXFAT_ATTRIB_DIR)
                        {
-                               if (node->flags & EXFAT_ATTRIB_DIR)
+                               if (node->attrib & EXFAT_ATTRIB_DIR)
                                        rc = exfat_rmdir(ef, existing);
                                else
                                        rc = -ENOTDIR;
                        }
                        else
                        {
-                               if (!(node->flags & EXFAT_ATTRIB_DIR))
+                               if (!(node->attrib & EXFAT_ATTRIB_DIR))
                                        rc = exfat_unlink(ef, existing);
                                else
                                        rc = -EISDIR;
@@ -1241,19 +1240,19 @@ void exfat_utimes(struct exfat_node* node, const struct timespec tv[2])
 {
        node->atime = tv[0].tv_sec;
        node->mtime = tv[1].tv_sec;
-       node->flags |= EXFAT_ATTRIB_DIRTY;
+       node->is_dirty = true;
 }
 
 void exfat_update_atime(struct exfat_node* node)
 {
        node->atime = time(NULL);
-       node->flags |= EXFAT_ATTRIB_DIRTY;
+       node->is_dirty = true;
 }
 
 void exfat_update_mtime(struct exfat_node* node)
 {
        node->mtime = time(NULL);
-       node->flags |= EXFAT_ATTRIB_DIRTY;
+       node->is_dirty = true;
 }
 
 const char* exfat_get_label(struct exfat* ef)