--- Program M - AIML interpreter, A.L.I.C.E. Chat Robot 
--- (c) 2002 Dr. Richard S. Wallace - drwallace@alicebot.org
--- ALICE A.I. Foundation, Inc. - Www.AliceBot.Org 
--- Free software distributed under the terms of 
--- the GNU General Public Lincense as published by the
--- Free Software Foundation, Inc.
---
var VersionString := 
    'Program M (AIML in SETL) version version 0.5 03/04/2002';
--- M = Graphmaster + Substitutions + Matching + AIML Parser + Autochat +
---     Loebner Interface + Targeting 

---- Usage:
---- setl M.setl : default mode (Loebner)
---- setl M.setl -x test : run test function.
---- setl M.setl -x build : build the Graphmaster graph from AIMLFiles.
---- setl M.setl -x update : update the Graphmaster graph from DATADIR/new.aiml
---- setl M.setl -x update F : update the Graphmaster graph from file F
---- setl M.setl -x loebner : Console Loebner Contest-style interface.
---- setl M.setl -x autochat : Robot chats to itself and creates targets.
---- setl M.setl -x autochat N : AutoChat for N iterations
---- setl M.setl -x Any other text statement or query. : Produces a 
---- "one-shot" response to a single sentence input.  Make sure the
---- query is not one of: test, build update, loebner, or autochat!

--- Not fully implemented yet: 
--- <condition>, 
--- <gossip> (partial implementation), <javascript>.

--- Macro:
#define flatten(path, m, n) +/[x+' ' : x in path(m..n)] 
--- Global variables:
var ROOT := 'graph'; -- ROOT of the Graphmaster graph as a folder.
var DATADIR := 'data'; --- location of output data file directory.
var CLIENTDIR := 'data/clients'; --- location client information.
var CONFIGDIR := 'config'; --- location of configuation files (must exist).
---- The following files must exist:
var aimlfiles := unstr getfile(CONFIGDIR+'/files.txt'); -- AIML source Files
var delims := unstr getfile(CONFIGDIR+'/delims.txt'); -- Delimeters, Abbre-
var abbrevs :=  unstr getfile(CONFIGDIR+'/abbrevs.txt'); -- viations
var pronouns := unstr getfile(CONFIGDIR+'/pronouns.txt'); -- Pronouns
var defaults := unstr getfile(CONFIGDIR+'/defaults.txt'); -- Predicate Defaults
var normsubs := unstr getfile(CONFIGDIR+'/normsubs.txt'); -- Normalization substs.
var macrosubs := unstr getfile(CONFIGDIR+'/macrosubs.txt'); -- Macro tag substs.
var formalsubs := unstr getfile(CONFIGDIR+'/formalsubs.txt'); -- <formal> substs.
var personsubs := unstr getfile(CONFIGDIR+'/personsubs.txt'); -- <person> substs.
var person2subs := unstr getfile(CONFIGDIR+'/person2subs.txt');-- <person2> substs.
var prompt := '% '; --- Initial Prompt for Loebner interface
---- Magic numbers:
var DialogDepth := 4; --- Depth of memory for <input> and <that>
var TargetLimit := 25; --- Maximum number of suggested categories generated.
var DeepestDepth := 64; -- Limit of AIML Template parser recursion depth.
var AutoChatIterations := 1000; --- Number of iterations to run Auto Chat.
var NCategories := 45000;  --- Estimated number of categories.
var NVocabulary := 8000;   --- Estimated vocabulary size
var RAM := '100K';   --- Estimated vocabulary size
--- This group of definitions is ASCII-centric:
var numerals := "0123456789"; -- Arabic Numerals
var uppercase := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; -- Capital Letters
var lowercase := "abcdefghijklmnopqrstuvwxyz"; -- small letters
var alphanumerics := uppercase+lowercase+numerals; -- All of the above.
var doublequote := '"'; -- Insidious double-quote character
var singlequote := "'"; -- Insidious single-quote character
var quotemarks := doublequote+singlequote; -- Insidious duo.
var escapechars := "\n\\ "; -- Peksy escape charachters.
var glyphs := '.?!@#$%^&*[]{}()_-~`:;,/+=|'; -- Cave Man Drawings.
--- templatechars is the set of all text chars allowed outside tags
--- in the AIML <template>
var templatechars := escapechars+alphanumerics+glyphs+quotemarks; 
--- in other words, just about any character except for < and >.
var Predicates := {}; -- Client predicate map
var Properties := -- Bot properties map
{['arch','SETL'],['os','Linux'],['nclients',1],['hourlyqueries',3600],
  ['size',NCategories],['vocabulary',NVocabulary],['memory',RAM]};
  
var Activations := {}; -- Activated AIML categories.
var Targets := {}; -- Potential new AIML categories.
var UpdateFile := DATADIR+'/new.aiml';

var ArgFun := { --- map from command line args to program functions.
[['build', 1], routine BuildGraph], [['update', 1], routine UpdateDefault],
[['update', 2], routine Update], [['test', 1], routine Test],
[['loebner', 1], routine Loebner], [['autochat', 1], routine AutoChat],
[['autochat', 2], routine AutoChat]
};

---- BEGIN MAIN PROGRAM -----
---- Note: the CONFIGDIR directory must exist for the program to run.

setrandom(0); --- Seed random number generation
magic := false; --- Disable SETL Regular Expression matching
if not fexists(DATADIR) then system('mkdir '+DATADIR); end if;
if not fexists(CLIENTDIR) then system('mkdir '+CLIENTDIR); end if;
if not fexists(ROOT) then --- 
  system('mkdir '+ROOT); 
  aimlfiles := [CONFIGDIR+'/default.aiml'];
  BuildGraph;
end if;

if #command_line >= 1 -- The equivalent of argv[]
then cmd := command_line(1);
else cmd := 'test';
end if;

if exists [fun, argc] in domain ArgFun | cmd = fun and #command_line = argc 
then F := ArgFun(fun, argc);
else F := routine OneShot; --- default
end if;
Initialize('localhost');
call(F);
---- END MAIN PROGRAM

--- OneShot:
--- Respond to single command line input

proc OneShot; 
if fexists(CLIENTDIR+'/localhost.txt') then 
  Predicates := unstr getfile(CLIENTDIR+'/localhost.txt');
else 
  Initialize('localhost');
end if;
if #command_line = 0 then print('You said nothing.'); 
else 
  multiline := +/[x+' ' : x in command_line];
  MultiLineResponse('localhost', multiline, routine Mprint);
end if;
putfile(CLIENTDIR+'/localhost.txt', str Predicates);
Dialogai('localhost'); 
end proc;

proc Test; --- for debugging
x := "My name is ALICE.  \nI live on St. John St. near Dr. Richard S. Wallace.  I'll ask you a question o.k.?\n\n  Isn't this a good question?";
print(x);
s := Sentenceai(x);
print('Sentenceai(x)='+s);
for z in s loop;
  print('INPUT='+z);
  print('NORMALIZE='+Normalize(z));
  print('CAPITALIZE='+Capitalize(z));
  print('FORMALIZE='+Formalize(z));
  print('TITLEAI='+Titleai(z));
end loop;
end proc;

--- Initialize predicate maps for a client.

proc Initialize(client);
  Predicates(client, 'inputs') ?:= ['Undefined'];
  Predicates(client, 'thats') ?:= [['Undefined']];
end proc;

---- Autochat: make the bot talk to itself.
---- Followed by targeting.

proc Autochat;
if #command_line > 1 then
  AutoChatIterations := unstr command_line(2);
end if;
input := 'xxx'; --- initial input.
for i in [1..AutoChatIterations] loop; --- AutoChatIterations is global.
  previouspath :=  path; --- Save previouspath for infinite loops
  [reply, path] := Answer(input, 'localhost'); --- Get the reply.
  print(i+'. ALICE: '+reply); 
  if path /= previouspath or path = ROOT+'/star/that/star/topic/star'
  then
    input := Sentenceai(reply); input := input(#input); input ?:= 'Undefined.';
  else input := 'DEFAULT'; --- Reset after infinite loop detected.
 end if;
flush(1);
end loop;
AIMLTargets;  --- Run the Targeting program
print(#Activations+' activated. '+#Predicates+' Predicates set.');
histo := +/[Activations(x)+' '+x+'\n' : x in domain Activations];
histo ?:= 'No Histogram';
tempfile := tmpnam;
putfile(tempfile, histo);
system('sort -n '+tempfile+' > data/activations.txt');
---Dialogai('localhost');
end proc;

--- AIMLTargets: Process all detected target categories and
--- create a file of potential new AIML categories.

proc AIMLTargets;
maxi := max/{#Targets{x} : x in domain Targets};
maxi ?:= 0;
newtargets := {};
for n in [1..maxi] loop;
for x in domain Targets loop; 
if #Targets{x} = n then 
  resultset := {};
  path := split(x, ' ');
  for y in Targets{x} loop;
    targetpath := split(y, ' ');
    result := Targetize(path, targetpath);
    resultset := resultset with result;
  end loop; --- y
  if #newtargets < TargetLimit then
  newtargets +:= resultset;
  end if;
end if; 
end loop; 
end loop; 

--- Targets are saved in the file targets.aiml.
--- Any targets with templates are merged with those in the update file.
--- Backup the update file as new.save

existingtargets := getfile(DATADIR+'/targets.aiml');
existingtargets ?:= '';
rmatch(existingtargets, '</aiml>');
match(existingtargets, '<aiml>');
existingtemplated := {x : x in split(existingtargets, '\n') | '<template></template>' notin x};
newtargetaiml := +/[x+'\n' : x in newtargets];
newtargetaiml := '<aiml>\n'+newtargetaiml+'\n</aiml>';
putfile(DATADIR+'/targets.aiml', newtargetaiml);
if fexists(UpdateFile) then 
  existingaiml := getfile(UpdateFile);
else existingaiml := '';
end if;
rmatch(existingaiml, '</aiml>');
match(existingaiml, '<aiml>');
newaimlset := {x : x in split(existingaiml, '\n')} + existingtemplated;
newaiml := +/[x+'\n' : x in newaimlset];
newaiml := '<aiml>\n'+newaiml+'\n</aiml>';
system('cp '+UpdateFile+' '+DATADIR+'/update.save'); 
putfile(UpdateFile, newaiml);
end proc;

---- Categorize:
---- Create an AIML category from pattern, that, topic, and template.

proc Categorize(pattern, that, topic, template);
template := '<template>'+template+'</template>';
pattern := '<pattern>'+pattern+'</pattern>';
if that /= '*' then that := '<that>'+that+'</that>'; else that := ''; end if;
category := '<category>'+pattern+that+template+'</category>';
if topic /= '*' then 
  category := '<topic name="'+topic+'">'+category+'</topic>';
end if;
return category;
end proc;

--- Loebner Contest style interface

proc Loebner;
multiline := '';
that := 'UNDEFINED';
print(getfile(CONFIGDIR+'/loebner.txt'));
loop
  nprint(prompt); flush(1);
  line := getline(0);
  if (#line <= 0) then
    MultiLineResponse(client, multiline, routine Lprint);    
--     Dialogai('localhost'); 
    multiline := '';
else multiline +:= ' '+line;
end if;
end loop;
end proc;


proc Update;
UpdateFile := command_line(2);
UpdateDefault;
end proc;

proc UpdateDefault;
aimlfiles := [UpdateFile];
AIMLTargets; -- move any new categories to UpdateFile
BuildGraph;
end proc;

--- BuildGraph: Read AIML files and build the Graphmaster in
--- the filesystem.

proc BuildGraph;
count := 0;
for L in aimlfiles loop
print(L);
x := getfile(L);
y := split(x, '<topic name=');
for z in y loop
  w := split(z, '<category>');
  for c in w loop
     if AddCategory(c, ROOT, '*', L) then count +:= 1; end if;
  end loop;
end loop;
end loop;
print('Graph in filesystem. '+count+' categories loaded.');
end proc;

--- AddCategory: add one new category to
--- the Graphmaster graph.

proc AddCategory(c, ROOT, topic, sourcefile);
  break(c, '<'); 
  match(c, '<pattern>'); 
  rbreak(c, '>'); 
  rmatch(c, '</aiml>'); 
  rbreak(c, '>'); 
  rmatch(c, '</category>'); 
  rbreak(c, '>'); 
  rmatch(c, '</template>'); 
  p := split(c, '</pattern>'); 
  if #p=2 then 
    [pattern, template] := p; 
  break(template, '<'); 
  match(template, '<that>'); 
  q := split(template, '</that>'); 
  if #q=2 then 
    [that, template] := q; 
  end if; 
  break(template, '<'); 
  match(template, '<template>'); 
  any(template, ' \n'); rany(template, ' \n'); 
  any(pattern, ' \n'); rany(pattern, ' \n'); 
  path := pattern+' that '+that+' topic '+topic; 
  path := split(path, ' '); 
  if Trimai(template) = '' then 
    print('Category '+path+' has an empty template, discarded');
  else
    return AddPath(ROOT, path, template, sourcefile);
  end if;
  end if; 
  return false;
end proc;

--- Target: Update the target map with a new  

proc Target(input, that, topic, path, template);
  gsub(path, '/', ' ');
  gsub(path, 'graph', '');
  gsub(path, 'star', '*');
  gsub(path, 'under', '_');
  path := Trimai(path);
  input := Trimai(input); topic := Trimai(topic);
  if '<sr' notin template then
    Targets := Targets with [path, input+' that '+that+' topic '+topic];
  end if;
end proc;

--- Targetize: create a new AIML category from
--- an existing graph path and a new path

proc Targetize(existingpath, newpath);

  existingthatindex := ThatIndex(existingpath);
  existingtopicindex := TopicIndex(existingpath);
  newthatindex := ThatIndex(newpath);
  newtopicindex := TopicIndex(newpath);
  if exists i in [1..#existingpath] | existingpath(i) = '*' or existingpath(i) = '_' then starindex := i; end if;
  if starindex < existingthatindex then
      pattern := flatten(newpath, 1, starindex);
      if starindex = newthatindex-1 then
        result := Categorize(pattern, '*', '*', '');
      else
        result := Categorize(pattern+'*', '*', '*', '');
      end if;
      elseif starindex < existingtopicindex then
        that := flatten(newpath, existingthatindex+1, starindex);
      if starindex = newtopicindex-1 then
        result := Categorize(pattern, that, '*', '');
      else 
        result := Categorize(pattern, that+' *', '*', '');
      end if;
    end if;
    return result;
end proc;

--- Normalize: Return a string in AIML pattern normalized form.
--- 

proc Normalize(x);
  x ?:= ' Om ';
  norm := to_upper(x);
  norm := Substitute(norm, normsubs);
  gsub(norm, '\n', ' ');
  return norm;
end proc;

---   Substitute(s, m):
---   A fundamental operation in AIML.  Substitute is a genaralization
---   of string substitution (e.g. SETL gsub) to process an array or tuple of
---   substitution pairs.  The substitution are stored externally in files.
---   They are processed one pair at a time, in order of appearance.

proc Substitute(s, subs);
  s := ' '+s+' '; -- make sure s begins and ends with a space.
  for [x, y] in subs loop;
    gsub(s, x, y);
  end loop;
  return Trimai(s);
end proc;

--- Trimai: Trim a string by removing any leading or trailing
--- blankspaces and/or newline characters.

proc Trimai(s);
  if not is_string s then s := str s; end if; -- must be a string
  while any(s,  ' \n') /= '' loop; end loop;
  while rany(s,  ' \n') /= '' loop; end loop;
  return s;
end proc;


--- Sentenceai: Split text string into sentences.

proc Sentenceai(z);  --- string is a multiline sentence
  z := Substitute(z, abbrevs); --- rewrite abbreviations w/o periods.
  for x in delims loop --- Replace all sentence delimeters with "."
    gsub(z, x, '.');
  end loop;
  result := [Formalize(x) : x in split(z, '.') | Trimai(x) /= ''];
  result ?:= ['Undefined sentence.'];
print('SENTENCEAI='+result);
  return result;   --- returns a tuple
end proc;

---- MultiLineResponse(client, input, Func):
---- This is the top-level function for replying to a client input.
---- The input is a string consisting of one or more sentences.
---- The function Func is a routine for displaying, formatting or sending the
---- replies.  MultilineResponse splits the input into sentences, and
---- obtains an answer for each one.  Each answer may contain one or
---- more sentences. 
---- Answer processes sentences one at a time.  The replies depend
---- on the state of the robot.  The state is determined by the
---- sequence of previous replies, but it does not depend on
---- whether the replies resulted from one query or several.
---- For example:
---- The robot does not see any difference between these:
---- C: Hello.
---- R: Hi there!
---- C: My name is Rich.  What are you?
---- R: Rich, are you my master?  I am the latest result in A.I.
---- and
---- C: Hello. My name is Rich.  What are you?
---- R: Hi there! Rich, are you my master?  I am the latest result in A.I.
---- In either case, the history of input and that is
---- exactly the same sequences of values.
---- At present, AIML has no defined way of indexing the top-level
---- multiline inputs. We may add this feature in the future.
---- For now, the input sequence is stored in a one-dimensional array or table.
---- The AIML code <input index="N"/> refers to the Nth element of the table.
---- The output that values are stored in a two-dimensional array or table.
---- The AIML code <that index="M,N"/> refers to the Nth element of the 
---- Mth term in the "that" table.
---- Cross reference this code with the following AIML
---- Parser code fragment dealing with <input/> and <that/>:
---- 
---- inputs := Predicates(client, 'inputs'); 
---- thats :=  Predicates(client, 'thats');
---- ...
----  elseif exists k in [1..DialogDepth] | 
----    match(remainder, '<input index="'+k+'"/>') /= '' then 
----    result := inputs(k);
----  elseif exists k in [1..DialogDepth] | exists m in [1..DialogDepth] |
----    match(remainder, '<that index="'+k+','+m+'"/>') /= '' then 
----    result := thats(k)(m);
---- ...
---- Note: match(X, Y) /= '' means Y starts with X.
---- remainder is the remainder of the selected template.

proc MultiLineResponse(client, input, Func);
  multiline := Sentenceai(input); -- Split the input into sentences.
  for sentence in multiline loop; -- Reply to each sentence
    [reply, path] := Answer(sentence, 'localhost');
    call (Func, sentence, reply); -- Do something with the response.
  end loop;
end proc;

--- Sample display functions for MultiLineResponse
proc Lprint(x, y); print(prompt+' '+y); end proc; -- w/prompt
proc Mprint(x, y); print(y); end proc; -- no promt.


--- Answer: Provide robot reply to a client sentence or query.
--- The input is a single sentence.  The output reply may consist of
--- one or more sentences.

proc Answer(input, client);
  stars := []; depth := 0; --- Initialize environment
  environ := [client, stars, matchpath, depth]; -- Matching environment.
  [reply, path] := Srai(input, environ); -- Match and evaluate template.
  inputs := Predicates(client, 'inputs'); -- Get input history.
  inputs := [input]+inputs; -- Prepend new input to history.
  inputs := inputs(1..DialogDepth); -- Discard oldest input from history.
  thats :=  Predicates(client, 'thats');  -- Get that history.
  thats := [Sentenceai(reply)]+thats; -- Prepend the reply to that history.
  thats := thats(1..DialogDepth); -- Discard oldest that from history.
  Predicates(client, 'inputs') := inputs; -- Save input history.
  Predicates(client, 'thats') := thats; -- Save that history.
  return([reply, path]);
end proc;

--- Dialogai: Display the last few lines of dialog.
--- Uses the stored values of "input" and "that" 

proc Dialogai(client);
thats := Predicates(client, 'thats');
inputs := Predicates(client, 'inputs');
for i in [#thats-i+1 : i in [1..#thats]] loop;
  print('C: '+inputs(i)+"."); --- The ith input goes with
  sentences := thats(i);   --- the ith "that" response.
  for x in sentences loop; print('R: '+x+'.'); end loop;
end loop;
flush(1);
end proc;


--- Response: top level AIML template evaluator.

proc Response(environ, remainder);
  [client, stars, matchpath, depth] := environ;
  prefix := ''; 
  if depth < DeepestDepth then 
    environ :=  [client, stars, matchpath, depth+1];
    while remainder /= '' loop;
      remainder := Macroai(remainder); --- AIML Macro Substitutions
      [result, remainder] := Tagai(environ, remainder); -- Process tag.
      remainder :=  prefix + result + remainder; --- Recombine result.
      remainder := Trimai(remainder); 
      prefix := span(remainder, templatechars); --- Advance to next '<'
    end loop;
  end if;
  return prefix;
end proc;

-- Tagai: Look for AIML tags in the template and process them.
-- Basically, the evaluation order is left-to-right, and inside-out.
-- One exception is the <random> tag. The program first picks one
-- of the random list elements and then evaluates it, rather
-- than evaluating all of them.

proc Tagai(environ, remainder);
  [client, stars, matchpath, depth] := environ;
  TagFunctions := 
{['srai', routine Srai],
 ['think', routine Thinkai],
 ['system', routine Systemai],
 ['random', routine Randomai],
 ['person', routine Personai],
 ['gossip', routine Gossipai],
 ['person2', routine Person2ai],
 ['condition', routine Ifai] 
};
  inputs := Predicates(client, 'inputs'); 
  thats :=  Predicates(client, 'thats');
  if match(remainder, '<version/>') /= ''
  then result := VersionString;
  elseif exists k in [1..9] | 
    match(remainder, '<star index="'+k+'"/>') /= '' then 
    if stars = om then result := 'No stars';
    else stars(k) ?:= 'Unbound';
       result := stars(k);  
    end if;
  elseif exists k in [1..DialogDepth] | 
    match(remainder, '<input index="'+k+'"/>') /= '' then 
    result := inputs(k);
  elseif exists k in [1..DialogDepth] | exists m in [1..DialogDepth] |
    match(remainder, '<that index="'+k+','+m+'"/>') /= '' then 
    result := thats(k)(m);
  elseif exists k in [1..9] | 
    match(remainder, '<thatstar index="'+k+'"/>') /= '' then 
    result := Thatstar(stars, matchpath, k);
  elseif exists k in [1..9] | 
    match(remainder, '<topicstar index="'+k+'"/>') /= '' then 
    result := Topicstar(stars, matchpath, k);
  elseif match(remainder, '<get name="') /= '' then 
    pred := break(remainder, '"');
    any(remainder, '"'); any(remainder,'/'); any(remainder, '>');
    result := Getai(client, pred); 
  elseif match(remainder, '<bot name="') /= '' then 
    pred := break(remainder, '"');
    any(remainder, '"'); any(remainder, '/'); any(remainder, '>');
    result := Botai(pred, environ); 
  elseif match(remainder, '<a ') /= '' then 
    break(remainder, '>'); any(remainder, '>');
    result := '';
    while #remainder > 0 and match(remainder, '</a>') = '' loop result := result+break(remainder, '<'); end loop;
  elseif match(remainder, '<set name="') /= '' then 
    pred := break(remainder, '"');
    any(remainder, '"');
    if match(remainder, '/') /= '' then --- atomic tag
      any(remainder, '>');
      inside := stars(1);
    else --- paired tag
      any(remainder, '>');
      inside := Companion(remainder, 'set', pred);
      match(inside, '<set name="'+pred+'">');
      offset := #inside+1;
      rmatch(inside, '</set>');
      while offset > #remainder+1 loop; offset -:= 1; end loop;
      remainder := remainder(offset..);
    end if;
    result := Setai(pred, inside, environ);
  elseif exists tag in domain TagFunctions | 
    match(remainder, '<'+tag+'>') /= '' then 
    [inside, remainder] := Proceed(remainder, tag);
    result := call(TagFunctions(tag), inside, environ);
    if is_tuple result then result := result(1); end if; -- Srai case
  elseif any(remainder,'<') /= '' then --- Unrecognized tag or > symbols
    result := '&lt;'; --- are turned into &lt;
  elseif any(remainder,'>') /= '' then
    result := '&gt;';
  else 
    result := '';
  end if;
  result ?:= '';
  result := Trimai(result);
return([result, remainder]);
end proc;

proc ThatIndex(path);
  if exists i in [1..#path] | path(i) = 'that' then return i; 
  else return 1;
  end if;
end proc;

proc TopicIndex(path);
  if exists i in [1..#path] | path(i) = 'topic' then return i; 
  else return 1;  
  end if;
end proc;

proc Thatstar(stars, path, index);
  match(path, ROOT);
  splitpath := split(path, '/');
  patternstars := #{i : i in [1..ThatIndex(splitpath)] | splitpath(i) = 'star'};
  thatstars := #{i : i in [ThatIndex(splitpath)..TopicIndex(splitpath)] | splitpath(i) = 'star'};
  return stars(index+patternstars);
end proc;

---

proc Topicstar(stars, path, index);
  match(path, ROOT);
  splitpath := split(path, '/');
  patternstars := #{i : i in [1..ThatIndex(splitpath)] | splitpath(i) = 'star'};
  thatstars := #{i : i in [Thatindex(path)..TopicIndex(path)] | splitpath(i) = 'star'};
  return stars(index+patternstars+thatstars);
end proc;

---  Setai: Save a predicate value.
--- 

proc Setai(pred, x, environ);
  [client, stars, matchpath, depth] := environ;
  v := Response(environ, x);  --- evaluate contents
  if pred in {'name','location'} then v := Titleai(v);
  else v := Formalize(v);
  end if;
  Predicates(client, pred) := v;
  if pred in pronouns then return pred; --- return pronoun name
  else return v; --- return contents
  end if;
end proc;

---  Getai: Return a predicate value

proc Getai(client, pred);
  defaults(pred) ?:= 'unknown';  
  Predicates(client ,pred) ?:= defaults (pred);
  x := Predicates(client, pred);
  if pred in {'name','location'} then return Titleai(x);
  else return Formalize(x);
  end if;
end proc;

--- Botai: Return a bot property.

proc Botai(prop, environ);
  prop := to_lower(prop);
  if Properties(prop) = om then
    x := '<srai>BOT '+prop+'</srai>';
    x := Response(environ, x);
  else 
    x := Properties(prop);
  end if;
  return x;
end proc;

--- Gossip: Partially implemented gossip tag.

proc Gossipai(x, environ);
  x := Response(environ, x);
  return Formalize(x);
end proc;

--- Titleai: Similar to Formalize, but each word is capitalized.

proc Titleai(x);
 x := Formalize(x);
 x := +/[Capitalize(z)+' ' : z in split(x, ' ')];
return x;
end proc;

--- Formalize: Make the output string x appear more "formal" or 
--- human readable.  Note: x is not evaluated.

proc Formalize(x);
  x ?:= ' Om '; --- x must be a string.
  x := Substitute(x, formalsubs);
  x := Capitalize(x);
  return x;
end proc;

--- Capitalize a string.

proc Capitalize(x);
if #x > 1 then x := to_upper x(1) + x(2..); 
elseif #x = 1 then x := to_upper x;
end if;
return x;
end proc;

--- Person2ai:
--- ELIZA-style Personal pronoun substitution: 1st<-->3rd person

proc Person2ai(x, environ);
  x := Response(environ, x);
  x := Normalize(x);
  x := Substitute(x, person2subs);
  return Formalize(to_lower x);
end proc;

--- Personai:
--- ELIZA-style Personal pronoun substitution: 1st<-->2nd person

proc Personai(x, environ);
  x := Response(environ, x);
  x := Normalize(x);
  x := Substitute(x, personsubs);
  return Formalize(to_lower x);
end proc;


--- Macroai: Miscellanious AIML, HTML and text substitutions.

proc Macroai(x);
 gsub(x, '\n', ' ');
 gsub(x, '<br/>', '\n');
 gsub(x, '<p/>', '\n\n');
 return Substitute(x, macrosubs);
end proc;

--- Systemai:
--- Execute an operating system command and return the result.

proc Systemai(x, environ);
  x := Response(environ, x);
  tempfile := tmpnam;
  x := x+' > '+tempfile;
  system(x);
  result := getfile(tempfile);
  return(result);
end proc;

--- Thinkai:
--- Evaluate the contents inside the tag, but return the null string.

proc Thinkai(x, environ);
 Response(environ, x);
 return '';
end proc;

--- Future home of condition tag:

proc Ifai(x, environ);
  return('CONDITION NOT IMPLEMENTED'); 
end proc;

proc Randomai(x, environ);
  randomlist := Trimai(x);
  list := [];
  while match(randomlist, '<li>') /= '' loop;
    [item, randomlist] := Proceed(randomlist, 'li');
    randomlist := Trimai(randomlist);
    list +:= [item];
  end loop;
  return random list; --- <random> tag
end proc;

--- Srai:- "symbolic reduction" in AIML, also known as "syntactic rewrite",
--- "simple recursion", "stimulus-response" or "synonym resolution."

proc Srai(x, environ);
  [client, stars, matchpath, depth] := environ;
  topic := Normalize(Predicates(client, 'topic'));
  thats := Predicates(client, 'thats');
  if thats(1) /= om and #thats(1) > 0 then 
    that := Normalize(thats(1)(#thats(1)));
  else that := 'Undefined';
  end if;
  x := Response(environ, x);
  x := Normalize(x);
  if x = om or x = '' then return ['You said nothing','']; end if;
  input := x;
  path := split(x+" that "+that+" topic "+topic, ' ');
  stars := [];
  matchpath := '';
  result := [template, stars, matchpath];
  Matchai(ROOT, path, 1, result);
  [template, stars, matchpath] := result;
print('PATH='+path);
print('MATCH='+matchpath);
  if Activations(matchpath) = om then Activations(matchpath) := 1; 
  else Activations(matchpath) +:= 1; 
  end if;
  Target(input, that, topic, matchpath, template);
  environ :=  [client, stars, matchpath, depth+1];
  reply := Response(environ, template);
  if reply = '' then 
    reply := 'I said nothing.'; 
  end if;
  reply ?:= 'I said OM.'; 
  reply := Formalize(reply);
  return [reply, matchpath];
end proc;

-- AddPath: add a new path to the Graph

proc AddPath(dir, path, template, sourcefile);
  for word in path loop 
    if word = '_' then word := 'under'; end if;
    if word = '*' then word := 'star'; end if;
    dir := dir+'/'+word; 
    if not fexists(dir) then system('mkdir '+dir); end if; 
  end loop; 
  f := dir+'/template';
  if not fexists(f) or Trimai(getfile(f)) = '' then
    putfile(f, template);
    h := dir+'/filename';   
    putfile(h, sourcefile);
    return true; -- success
  else print('DUPLICATE CATEGORY '+f+' discarded.');
  end if;
  return false; -- fail
end proc;

--- Matchai: Find the matching category for a client input
--- by searching the Graphmaster graph.

-- The argument binding is a vector of three elements:
-- The template, an array of star bindings, and the maching path.
-- For example:
--    result := [template, stars, matchpath];
--    Matchai(ROOT, path, 1, result);
-- places the detected template, stars and binding in the
-- 3-tuple called result.

--- The final implementation uses the filesystem to store
--- the graph.  

proc Matchai(node, path, index, rw binding);
  [template, stars, matchpath] := binding;
  if index > #path then 
     if fexists(node+'/template') then 
        template := getfile(node+'/template');  
        matchpath := node;
        template := Trimai(template);
        binding :=  [template, [], matchpath];
        return(true);
     else return(false);
     end if;
  end if;
  word := path(index);
  if fexists(node+'/under') and 
      exists i in [index+1..#path+1] |  Matchai(node+'/under', path, i, binding)
  then 
     phrase := flatten(path, index, i-1);
     stars := [phrase]+stars;
     binding :=  [binding(1), stars, binding(3)];
     return true;
  elseif fexists(node+'/'+word) and 
         Matchai(node+'/'+word, path, index+1, binding)
  then 
     return true;
  elseif fexists(node+'/star') and 
     exists i in [index+1..#path+1] | 
         Matchai(node+'/star', path, i, binding)
  then 
     phrase := flatten(path, index, i-1);
     stars := [phrase]+binding(2);
     binding :=  [binding(1), stars, binding(3)];
     return true;
  else
     return false;
  end if;
end proc;

-- Companion: Locate the mathcing paired XML tag and return
-- the text between the tags.
-- pred /= '' whenever the tag has named attributes.

proc Companion(text, tag, pred);
  if Trimai(text) = '' then return ''; end if;
  if pred /= '' then
    stag := '<'+tag+' name="';
    etag := '</'+tag+'>';
    text := stag+pred+'">'+text;
  else 
    stag := '<'+tag+'>';
    etag := '</'+tag+'>';
    text := stag+text;
  end if;  
  item := '';
  count := 0;
  while #text > 0 loop;
    if match(text, stag) /= '' then 
      count +:= 1; 
      if pred /= '' then 
         pred := break(text, '"');
         any(text, '"'); any(text, '>');
         item := item+stag+pred+'">';
      else 
         item := item+stag; 
      end if;
    elseif match(text, etag) /= '' then
      item := item+etag;
      if count = 1 then text := ''; 
      else count -:= 1; 
      end if;
    elseif match(text, '<') /= '' then
      item := item+'<'+break(text, '<'); 
    else
      item := item+break(text, '<'); 
    end if;
  end loop;
  return item;
end proc;


-- Proceed: Locate the matching paired XML tag and return
-- the text between the tags (expression) and the adjusted remainder.

proc Proceed(remainder, tag);
  stag := '<'+tag+'>';
  etag := '</'+tag+'>';
  match(remainder, stag);
  expression := Companion(remainder, tag, '');
  match(expression, stag);
  remainder := remainder(#expression+1..);
  rmatch(expression, etag);
  return([expression, remainder]);
end proc;