home *** CD-ROM | disk | FTP | other *** search
/ ftp.umcs.maine.edu / 2015-02-07.ftp.umcs.maine.edu.tar / ftp.umcs.maine.edu / pub / thesis / zhongy / rule / rule_based.cc < prev    next >
C/C++ Source or Header  |  1994-12-15  |  39KB  |  1,504 lines
  1. #include <stdio.h>
  2. #include <stdlib.h> 
  3. #include <iostream.h>
  4. #include <string.h>
  5. #include <ctype.h>
  6.  
  7. #include "rule.h"
  8.     
  9.  
  10. int                   NumberofObjects;
  11. /*ObjectType            *FirstObject; */
  12. int                   Length1;
  13. char                  *List[20];
  14. int                   option, option1;
  15. int                   Finish,Finished,Explanation; /*True--1, False--0*/
  16. ObjectNameType        ObjectName;
  17. ObjectValueType       ObjectValue;
  18. ObjectType            *PreviousPtr, *ObjectPtr;
  19. struct RuleType       *PreviousRulePtr, *RulePtr;
  20. RuleNameType          RuleName;
  21. int                   NumberofRules;
  22. RuleType              *FirstRule;
  23. PremiseType           *PremisePtr, *PreviousPremisePtr;
  24. ConclusionType        *ConclusionPtr;
  25. RuleType              *NewRule;
  26. int                   Line;
  27. char                  d;
  28. char                  *str1, *Title;
  29.  
  30. /**************Function 1 **********************************************/
  31. static void EraseScreen() 
  32. {
  33.   system("clear");
  34. };
  35.  
  36. /**************Function 2 **********************************************/
  37. /*
  38.   change C to C++
  39.  
  40.   we put all paramater to the ()
  41.  
  42. */
  43. static void GenerateList(char *List[20],int *Length1,int ListNumber)
  44. /*
  45.  used in C
  46.  
  47. int ListNumber;
  48. char *List[20];
  49. int *Length1;
  50. */
  51. {
  52.   int j;
  53.  
  54.   j=ListNumber;
  55.   switch (j)  {
  56.     case 1:
  57.          List[1]="Objects";
  58.          List[2]="Rules";
  59.          List[3]="Facts";
  60.          List[4]="Backward chaining";
  61.          List[5]="Forward chaining";
  62.          List[6]="Save knowledge base";
  63.          List[7]="Load knowledge base from file";
  64.          List[8]="Select explanation";
  65.          List[9]="End";
  66.          *Length1=9;
  67.          break;
  68.    case 2:
  69.          List[1]="Add";
  70.          List[2]="Erase";
  71.          List[3]="List";
  72.          *Length1=3;
  73.          break;
  74.    case 3:
  75.          List[1]="Initialize";
  76.          List[2]="Give values";
  77.          List[3]="List";
  78.          *Length1=3;
  79.          break;
  80.    default:
  81.          break;
  82.    }
  83. }
  84.  
  85. /**************Function 3**********************************************/
  86. /*
  87.   Same thing
  88.  
  89.   change from C to C++, we must change the position of paramater
  90. */
  91. static void OptionList(char *List[20],int Number,int *Option)
  92. /*
  93.   used in C
  94.  
  95. char *List[20];
  96. int Number;
  97. int *Option;
  98. */
  99. {
  100.   int i;
  101.   
  102.   EraseScreen();
  103.   for (i=1; i<=Number; i++)
  104.       printf("  %d   %s \n",i,List[i]);
  105.   printf("\n\n");
  106.   printf("Select one option :");
  107.   do {
  108.      scanf("%d",Option);
  109.      if (((*Option) > Number) || ((*Option) <1))
  110.         printf("\n Invalid option, reenter the option: ");
  111.   } while (((*Option) > Number) || ((*Option) <1));
  112.  
  113. }
  114.  
  115. /****************Function 4******************************************/
  116. void Trim(char *str1)
  117. {
  118.   char c;
  119.   int len,i,counter;
  120.   char str2[MaxCharactersObjectName];
  121.   
  122.   printf("\n Enter the Trim");
  123.   len=strlen(str1);
  124.   counter=-1;
  125.   for (i=0;i<len;i++) {
  126.       c=str1[i];
  127.       if (c==' ') c='\0';
  128.       if (isupper(c)) tolower(c);
  129.       if (c != '\0') {
  130.          counter++;
  131.          str2[counter]=c;    
  132.          };
  133.       }
  134.   counter++;
  135.   str2[counter]='\0';
  136.   
  137.   strncpy(str1,str2,strlen(str2));
  138. }
  139.  
  140. /****************Function 5******************************************/
  141. void GiveNameofObject(char *Name)
  142. {
  143.   char str[MaxCharactersObjectName];
  144.  
  145.   printf("\nGive name of the object(if no more enter quit):");
  146.   scanf("%s",str);
  147.  /* Trim(str);  /*****Fun 4, not necessary ***************/
  148.   printf("Here comes the object:%s", str); 
  149.  
  150.   strncpy(Name,str,strlen(str));
  151. }
  152.  
  153.  
  154. /**************Function  6******************************************/
  155. /*
  156.   Found--return point to ObjectType
  157.  
  158.   Not Found--return NULL
  159. */
  160.  
  161. ObjectType *SearchObject(char *ObjectName)
  162. {
  163.   int Found;
  164.  
  165.   Found=0;
  166.   PreviousPtr=NULL;
  167.   ObjectPtr=FirstObject;
  168.  
  169.   while ((ObjectPtr != NULL) && (Found == 0)) {
  170.      if (!strcmp(ObjectName,(*ObjectPtr).Name())) {
  171.         Found=1;
  172.         return(ObjectPtr);
  173.         }
  174.      else {
  175.         PreviousPtr=ObjectPtr;
  176.         ObjectPtr=(*ObjectPtr).Next();
  177.         };
  178.      };
  179.   return(NULL);
  180. }
  181.  
  182.  
  183. /************Function 7*******************************************/
  184.  
  185. ObjectType *CreateObject(char *ObjectName)
  186. /*
  187.   used in C
  188.  
  189. char *ObjectName;
  190. */
  191. {
  192.   ObjectType *Object_Ptr;
  193.  
  194.   /*
  195.   Object_Ptr=malloc(sizeof(struct ObjectType));
  196.   */
  197.   Object_Ptr=new ObjectType;
  198.  
  199.   NumberofObjects++;
  200.   
  201.   (*Object_Ptr).set_Name(ObjectName);
  202.   (*Object_Ptr).set_Value("Unknown");
  203.   (*Object_Ptr).set_Known(0);
  204.   (*Object_Ptr).set_Next(FirstObject);
  205.   (*Object_Ptr).set_Type(PROBLEM);
  206.  
  207. /*
  208.   used in C
  209.  
  210.   strcpy(Object_Ptr.Name(),ObjectName);
  211.   strcpy(Object_Ptr.Value(),"Unknown");
  212.   Object_Ptr->Known=0;
  213.   Object_Ptr->Next=FirstObject;
  214. */
  215.  
  216.   FirstObject=Object_Ptr;
  217.   /*
  218.   printf("\n first");
  219.   printf("\nObjectName is:%s",(*FirstObject).Name());
  220.   printf("\nObjectName is:%s",(*FirstObject).Value());
  221.   printf("\nKnown:%d, Next is:%d",(*FirstObject).Known(),(*FirstObject).Next());
  222.   */
  223.  
  224.   return(Object_Ptr);
  225. }
  226.  
  227. ObjectType *CreateObject2(int type)
  228. {
  229.  
  230.   ObjectType *ObjPtr;
  231.   ObjectType *ObjectPtr;
  232.   char Hostname[50];
  233.   char Obj_name[50];
  234.   char Probname[50];
  235.   char Eventname[50];
  236.   long time_interval;
  237.   struct timeval t;
  238.  
  239.  
  240.       switch (type) {
  241.       case MIB_VALUE:
  242.            bzero(Hostname, sizeof(Hostname));
  243.            bzero(Obj_name, sizeof(Obj_name));
  244.  
  245.            printf("\nEnter Hostname Name:");
  246.            scanf("%s",Hostname);
  247.            printf("\nEnter Objectname:");
  248.            scanf("%s",Obj_name);
  249.            printf("\nEnter time interval:");
  250.            scanf("%d", &time_interval);
  251.  
  252.            ObjectPtr=SearchObject(strcat(Hostname,Obj_name));
  253.  
  254.            if (ObjectPtr ==NULL) {
  255.                ObjPtr=new ObjectType;
  256.                (*ObjPtr).set_Type(MIB_VALUE);
  257.                (*ObjPtr).set_hostname(Hostname);
  258.                (*ObjPtr).set_objname(Obj_name);
  259.                (*ObjPtr).set_Name(strcat(Hostname,Obj_name));
  260.                t.tv_sec=time_interval;
  261.                (*ObjPtr).set_timeleft(t);
  262.                (*ObjPtr).set_timeinterval(t);
  263.                (*ObjPtr).set_Known(0);
  264.                }
  265.            else {
  266.                printf("\nObject already existed");
  267.                return(NULL);
  268.                };
  269.            break;
  270.  
  271.       case MIB_VARIANCE:
  272.            bzero(Hostname, sizeof(Hostname));
  273.            bzero(Obj_name, sizeof(Obj_name));
  274.  
  275.            printf("\nEnter Hostname Name:");
  276.            scanf("%s",Hostname);
  277.            printf("\nEnter Objectname:");
  278.            scanf("%s",Obj_name);
  279.            printf("\nEnter time interval:");
  280.            scanf("%d", &time_interval);
  281.  
  282.            ObjectPtr=SearchObject(strcat(Hostname,Obj_name)); 
  283.            if (ObjectPtr ==NULL) {
  284.                ObjPtr=new ObjectType;
  285.                (*ObjPtr).set_Type(MIB_VARIANCE);
  286.                (*ObjPtr).set_hostname(Hostname);
  287.                (*ObjPtr).set_objname(Obj_name);
  288.                (*ObjPtr).set_Name(strcat(Hostname,Obj_name));
  289.                t.tv_sec=time_interval;
  290.                (*ObjPtr).set_timeleft(t);
  291.                (*ObjPtr).set_timeinterval(t);
  292.                (*ObjPtr).set_Known(0);
  293.                }
  294.            else {
  295.                printf("\nObject already existed");
  296.                return(NULL);
  297.                };
  298.            break;
  299.       case PROBLEM:
  300.            bzero(Probname,sizeof(Probname));
  301.            printf("\nEnter problem name:");
  302.            scanf("%s", Probname);
  303.  
  304.            ObjectPtr=SearchObject(Probname); 
  305.            if (ObjectPtr ==NULL) {
  306.                ObjPtr=new ObjectType;
  307.                (*ObjPtr).set_Type(PROBLEM);
  308.                (*ObjPtr).set_Known(0);
  309.                (*ObjPtr).set_Name(Probname);
  310.                }
  311.            else {
  312.                printf("\nObject already existed");
  313.                return(NULL);
  314.                };
  315.            break;
  316.       case EVENT:
  317.            bzero(Eventname,sizeof(Eventname));
  318.            printf("\nEnter event name:");
  319.            scanf("%s",Eventname);
  320.  
  321.            ObjectPtr=SearchObject(Eventname); 
  322.            if (ObjectPtr ==NULL) {
  323.               ObjPtr=new ObjectType;
  324.               (*ObjPtr).set_Type(EVENT);
  325.               (*ObjPtr).set_Known(0);
  326.               (*ObjPtr).set_Name(Eventname);
  327.               }
  328.            else {
  329.                printf("\nObject already existed");
  330.                return(NULL);
  331.                };
  332.            break;
  333.       default:
  334.            break;
  335.       }
  336.  
  337.     (*ObjPtr).set_Next(FirstObject);
  338.     FirstObject=ObjPtr;
  339.  
  340.   return(ObjPtr);
  341.  
  342. }  
  343.  
  344. /**********Function 8*******************************************/
  345.  
  346. static void ControlScr() 
  347. {
  348.   char s[MaxCharactersObjectName];
  349.  
  350.   Line=Line+1;
  351.   if (Line > Nlines) {
  352.      printf("\n----Type character 'c' to cancel and other key to continue:");
  353.      scanf("%s",s);
  354.      d=s[0];
  355.      EraseScreen();
  356.      Line=0;
  357.      }
  358. }
  359.  
  360. /**********Function 9*******************************************/
  361.  
  362. void ListObjects()
  363. {
  364.   char s[MaxCharactersObjectName];
  365.   ObjectType *ObjectPtr;
  366.  
  367.   EraseScreen();
  368.   printf("\n *List of Objects*(type 0:MIB_VALUE,1:MIB_VARIANCE,2:PROBLEM,3:EVENT*\n");
  369.   printf("\n ***Type**          **Name***\n");
  370.   ObjectPtr=FirstObject;
  371.   Line=2;
  372.   d='B';
  373.   while ((ObjectPtr != NULL)&&(d != 'c'))  {
  374.         printf("  %d           %s \n",(*ObjectPtr).Type(), (*ObjectPtr).Name());
  375.         ObjectPtr=(*ObjectPtr).Next();
  376.         ControlScr();
  377.         }
  378.   if ( d != 'c') {
  379.     printf("\n *****End of List****Hit 'q' <Enter> to exit:");
  380.     scanf("%s",s);
  381.     while ( strcmp(s,"q")) {
  382.       printf("\nHit 'q' <Enter> to exit:");
  383.       scanf("%s",s);
  384.       }
  385.     }
  386. }
  387.  
  388.  
  389. /********Function 10******************************************/
  390.  
  391.   
  392. int GiveRuleName(char *Name)
  393. {
  394.   char str[MaxCharactersObjectName];
  395.  
  396.   printf("\n Enter Rule Name?:(y/n)");
  397.   scanf("%s",str);
  398.   if (!strncmp(str,"y",1)) {
  399.      printf("    Give name of the rule:");
  400.      scanf("%s",str);
  401.      /* Trim(str);  /*****Fun 4, not necessary ***************/
  402.      printf("\n $$Begin to set up rule:%s", str);
  403.      strncpy(Name,str,strlen(str));
  404.      return(1);
  405.      }
  406.   else
  407.      return(0);
  408. }
  409.  
  410.  
  411. /*******Function 11****************************************/
  412.  
  413. /*
  414.   return value:
  415.     Point to Found Rule--Found,  NULL--Not Found
  416. */
  417.  
  418. struct RuleType *SearchRule(char *RuleName)
  419. {
  420.   int Found;
  421.  
  422.   Found=0;
  423.   PreviousRulePtr=NULL;
  424.   RulePtr=FirstRule;
  425.  
  426.   while ((RulePtr != NULL) && (Found == 0)) {
  427.      if (!strcmp(RuleName,(*RulePtr).Name())) {
  428.         Found=1;
  429.         return(RulePtr);
  430.         }
  431.      else {
  432.         PreviousRulePtr=RulePtr;
  433.         RulePtr=(*RulePtr).Next();
  434.         };
  435.      };
  436.   return(NULL);
  437. }
  438.  
  439. /******Function 12********************************************/
  440. /*
  441.   Reads a premise (object and value) and checks whether or not the object
  442.   is in the objects list. If not the object is created
  443.  
  444.   return value:   1--sucess, 0--failure
  445. */
  446.  
  447. int GiveExpression()
  448. {
  449.  char str[MaxCharactersObjectName];
  450.  char ObjectName[MaxCharactersObjectName];
  451.  
  452.  
  453.  
  454.  printf("\n Enter the expression:(y/n) <Enter> ");
  455.  scanf("%s",str);
  456.  if ( !strncmp(str,"y",1)) {
  457.     printf("        Give object:");
  458.     scanf("%s",str);
  459.     strcpy(ObjectName,str);
  460.     ObjectPtr=SearchObject(ObjectName);
  461.     if (ObjectPtr == NULL) {
  462.        printf("\n$$This object does not exist, but it is created as problem");
  463.        ObjectPtr=CreateObject(ObjectName);
  464.        }
  465.     printf("\n      Give value of the object:");
  466.     scanf("%s",str);
  467.     strcpy(ObjectValue,str);
  468.     return(1);
  469.     }
  470.  else {
  471.     return(0);
  472.     };
  473. }
  474.    
  475.  
  476. /******Function 13 *******************************************/
  477.  
  478. struct RuleType *CreateRule()
  479. {
  480.   char *Name1;
  481.   int c;
  482.   int Premtype;
  483.  
  484.   char PremObjName[50];
  485.   char Premvalue[50];
  486.   char ObjectName[50];
  487.   ObjectType *Object_Ptr;
  488.   int  firstPrem;
  489.   int  Int_value;
  490.   PremiseType *PremPtr;
  491.  
  492.   /*
  493.   NewRule=malloc(sizeof(struct RuleType));
  494.   */
  495.  
  496.   NewRule=new RuleType;
  497.   NumberofRules++;
  498.  
  499.   /*
  500.     C
  501.   strcpy(NewRule->Name,RuleName);
  502.   NewRule->Premise=NULL;
  503.   NewRule->Conclusion=NULL;
  504.   NewRule->Next=FirstRule;
  505.   */
  506.   (*NewRule).set_Name(RuleName);
  507.   (*NewRule).set_Premise(NULL);
  508.   (*NewRule).set_Conclusion(NULL);
  509.   (*NewRule).set_Next(FirstRule);
  510.   
  511.   /*
  512.    Enter the premise
  513.   */
  514.      printf("\nEnter the type of Premtype:");
  515.      scanf("%d",&Premtype);
  516.      firstPrem=1;
  517.      while (Premtype != 9999) {
  518.        PremPtr=new PremiseType;
  519.        (*PremPtr).set_Operation(Premtype);
  520.  
  521.        printf("\nEnter the object name of this premise:");
  522.        scanf("%s",PremObjName);
  523.        strcpy(ObjectName,PremObjName);
  524.        Object_Ptr=SearchObject(ObjectName);
  525.        if (Object_Ptr == NULL) {
  526.           printf("\n$$This object does not exist,but it is created as problem");
  527.           Object_Ptr=CreateObject(ObjectName);
  528.           }
  529.        (*PremPtr).set_Object(Object_Ptr);
  530.  
  531.        switch (Premtype) {
  532.          case EQUAL_STR:
  533.               printf("\nEnter the Premise string value:");
  534.               scanf("%s",Premvalue);
  535.               (*PremPtr).set_Value(Premvalue);
  536.               break;
  537.          case EQUAL_INT:
  538.          case BIGGER:
  539.          case LESSER:
  540.               printf("\nEnter the Premise int value:");
  541.               scanf("%d",&Int_value);
  542.               (*PremPtr).set_Int(Int_value);
  543.               break;
  544.          default:
  545.               break;
  546.          };
  547.  
  548.        if (firstPrem == 0) {
  549.             (*PremPtr).set_Next((*NewRule).Premise());
  550.             (*NewRule).set_Premise(PremPtr);
  551.             }
  552.        else {
  553.             firstPrem=0;
  554.             (*PremPtr).set_Next(NULL);
  555.             (*NewRule).set_Premise(PremPtr);
  556.             }
  557.        printf("\n Enter the type of Premtype(no more 9999):");
  558.        scanf("%d",&Premtype);
  559.        }
  560.  
  561.   
  562.  
  563.    /*
  564.    Enter the conclusion
  565.    */
  566.  
  567.    do {
  568.       printf("\n Give conclusion of the rule:");
  569.       c=GiveExpression();
  570.       if (c ==0)
  571.          printf("\n No Conclusion Entered");
  572.       }
  573.    while (c==0);
  574.    /*
  575.    ConclusionPtr=malloc(sizeof(struct ConclusionType));
  576.    */
  577.    ConclusionPtr=new ConclusionType;
  578.    /* C
  579.    NewRule->Conclusion=ConclusionPtr;
  580.    */
  581.    (*NewRule).set_Conclusion(ConclusionPtr);
  582.  
  583.    /*  C
  584.    ConclusionPtr->Object=ObjectPtr;
  585.    strcpy(ConclusionPtr->Value,ObjectValue);
  586.  
  587.    */
  588.    (*ConclusionPtr).set_Object(ObjectPtr);
  589.    (*ConclusionPtr).set_Value(ObjectValue);
  590.  
  591.    FirstRule=NewRule;
  592.     
  593.    return(NewRule);
  594. }
  595.  
  596.  
  597. /****   Function 14***************************************************/
  598. /*
  599.   search the Rulename, Found--1,founded, Found--0,not founded
  600.  
  601.   if (Found)
  602.      Erases one rule from the list of rules and disposes the memory space
  603.      occupied by its premises, conclusion and the rule itself
  604.  
  605. */
  606.  
  607. int EraseRule(char *RuleName)
  608. {
  609.   int Found;
  610.   struct PremiseType *PtrP;
  611.  
  612.   RulePtr=FirstRule;
  613.   PreviousRulePtr=NULL;
  614.   Found=0;
  615.   while ((RulePtr != NULL) && (Found == 0)) {
  616.      if ( !strcmp(RuleName,(*RulePtr).Name()))
  617.         Found=1;
  618.      else {
  619.         PreviousRulePtr=RulePtr;
  620.         RulePtr=(*RulePtr).Next();
  621.         }
  622.      }
  623.  
  624.   if (Found ==1) {
  625.      PremisePtr=(*RulePtr).Premise();
  626.      while (PremisePtr != NULL) {
  627.         PtrP=(*PremisePtr).Next();
  628.         /*
  629.         free(PremisePtr);
  630.         */
  631.         delete PremisePtr;
  632.         PremisePtr=PtrP;
  633.         }
  634.      /*
  635.      free((*RulePtr).Conclusion());
  636.      */
  637.      delete (*RulePtr).Conclusion();
  638.      if (PreviousRulePtr == NULL)
  639.         FirstRule=(*RulePtr).Next();
  640.      else {
  641.         /*
  642.           C
  643.         PreviousRulePtr->Next=RulePtr->Next;
  644.         */
  645.         (*PreviousRulePtr).set_Next((*RulePtr).Next());
  646.  
  647.         /*
  648.         free(RulePtr);
  649.         */
  650.         delete RulePtr;
  651.         NumberofRules=NumberofRules-1;
  652.         }
  653.      return(1);
  654.      }
  655.   else
  656.      return(0);
  657.  
  658. }
  659.         
  660.  
  661. /************ Function 15**************************************************/
  662.  
  663. void ListRules()
  664. {
  665.   char s[MaxCharactersObjectName];
  666.   struct ObjectType *ObjPtr;
  667.   
  668.   EraseScreen();
  669.   printf("\n       List of Rules           ");
  670.   printf("\n______________________________________________________________");
  671.   RulePtr=FirstRule;
  672.   Line=2;
  673.   d='B';
  674.   while ((RulePtr != NULL) && (d != 'c')) {
  675.      printf("\n %s:",(*RulePtr).Name());
  676.      printf("\n IF");
  677.      PremisePtr=(*RulePtr).Premise();
  678.      while (PremisePtr != NULL) {
  679.         ObjPtr=(*PremisePtr).Object();
  680.         switch ((*PremisePtr).Op()) {
  681.           case EQUAL_STR:
  682.            printf("\n EQUAL_STR  %s=%s",(*ObjPtr).Name(),(*PremisePtr).Value());
  683.            break;
  684.           case EQUAL_INT:
  685.             printf("\n INT %s = %d",(*ObjPtr).Name(),(*PremisePtr).INT_Value());
  686.             break;
  687.           case BIGGER:
  688.             printf("\n INT %s > %d",(*ObjPtr).Name(),(*PremisePtr).INT_Value());
  689.             break;
  690.           case LESSER:
  691.             printf("\n INT %s < %d",(*ObjPtr).Name(),(*PremisePtr).INT_Value());
  692.             break;
  693.           default:
  694.             break;
  695.           }
  696.         PremisePtr=(*PremisePtr).Next();
  697.         }
  698.      printf("\n THEN");
  699.      /*
  700.        C
  701.      printf("\n  %s",(*RulePtr->Conclusion->Object).Name());
  702.      printf("=%s",RulePtr->Conclusion->Value);
  703.      */
  704.      printf("\n %s", (*((*((*RulePtr).Conclusion())).Object())).Name() );
  705.      printf("=%s",(*(*RulePtr).Conclusion()).Value()  );
  706.      ControlScr();
  707.      RulePtr=(*RulePtr).Next();
  708.      printf("\n");
  709.      }
  710.  
  711.   if ( d != 'c') {
  712.     printf("\n *****End of Rule List****Hit 'q' <Enter> to exit:");
  713.     scanf("%s",s);
  714.     while ( strcmp(s,"q")) {
  715.       printf("\nHit 'q' <Enter> to exit:");
  716.       scanf("%s",s);
  717.       }
  718.     }
  719. }
  720.  
  721. /***********  Function 16 ************************************************/
  722.  
  723. void InitializeObjects()
  724. {
  725.   struct ObjectType *Object_Ptr;
  726.  
  727.   Object_Ptr=FirstObject;
  728.   while (Object_Ptr != NULL ) {
  729.      (*Object_Ptr).set_Value("Unknown");
  730.      (*Object_Ptr).set_Known(0);
  731.      Object_Ptr=(*Object_Ptr).Next();
  732.      
  733.      /*
  734.        used in C
  735.  
  736.      strcpy(Object_Ptr->Value,"Unknown");
  737.      Object_Ptr->Known=0;
  738.      Object_Ptr=Object_Ptr=Object_Ptr->Next;
  739.      */
  740.      }
  741. }
  742.   
  743.   
  744. /*********  Function 17 ************************************************/
  745.  
  746. void GiveObjectValue()
  747. {
  748.   char str[MaxCharactersObjectValue];
  749.   struct ObjectType *ObjPtr;
  750.   char  Objectname[MaxCharactersObjectName];
  751.  
  752.   printf("\nGive name of the object(if no more enter quit):");
  753.   scanf("%s",ObjectName);
  754.   while (strncmp(ObjectName,"quit",4)) {
  755.      ObjPtr=SearchObject(ObjectName);
  756.      if (ObjPtr != NULL ) {
  757.         printf("\nGive Value of Object (%s):",ObjectName);
  758.         scanf("%s",str);
  759.         (*ObjPtr).set_Value(str);
  760.         (*ObjPtr).set_Known(1);
  761.         }
  762.      else {
  763.         printf("\n The object (%s) does not exist",ObjectName);
  764.         }
  765.      printf("\nGive name of the object(if no more enter quit):");
  766.      scanf("%s",ObjectName);
  767.      }
  768. }
  769.         
  770.  
  771. /******   Functiopn 18 *********************************************/
  772.  
  773. void ListFacts()
  774. {
  775.   char s[MaxCharactersObjectName];
  776.  
  777.   EraseScreen();
  778.   printf("\n ******List of Objects Facts**********************\n");
  779.   ObjectPtr=FirstObject;
  780.   Line=2;
  781.   d='B';
  782.   while ((ObjectPtr != NULL)&&(d != 'c'))  {
  783.         if ((*ObjectPtr).Known() == 1) {
  784.            printf("Objname=%s,value=%s\n",(*ObjectPtr).Name(),(*ObjectPtr).Value());
  785.             }
  786.         else
  787.             printf("Objname=%s,value=UNKNOWN\n",(*ObjectPtr).Name());
  788.         ObjectPtr=(*ObjectPtr).Next();
  789.         ControlScr();
  790.         }
  791.   if ( d != 'c') {
  792.     printf("\n *****End of List****Hit 'q' <Enter> to exit:");
  793.     scanf("%s",s);
  794.     while ( strcmp(s,"q")) {
  795.       printf("\nHit 'q' <Enter> to exit:");
  796.       scanf("%s",s);
  797.       }
  798.     }
  799. }
  800.  
  801.  
  802. /********* Function 19 ****************************************/
  803. /*
  804.   return 1-- Yes
  805.  
  806.   return 0-- No 
  807. */
  808. int IsObjectInRules(struct ObjectType *ObjPtr)
  809. {
  810.   struct RuleType *Rule_Ptr;
  811.   struct PremiseType *Premise_Ptr;
  812.   int Found,Isin;
  813.  
  814.  
  815.   Isin=0;
  816.   Rule_Ptr=FirstRule;
  817.   while (Rule_Ptr != NULL ) {
  818.      Found=0;
  819.      Premise_Ptr=(*Rule_Ptr).Premise();
  820.  
  821.      while ((Premise_Ptr != NULL) && (Found == 0)) {
  822.         if ((*Premise_Ptr).Object() == ObjPtr) {
  823.            Found=1;
  824.            Isin=1;
  825.            }
  826.         Premise_Ptr=(*Premise_Ptr).Next();
  827.         };
  828.  
  829.      if ((*(*Rule_Ptr).Conclusion()).Object() == ObjPtr) {
  830.            Isin=1;
  831.            Found=1;
  832.            }
  833.  
  834.      if (Found == 1) 
  835.         printf("\n Object (%s) is in Rule (%s)",ObjPtr->Name,Rule_Ptr->Name);
  836.  
  837.      Rule_Ptr=(*Rule_Ptr).Next();
  838.      }
  839.   return(Isin);
  840. }
  841.  
  842. /********** Function 20 ****************************************/
  843.  
  844.  
  845. void EraseObject()
  846. {
  847.   char  Objectname[MaxCharactersObjectName];
  848.   struct ObjectType *ObjPtr;
  849.  
  850.  
  851.   printf("\nGive name of the object(if no more enter quit):");
  852.   scanf("%s",ObjectName);
  853.  
  854.   while (strncmp(ObjectName,"quit",4)) {
  855.      ObjPtr=SearchObject(ObjectName);
  856.      if (ObjPtr != NULL ) {
  857.         if (IsObjectInRules(ObjPtr) == 0 ) {
  858.            if (ObjPtr == FirstObject)
  859.               (*FirstObject).set_Next((*ObjPtr).Next());
  860.            else
  861.               (*PreviousPtr).set_Next((*ObjPtr).Next());
  862.            /*
  863.            free(ObjPtr);
  864.            */
  865.            delete ObjPtr;
  866.            }
  867.         else
  868.            printf("\n The object (%s) can not be deleted",ObjectName);
  869.         }
  870.      else
  871.         printf("\n The object (%s) does not exist",ObjectName);
  872.      printf("\nGive name of the object(if no more enter quit):");
  873.      scanf("%s",ObjectName);
  874.      }
  875. } 
  876.  
  877. /*************** Function 21 ******************************************/
  878.  
  879. void ForwardChaining()
  880. {
  881.   int Bad,Concludes;
  882.   struct RuleType *Rule_Ptr;
  883.   struct PremiseType *Premise_Ptr;
  884.  
  885.   do {
  886.      /* printf("\n First run"); */
  887.      Concludes=0;
  888.      Rule_Ptr=FirstRule;
  889.      do {
  890.        /*  printf("\n second run"); */
  891.         if ((*(*(*Rule_Ptr).Conclusion()).Object()).Known() == 0) {
  892.            Premise_Ptr=(*Rule_Ptr).Premise();
  893.            Bad=0;
  894.            while ((Premise_Ptr != NULL) && (Bad == 0)) {
  895.  
  896.              /*test whether premise is OK or not****************************/
  897.              switch ((*Premise_Ptr).Op()) {
  898.                case EQUAL_STR:
  899.                     if (strcmp((*(*Premise_Ptr).Object()).Value(),(*Premise_Ptr).Value()) != 0) 
  900.                     Bad=1;
  901.                     break;
  902.                case EQUAL_INT:
  903.                     if ((*Premise_Ptr).INT_Value() != (*(*Premise_Ptr).Object()).Diff() ) 
  904.                     Bad=1;
  905.                     if ( (*(*Premise_Ptr).Object()).Time_Left().tv_sec != (*(*Premise_Ptr).Object()).Time_Interval().tv_sec ) /*make sure it is the first time*/
  906.                     Bad=1; 
  907.                     
  908.                     break;
  909.                case BIGGER:
  910.                     if ((*Premise_Ptr).INT_Value() >= (*(*Premise_Ptr).Object()).Diff() ) 
  911.                     Bad=1;
  912.                     if ( (*(*Premise_Ptr).Object()).Time_Left().tv_sec != (*(*Premise_Ptr).Object()).Time_Interval().tv_sec ) /*make sure it is the first time*/
  913.                     Bad=1;
  914.                     
  915.                     break;
  916.                case LESSER:
  917.                     if ((*Premise_Ptr).INT_Value() <= (*(*Premise_Ptr).Object()).Diff() )
  918.                     Bad=1;
  919.                     if ( (*(*Premise_Ptr).Object()).Time_Left().tv_sec != (*(*Premise_Ptr).Object()).Time_Interval().tv_sec ) /*make sure it is the first time*/
  920.                     Bad=1;
  921.                     
  922.                     break;
  923.                default:
  924.                     break;
  925.                }
  926.               Premise_Ptr=(*Premise_Ptr).Next();
  927.               }
  928.            if (Bad == 0) {
  929.           /*    printf("\n A conclusion here");
  930.           */
  931.               Concludes=1;
  932.               (*(*(*Rule_Ptr).Conclusion()).Object()).set_Known(1);
  933.  
  934.               (*(*(*Rule_Ptr).Conclusion()).Object()).set_Value((*(*Rule_Ptr).Conclusion()).Value());
  935.  
  936.               if (Explanation == 1) {
  937.            /*   printf("\n Conclusions: (%s)",(*(*(*Rule_Ptr).Conclusion()).Object()).Name());
  938.            */
  939.                   printf("=(%s)",(*(*Rule_Ptr).Conclusion()).Value());
  940.                   printf(" based on rule (%s)",(*Rule_Ptr).Name());
  941.                   }
  942.               else {
  943.                   printf("\n Conclusions:(%s)",(*(*(*Rule_Ptr).Conclusion()).Object()).Name());
  944.                   printf("=(%s)",(*(*Rule_Ptr).Conclusion()).Value());
  945.                   }
  946.               }
  947.            }
  948.         Rule_Ptr=(*Rule_Ptr).Next();
  949.         } while (Rule_Ptr != NULL); 
  950.      } while (Concludes == 1);
  951. }
  952.        
  953.  
  954. /******* Function 22 ***************************************************/
  955.  
  956. struct RuleType *FindRule(ObjectType *ObjPtr,struct RuleType *RulePtr)
  957.  
  958. {
  959.   int Found;
  960.  
  961.   printf("\n in find function");
  962.   Found=False;
  963.   while ((RulePtr != NULL) && (Found == False)) {
  964.      if ((*(*RulePtr).Conclusion()).Object() == ObjPtr) {
  965.         Found=True;
  966.         return(RulePtr);
  967.         }
  968.      else
  969.         RulePtr=(*RulePtr).Next();
  970.      }
  971.   return(NULL);
  972. }
  973.  
  974. /****** Function 23 *************************************************/
  975.  
  976.  
  977. void BackwardChaining(ObjectType *ObjPtr)
  978. {
  979.   struct PremiseType *PremisePtr1;
  980.   struct RuleType *RulePtr1;
  981.   int Bad,Known;
  982.   char str[MaxCharactersObjectName];
  983.   
  984.   
  985.   printf("\n in Backwardchaining");
  986.   if ((*ObjPtr).Known() == False) {
  987.      Known=False;
  988.      (*ObjPtr).set_Known(True);
  989.      RulePtr1=FindRule(ObjPtr,FirstRule);
  990.      while ((RulePtr1 != NULL) && (Known == False)) {
  991.         printf("\n first loop");
  992.         PremisePtr1 =(*RulePtr1).Premise();
  993.         Bad=False;
  994.         while ((PremisePtr1 != NULL) && (Bad == False)) {
  995.            printf("\nsecond loop");
  996.            BackwardChaining((*PremisePtr1).Object());
  997.            if (strcmp((*(*PremisePtr1).Object()).Value(),(*PremisePtr1).Value()) != 0)
  998.               Bad=True;
  999.            else
  1000.               PremisePtr1=(*PremisePtr1).Next();
  1001.            };
  1002.     
  1003.         if (Bad == False) {
  1004.            printf("\n third place");
  1005.            (*ObjPtr).set_Value((*(*RulePtr1).Conclusion()).Value());
  1006.            (*ObjPtr).set_Known(True);
  1007.            Known=True;
  1008.            if (Explanation == True) {
  1009.               printf("\nConcludes:(%s)=(%s)",(*ObjPtr).Name(),(*ObjPtr).Value());
  1010.               printf("based on rule (%s)",(*RulePtr1).Name());
  1011.               }
  1012.            }
  1013.         RulePtr1=FindRule(ObjPtr,(*RulePtr1).Next());
  1014.         }
  1015.  
  1016.     if (Known == False) {
  1017.        printf("\nGive value of the object (%s):",(*ObjPtr).Name());
  1018.        scanf("%s",str);
  1019.        /*
  1020.        strcpy(ObjPtr->Value,str);
  1021.        */
  1022.        (*ObjPtr).set_Value(str);
  1023.        }
  1024.     }
  1025.   else 
  1026.     printf("\n object (%s)=(%s)",(*ObjPtr).Name(),(*ObjPtr).Value());
  1027. }
  1028.         
  1029. /*************Function 24***************************************************/
  1030. void Load_DB(void)
  1031. {
  1032.   char Hostname[50];
  1033.   char Obj_name[50];
  1034.   char Probname[50];
  1035.   char Eventname[50];
  1036.   FILE *var_file;
  1037.   long time_interval;
  1038.   int typecode;
  1039.   struct timeval t;
  1040.  
  1041.   ObjectType *ObjPtr;
  1042.   int i;
  1043.  
  1044.   int firsttime;
  1045.   int Current_Value;
  1046.  
  1047.   char Rulname[50];
  1048.   char PremObjName[50];
  1049.   char Premvalue[50];
  1050.   char ConcObjName[50];
  1051.   char Concvalue[50];
  1052.   char ObjectName[50];
  1053.   ObjectType *ObjectPtr;
  1054.   int firstrule,firstPrem;
  1055.   RuleType *RulePtr;
  1056.   int Premtype, Int_value;
  1057.   PremiseType *PremPtr;
  1058.   ConclusionType *ConcPtr;
  1059.  
  1060.  
  1061.  
  1062.   /*
  1063.    initialize database
  1064.   */
  1065.  
  1066.  
  1067.   if ((var_file=fopen("VAR.TXT","r")) == NULL) {
  1068.      printf("\n VAR.TXT can not be opened");
  1069.      exit(0);
  1070.      };
  1071.  
  1072.   firsttime=1;
  1073.   while (1) {
  1074.     bzero(Hostname,sizeof(Hostname));
  1075.     bzero(Obj_name,sizeof(Obj_name));
  1076.     fscanf(var_file,"%d",&typecode);
  1077.     if (typecode == 9999){
  1078.        break;
  1079.        }
  1080.  
  1081.     switch (typecode) {
  1082.       case MIB_VARIANCE:
  1083.            fscanf(var_file,"%s",Hostname);
  1084.            fscanf(var_file,"%s",Obj_name);
  1085.            fscanf(var_file,"%d",&time_interval);
  1086.  
  1087.            ObjPtr=new ObjectType;
  1088.            (*ObjPtr).set_Type(MIB_VARIANCE);
  1089.            (*ObjPtr).set_hostname(Hostname);
  1090.            (*ObjPtr).set_objname(Obj_name);
  1091.            (*ObjPtr).set_Name(strcat(Hostname,Obj_name));
  1092.            t.tv_sec=time_interval;
  1093.            (*ObjPtr).set_timeleft(t);
  1094.            (*ObjPtr).set_timeinterval(t);
  1095.            (*ObjPtr).set_Known(0);
  1096.            
  1097.            break;
  1098.       case MIB_VALUE:
  1099.            fscanf(var_file,"%s",Hostname);
  1100.            fscanf(var_file,"%s",Obj_name);
  1101.            fscanf(var_file,"%d",&time_interval);
  1102.  
  1103.            ObjPtr=new ObjectType;
  1104.            (*ObjPtr).set_Type(MIB_VALUE);
  1105.            (*ObjPtr).set_hostname(Hostname);
  1106.            (*ObjPtr).set_objname(Obj_name);
  1107.            (*ObjPtr).set_Name(strcat(Hostname,Obj_name));
  1108.            t.tv_sec=time_interval;
  1109.            (*ObjPtr).set_timeleft(t);
  1110.            (*ObjPtr).set_timeinterval(t);
  1111.            (*ObjPtr).set_Known(0);
  1112.  
  1113.            break;
  1114.       case PROBLEM:
  1115.            bzero(Probname,sizeof(Probname));
  1116.            fscanf(var_file,"%s",Probname);
  1117.            
  1118.            ObjPtr=new ObjectType;
  1119.            (*ObjPtr).set_Type(PROBLEM);
  1120.            (*ObjPtr).set_Known(0);
  1121.            (*ObjPtr).set_Name(Probname);
  1122.  
  1123.            break;
  1124.       case EVENT:
  1125.            bzero(Eventname,sizeof(Eventname));
  1126.            fscanf(var_file,"%s",Eventname);
  1127.            
  1128.            ObjPtr=new ObjectType;
  1129.            (*ObjPtr).set_Type(EVENT);
  1130.            (*ObjPtr).set_Known(0);
  1131.            (*ObjPtr).set_Name(Eventname);
  1132.  
  1133.            break;
  1134.       default:
  1135.            break;
  1136.       }
  1137.  
  1138.     if (firsttime ==0 ) {
  1139.         (*ObjPtr).set_Next(FirstObject);
  1140.         FirstObject=ObjPtr;
  1141.         }
  1142.     else {
  1143.         firsttime=0;
  1144.         (*ObjPtr).set_Next(NULL);
  1145.         FirstObject=ObjPtr;
  1146.         }
  1147.     }
  1148.  
  1149.    /* initialize rule  */
  1150.  
  1151.    firstrule=1;
  1152.    while (1) {
  1153.      bzero(Rulname,sizeof(Rulname));
  1154.      fscanf(var_file,"%s",Rulname);
  1155.  
  1156.      if (!strcmp(Rulname,"END")) {
  1157.         break;
  1158.         }
  1159.  
  1160.      RulePtr=new RuleType;
  1161.      (*RulePtr).set_Name(Rulname);
  1162.      
  1163.      /* set premise   **********/
  1164.  
  1165.      fscanf(var_file,"%d",&Premtype);
  1166. printf("\n Premtype is %d",Premtype);
  1167.      firstPrem=1;
  1168.      while (Premtype != 8888) {
  1169.        PremPtr=new PremiseType; 
  1170.        (*PremPtr).set_Operation(Premtype);
  1171.  
  1172.        fscanf(var_file,"%s",PremObjName);
  1173.        strcpy(ObjectName,PremObjName);              
  1174.        ObjectPtr=SearchObject(ObjectName);
  1175.        if (ObjectPtr == NULL) {
  1176.           printf("\n$$This object does not exist, but it is created");
  1177.           ObjectPtr=CreateObject(ObjectName); 
  1178.           }
  1179.        (*PremPtr).set_Object(ObjectPtr);
  1180.  
  1181.        switch (Premtype) {
  1182.          case EQUAL_STR:
  1183.               fscanf(var_file,"%s",Premvalue);
  1184.               (*PremPtr).set_Value(Premvalue);
  1185.               break;
  1186.          case EQUAL_INT:
  1187.          case BIGGER:
  1188.          case LESSER:
  1189.               fscanf(var_file,"%d",&Int_value);
  1190.               (*PremPtr).set_Int(Int_value);
  1191.               break;
  1192.          default:
  1193.               printf("\n file is in wrong format");
  1194.               break;
  1195.          };
  1196.  
  1197.        if (firstPrem == 0) {
  1198.             (*PremPtr).set_Next((*RulePtr).Premise());
  1199.             (*RulePtr).set_Premise(PremPtr);
  1200.             }
  1201.        else {
  1202.             firstPrem=0;
  1203.             (*PremPtr).set_Next(NULL);
  1204.             (*RulePtr).set_Premise(PremPtr);
  1205.             }
  1206.        fscanf(var_file,"%d",&Premtype);
  1207.        }
  1208.  
  1209.      /***set conclusion********************************************/
  1210.      fscanf(var_file,"%s",ConcObjName);
  1211.      strcpy(ObjectName,ConcObjName);
  1212.      ObjectPtr=SearchObject(ObjectName);
  1213.      if (ObjectPtr == NULL) {
  1214.         printf("\n$$This object does not exist, but it is created");
  1215.         ObjectPtr=CreateObject(ObjectName);
  1216.         }
  1217.      ConcPtr=new ConclusionType;
  1218.      (*ConcPtr).set_Object(ObjectPtr);
  1219.  
  1220.      fscanf(var_file,"%s",Concvalue);
  1221.  
  1222.      (*ConcPtr).set_Value(Concvalue);
  1223.      
  1224.      (*RulePtr).set_Conclusion(ConcPtr);
  1225.  
  1226.  
  1227.      /**next Rule************************************************/
  1228.      if (firstrule == 0) {
  1229.         (*RulePtr).set_Next(FirstRule);
  1230.         FirstRule=RulePtr;
  1231.         }
  1232.      else {
  1233.         firstrule=0;
  1234.         (*RulePtr).set_Next(NULL);
  1235.         FirstRule=RulePtr;
  1236.         }
  1237.      }
  1238.    close(var_file);
  1239. }
  1240.  
  1241. void Save_DB()
  1242. {
  1243.   ObjectType *ObjectPtr;
  1244.   RuleType *RulePtr;
  1245.   PremiseType *PremPtr;
  1246.   FILE *var_file;
  1247.  
  1248.     if ((var_file=fopen("VAR.TXT","w")) == NULL) {
  1249.      printf("\n VAR.TXT can not be opened");
  1250.      exit(0);
  1251.      };
  1252.  
  1253.     /*
  1254.       write object
  1255.     */
  1256.  
  1257.     ObjectPtr=FirstObject;
  1258.     while (ObjectPtr != NULL) {
  1259.        fprintf(var_file,"%d  ",(*ObjectPtr).Type());
  1260.        switch((*ObjectPtr).Type()) {
  1261.          case MIB_VARIANCE:
  1262.               fprintf(var_file,"%s  ",(*ObjectPtr).Hostname());
  1263.               fprintf(var_file,"%s  ",(*ObjectPtr).Obj_Name());
  1264.               fprintf(var_file,"%d  ",(*ObjectPtr).Time_Interval().tv_sec);
  1265.               break;
  1266.          case PROBLEM:
  1267.               fprintf(var_file,"%s  ",(*ObjectPtr).Name());
  1268.               break;
  1269.          case EVENT:
  1270.               fprintf(var_file,"%s  ",(*ObjectPtr).Name()); 
  1271.               break;
  1272.          case MIB_VALUE:
  1273.               fprintf(var_file,"%s  ",(*ObjectPtr).Hostname());
  1274.               fprintf(var_file,"%s  ",(*ObjectPtr).Obj_Name());
  1275.               fprintf(var_file,"%d  ",(*ObjectPtr).Time_Interval().tv_sec);
  1276.  
  1277.               break;
  1278.          default:
  1279.               break;
  1280.          }
  1281.       fprintf(var_file,"\n");
  1282.       ObjectPtr =(*ObjectPtr).Next();
  1283.       }
  1284.     fprintf(var_file,"9999\n");
  1285.  
  1286.     /*
  1287.      write rule
  1288.     */
  1289.  
  1290.     RulePtr=FirstRule;
  1291.     while (RulePtr != NULL) {
  1292.       fprintf(var_file,"%s ",(*RulePtr).Name());   
  1293.       PremPtr=(*RulePtr).Premise();
  1294.       while (PremPtr != NULL) {
  1295.          fprintf(var_file,"%d ",(*PremPtr).Op());
  1296.          fprintf(var_file,"%s ",(*(*PremPtr).Object()).Name());
  1297.          switch ((*PremPtr).Op()) {
  1298.            case EQUAL_STR:
  1299.               fprintf(var_file,"%s ",(*PremPtr).Value());
  1300.               break;
  1301.            case EQUAL_INT:
  1302.            case BIGGER:
  1303.            case LESSER:
  1304.               fprintf(var_file,"%d ",(*PremPtr).INT_Value());
  1305.               break;
  1306.            default:
  1307.               break;
  1308.            };
  1309.          PremPtr=(*PremPtr).Next();
  1310.          }
  1311.       fprintf(var_file,"8888 ");
  1312.  
  1313.       /* conclusion*/
  1314.       fprintf(var_file,"%s ",(*(*(*RulePtr).Conclusion()).Object()).Name());   
  1315.       fprintf(var_file,"%s ",(*(*RulePtr).Conclusion()).Value());   
  1316.  
  1317.       fprintf(var_file,"\n");
  1318.       RulePtr=(*RulePtr).Next();
  1319.       }
  1320.     fprintf(var_file,"END\n");
  1321.  
  1322. }
  1323.  
  1324. /* set all Event and Problem as unknow */
  1325. void Clear_DB()
  1326. {
  1327.   ObjectType *ObjPtr;
  1328.  
  1329.     ObjPtr=FirstObject;
  1330.     while (ObjPtr != NULL ) {
  1331.        switch ((*ObjPtr).Type()) {
  1332.          case MIB_VARIANCE:
  1333.            break;
  1334.          case MIB_VALUE:
  1335.            break;
  1336.          case PROBLEM:
  1337.            (*ObjPtr).set_Known(0);
  1338.            (*ObjPtr).set_Value("");
  1339.            break;
  1340.          case EVENT:
  1341.            (*ObjPtr).set_Known(0);
  1342.            (*ObjPtr).set_Value("");
  1343.            break;
  1344.          default:
  1345.            break;
  1346.          }
  1347.        ObjPtr=(*ObjPtr).Next();
  1348.        };
  1349. }
  1350.         
  1351.  
  1352. void ITRDB()
  1353. {
  1354.   int c;
  1355.   int type;
  1356.   char str[MaxCharactersObjectName];
  1357.   char ObjName[MaxCharactersObjectName];
  1358.   struct ObjectType *ObjPtr; 
  1359.  
  1360.   
  1361.   Explanation=True;   
  1362.   NumberofObjects=0;
  1363.   NumberofRules=0;
  1364.   FirstObject=NULL;
  1365.   Finish=False;
  1366.   EraseScreen();
  1367.  
  1368.   do {
  1369.     GenerateList(List,&Length1,1); /***** Fun 2 ********/
  1370.     OptionList(List,Length1,&option); /****** Fun 3 ********/
  1371.     switch (option) {
  1372.       case 1:
  1373.            GenerateList(List,&Length1,2); /******** Fun 2 **********/
  1374.            OptionList(List,Length1,&option1); /******* Fun 3 *******/
  1375.            switch (option1) {
  1376.              case 1:
  1377.               /* old version
  1378.    
  1379.                 GiveNameofObject(ObjectName); 
  1380.                 while (strncmp(ObjectName,"quit",4)) {
  1381.                   ObjectPtr=SearchObject(ObjectName); 
  1382.                   if (ObjectPtr ==NULL) 
  1383.                       ObjectPtr=CreateObject(ObjectName); 
  1384.                   GiveNameofObject(ObjectName);
  1385.                   };
  1386.               */
  1387.  
  1388.                 printf("\nGive type of the object(9999 end):");
  1389.                 scanf("%d", &type);
  1390.                 while (type != 9999) {
  1391.                   ObjectPtr=CreateObject2(type);
  1392.                   printf("\nGive type of the object(9999 end):");
  1393.                   scanf("%d", &type);
  1394.                   }
  1395.                 break;
  1396.              case 2:
  1397.                  /****Erase an Object from the object list******/
  1398.                  EraseObject();        /*****Fun 20*******/
  1399.                  break;
  1400.              case 3:
  1401.                  ListObjects(); /*** Fun 9****/
  1402.                  break;
  1403.              default:
  1404.                  break;
  1405.              };
  1406.            break;
  1407.       case 2:
  1408.            GenerateList(List,&Length1,2);      /**** Fun 2 *************/      
  1409.            OptionList(List,Length1,&option1);  /**** Fun 3 *************/
  1410.            switch (option1) {
  1411.              case 1:
  1412.                   c=GiveRuleName(RuleName);     /***** Fun 10 ***********/     
  1413.                   while (c==1)  {
  1414.                     if(SearchRule(RuleName) == NULL); /*Fun 11*/
  1415.                        RulePtr=CreateRule(); /*Fun 13*/
  1416.                     c=GiveRuleName(RuleName); /*Fun 10*/
  1417.                     }
  1418.                   break;
  1419.              case 2:
  1420.                   c=GiveRuleName(RuleName);
  1421.                   while( c== 1) {
  1422.                      if ( EraseRule(RuleName))
  1423.                         printf("\n %s is erased",RuleName);
  1424.                      else
  1425.                         printf("\n No such Rule");
  1426.                      c=GiveRuleName(RuleName);
  1427.                      }
  1428.                   break;
  1429.              case 3:
  1430.                   ListRules();      
  1431.                   break;
  1432.              default:
  1433.                   break;
  1434.              }
  1435.            break;
  1436.       case 3:
  1437.            GenerateList(List,&Length1,3);
  1438.            OptionList(List,Length1,&option1);
  1439.            switch (option1) {
  1440.                case 1:
  1441.                      InitializeObjects();   /***Fun 16***/
  1442.                      break;
  1443.                case 2:
  1444.                      GiveObjectValue();     /***Fun 17***/
  1445.                      break;
  1446.                case 3:
  1447.                      ListFacts();
  1448.                      break;
  1449.                default:
  1450.                      break;
  1451.                }
  1452.            break;
  1453.       case 4:
  1454.            do {
  1455.               printf("\nGive name of the object(if no more enter quit):");
  1456.               scanf("%s",ObjName);
  1457.               printf("\n something");
  1458.               ObjPtr=SearchObject(ObjName);
  1459.               if (ObjPtr != NULL ) {
  1460.                  BackwardChaining(ObjPtr);
  1461.                  if (Explanation == False)
  1462.                     printf("\nConcludes: (%s)=(%s)",ObjPtr->Name,ObjPtr->Value);
  1463.                  }
  1464.               else {
  1465.                  printf("\n This object does not exist");
  1466.                  }
  1467.               printf("\n Done? (y/n)");
  1468.               scanf("%s",str);
  1469.               } while (strcmp(str,"y"));
  1470.            break;
  1471.       case 5:
  1472.            do {
  1473.               ForwardChaining();
  1474.               printf("\n Done? (y/n)");
  1475.               scanf("%s",str);
  1476.               } while (strcmp(str,"y"));
  1477.            break;
  1478.       case 6:
  1479.            Save_DB();
  1480.            break;
  1481.       case 7:
  1482.            Load_DB();
  1483.            break;
  1484.       case 8:
  1485.            printf("\n Explanation? (y/n)");
  1486.            scanf("%s",str);
  1487.            if (!strcmp(str,"y")) 
  1488.               Explanation=True;
  1489.            else
  1490.               Explanation=False;
  1491.            break;
  1492.       case 9:
  1493.  
  1494.            Finish=1;
  1495.            break;
  1496.       default:
  1497.  
  1498.            break;
  1499.       };
  1500.   } while (Finish == 0);
  1501.  
  1502. }
  1503.  
  1504.