Теория формальных языков, грамматик и автоматов. Ишакова Е.Н. - 55 стр.

UptoLike

Составители: 

55
ifstream fi(fname);
N.clear();
T.clear();
P.clear();
// ввод нетерминалов
fi >> n;
for (i = 0; i < n; i++){
fi >> c;
N.insert(c);
}
// ввод терминалов
fi >> n;
for (i = 0; i < n; i++){
fi >> c;
T.insert(c);
}
// ввод правил
fi >> n;
for (i = 0; i < n; i++){
fi >> r.first >> r.second;
P.insert(r);
}
// начальный символ
fi >> S;
}
string Grammar::AsString(){
string res = "";
charset::iterator i;
res += "Nonterminals (";
res += IntToStr(N.size()).c_str();
res += ") : ";
for (i = N.begin(); i != N.end(); i++){
res += *i;
res += " ";
}
res += "\nTerminals (";
res += IntToStr(T.size()).c_str();
res += ") : ";
for (i = T.begin(); i != T.end(); i++){
res += *i;
res += " ";
}
res += "\nRules (";
res += IntToStr(P.size()).c_str();
res += ")\n";
for (rulemap::iterator j = P.begin(); j != P.end();
j++){
res += "\t";
res += j->first;
res += " -> " + j->second + "\n";
}
res += "Starting symbol: ";
res += S;
res += "\n";
return res;
}
void Grammar::OutGrammar(char *fname){
ofstream fo(fname);
charset::iterator i;
fo << N.size() << "\n";
for (i = N.begin(); i != N.end(); i++)
fo << *i;
fo << "\n" << T.size() << "\n";
for (i = T.begin(); i != T.end(); i++)
fo << *i;
fo << "\n" << P.size() << "\n";
for (rulemap::iterator j = P.begin(); j != P.end();
j++)
fo << j->first << " " << j->second << "\n";
fo << "\n" << S;
}
void FAutomat::SetGrammar(Grammar *NG){
G = NG;
}
void FAutomat::CreateAutomat(){
rulemap::iterator i, j;
rule r;
char c, t;
int k;
// поиск незанятого символа
for(c = 'A'; G->N.count(c); c++);
// поиск правил вида A -> a без A -> aB
for(i = G->P.begin(); i != G->P.end(); i++)
if (i->second.length() == 1 && G->T.count(i-
>second[0])){
for(j = G->P.lower_bound(i->first), k = G-
>P.count(i->first); k; j++, k--)
if (j->second.length() == 2 && j-
>second[0] == i->second[0] && G->N.count(j-
>second[1]))
break;
if (!k){
// добавление правила вида A -> aC
r.first = i->first;
r.second = i->second + c;
G->P.insert(r);
G->N.insert(c);
}
}
// начальный символ
H = G->S;
// состояния
Q = G->N;
Лист
18
                                                             res += S;
                                                             res += "\n";
ifstream fi(fname);                                          return res;
   N.clear();                                            }
   T.clear();
   P.clear();                                            void Grammar::OutGrammar(char *fname){
   // ввод нетерминалов                                    ofstream fo(fname);
   fi >> n;                                                charset::iterator i;
   for (i = 0; i < n; i++){                                fo << N.size() << "\n";
      fi >> c;                                             for (i = N.begin(); i != N.end(); i++)
      N.insert(c);                                            fo << *i;
   }                                                       fo << "\n" << T.size() << "\n";
   // ввод терминалов                                      for (i = T.begin(); i != T.end(); i++)
   fi >> n;                                                   fo << *i;
   for (i = 0; i < n; i++){                                fo << "\n" << P.size() << "\n";
      fi >> c;                                             for (rulemap::iterator j = P.begin(); j != P.end();
      T.insert(c);                                       j++)
   }                                                          fo << j->first << " " << j->second << "\n";
   // ввод правил                                          fo << "\n" << S;
   fi >> n;                                              }
   for (i = 0; i < n; i++){
      fi >> r.first >> r.second;                         void FAutomat::SetGrammar(Grammar *NG){
      P.insert(r);                                         G = NG;
   }                                                     }
   // начальный символ
   fi >> S;                                              void FAutomat::CreateAutomat(){
}                                                          rulemap::iterator i, j;
                                                           rule r;
string Grammar::AsString(){                                char c, t;
   string res = "";                                        int k;
   charset::iterator i;                                    // поиск незанятого символа
   res += "Nonterminals (";                                for(c = 'A'; G->N.count(c); c++);
   res += IntToStr(N.size()).c_str();                      // поиск правил вида A -> a без A -> aB
   res += ") : ";                                          for(i = G->P.begin(); i != G->P.end(); i++)
   for (i = N.begin(); i != N.end(); i++){                    if (i->second.length() == 1 && G->T.count(i-
      res += *i;                                         >second[0])){
      res += " ";                                                for(j = G->P.lower_bound(i->first), k = G-
   }                                                     >P.count(i->first); k; j++, k--)
   res += "\nTerminals (";                                          if (j->second.length() == 2 && j-
   res += IntToStr(T.size()).c_str();                    >second[0] == i->second[0] && G->N.count(j-
   res += ") : ";                                        >second[1]))
   for (i = T.begin(); i != T.end(); i++){                             break;
      res += *i;                                                 if (!k){
      res += " ";                                                   // добавление правила вида A -> aC
   }                                                                r.first = i->first;
   res += "\nRules (";                                              r.second = i->second + c;
   res += IntToStr(P.size()).c_str();                               G->P.insert(r);
   res += ")\n";                                                    G->N.insert(c);
   for (rulemap::iterator j = P.begin(); j != P.end();           }
j++){                                                         }
      res += "\t";                                         // начальный символ
      res += j->first;                                     H = G->S;
      res += " -> " + j->second + "\n";                    // состояния
   }                                                       Q = G->N;

  res += "Starting symbol: ";




                                                                                                           Лист
                                                                                                           18


                                                                                                                 55