| 2 |
- |
1 |
#include <u.h>
|
|
|
2 |
#include <libc.h>
|
|
|
3 |
|
|
|
4 |
#define R rand()&32767
|
|
|
5 |
#define T 0.125
|
|
|
6 |
#define CHOOSE(x) (x[(R)%(sizeof x / sizeof x[0])])
|
|
|
7 |
#define EQ(a,b) (strcmp(a,b)==0)
|
|
|
8 |
#define LAST(x) (x[strlen(x)-1])
|
|
|
9 |
#define VOWEL(x) (x=='a'||x=='e'||x=='i'||x=='o'||x=='u')
|
|
|
10 |
#define N 8
|
|
|
11 |
|
|
|
12 |
typedef struct xyz {
|
|
|
13 |
char *type;
|
|
|
14 |
union {
|
|
|
15 |
struct xyz *x[N];
|
|
|
16 |
char *s[N];
|
|
|
17 |
} list;
|
|
|
18 |
} *X, XX;
|
|
|
19 |
typedef struct {
|
|
|
20 |
char *number, *ending, *tense, *an, *unspec, *passive;
|
|
|
21 |
} *E, EE;
|
|
|
22 |
|
|
|
23 |
char *tense(), *number();
|
|
|
24 |
char buff[1000];
|
|
|
25 |
int io;
|
|
|
26 |
int flag;
|
|
|
27 |
int eqn=0, tbl=0, pic=0;
|
|
|
28 |
double makeup = -1.;
|
|
|
29 |
|
|
|
30 |
X np(E);
|
|
|
31 |
X aux(E);
|
|
|
32 |
X passive(E);
|
|
|
33 |
X passprep(void);
|
|
|
34 |
X vp(E);
|
|
|
35 |
X art(E);
|
|
|
36 |
X modal(E);
|
|
|
37 |
X perf(E);
|
|
|
38 |
X prog(E);
|
|
|
39 |
X verb(E);
|
|
|
40 |
X noun(E);
|
|
|
41 |
X nounal(E);
|
|
|
42 |
char *prefix(void);
|
|
|
43 |
char *root(void);
|
|
|
44 |
int prob(double);
|
|
|
45 |
char *tense(void);
|
|
|
46 |
char *number(void);
|
|
|
47 |
X getxx(void);
|
|
|
48 |
X verbal(E);
|
|
|
49 |
X adverb(void);
|
|
|
50 |
X adjective(void);
|
|
|
51 |
X adjph(E);
|
|
|
52 |
X prep(void);
|
|
|
53 |
X comp(E);
|
|
|
54 |
X advp(E);
|
|
|
55 |
X vprep(void);
|
|
|
56 |
E getenvq(void);
|
|
|
57 |
X comma(E);
|
|
|
58 |
X conjadv(void);
|
|
|
59 |
X lconjadv(void);
|
|
|
60 |
X conjsub(void);
|
|
|
61 |
X lconjsub(void);
|
|
|
62 |
X conj(void);
|
|
|
63 |
X nomz(void);
|
|
|
64 |
X equation();
|
|
|
65 |
X turgid(E);
|
|
|
66 |
void pr(X);
|
|
|
67 |
void out(char *);
|
|
|
68 |
void caps(void);
|
|
|
69 |
void abo(void);
|
|
|
70 |
char *splitup(char *);
|
|
|
71 |
|
|
|
72 |
X
|
|
|
73 |
nomq(E env) {
|
|
|
74 |
X v = getxx();
|
|
|
75 |
v->type = "-nomq";
|
|
|
76 |
if (EQ(env->number, "sing")) {
|
|
|
77 |
if (EQ(tense(), "past"))
|
|
|
78 |
v->list.s[0] = "there was";
|
|
|
79 |
else
|
|
|
80 |
v->list.s[0] = "there is";
|
|
|
81 |
} else {
|
|
|
82 |
if (EQ(tense(), "past"))
|
|
|
83 |
v->list.s[0] = "there were";
|
|
|
84 |
else
|
|
|
85 |
v->list.s[0] = "there are";
|
|
|
86 |
}
|
|
|
87 |
if (prob(0.2))
|
|
|
88 |
v->list.s[1] = " not";
|
|
|
89 |
return v;
|
|
|
90 |
}
|
|
|
91 |
|
|
|
92 |
X
|
|
|
93 |
rel(void) {
|
|
|
94 |
static char *c[] = {"that", "which"};
|
|
|
95 |
X v = getxx();
|
|
|
96 |
v->type = "-rel";
|
|
|
97 |
v->list.s[0] = CHOOSE(c);
|
|
|
98 |
return v;
|
|
|
99 |
}
|
|
|
100 |
|
|
|
101 |
X
|
|
|
102 |
sent(E env) {
|
|
|
103 |
X sentv = getxx();
|
|
|
104 |
sentv->type = "sent";
|
|
|
105 |
if (prob(0.09)) {
|
|
|
106 |
env->unspec = "";
|
|
|
107 |
sentv->list.x[1] = np(env);
|
|
|
108 |
sentv->list.x[3] = aux(env);
|
|
|
109 |
sentv->list.x[4] = vp(env);
|
|
|
110 |
sentv->list.x[0] = nomq(env);
|
|
|
111 |
sentv->list.x[2] = rel();
|
|
|
112 |
return sentv;
|
|
|
113 |
}
|
|
|
114 |
sentv->list.x[0] = np(env);
|
|
|
115 |
sentv->list.x[1] = aux(env);
|
|
|
116 |
sentv->list.x[2] = vp(env);
|
|
|
117 |
return sentv;
|
|
|
118 |
}
|
|
|
119 |
|
|
|
120 |
X
|
|
|
121 |
nomy(void) {
|
|
|
122 |
X v = getxx();
|
|
|
123 |
v->type = "-nomq";
|
|
|
124 |
v->list.s[0] = "the fact that";
|
|
|
125 |
return v;
|
|
|
126 |
}
|
|
|
127 |
|
|
|
128 |
X
|
|
|
129 |
np(env)
|
|
|
130 |
E env;
|
|
|
131 |
{
|
|
|
132 |
X npv = getxx();
|
|
|
133 |
EE nenv;
|
|
|
134 |
static EE empty;
|
|
|
135 |
npv->type = "np";
|
|
|
136 |
if (prob(0.025)) {
|
|
|
137 |
nenv = empty;
|
|
|
138 |
npv->list.x[0] = nomy();
|
|
|
139 |
npv->list.x[1] = sent(&nenv);
|
|
|
140 |
if (env->number == 0)
|
|
|
141 |
env->number = "sing";
|
|
|
142 |
return npv;
|
|
|
143 |
}
|
|
|
144 |
npv->list.x[1] = nounal(env);
|
|
|
145 |
npv->list.x[0] = art(env);
|
|
|
146 |
return npv;
|
|
|
147 |
}
|
|
|
148 |
|
|
|
149 |
X
|
|
|
150 |
aux(E env) {
|
|
|
151 |
X auxv = getxx();
|
|
|
152 |
int i = 0;
|
|
|
153 |
auxv->type = "aux";
|
|
|
154 |
if (env->tense == 0)
|
|
|
155 |
env->tense = env->ending = tense();
|
|
|
156 |
if (prob(0.25))
|
|
|
157 |
auxv->list.x[i++] = modal(env);
|
|
|
158 |
if (prob(0.25))
|
|
|
159 |
auxv->list.x[i++] = perf(env);
|
|
|
160 |
if (prob(0.25))
|
|
|
161 |
auxv->list.x[i++] = prog(env);
|
|
|
162 |
USED(i);
|
|
|
163 |
return auxv;
|
|
|
164 |
}
|
|
|
165 |
|
|
|
166 |
X
|
|
|
167 |
passive(env)
|
|
|
168 |
E env;
|
|
|
169 |
{
|
|
|
170 |
X v = getxx();
|
|
|
171 |
v->type = "-passive";
|
|
|
172 |
if (env->tense == 0)
|
|
|
173 |
env->tense = env->ending = tense();
|
|
|
174 |
if (env->number == 0)
|
|
|
175 |
env->number = number();
|
|
|
176 |
if (EQ(env->ending, "modal"))
|
|
|
177 |
v->list.s[0] = "be";
|
|
|
178 |
else if (EQ(env->ending, "-en"))
|
|
|
179 |
v->list.s[0] = "been";
|
|
|
180 |
else if (EQ(env->ending, "-ing"))
|
|
|
181 |
v->list.s[0] = "being";
|
|
|
182 |
else {
|
|
|
183 |
if (EQ(env->tense, "past"))
|
|
|
184 |
v->list.s[0] = EQ(env->number, "sing") ? "was" : "were";
|
|
|
185 |
else
|
|
|
186 |
v->list.s[0] = EQ(env->number, "sing") ? "is" : "are";
|
|
|
187 |
}
|
|
|
188 |
env->passive = env->ending = "pass";
|
|
|
189 |
return v;
|
|
|
190 |
}
|
|
|
191 |
|
|
|
192 |
X
|
|
|
193 |
passprep(void) {
|
|
|
194 |
X v = getxx();
|
|
|
195 |
v->type = "-passprep";
|
|
|
196 |
v->list.s[0] = "by";
|
|
|
197 |
return v;
|
|
|
198 |
}
|
|
|
199 |
|
|
|
200 |
X
|
|
|
201 |
vp(env)
|
|
|
202 |
E env;
|
|
|
203 |
{
|
|
|
204 |
X vpv = getxx();
|
|
|
205 |
int i = 0;
|
|
|
206 |
vpv->type = "vp";
|
|
|
207 |
if (prob(0.5))
|
|
|
208 |
vpv->list.x[i++] = passive(env);
|
|
|
209 |
vpv->list.x[i++] = verbal(env);
|
|
|
210 |
vpv->list.x[i++] = comp(env);
|
|
|
211 |
if (prob(0.10))
|
|
|
212 |
vpv->list.x[i++] = advp(env);
|
|
|
213 |
USED(i);
|
|
|
214 |
return vpv;
|
|
|
215 |
}
|
|
|
216 |
|
|
|
217 |
X
|
|
|
218 |
art(env)
|
|
|
219 |
E env;
|
|
|
220 |
{
|
|
|
221 |
static char *aspecsg[] = {"the", "the", "the", "the", "the", "this", "this", "that"};
|
|
|
222 |
static char *aspecpl[] = {"the", "the", "the", "the", "the", "these", "those"};
|
|
|
223 |
static char *aunssg[] = {"a", "a", "a", "a", "a", "a", "a", "much", "each", "any"};
|
|
|
224 |
static char *aunspl[] = {"some", "a few", "a couple", "several", "many", "all",
|
|
|
225 |
"no",
|
|
|
226 |
"an undue number of",
|
|
|
227 |
"a number of"};
|
|
|
228 |
X artv = getxx();
|
|
|
229 |
artv->type = "-art";
|
|
|
230 |
if (env->number == 0)
|
|
|
231 |
env->number = number();
|
|
|
232 |
if (env->unspec == 0 && prob(0.33)) {
|
|
|
233 |
if (EQ(env->number, "sing"))
|
|
|
234 |
artv->list.s[0] = CHOOSE(aspecsg);
|
|
|
235 |
else
|
|
|
236 |
artv->list.s[0] = CHOOSE(aspecpl);
|
|
|
237 |
} else if (prob(0.50) || env->an && EQ(env->number, "sing")) {
|
|
|
238 |
if (EQ(env->number, "sing"))
|
|
|
239 |
artv->list.s[0] = env->an ? "a" : CHOOSE(aunssg);
|
|
|
240 |
else
|
|
|
241 |
artv->list.s[0] = CHOOSE(aunspl);
|
|
|
242 |
if (env->an && EQ(artv->list.s[0], "all"))
|
|
|
243 |
artv->list.s[0] = "";
|
|
|
244 |
} else
|
|
|
245 |
artv->list.s[0] = "";
|
|
|
246 |
env->unspec = 0;
|
|
|
247 |
if (env->an && EQ(env->an, "an") && EQ(artv->list.s[0], "a"))
|
|
|
248 |
artv->list.s[0] = "an";
|
|
|
249 |
env->an = 0;
|
|
|
250 |
return artv;
|
|
|
251 |
}
|
|
|
252 |
|
|
|
253 |
X
|
|
|
254 |
modal(env)
|
|
|
255 |
E env;
|
|
|
256 |
{
|
|
|
257 |
static char *pres[] = {"can", "may", "must", "shall", "will"};
|
|
|
258 |
static char *past[] = {"could", "might", "should", "would"};
|
|
|
259 |
X modalv = getxx();
|
|
|
260 |
modalv->type = "-modal";
|
|
|
261 |
if (env->tense == 0)
|
|
|
262 |
env->tense = env->ending = tense();
|
|
|
263 |
if (EQ(env->ending, "pres"))
|
|
|
264 |
modalv->list.s[0] = CHOOSE(pres);
|
|
|
265 |
else
|
|
|
266 |
modalv->list.s[0] = CHOOSE(past);
|
|
|
267 |
env->ending = "modal";
|
|
|
268 |
return modalv;
|
|
|
269 |
}
|
|
|
270 |
|
|
|
271 |
X
|
|
|
272 |
perf(env)
|
|
|
273 |
E env;
|
|
|
274 |
{
|
|
|
275 |
X perfv = getxx();
|
|
|
276 |
perfv->type = "-perf";
|
|
|
277 |
if (env->tense == 0)
|
|
|
278 |
env->tense = env->ending = tense();
|
|
|
279 |
if (env->number == 0)
|
|
|
280 |
env->number = number();
|
|
|
281 |
if (EQ(env->ending, "past")) {
|
|
|
282 |
perfv->list.s[0] = "had";
|
|
|
283 |
} else if (EQ(env->ending, "pres")) {
|
|
|
284 |
if (EQ(env->number, "sing"))
|
|
|
285 |
perfv->list.s[0] = "had";
|
|
|
286 |
else
|
|
|
287 |
perfv->list.s[0] = "have";
|
|
|
288 |
} else
|
|
|
289 |
perfv->list.s[0] = "have";
|
|
|
290 |
env->ending = "-en";
|
|
|
291 |
return perfv;
|
|
|
292 |
}
|
|
|
293 |
|
|
|
294 |
X
|
|
|
295 |
prog(env)
|
|
|
296 |
E env;
|
|
|
297 |
{
|
|
|
298 |
X progv = getxx();
|
|
|
299 |
progv->type = "-prog";
|
|
|
300 |
if (env->tense == 0)
|
|
|
301 |
env->tense = env->ending = tense();
|
|
|
302 |
if (env->number == 0)
|
|
|
303 |
env->number = number();
|
|
|
304 |
if (EQ(env->ending, "pres")) {
|
|
|
305 |
if (EQ(env->number, "sing"))
|
|
|
306 |
progv->list.s[0] = "is";
|
|
|
307 |
else
|
|
|
308 |
progv->list.s[0] = "are";
|
|
|
309 |
} else if (EQ(env->ending, "past")) {
|
|
|
310 |
if (EQ(env->number, "sing"))
|
|
|
311 |
progv->list.s[0] = "was";
|
|
|
312 |
else
|
|
|
313 |
progv->list.s[0] = "were";
|
|
|
314 |
} else if (EQ(env->ending, "-en")) {
|
|
|
315 |
progv->list.s[0] = "been";
|
|
|
316 |
} else if (EQ(env->ending, "modal")) {
|
|
|
317 |
progv->list.s[0] = "be";
|
|
|
318 |
}
|
|
|
319 |
env->ending = "-ing";
|
|
|
320 |
return progv;
|
|
|
321 |
}
|
|
|
322 |
|
|
|
323 |
X
|
|
|
324 |
verb(env)
|
|
|
325 |
E env;
|
|
|
326 |
{
|
|
|
327 |
/* they pres, he pres, they past, they perf, they prog, they pass */
|
|
|
328 |
static char *ends[][6] = {{"ate", "ates", "ated", "ated", "ating", "ated"},
|
|
|
329 |
{"en", "ens", "ened", "ened", "ening", "ened"},
|
|
|
330 |
{"esce", "esces", "esced", "esced", "escing", "esced"},
|
|
|
331 |
{"fy", "fies", "fied", "fied", "fying", "fied"},
|
|
|
332 |
{"ize", "izes", "ized", "ized", "izing", "ized"}};
|
|
|
333 |
X verbv = getxx();
|
|
|
334 |
int i;
|
|
|
335 |
verbv->type = "-verb";
|
|
|
336 |
if (env->tense == 0)
|
|
|
337 |
env->tense = env->ending = tense();
|
|
|
338 |
if (env->number == 0)
|
|
|
339 |
env->number = number();
|
|
|
340 |
if (0 && prob(0.1) && EQ(env->tense, env->ending)) {
|
|
|
341 |
if (EQ(env->number, "sing")) {
|
|
|
342 |
if (EQ(env->tense, "pres"))
|
|
|
343 |
verbv->list.s[0] = "is";
|
|
|
344 |
else
|
|
|
345 |
verbv->list.s[0] = "was";
|
|
|
346 |
} else {
|
|
|
347 |
if (EQ(env->tense, "pres"))
|
|
|
348 |
verbv->list.s[0] = "are";
|
|
|
349 |
else
|
|
|
350 |
verbv->list.s[0] = "were";
|
|
|
351 |
}
|
|
|
352 |
} else {
|
|
|
353 |
verbv->list.s[0] = prefix();
|
|
|
354 |
verbv->list.s[1] = root();
|
|
|
355 |
if (EQ(env->ending, "pres") && EQ(env->number, "sing"))
|
|
|
356 |
i = 1;
|
|
|
357 |
else if (EQ(env->ending, "pres") || EQ(env->ending, "modal"))
|
|
|
358 |
i = 0;
|
|
|
359 |
else if (EQ(env->ending, "past"))
|
|
|
360 |
i = 2;
|
|
|
361 |
else if (EQ(env->ending, "-en"))
|
|
|
362 |
i = 3;
|
|
|
363 |
else if (EQ(env->ending, "-ing"))
|
|
|
364 |
i = 4;
|
|
|
365 |
else if (EQ(env->ending, "pass"))
|
|
|
366 |
i = 5;
|
|
|
367 |
else
|
|
|
368 |
i = 0;
|
|
|
369 |
verbv->list.s[2] = ends[R % (sizeof ends / sizeof *ends)][i];
|
|
|
370 |
}
|
|
|
371 |
env->ending = 0;
|
|
|
372 |
return verbv;
|
|
|
373 |
}
|
|
|
374 |
|
|
|
375 |
static char *nounlist[] = {"final completion",
|
|
|
376 |
"final ending", "final outcome",
|
|
|
377 |
"adaptation", "appearance", "argument", "circumstance",
|
|
|
378 |
"confession", "confidence", "delimitation", "dilution",
|
|
|
379 |
"dissertation", "distribution", "duplication",
|
|
|
380 |
"entertainment", "equipment", "evolution",
|
|
|
381 |
"existence", "expression", "generation", "impression",
|
|
|
382 |
"integration", "interaction", "investment", "judgment",
|
|
|
383 |
"population", "provision", "solution", "statement",
|
|
|
384 |
"tradition", "transmission",
|
|
|
385 |
"final result", "added increment", "assistance",
|
|
|
386 |
"beneficial assistance", "mutual cooperation",
|
|
|
387 |
"projection", "future projection",
|
|
|
388 |
"capability", "conjecture", "consensus of opinion",
|
|
|
389 |
"general consensus", "absence", "deficiency",
|
|
|
390 |
"inadequacy", "insufficience", "insufficiency",
|
|
|
391 |
"growing importance", "renewed emphasis",
|
|
|
392 |
"renewed interest", "changing behavior",
|
|
|
393 |
"critical thinking", "careful thinking",
|
|
|
394 |
"comprehensive survey", "high standard",
|
|
|
395 |
"basic foundation", "system testing",
|
|
|
396 |
"serious discussion", "serious concern",
|
|
|
397 |
"organizational framework", "prototype model",
|
|
|
398 |
"uniform nomenclature", "greater cooperation",
|
|
|
399 |
"uniform consistency", "early expectation",
|
|
|
400 |
"standardization", "great similarity",
|
|
|
401 |
"shortage", "presence", "sufficiency",
|
|
|
402 |
"consequent result", "construct", "disutility",
|
|
|
403 |
"early beginning", "emotional feeling", "endeavor",
|
|
|
404 |
"authorization", "order of magnitude", "preference",
|
|
|
405 |
"impact", "joint cooperation", "joint partnership",
|
|
|
406 |
"main essential", "methodology", "modification",
|
|
|
407 |
"necessary requisite", "past history", "situation",
|
|
|
408 |
"effectuation", "clarification", "new doubt",
|
|
|
409 |
"policy", "encouragement", "preparation",
|
|
|
410 |
"criterion", "material", "interest", "acceptance",
|
|
|
411 |
"rejection", "publication", "circulation",
|
|
|
412 |
"protection", "insurance",
|
|
|
413 |
"assignment", "identification",
|
|
|
414 |
"submission", "request",
|
|
|
415 |
"guidance", "correspondence", "inclusion",
|
|
|
416 |
"attachment", "assumption",
|
|
|
417 |
"recommendation", "prescription", "approval",
|
|
|
418 |
"discretion", "responsibility", "relevance",
|
|
|
419 |
"issuance", "termination", "total effect",
|
|
|
420 |
"deleterious effect", "consolidation",
|
|
|
421 |
"aggregation", "definiteness", "commencement",
|
|
|
422 |
"actual experience", "experience",
|
|
|
423 |
"combination", "accord", "filing",
|
|
|
424 |
"idea", "abstraction", "method", "procedure",
|
|
|
425 |
"complaint", "maintenance", "finance", "travel",
|
|
|
426 |
"purchase", "repair", "routine",
|
|
|
427 |
"development", "cancellation",
|
|
|
428 |
"partitioning", "development effort",
|
|
|
429 |
"project", "automation", "multilevel architecture",
|
|
|
430 |
"multilevel heirarchy", "data stream",
|
|
|
431 |
"objective",
|
|
|
432 |
"individual assignment", "mode of operation",
|
|
|
433 |
"clear community", "attendant interest",
|
|
|
434 |
"task division", "well defined interfacing",
|
|
|
435 |
"team report", "meeting time", "effective use",
|
|
|
436 |
"friction",
|
|
|
437 |
"major objective", "ownership",
|
|
|
438 |
"overall project time constraint",
|
|
|
439 |
"functional division", "requirements analysis",
|
|
|
440 |
"code development", "charter",
|
|
|
441 |
"requirements definition", "vertical division",
|
|
|
442 |
"broad range", "strong feeling",
|
|
|
443 |
"considerable latitude", "overall project constraint",
|
|
|
444 |
"sufficient resource", "assigned task", "expectation",
|
|
|
445 |
"critical aspect", "clear understanding",
|
|
|
446 |
"computing load", "clean interfacing", "natural basis",
|
|
|
447 |
"team activity", "team responsibility",
|
|
|
448 |
"main function", "predominant portion",
|
|
|
449 |
"work plan", "major breakpoint", "work module",
|
|
|
450 |
"achievable accuracy", "supplementary work",
|
|
|
451 |
"field version", "internal establishment",
|
|
|
452 |
"internal communication", "development progress",
|
|
|
453 |
"internal meeting", "experience level",
|
|
|
454 |
"high level autonomy", "adherence",
|
|
|
455 |
"feasibility demonstration", "persistent problem",
|
|
|
456 |
"internal objective", "idea sharing",
|
|
|
457 |
"improved performance", "unfamiliar methodology",
|
|
|
458 |
"new methodology", "development experience",
|
|
|
459 |
"module specification", "good progress",
|
|
|
460 |
"optimal number", "natural division",
|
|
|
461 |
"good relationship", "cross attendance",
|
|
|
462 |
"attendance", "necessary communication",
|
|
|
463 |
"evolving organization", "basic principle",
|
|
|
464 |
"complete revision", "general information",
|
|
|
465 |
"primary objective", "load-carrying capacity",
|
|
|
466 |
"necessary revision", "major change",
|
|
|
467 |
"clarified interpretation", "subsequent attempt",
|
|
|
468 |
"basic objective", "full utilization",
|
|
|
469 |
"practical consideration",
|
|
|
470 |
"proportionate quantity", "substantial change",
|
|
|
471 |
"database design", "unified framework",
|
|
|
472 |
"customer service", "strong interest",
|
|
|
473 |
"unified description", "necessary background information",
|
|
|
474 |
"provisioning", "physical coverage", "general observation",
|
|
|
475 |
"new technology", "validity determination",
|
|
|
476 |
"relation", "regulation", "verification",
|
|
|
477 |
"impediment", "portal", "practice", "premise",
|
|
|
478 |
"basis", "movement", "question",
|
|
|
479 |
"issue", "input", "output", "observation",
|
|
|
480 |
"input", "output", "input", "output",
|
|
|
481 |
"mechanization", "function", "evaluation",
|
|
|
482 |
"result", "further consideration", "category",
|
|
|
483 |
"performance indicator", "early warning",
|
|
|
484 |
"analysis purpose", "measurement", "replacement",
|
|
|
485 |
"utilitarian purpose",
|
|
|
486 |
"quota", "proposed enhancement", "enhancement",
|
|
|
487 |
"interfacing", "team organization", "module",
|
|
|
488 |
"guideline", "continuing study",
|
|
|
489 |
"required assistance", "major advance",
|
|
|
490 |
"proposal", "hierarchy",
|
|
|
491 |
"current view", "refinement", "activity",
|
|
|
492 |
"external description", "tight schedule pressure",
|
|
|
493 |
"internal conflict", "internal issue",
|
|
|
494 |
"reasonable compromise", "next phase",
|
|
|
495 |
"goal", "time constraint", "constraint",
|
|
|
496 |
"outcome", "important outcome",
|
|
|
497 |
"considerable experience", "intelligent choice",
|
|
|
498 |
"deliverable documentation", "discussion",
|
|
|
499 |
"timely delivery", "design issue", "large quantity",
|
|
|
500 |
"general environment", "protocol",
|
|
|
501 |
"transitioning", "modeling",
|
|
|
502 |
"considerable difficulty", "abstract interfacing",
|
|
|
503 |
"data structure", "consideration", "difficulty",
|
|
|
504 |
"statistical accuracy",
|
|
|
505 |
"agenda", "technique", "reordering",
|
|
|
506 |
"reauthorization", "current proposal",
|
|
|
507 |
"significant change", "criteria", "validation",
|
|
|
508 |
"validity",
|
|
|
509 |
"terminology", "current understanding",
|
|
|
510 |
"incorporation", "staffing impact",
|
|
|
511 |
"schedule impact", "cost tradeoff",
|
|
|
512 |
"system architecture",
|
|
|
513 |
"adequate capacity", "centralization",
|
|
|
514 |
"current task", "system deployment",
|
|
|
515 |
"attendant uncertainty", "process",
|
|
|
516 |
"potential usefulness", "proposed method",
|
|
|
517 |
"basic assumption", "anomaly",
|
|
|
518 |
"available data", "potential improvement",
|
|
|
519 |
"registration", "exemption", "exception",
|
|
|
520 |
"follow-up", "service",
|
|
|
521 |
"installation", "construction", "necessity",
|
|
|
522 |
"occasion", "instrumentation", "disposal",
|
|
|
523 |
"attractiveness",
|
|
|
524 |
"convenience", "sponsoring",
|
|
|
525 |
"signification", "meaningfulness",
|
|
|
526 |
"significantness", "individuality",
|
|
|
527 |
"specification", "determination", "affirmation",
|
|
|
528 |
"recruitment", "supervision", "management",
|
|
|
529 |
"oversight", "overview", "environment",
|
|
|
530 |
"effectation", "circumvention", "location",
|
|
|
531 |
"execution", "effectiveness", "consciousness",
|
|
|
532 |
"notation", "confirmation", "restriction",
|
|
|
533 |
"organization", "realization", "actification",
|
|
|
534 |
"activation", "reification", "beginning", "conclusion",
|
|
|
535 |
"ending", "finishing", "teamwork", "motivation",
|
|
|
536 |
"attitude", "good attitude",
|
|
|
537 |
"progress", "milestone", "deadline", "schedule",
|
|
|
538 |
"allocation", "resource", "command", "concern",
|
|
|
539 |
"time", "time frame", "reality",
|
|
|
540 |
"behaviour", "ability", "advent", "increment",
|
|
|
541 |
"opportunity", "accomplishment", "aggregate",
|
|
|
542 |
"analysis", "totality", "matter",
|
|
|
543 |
"date", "duration", "centrality",
|
|
|
544 |
"proximity", "collection", "elimination",
|
|
|
545 |
"investigation", "opinion", "debate",
|
|
|
546 |
"decision", "benefit", "difference", "discontinuity",
|
|
|
547 |
"fabrication", "plan", "chart", "forecast",
|
|
|
548 |
"simplicity", "simplification", "maximization",
|
|
|
549 |
"minimization", "direction",
|
|
|
550 |
"agreement",
|
|
|
551 |
"amount", "quantity", "quality", "essence",
|
|
|
552 |
"description", "violation", "purpose",
|
|
|
553 |
"primary purpose", "automatic control", "redefinition",
|
|
|
554 |
"uniform emphasis", "study activity", "work activity",
|
|
|
555 |
"concept stage", "concept activity",
|
|
|
556 |
"possible potential", "summarization", "system function",
|
|
|
557 |
"rationale", "significant enhancement", "diverse need",
|
|
|
558 |
"diverse organization", "comprehensive plan", "interim",
|
|
|
559 |
"functional overview", "system configuration",
|
|
|
560 |
"configuration", "failure", "quantitative result",
|
|
|
561 |
"major obstacle", "conception",
|
|
|
562 |
"effectiveness", "final evaluation",
|
|
|
563 |
"interrelationship", "functional requirement",
|
|
|
564 |
"system philosophy", "verbal interchange",
|
|
|
565 |
"perceived inadequacy", "primary emphasis",
|
|
|
566 |
"intermingling", "cooperation", "partnership",
|
|
|
567 |
"adjustment", "application", "implementation",
|
|
|
568 |
"contact", "mention", "power",
|
|
|
569 |
"nature", "invention", "importance",
|
|
|
570 |
"ground", "reason", "permission", "size",
|
|
|
571 |
"report", "documentation", "priority",
|
|
|
572 |
"pursuance", "recurrance", "resumption",
|
|
|
573 |
"presupposition", "continuance",
|
|
|
574 |
"substantiation", "success", "action", "truth",
|
|
|
575 |
"past experience", "greater acceptability",
|
|
|
576 |
"organizational structure", "clear distinction",
|
|
|
577 |
"clear definition",
|
|
|
578 |
"significant use", "unmet need", "centralized organization",
|
|
|
579 |
"vague concept", "negative impact", "detrimental effect",
|
|
|
580 |
"modularization", "submodularization",
|
|
|
581 |
"effect", "consistancy",
|
|
|
582 |
"inconsistancy", "completion", "utilization",
|
|
|
583 |
"reference", "doubt", "evidence",
|
|
|
584 |
"viewpoint",
|
|
|
585 |
"actual fact",
|
|
|
586 |
"true fact", "underlying purpose", "viable alternative"};
|
|
|
587 |
|
|
|
588 |
static char *adjlist[] = {"concrete", "abstract", "procedural",
|
|
|
589 |
"real", "ideal", "functional", "prototype",
|
|
|
590 |
"effective", "capable", "incremental",
|
|
|
591 |
"perceived", "associated", "interdepartmental",
|
|
|
592 |
"diverse", "characteristic", "worst-case",
|
|
|
593 |
"qualitative", "fully automatic", "candidate",
|
|
|
594 |
"consensual", "consequential", "conjectural",
|
|
|
595 |
"constructive", "initial", "cooperative",
|
|
|
596 |
"essential", "methodological", "requisite",
|
|
|
597 |
"historical", "situational", "political",
|
|
|
598 |
"prepared", "material", "defined", "well defined",
|
|
|
599 |
"organizational", "projected", "overall",
|
|
|
600 |
"accepted", "rejected", "corresponding",
|
|
|
601 |
"committed", "environmental", "typical", "working", "timely",
|
|
|
602 |
"growing", "unprecedented", "new", "renewed", "fresh",
|
|
|
603 |
"rapid", "changing", "careful", "comprehensive", "broad",
|
|
|
604 |
"massive", "huge", "enormous",
|
|
|
605 |
"evaluated", "discresionary",
|
|
|
606 |
"durable", "beneficial",
|
|
|
607 |
"maximal", "tremendous", "minimal",
|
|
|
608 |
"on-site", "standardized", "standard",
|
|
|
609 |
"powerful", "natural", "necessary",
|
|
|
610 |
"reasonable", "successful",
|
|
|
611 |
"doubtful", "dubious", "certain",
|
|
|
612 |
"unified", "different", "similar", "utilitarian",
|
|
|
613 |
"realizable", "organizable", "motivated",
|
|
|
614 |
"topical", "valuable", "feasible",
|
|
|
615 |
"intelligent", "deliverable", "nontrivial",
|
|
|
616 |
"worthwhile", "complicated",
|
|
|
617 |
"organized", "organizing", "progressing",
|
|
|
618 |
"schedulable", "resourceful", "commanding",
|
|
|
619 |
"important", "allocatable", "temporal",
|
|
|
620 |
"ponderable", "understandable", "comprehendable",
|
|
|
621 |
"past", "present", "future",
|
|
|
622 |
"obvious", "considerable", "finished", "completed",
|
|
|
623 |
"unique", "abovementioned",
|
|
|
624 |
"major", "minor", "tendentious", "activating",
|
|
|
625 |
"actual", "added", "adequate", "affordable",
|
|
|
626 |
"analyzable", "additional", "intuitive",
|
|
|
627 |
"artificial", "good", "better",
|
|
|
628 |
"worse", "bad", "basic", "fundamental", "brief",
|
|
|
629 |
"general", "very unique", "extreme", "most unique",
|
|
|
630 |
"central", "proximate", "approximate", "collected",
|
|
|
631 |
"conductable", "comtemplatable",
|
|
|
632 |
"continuing", "demonstrable", "desirable",
|
|
|
633 |
"correctable", "foreseeable",
|
|
|
634 |
"discontinued", "early", "beginning",
|
|
|
635 |
"effectuated", "elucidated", "emotional",
|
|
|
636 |
"enclosed", "enthused", "entire", "exact",
|
|
|
637 |
"experimental", "fearful", "final",
|
|
|
638 |
"following", "informative",
|
|
|
639 |
"full", "complete", "indicated", "authorized",
|
|
|
640 |
"modularized", "submodularized",
|
|
|
641 |
"particular", "preferred", "satisfactory",
|
|
|
642 |
"measurable", "referenced", "literal",
|
|
|
643 |
"modified",
|
|
|
644 |
"correct", "prioritized", "prolonged",
|
|
|
645 |
"regrettable", "apparent",
|
|
|
646 |
"continued", "subsequent", "sufficient",
|
|
|
647 |
"suggestive", "true", "ultimate", "separate",
|
|
|
648 |
"purposeful", "regarded", "resulting",
|
|
|
649 |
"doubtful", "evident", "interesting", "worthy",
|
|
|
650 |
"uniform", "vital", "viable",
|
|
|
651 |
"worthwhile", "alternative",
|
|
|
652 |
"sophisticated", "employed",
|
|
|
653 |
"clear", "lucid", "simple", "perspicuous",
|
|
|
654 |
"incomplete", "concerned"};
|
|
|
655 |
|
|
|
656 |
X
|
|
|
657 |
noun(env)
|
|
|
658 |
E env;
|
|
|
659 |
{
|
|
|
660 |
static char *suff[] = {"ion", "sion", "tion", "age",
|
|
|
661 |
"ness", "ment", "ure",
|
|
|
662 |
"ity", "iety", "ty", "ence", "ency", "ance",
|
|
|
663 |
"ancy", "tude", "hood", "ture", "ate", "art", "ard",
|
|
|
664 |
"ism", "ine", "stress", "trix", "ess",
|
|
|
665 |
"dom", "ship", "eer", "ster", "ant", "ent", "ary",
|
|
|
666 |
"ery", "ory", "ette", "let", "ling", "ule", "kin",
|
|
|
667 |
"ar", "or", "ist", "fulness",
|
|
|
668 |
"kin", "cule", "icle", "y", "ability", "iosos"};
|
|
|
669 |
X nounv = getxx();
|
|
|
670 |
int i = 0;
|
|
|
671 |
nounv->type = "-noun";
|
|
|
672 |
if (env->number == 0)
|
|
|
673 |
env->number = number();
|
|
|
674 |
if (prob(makeup)) {
|
|
|
675 |
if (prob(0.05)) {
|
|
|
676 |
nounv->list.s[i++] = CHOOSE(adjlist);
|
|
|
677 |
nounv->list.s[i++] = "ness";
|
|
|
678 |
} else
|
|
|
679 |
nounv->list.s[i++] = CHOOSE(nounlist);
|
|
|
680 |
} else {
|
|
|
681 |
nounv->list.s[i++] = prefix();
|
|
|
682 |
nounv->list.s[i++] = root();
|
|
|
683 |
nounv->list.s[i++] = CHOOSE(suff);
|
|
|
684 |
}
|
|
|
685 |
if (EQ(env->number, "plural")) {
|
|
|
686 |
if (LAST(nounv->list.s[i - 1]) == 's')
|
|
|
687 |
nounv->list.s[i] = "es";
|
|
|
688 |
else if (LAST(nounv->list.s[i - 1]) == 'y')
|
|
|
689 |
nounv->list.s[i] = "ies";
|
|
|
690 |
else
|
|
|
691 |
nounv->list.s[i] = "s";
|
|
|
692 |
}
|
|
|
693 |
return nounv;
|
|
|
694 |
}
|
|
|
695 |
|
|
|
696 |
X
|
|
|
697 |
adjval(void) {
|
|
|
698 |
X adjvalv = getxx();
|
|
|
699 |
int i = 0;
|
|
|
700 |
adjvalv->type = "adjval";
|
|
|
701 |
if (prob(0.25)) {
|
|
|
702 |
adjvalv->list.x[i++] = adverb();
|
|
|
703 |
}
|
|
|
704 |
do {
|
|
|
705 |
adjvalv->list.x[i++] = adjective();
|
|
|
706 |
} while (i < N - 1 && prob(0.25));
|
|
|
707 |
return adjvalv;
|
|
|
708 |
}
|
|
|
709 |
|
|
|
710 |
X
|
|
|
711 |
nounal(env)
|
|
|
712 |
E env;
|
|
|
713 |
{
|
|
|
714 |
X nounalv = getxx();
|
|
|
715 |
int i = 0;
|
|
|
716 |
X p;
|
|
|
717 |
nounalv->type = "nounal";
|
|
|
718 |
if (prob(0.15)) {
|
|
|
719 |
nounalv->list.x[i++] = adjval();
|
|
|
720 |
}
|
|
|
721 |
nounalv->list.x[i++] = noun(env);
|
|
|
722 |
if (prob(0.15)) {
|
|
|
723 |
nounalv->list.x[i] = adjph(env);
|
|
|
724 |
}
|
|
|
725 |
env->an = "a";
|
|
|
726 |
for (p = nounalv; p->type[0] != '-'; p = p->list.x[0]);
|
|
|
727 |
for (i = 0; p->list.s[i]; i++) {
|
|
|
728 |
if (p->list.s[i][0] == 0)
|
|
|
729 |
continue;
|
|
|
730 |
if (VOWEL(p->list.s[i][0])) {
|
|
|
731 |
env->an = "an";
|
|
|
732 |
}
|
|
|
733 |
break;
|
|
|
734 |
}
|
|
|
735 |
return nounalv;
|
|
|
736 |
}
|
|
|
737 |
|
|
|
738 |
char *
|
|
|
739 |
prefix(void) {
|
|
|
740 |
static char *pref[] = {
|
|
|
741 |
"amb", "ambi", "super", "hyper", "an", "tra", "trans", "post", "palim",
|
|
|
742 |
"omni", "pan", "circ", "circum", "peri", "a", "ab", "abs", "de", "apo",
|
|
|
743 |
"re", "ana", "mal", "ante", "pre", "fore", "pro", "infra", "para",
|
|
|
744 |
"inter", "ultra", "extra", "trans", "cata", "de", "oct", "octa",
|
|
|
745 |
"octo", "equi", "pseudo", "prim", "prot", "proto", "pent", "penta",
|
|
|
746 |
"quin", "quint", "quinque", "pro", "tetr", "tetra", "quad", "quadr",
|
|
|
747 |
"quadri", "quartet", "off", "bene", "hemi", "demi", "semi", "crypto",
|
|
|
748 |
"cent", "centi", "hecto", "en", "em", "in", "im", "intro", "be",
|
|
|
749 |
"macro", "poly", "mult", "multi", "neo", "nona", "novem", "ennea",
|
|
|
750 |
"in", "un", "im", "il", "ir", "non", "a", "nil", "paleo", "mon", "mono",
|
|
|
751 |
"uni", "e", "ex", "ec", "ef", "super", "supr", "sur", "hyper", "vic",
|
|
|
752 |
"vice", "hept", "hepta", "sept", "septe", "septem", "septi", "hex",
|
|
|
753 |
"hexa", "sex", "dis", "deca", "deka", "deci", "kilo", "mill", "milli",
|
|
|
754 |
"tri", "per", "dia", "ad", "com", "di", "amphi", "bi", "bin", "bis",
|
|
|
755 |
"sub", "hypo", "epi", "eu", "holo"};
|
|
|
756 |
if (prob(0.65))
|
|
|
757 |
return "";
|
|
|
758 |
return CHOOSE(pref);
|
|
|
759 |
}
|
|
|
760 |
|
|
|
761 |
char *
|
|
|
762 |
root(void) {
|
|
|
763 |
static char *root[] = {
|
|
|
764 |
"pan", "omni", "arch", "zo", "rog", "rogat", "cred", "flect", "flex",
|
|
|
765 |
"test", "hem", "hemato", "nasc", "nat", "bibl", "fer", "voc", "port", "lat",
|
|
|
766 |
"fortuna", "ped", "chrom", "vinc", "vict", "crea", "cise", "mort", "mors",
|
|
|
767 |
"necr", "claim", "clam", "hetero", "pel", "puls", "vac", "iso", "phobe",
|
|
|
768 |
"phobia", "prim", "prime", "flu", "flux", "sequ", "liber", "liver", "theo",
|
|
|
769 |
"magna", "medi", "man", "manu", "pen", "pend", "pens", "eu", "capit",
|
|
|
770 |
"iatr", "aud", "aus", "cor", "cord", "cour", "grav", "ten", "tain",
|
|
|
771 |
"tent", "sacr", "sacer", "heiro", "sanct", "cide", "mega", "ultima",
|
|
|
772 |
"ridi", "risi", "leg", "jus", "jur", "nom", "duc", "duct", "duce",
|
|
|
773 |
"bio", "viv", "vivi", "vita", "lus", "lum", "luc", "photo",
|
|
|
774 |
"min", "philo", "phile", "phila", "amic", "anthrop", "poly", "multi",
|
|
|
775 |
"fac", "fact", "fic", "fect", "meter", "psych", "mod", "mot", "mov",
|
|
|
776 |
"nov", "neo", "neg", "uni", "alter", "ali", "idio", "pop", "dem",
|
|
|
777 |
"demo", "lic", "licit", "poten", "posse", "potes", "mem", "simul",
|
|
|
778 |
"arch", "homo", "mar", "mer", "vis", "vid", "scope", "auto", "mitt",
|
|
|
779 |
"miss", "ac", "acr", "brev", "clud", "clus", "dorm", "micro", "aster",
|
|
|
780 |
"astro", "rect", "recti", "forc", "fort", "path", "cap", "cep", "cept",
|
|
|
781 |
"put", "tempo", "tempor", "dent", "dont", "ver", "veri",
|
|
|
782 |
"feder", "fide", "feal", "fid", "cosm", "migra", "hydro", "aqu",
|
|
|
783 |
"endo", "gyn", "logo", "opus", "oper", "graph", "scrib", "scrip",
|
|
|
784 |
"mis", "miso", "anni", "annu", "enni", "ced", "cede", "ceed", "cess"};
|
|
|
785 |
return CHOOSE(root);
|
|
|
786 |
}
|
|
|
787 |
|
|
|
788 |
prob(f)
|
|
|
789 |
double f;
|
|
|
790 |
{
|
|
|
791 |
return (R) < (f * 32767.0);
|
|
|
792 |
}
|
|
|
793 |
|
|
|
794 |
char *
|
|
|
795 |
tense()
|
|
|
796 |
{
|
|
|
797 |
return prob(0.5) ? "pres" : "past";
|
|
|
798 |
}
|
|
|
799 |
|
|
|
800 |
char *
|
|
|
801 |
number()
|
|
|
802 |
{
|
|
|
803 |
return prob(0.25) ? "plural" : "sing";
|
|
|
804 |
}
|
|
|
805 |
|
|
|
806 |
X
|
|
|
807 |
getxx()
|
|
|
808 |
{
|
|
|
809 |
X rv;
|
|
|
810 |
static XX empty;
|
|
|
811 |
|
|
|
812 |
rv = (X) malloc(sizeof *rv);
|
|
|
813 |
if (rv == 0) {
|
|
|
814 |
fprint(2, "festoon: outa space\n");
|
|
|
815 |
exits("space");
|
|
|
816 |
}
|
|
|
817 |
*rv = empty;
|
|
|
818 |
return rv;
|
|
|
819 |
}
|
|
|
820 |
|
|
|
821 |
X
|
|
|
822 |
verbal(env)
|
|
|
823 |
E env;
|
|
|
824 |
{
|
|
|
825 |
X verbalv = getxx();
|
|
|
826 |
int i = 0;
|
|
|
827 |
verbalv->type = "verbal";
|
|
|
828 |
if (prob(0.25))
|
|
|
829 |
verbalv->list.x[i++] = adverb();
|
|
|
830 |
verbalv->list.x[i] = verb(env);
|
|
|
831 |
return verbalv;
|
|
|
832 |
}
|
|
|
833 |
|
|
|
834 |
static char *advlist[] = {"absolutely", "functionally",
|
|
|
835 |
"accordingly", "broadly", "actionably", "actually",
|
|
|
836 |
"additionally",
|
|
|
837 |
"ambiguously", "amply",
|
|
|
838 |
"analogously",
|
|
|
839 |
"aperiodically",
|
|
|
840 |
"apparently", "appreciably",
|
|
|
841 |
"appropriately", "approximately",
|
|
|
842 |
"arbitrarily",
|
|
|
843 |
"associatively",
|
|
|
844 |
"automatically",
|
|
|
845 |
"awfully",
|
|
|
846 |
"axiomatically",
|
|
|
847 |
"badly", "barely", "basically",
|
|
|
848 |
"beneficially",
|
|
|
849 |
"blatantly",
|
|
|
850 |
"capably", "carefully", "carelessly",
|
|
|
851 |
"casually", "causally", "cautiously",
|
|
|
852 |
"centrally", "certainly",
|
|
|
853 |
"cheaply", "cleanly",
|
|
|
854 |
"closely", "coarsely", "cognizantly",
|
|
|
855 |
"coincidentally", "collectively", "collaterally",
|
|
|
856 |
"comparably",
|
|
|
857 |
"competently", "completely", "comprehensibly",
|
|
|
858 |
"concededly", "conceivably",
|
|
|
859 |
"concisely", "conclusively", "concretely",
|
|
|
860 |
"concurrently", "conjecturally",
|
|
|
861 |
"currently",
|
|
|
862 |
"conscientously", "consequently", "consequentially",
|
|
|
863 |
"consistently", "constantly",
|
|
|
864 |
"contemporaneuosly", "constructively",
|
|
|
865 |
"continually", "continuously", "contractually",
|
|
|
866 |
"contrarily", "contributatively", "conveniently",
|
|
|
867 |
"conventionally",
|
|
|
868 |
"correctively",
|
|
|
869 |
"correctly",
|
|
|
870 |
"crudely",
|
|
|
871 |
"curiously",
|
|
|
872 |
"decidedly",
|
|
|
873 |
"deeply",
|
|
|
874 |
"deficiently", "demandingly",
|
|
|
875 |
"dependably", "desireably",
|
|
|
876 |
"determinately", "diagnostically",
|
|
|
877 |
"differentially", "differently",
|
|
|
878 |
"directly", "discernibly",
|
|
|
879 |
"distinctly", "doubtfully", "dramatically",
|
|
|
880 |
"dynamically",
|
|
|
881 |
"economically",
|
|
|
882 |
"effecaciously", "efficiently",
|
|
|
883 |
"elegantly",
|
|
|
884 |
"emphatically", "encouragingly",
|
|
|
885 |
"endlessly", "endurably",
|
|
|
886 |
"entirely", "epistomologically",
|
|
|
887 |
"functionally", "immediately",
|
|
|
888 |
"equably", "equally", "equitably", "erroneously",
|
|
|
889 |
"esoterically", "eternally", "evenly", "eventfully",
|
|
|
890 |
"eventually", "evidently",
|
|
|
891 |
"exceedingly", "exactly", "excellently",
|
|
|
892 |
"exceptionally", "excessively", "exclusively",
|
|
|
893 |
"experimentally",
|
|
|
894 |
"explicitly", "extremely",
|
|
|
895 |
"factually", "faithfully",
|
|
|
896 |
"faultlessly", "feasibly",
|
|
|
897 |
"finitely", "firmly", "forcefully",
|
|
|
898 |
"formally", "formerly", "frankly", "freely",
|
|
|
899 |
"frugally", "fully", "generally",
|
|
|
900 |
"globally", "gradually",
|
|
|
901 |
"harmlessly",
|
|
|
902 |
"helpfully",
|
|
|
903 |
"highly", "homogeneously",
|
|
|
904 |
"hopefully",
|
|
|
905 |
"ideally", "identically", "ideologically",
|
|
|
906 |
"idiomatically", "idiosyncratically", "idly",
|
|
|
907 |
"imaginably", "immaterially", "immensely",
|
|
|
908 |
"impartially", "imperceptably", "imperfectly", "importantly",
|
|
|
909 |
"improperly", "imprudently", "inaccurately", "inappropriately",
|
|
|
910 |
"accurately",
|
|
|
911 |
"inclusively", "incompletely", "incorrectly",
|
|
|
912 |
"increasingly", "independently",
|
|
|
913 |
"indirectly", "ineffectively", "ineffectually", "inefficiently",
|
|
|
914 |
"infallibly", "instantaneously", "instantly",
|
|
|
915 |
"insufficiently", "internally", "likely", "only",
|
|
|
916 |
"invaluably", "inversely", "irrelevantly", "irrespectively",
|
|
|
917 |
"largely", "lastly", "legitimately", "literally",
|
|
|
918 |
"locally", "loosely", "manageably", "markedly",
|
|
|
919 |
"memorably", "mildly", "mindfully", "moderately",
|
|
|
920 |
"momentarily", "naturally", "needfully", "needlessly",
|
|
|
921 |
"nominally", "normally", "objectively", "occasionally",
|
|
|
922 |
"temporarily",
|
|
|
923 |
"officially", "oppositely", "ordinarily", "ostensibly",
|
|
|
924 |
"partially", "permissibly",
|
|
|
925 |
"personally", "pertinently",
|
|
|
926 |
"physically", "plainly", "plainly",
|
|
|
927 |
"pleasingly", "politically",
|
|
|
928 |
"potentially", "predictively",
|
|
|
929 |
"predominantly", "prematurely", "preparedly", "presently",
|
|
|
930 |
"previously", "primarily",
|
|
|
931 |
"primely", "principally", "problematically",
|
|
|
932 |
"productively", "promptly", "proportionately",
|
|
|
933 |
"provably", "purely", "quickly", "radically", "randomly", "recently",
|
|
|
934 |
"repeatedly", "secondarily", "separately",
|
|
|
935 |
"usually", "specifically",
|
|
|
936 |
"redundantly", "regardlessly", "reliably",
|
|
|
937 |
"remarkably", "remotely", "respectively",
|
|
|
938 |
"probably",
|
|
|
939 |
"robustly", "seemingly",
|
|
|
940 |
"sensibly", "singularly", "steadily",
|
|
|
941 |
"strikingly", "substantially", "successfully",
|
|
|
942 |
"supposedly", "systematically", "understandably",
|
|
|
943 |
"necessarily", "unfortunately",
|
|
|
944 |
"unnecessarily", "unmistakably", "usefully", "weakly"};
|
|
|
945 |
|
|
|
946 |
X
|
|
|
947 |
adverb(void) {
|
|
|
948 |
static char *wordy[] = {"very ", "extremely ", "generally ",
|
|
|
949 |
"reasonably ", "fundamentally ", "essentially ", "particularly ",
|
|
|
950 |
"very ",
|
|
|
951 |
"very ", "very ",
|
|
|
952 |
"very ", "very ",
|
|
|
953 |
"very ", "very ",
|
|
|
954 |
"very ", "very ",
|
|
|
955 |
"very ", "very ",
|
|
|
956 |
"very ", "very ",
|
|
|
957 |
"very ", "very ",
|
|
|
958 |
"entirely ",
|
|
|
959 |
"rather ", "fairly ", "relatively ", "comparatively ",
|
|
|
960 |
"moderately ",
|
|
|
961 |
"totally ", "very ", "quite "};
|
|
|
962 |
static char *suff[] = {"wardly", "ably", "wisely",
|
|
|
963 |
"ably", "ily", "ly", "ly", "ly"};
|
|
|
964 |
|
|
|
965 |
X adverbv = getxx();
|
|
|
966 |
int i = 0;
|
|
|
967 |
|
|
|
968 |
adverbv->type = "-adverb";
|
|
|
969 |
if (prob(0.150)) {
|
|
|
970 |
adverbv->list.s[i] = prob(.5) ? "simply" : "easily";
|
|
|
971 |
return adverbv;
|
|
|
972 |
}
|
|
|
973 |
if (prob(0.4))
|
|
|
974 |
adverbv->list.s[i++] = CHOOSE(wordy);
|
|
|
975 |
if (prob(makeup))
|
|
|
976 |
adverbv->list.s[i] = CHOOSE(advlist);
|
|
|
977 |
else {
|
|
|
978 |
adverbv->list.s[i++] = prefix();
|
|
|
979 |
adverbv->list.s[i++] = root();
|
|
|
980 |
adverbv->list.s[i] = CHOOSE(suff);
|
|
|
981 |
}
|
|
|
982 |
return adverbv;
|
|
|
983 |
}
|
|
|
984 |
|
|
|
985 |
X
|
|
|
986 |
adjective(void) {
|
|
|
987 |
static char *suff[] = {"ive", "ful", "ous", "some", "oid",
|
|
|
988 |
"ine", "esque", "en", "an",
|
|
|
989 |
"ile", "able", "ible", "istic", "ic",
|
|
|
990 |
"an", "ian", "ish", "ite", "al", "less"};
|
|
|
991 |
X adjv = getxx();
|
|
|
992 |
int i = 0;
|
|
|
993 |
|
|
|
994 |
adjv->type = "-adjective";
|
|
|
995 |
if (prob(0.2)) {
|
|
|
996 |
adjv->list.s[i++] = "not ";
|
|
|
997 |
adjv->list.s[i++] = "un";
|
|
|
998 |
}
|
|
|
999 |
if (prob(makeup)) {
|
|
|
1000 |
adjv->list.s[i] = CHOOSE(adjlist);
|
|
|
1001 |
return adjv;
|
|
|
1002 |
}
|
|
|
1003 |
adjv->list.s[i++] = prefix();
|
|
|
1004 |
adjv->list.s[i++] = root();
|
|
|
1005 |
adjv->list.s[i] = CHOOSE(suff);
|
|
|
1006 |
return adjv;
|
|
|
1007 |
}
|
|
|
1008 |
|
|
|
1009 |
X
|
|
|
1010 |
adjph(env)
|
|
|
1011 |
E env;
|
|
|
1012 |
{
|
|
|
1013 |
X adjv = getxx();
|
|
|
1014 |
EE nenv;
|
|
|
1015 |
static EE empty;
|
|
|
1016 |
int i = 0;
|
|
|
1017 |
adjv->type = "adjph";
|
|
|
1018 |
if (prob(0.25)) {
|
|
|
1019 |
nenv = *env;
|
|
|
1020 |
nenv.tense = 0;
|
|
|
1021 |
adjv->list.x[i++] = rel();
|
|
|
1022 |
adjv->list.x[i++] = aux(&nenv);
|
|
|
1023 |
adjv->list.x[i] = vp(&nenv);
|
|
|
1024 |
return adjv;
|
|
|
1025 |
}
|
|
|
1026 |
nenv = empty;
|
|
|
1027 |
adjv->list.x[i++] = prep();
|
|
|
1028 |
adjv->list.x[i] = np(&nenv);
|
|
|
1029 |
return adjv;
|
|
|
1030 |
}
|
|
|
1031 |
|
|
|
1032 |
static char *preplist[] = {"across", "by", "in", "of",
|
|
|
1033 |
"near", "under", "over",
|
|
|
1034 |
"in back of", "below", "behind", "of", "of", "of", "of",
|
|
|
1035 |
"centered around", "centered about",
|
|
|
1036 |
"in close proximity to", "following after",
|
|
|
1037 |
"in between", "in conflict with", "in conjunction with",
|
|
|
1038 |
"in the area of", "in the neighborhood of", "in the proximity of",
|
|
|
1039 |
"in the field of", "for the purpose of",
|
|
|
1040 |
"giving rise to", "based upon", "being caused by",
|
|
|
1041 |
"of", "of", "of", "of",
|
|
|
1042 |
"being effectuated by", "being aggrevated by",
|
|
|
1043 |
"being used with",
|
|
|
1044 |
"being collected together with", "being combined together with",
|
|
|
1045 |
"connected up to", "exhibiting a tendency towards",
|
|
|
1046 |
"being facilitated by",
|
|
|
1047 |
"being employed with",
|
|
|
1048 |
"having a deleterious effect upon", "impacting",
|
|
|
1049 |
"being joined together with", "being merged together with",
|
|
|
1050 |
"in the vicinity of"};
|
|
|
1051 |
|
|
|
1052 |
X
|
|
|
1053 |
prep(void) {
|
|
|
1054 |
X pv = getxx();
|
|
|
1055 |
pv->type = "-prep";
|
|
|
1056 |
pv->list.s[0] = CHOOSE(preplist);
|
|
|
1057 |
return pv;
|
|
|
1058 |
}
|
|
|
1059 |
|
|
|
1060 |
X
|
|
|
1061 |
comp(env)
|
|
|
1062 |
E env;
|
|
|
1063 |
{
|
|
|
1064 |
X v = getxx();
|
|
|
1065 |
EE nenv;
|
|
|
1066 |
static EE empty;
|
|
|
1067 |
int i = 0;
|
|
|
1068 |
nenv = empty;
|
|
|
1069 |
v->type = "comp";
|
|
|
1070 |
if (0 && prob(0.001))
|
|
|
1071 |
v->list.x[i++] = adjective();
|
|
|
1072 |
else if (prob(0.1))
|
|
|
1073 |
v->list.x[i++] = advp(&nenv);
|
|
|
1074 |
else {
|
|
|
1075 |
if (env->passive)
|
|
|
1076 |
v->list.x[i++] = passprep();
|
|
|
1077 |
v->list.x[i++] = np(&nenv);
|
|
|
1078 |
env->passive = 0;
|
|
|
1079 |
}
|
|
|
1080 |
if (0 && prob(0.05))
|
|
|
1081 |
v->list.x[i++] = adverb();
|
|
|
1082 |
USED(i);
|
|
|
1083 |
return v;
|
|
|
1084 |
}
|
|
|
1085 |
|
|
|
1086 |
X
|
|
|
1087 |
advp(env)
|
|
|
1088 |
E env;
|
|
|
1089 |
{
|
|
|
1090 |
X v = getxx();
|
|
|
1091 |
v->type = "advp";
|
|
|
1092 |
v->list.x[0] = vprep();
|
|
|
1093 |
v->list.x[1] = np(env);
|
|
|
1094 |
return v;
|
|
|
1095 |
}
|
|
|
1096 |
|
|
|
1097 |
static char *vpreplist[] = {"to", "at", "by", "from", "with", "for"};
|
|
|
1098 |
|
|
|
1099 |
X
|
|
|
1100 |
vprep(void) {
|
|
|
1101 |
X v = getxx();
|
|
|
1102 |
v->type = "-vprep";
|
|
|
1103 |
v->list.s[0] = CHOOSE(vpreplist);
|
|
|
1104 |
return v;
|
|
|
1105 |
}
|
|
|
1106 |
|
|
|
1107 |
E
|
|
|
1108 |
getenvq()
|
|
|
1109 |
{
|
|
|
1110 |
static EE empty;
|
|
|
1111 |
E v;
|
|
|
1112 |
v = (E) malloc(sizeof *v);
|
|
|
1113 |
if (v == 0) {
|
|
|
1114 |
print("outa room\n");
|
|
|
1115 |
exits("room");
|
|
|
1116 |
}
|
|
|
1117 |
*v = empty;
|
|
|
1118 |
return v;
|
|
|
1119 |
}
|
|
|
1120 |
|
|
|
1121 |
X
|
|
|
1122 |
comma(env)
|
|
|
1123 |
E env;
|
|
|
1124 |
{
|
|
|
1125 |
X v = getxx();
|
|
|
1126 |
static EE empty;
|
|
|
1127 |
|
|
|
1128 |
v->type = "-comma";
|
|
|
1129 |
v->list.s[0] = ",";
|
|
|
1130 |
*env = empty;
|
|
|
1131 |
return v;
|
|
|
1132 |
}
|
|
|
1133 |
|
|
|
1134 |
static char *conjadvlist[] = {"we believe", "naturally", "therefore",
|
|
|
1135 |
"moreover", "obviously"};
|
|
|
1136 |
|
|
|
1137 |
X
|
|
|
1138 |
conjadv(void) {
|
|
|
1139 |
X v = getxx();
|
|
|
1140 |
|
|
|
1141 |
v->type = "-conjadv";
|
|
|
1142 |
v->list.s[0] = CHOOSE(conjadvlist);
|
|
|
1143 |
return v;
|
|
|
1144 |
}
|
|
|
1145 |
|
|
|
1146 |
static char *lconjlist[] = {"therefore", "however", "nevertheless",
|
|
|
1147 |
"consequently", "also", "in addition", "moreover",
|
|
|
1148 |
"accordingly", "essentially", "presumably", "actually",
|
|
|
1149 |
"basically", "importantly", "clearly", "obviously",
|
|
|
1150 |
"needless to say", "as already stated",
|
|
|
1151 |
"generally", "approximately", "presently",
|
|
|
1152 |
"hopefully", "usually", "in the great majority of cases",
|
|
|
1153 |
"seen in the above light", "most significantly",
|
|
|
1154 |
"when the need arises",
|
|
|
1155 |
"in a large number of cases", "after this is accomplished",
|
|
|
1156 |
"in all cases",
|
|
|
1157 |
"having been made aware concerning these matters",
|
|
|
1158 |
"as an example of this", "as a consequence of this",
|
|
|
1159 |
"as a matter of fact", "as is often the case",
|
|
|
1160 |
"as of this date", "assuming that this is the case",
|
|
|
1161 |
"at the present moment in time", "at this time",
|
|
|
1162 |
"as a consequent result of this", "as a desireable benefit of this",
|
|
|
1163 |
"if at all possible", "similarly", "in the same connection",
|
|
|
1164 |
"in large measure", "in many cases", "in rare cases",
|
|
|
1165 |
"in some cases", "in the interim", "in the last analysis",
|
|
|
1166 |
"in light of these facts", "in the majority of instances",
|
|
|
1167 |
"in the not too distant future", "in the same way as described above",
|
|
|
1168 |
"in this case", "for all intents and purposes",
|
|
|
1169 |
"to arrive at an approximation", "for this reason",
|
|
|
1170 |
"for many reasons, then",
|
|
|
1171 |
"as is often the case", "last but not least",
|
|
|
1172 |
"later on", "on a few occasions", "on this occasion",
|
|
|
1173 |
"in summary", "taking this into consideration",
|
|
|
1174 |
"with this in mind",
|
|
|
1175 |
"substantially", "ultimately"};
|
|
|
1176 |
|
|
|
1177 |
X
|
|
|
1178 |
lconjadv(void) {
|
|
|
1179 |
|
|
|
1180 |
X v = getxx();
|
|
|
1181 |
v->type = "-lconjadv";
|
|
|
1182 |
v->list.s[0] = CHOOSE(lconjlist);
|
|
|
1183 |
return v;
|
|
|
1184 |
}
|
|
|
1185 |
|
|
|
1186 |
X
|
|
|
1187 |
conjsub(void) {
|
|
|
1188 |
static char *conjsublist[] = {"although", "even though",
|
|
|
1189 |
"despite the fact that",
|
|
|
1190 |
"for the simple reason that",
|
|
|
1191 |
"because", "due to the fact that", "since",
|
|
|
1192 |
"whether or not",
|
|
|
1193 |
"inasmuch as",
|
|
|
1194 |
"as"};
|
|
|
1195 |
X v = getxx();
|
|
|
1196 |
v->type = "-conjsub";
|
|
|
1197 |
v->list.s[0] = CHOOSE(conjsublist);
|
|
|
1198 |
return v;
|
|
|
1199 |
}
|
|
|
1200 |
|
|
|
1201 |
static char *lconjsublist[] = {"although", "even though",
|
|
|
1202 |
"despite the fact that",
|
|
|
1203 |
"because", "due to the fact that", "since",
|
|
|
1204 |
"if", "anytime that", "in the case that",
|
|
|
1205 |
"as a consequence of the fact that",
|
|
|
1206 |
"as regards the fact that",
|
|
|
1207 |
"as a desireable benefit of the fact that",
|
|
|
1208 |
"with reference to the fact that",
|
|
|
1209 |
"as long as",
|
|
|
1210 |
"as an important essential of the fact that",
|
|
|
1211 |
"in conjunction with the fact that",
|
|
|
1212 |
"in the light of the fact that",
|
|
|
1213 |
"if", "if", "if", "if",
|
|
|
1214 |
"leaving out of consideration the fact that",
|
|
|
1215 |
"just as",
|
|
|
1216 |
"inasmuch as", "until such time as",
|
|
|
1217 |
"as soon as", "being as", "in the same way as",
|
|
|
1218 |
"with the exception of the fact that",
|
|
|
1219 |
"notwithstanding the fact that",
|
|
|
1220 |
"on the grounds that",
|
|
|
1221 |
"on the basis of the fact that",
|
|
|
1222 |
"persuant to the fact that",
|
|
|
1223 |
"although it seems apparent that",
|
|
|
1224 |
"with regard to the fact that",
|
|
|
1225 |
"as can be seen from the fact that",
|
|
|
1226 |
"as"};
|
|
|
1227 |
|
|
|
1228 |
X
|
|
|
1229 |
lconjsub(void) {
|
|
|
1230 |
X v = getxx();
|
|
|
1231 |
v->type = "-lconjsub";
|
|
|
1232 |
v->list.s[0] = CHOOSE(lconjsublist);
|
|
|
1233 |
return v;
|
|
|
1234 |
}
|
|
|
1235 |
|
|
|
1236 |
static char *conjlist[] = {"and", "but", "yet", "and", "and"};
|
|
|
1237 |
|
|
|
1238 |
X
|
|
|
1239 |
conj(void) {
|
|
|
1240 |
X v = getxx();
|
|
|
1241 |
v->type = "-conj";
|
|
|
1242 |
v->list.s[0] = CHOOSE(conjlist);
|
|
|
1243 |
return v;
|
|
|
1244 |
}
|
|
|
1245 |
static char *nomzlist[] = {"it is easy to see that",
|
|
|
1246 |
"it is a basic fact that",
|
|
|
1247 |
"it is obvious that", "it is not unimportant that",
|
|
|
1248 |
"it is easy to overlook the fact that",
|
|
|
1249 |
"it is within the realm of possibility that",
|
|
|
1250 |
"it is apparent that",
|
|
|
1251 |
"this is indicitive of the fact that",
|
|
|
1252 |
"this is in substantial agreement with the fact that",
|
|
|
1253 |
"this demonstrates the fact that",
|
|
|
1254 |
"this leaves out of consideration the fact that",
|
|
|
1255 |
"it is of the utmost importance that",
|
|
|
1256 |
"the truth is that",
|
|
|
1257 |
"the fact is that",
|
|
|
1258 |
"it turns out that", "it will turn out to be true that",
|
|
|
1259 |
"it should be noted that",
|
|
|
1260 |
"it stands to reason that",
|
|
|
1261 |
"it would not be unreasonable to assume that",
|
|
|
1262 |
"it is interesting to note that",
|
|
|
1263 |
"this can be proved by:",
|
|
|
1264 |
"this is a trivial consequence of",
|
|
|
1265 |
"it is assumed that",
|
|
|
1266 |
"it remains to be shown that",
|
|
|
1267 |
"it is left to the reader to prove"
|
|
|
1268 |
};
|
|
|
1269 |
|
|
|
1270 |
X
|
|
|
1271 |
nomz(void) {
|
|
|
1272 |
X v = getxx();
|
|
|
1273 |
v->type = "-nomz";
|
|
|
1274 |
v->list.s[0] = CHOOSE(nomzlist);
|
|
|
1275 |
return v;
|
|
|
1276 |
}
|
|
|
1277 |
|
|
|
1278 |
X
|
|
|
1279 |
equation(void) {
|
|
|
1280 |
X v = getxx();
|
|
|
1281 |
static char eqnbuff[100], x;
|
|
|
1282 |
static char *eqnelem[] = {"int", "sum", "prod", "union", "inter"};
|
|
|
1283 |
static char *eqnfn[] = { "sin", "cos", "tan", "arc", "det",
|
|
|
1284 |
"log", "exp", "f", "g", "sinh", "O", "J sub 0", "J sub 1",
|
|
|
1285 |
"P sub i", "gamma", "zeta" };
|
|
|
1286 |
static char *eqnval[] = { "0", "DELTA", "GAMMA", "LAMBDA",
|
|
|
1287 |
"OMEGA", "PHI", "PSI", "SIGMA", "THETA", "UPSILON",
|
|
|
1288 |
"XI", "alpha", "beta", "gamma", "delta", "epsilon",
|
|
|
1289 |
"eta", "kappa","lambda", "mu", "omega", "x", "zeta", "inf"};
|
|
|
1290 |
static char *eqnrel[] = {"=", "<=", ">=", "==", "!=", "approx"};
|
|
|
1291 |
|
|
|
1292 |
x = 'a' + (R)%26;
|
|
|
1293 |
v->type = "-eqn";
|
|
|
1294 |
sprint(eqnbuff,"$%s from %c=%d to %s %s ( %c ) d%c %s %s$",
|
|
|
1295 |
CHOOSE(eqnelem), x, (R)&077, CHOOSE(eqnval), CHOOSE(eqnfn),
|
|
|
1296 |
x, x, CHOOSE(eqnrel), CHOOSE(eqnval));
|
|
|
1297 |
v->list.s[0] = eqnbuff;
|
|
|
1298 |
return v;
|
|
|
1299 |
}
|
|
|
1300 |
|
|
|
1301 |
X
|
|
|
1302 |
turgid(env)
|
|
|
1303 |
E env;
|
|
|
1304 |
{
|
|
|
1305 |
X v = getxx();
|
|
|
1306 |
int i = 0;
|
|
|
1307 |
|
|
|
1308 |
v->type = "turgid";
|
|
|
1309 |
if (prob(T * 1.5)) {
|
|
|
1310 |
v->list.x[i++] = lconjadv();
|
|
|
1311 |
v->list.x[i++] = comma(env);
|
|
|
1312 |
v->list.x[i++] = sent(env);
|
|
|
1313 |
} else if (prob(2 * T)) {
|
|
|
1314 |
v->list.x[i++] = turgid(env);
|
|
|
1315 |
v->list.x[i++] = comma(env);
|
|
|
1316 |
v->list.x[i++] = conj();
|
|
|
1317 |
v->list.x[i++] = sent(env);
|
|
|
1318 |
} else if (prob(1.5 * T)) {
|
|
|
1319 |
v->list.x[i++] = lconjsub();
|
|
|
1320 |
v->list.x[i++] = sent(env);
|
|
|
1321 |
v->list.x[i++] = comma(env);
|
|
|
1322 |
v->list.x[i++] = sent(env);
|
|
|
1323 |
} else if (prob(T * .5)) {
|
|
|
1324 |
v->list.x[i++] = sent(env);
|
|
|
1325 |
v->list.x[i++] = comma(env);
|
|
|
1326 |
v->list.x[i++] = conjadv();
|
|
|
1327 |
} else if (prob(T)) {
|
|
|
1328 |
v->list.x[i++] = turgid(env);
|
|
|
1329 |
v->list.x[i++] = comma(env);
|
|
|
1330 |
v->list.x[i++] = conjsub();
|
|
|
1331 |
v->list.x[i++] = sent(env);
|
|
|
1332 |
} else if (prob(.5 * T)) {
|
|
|
1333 |
v->list.x[i++] = nomz();
|
|
|
1334 |
if (eqn && prob(.5)) {
|
|
|
1335 |
v->list.x[i++] = equation();
|
|
|
1336 |
v->list.x[i++] = comma(env);
|
|
|
1337 |
v->list.x[i++] = conj();
|
|
|
1338 |
}
|
|
|
1339 |
v->list.x[i++] = sent(env);
|
|
|
1340 |
} else
|
|
|
1341 |
v->list.x[i++] = sent(env);
|
|
|
1342 |
USED(i);
|
|
|
1343 |
return v;
|
|
|
1344 |
}
|
|
|
1345 |
|
|
|
1346 |
char *
|
|
|
1347 |
splitup(char *strlab) {
|
|
|
1348 |
static char label[64];
|
|
|
1349 |
int j, c;
|
|
|
1350 |
|
|
|
1351 |
label[0]='"';
|
|
|
1352 |
for (j=1; j<60 &&
|
|
|
1353 |
(c = *strlab++) != '\0'; j++)
|
|
|
1354 |
if (c == ' ') {
|
|
|
1355 |
label[j++]='"';
|
|
|
1356 |
label[j++]=' ';
|
|
|
1357 |
label[j]='"';
|
|
|
1358 |
}
|
|
|
1359 |
else
|
|
|
1360 |
label[j] = c;
|
|
|
1361 |
label[j++] = '"'; label[j] = '\0';
|
|
|
1362 |
return(label);
|
|
|
1363 |
}
|
|
|
1364 |
|
|
|
1365 |
void
|
|
|
1366 |
abo(void) {
|
|
|
1367 |
fprint(2, "usage: festoon [-pet] [-sSEED] [SENTENCES] [%%-invented-nouns]\n");
|
|
|
1368 |
exits("usage");
|
|
|
1369 |
}
|
|
|
1370 |
|
|
|
1371 |
void
|
|
|
1372 |
caps(void) {
|
|
|
1373 |
int i;
|
|
|
1374 |
for (i = 1; i < io; i++)
|
|
|
1375 |
if (buff[i - 1] == ' ' && buff[i] <= 'z' && buff[i] >= 'a')
|
|
|
1376 |
buff[i] += 'A' - 'a';
|
|
|
1377 |
}
|
|
|
1378 |
|
|
|
1379 |
void
|
|
|
1380 |
main(int argc, char *argv[]) {
|
|
|
1381 |
static char *furniture[] = {"WASTEBASKET", "ASHTRAY", "TABLE",
|
|
|
1382 |
"DESK DRAWER", "COAT LOCKER", "BOOKSHELF"};
|
|
|
1383 |
|
|
|
1384 |
static char *ccto[] = {
|
|
|
1385 |
"J. N. Akkerhuis",
|
|
|
1386 |
"J. J. Argosy",
|
|
|
1387 |
"M. D. Banal",
|
|
|
1388 |
"H. V. Bandersnatch",
|
|
|
1389 |
"L. Bimmler",
|
|
|
1390 |
"F. W. Blivet",
|
|
|
1391 |
"Z. Brazen",
|
|
|
1392 |
"M. Bushido",
|
|
|
1393 |
"J. D. Carbuncle",
|
|
|
1394 |
"N. Crab",
|
|
|
1395 |
"R. H. deTruckle",
|
|
|
1396 |
"R. L. Drechsler",
|
|
|
1397 |
"C. B. Dudgeon",
|
|
|
1398 |
"R. T. Dun",
|
|
|
1399 |
"G. R. Emlin",
|
|
|
1400 |
"W. G. Fallow",
|
|
|
1401 |
"R. S. Flummox",
|
|
|
1402 |
"R. N. Fribble",
|
|
|
1403 |
"C. R. Glitch",
|
|
|
1404 |
"R. H. Hardin",
|
|
|
1405 |
"S. A. Hobble",
|
|
|
1406 |
"B. W. Kernighan",
|
|
|
1407 |
"D. B. Knudsen",
|
|
|
1408 |
"C. L'Hommedieu",
|
|
|
1409 |
"R. S. Limn",
|
|
|
1410 |
"S. T. Livid",
|
|
|
1411 |
"Mrs. B. R. Mauve",
|
|
|
1412 |
"C. Mee",
|
|
|
1413 |
"N-P. Nelson",
|
|
|
1414 |
"C. H. Russet",
|
|
|
1415 |
"M. Shayegan",
|
|
|
1416 |
"M. H. Simper",
|
|
|
1417 |
"B. R. Sorrel",
|
|
|
1418 |
"G. Swale",
|
|
|
1419 |
"R. R. Swarthy",
|
|
|
1420 |
"P. Terra-Cotta",
|
|
|
1421 |
"U. G. Winnow"};
|
|
|
1422 |
|
|
|
1423 |
static char *picelem[] = { "box", "ellipse", "box", "box"};
|
|
|
1424 |
static char *piccon[] = { "arrow", "line", "line <-", "line <->",
|
|
|
1425 |
"spline", "spline <-", "spline <->"};
|
|
|
1426 |
static char *picdir[] = { "right", "down right", "down",
|
|
|
1427 |
"left", "up left", "left", "down", "down right", nil};
|
|
|
1428 |
E env;
|
|
|
1429 |
X tree;
|
|
|
1430 |
int i, j = 0, k = 0;
|
|
|
1431 |
int lim = 0;
|
|
|
1432 |
long t = 0;
|
|
|
1433 |
char c, **str;
|
|
|
1434 |
int junk, junk2;
|
|
|
1435 |
|
|
|
1436 |
for (i = 1, ++argv; i < argc; i++, argv++)
|
|
|
1437 |
if (*argv[0] == '-') /* -pet -snnn */
|
|
|
1438 |
while (c = *++argv[0])
|
|
|
1439 |
switch (c) {
|
|
|
1440 |
case 'z':
|
|
|
1441 |
flag = 1;
|
|
|
1442 |
continue;
|
|
|
1443 |
case 'p':
|
|
|
1444 |
pic = 1;
|
|
|
1445 |
continue;
|
|
|
1446 |
case 't':
|
|
|
1447 |
tbl = 1;
|
|
|
1448 |
continue;
|
|
|
1449 |
case 'e':
|
|
|
1450 |
eqn = 1;
|
|
|
1451 |
continue;
|
|
|
1452 |
case 's':
|
|
|
1453 |
t = atoi(argv[0]+1); argv[0][1] = '\0';
|
|
|
1454 |
continue;
|
|
|
1455 |
default:
|
|
|
1456 |
abo(); /* illegal option */
|
|
|
1457 |
}
|
|
|
1458 |
else if (lim == 0)
|
|
|
1459 |
lim = atoi(argv[0]);
|
|
|
1460 |
else
|
|
|
1461 |
makeup = 1.0 - (float) atoi(argv[0]) / 100.0;
|
|
|
1462 |
USED(i);
|
|
|
1463 |
if (t == 0)
|
|
|
1464 |
time(&t);
|
|
|
1465 |
if (makeup < 0. || makeup > 1.0)
|
|
|
1466 |
makeup = 1.0;
|
|
|
1467 |
if (lim <= 0)
|
|
|
1468 |
lim = 25;
|
|
|
1469 |
srand((int) t);
|
|
|
1470 |
|
|
|
1471 |
print(".TL\n");
|
|
|
1472 |
env = getenvq();
|
|
|
1473 |
tree = np(env);
|
|
|
1474 |
io = 0;
|
|
|
1475 |
pr(tree);
|
|
|
1476 |
buff[io] = 0;
|
|
|
1477 |
caps();
|
|
|
1478 |
print("%s\n", buff);
|
|
|
1479 |
print(".AU \"C. C. Festoon\" CCF Headquarters %ld\n", t);
|
|
|
1480 |
if (eqn)
|
|
|
1481 |
print(".EQ\ndelim $$\n.EN\n");
|
|
|
1482 |
print(".AS\n");
|
|
|
1483 |
free(env);
|
|
|
1484 |
do {
|
|
|
1485 |
env = getenvq();
|
|
|
1486 |
tree = turgid(env);
|
|
|
1487 |
io = 0;
|
|
|
1488 |
pr(tree);
|
|
|
1489 |
buff[io] = 0;
|
|
|
1490 |
print("%s.\n", buff);
|
|
|
1491 |
free(env);
|
|
|
1492 |
} while (prob(0.75));
|
|
|
1493 |
print(".AE\n");
|
|
|
1494 |
print(".MT \"MEMORANDUM FOR %s\"\n.hy 1\n",
|
|
|
1495 |
CHOOSE(furniture));
|
|
|
1496 |
while (i++ < lim) {
|
|
|
1497 |
if (i % 23 == 0) { /* Time for a section header */
|
|
|
1498 |
env = getenvq();
|
|
|
1499 |
tree = np(env);
|
|
|
1500 |
io = 0;
|
|
|
1501 |
print(".H 1 \"");
|
|
|
1502 |
pr(tree);
|
|
|
1503 |
buff[io] = 0;
|
|
|
1504 |
caps();
|
|
|
1505 |
print("%s\"\n", buff);
|
|
|
1506 |
free(env);
|
|
|
1507 |
}
|
|
|
1508 |
if (i % 27 == 0 && pic) { /* Time for a picture */
|
|
|
1509 |
print(".DS CB\n.ps -1\n.PS\n");
|
|
|
1510 |
str = &(CHOOSE(picdir));
|
|
|
1511 |
if (*str == nil) str = &picdir[0];
|
|
|
1512 |
junk2 = (R&07) + 3;
|
|
|
1513 |
for(junk = 1; junk < junk2; junk++) {
|
|
|
1514 |
print("%s; ", *str);
|
|
|
1515 |
if (str == &picdir[0]) {
|
|
|
1516 |
pic = 2; print("A: ");
|
|
|
1517 |
}
|
|
|
1518 |
print("%s %s ht %3.1f wid %3.1f\n",
|
|
|
1519 |
CHOOSE(picelem), splitup(CHOOSE(nounlist)),
|
|
|
1520 |
0.4+0.5/junk2, 0.8+0.6/junk2);
|
|
|
1521 |
print("%s %s %3.1f ",
|
|
|
1522 |
CHOOSE(piccon), *str, 0.2+.3/junk2);
|
|
|
1523 |
if (*++str == nil) str = &picdir[0];
|
|
|
1524 |
print("then %s %3.1f %s\n",
|
|
|
1525 |
*str, 0.3+.2/junk2,
|
|
|
1526 |
splitup(CHOOSE(adjlist)));
|
|
|
1527 |
}
|
|
|
1528 |
print("circle rad .3 \"process\" \"completion\"\n");
|
|
|
1529 |
if (pic == 2) {
|
|
|
1530 |
pic =1;
|
|
|
1531 |
print("line <- dashed up .25 from A.n\n");
|
|
|
1532 |
print("circle rad .3 \"process\" \"start\"\n");
|
|
|
1533 |
}
|
|
|
1534 |
print(".PE\n.ps +1\n.DE\n");
|
|
|
1535 |
print(".ce\n\\fBFigure %d\\fP\n", i/27);
|
|
|
1536 |
}
|
|
|
1537 |
if (i % 41 == 0 && tbl) { /* Time for a table */
|
|
|
1538 |
print(".TS\n");
|
|
|
1539 |
print("box, center;\nc\ts\ts\n");
|
|
|
1540 |
print("n | l | lw(%3.1fi).\n", 2.0+(41.0+(t&07))/i);
|
|
|
1541 |
print("Action Plan %d\n=\n", i);
|
|
|
1542 |
print("Item\tWho\tAction\n");
|
|
|
1543 |
for (junk = 1; junk < (i&17)+4; junk++) {
|
|
|
1544 |
print("_\n%ld\t", t/i+junk);
|
|
|
1545 |
print("%s\tT{\n", CHOOSE(ccto));
|
|
|
1546 |
env = getenvq();
|
|
|
1547 |
io = 0;
|
|
|
1548 |
tree = sent(env);
|
|
|
1549 |
pr(tree);
|
|
|
1550 |
buff[io] = 0;
|
|
|
1551 |
print("%s.\nT}\n", buff);
|
|
|
1552 |
free(env);
|
|
|
1553 |
}
|
|
|
1554 |
print(".TE\n");
|
|
|
1555 |
print(".ce\n\\fBTable %d\\fP\n", i/41);
|
|
|
1556 |
}
|
|
|
1557 |
env = getenvq();
|
|
|
1558 |
tree = turgid(env);
|
|
|
1559 |
io = 0;
|
|
|
1560 |
pr(tree);
|
|
|
1561 |
buff[io] = 0;
|
|
|
1562 |
if (++k % 13 == 0 && prob(0.35)) { /* Bullet list */
|
|
|
1563 |
print("%s:\n", buff);
|
|
|
1564 |
print(".BL\n");
|
|
|
1565 |
do {
|
|
|
1566 |
print(".LI\n");
|
|
|
1567 |
free(env);
|
|
|
1568 |
env = getenvq();
|
|
|
1569 |
io = 0;
|
|
|
1570 |
tree = sent(env);
|
|
|
1571 |
pr(tree);
|
|
|
1572 |
buff[io] = 0;
|
|
|
1573 |
print("%s.\n", buff);
|
|
|
1574 |
} while (prob(.83));
|
|
|
1575 |
print(".LE\n");
|
|
|
1576 |
print(".P\n");
|
|
|
1577 |
} else {
|
|
|
1578 |
if (k % 11 == 0 && prob(.21)) { /* do as footnote */
|
|
|
1579 |
print("%s\\*F.\n", buff);
|
|
|
1580 |
free(env);
|
|
|
1581 |
env = getenvq();
|
|
|
1582 |
io = 0;
|
|
|
1583 |
tree = sent(env);
|
|
|
1584 |
pr(tree);
|
|
|
1585 |
buff[io] = 0;
|
|
|
1586 |
print(".FS\n%s.\n.FE\n", buff);
|
|
|
1587 |
}
|
|
|
1588 |
else print("%s.\n", buff); /* normal flush */
|
|
|
1589 |
}
|
|
|
1590 |
if (++j > 2 && prob(0.4))
|
|
|
1591 |
print(".P\n"), j = 0;
|
|
|
1592 |
free(env);
|
|
|
1593 |
}
|
|
|
1594 |
USED(i);
|
|
|
1595 |
print(".SG\n");
|
|
|
1596 |
print(".NS 0\n");
|
|
|
1597 |
for (j = 0; j == 0;) {
|
|
|
1598 |
for (i = 0; i < sizeof ccto / sizeof *ccto; i++) {
|
|
|
1599 |
if (prob(.10))
|
|
|
1600 |
j = 1, print("%s\n", ccto[i]);
|
|
|
1601 |
}
|
|
|
1602 |
}
|
|
|
1603 |
print(".NE\n");
|
|
|
1604 |
USED(i);
|
|
|
1605 |
exits("");
|
|
|
1606 |
}
|
|
|
1607 |
|
|
|
1608 |
void
|
|
|
1609 |
pr(tree)
|
|
|
1610 |
X tree;
|
|
|
1611 |
{
|
|
|
1612 |
int i;
|
|
|
1613 |
if (flag ) {
|
|
|
1614 |
out("<");
|
|
|
1615 |
out(tree->type);
|
|
|
1616 |
out(">");
|
|
|
1617 |
}
|
|
|
1618 |
if (tree->type[0] == '-') {
|
|
|
1619 |
out(" ");
|
|
|
1620 |
for (i = 0; tree->list.s[i]; i++) {
|
|
|
1621 |
out(tree->list.s[i]);
|
|
|
1622 |
}
|
|
|
1623 |
} else
|
|
|
1624 |
for (i = 0; tree->list.x[i]; i++) {
|
|
|
1625 |
pr(tree->list.x[i]);
|
|
|
1626 |
}
|
|
|
1627 |
free(tree);
|
|
|
1628 |
USED(i);
|
|
|
1629 |
return;
|
|
|
1630 |
}
|
|
|
1631 |
|
|
|
1632 |
void
|
|
|
1633 |
out(s)
|
|
|
1634 |
char *s;
|
|
|
1635 |
{
|
|
|
1636 |
if (io == 0 && *s == ' ')
|
|
|
1637 |
return;
|
|
|
1638 |
if (io == 0) {
|
|
|
1639 |
for (; s[io]; io++)
|
|
|
1640 |
buff[io] = s[io];
|
|
|
1641 |
buff[0] += 'A' - 'a';
|
|
|
1642 |
return;
|
|
|
1643 |
}
|
|
|
1644 |
if ((buff[io - 1] == ' ' || buff[io - 1] == '\n' ) && *s == ' ')
|
|
|
1645 |
return;
|
|
|
1646 |
if (buff[io - 1] == ' ' && *s == ',') {
|
|
|
1647 |
buff[io - 1] = ',';
|
|
|
1648 |
buff[io++] = '\n';
|
|
|
1649 |
return;
|
|
|
1650 |
}
|
|
|
1651 |
if (buff[io - 1] == 'y' && *s == 'i' && s[1] == 'e')
|
|
|
1652 |
io--;
|
|
|
1653 |
else if (*s == buff[io - 1] && *s != 's' && *s != 'n')
|
|
|
1654 |
io--;
|
|
|
1655 |
else if (*s == 'e' && buff[io - 1] == 'a')
|
|
|
1656 |
io--;
|
|
|
1657 |
for (; *s;)
|
|
|
1658 |
buff[io++] = *s++;
|
|
|
1659 |
return;
|
|
|
1660 |
}
|