sys/src/games/festoon.c

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