``````{
From: Rene Schwietzke <rs@informatik.tu-cottbus.de>
}

program wildcards;
{****************************************************************************
*  René Schwietzke  Richard-Koenig-Str. 08  D-04916 Herzberg  GERMANY      *
*                                                                          *
*  Internet: rs@informatik.tu-cottbus.de                                   *
****************************************************************************
*  This is my implementation of a simple wildcard recognizer.              *
*  Try it !                                                                *
*  Please check the correctness, report all bugs and say your opinion.     *
*                                                                          *
*  written in Borland Pascal 7.0 with using of exit, break and continue    *
****************************************************************************
}
uses crt; {only for this demo}
{ *                : >=0 letters
for example:
*A              : words with >=1 letters and A at the end
A*A             : words with >=2 letters and A at the begin and end
A*              : words with >=1 letters and A at the begin

?                : one letter

Combine it !
See the examples at the end.}

{********** this function returns true if input_word=wilds ****************}
Function Wild(input_word,wilds:String;upcase_wish:boolean):Boolean;

{looking for next *, returns position and string until position}
function search_next(var wilds:string):word;
var position,position2:word;
begin
position:=pos('*',wilds); {looks for *}

if position<>0 then wilds:=copy(wilds,1,position-1);
{returns the string}

search_next:=position;
end;

{compares a string with '?' and another,
returns the position of helpwilds in input_word}
function find_part(helpwilds,input_word:string):word;
var q,q2,q3,between:word;
diff:integer;
begin
q:=pos('?',helpwilds);

if q=0 then
begin
{if no '?' in helpwilds}

find_part:=pos(helpwilds,input_word);
exit;
end;

{'?' in helpwilds}
diff:=length(input_word)-length(helpwilds);
if diff<0 then begin find_part:=0;exit;end;
between:=0;

{now move helpwilds over input_word}
for q:=0 to diff do
begin
for q2:=1 to length(helpwilds) do
begin
if (input_word[q+q2]=helpwilds[q2]) or (helpwilds[q2]='?') then
begin if q2=length(helpwilds) then begin find_part:=q+1;exit;end;end
else break;
end;
end;
find_part:=0;
end;
{************************** MAIN ******************************************}
{                this is the mainpart of wild                              }
var cwild,cinput_word:word;{counter for positions}
q,lengthhelpwilds:word;
maxinput_word,maxwilds:word;{length of input_word and wilds}
helpwilds:string;
begin
wild:=false;

{uncomment this for often use with 'wildcardless' wilds}
{if wilds=input_word then begin wild:=true;exit;end;}

{delete '**', because '**'='*'}
repeat
q:=pos('**',wilds);
if q<>0 then
wilds:=copy(wilds,1,q-1)+'*'+copy(wilds,q+2,255);
until q=0;

{for fast end, if wilds only '*'}
if wilds='*' then begin wild:=true;exit;end;

maxinput_word:=length(input_word);
maxwilds     :=length(wilds);

{upcase all letters}
if upcase_wish then
begin
for q:=1 to maxinput_word do input_word[q]:=upcase(input_word[q]);
for q:=1 to maxwilds do wilds[q]:=upcase(wilds[q]);
end;

{set initialization}
cinput_word:=1;cwild:=1;
wild:=true;

repeat
{equal letters}
if input_word[cinput_word]=wilds[cwild] then
begin
{goto next letter}
inc(cwild);
inc(cinput_word);
continue;
end;

{equal to '?'}
if wilds[cwild]='?' then
begin
{goto next letter}
inc(cwild);
inc(cinput_word);
continue;
end;

{handling of '*'}
if wilds[cwild]='*' then
begin
helpwilds:=copy(wilds,cwild+1,maxwilds);{takes the rest of wilds}

q:=search_next(helpwilds);{search the next '*'}

lengthhelpwilds:=length(helpwilds);

if q=0 then
begin
{no '*' in the rest}
{compare the ends}
if helpwilds='' then exit;{'*' is the last letter}

{check the rest for equal length and no '?'}
for q:=0 to lengthhelpwilds-1 do
if (helpwilds[lengthhelpwilds-q]<>input_word[maxinput_word-q]) and
(helpwilds[lengthhelpwilds-q]<>'?') then
begin wild:=false;exit;end;
exit;
end;

{handle all to the next '*'}
inc(cwild,1+lengthhelpwilds);
q:=find_part(helpwilds,copy(input_word,cinput_word,255));
if q=0 then begin wild:=false;exit;end;
cinput_word:=q+lengthhelpwilds;
continue;
end;

wild:=false;exit;

until (cinput_word>maxinput_word) or (cwild>maxwilds);
{no completed evaluation}
if cinput_word<=maxinput_word then wild:=false;
if cwild<=maxwilds then wild:=false;
end;

begin
clrscr;
{examples with the right result 'T' or 'F'}
writeln(wild('Gebauer','G?bauer',false),' T');
writeln(wild('Heiter','*r*s',false),' F');
writeln(wild('Löffler','*r*s',false),' F');
writeln(wild('Trinks','*r*s',false),' T');
writeln(wild('Schwietzke','*e*e*',false),' T');
writeln(wild('Endemann','*e*e*',false),' F');
writeln(wild('Schwietzke','Schwietzke',false),' T');
writeln(wild('Schwietzke','*',false),' T');
writeln(wild('Schwietzke','Schwi*',false),' T');
writeln(wild('Schwietzke','*tzke',false),' T');

writeln(wild('Schwietzke','S?hwie*e',false),' T');
writeln(wild('Schwietzke','S*??*e',false),' T');

writeln(wild('Schwietzke','S*e',false),' T');
writeln(wild('Schwietzke','*e',false),' T');

writeln(wild('Schwietzke','S*k*',false),' T');
writeln(wild('Schwietzke','S??w??tzke',false),' T');
writeln(wild('Schwietzke','Sch*?t*ke',false),' T');
writeln(wild('Schwietzke','Sch*k',false),' F');
writeln(wild('Schwietzke','Sch*i?t*k?',false),' T');

writeln(wild('Physik in Übersichten','?*',false),' T');
writeln(wild('Physik in Übersichten','P*??*en',false),' T');

writeln(wild('Alle Physik in Übersichten Physik in Ablagen',
'*n Physik*',false),' T');

{Thank's for testing and using.}
{René Schwietzke 01-16-1995}
end.

``````