![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hyde.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / emacs|
Return to hyde.c CVS log | Up to [Research Unix] / researchv9 / cmd / emacs |
1.1 ! root 1: #include <stdio.h> ! 2: #define trace if (traceon) printf ! 3: ! 4: extern FILE *popen(); ! 5: extern char *getenv(); ! 6: extern char *malloc(); ! 7: ! 8: /* HYpothesis Driven Expert */ ! 9: ! 10: struct ref { ! 11: struct ref *next; ! 12: struct defblk *this; ! 13: char *text; ! 14: }; ! 15: struct defblk { ! 16: struct defblk *next; ! 17: char *name; ! 18: int type; ! 19: struct ref *definition; ! 20: }; ! 21: struct conc { ! 22: int weight; ! 23: struct hype *hypo; ! 24: int vector; ! 25: int num; ! 26: struct fact *confirms[]; ! 27: }; ! 28: struct fact { ! 29: struct fact *next; ! 30: struct defblk *name; ! 31: int truth; ! 32: struct concr *setlist; ! 33: }; ! 34: ! 35: struct concr { ! 36: struct concr *next; ! 37: struct conc *this; ! 38: }; ! 39: struct hype { ! 40: struct hype *next; ! 41: struct defblk *name; ! 42: int confid; ! 43: short asked; ! 44: short action; ! 45: struct ref *queries; ! 46: char *text; ! 47: char *explain; ! 48: }; ! 49: ! 50: #define NHASH 255 ! 51: struct defblk *hashtable[NHASH]; ! 52: ! 53: ! 54: #define FACT 1 ! 55: #define HYPO 2 ! 56: #define STRING 3 ! 57: ! 58: #define ASK 1 ! 59: #define SCAN 2 ! 60: #define RUN 3 ! 61: ! 62: #define FUNKNOWN 0 ! 63: #define FTRUE 1 ! 64: #define FFALSE -1 ! 65: ! 66: #define HUNCERTAIN 10 ! 67: #define HTRUE 100 ! 68: #define HFALSE 0 ! 69: ! 70: struct hype *hypes; ! 71: struct fact *facts; ! 72: ! 73: int tot_facts; ! 74: int tot_hypes; ! 75: int traceon = 0; ! 76: FILE *kfile; ! 77: ! 78: #define SYMCHAR 1 ! 79: #define WHITE 2 ! 80: char ctype[128] = { ! 81: 0, 0, 0, 0, 0, 0, 0, 0, ! 82: 0, WHITE, WHITE, 0, 0, 0, 0, 0, ! 83: 0, 0, 0, 0, 0, 0, 0, 0, ! 84: 0, 0, 0, 0, 0, 0, 0, 0, ! 85: WHITE, 0, 0, 0, 0, 0, 0, 0, ! 86: 0, 0, 0, 0, 0, 0, 0, 0, ! 87: SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR, ! 88: SYMCHAR,SYMCHAR,0, 0, 0, 0, 0, 0, ! 89: 0,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR, ! 90: SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR, ! 91: SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR, ! 92: SYMCHAR,SYMCHAR,SYMCHAR,0, 0, 0, 0, SYMCHAR, ! 93: 0 ,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR, ! 94: SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR, ! 95: SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR,SYMCHAR, ! 96: SYMCHAR,SYMCHAR,SYMCHAR,0, 0, 0, 0, 0 ! 97: }; ! 98: #define streq(x,y) (strcmp(x,y) == 0) ! 99: ! 100: struct defblk *getref(name,type,create) ! 101: ! 102: /* Keywords: symbol-table:50 internal-database:50 */ ! 103: ! 104: char *name; ! 105: int type; ! 106: int create; ! 107: { ! 108: int hash; ! 109: char *np; ! 110: struct defblk *defp; ! 111: ! 112: np = name; ! 113: hash = 0; ! 114: while (*np) hash += *np++; ! 115: hash = hash %NHASH; ! 116: defp = hashtable[hash]; ! 117: while (defp && strcmp(name,defp->name)) defp = defp->next; ! 118: if (defp == NULL) { ! 119: struct fact *factp; ! 120: struct hype *hypep; ! 121: ! 122: if (create == 0) return(NULL); ! 123: defp = ((struct defblk *) malloc(sizeof(*defp))); ! 124: defp->next = hashtable[hash]; ! 125: hashtable[hash] = defp; ! 126: defp->name = (char *) malloc(strlen(name)+1); ! 127: strcpy(defp->name,name); ! 128: defp->type = type; ! 129: switch(type) { ! 130: ! 131: case STRING: ! 132: defp->definition = NULL; ! 133: break; ! 134: case FACT: ! 135: ! 136: tot_facts++; ! 137: defp->definition = (struct ref *) malloc(sizeof(*factp)); ! 138: factp = (struct fact *) defp->definition; ! 139: factp->name = defp; ! 140: factp->next = facts; ! 141: facts = factp; ! 142: factp->truth = FUNKNOWN; ! 143: factp->setlist = NULL; ! 144: trace ("Defining fact %s\n",name); ! 145: break; ! 146: case HYPO: ! 147: tot_hypes++; ! 148: defp->definition = (struct ref *) malloc(sizeof(*hypep)); ! 149: hypep = (struct hype *) defp->definition; ! 150: hypep -> name = defp; ! 151: hypep -> next = hypes; ! 152: hypes = hypep; ! 153: hypep -> asked = 0; ! 154: hypep -> confid = HUNCERTAIN; ! 155: hypep -> text = NULL; ! 156: hypep -> explain = NULL; ! 157: hypep -> queries = NULL; ! 158: trace ("Defining hypothesis %s\n",name); ! 159: break; ! 160: } ! 161: } else { ! 162: if (type && (type != defp->type)) { ! 163: fprintf(stderr,"Multiply defined symbol: %s\n",name); ! 164: } ! 165: } ! 166: return(defp); ! 167: } ! 168: ! 169: char expbuf[512]; ! 170: ! 171: char *expcom(oldcom) ! 172: register char *oldcom; ! 173: { ! 174: register char *newcom; ! 175: char symbuf[128]; ! 176: char *symp; ! 177: struct defblk *defp; ! 178: struct fact *factp; ! 179: int infalse; ! 180: newcom = expbuf; ! 181: ! 182: while (*oldcom) { ! 183: switch (*oldcom) { ! 184: ! 185: case '\\': ! 186: *newcom++ = * ++oldcom; ! 187: break; ! 188: case '%': ! 189: oldcom++; ! 190: symp = symbuf; ! 191: while ((ctype[*oldcom] & SYMCHAR)==0) oldcom++; ! 192: while ((ctype[*oldcom] & SYMCHAR)) *symp++ = *oldcom++; ! 193: *symp = 0; ! 194: defp = getref(symbuf,0,0); ! 195: if (defp ) switch(defp->type) { ! 196: case STRING: ! 197: symp = (char *) defp->definition; ! 198: while (*symp) *newcom++ = *symp++; ! 199: oldcom--; ! 200: break; ! 201: case FACT: ! 202: factp = (struct fact *) defp->definition; ! 203: while (*oldcom != '(' ) oldcom++; ! 204: infalse = 0; ! 205: oldcom++; ! 206: while (1) { ! 207: switch (*oldcom) { ! 208: case 0: ! 209: case ')': ! 210: goto done; ! 211: case ':': ! 212: infalse++; ! 213: break; ! 214: case '\\': ! 215: ++oldcom; ! 216: default: ! 217: if (((factp->truth == FTRUE) && (infalse == 0)) || ! 218: ((factp->truth == FFALSE) && (infalse))) { ! 219: ! 220: *newcom++ = *oldcom; ! 221: } ! 222: break; ! 223: } ! 224: oldcom++; ! 225: } ! 226: } else { ! 227: fprintf(stderr,"%s is undefined on expansion",symbuf); ! 228: } ! 229: done: break; ! 230: default: ! 231: *newcom++ = *oldcom; ! 232: } ! 233: oldcom++; ! 234: } ! 235: *newcom= 0; ! 236: trace ("Expanded into %s\n",expbuf); ! 237: return(expbuf); ! 238: } ! 239: ! 240: ! 241: struct hype * curhype() ! 242: { ! 243: struct hype *hype,*rehype; ! 244: int maxhype; ! 245: ! 246: maxhype = HUNCERTAIN; /* Cut off any below this level */ ! 247: rehype = NULL; ! 248: for (hype = hypes; hype; hype = hype-> next) if ((hype->asked==0) && (hype->confid > maxhype)) { ! 249: maxhype = hype->confid; ! 250: rehype = hype; ! 251: } ! 252: trace ("Best hypothesis is %s\n",rehype->name->name); ! 253: return(rehype); ! 254: } ! 255: reset() ! 256: { ! 257: struct fact *factp; ! 258: struct hype *hypep; ! 259: struct defblk *defp; ! 260: int i; ! 261: ! 262: for (i = 0; i < NHASH; i++) { ! 263: for (defp = hashtable[i]; defp; defp = defp->next) { ! 264: if (defp->type == STRING) defp->definition = NULL; ! 265: } ! 266: } ! 267: for (factp = facts; factp; factp = factp->next) factp->truth=FUNKNOWN; ! 268: for (hypep = hypes; hypep; hypep = hypep->next) { ! 269: hypep->confid = HUNCERTAIN; ! 270: hypep->asked = 0; ! 271: } ! 272: defp = getref("start",FACT,1); ! 273: setfact(defp->definition,FTRUE); /* Start up the inference engine */ ! 274: } ! 275: ! 276: askhype(hype) ! 277: struct hype *hype; ! 278: { ! 279: char buf[20]; ! 280: struct defblk *defp; ! 281: struct ref *refp; ! 282: struct fact *factp; ! 283: struct fact *factors[20]; ! 284: int truth[20]; ! 285: int nfact = 0; ! 286: int i; ! 287: char *bufp; ! 288: FILE *fp; ! 289: ! 290: trace ("Asking about hypothesis %s\n",hype->name->name); ! 291: refp = hype->queries; ! 292: while (refp) { ! 293: defp = refp->this; ! 294: if (defp->type == STRING) { ! 295: if (defp->definition) return(0); ! 296: goto setup; ! 297: } ! 298: factp = (struct fact *) defp->definition; ! 299: trace ("Sub-fact %s, state %d\n",factp->name->name,factp->truth); ! 300: if (factp->truth == FUNKNOWN) { ! 301: if (nfact == 0) { ! 302: setup: switch (hype->action) { ! 303: case ASK: printf ("%s\n\n",expcom(hype->text)); ! 304: if (defp->type == STRING) { ! 305: gets(buf); ! 306: defp->definition = (struct ref *) malloc(strlen(buf)+1); ! 307: strcpy(defp->definition,buf); ! 308: return(1); ! 309: } ! 310: break; ! 311: case SCAN: ! 312: fp = fopen(hype->text,"r"); ! 313: trace ("Scanning %s from hypothesis %s\n", hype->text,hype->name->name); ! 314: fmatch(fp,hype->queries); ! 315: fclose(fp); ! 316: return(1); ! 317: case RUN: ! 318: fp = popen(expcom(hype->text),"r"); ! 319: trace ("Running %s from hypothesis %s\n", hype->text,hype->name->name); ! 320: fmatch(fp,hype->queries); ! 321: pclose(fp); ! 322: return(1); ! 323: } ! 324: } ! 325: factors[nfact++] = factp; ! 326: printf (" %d) %s\n",nfact,refp->text); ! 327: } ! 328: refp = refp->next; ! 329: } ! 330: if (nfact == 0) return(0); ! 331: ! 332: printf ("\n? "); ! 333: again: gets(buf); ! 334: for (i = 0; i < nfact; i++) truth[i] = FFALSE; ! 335: for (bufp = buf; *bufp; bufp++) { ! 336: if (*bufp == 't') { ! 337: traceon = !traceon; ! 338: continue; ! 339: } ! 340: if (*bufp == '!') { ! 341: bufp++; ! 342: if (*bufp == 0) { ! 343: bufp = getenv("SHELL"); ! 344: if ((bufp == NULL) || (*bufp == 0)) bufp= "/bin/sh"; ! 345: } ! 346: system (bufp); ! 347: return(askhype(hype)); ! 348: } ! 349: if (*bufp == 'q') return(-1); ! 350: if ((*bufp < '1') || (*bufp > '0'+nfact)) { ! 351: if ((*bufp == ' ') || (*bufp == ',')) continue; ! 352: printf ("Please type all of the numbers that apply\n"); ! 353: goto again; ! 354: } ! 355: truth[*bufp-'1'] = FTRUE; ! 356: } ! 357: for (i = 0; i < nfact; i++) { ! 358: setfact(factors[i],truth[i]); ! 359: } ! 360: return(1); ! 361: } ! 362: ! 363: setfact(factp,truth) ! 364: struct fact *factp; ! 365: int truth; ! 366: { ! 367: struct hype *hype; ! 368: struct conc *concp; ! 369: struct concr *refp; ! 370: int trigger; ! 371: int i; ! 372: ! 373: factp->truth = truth; ! 374: ! 375: trace ("Setting fact %s to %d\n",factp->name->name,truth); ! 376: ! 377: for (refp = factp->setlist; refp; refp = refp ->next) { ! 378: concp = refp->this; ! 379: trigger = 1; ! 380: for (i = 0;(trigger && (i < concp->num)); i++) { ! 381: if (concp->confirms[i]->truth == FUNKNOWN) trigger = 0; ! 382: else { ! 383: if ((concp->vector>>i) & 1) { ! 384: if (concp->confirms[i]->truth == FFALSE) trigger = 0; ! 385: } else { ! 386: if (concp->confirms[i]->truth == FTRUE) trigger = 0; ! 387: } ! 388: } ! 389: } ! 390: if (trigger) { ! 391: sethype(concp->hypo,concp->weight); ! 392: } ! 393: ! 394: } ! 395: } ! 396: ! 397: sethype(hype,weight) ! 398: ! 399: struct hype *hype; ! 400: int weight; ! 401: { ! 402: ! 403: if (hype->name->type == FACT) { ! 404: struct fact *factp; ! 405: factp = (struct fact *) hype; ! 406: if (factp-> truth != FUNKNOWN) return; ! 407: if (weight == 0) { ! 408: setfact(factp,FFALSE); ! 409: } else { ! 410: setfact(factp,FTRUE); ! 411: } ! 412: return; ! 413: } ! 414: if (weight < 0) hype->confid = HTRUE; ! 415: else { ! 416: hype->confid *= weight; ! 417: hype->confid /= 10; ! 418: } ! 419: if (hype->confid > HTRUE) hype->confid = HTRUE; ! 420: trace ("Adjusting hypothesis %s by %d gives %d\n",hype->name->name,weight,hype->confid); ! 421: } ! 422: ! 423: dumplike() ! 424: { ! 425: struct hype *hypo; ! 426: ! 427: for (hypo = hypes; hypo; hypo = hypo->next) { ! 428: hypo->asked = 0; ! 429: } ! 430: while (hypo = curhype()) { ! 431: hypo->asked = 1; ! 432: if (hypo->explain) { ! 433: printf ("The following is a possible cause of your problem:\n\n%s\n",hypo->explain); ! 434: printf ("\nThis explaination has a confidence factor of %d on a scale of %d to %d\n",hypo->confid,HFALSE,HTRUE); ! 435: printf ("_________________________________________________________________________\n"); ! 436: } ! 437: } ! 438: } ! 439: ! 440: cycle() ! 441: { ! 442: struct hype *hypo; ! 443: int ret; ! 444: ! 445: #ifdef DIAGNOSE ! 446: printf ("You will be asked to clarify your problem\n"); ! 447: #endif ! 448: printf ("For each question, please answer with all of the numbers\n"); ! 449: printf ("of the statements that apply. For example 136\n"); ! 450: printf ("if answers 1, 3, and 6 apply. If you would like to quit, type 'q'\n"); ! 451: printf ("If you would like to escape to run a unix commmand, type '!'\n"); ! 452: printf ("or '!command' in response to a question.\n\n"); ! 453: ! 454: while (hypo = curhype()) { ! 455: if (ret= askhype(hypo)) { ! 456: if (ret < 0) return; /* User quit */ ! 457: if (hypo->explain == NULL) hypo->asked = 1; ! 458: } else { ! 459: hypo->asked = 1; ! 460: if (hypo->explain) { ! 461: #ifdef DIAGNOSE ! 462: printf ("The following is a possible cause of your problem:\n\n%s\n",hypo->explain); ! 463: printf ("\nThis explaination has a confidence factor of %d on a scale of %d to %d\n",hypo->confid,HFALSE,HTRUE); ! 464: if (gyn("Would you like to continue to identify other possible causes") == 0) return; ! 465: #else ! 466: printf("%s\n",hypo->explain); ! 467: return(0); ! 468: #endif ! 469: } ! 470: } ! 471: } ! 472: } ! 473: ! 474: gyn(string) ! 475: char *string; ! 476: { ! 477: char buf[100]; ! 478: ! 479: while (1) { ! 480: printf ("%s\n",string); ! 481: if (gets(buf) == NULL) return(0); ! 482: if (buf[0] == 'y') return(1); ! 483: if (buf[0] == 'n') return(0); ! 484: printf ("Please answer with 'yes' or 'no'\n"); ! 485: } ! 486: } ! 487: ! 488: char * ! 489: gstring() ! 490: { ! 491: char buf[512]; ! 492: char *bufp; ! 493: int c; ! 494: ! 495: c = nonblank(); ! 496: if (c != '"') { ! 497: fprintf("Missing character string argument\n"); ! 498: ungetc(c,kfile); ! 499: return; ! 500: } ! 501: bufp = buf; ! 502: while (((c =getc(kfile)) != EOF) && (c != '"')) { ! 503: if (c == '\\') c = getc(kfile); ! 504: *bufp++ = c; ! 505: } ! 506: *bufp++ = 0; ! 507: bufp = malloc(bufp-buf+1); ! 508: strcpy(bufp,buf); ! 509: trace ("Storing character string %s\n",bufp); ! 510: return(bufp); ! 511: } ! 512: ! 513: nonblank() ! 514: { ! 515: int c; ! 516: ! 517: while ((c = getc(kfile)) != EOF) { ! 518: if ((ctype[c] & WHITE) == 0) return(c); ! 519: } ! 520: return(EOF); ! 521: } ! 522: ! 523: int number(sp) ! 524: /* Keywords: string-processing file-scanning:50 user-interface:10 */ ! 525: ! 526: char *sp; ! 527: { ! 528: int n; ! 529: n = 0; ! 530: while (*sp) n = n*10 + (*sp++) -'0'; ! 531: return(n); ! 532: } ! 533: ! 534: char symbuf[64]; ! 535: ! 536: char * symbol() ! 537: { ! 538: int c; ! 539: char *symp; ! 540: ! 541: symp = symbuf; ! 542: ! 543: c = nonblank(); ! 544: while ((c != EOF) && (ctype[c]&SYMCHAR)) { ! 545: *symp++ = c; ! 546: c = getc(kfile); ! 547: } ! 548: if (c == EOF) return(NULL); ! 549: ungetc(c,kfile); ! 550: *symp++ = 0; ! 551: trace ("Reading symbol: %s\n",symbuf); ! 552: return(symbuf); ! 553: } ! 554: ! 555: ! 556: /* Knowledge file formats: */ ! 557: ! 558: ! 559: /* Hypothesis name: { */ ! 560: /* Ask: "text for asking" */ ! 561: /* Scan: "file(s) to scan" */ ! 562: /* Run: "command to run" */ ! 563: /* Replies: { */ ! 564: /* factname: "description" */ ! 565: /* } */ ! 566: /* Read: string */ ! 567: ! 568: /* Explain: "explaination if terminal diagnosis" */ ! 569: ! 570: /* Infer hypothesis <with certaintity number> from { */ ! 571: /* Conclude fact from { */ ! 572: /* fact, or !fact */ ! 573: /* } */ ! 574: ! 575: main(argc, argv) ! 576: ! 577: /* Keywords: user-interface command-line file-scanning:10 file-opening:10 */ ! 578: ! 579: int argc; ! 580: char *argv []; ! 581: ! 582: { ! 583: int i; ! 584: int ktest = 0; ! 585: for (i = 1; i < argc; i++) { ! 586: if (streq(argv[i],"-t")) { ! 587: traceon++; ! 588: i++; ! 589: } ! 590: if (streq(argv[i],"-k")) { ! 591: ktest++; ! 592: i++; ! 593: } ! 594: if (argc>2) printf ("Loading file %s\n",argv[i]); ! 595: parse(argv[i]); ! 596: } ! 597: if (ktest) { ! 598: dumpknow(); ! 599: } ! 600: while (1) { ! 601: reset(); ! 602: cycle(); ! 603: #ifdef DIAGNOSE ! 604: printf ("I can offer no further help with this problem\n"); ! 605: printf ("If you are still having trouble, contact ihnss!warren\n\n"); ! 606: ! 607: if (gyn("Would you like a summary of all likely causes?")) dumplike(); ! 608: if (gyn("Would you like to try another diagnosis?")==0) break; ! 609: #else ! 610: if (gyn("Would you like to do something else?")==0) break; ! 611: #endif ! 612: } ! 613: } ! 614: dumpknow() ! 615: { ! 616: struct fact *factp; ! 617: struct hype *hypep; ! 618: struct ref *refp; ! 619: struct conc *consp; ! 620: struct concr *concrp; ! 621: int header; ! 622: ! 623: reset(); ! 624: header = 0; ! 625: for (factp = facts; factp; factp= factp->next) { ! 626: for (concrp = factp->setlist; concrp; concrp = concrp->next) { ! 627: concrp->this->hypo->asked = 1; ! 628: } ! 629: } ! 630: header = 0; ! 631: for (hypep = hypes; hypep; hypep = hypep->next) { ! 632: if ((hypep->text == NULL)&& (hypep->explain == NULL)) { ! 633: if (header == 0) { ! 634: header = 1; ! 635: printf ("The following hypotheses are never defined:\n"); ! 636: } ! 637: printf (" %s\n",hypep->name->name); ! 638: } ! 639: for (refp = hypep->queries; refp; refp = refp->next) { ! 640: ((struct fact *) refp->this->definition)->truth = FTRUE; ! 641: } ! 642: } ! 643: header = 0; ! 644: for (hypep = hypes; hypep; hypep = hypep->next) { ! 645: if (hypep->asked == 0) { ! 646: if (header == 0) { ! 647: header = 1; ! 648: printf ("The following hypotheses are not inferred by any facts:\n"); ! 649: } ! 650: printf (" %s\n",hypep->name->name); ! 651: } ! 652: } ! 653: header = 0; ! 654: for (factp = facts; factp; factp= factp->next) { ! 655: if (factp->truth == FUNKNOWN) { ! 656: if (header == 0) { ! 657: header = 1; ! 658: printf ("The following facts are never set:\n"); ! 659: } ! 660: printf (" %s\n",factp->name->name); ! 661: } ! 662: } ! 663: header = 0; ! 664: for (factp = facts; factp; factp= factp->next) { ! 665: if (factp->setlist == NULL) { ! 666: if (header == 0) { ! 667: header = 1; ! 668: printf ("The following facts are never used to infer anything:\n"); ! 669: } ! 670: printf (" %s\n",factp->name->name); ! 671: } ! 672: } ! 673: reset(); ! 674: } ! 675: parse(np) ! 676: ! 677: /* Keywords: file-scanning file-opening:10 preprocessor:10 database-input:10 */ ! 678: ! 679: char *np; ! 680: { ! 681: register char *symp; ! 682: char c; ! 683: kfile = fopen(np,"r"); ! 684: ! 685: if (kfile == NULL) { ! 686: fprintf(stderr,"Can't open %s\n",np); ! 687: return; ! 688: } ! 689: ! 690: while (symp = symbol()) { ! 691: if (streq(symp,"Hypothesis")) addhype(); ! 692: else if (streq(symp,"Infer")) addinfer(HYPO); ! 693: else if (streq(symp,"Conclude")) addinfer(FACT); ! 694: else { ! 695: fprintf (stderr,"Bad keyword %s\n",symp); ! 696: c = nonblank(); ! 697: if (ctype[c] & SYMCHAR) ungetc(c,kfile); ! 698: } ! 699: } ! 700: } ! 701: ! 702: addhype() ! 703: { ! 704: register char *sp; ! 705: register struct hype *hypep; ! 706: register struct defblk *defp; ! 707: register struct fact *factp; ! 708: struct ref *refp; ! 709: char c; ! 710: ! 711: sp = symbol(); ! 712: if (sp == NULL) { ! 713: eof: fprintf(stderr,"Unexpected EOF in hypothesis\n"); ! 714: return; ! 715: } ! 716: defp = getref(sp,HYPO,1); ! 717: hypep = (struct hype *) defp->definition; ! 718: c = nonblank(); ! 719: if (c != ':') { ! 720: fprintf(stderr,"Missing ':' after hypothesis name %s\n",sp); ! 721: } ! 722: c = nonblank(); ! 723: if (c != '{') { ! 724: fprintf (stderr,"Empty hypothesis body %s\n",sp); ! 725: } ! 726: while (1) { ! 727: c = nonblank(); ! 728: if ((c == EOF) || (c == '}')) return; ! 729: ungetc(c,kfile); ! 730: sp = symbol(); ! 731: c = nonblank(); ! 732: if (c != ':') { ! 733: fprintf(stderr,"Missing ':' after hypothesis name %s\n",sp); ! 734: } ! 735: if (streq(sp,"Ask")) { ! 736: hypep->text = gstring(); ! 737: hypep->action = ASK; ! 738: } ! 739: else if (streq(sp,"Scan")) { ! 740: hypep->text = gstring(); ! 741: hypep->action = SCAN; ! 742: } ! 743: else if (streq(sp,"Run")) { ! 744: hypep->text = gstring(); ! 745: hypep->action = RUN; ! 746: } else if (streq(sp,"Explain")) { ! 747: hypep->explain = gstring(); ! 748: } else if (streq(sp,"Read")) { ! 749: sp = symbol(); ! 750: defp = getref(sp,STRING,1); ! 751: refp = (struct ref *) malloc(sizeof *refp); ! 752: refp->next = hypep->queries; ! 753: refp->this = defp; ! 754: refp->text = NULL; ! 755: hypep->queries = refp; ! 756: } else if (streq(sp,"Replies")) { ! 757: c = nonblank(); ! 758: if (c != '{') { ! 759: fprintf (stderr,"Empty replies body %s\n",sp); ! 760: } ! 761: while (1) { ! 762: c = nonblank(); ! 763: if (c == '}') break; ! 764: ungetc(c,kfile); ! 765: sp = symbol(); ! 766: c = nonblank(); ! 767: if (c != ':') { ! 768: fprintf(stderr,"Missing ':' after reply name %s\n",sp); ! 769: } ! 770: if ((*sp >= 'A') && (*sp <= 'Z')) { ! 771: ! 772: /* Define a hypothesis and fact of the same name, and make an inference */ ! 773: ! 774: struct hype *infhype; ! 775: struct conc *concp; ! 776: struct concr *concrp; ! 777: ! 778: defp = getref(sp,HYPO,1); ! 779: infhype = (struct hype *) defp->definition; ! 780: *sp += 32; ! 781: defp = getref(sp,FACT,1); ! 782: factp = (struct fact *) defp->definition; ! 783: if (factp->setlist) { ! 784: ! 785: /* Already exists, assume the infers part does to */ ! 786: goto makeref; /* Join other branch to make this reference to it. */ ! 787: } ! 788: concrp = (struct concr *) malloc(sizeof *concrp); ! 789: factp->setlist = concrp; ! 790: concp = (struct conc *) malloc((sizeof *concp) + (sizeof factp)); ! 791: concrp->this = concp; ! 792: concrp->next = NULL; ! 793: concp -> weight = -1; ! 794: concp ->hypo = infhype; ! 795: concp -> vector = 1; ! 796: concp -> num = 1; ! 797: concp ->confirms[0] = factp; ! 798: } else { ! 799: defp = getref(sp,FACT,1); ! 800: factp = (struct fact *) defp->definition; ! 801: } ! 802: makeref: ! 803: c = nonblank(); ! 804: ungetc(c,kfile); ! 805: refp = (struct ref *) malloc(sizeof *refp); ! 806: refp -> next = hypep -> queries; ! 807: hypep->queries = refp; ! 808: refp->this = defp; ! 809: if (c == '"') { ! 810: refp->text = gstring(); ! 811: } ! 812: } ! 813: } else { ! 814: fprintf (stderr,"Bad Keyword %s\n",sp); ! 815: } ! 816: } ! 817: } ! 818: addinfer(type) ! 819: int type; ! 820: { ! 821: struct hype *hypep; ! 822: struct fact *factp; ! 823: struct conc *concp; ! 824: struct fact *facts[20]; ! 825: struct concr *concrp; ! 826: struct ref *refp; ! 827: struct defblk *defp; ! 828: register char *sp; ! 829: int factor; ! 830: int vector; ! 831: int c; ! 832: int numinf; ! 833: int num; ! 834: ! 835: sp = symbol(); ! 836: factor = -1; ! 837: if (*sp == '!') { ! 838: factor = 0; ! 839: sp++; ! 840: } ! 841: defp = getref(sp,type,1); ! 842: hypep = (struct hype *) defp->definition; ! 843: ! 844: sp = symbol(); ! 845: if (streq(sp,"certainty")) { ! 846: if (type != HYPO) fprintf(stderr,"Conclude clause can't have a certainty factor\n"); ! 847: sp = symbol(); ! 848: factor = number(sp); ! 849: sp = symbol(); ! 850: } ! 851: if (streq(sp,"from")) { ! 852: c = nonblank(); ! 853: if (c == '{') { ! 854: num=1000; ! 855: } else { ! 856: ungetc(c,kfile); ! 857: num = 1; ! 858: } ! 859: vector = 0; ! 860: numinf = 0; ! 861: while (num--) { ! 862: c = nonblank(); ! 863: if (c == '}') break; ! 864: vector = vector << 1; ! 865: if (c != '!' ) { ! 866: vector += 1; ! 867: ungetc(c,kfile); ! 868: } ! 869: sp = symbol(); ! 870: defp = getref(sp,FACT,1); ! 871: facts[numinf++] = (struct fact *) defp->definition; ! 872: } ! 873: if (numinf) { ! 874: int x; ! 875: ! 876: concp = (struct conc *) malloc((sizeof *concp) + numinf * (sizeof factp)); ! 877: concp ->hypo = hypep; ! 878: concp -> weight = factor; ! 879: concp -> vector = vector; ! 880: concp -> num = numinf; ! 881: x = 0; ! 882: while (--numinf >= 0) { ! 883: factp = facts[numinf]; ! 884: concrp = (struct concr *) malloc(sizeof *concrp); ! 885: concrp ->next = factp->setlist; ! 886: factp->setlist = concrp; ! 887: concrp->this = concp; ! 888: concp->confirms[x++] = factp; ! 889: } ! 890: } ! 891: } ! 892: } ! 893: ! 894: ! 895: match(pat,targ) ! 896: char *pat,*targ; ! 897: { ! 898: int first; ! 899: register char *p, *t; ! 900: ! 901: if (*pat== '^') { ! 902: first=1; ! 903: pat++; ! 904: } else first = 0; ! 905: ! 906: while ( *targ) { ! 907: if (*pat == *targ) { ! 908: p = pat; ! 909: t = targ; ! 910: while (*p) if (*p++ != *t++) goto next; ! 911: return(1); ! 912: } ! 913: next: if (first) return(0); ! 914: targ++; ! 915: } ! 916: return(0); ! 917: } ! 918: ! 919: fmatch(fp,refp) ! 920: FILE *fp; ! 921: struct ref *refp; ! 922: { ! 923: struct fact *factp; ! 924: struct ref *rp; ! 925: char buf[512]; ! 926: ! 927: if (fp == NULL) return; ! 928: while (fgets(buf,512,fp)) { ! 929: for (rp = refp; rp != NULL; rp = rp->next) { ! 930: if (rp->this->type == STRING) { ! 931: buf[strlen(buf)-1] = 0; ! 932: rp->this->definition = (struct ref *) malloc(strlen(buf)+1); ! 933: strcpy(rp->this->definition,buf); ! 934: } else { ! 935: factp = (struct fact *) rp->this->definition; ! 936: if ((factp->truth == FUNKNOWN) && match(rp->text,buf)) setfact(factp,FTRUE); ! 937: } ! 938: } ! 939: } ! 940: for (rp = refp; rp != NULL; rp = rp->next) { ! 941: if (rp->this->type == FACT) { ! 942: factp = (struct fact *) rp->this->definition; ! 943: if (factp->truth == FUNKNOWN) setfact(factp,FFALSE); ! 944: } ! 945: } ! 946: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.