Changeset 2 for UMainForm.pas

Timestamp:

Oct 1, 2007, 3:09:51 PM (17 years ago)

Author:

george

Message:

Zobrazení gramatiky.
Zkoušení analýzy jiný gramatiky.

File:

• UMainForm.pas (modified) (15 diffs)

UMainForm.pas

@@ -58 +58 @@
 
   TGrammerItem = record
+  public
     ItemType: TRuleItemType;
     Character: Char;
@@ -64 +65 @@
     Repetition: Boolean;
     procedure GetPossibleCharacters(Path: TGrammerPath; var Characters: TPossibleCharacters);
+    constructor Create(ItemType: TRuleType);
   end;
 
@@ -74 +76 @@
     Items: array of TGrammerItem;
     procedure AddTerminal(Character: Char; Optional, Repetition: Boolean);
+    procedure AddTerminalText(Text: string);
     procedure AddRule(Rule: TGrammerRule; Optional, Repetition: Boolean);
     procedure ProcessCharacter(Character: Char);
     procedure GetPossibleCharacters(Path: TGrammerPath;
       var Characters: TPossibleCharacters; UseIndex: Integer = 0; UseCharIndex: Integer = 0);
+    constructor Create;
   end;
 
@@ -93 +97 @@
     Button1: TButton;
     TreeView1: TTreeView;
+    TreeView2: TTreeView;
     procedure FormCreate(Sender: TObject);
     procedure FormDestroy(Sender: TObject);
@@ -103 +108 @@
     SourceProgram: TProgram;
     procedure ShowProgramTree(SourceProgram: TProgram);
+    procedure ShowGrammerTree(Grammer: TGrammer);
   end;
 
@@ -119 +125 @@
 procedure TMainForm.FormCreate(Sender: TObject);
 var
+  LowerCaseAlphabeticCharacter, UpperCaseAlphabeticCharacter,
   Digit, AlphabeticCharacter, Number, AlphaNumericCharacter,
-    Identifier, Assigmnent, Expression, RuleString: TGrammerRule;
+    Identifier, Assignment, Expression, RuleString, Rule, RuleList,
+    AlternateOptions, OptionBlock, RepetitionBlock, GroupingBlock,
+    AlternateOptionsSubBlock, Term, AllCharacters, WhiteSpace: TGrammerRule;
   C: Char;
+  I: Integer;
+  SourceCode: string;
 begin
   Grammer := TGrammer.Create;
-
   with Grammer do begin
+    WhiteSpace := TGrammerRule.Create;
+    with WhiteSpace do begin
+      Name := 'WhiteSpace';
+      RuleType := rtAlternative;
+      AddTerminal(' ', False, False);
+      AddTerminal(#10, False, False);
+      AddTerminal(#13, False, False);
+    end;
+    Rules.Add(WhiteSpace);
+
+    LowerCaseAlphabeticCharacter := TGrammerRule.Create;
+    with LowerCaseAlphabeticCharacter do begin
+      Name := 'LowerCaseAlphabeticCharacter';
+      RuleType := rtAlternative;
+      for C := 'a' to 'z' do AddTerminal(C, False, False);
+    end;
+    Rules.Add(LowerCaseAlphabeticCharacter);
+
+    UpperCaseAlphabeticCharacter := TGrammerRule.Create;
+    with UpperCaseAlphabeticCharacter do begin
+      Name := 'UpperCaseAlphabeticCharacter';
+      RuleType := rtAlternative;
+      for C := 'A' to 'Z' do AddTerminal(C, False, False);
+    end;
+    Rules.Add(UpperCaseAlphabeticCharacter);
+
     AlphabeticCharacter := TGrammerRule.Create;
     with AlphabeticCharacter do begin
       Name := 'AlphabeticCharacter';
       RuleType := rtAlternative;
-      for C := 'A' to 'Z' do AddTerminal(C, False, False);
+      AddRule(LowerCaseAlphabeticCharacter, False, False);
+      AddRule(UpperCaseAlphabeticCharacter, False, False);
     end;
     Rules.Add(AlphabeticCharacter);
@@ -169 +206 @@
     Rules.Add(Identifier);
 
+    AllCharacters := TGrammerRule.Create;
+    with AllCharacters do begin
+      Name := 'AllCharacters';
+      RuleType := rtAlternative;
+      for I := 32 to 38 do AddTerminal(Chr(I), False, False);
+      for I := 40 to 125 do AddTerminal(Chr(I), False, False);
+    end;
+    Rules.Add(AllCharacters);
+
     RuleString := TGrammerRule.Create;
     with RuleString do begin
@@ -174 +220 @@
       RuleType := rtSequence;
       AddTerminal('''', False, False);
-      AddRule(AlphaNumericCharacter, True, True);
+      AddRule(AllCharacters, True, True);
       AddTerminal('''', False, False);
     end;
     Rules.Add(RuleString);
 
+    AlternateOptions := TGrammerRule.Create;
     Expression := TGrammerRule.Create;
+
+    AlternateOptionsSubBlock := TGrammerRule.Create;
+    with AlternateOptionsSubBlock do begin
+      Name := 'AlternateOptionsSubBlock';
+      RuleType := rtSequence;
+      AddRule(WhiteSpace, True, True);
+      AddTerminal('|', False, False);
+      AddRule(WhiteSpace, True, True);
+      AddRule(AlternateOptions, True, True);
+    end;
+    Rules.Add(AlternateOptionsSubBlock);
+
+    OptionBlock := TGrammerRule.Create;
+    with OptionBlock do begin
+      Name := 'OptionBlock';
+      RuleType := rtSequence;
+      AddTerminal('[', False, False);
+      AddRule(WhiteSpace, True, True);
+      AddRule(Expression, False, False);
+      AddRule(WhiteSpace, True, True);
+      AddTerminal(']', False, False);
+    end;
+    Rules.Add(OptionBlock);
+
+    RepetitionBlock := TGrammerRule.Create;
+    with RepetitionBlock do begin
+      Name := 'RepetitionBlock';
+      RuleType := rtSequence;
+      AddTerminal('{', False, False);
+      AddRule(WhiteSpace, True, True);
+      AddRule(Expression, False, False);
+      AddRule(WhiteSpace, True, True);
+      AddTerminal('}', False, False);
+    end;
+    Rules.Add(RepetitionBlock);
+
+    GroupingBlock := TGrammerRule.Create;
+    with GroupingBlock do begin
+      Name := 'GroupingBlock';
+      RuleType := rtSequence;
+      AddTerminal('(', False, False);
+      AddRule(WhiteSpace, True, True);
+      AddRule(Expression, False, False);
+      AddRule(WhiteSpace, True, True);
+      AddTerminal(')', False, False);
+    end;
+    Rules.Add(GroupingBlock);
+
+    Term := TGrammerRule.Create;
+    with Term do begin
+      Name := 'Term';
+      RuleType := rtAlternative;
+      AddRule(Identifier, False, False);
+      AddRule(RuleString, False, False);
+    end;
+    Rules.Add(Term);
+
+    with AlternateOptions do begin
+      Name := 'AlternateOptions';
+      RuleType := rtSequence;
+      AddRule(Term, False, False);
+      AddRule(AlternateOptionsSubBlock, True, True);
+    end;
+    Rules.Add(AlternateOptions);
+
     with Expression do begin
       Name := 'Expression';
       RuleType := rtAlternative;
+      AddRule(RepetitionBlock, False, False);
+      AddRule(OptionBlock, False, False);
+      AddRule(GroupingBlock, False, False);
+      AddRule(AlternateOptions, False, False);
+    end;
+    Rules.Add(Expression);
+
+    Rule := TGrammerRule.Create;
+    with Rule do begin
+      Name := 'Rule';
+      RuleType := rtSequence;
+      AddRule(WhiteSpace, True, True);
       AddRule(Identifier, False, False);
-      AddRule(Number, False, False);
-      AddRule(RuleString, False, False);
-    end;
-    Rules.Add(Expression);
-
-    Assigmnent := TGrammerRule.Create;
-    with Assigmnent do begin
-      Name := 'Assigmnent';
-      RuleType := rtSequence;
-      AddRule(Identifier, False, False);
-      AddTerminal(':', False, False);
+      AddRule(WhiteSpace, True, True);
       AddTerminal('=', False, False);
-      AddRule(Expression, False, False);
-    end;
-    Rules.Add(Assigmnent);
-
-    TopRule := Assigmnent;
-  end;
+      AddRule(WhiteSpace, True, True);
+      AddRule(Expression, False, True);
+      AddRule(WhiteSpace, True, True);
+      AddTerminal('.', False, False);
+      AddRule(WhiteSpace, True, True);
+    end;
+    Rules.Add(Rule);
+
+    RuleList := TGrammerRule.Create;
+    with RuleList do begin
+      Name := 'RuleList';
+      RuleType := rtSequence;
+      AddRule(Rule, False, True);
+    end;
+    Rules.Add(RuleList);
+
+    TopRule := RuleList;
+  end;
+
+  ShowGrammerTree(Grammer);
 
   SourceProgram := TProgram.Create;
-
-  Memo1.Lines.LoadFromFile('Program.pas');
+  Memo1.Lines.LoadFromFile('P0.grm');
+  SourceCode := '';;
+//  with Memo1.Lines do
+//  for I := 1 to Length(Text) do begin
+//    if (Text[I] <> ' ') and (Text[I] <> #10) and (Text[I] <> #13) then SourceCode := SourceCode + Text[I];
+//  end;
+
   Grammer.Parse(Memo1.Text, SourceProgram);
   ShowProgramTree(SourceProgram);
@@ -229 +362 @@
   Items[High(Items)].Optional := Optional;
   Items[High(Items)].Repetition := Repetition;
+end;
+
+procedure TGrammerRule.AddTerminalText(Text: string);
+var
+  I: Integer;
+begin
+  for I := 1 to Length(Text) do AddTerminal(Text[I], False, False);
+end;
+
+constructor TGrammerRule.Create;
+begin
+
 end;
 
@@ -264 +409 @@
 begin
   Memo1.Lines.SaveToFile('Program.pas');
+
   Grammer.Free;
   SourceProgram.Free;
+end;
+
+procedure TMainForm.ShowGrammerTree(Grammer: TGrammer);
+var
+  I, II: Integer;
+  NewTreeNode: TTreeNode;
+  NewTreeNode2: TTreeNode;
+  Attributs: string;
+begin
+  with Grammer, TreeView2, Items do begin
+    BeginUpdate;
+    Clear;
+    TopItem := AddChild(nil, 'Gramatika');
+    for I := 0 to Rules.Count - 1 do with TGrammerRule(Rules[I]) do begin
+      case RuleType of
+        rtSequence: Attributs := '(Seq)';
+        rtAlternative: Attributs := '(Alt)';
+      end;
+      NewTreeNode := AddChild(TopItem, Name + Attributs);
+      for II := 0 to Length(Items) - 1 do
+      with Items[II] do begin
+        if Optional then Attributs := '(Opt)' else Attributs := '';
+        if Repetition then Attributs := Attributs + '(Rep)';
+        case ItemType of
+          itTerminal: Attributs := Character + Attributs;
+          itNonterminal: if Assigned(Rule) then
+          Attributs := '<' + Rule.Name + '>' + Attributs;
+            else Attributs := '<?>' + Attributs;
+        end;
+        NewTreeNode2 := AddChild(NewTreeNode, Attributs);
+      end;
+    end;
+    TopItem.Expand(False);
+    EndUpdate;
+  end;
 end;
 
@@ -316 +497 @@
 var
   Path: TGrammerPath;
-  I: Integer;
+  I, II: Integer;
   C: Integer;
   Scope: TPossibleCharacters;
@@ -322 +503 @@
   UseCharIndex: Integer;
   UseRule: TGrammerRule;
+  ExpectedCharacters: string;
 begin
   SetLength(Path.Items, Length(Path.Items) + 1);
@@ -344 +526 @@
         ParsedProgram.Insert(Scope.Items[C].RulePath, Scope.Items[C].Character);
       end else begin
-        raise Exception.Create('Parse error');
+        ExpectedCharacters := '';
+        for II := 0 to Length(Scope.Items) - 1 do
+          ExpectedCharacters := ExpectedCharacters + Scope.Items[II].Character;
+        break;
+        //raise Exception.Create('Parse error. Expected "' + ExpectedCharacters +
+          //'" but found "' + Text[I] + '".');
       end;
       Path.Assign(Scope.Items[C].RulePath);
@@ -415 +602 @@
 { TGrammerItem }
 
+constructor TGrammerItem.Create(ItemType: TRuleType);
+begin
+  Rule := nil;
+end;
+
 procedure TGrammerItem.GetPossibleCharacters(Path: TGrammerPath;
   var Characters: TPossibleCharacters);
@@ -444 +636 @@
           SetLength(Path.Items, PathIndex + 1);
           Inc(Path.Items[PathIndex].ItemIndex);
-          Inc(Path.Items[PathIndex].CharIndex);
+          //Inc(Path.Items[PathIndex].CharIndex);
           Rule.Items[Index].GetPossibleCharacters(Path, Characters);
           Found := True;