1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// Take three word input lines on stdin (the three space separated words are
// command name, option string with current config, option string from
// allyesconfig; space separated, the last two are and double quotes)
// and produce flag #defines to stdout.
// 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
struct flag {
struct flag *next;
char *command;
struct flag *lopt;
};
// Break down a command string into struct flag list.
struct flag *digest(char *string)
{
struct flag *list = NULL;
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;
}
while (*++string != ')'); // An empty longopt () would break this.
*(string++) = 0;
continue;
}
if (strchr("?&^-:#|@*; ", *string)) string++;
else if (strchr("=<>", *string)) {
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;
}
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;
for (;;) {
struct flag *flist, *aflist, *offlist;
unsigned bit = 0;
if (3 != fscanf(stdin, "%255s \"%1023[^\"]\" \"%1023[^\"]\"\n",
command, flags, allflags)) break;
printf("// %s %s %s\n", command, flags, allflags);
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) {
struct flag *f = offlist->lopt;
while (f) {
printf("#undef FLAG_%s\n", f->command);
f = f->next;
}
if (offlist->command) printf("#undef FLAG_%c\n", *offlist->command);
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) {
if (aflist->lopt) {
if (flist && flist->lopt &&
!strcmp(flist->lopt->command, aflist->lopt->command))
{
sprintf(out, "#define FLAG_%s (1<<%d)\n", flist->lopt->command, bit);
flist->lopt = flist->lopt->next;
} else sprintf(out, "#define FLAG_%s 0\n", aflist->lopt->command);
aflist->lopt = aflist->lopt->next;
if (!aflist->command) aflist = aflist->next;
} else if (aflist->command) {
if (flist && (!aflist->command || *aflist->command == *flist->command))
{
if (aflist->command)
sprintf(out, "#define FLAG_%c (1<<%d)\n", *aflist->command, bit);
bit++;
flist = flist->next;
} else sprintf(out, "#define FLAG_%c 0\n", *aflist->command);
aflist = aflist->next;
}
out += strlen(out);
}
sprintf(out, "#endif\n\n");
out += strlen(out);
}
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;
}
}
|
