--- /dev/null
+/* Code to move a ccan module into the ccan_ namespace. */
+#include <err.h>
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdbool.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include "talloc/talloc.h"
+
+#define CFLAGS "-O3 -Wall -Wundef -Wstrict-prototypes -Wold-style-definition -Wmissing-prototypes -Wmissing-declarations -Werror -I. -Iccan_tools/libtap/src/"
+
+#define IDENT_CHARS "ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
+ "abcdefghijklmnopqrstuvwxyz" \
+ "01234567889_"
+
+static bool verbose = false;
+static int indent = 0;
+#define verbose(args...) \
+ do { if (verbose) { \
+ unsigned int _i; \
+ for (_i = 0; _i < indent; _i++) printf(" "); \
+ printf(args); \
+ } \
+ } while(0)
+#define verbose_indent() (indent += 2)
+#define verbose_unindent() (indent -= 2)
+
+#define streq(a,b) (strcmp((a),(b)) == 0)
+
+#define strstarts(str,prefix) (strncmp((str),(prefix),strlen(prefix)) == 0)
+
+static inline bool strends(const char *str, const char *postfix)
+{
+ if (strlen(str) < strlen(postfix))
+ return false;
+
+ return streq(str + strlen(str) - strlen(postfix), postfix);
+}
+
+static int close_no_errno(int fd)
+{
+ int ret = 0, serrno = errno;
+ if (close(fd) < 0)
+ ret = errno;
+ errno = serrno;
+ return ret;
+}
+
+static int unlink_no_errno(const char *filename)
+{
+ int ret = 0, serrno = errno;
+ if (unlink(filename) < 0)
+ ret = errno;
+ errno = serrno;
+ return ret;
+}
+
+static void *grab_fd(const void *ctx, int fd)
+{
+ int ret;
+ unsigned int max = 16384, size = 0;
+ char *buffer;
+
+ buffer = talloc_array(ctx, char, max+1);
+ while ((ret = read(fd, buffer + size, max - size)) > 0) {
+ size += ret;
+ if (size == max)
+ buffer = talloc_realloc(ctx, buffer, char, max*=2 + 1);
+ }
+ if (ret < 0) {
+ talloc_free(buffer);
+ buffer = NULL;
+ } else
+ buffer[size] = '\0';
+
+ return buffer;
+}
+
+/* This version adds one byte (for nul term) */
+static void *grab_file(const void *ctx, const char *filename)
+{
+ int fd;
+ char *buffer;
+
+ if (streq(filename, "-"))
+ fd = dup(STDIN_FILENO);
+ else
+ fd = open(filename, O_RDONLY, 0);
+
+ if (fd < 0)
+ return NULL;
+
+ buffer = grab_fd(ctx, fd);
+ close_no_errno(fd);
+ return buffer;
+}
+
+/* This is a dumb one which copies. We could mangle instead. */
+static char **split(const void *ctx, const char *text, const char *delims,
+ unsigned int *nump)
+{
+ char **lines = NULL;
+ unsigned int max = 64, num = 0;
+
+ lines = talloc_array(ctx, char *, max+1);
+
+ while (*text != '\0') {
+ unsigned int len = strcspn(text, delims);
+ lines[num] = talloc_array(lines, char, len + 1);
+ memcpy(lines[num], text, len);
+ lines[num][len] = '\0';
+ text += len;
+ text += strspn(text, delims);
+ if (++num == max)
+ lines = talloc_realloc(ctx, lines, char *, max*=2 + 1);
+ }
+ lines[num] = NULL;
+ if (nump)
+ *nump = num;
+ return lines;
+}
+
+static char **get_dir(const char *dir)
+{
+ DIR *d;
+ struct dirent *ent;
+ char **names = NULL;
+ unsigned int size = 0;
+
+ d = opendir(dir);
+ if (!d)
+ return NULL;
+
+ while ((ent = readdir(d)) != NULL) {
+ names = talloc_realloc(dir, names, char *, size + 2);
+ names[size++]
+ = talloc_asprintf(names, "%s/%s", dir, ent->d_name);
+ }
+ names[size++] = NULL;
+ closedir(d);
+ return names;
+}
+
+static char ** __attribute__((format(printf, 2, 3)))
+lines_from_cmd(const void *ctx, char *format, ...)
+{
+ va_list ap;
+ char *cmd, *buffer;
+ FILE *p;
+
+ va_start(ap, format);
+ cmd = talloc_vasprintf(ctx, format, ap);
+ va_end(ap);
+
+ p = popen(cmd, "r");
+ if (!p)
+ err(1, "Executing '%s'", cmd);
+
+ buffer = grab_fd(ctx, fileno(p));
+ if (!buffer)
+ err(1, "Reading from '%s'", cmd);
+ pclose(p);
+
+ return split(ctx, buffer, "\n", NULL);
+}
+
+struct replace
+{
+ struct replace *next;
+ char *string;
+};
+
+static void __attribute__((noreturn)) usage(void)
+{
+ errx(1, "Usage:\n"
+ "namespacize [--verbose] <dir>\n"
+ "namespacize [--verbose] --adjust <dir>...\n"
+ "The first form converts dir/ to insert 'ccan_' prefixes, and\n"
+ "then adjusts any other ccan directories at the same level which\n"
+ "are effected.\n"
+ "--adjust does an adjustment for each directory, in case a\n"
+ "dependency has been namespacized\n");
+}
+
+static void add_replace(struct replace **repl, const char *str)
+{
+ struct replace *new, *i;
+
+ /* Avoid duplicates. */
+ for (i = *repl; i; i = i->next)
+ if (streq(i->string, str))
+ return;
+
+ new = talloc(*repl, struct replace);
+ new->next = *repl;
+ new->string = talloc_strdup(new, str);
+ *repl = new;
+}
+
+static void add_replace_tok(struct replace **repl, const char *s)
+{
+ struct replace *new;
+ unsigned int len = strspn(s, IDENT_CHARS);
+
+ new = talloc(*repl, struct replace);
+ new->next = *repl;
+ new->string = talloc_strndup(new, s, len);
+ *repl = new;
+}
+
+static char *basename(const void *ctx, const char *dir)
+{
+ char *p = strrchr(dir, '/');
+
+ if (!p)
+ return (char *)dir;
+ return talloc_strdup(ctx, p+1);
+}
+
+static void look_for_macros(char *contents, struct replace **repl)
+{
+ char *p;
+ enum { LINESTART, HASH, DEFINE, NONE } state = LINESTART;
+
+ /* Look for lines of form #define X */
+ for (p = contents; *p; p++) {
+ if (*p == '\n')
+ state = LINESTART;
+ else if (!isspace(*p)) {
+ if (state == LINESTART && *p == '#')
+ state = HASH;
+ else if (state==HASH && !strncmp(p, "define", 6)) {
+ state = DEFINE;
+ p += 5;
+ } else if (state == DEFINE) {
+ unsigned int len;
+
+ len = strspn(p, IDENT_CHARS);
+ if (len) {
+ char *s;
+ s = talloc_strndup(contents, p, len);
+ /* Don't wrap idempotent wrappers */
+ if (!strstarts(s, "CCAN_")) {
+ verbose("Found %s\n", s);
+ add_replace(repl, s);
+ }
+ }
+ state = NONE;
+ } else
+ state = NONE;
+ }
+ }
+}
+
+/* Blank out preprocessor lines, and eliminate \ */
+static void preprocess(char *p)
+{
+ char *s;
+
+ /* We assume backslashes are only used for macros. */
+ while ((s = strstr(p, "\\\n")) != NULL)
+ s[0] = s[1] = ' ';
+
+ /* Now eliminate # lines. */
+ if (p[0] == '#') {
+ unsigned int i;
+ for (i = 0; p[i] != '\n'; i++)
+ p[i] = ' ';
+ }
+ while ((s = strstr(p, "\n#")) != NULL) {
+ unsigned int i;
+ for (i = 1; s[i] != '\n'; i++)
+ s[i] = ' ';
+ }
+}
+
+static char *get_statement(const void *ctx, char **p)
+{
+ unsigned brackets = 0;
+ bool seen_brackets = false;
+ char *answer = talloc_strdup(ctx, "");
+
+ for (;;) {
+ if ((*p)[0] == '/' && (*p)[1] == '/')
+ *p += strcspn(*p, "\n");
+ else if ((*p)[0] == '/' && (*p)[1] == '*')
+ *p = strstr(*p, "*/") + 1;
+ else {
+ char c = **p;
+ if (c == ';' && !brackets) {
+ (*p)++;
+ return answer;
+ }
+ /* Compress whitespace into a single ' ' */
+ if (isspace(c)) {
+ c = ' ';
+ while (isspace((*p)[1]))
+ (*p)++;
+ } else if (c == '{' || c == '(' || c == '[') {
+ if (c == '(')
+ seen_brackets = true;
+ brackets++;
+ } else if (c == '}' || c == ')' || c == ']')
+ brackets--;
+
+ if (answer[0] != '\0' || c != ' ') {
+ answer = talloc_realloc(NULL, answer, char,
+ strlen(answer) + 2);
+ answer[strlen(answer)+1] = '\0';
+ answer[strlen(answer)] = c;
+ }
+ if (c == '}' && seen_brackets && brackets == 0) {
+ (*p)++;
+ return answer;
+ }
+ }
+ (*p)++;
+ if (**p == '\0')
+ return NULL;
+ }
+}
+
+/* This hack should handle well-formatted code. */
+static void look_for_definitions(char *contents, struct replace **repl)
+{
+ char *stmt, *p = contents;
+
+ preprocess(contents);
+
+ while ((stmt = get_statement(contents, &p)) != NULL) {
+ int i, len;
+
+ /* Definition of struct/union? */
+ if ((strncmp(stmt, "struct", 5) == 0
+ || strncmp(stmt, "union", 5) == 0)
+ && strchr(stmt, '{') && stmt[7] != '{')
+ add_replace_tok(repl, stmt+7);
+
+ /* Definition of var or typedef? */
+ for (i = strlen(stmt)-1; i >= 0; i--)
+ if (strspn(stmt+i, IDENT_CHARS) == 0)
+ break;
+
+ if (i != strlen(stmt)-1) {
+ add_replace_tok(repl, stmt+i+1);
+ continue;
+ }
+
+ /* function or array declaration? */
+ len = strspn(stmt, IDENT_CHARS "* ");
+ if (len > 0 && (stmt[len] == '(' || stmt[len] == '[')) {
+ if (strspn(stmt + len + 1, IDENT_CHARS) != 0) {
+ for (i = len-1; i >= 0; i--)
+ if (strspn(stmt+i, IDENT_CHARS) == 0)
+ break;
+ if (i != len-1) {
+ add_replace_tok(repl, stmt+i+1);
+ continue;
+ }
+ } else {
+ /* Pointer to function? */
+ len++;
+ len += strspn(stmt + len, " *");
+ i = strspn(stmt + len, IDENT_CHARS);
+ if (i > 0 && stmt[len + i] == ')')
+ add_replace_tok(repl, stmt+len);
+ }
+ }
+ }
+}
+
+/* FIXME: Only does main header, should chase local includes. */
+static void analyze_headers(const char *dir, struct replace **repl)
+{
+ char *hdr, *contents;
+
+ /* Get hold of header, assume that's it. */
+ hdr = talloc_asprintf(dir, "%s/%s.h", dir, basename(dir, dir));
+ contents = grab_file(dir, hdr);
+ if (!contents)
+ err(1, "Reading %s", hdr);
+
+ verbose("Looking in %s for macros\n", hdr);
+ verbose_indent();
+ look_for_macros(contents, repl);
+ verbose_unindent();
+
+ verbose("Looking in %s for symbols\n", hdr);
+ verbose_indent();
+ look_for_definitions(contents, repl);
+ verbose_unindent();
+}
+
+static void write_replacement_file(const char *dir, struct replace **repl)
+{
+ char *replname = talloc_asprintf(dir, "%s/.namespacize", dir);
+ int fd;
+ struct replace *r;
+
+ fd = open(replname, O_WRONLY|O_CREAT|O_EXCL, 0644);
+ if (fd < 0) {
+ if (errno == EEXIST)
+ errx(1, "%s already exists: can't namespacize twice",
+ replname);
+ err(1, "Opening %s", replname);
+ }
+
+ for (r = *repl; r; r = r->next) {
+ if (write(fd,r->string,strlen(r->string)) != strlen(r->string)
+ || write(fd, "\n", 1) != 1) {
+ unlink_no_errno(replname);
+ if (errno == 0)
+ errx(1, "Short write to %s: disk full?",
+ replname);
+ errx(1, "Writing to %s", replname);
+ }
+ }
+
+ close(fd);
+}
+
+static int unlink_destroy(char *name)
+{
+ unlink(name);
+ return 0;
+}
+
+static char *find_word(char *f, const char *str)
+{
+ char *p = f;
+
+ while ((p = strstr(p, str)) != NULL) {
+ /* Check it's not in the middle of a word. */
+ if (p > f && (isalnum(p[-1]) || p[-1] == '_')) {
+ p++;
+ continue;
+ }
+ if (isalnum(p[strlen(str)]) || p[strlen(str)] == '_') {
+ p++;
+ continue;
+ }
+ return p;
+ }
+ return NULL;
+}
+
+/* This is horribly inefficient but simple. */
+static const char *rewrite_file(const char *filename,
+ const struct replace *repl)
+{
+ char *newname, *file;
+ int fd;
+
+ verbose("Rewriting %s\n", filename);
+ file = grab_file(filename, filename);
+ if (!file)
+ err(1, "Reading file %s", filename);
+
+ for (; repl; repl = repl->next) {
+ char *p;
+
+ while ((p = find_word(file, repl->string)) != NULL) {
+ unsigned int off;
+ char *new = talloc_array(file, char, strlen(file)+6);
+
+ off = p - file;
+ memcpy(new, file, off);
+ if (isupper(repl->string[0]))
+ memcpy(new + off, "CCAN_", 5);
+ else
+ memcpy(new + off, "ccan_", 5);
+ strcpy(new + off + 5, file + off);
+ file = new;
+ }
+ }
+
+ /* If we exit for some reason, we want this erased. */
+ newname = talloc_asprintf(talloc_autofree_context(), "%s.tmp",
+ filename);
+ fd = open(newname, O_WRONLY|O_CREAT|O_EXCL, 0644);
+ if (fd < 0)
+ err(1, "Creating %s", newname);
+
+ talloc_set_destructor(newname, unlink_destroy);
+ if (write(fd, file, strlen(file)) != strlen(file)) {
+ if (errno == 0)
+ errx(1, "Short write to %s: disk full?", newname);
+ errx(1, "Writing to %s", newname);
+ }
+ close(fd);
+ return newname;
+}
+
+struct adjusted
+{
+ struct adjusted *next;
+ const char *file;
+ const char *tmpfile;
+};
+
+static void setup_adjust_files(const char *dir,
+ const struct replace *repl,
+ struct adjusted **adj)
+{
+ char **files;
+
+ for (files = get_dir(dir); *files; files++) {
+ if (strends(*files, "/test"))
+ setup_adjust_files(*files, repl, adj);
+ else if (strends(*files, ".c") || strends(*files, ".h")) {
+ struct adjusted *a = talloc(dir, struct adjusted);
+ a->next = *adj;
+ a->file = *files;
+ a->tmpfile = rewrite_file(a->file, repl);
+ *adj = a;
+ }
+ }
+}
+
+/* This is the "commit" stage, so we hope it won't fail. */
+static void rename_files(const struct adjusted *adj)
+{
+ while (adj) {
+ if (rename(adj->tmpfile, adj->file) != 0)
+ warn("Could not rename over '%s', we're in trouble",
+ adj->file);
+ adj = adj->next;
+ }
+}
+
+static void convert_dir(const char *dir)
+{
+ char *name;
+ struct replace *replace = NULL;
+ struct adjusted *adj = NULL;
+
+ /* Remove any ugly trailing slashes. */
+ name = talloc_strdup(NULL, dir);
+ while (strends(name, "/"))
+ name[strlen(name)-1] = '\0';
+
+ analyze_headers(name, &replace);
+ write_replacement_file(name, &replace);
+ setup_adjust_files(name, replace, &adj);
+ rename_files(adj);
+ talloc_free(name);
+ talloc_free(replace);
+}
+
+static struct replace *read_replacement_file(const char *depdir)
+{
+ struct replace *repl = NULL;
+ char *replname = talloc_asprintf(depdir, "%s/.namespacize", depdir);
+ char *file, **line;
+
+ file = grab_file(replname, replname);
+ if (!file) {
+ if (errno != ENOENT)
+ err(1, "Opening %s", replname);
+ return NULL;
+ }
+
+ for (line = split(file, file, "\n", NULL); *line; line++)
+ add_replace(&repl, *line);
+ return repl;
+}
+
+static char *build_info(const void *ctx, const char *dir)
+{
+ char *file, *cfile, *cmd;
+
+ cfile = talloc_asprintf(ctx, "%s/%s", dir, "_info.c");
+ file = talloc_asprintf(cfile, "%s/%s", dir, "_info");
+ cmd = talloc_asprintf(file, "gcc " CFLAGS " -o %s %s", file, cfile);
+ if (system(cmd) != 0)
+ errx(1, "Failed to compile %s", file);
+
+ return file;
+}
+
+static char **get_deps(const void *ctx, const char *dir)
+{
+ char **deps, *cmd;
+
+ cmd = talloc_asprintf(ctx, "%s depends", build_info(ctx, dir));
+ deps = lines_from_cmd(cmd, cmd);
+ if (!deps)
+ err(1, "Could not run '%s'", cmd);
+ return deps;
+}
+
+static char *parent_dir(const void *ctx, const char *dir)
+{
+ char *parent, *slash;
+
+ parent = talloc_strdup(ctx, dir);
+ slash = strrchr(parent, '/');
+ if (slash)
+ *slash = '\0';
+ else
+ parent = talloc_strdup(ctx, ".");
+ return parent;
+}
+
+static void adjust_dir(const char *dir)
+{
+ char *parent = parent_dir(NULL, dir);
+ char **deps;
+
+ verbose("Adjusting %s\n", dir);
+ verbose_indent();
+ for (deps = get_deps(parent, dir); *deps; deps++) {
+ char *depdir;
+ struct adjusted *adj = NULL;
+ struct replace *repl;
+
+ depdir = talloc_asprintf(parent, "%s/%s", parent, *deps);
+ repl = read_replacement_file(depdir);
+ if (repl) {
+ verbose("%s has been namespacized\n", depdir);
+ setup_adjust_files(parent, repl, &adj);
+ rename_files(adj);
+ } else
+ verbose("%s has not been namespacized\n", depdir);
+ talloc_free(depdir);
+ }
+ verbose_unindent();
+}
+
+static void adjust_dependents(const char *dir)
+{
+ char *parent = parent_dir(NULL, dir);
+ char *base = basename(parent, dir);
+ char **file;
+
+ verbose("Looking for dependents in %s\n", parent);
+ verbose_indent();
+ for (file = get_dir(parent); *file; file++) {
+ char *infoc, **deps;
+ bool isdep = false;
+
+ if (basename(*file, *file)[0] == '.')
+ continue;
+
+ infoc = talloc_asprintf(*file, "%s/_info.c", *file);
+ if (access(infoc, R_OK) != 0)
+ continue;
+
+ for (deps = get_deps(*file, *file); *deps; deps++) {
+ if (streq(*deps, base))
+ isdep = true;
+ }
+ if (isdep)
+ adjust_dir(*file);
+ else
+ verbose("%s is not dependent\n", *file);
+ }
+ verbose_unindent();
+}
+
+int main(int argc, char *argv[])
+{
+ if (argv[1] && streq(argv[1], "--verbose")) {
+ verbose = true;
+ argv++;
+ argc--;
+ }
+
+ if (argc == 2) {
+ verbose("Namespacizing %s\n", argv[1]);
+ verbose_indent();
+ convert_dir(argv[1]);
+ adjust_dependents(argv[1]);
+ verbose_unindent();
+ return 0;
+ }
+
+ if (argc > 2 && streq(argv[1], "--adjust")) {
+ unsigned int i;
+
+ for (i = 2; i < argc; i++)
+ adjust_dir(argv[i]);
+ return 0;
+ }
+ usage();
+}
projects / ponghero.git / blobdiff