To make the user input case-insensitive, it turns out that we don't need to change the parser at all.  Instead, we need to change the tokenizer to change all parsed tokens to lowercase (except for strings, we want to allow the user to specify case in strings).  We need to make a new class which descends from TIEClipsStream.  The TIEClipsStream class has a protected method, FinishToken, which is called whenever a token is parsed.  We override this method and convert the string input to lowercase (you need to add IEInterfaces to the uses clause too):

 

  TCIStream = class(TIEClipsStream)
  private
    { Private declarations }
  protected
    { Protected declarations }
    function FinishToken(AChar: Integer;
      const AString: String): IStreamToken; override;
  public
    { Public declarations }
  published
    { Published declarations }
  end;
 

{ TCIStream }

 

function TCIStream.FinishToken(AChar: Integer;
  const AString: String): IStreamToken;
begin
     if AChar <> Ord('"') then
        result := inherited FinishToken(AChar, LowerCase(AString))
     else
        result := inherited FinishToken(AChar, AString);
end;

 

Our code above checks the AChar parameter, which gives a hint about the token data type to create, to see if it is a string.  If it is not, it converts the AString input parameter to lowercase and calls the inherited FinishToken method.  Otherwise, if it is a string, we leave the AString input parameter alone and call the inherited method.

 

Voila!  We are done with the parsing and tokenization.  To make our new TInferenceEngine component USE the new tokenizer, we set the TokenizerType property.  For our purposes, we will set the TokenizerType property in the TCIInferenceEngine constructor:

constructor TCIInferenceEngine.Create(AOwner: TComponent);
begin
     inherited Create( AOwner );
     TokenizerType := TCIStream;
end;
 

 

Ok, now we have finished the user input part of our problem.  To make sure the TInferenceEngine functions and variables match the lowercase user-input, we need to set some global variables.  We will create an initialization section for the unit and set the variables (note for the following code you need to add the IEConsts and IEValue units to your uses clause):

initialization
   SDefaultSlotName := LowerCase(SDefaultSlotName);
   SInitialFactPattern := LowerCase(SInitialFactPattern);
   SInitialFact := LowerCase(SInitialFact);
   SEmptyFuzzy := LowerCase(SEmptyFuzzy);
   SLocalBinding := LowerCase(SLocalBinding);
   SPatternBinding := LowerCase(SPatternBinding);
   SRuleBinding := LowerCase(SRuleBinding);
   SNULLFact := LowerCase(SNULLFact);
   STypeSymbolKeyword := LowerCase(STypeSymbolKeyword);
   STypeAtomKeyword := LowerCase(STypeAtomKeyword);
   STypeStringKeyword := LowerCase(STypeStringKeyword);
   STypeIntegerKeyword := LowerCase(STypeIntegerKeyword);
   STypeFloatKeyword := LowerCase(STypeFloatKeyword);
   STypeLexemeKeyword := LowerCase(STypeLexemeKeyword);
   STypeNumberKeyword := LowerCase(STypeNumberKeyword);
   STypeClassKeyword := LowerCase(STypeClassKeyword);
   STypeDescriptorKeyword := LowerCase(STypeDescriptorKeyword);
   STypeObjectKeyword := LowerCase(STypeObjectKeyword);
   STypeExternalAddrKeyword := LowerCase(STypeExternalAddrKeyword);
   STypeFuzzyKeyword := LowerCase(STypeFuzzyKeyword);
   STypeFactKeyword := LowerCase(STypeFactKeyword);
   STypeFactIdKeyword := LowerCase(STypeFactIdKeyword);
   STypeVariableKeyword := LowerCase(STypeVariableKeyword);
   FCTrue.AsAtom := 'true';
   FCFalse.AsAtom := 'false';
   FCEOF.AsAtom := 'eof';
 

 

Note that, in general, this new unit cannot coexist with regular TInferenceEngine components because they use the same global variables.

 

At this point, we are done.  You can easily test this component.  Create a new application and form and add your component unit to the uses clause.  In the OnCreate event of the form, create the TCIInferenceEngine component:

procedure TForm1.FormCreate(Sender: TObject);
begin
     CIInferenceEngine1 := TCIInferenceEngine.Create(Self);
end;

 

Drop a button and a TConsoleDialog component on the form.  In the button's OnClick event, assign the CIInferenceEngine1 component to the console dialog's Engine property and execute it:

procedure TForm1.Button1Click(Sender: TObject);
begin
     ConsoleDialog1.Engine := CIInferenceEngine1;
     ConsoleDialog1.Execute;
end;

 

Compile and run the application.  Click the button and play with the new case-insensitive inference engine!