Change indentation to improve readability.

1 files changed, 137 insertions, 140 deletions

diff --git a/src/builtin.c b/src/builtin.c
index 53d135d..18a8f9d 100644
--- a/src/builtin.c
+++ b/src/builtin.c
@@ -24,19 +24,19 @@
 int
 builtin_init(struct dictionary *dict)
 {
-	return 0;
+    return 0;
 }
 
 int
 builtin_done(struct dictionary *dict)
 {
-	return 0;
+    return 0;
 }
 
 void *
 builtin_open(struct dictionary *dict)
 {
-	return dict;
+    return dict;
 }
 
 #define CMP_EXACT   0
@@ -54,201 +54,198 @@ typedef int (*strcmp_fn) (const char *, const char *, int flags);
 static int
 cmp_exact(const char *pat, const char *str, int flags)
 {
-	return strcmp(pat, str) == 0;
+    return strcmp(pat, str) == 0;
 }
 
 static int
 cmp_exact_ci(const char *pat, const char *str, int flags)
 {
-	return strcmp(pat, str) == 0;
+    return strcmp(pat, str) == 0;
 }
 
 static int
 cmp_fnmatch(const char *pat, const char *str, int flags)
 {
-	return fnmatch(pat, str, flags) == 0;
+    return fnmatch(pat, str, flags) == 0;
 }
 
 static int
 cmp_regex(const char *pat, const char *str, int flags)
 {
-	int rc;
-	regex_t regex;
+    int rc;
+    regex_t regex;
 
-	rc = regcomp(&regex, pat, flags);
-	if (rc) {
-		char errbuf[512];
+    rc = regcomp(&regex, pat, flags);
+    if (rc) {
+	char errbuf[512];
 
-		regerror(rc, &regex, errbuf, sizeof(errbuf));
-		wy_log(LOG_ERR, _("%s: cannot compile regexp: %s"), pat,
-		       errbuf);
-		return 0;
-	}
+	regerror(rc, &regex, errbuf, sizeof(errbuf));
+	wy_log(LOG_ERR, _("%s: cannot compile regexp: %s"), pat, errbuf);
+	return 0;
+    }
 
-	rc = regexec(&regex, str, 0, NULL, 0);
-	regfree(&regex);
-	return rc == 0;
+    rc = regexec(&regex, str, 0, NULL, 0);
+    regfree(&regex);
+    return rc == 0;
 }
 
 int
 parse_cmp_type(const char *pat, strcmp_fn * cmpfn, int *rf)
 {
-	size_t len = strcspn(pat, ",");
-	int flags = 0;
-	int cmp;
-
-	if (STRMATCH("exact", pat, len))
-		cmp = CMP_EXACT;
-	else if (STRMATCH("fnmatch", pat, len))
-		cmp = CMP_FNMATCH;
-	else if (STRMATCH("regex", pat, len))
-		cmp = CMP_REGEX;
-	else
-		return 1;
-
-	pat += len;
-	if (*pat) {
-		while (*++pat) {
-			switch (*pat) {
-			case 'i':
-				flags |= RF_ICASE;
-				break;
-
-			case 'b':
-				flags |= RF_BASIC;
-				break;
-
-			default:
-				wy_log(LOG_NOTICE,
-				       _("unrecognized comparison flag: %c"),
-				       *pat);
-			}
-		}
-	}
-
-	switch (cmp) {
-	case CMP_EXACT:
-		*cmpfn = (flags & RF_ICASE) ? cmp_exact_ci : cmp_exact;
+    size_t len = strcspn(pat, ",");
+    int flags = 0;
+    int cmp;
+
+    if (STRMATCH("exact", pat, len))
+	cmp = CMP_EXACT;
+    else if (STRMATCH("fnmatch", pat, len))
+	cmp = CMP_FNMATCH;
+    else if (STRMATCH("regex", pat, len))
+	cmp = CMP_REGEX;
+    else
+	return 1;
+
+    pat += len;
+    if (*pat) {
+	while (*++pat) {
+	    switch (*pat) {
+	    case 'i':
+		flags |= RF_ICASE;
 		break;
 
-	case CMP_FNMATCH:
-		*cmpfn = cmp_fnmatch;
-		*rf = FNM_NOESCAPE | FNM_PERIOD |
-		      ((flags & RF_ICASE) ? FNM_CASEFOLD : 0);
+	    case 'b':
+		flags |= RF_BASIC;
 		break;
 
-	case CMP_REGEX:
-		*cmpfn = cmp_regex;
-		*rf = ((flags & RF_BASIC) ? 0 : REG_EXTENDED) | REG_NOSUB;
-		if (flags & RF_ICASE)
-			*rf |= REG_ICASE;
-		break;
+	    default:
+		wy_log(LOG_NOTICE,
+		       _("unrecognized comparison flag: %c"), *pat);
+	    }
 	}
-	return 0;
+    }
+
+    switch (cmp) {
+    case CMP_EXACT:
+	*cmpfn = (flags & RF_ICASE) ? cmp_exact_ci : cmp_exact;
+	break;
+
+    case CMP_FNMATCH:
+	*cmpfn = cmp_fnmatch;
+	*rf = FNM_NOESCAPE | FNM_PERIOD |
+	    ((flags & RF_ICASE) ? FNM_CASEFOLD : 0);
+	break;
+
+    case CMP_REGEX:
+	*cmpfn = cmp_regex;
+	*rf = ((flags & RF_BASIC) ? 0 : REG_EXTENDED) | REG_NOSUB;
+	if (flags & RF_ICASE)
+	    *rf |= REG_ICASE;
+	break;
+    }
+    return 0;
 }
 
 struct builtin_data_storage {
-	struct grecs_txtacc *acc;
-	char **wp;
+    struct grecs_txtacc *acc;
+    char **wp;
 };
 
 static int default_ncol[] = {
-	4,	/* project-uploader: name, realname, email, pubkey */
-	2,	/* project-owner: email, realname */
+    4,	  /* project-uploader: name, realname, email, pubkey */
+    2,	  /* project-owner: email, realname */
 };
 
 int
 builtin_lookup(struct dictionary *dict, void *handle, const char *req)
 {
-	int i;
-	int rc;
-	size_t count = 0;
-	struct grecs_txtacc *acc;
-	int flags = 0;
-	strcmp_fn cmpfn = cmp_exact;
-	struct builtin_data_storage *bds;
-	int ncol = default_ncol[dict->id];
-
-	if (dict->parmc == 0) {
-		dict->nrow = dict->ncol = 0;
-		return 0;
-	}
-
-	acc = grecs_txtacc_create();
+    int i;
+    int rc;
+    size_t count = 0;
+    struct grecs_txtacc *acc;
+    int flags = 0;
+    strcmp_fn cmpfn = cmp_exact;
+    struct builtin_data_storage *bds;
+    int ncol = default_ncol[dict->id];
+
+    if (dict->parmc == 0) {
+	dict->nrow = dict->ncol = 0;
+	return 0;
+    }
 
-	for (i = 0; i < dict->parmc; i++) {
-		char *pat = dict->parmv[i];
+    acc = grecs_txtacc_create();
 
-		if (pat[0] == '/') {
-			pat++;
-			if (*pat != '/'
-			    && parse_cmp_type(pat, &cmpfn, &flags) == 0)
-				continue;
-		}
+    for (i = 0; i < dict->parmc; i++) {
+	char *pat = dict->parmv[i];
 
-		if (i + ncol >= dict->parmc)
-			break;
+	if (pat[0] == '/') {
+	    pat++;
+	    if (*pat != '/' && parse_cmp_type(pat, &cmpfn, &flags) == 0)
+		continue;
+	}
 
-		if (cmpfn(pat, req, flags)) {
-			size_t j;
-			for (j = 1; j <= ncol; j++) {
-				char *val = dict->parmv[i + j];
-				grecs_txtacc_grow(acc, val, strlen(val) + 1);
-			}
-			count++;
-		}
+	if (i + ncol >= dict->parmc)
+	    break;
 
-		i += ncol;
+	if (cmpfn(pat, req, flags)) {
+	    size_t j;
+	    for (j = 1; j <= ncol; j++) {
+		char *val = dict->parmv[i + j];
+		grecs_txtacc_grow(acc, val, strlen(val) + 1);
+	    }
+	    count++;
 	}
 
-	dict->nrow = count;
-	dict->ncol = ncol;
-
-	if (count == 0) {
-		grecs_txtacc_free(acc);
-		bds = NULL;
-		rc = 1;
-	} else {
-		size_t i;
-		char *p;
-
-		bds = grecs_malloc(sizeof(*bds));
-		count *= ncol;
-		bds->wp = grecs_calloc(count, sizeof(bds->wp[0]));
-		bds->acc = acc;
-		p = grecs_txtacc_finish(acc, 0);
-
-		for (i = 0; i < count; i++) {
-			bds->wp[i] = p;
-			p += strlen(p) + 1;
-		}
-		rc = 0;
+	i += ncol;
+    }
+
+    dict->nrow = count;
+    dict->ncol = ncol;
+
+    if (count == 0) {
+	grecs_txtacc_free(acc);
+	bds = NULL;
+	rc = 1;
+    } else {
+	size_t i;
+	char *p;
+
+	bds = grecs_malloc(sizeof(*bds));
+	count *= ncol;
+	bds->wp = grecs_calloc(count, sizeof(bds->wp[0]));
+	bds->acc = acc;
+	p = grecs_txtacc_finish(acc, 0);
+
+	for (i = 0; i < count; i++) {
+	    bds->wp[i] = p;
+	    p += strlen(p) + 1;
 	}
+	rc = 0;
+    }
 
-	dict->storage = bds;
+    dict->storage = bds;
 
-	return rc;
+    return rc;
 }
 
 int
 builtin_free_result(struct dictionary *dict, void *handle)
 {
-	if (dict->storage) {
-		struct builtin_data_storage *bds = dict->storage;
-		grecs_txtacc_free(bds->acc);
-		free(bds->wp);
-		free(bds);
-		dict->storage = NULL;
-	}
-	return 0;
+    if (dict->storage) {
+	struct builtin_data_storage *bds = dict->storage;
+	grecs_txtacc_free(bds->acc);
+	free(bds->wp);
+	free(bds);
+	dict->storage = NULL;
+    }
+    return 0;
 }
 
 int
 builtin_get(struct dictionary *dict, void *handle, unsigned nrow,
 	    unsigned ncol)
 {
-	struct builtin_data_storage *bds = dict->storage;
-	char *str = bds->wp[nrow * dict->ncol + ncol];
-	dictionary_copy_result(dict, str, strlen(str));
-	return 0;
+    struct builtin_data_storage *bds = dict->storage;
+    char *str = bds->wp[nrow * dict->ncol + ncol];
+    dictionary_copy_result(dict, str, strlen(str));
+    return 0;
 }