libfdisk: rename fdisk_dump_ to fdisk_script_

Signed-off-by: Karel Zak <kzak@redhat.com>

diff --git a/libfdisk/src/Makemodule.am b/libfdisk/src/Makemodule.am
index 2077e36714ce74fb4483357bb704b6ccc0a4e08d..e33962bf702211f11be2f9a87a837cd9921e68be 100644 (file)
--- a/libfdisk/src/Makemodule.am
+++ b/libfdisk/src/Makemodule.am
@@ -20,7 +20,7 @@ libfdisk_la_SOURCES = \
        libfdisk/src/partition.c \
        libfdisk/src/table.c \
        libfdisk/src/iter.c \
-       libfdisk/src/dump.c \
+       libfdisk/src/script.c \
        \
        libfdisk/src/sun.c \
        libfdisk/src/sgi.c \
@@ -52,7 +52,7 @@ endif
 
 check_PROGRAMS += \
        test_fdisk_ask \
-       test_fdisk_dump \
+       test_fdisk_script \
        test_fdisk_utils
 
 libfdisk_tests_cflags  = -DTEST_PROGRAM $(libfdisk_la_CFLAGS)
@@ -77,7 +77,7 @@ test_fdisk_utils_CFLAGS = $(libfdisk_tests_cflags)
 test_fdisk_utils_LDFLAGS = $(libfdisk_tests_ldflags)
 test_fdisk_utils_LDADD = $(libfdisk_tests_ldadd)
 
-test_fdisk_dump_SOURCES = libfdisk/src/dump.c
-test_fdisk_dump_CFLAGS = $(libfdisk_tests_cflags)
-test_fdisk_dump_LDFLAGS = $(libfdisk_tests_ldflags)
-test_fdisk_dump_LDADD = $(libfdisk_tests_ldadd)
+test_fdisk_script_SOURCES = libfdisk/src/script.c
+test_fdisk_script_CFLAGS = $(libfdisk_tests_cflags)
+test_fdisk_script_LDFLAGS = $(libfdisk_tests_ldflags)
+test_fdisk_script_LDADD = $(libfdisk_tests_ldadd)

diff --git a/libfdisk/src/dump.c b/libfdisk/src/script.c
similarity index 73%
rename from libfdisk/src/dump.c
rename to libfdisk/src/script.c
index a81aae5d1ea69e238ad78cff435f7fd8f4847067..c141c354f2632787cad18fcbaba86acd6140f888 100644 (file)
--- a/libfdisk/src/dump.c
+++ b/libfdisk/src/script.c
@@ -2,15 +2,15 @@
 #include "fdiskP.h"
 #include "strutils.h"
 
-/* dump header (e.g. unit: sectors) */
-struct fdisk_dumpheader {
+/* script header (e.g. unit: sectors) */
+struct fdisk_scriptheader {
        struct list_head        headers;
        char                    *name;
        char                    *data;
 };
 
-/* dump control struct */
-struct fdisk_dump {
+/* script control struct */
+struct fdisk_script {
        struct fdisk_table      *table;
        struct list_head        headers;
        struct fdisk_context    *cxt;
@@ -24,7 +24,7 @@ struct fdisk_dump {
 };
 
 
-static void fdisk_dump_free_header(struct fdisk_dump *dp, struct fdisk_dumpheader *fi)
+static void fdisk_script_free_header(struct fdisk_script *dp, struct fdisk_scriptheader *fi)
 {
        if (!fi)
                return;
@@ -37,16 +37,16 @@ static void fdisk_dump_free_header(struct fdisk_dump *dp, struct fdisk_dumpheade
 }
 
 /**
- * fdisk_new_dump:
+ * fdisk_new_script:
  *
- * The dump hold fdisk_table and additional information to read/write
- * dump to the file.
+ * The script hold fdisk_table and additional information to read/write
+ * script to the file.
  *
- * Returns: newly allocated dump struct.
+ * Returns: newly allocated script struct.
  */
-struct fdisk_dump *fdisk_new_dump(struct fdisk_context *cxt)
+struct fdisk_script *fdisk_new_script(struct fdisk_context *cxt)
 {
-       struct fdisk_dump *dp = NULL;
+       struct fdisk_script *dp = NULL;
 
        dp = calloc(1, sizeof(*dp));
        if (!dp)
@@ -62,18 +62,18 @@ struct fdisk_dump *fdisk_new_dump(struct fdisk_context *cxt)
 }
 
 /**
- * fdisk_ref_dump:
- * @dp: dump pointer
+ * fdisk_ref_script:
+ * @dp: script pointer
  *
  * Incremparts reference counter.
  */
-void fdisk_ref_dump(struct fdisk_dump *dp)
+void fdisk_ref_script(struct fdisk_script *dp)
 {
        if (dp)
                dp->refcount++;
 }
 
-static void fdisk_reset_dump(struct fdisk_dump *dp)
+static void fdisk_reset_script(struct fdisk_script *dp)
 {
        assert(dp);
 
@@ -81,41 +81,41 @@ static void fdisk_reset_dump(struct fdisk_dump *dp)
        dp->table = NULL;
 
        while (!list_empty(&dp->headers)) {
-               struct fdisk_dumpheader *fi = list_entry(dp->headers.next,
-                                                 struct fdisk_dumpheader, headers);
-               fdisk_dump_free_header(dp, fi);
+               struct fdisk_scriptheader *fi = list_entry(dp->headers.next,
+                                                 struct fdisk_scriptheader, headers);
+               fdisk_script_free_header(dp, fi);
        }
        INIT_LIST_HEAD(&dp->headers);
 }
 
 /**
- * fdisk_unref_dump:
- * @dp: dump pointer
+ * fdisk_unref_script:
+ * @dp: script pointer
  *
  * De-incremparts reference counter, on zero the @dp is automatically
  * deallocated.
  */
-void fdisk_unref_dump(struct fdisk_dump *dp)
+void fdisk_unref_script(struct fdisk_script *dp)
 {
        if (!dp)
                return;
 
        dp->refcount--;
        if (dp->refcount <= 0) {
-               fdisk_reset_dump(dp);
+               fdisk_reset_script(dp);
                fdisk_unref_context(dp->cxt);
-               DBG(DUMP, ul_debugobj(dp, "free dump"));
+               DBG(DUMP, ul_debugobj(dp, "free script"));
                free(dp);
        }
 }
 
-static struct fdisk_dumpheader *dump_get_header(struct fdisk_dump *dp,
+static struct fdisk_scriptheader *script_get_header(struct fdisk_script *dp,
                                                     const char *name)
 {
        struct list_head *p;
 
        list_for_each(p, &dp->headers) {
-               struct fdisk_dumpheader *fi = list_entry(p, struct fdisk_dumpheader, headers);
+               struct fdisk_scriptheader *fi = list_entry(p, struct fdisk_scriptheader, headers);
 
                if (strcasecmp(fi->name, name) == 0)
                        return fi;
@@ -125,31 +125,31 @@ static struct fdisk_dumpheader *dump_get_header(struct fdisk_dump *dp,
 }
 
 /**
- * fdisk_dump_get_header:
- * @dp: dump instance
+ * fdisk_script_get_header:
+ * @dp: script instance
  * @name: header name
  *
  * Returns: pointer to header data or NULL.
  */
-const char *fdisk_dump_get_header(struct fdisk_dump *dp, const char *name)
+const char *fdisk_script_get_header(struct fdisk_script *dp, const char *name)
 {
-       struct fdisk_dumpheader *fi;
+       struct fdisk_scriptheader *fi;
 
        assert(dp);
        assert(name);
 
-       fi = dump_get_header(dp, name);
+       fi = script_get_header(dp, name);
        return fi ? fi->data : NULL;
 }
 
 
 /**
- * fdisk_dump_set_header:
- * @dp: dump instance
+ * fdisk_script_set_header:
+ * @dp: script instance
  * @name: header name
  * @data: header data (or NULL)
  *
- * The headers are used as global options (in dump) for whole partition table, always one
+ * The headers are used as global options (in script) for whole partition table, always one
  * header per line.
  *
  * If no @data specified then the header is removed. If header does not exist
@@ -161,11 +161,11 @@ const char *fdisk_dump_get_header(struct fdisk_dump *dp, const char *name)
  *
  * Returns: 0 on success, <0 on error
  */
-int fdisk_dump_set_header(struct fdisk_dump *dp,
+int fdisk_script_set_header(struct fdisk_script *dp,
                            const char *name,
                            const char *data)
 {
-       struct fdisk_dumpheader *fi;
+       struct fdisk_scriptheader *fi;
 
        assert(dp);
        assert(name);
@@ -173,13 +173,13 @@ int fdisk_dump_set_header(struct fdisk_dump *dp,
        if (!dp || !name)
                return -EINVAL;
 
-       fi = dump_get_header(dp, name);
+       fi = script_get_header(dp, name);
        if (!fi && !data)
                return 0;       /* want to remove header that does not exist, success */
 
        if (!data) {
                /* no data, remove the header */
-               fdisk_dump_free_header(dp, fi);
+               fdisk_script_free_header(dp, fi);
                return 0;
        }
 
@@ -192,7 +192,7 @@ int fdisk_dump_set_header(struct fdisk_dump *dp,
                fi->name = strdup(name);
                fi->data = strdup(data);
                if (!fi->data || !fi->name) {
-                       fdisk_dump_free_header(dp, fi);
+                       fdisk_script_free_header(dp, fi);
                        return -ENOMEM;
                }
                list_add_tail(&fi->headers, &dp->headers);
@@ -210,45 +210,45 @@ int fdisk_dump_set_header(struct fdisk_dump *dp,
 }
 
 /**
- * fdisk_dump_get_table:
- * @dp: dump
+ * fdisk_script_get_table:
+ * @dp: script
  *
  * The table (container with partitions) is possible to create by
- * fdisk_dump_read_context() or fdisk_dump_read_file(), otherwise
+ * fdisk_script_read_context() or fdisk_script_read_file(), otherwise
  * this function returns NULL.
  *
- * Returns: NULL or dump.
+ * Returns: NULL or script.
  */
-struct fdisk_table *fdisk_dump_get_table(struct fdisk_dump *dp)
+struct fdisk_table *fdisk_script_get_table(struct fdisk_script *dp)
 {
        assert(dp);
        return dp ? dp->table : NULL;
 }
 
-static struct fdisk_label *dump_get_label(struct fdisk_dump *dp)
+static struct fdisk_label *script_get_label(struct fdisk_script *dp)
 {
        assert(dp);
        assert(dp->cxt);
 
        if (!dp->label) {
                dp->label = fdisk_get_label(dp->cxt,
-                                       fdisk_dump_get_header(dp, "label"));
+                                       fdisk_script_get_header(dp, "label"));
                DBG(DUMP, ul_debug("label '%s'", dp->label ? dp->label->name : ""));
        }
        return dp->label;
 }
 
 /**
- * fdisk_dump_read_context:
- * @dp: dump
+ * fdisk_script_read_context:
+ * @dp: script
  * @cxt: context
  *
- * Reads data from the current context (on disk partition table) into the dump.
- * If the context is no specified than defaults to context used for fdisk_new_dump().
+ * Reads data from the current context (on disk partition table) into the script.
+ * If the context is no specified than defaults to context used for fdisk_new_script().
  *
  * Return: 0 on success, <0 on error.
  */
-int fdisk_dump_read_context(struct fdisk_dump *dp, struct fdisk_context *cxt)
+int fdisk_script_read_context(struct fdisk_script *dp, struct fdisk_context *cxt)
 {
        struct fdisk_label *lb;
        int rc;
@@ -262,7 +262,7 @@ int fdisk_dump_read_context(struct fdisk_dump *dp, struct fdisk_context *cxt)
        if (!dp || !cxt)
                return -EINVAL;
 
-       fdisk_reset_dump(dp);
+       fdisk_reset_script(dp);
 
        lb = fdisk_get_label(cxt, NULL);
        if (!lb)
@@ -274,16 +274,16 @@ int fdisk_dump_read_context(struct fdisk_dump *dp, struct fdisk_context *cxt)
                return rc;
 
        /* generate headers */
-       rc = fdisk_dump_set_header(dp, "label", fdisk_label_get_name(lb));
+       rc = fdisk_script_set_header(dp, "label", fdisk_label_get_name(lb));
 
        if (!rc && fdisk_get_disklabel_id(cxt, &p) == 0 && p) {
-               rc = fdisk_dump_set_header(dp, "label-id", p);
+               rc = fdisk_script_set_header(dp, "label-id", p);
                free(p);
        }
        if (!rc && cxt->dev_path)
-               rc = fdisk_dump_set_header(dp, "device", cxt->dev_path);
+               rc = fdisk_script_set_header(dp, "device", cxt->dev_path);
        if (!rc)
-               rc = fdisk_dump_set_header(dp, "unit", "sectors");
+               rc = fdisk_script_set_header(dp, "unit", "sectors");
 
        /* TODO: label specific headers (e.g. uuid for GPT) */
 
@@ -291,15 +291,15 @@ int fdisk_dump_read_context(struct fdisk_dump *dp, struct fdisk_context *cxt)
 }
 
 /**
- * fdisk_dump_write_file:
- * @dp: dump
+ * fdisk_script_write_file:
+ * @dp: script
  * @f: output file
  *
- * Writes dump @dp to the ile @f.
+ * Writes script @dp to the ile @f.
  *
  * Returns: 0 on sucess, <0 on error.
  */
-int fdisk_dump_write_file(struct fdisk_dump *dp, FILE *f)
+int fdisk_script_write_file(struct fdisk_script *dp, FILE *f)
 {
        struct list_head *h;
        struct fdisk_partition *pa;
@@ -309,9 +309,9 @@ int fdisk_dump_write_file(struct fdisk_dump *dp, FILE *f)
        assert(dp);
        assert(f);
 
-       /* dump headers */
+       /* script headers */
        list_for_each(h, &dp->headers) {
-               struct fdisk_dumpheader *fi = list_entry(h, struct fdisk_dumpheader, headers);
+               struct fdisk_scriptheader *fi = list_entry(h, struct fdisk_scriptheader, headers);
                fprintf(f, "%s: %s\n", fi->name, fi->data);
                if (strcmp(fi->name, "device") == 0)
                        devname = fi->data;
@@ -370,7 +370,7 @@ static inline int is_header_line(const char *s)
 }
 
 /* parses "<name>: value", note modifies @s*/
-static int parse_header_line(struct fdisk_dump *dp, char *s)
+static int parse_header_line(struct fdisk_script *dp, char *s)
 {
        int rc = -EINVAL;
        char *name, *value;
@@ -393,7 +393,7 @@ static int parse_header_line(struct fdisk_dump *dp, char *s)
        rtrim_whitespace((unsigned char *) value);
 
        if (*name && *value)
-               rc = fdisk_dump_set_header(dp, name, value);
+               rc = fdisk_script_set_header(dp, name, value);
 done:
        if (rc)
                DBG(DUMP, ul_debug("header parse error: [rc=%d]", rc));
@@ -486,7 +486,7 @@ static int partno_from_devname(char *s)
        return pno - 1;
 }
 
-static int parse_dump_line(struct fdisk_dump *dp, char *s)
+static int parse_script_line(struct fdisk_script *dp, char *s)
 {
        char *p;
        struct fdisk_partition *pa;
@@ -497,7 +497,7 @@ static int parse_dump_line(struct fdisk_dump *dp, char *s)
        assert(dp);
        assert(s);
 
-       DBG(DUMP, ul_debug("   parse dump line: '%s'", s));
+       DBG(DUMP, ul_debug("   parse script line: '%s'", s));
 
        pa = fdisk_new_partition();
        if (!pa)
@@ -570,7 +570,7 @@ static int parse_dump_line(struct fdisk_dump *dp, char *s)
                        if (rc)
                                break;
                        pa->type = fdisk_label_parse_parttype(
-                                       dump_get_label(dp), type);
+                                       script_get_label(dp), type);
                        free(type);
 
                        if (!pa->type || fdisk_parttype_is_unknown(pa->type)) {
@@ -581,7 +581,7 @@ static int parse_dump_line(struct fdisk_dump *dp, char *s)
                        }
 
                } else {
-                       DBG(DUMP, ul_debug("dump parse error: unknown field '%s'", p));
+                       DBG(DUMP, ul_debug("script parse error: unknown field '%s'", p));
                        rc = -EINVAL;
                        break;
                }
@@ -594,20 +594,20 @@ static int parse_dump_line(struct fdisk_dump *dp, char *s)
        if (!rc)
                rc = fdisk_table_add_partition(dp->table, pa);
        if (rc)
-               DBG(DUMP, ul_debug("dump parse error: [rc=%d]", rc));
+               DBG(DUMP, ul_debug("script parse error: [rc=%d]", rc));
 
        fdisk_unref_partition(pa);
        return rc;
 }
 
-static int parse_commas_line(struct fdisk_dump *dp, const char *s)
+static int parse_commas_line(struct fdisk_script *dp, const char *s)
 {
        DBG(DUMP, ul_debug("   commas line parse error"));
        return -EINVAL;
 }
 
 /* modifies @s ! */
-int fdisk_dump_read_buffer(struct fdisk_dump *dp, char *s)
+int fdisk_script_read_buffer(struct fdisk_script *dp, char *s)
 {
        int rc = 0;
 
@@ -630,9 +630,9 @@ int fdisk_dump_read_buffer(struct fdisk_dump *dp, char *s)
        if (fdisk_table_is_empty(dp->table) && is_header_line(s))
                rc = parse_header_line(dp, s);
 
-       /* parse dump format */
+       /* parse script format */
        else if (strchr(s, '='))
-               rc = parse_dump_line(dp, s);
+               rc = parse_script_line(dp, s);
 
        /* parse simple <value>, ... format */
        else
@@ -644,7 +644,7 @@ int fdisk_dump_read_buffer(struct fdisk_dump *dp, char *s)
        return rc;
 }
 
-char fdisk_dump_read_line(struct fdisk_dump *dp, FILE *f)
+char fdisk_script_read_line(struct fdisk_script *dp, FILE *f)
 {
        char buf[BUFSIZ];
        char *s;
@@ -679,20 +679,20 @@ char fdisk_dump_read_line(struct fdisk_dump *dp, FILE *f)
                s = (char *) skip_blank(buf);
        } while (*s == '\0' || *s == '#');
 
-       return fdisk_dump_read_buffer(dp, s);
+       return fdisk_script_read_buffer(dp, s);
 }
 
 
 /**
- * fdisk_dump_read_file:
- * @dp: dump
+ * fdisk_script_read_file:
+ * @dp: script
  * @f input file
  *
- * Reads file @f into dump @dp.
+ * Reads file @f into script @dp.
  *
  * Returns: 0 on success, <0 on error.
  */
-int fdisk_dump_read_file(struct fdisk_dump *dp, FILE *f)
+int fdisk_script_read_file(struct fdisk_script *dp, FILE *f)
 {
        int rc = NULL;
 
@@ -702,7 +702,7 @@ int fdisk_dump_read_file(struct fdisk_dump *dp, FILE *f)
        DBG(DUMP, ul_debug("parsing file"));
 
        while (!feof(f)) {
-               rc = fdisk_dump_read_line(dp, f);
+               rc = fdisk_script_read_line(dp, f);
                if (rc)
                        break;
        }
@@ -712,21 +712,21 @@ int fdisk_dump_read_file(struct fdisk_dump *dp, FILE *f)
 
 
 #ifdef TEST_PROGRAM
-int test_dump(struct fdisk_test *ts, int argc, char *argv[])
+int test_script(struct fdisk_test *ts, int argc, char *argv[])
 {
        char *devname = argv[1];
        struct fdisk_context *cxt;
-       struct fdisk_dump *dp;
+       struct fdisk_script *dp;
 
        cxt = fdisk_new_context();
        fdisk_assign_device(cxt, devname, 1);
 
-       dp = fdisk_new_dump(cxt);
-       fdisk_dump_read_context(dp, NULL);
-       fdisk_dump_set_header(dp, "custom-header-foo", "bar");
+       dp = fdisk_new_script(cxt);
+       fdisk_script_read_context(dp, NULL);
+       fdisk_script_set_header(dp, "custom-header-foo", "bar");
 
-       fdisk_dump_write_file(dp, stdout);
-       fdisk_unref_dump(dp);
+       fdisk_script_write_file(dp, stdout);
+       fdisk_unref_script(dp);
        fdisk_unref_context(cxt);
 
        return 0;
@@ -735,7 +735,7 @@ int test_dump(struct fdisk_test *ts, int argc, char *argv[])
 int test_read(struct fdisk_test *ts, int argc, char *argv[])
 {
        char *filename = argv[1];
-       struct fdisk_dump *dp;
+       struct fdisk_script *dp;
        struct fdisk_context *cxt;
        FILE *f;
 
@@ -743,13 +743,13 @@ int test_read(struct fdisk_test *ts, int argc, char *argv[])
                err(EXIT_FAILURE, "%s: cannot open", filename);
 
        cxt = fdisk_new_context();
-       dp = fdisk_new_dump(cxt);
+       dp = fdisk_new_script(cxt);
 
-       fdisk_dump_read_file(dp, f);
+       fdisk_script_read_file(dp, f);
        fclose(f);
 
-       fdisk_dump_write_file(dp, stdout);
-       fdisk_unref_dump(dp);
+       fdisk_script_write_file(dp, stdout);
+       fdisk_unref_script(dp);
        fdisk_unref_context(cxt);
 
        return 0;
@@ -758,8 +758,8 @@ int test_read(struct fdisk_test *ts, int argc, char *argv[])
 int main(int argc, char *argv[])
 {
        struct fdisk_test tss[] = {
-       { "--dump",  test_dump,    "<device>   print PT" },
-       { "--read",  test_read,    "<file>     read PT scrit from file" },
+       { "--script",  test_script,  "<device>   print PT" },
+       { "--read",    test_read,    "<file>     read PT scrit from file" },
        { NULL }
        };