blob: 93294884e8f0d6fc4519ab4f1874a33c0f55d208 [file] [log] [blame]
// Take three word input lines on stdin and produce flag #defines to stdout.
// The three words on each input lnie are command name, option string with
// current config, option string from allyesconfig. The three are space
// separated and the last two are in double quotes.
// This is intentionally crappy code because we control the inputs. It leaks
// memory like a sieve and segfaults if malloc returns null, but does the job.
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
struct flag {
struct flag *next;
char *command;
struct flag *lopt;
};
int chrtype(char c)
{
// Does this populate a GLOBALS() variable?
if (strchr("?&^-:#|@*; %", c)) return 1;
// Is this followed by a numeric argument in optstr?
if (strchr("=<>", c)) return 2;
return 0;
}
// replace chopped out USE_BLAH() sections with low-ascii characters
// showing how many flags got skipped
char *mark_gaps(char *flags, char *all)
{
char *n, *new, c;
int bare = 1;
// Shell feeds in " " for blank args, leading space not meaningful.
while (isspace(*flags)) flags++;
while (isspace(*all)) all++;
n = new = strdup(all);
while (*all) {
// --longopt parentheticals dealt with as a unit
if (*all == '(') {
int len = 0;
while (all[len++] != ')');
if (strncmp(flags, all, len)) {
// bare longopts need their own skip placeholders
if (bare) *(new++) = 1;
} else {
memcpy(new, all, len);
new += len;
flags += len;
}
all += len;
continue;
}
c = *(all++);
if (bare) bare = chrtype(c);
if (*flags == c) {
*(new++) = c;
flags++;
continue;
}
c = chrtype(c);
if (!c) *(new++) = 1;
else if (c==2) while (isdigit(*all)) all++;
}
*new = 0;
return n;
}
// Break down a command string into linked list of "struct flag".
struct flag *digest(char *string)
{
struct flag *list = NULL;
char *err = string, c;
while (*string) {
// Groups must be at end.
if (*string == '[') break;
// Longopts
if (*string == '(') {
struct flag *new = calloc(sizeof(struct flag), 1);
new->command = ++string;
// Attach longopt to previous short opt, if any.
if (list && list->command) {
new->next = list->lopt;
list->lopt = new;
} else {
struct flag *blank = calloc(sizeof(struct flag), 1);
blank->next = list;
blank->lopt = new;
list = blank;
}
// An empty longopt () would break this.
while (*++string != ')') if (*string == '-') *string = '_';
*(string++) = 0;
continue;
}
c = chrtype(*string);
if (c == 1) string++;
else if (c == 2) {
if (string[1]=='-') string++;
if (!isdigit(string[1])) {
fprintf(stderr, "%c without number in '%s'", *string, err);
exit(1);
}
while (isdigit(*++string)) {
if (!list) {
string++;
break;
}
}
} else {
struct flag *new = calloc(sizeof(struct flag), 1);
new->command = string++;
new->next = list;
list = new;
}
}
return list;
}
// Parse C-style octal escape
void octane(char *from)
{
unsigned char *to = (void *)from;
while (*from) {
if (*from == '\\') {
*to = 0;
while (isdigit(*++from)) *to = (8**to)+*from-'0';
to++;
} else *to++ = *from++;
}
*to = 0;
}
int main(int argc, char *argv[])
{
char command[256], flags[1023], allflags[1024];
char *out, *outbuf = malloc(1024*1024);
// Yes, the output buffer is 1 megabyte with no bounds checking.
// See "intentionally crappy", above.
if (!(out = outbuf)) return 1;
printf("#undef FORCED_FLAG\n#undef FORCED_FLAGLL\n"
"#ifdef FORCE_FLAGS\n#define FORCED_FLAG 1\n#define FORCED_FLAGLL 1LL\n"
"#else\n#define FORCED_FLAG 0\n#define FORCED_FLAGLL 0\n#endif\n\n");
for (;;) {
struct flag *flist, *aflist, *offlist;
char *mgaps = 0;
unsigned bit;
*command = *flags = *allflags = 0;
bit = fscanf(stdin, "%255s \"%1023[^\"]\" \"%1023[^\"]\"\n",
command, flags, allflags);
octane(flags);
octane(allflags);
if (getenv("DEBUG"))
fprintf(stderr, "command=%s, flags=%s, allflags=%s\n",
command, flags, allflags);
if (!*command) break;
if (bit != 3) {
fprintf(stderr, "\nError in %s (see generated/flags.raw)\n", command);
exit(1);
}
bit = 0;
printf("// %s %s %s\n", command, flags, allflags);
if (*flags != ' ') mgaps = mark_gaps(flags, allflags);
else if (*allflags != ' ') mgaps = allflags;
// If command disabled, use allflags for OLDTOY()
printf("#undef OPTSTR_%s\n#define OPTSTR_%s ", command, command);
if (mgaps) printf("\"%s\"\n", mgaps);
else printf("0\n");
if (mgaps != allflags) free(mgaps);
flist = digest(flags);
offlist = aflist = digest(allflags);
printf("#ifdef CLEANUP_%s\n#undef CLEANUP_%s\n#undef FOR_%s\n",
command, command, command);
while (offlist) {
char *s = (char []){0, 0, 0, 0};
if (!offlist->command) s = offlist->lopt->command;
else {
*s = *offlist->command;
if (127 < (unsigned char)*s) sprintf(s, "X%02X", 127&*s);
}
printf("#undef FLAG_%s\n", s);
offlist = offlist->next;
}
printf("#endif\n\n");
sprintf(out, "#ifdef FOR_%s\n#ifndef TT\n#define TT this.%s\n#endif\n",
command, command);
out += strlen(out);
while (aflist) {
char *llstr = bit>31 ? "LL" : "", *s = (char []){0, 0, 0, 0};
int enabled = 0;
// Output flag macro for bare longopts
if (!aflist->command) {
s = aflist->lopt->command;
if (flist && flist->lopt &&
!strcmp(flist->lopt->command, aflist->lopt->command)) enabled++;
// Output normal flag macro
} else {
*s = *aflist->command;
if (127 < (unsigned char)*s) sprintf(s, "X%02X", 127&*s);
if (flist && flist->command && *aflist->command == *flist->command)
enabled++;
}
out += sprintf(out, "#define FLAG_%s (%s%s<<%d)\n",
s, enabled ? "1" : "FORCED_FLAG", llstr, bit++);
aflist = aflist->next;
if (enabled) flist = flist->next;
}
out = stpcpy(out, "#endif\n\n");
}
if (fflush(0) && ferror(stdout)) return 1;
out = outbuf;
while (*out) {
int i = write(1, outbuf, strlen(outbuf));
if (i<0) return 1;
out += i;
}
return 0;
}