private void makeItem()
{
int current = 0;
for (int i = 0; i < Grammar.Productions.Count; i++)
{
var prod = new Production(Grammar.Productions[i].Name, Grammar.Productions[i].Left);
for (var j = 0; j < Grammar.Productions[i].Right.Count; j++)
{
var temp = Grammar.Productions[i].Right[j];
for (int k = 0; k <= temp.Count; k++)
{
var pe = new ProductionExpression()
{
Parent = Grammar.Productions[i]
};
pe.AddRange(temp);
if (pe.IsEpsilonExpression)
{
pe.Clear();
pe.Add(dotTerminal);
prod.Add(pe);
dic[prod.Left].Add(current);
current++;
break;
}
else
{
pe.Insert(k, dotTerminal);
}
prod.Add(pe);
dic[prod.Left].Add(current);
current++;
}
prodDict.Add(temp, new Tuple <int, int>(i, j));
}
items.AddRange(prod.Expand());
}
}
public Province(Label Lb)
{
ctrl = Lb;
ID = Form1.idstore;
Form1.idstore++;
ProvinceName = "None";
Production.Add("wood", 0);
Storage.Add("wood", 0);
Production.Add("bricks", 0);
Storage.Add("bricks", 0);
Production.Add("wheat", 0);
Storage.Add("wheat", 0);
Production.Add("metals", 0);
Storage.Add("metals", 0);
Production.Add("tools", 0);
Storage.Add("tools", 0);
Production.Add("weapons", 0);
Storage.Add("weapons", 0);
Production.Add("wool", 0);
Storage.Add("wool", 0);
Production.Add("cloth", 0);
Storage.Add("cloth", 0);
Production.Add("furs", 0);
Storage.Add("furs", 0);
Production.Add("ale", 0);
Storage.Add("ale", 0);
Production.Add("wine", 0);
Storage.Add("wine", 0);
Production.Add("spices", 0);
Storage.Add("spices", 0);
Production.Add("meat", 0);
Storage.Add("meat", 0);
Production.Add("salt", 0);
Storage.Add("salt", 0);
Production.Add("hemps", 0);
Storage.Add("hemps", 0);
foreach (string s in Form1.ProductName)
{
BProduction.Add(s, 0);
Shortage.Add(s, 0);
Buildings.Add(s, 0);
PriceModifier.Add(s, 100);
PopulationUsage.Add(s, 0);
}
WarMode = false;
}
private void makeCmp(List <Production> cmp1, int i, AbstractTerminal ch)
{
for (int j = 0; j < Collections[i].Count; j++)
{
var str = Collections[i][j].Clone();
int k;
for (k = 0; k < str.Count; k++)
{
if (ReferenceEquals(str[k], dotTerminal))
{
break;
}
}
if (k != str.Count - 1 && str[k + 1] == ch)
{
str.RemoveAt(k);
str.Insert(k + 1, dotTerminal);
var pd = new Production(Collections[i][j].Parent.Left);
pd.Add(str);
cmp1.Add(pd);
}
}
}
public void Test()
{
Symbols symbols = new Symbols();
Productions productions = new Productions();
Syntax syntax = new Syntax(symbols, productions);
symbols.RegistTerm("a");
symbols.RegistTerm("b");
symbols.RegistTerm("c");
symbols.RegistNonterm("S");
symbols.RegistNonterm("A");
symbols.RegistNonterm("B");
symbols.RegistNonterm("C");
symbols.RegistNonterm("D");
Production S_AB = new Production("S");
S_AB.Add("A").Add("B");
Production S_bC = new Production("S");
S_bC.Add("b").Add("C");
Production A_ = new Production("A");
A_.Add("");
Production A_b = new Production("A");
A_b.Add("b");
Production B_ = new Production("B");
B_.Add("");
Production B_aD = new Production("B");
B_aD.Add("a").Add("D");
Production C_AD = new Production("C");
C_AD.Add("A").Add("D");
Production C_b = new Production("C");
C_b.Add("b");
Production D_aS = new Production("D");
D_aS.Add("a").Add("S");
Production D_c = new Production("D");
D_c.Add("c");
bool rs;
rs = productions.Products.Add(S_AB); Assert.IsTrue(rs);
rs = productions.Products.Add(S_bC); Assert.IsTrue(rs);
rs = productions.Products.Add(A_); Assert.IsTrue(rs);
rs = productions.Products.Add(A_b); Assert.IsTrue(rs);
rs = productions.Products.Add(B_); Assert.IsTrue(rs);
rs = productions.Products.Add(B_aD); Assert.IsTrue(rs);
rs = productions.Products.Add(C_AD); Assert.IsTrue(rs);
rs = productions.Products.Add(C_b); Assert.IsTrue(rs);
rs = productions.Products.Add(D_aS); Assert.IsTrue(rs);
rs = productions.Products.Add(D_c); Assert.IsTrue(rs);
symbols.Show();
productions.Show();
syntax.CalculateEpsilonSet();
Assert.IsTrue(syntax.EpsilonSet["S"]);
Assert.IsTrue(syntax.EpsilonSet["A"]);
Assert.IsTrue(syntax.EpsilonSet["B"]);
Assert.IsFalse(syntax.EpsilonSet["C"]);
Assert.IsFalse(syntax.EpsilonSet["D"]);
syntax.CalculateFirstSet();
var firstSet = syntax.FirstSet;
foreach (var item in firstSet)
{
var key = item.Key;
var value = item.Value;
}
Assert.AreEqual(3, firstSet["S"].Count);
Assert.AreEqual(2, firstSet["A"].Count);
Assert.AreEqual(2, firstSet["B"].Count);
Assert.AreEqual(3, firstSet["C"].Count);
Assert.AreEqual(2, firstSet["D"].Count);
}
private void makeGo()
{
int m = Collections.Count;
for (int t = 0; t < V.Count; t++)
{
var ch = V[t];
for (int i = 0; i < m; i++)
{
var cmp1 = new List <Production>();
makeCmp(cmp1, i, ch);
if (cmp1.Count == 0)
{
continue;
}
for (int j = 0; j < m; j++)
{
var cmp2 = new List <Production>();
for (int k = 0; k < Collections[j].Count; k++)
{
var str = Collections[j][k];
int x;
for (x = 0; x < str.Count; x++)
{
if (ReferenceEquals(str[x], dotTerminal))
{
break;
}
}
if (x > 0 && str[x - 1] == ch)
{
var pd = new Production(Collections[j][k].Parent.Left);
pd.Add(str);
cmp2.Add(pd);
}
}
bool flag = true;
if (cmp2.Count != cmp1.Count)
{
continue;
}
for (int k = 0; k < cmp1.Count; k++)
{
if (cmp1[k] == cmp2[k])
{
continue;
}
else
{
flag = false;
}
}
if (flag)
{
if (!Go.ContainsKey(i))
{
Go.Add(i, new Dictionary <AbstractTerminal, int>());
}
if (!Go[i].ContainsKey(ch))
{
Go[i].Add(ch, j);
}
}
}
}
}
}
protected virtual void makeSet()
{
bool[] has = new bool[500];
for (int i = 0; i < items.Count; i++)
{
if (items[i].Left == Grammar.BeginSymbol && ReferenceEquals(items[i].Right[0][0], dotTerminal))
{
var temp = new Closure();
var str = items[i].Right[0];
var element = temp.Element;
element.Add(items[i].Right[0]);
int x = 0;
for (x = 0; x < str.Count; x++)
{
if (ReferenceEquals(str[x], dotTerminal))
{
break;
}
}
has = new bool[500];
has[i] = true;
if (x != str.Count - 1)
{
var q = new Queue <ProductionExpression>();
q.Enqueue(str.SubExpr(x + 1, 1));
while (!(q.Count == 0))
{
var u = q.Peek();
q.Dequeue();
var id = dic[(NonTerminal)u[0]];
for (int j = 0; j < id.Count; j++)
{
int tx = id[j];
if (ReferenceEquals(items[tx].Right[0][0], dotTerminal))
{
if (has[tx])
{
continue;
}
has[tx] = true;
if ((items[tx].Right[0][1] is NonTerminal nt))
{
q.Enqueue(items[tx].Right[0].SubExpr(1, 1));
}
element.Add(items[tx].Right[0]);
}
}
}
}
Collections.Add(temp);
}
}
for (int i = 0; i < Collections.Count; i++)
{
var temp = new Dictionary <AbstractTerminal, Closure>();
for (int j = 0; j < Collections[i].Count; j++)
{
var str = Collections[i][j].Clone();
int x = 0;
for (; x < str.Count; x++)
{
if (ReferenceEquals(str[x], dotTerminal))
{
break;
}
}
if (x == str.Count - 1)
{
continue;
}
var y = str[x + 1];
int ii = 0;
str.RemoveAt(x);
str.Insert(x + 1, dotTerminal);
var cmp = new Production(Collections[i][j].Parent.Left);
cmp.Add(str);
for (int k = 0; k < items.Count; k++)
{
if (items[k] == cmp)
{
ii = k;
break;
}
}
has = new bool[500];
if (!temp.ContainsKey(y))
{
temp.Add(y, new Closure());
}
var element = temp[y].Element;
element.Add(items[ii].Right[0]);
has[ii] = true;
x++;
if (x != str.Count - 1)
{
var q = new Queue <ProductionExpression>();
q.Enqueue(str.SubExpr(x + 1, 1));
while (!(q.Count == 0))
{
var u = q.Peek();
q.Dequeue();
List <int> id;
if (u[0] is NonTerminal nts)
{
id = dic[nts];
for (int d = 0; d < id.Count; d++)
{
int tx = id[d];
if (ReferenceEquals(items[tx].Right[0][0], dotTerminal))
{
if (has[tx])
{
continue;
}
has[tx] = true;
if (items[tx].Right[0].Count > 1 && items[tx].Right[0][1] is NonTerminal nt)
{
q.Enqueue(items[tx].Right[0].SubExpr(1, 1));
}
element.Add(items[tx].Right[0]);
}
}
}
}
}
}
foreach (var kp in temp)
{
Collections.Add(kp.Value);
}
for (int k = 0; k < Collections.Count; k++)
{
for (int j = k + 1; j < Collections.Count; j++)
{
if (Collections[k] == Collections[j])
{
Collections.RemoveAt(j);
}
}
}
}
}
Production Loader()
{
Tests.TestNumberPaser();
Production Root = Factory.Or("CSGrammar");
Production Class = Factory.And("Class").Array().Node("Class");
Production ClassBody = Factory.Or("Class_Body").Node("ClassBody");
Production Member = Factory.And("Member").Node("ClassMember");
Production Func = Factory.And("Func").Node("ClassFunc");
Production VType = Factory.Or("Type").Node();
Production Memory = Factory.Or("Memory").Node();
Production Permission = Factory.Or("Permission").Node("Permission");
Production Expressions = Factory.Or("Expressions").Array();
Production OP2 = Factory.Or("OP2").Node();
Production OP3 = Factory.Or("OP3").Node();
Production V = Factory.Or("V").Node();
Production Exp = Factory.And("Exp");
Production ExpDecl = Factory.And("ExpDecl");
Production LHS = Factory.Or("LHS").Node("LHS");
Production RHS = Factory.Or("RHS").Node("RHS");
Production ComExpression = Factory.And("ComExpression");
Production Factor = Factory.Or("Factor");
Production ClassName = Factory.Symbol(Grammar.ID);
Production FuncName = Factory.Symbol(Grammar.ID).Node("FuncName");
Production MemberName = Factory.Symbol(Grammar.ID).Node("MemberName");
Production OneArg = Factory.And("OneArg");
Production Arg = Factory.Symbol(Grammar.ID).Node("Arg");
Production Arguments = Factory.Or("Arguments").Node();
Production Var = Factory.Symbol(Grammar.ID).Node("Var");
Production Decl = Factory.And("Decl");
Production OpAdd = Factory.Symbol("+").Node("Op");
Production OpSub = Factory.Symbol("-").Node("Op");
Production OpMul = Factory.Symbol("*").Node("Op");
Production OpDiv = Factory.Symbol("/").Node("Op");
Production VTypeID = Factory.Symbol(Grammar.ID).Node("Type");
Production LineComment = Factory.And("LineComment");
Production BlockComment = Factory.And("BlockComment");
Production NewLine = Factory.Symbol(Grammar.LineFeed);
Production EOF = Factory.Symbol(Grammar.Eof);
LineComment.Add("//" + Grammar.Any + NewLine);
BlockComment.Add("/*" + Grammar.Any + "*/");
OP2.Add(OpAdd | OpSub);
OP3.Add(OpMul | OpDiv);
V.Add(Var);
V.Add("(" + V + ")");
Decl.Add(VType + Var);
LHS.Add(Var | Decl);
Factor.Add(V);
Factor.Add(V + OP3 + Factor);
Factor.Add("(" + Factor + ")");
RHS.Add(V);
RHS.Add(V + OP2 + Factor);
RHS.Add(V + OP2 + RHS);
RHS.Add(Factor + OP2 + RHS);
RHS.Add("(" + RHS + ")");
Exp.Add(LHS + "=" + RHS + ";");
ExpDecl.Add(Decl + ";");
Permission.Add(Grammar.Empty | TokenID.Permission);
Memory.Add(Grammar.Empty | TokenID.Memory);
VType.Add(VTypeID | TokenID.InnerType);
Member.Add(Permission + Memory + VType + MemberName + ";");
Expressions.Add(Exp | ExpDecl);
ComExpression.Add("{" + Expressions + "}");
OneArg.Add(VType + Arg);
Arguments.Add(OneArg);
Arguments.Add(OneArg + "," + Arguments);
Arguments.Add(Grammar.Empty);
Func.Add(Permission + Memory + VType + FuncName + "(" + Arguments + ")" + ComExpression);
ClassBody.Add(Member | Func | Grammar.Empty);
Class.Add(Permission + Memory + TokenID.Class + "{" + ClassName + ClassBody + "}");
Root.Add(Class | EOF);
return(Root);
}
