epsilon.shift source code

1 module epsilon.shift;
2 
3 import EAG = epsilon.eag;
4 import io : UndefPos;
5 import runtime;
6 import std.bitmanip : BitArray;
7 import std.conv : to;
8 
9 private const nil = EAG.nil;
10 
11 public void Shift()
12 {
13     int HT;
14     EAG.Alt HA;
15     EAG.Factor HF;
16     int Rhs;
17     int Num;
18     int Var;
19     BitArray GenNonts = EAG.All - EAG.Pred;
20     BitArray Del;
21 
22     Del.length = EAG.NextHNont + 1;
23     EAG.NextMAlt = EAG.firstMAlt;
24     EAG.NextMemb = EAG.firstMemb;
25     EAG.NextVar = EAG.firstVar;
26     EAG.NextNode = EAG.firstNode;
27     EAG.NextParam = EAG.firstParam;
28     EAG.NextMTerm = EAG.NextHTerm - EAG.firstHTerm + EAG.firstMTerm;
29     while (EAG.NextMTerm >= EAG.MTerm.length)
30         EAG.Expand;
31     for (HT = EAG.firstHTerm; HT < EAG.NextHTerm; ++HT)
32         EAG.MTerm[HT - EAG.firstHTerm + EAG.firstMTerm].Id = EAG.HTerm[HT].Id;
33     EAG.NextMNont = EAG.NextHNont - EAG.firstHNont + EAG.firstMNont;
34     while (EAG.NextMNont >= EAG.MNont.length)
35         EAG.Expand;
36     for (int HN = EAG.firstHNont; HN < EAG.NextHNont; ++HN)
37     {
38         if (GenNonts[HN])
39         {
40             EAG.MNont[HN - EAG.firstHNont + EAG.firstMNont].Id = EAG.HNont[HN].NamedId;
41             EAG.MNont[HN - EAG.firstHNont + EAG.firstMNont].MRule = nil;
42             EAG.MNont[HN - EAG.firstHNont + EAG.firstMNont].IsToken = EAG.HNont[HN].IsToken;
43             HA = EAG.HNont[HN].Def.Sub;
44             do
45             {
46                 EAG.Scope = EAG.NextVar;
47                 HA.Scope.Beg = EAG.NextVar;
48                 HA.Formal.Pos = UndefPos;
49                 HA.Formal.Params = EAG.NextParam;
50                 EAG.AppParam(EAG.NextNode, UndefPos);
51                 EAG.ParamBuf[EAG.NextParam - 1].isDef = false;
52                 EAG.AppParam(nil, UndefPos);
53                 EAG.NodeBuf[EAG.NextNode] = EAG.NextMAlt;
54                 ++EAG.NextNode;
55                 if (EAG.NextNode >= EAG.NodeBuf.length)
56                     EAG.Expand;
57                 Rhs = EAG.NextMemb;
58                 HF = HA.Sub;
59                 Num = 2;
60                 while (HF !is null)
61                 {
62                     if (auto term = cast(EAG.Term) HF)
63                     {
64                         EAG.AppMemb(-(term.Sym - EAG.firstHTerm + EAG.firstMTerm));
65                     }
66                     else if (GenNonts[(cast(EAG.Nont) HF).Sym])
67                     {
68                         EAG.AppMemb((cast(EAG.Nont) HF).Sym - EAG.firstHNont + EAG.firstMNont);
69                         Var = EAG.FindVar((cast(EAG.Nont) HF)
70                                 .Sym - EAG.firstHNont + EAG.firstMNont, Num, UndefPos, true);
71                         EAG.NodeBuf[EAG.NextNode] = -Var;
72                         ++EAG.NextNode;
73                         if (EAG.NextNode >= EAG.NodeBuf.length)
74                             EAG.Expand;
75                         (cast(EAG.Nont) HF).Actual.Pos = UndefPos;
76                         (cast(EAG.Nont) HF).Actual.Params = EAG.NextParam;
77                         EAG.AppParam(-Var, UndefPos);
78                         EAG.ParamBuf[EAG.NextParam - 1].isDef = true;
79                         EAG.AppParam(nil, UndefPos);
80                         ++Num;
81                     }
82                     else
83                     {
84                         if (HF.Next !is null)
85                             HF.Next.Prev = HF.Prev;
86                         if (HF.Prev !is null)
87                             HF.Prev.Next = HF.Next;
88                         if (HF == HA.Sub)
89                             HA.Sub = HF.Next;
90                         if (HF == HA.Last)
91                             HA.Last = HF.Prev;
92                     }
93                     HF = HF.Next;
94                 }
95                 if (cast(EAG.Rep) EAG.HNont[HN].Def)
96                 {
97                     EAG.AppMemb(HN - EAG.firstHNont + EAG.firstMNont);
98                     Var = EAG.FindVar(HN - EAG.firstHNont + EAG.firstMNont, Num, UndefPos, true);
99                     EAG.NodeBuf[EAG.NextNode] = -Var;
100                     ++EAG.NextNode;
101                     if (EAG.NextNode >= EAG.NodeBuf.length)
102                         EAG.Expand;
103                     HA.Actual.Pos = UndefPos;
104                     HA.Actual.Params = EAG.NextParam;
105                     EAG.AppParam(-Var, UndefPos);
106                     EAG.ParamBuf[EAG.NextParam - 1].isDef = true;
107                     EAG.AppParam(nil, UndefPos);
108                 }
109                 EAG.AppMemb(nil);
110                 EAG.AppMemb(EAG.NewMAlt(HN - EAG.firstHNont + EAG.firstMNont, Rhs));
111                 HA.Scope.End = EAG.NextVar;
112                 HA = HA.Next;
113             }
114             while (HA !is null);
115             if (cast(EAG.Opt) EAG.HNont[HN].Def || cast(EAG.Rep) EAG.HNont[HN].Def)
116             {
117                 if (auto opt = cast(EAG.Opt) EAG.HNont[HN].Def)
118                 {
119                     opt.Formal.Pos = UndefPos;
120                     opt.Formal.Params = EAG.NextParam;
121                     opt.Scope.Beg = EAG.NextVar;
122                     opt.Scope.End = EAG.NextVar;
123                 }
124                 else if (auto rep = cast(EAG.Rep) EAG.HNont[HN].Def)
125                 {
126                     rep.Formal.Pos = UndefPos;
127                     rep.Formal.Params = EAG.NextParam;
128                     rep.Scope.Beg = EAG.NextVar;
129                     rep.Scope.End = EAG.NextVar;
130                 }
131                 EAG.AppParam(EAG.NextNode, UndefPos);
132                 EAG.ParamBuf[EAG.NextParam - 1].isDef = false;
133                 EAG.AppParam(nil, UndefPos);
134                 EAG.NodeBuf[EAG.NextNode] = EAG.NextMAlt;
135                 ++EAG.NextNode;
136                 if (EAG.NextNode >= EAG.NodeBuf.length)
137                     EAG.Expand;
138                 Rhs = EAG.NextMemb;
139                 EAG.AppMemb(nil);
140                 EAG.AppMemb(EAG.NewMAlt(HN - EAG.firstHNont + EAG.firstMNont, Rhs));
141             }
142         }
143         else
144         {
145             EAG.HNont[HN].Def = null;
146             Del[HN] = true;
147             EAG.MNont[HN - EAG.firstHNont + EAG.firstMNont].Id = nil;
148             EAG.MNont[HN - EAG.firstHNont + EAG.firstMNont].MRule = nil;
149             EAG.MNont[HN - EAG.firstHNont + EAG.firstMNont].IsToken = false;
150         }
151     }
152     EAG.NextDom = EAG.firstDom;
153     foreach (HN; GenNonts.bitsSet)
154     {
155         EAG.HNont[HN].Sig = EAG.NextDom;
156         EAG.AppDom('+', HN.to!int - EAG.firstHNont + EAG.firstMNont);
157         EAG.AppDom('+', nil);
158     }
159     EAG.All -= Del;
160     EAG.Pred -= Del;
161     EAG.Prod -= Del;
162     EAG.Reach -= Del;
163     EAG.Null -= Del;
164 }