CocoSourcesCS 2

   1 /*-------------------------------------------------------------------------
   2 DFA.cs -- Generation of the Scanner Automaton
   3 Compiler Generator Coco/R,
   4 Copyright (c) 1990, 2004 Hanspeter Moessenboeck, University of Linz
   5 extended by M. Loeberbauer & A. Woess, Univ. of Linz
   6 with improvements by Pat Terry, Rhodes University
   7 
   8 This program is free software; you can redistribute it and/or modify it 
   9 under the terms of the GNU General Public License as published by the 
  10 Free Software Foundation; either version 2, or (at your option) any 
  11 later version.
  12 
  13 This program is distributed in the hope that it will be useful, but 
  14 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
  15 or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License 
  16 for more details.
  17 
  18 You should have received a copy of the GNU General Public License along 
  19 with this program; if not, write to the Free Software Foundation, Inc., 
  20 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21 
  22 As an exception, it is allowed to write an extension of Coco/R that is
  23 used as a plugin in non-free software.
  24 
  25 If not otherwise stated, any source code generated by Coco/R (other than 
  26 Coco/R itself) does not fall under the GNU General Public License.
  27 -------------------------------------------------------------------------*/
  28 using System;
  29 using System.IO;
  30 using System.Text;
  31 using System.Collections;
  32 
  33 namespace at.jku.ssw.Coco {
  34 
  35 //-----------------------------------------------------------------------------
  36 //  State
  37 //-----------------------------------------------------------------------------
  38 
  39 public class State {                // state of finite automaton
  40     public int nr;                        // state number
  41     public Action firstAction;// to first action of this state
  42     public Symbol endOf;            // recognized token if state is final
  43     public bool ctx;                    // true if state is reached via contextTrans
  44     public State next;
  45     
  46     public void AddAction(Action act) {
  47         Action lasta = null, a = firstAction;
  48         while (a != null && act.typ >= a.typ) {lasta = a; a = a.next;}
  49         // collecting classes at the beginning gives better performance
  50         act.next = a;
  51         if (a==firstAction) firstAction = act; else lasta.next = act;
  52     }
  53     
  54     public void DetachAction(Action act) {
  55         Action lasta = null, a = firstAction;
  56         while (a != null && a != act) {lasta = a; a = a.next;}
  57         if (a != null)
  58             if (a == firstAction) firstAction = a.next; else lasta.next = a.next;
  59     }
  60     
  61     public void MeltWith(State s) { // copy actions of s to state
  62         for (Action action = s.firstAction; action != null; action = action.next) {
  63             Action a = new Action(action.typ, action.sym, action.tc);
  64             a.AddTargets(action);
  65             AddAction(a);
  66         }
  67     }
  68     
  69 }
  70 
  71 //-----------------------------------------------------------------------------
  72 //  Action
  73 //-----------------------------------------------------------------------------
  74 
  75 public class Action {            // action of finite automaton
  76     public int typ;                    // type of action symbol: clas, chr
  77     public int sym;                    // action symbol
  78     public int tc;                    // transition code: normalTrans, contextTrans
  79     public Target target;        // states reached from this action
  80     public Action next;
  81     
  82     public Action(int typ, int sym, int tc) {
  83         this.typ = typ; this.sym = sym; this.tc = tc;
  84     }
  85     
  86     public void AddTarget(Target t) { // add t to the action.targets
  87         Target last = null;
  88         Target p = target;
  89         while (p != null && t.state.nr >= p.state.nr) {
  90             if (t.state == p.state) return;
  91             last = p; p = p.next;
  92         }
  93         t.next = p;
  94         if (p == target) target = t; else last.next = t;
  95     }
  96 
  97     public void AddTargets(Action a) { // add copy of a.targets to action.targets
  98         for (Target p = a.target; p != null; p = p.next) {
  99             Target t = new Target(p.state);
 100             AddTarget(t);
 101         }
 102         if (a.tc == Node.contextTrans) tc = Node.contextTrans;
 103     }
 104     
 105     public CharSet Symbols(Tab tab) {
 106         CharSet s;
 107         if (typ == Node.clas)
 108             s = tab.CharClassSet(sym).Clone();
 109         else {
 110             s = new CharSet(); s.Set(sym);
 111         }
 112         return s;
 113     }
 114     
 115     public void ShiftWith(CharSet s, Tab tab) {
 116         if (s.Elements() == 1) {
 117             typ = Node.chr; sym = s.First();
 118         } else {
 119             CharClass c = tab.FindCharClass(s);
 120             if (c == null) c = tab.NewCharClass("#", s); // class with dummy name
 121             typ = Node.clas; sym = c.n;
 122         }
 123     }
 124     
 125 }
 126 
 127 //-----------------------------------------------------------------------------
 128 //  Target
 129 //-----------------------------------------------------------------------------
 130 
 131 public class Target {                // set of states that are reached by an action
 132     public State state;                // target state
 133     public Target next;
 134     
 135     public Target (State s) {
 136         state = s;
 137     }
 138 }
 139 
 140 //-----------------------------------------------------------------------------
 141 //  Melted
 142 //-----------------------------------------------------------------------------
 143 
 144 public class Melted {                    // info about melted states
 145     public BitArray set;                // set of old states
 146     public State state;                    // new state
 147     public Melted next;
 148     
 149     public Melted(BitArray set, State state) {
 150         this.set = set; this.state = state;
 151     }    
 152 }
 153 
 154 //-----------------------------------------------------------------------------
 155 //  Comment
 156 //-----------------------------------------------------------------------------
 157 
 158 public class Comment {                    // info about comment syntax
 159     public string start;
 160     public string stop;
 161     public bool nested;
 162     public Comment next;
 163     
 164     public Comment(string start, string stop, bool nested) {
 165         this.start = start; this.stop = stop; this.nested = nested;
 166     }
 167     
 168 }
 169 
 170 //-----------------------------------------------------------------------------
 171 //  CharSet
 172 //-----------------------------------------------------------------------------
 173 
 174 public class CharSet {
 175 
 176     public class Range {
 177         public int from, to;
 178         public Range next;
 179         public Range(int from, int to) { this.from = from; this.to = to; }
 180     }
 181 
 182     public Range head;
 183 
 184     public bool this[int i] {
 185         get {
 186             for (Range p = head; p != null; p = p.next)
 187                 if (i < p.from) return false;
 188                 else if (i <= p.to) return true; // p.from <= i <= p.to
 189             return false;
 190         }
 191     }
 192 
 193     public void Set(int i) {
 194         Range cur = head, prev = null;
 195         while (cur != null && i >= cur.from-1) {
 196             if (i <= cur.to + 1) { // (cur.from-1) <= i <= (cur.to+1)
 197                 if (i == cur.from - 1) cur.from--;
 198                 else if (i == cur.to + 1) {
 199                     cur.to++;
 200                     Range next = cur.next;
 201                     if (next != null && cur.to == next.from - 1) { cur.to = next.to; cur.next = next.next; };
 202                 }
 203                 return;
 204             }
 205             prev = cur; cur = cur.next;
 206         }
 207         Range n = new Range(i, i);
 208         n.next = cur;
 209         if (prev == null) head = n; else prev.next = n;
 210     }
 211 
 212     public CharSet Clone() {
 213         CharSet s = new CharSet();
 214         Range prev = null;
 215         for (Range cur = head; cur != null; cur = cur.next) {
 216             Range r = new Range(cur.from, cur.to);
 217             if (prev == null) s.head = r; else prev.next = r;
 218             prev = r;
 219         }
 220         return s;
 221     }
 222 
 223     public bool Equals(CharSet s) {
 224         Range p = head, q = s.head;
 225         while (p != null && q != null) {
 226             if (p.from != q.from || p.to != q.to) return false;
 227             p = p.next; q = q.next;
 228         }
 229         return p == q;
 230     }
 231 
 232     public int Elements() {
 233         int n = 0;
 234         for (Range p = head; p != null; p = p.next) n += p.to - p.from + 1;
 235         return n;
 236     }
 237 
 238     public int First() {
 239         if (head != null) return head.from;
 240         return -1;
 241     }
 242 
 243     public void Or(CharSet s) {
 244         for (Range p = s.head; p != null; p = p.next)
 245             for (int i = p.from; i <= p.to; i++) Set(i);
 246     }
 247 
 248     public void And(CharSet s) {
 249         CharSet x = new CharSet();
 250         for (Range p = head; p != null; p = p.next)
 251             for (int i = p.from; i <= p.to; i++)
 252                 if (s[i]) x.Set(i);
 253         head = x.head;
 254     }
 255 
 256     public void Subtract(CharSet s) {
 257         CharSet x = new CharSet();
 258         for (Range p = head; p != null; p = p.next)
 259             for (int i = p.from; i <= p.to; i++)
 260                 if (!s[i]) x.Set(i);
 261         head = x.head;
 262     }
 263 
 264     public bool Includes(CharSet s) {
 265         for (Range p = s.head; p != null; p = p.next)
 266             for (int i = p.from; i <= p.to; i++)
 267                 if (!this[i]) return false;
 268         return true;
 269     }
 270 
 271     public bool Intersects(CharSet s) {
 272         for (Range p = s.head; p != null; p = p.next)
 273             for (int i = p.from; i <= p.to; i++)
 274                 if (this[i]) return true;
 275         return false;
 276     }
 277 
 278     public void Fill() {
 279         head = new Range(Char.MinValue, Char.MaxValue);
 280     }
 281 }
 282 
 283 
 284 //-----------------------------------------------------------------------------
 285 //  Generator
 286 //-----------------------------------------------------------------------------
 287 class Generator {
 288     private const int EOF = -1;
 289 
 290     private FileStream fram;
 291     private StreamWriter gen;
 292     private readonly Tab tab;
 293     private string frameFile;
 294 
 295     public Generator(Tab tab) {
 296         this.tab = tab;
 297     }
 298 
 299     public FileStream OpenFrame(String frame) {
 300         if (tab.frameDir != null) frameFile = Path.Combine(tab.frameDir, frame);
 301         if (frameFile == null || !File.Exists(frameFile)) frameFile = Path.Combine(tab.srcDir, frame);
 302         if (frameFile == null || !File.Exists(frameFile)) throw new FatalError("Cannot find : " + frame);
 303 
 304         try {
 305             fram = new FileStream(frameFile, FileMode.Open, FileAccess.Read, FileShare.Read);
 306         } catch (FileNotFoundException) {
 307             throw new FatalError("Cannot open frame file: " + frameFile);
 308         }
 309         return fram;
 310     }
 311 
 312 
 313 
 314     public StreamWriter OpenGen(string target) {
 315         string fn = Path.Combine(tab.outDir, target);
 316         try {
 317             if (File.Exists(fn)) File.Copy(fn, fn + ".old", true);
 318             gen = new StreamWriter(new FileStream(fn, FileMode.Create)); /* pdt */
 319         } catch (IOException) {
 320             throw new FatalError("Cannot generate file: " + fn);
 321         }
 322         return gen;
 323     }
 324 
 325 
 326     public void GenCopyright() {
 327         string copyFr = null;
 328         if (tab.frameDir != null) copyFr = Path.Combine(tab.frameDir, "Copyright.frame");
 329         if (copyFr == null || !File.Exists(copyFr)) copyFr = Path.Combine(tab.srcDir, "Copyright.frame");
 330         if (copyFr == null || !File.Exists(copyFr)) return;
 331 
 332         try {
 333             FileStream scannerFram = fram;
 334             fram = new FileStream(copyFr, FileMode.Open, FileAccess.Read, FileShare.Read);
 335             CopyFramePart(null);
 336             fram = scannerFram;
 337         } catch (FileNotFoundException) {
 338             throw new FatalError("Cannot open Copyright.frame");
 339         }
 340     }
 341 
 342     public void SkipFramePart(String stop) {
 343         CopyFramePart(stop, false);
 344     }
 345 
 346 
 347     public void CopyFramePart(String stop) {
 348         CopyFramePart(stop, true);
 349     }
 350 
 351     // if stop == null, copies until end of file
 352     private void CopyFramePart(string stop, bool generateOutput) {
 353         char startCh = (char) 0;
 354         int endOfStopString = 0;
 355 
 356         if (stop != null) {
 357             startCh = stop[0];
 358             endOfStopString = stop.Length - 1;
 359         }
 360 
 361         int ch = framRead();
 362         while (ch != EOF) {
 363             if (stop != null && ch == startCh) {
 364                 int i = 0;
 365                 do {
 366                     if (i == endOfStopString) return; // stop[0..i] found
 367                     ch = framRead(); i++;
 368                 } while (ch == stop[i]);
 369                 // stop[0..i-1] found; continue with last read character
 370                 if (generateOutput) gen.Write(stop.Substring(0, i));
 371             } else {
 372                 if (generateOutput) gen.Write((char) ch);
 373                 ch = framRead();
 374             }
 375         }
 376         
 377         if (stop != null) throw new FatalError("Incomplete or corrupt frame file: " + frameFile);
 378     }
 379 
 380     private int framRead() {
 381         try {
 382             return fram.ReadByte();
 383         } catch (Exception) {
 384             throw new FatalError("Error reading frame file: " + frameFile);
 385         }
 386     }
 387 }
 388 
 389 //-----------------------------------------------------------------------------
 390 //  DFA
 391 //-----------------------------------------------------------------------------
 392 
 393 public class DFA {
 394     private int maxStates;
 395     private int lastStateNr;   // highest state number
 396     private State firstState;
 397     private State lastState;   // last allocated state
 398     private int lastSimState;  // last non melted state
 399     private FileStream fram;   // scanner frame input
 400     private StreamWriter gen;  // generated scanner file
 401     private Symbol curSy;      // current token to be recognized (in FindTrans)
 402     private bool dirtyDFA;     // DFA may become nondeterministic in MatchLiteral
 403 
 404     public bool ignoreCase;   // true if input should be treated case-insensitively
 405     public bool hasCtxMoves;  // DFA has context transitions
 406     
 407     // other Coco objects
 408     private Parser     parser;
 409     private Tab        tab;
 410     private Errors     errors;
 411     private TextWriter trace;
 412 
 413     //---------- Output primitives
 414     private string Ch(int ch) {
 415         if (ch < ‘ ‘ || ch >= 127 || ch == ‘\‘‘ || ch == ‘\\‘) return Convert.ToString(ch);
 416         else return String.Format("‘{0}‘", (char)ch);
 417     }
 418     
 419     private string ChCond(char ch) {
 420         return String.Format("ch == {0}", Ch(ch));
 421     }
 422     
 423     private void PutRange(CharSet s) {
 424         for (CharSet.Range r = s.head; r != null; r = r.next) {
 425             if (r.from == r.to) { gen.Write("ch == " + Ch(r.from)); }
 426             else if (r.from == 0) { gen.Write("ch <= " + Ch(r.to)); }
 427             else { gen.Write("ch >= " + Ch(r.from) + " && ch <= " + Ch(r.to)); }
 428             if (r.next != null) gen.Write(" || ");
 429         }
 430     }
 431     
 432     //---------- State handling
 433     
 434     State NewState() {
 435         State s = new State(); s.nr = ++lastStateNr;
 436         if (firstState == null) firstState = s; else lastState.next = s;
 437         lastState = s;
 438         return s;
 439     }
 440     
 441     void NewTransition(State from, State to, int typ, int sym, int tc) {
 442         Target t = new Target(to);
 443         Action a = new Action(typ, sym, tc); a.target = t;
 444         from.AddAction(a);
 445         if (typ == Node.clas) curSy.tokenKind = Symbol.classToken;
 446     }
 447     
 448     void CombineShifts() {
 449         State state;
 450         Action a, b, c;
 451         CharSet seta, setb;
 452         for (state = firstState; state != null; state = state.next) {
 453             for (a = state.firstAction; a != null; a = a.next) {
 454                 b = a.next;
 455                 while (b != null)
 456                     if (a.target.state == b.target.state && a.tc == b.tc) {
 457                         seta = a.Symbols(tab); setb = b.Symbols(tab);
 458                         seta.Or(setb);
 459                         a.ShiftWith(seta, tab);
 460                         c = b; b = b.next; state.DetachAction(c);
 461                     } else b = b.next;
 462             }
 463         }
 464     }
 465     
 466     void FindUsedStates(State state, BitArray used) {
 467         if (used[state.nr]) return;
 468         used[state.nr] = true;
 469         for (Action a = state.firstAction; a != null; a = a.next)
 470             FindUsedStates(a.target.state, used);
 471     }
 472     
 473     void DeleteRedundantStates() {
 474         State[] newState = new State[lastStateNr + 1];
 475         BitArray used = new BitArray(lastStateNr + 1);
 476         FindUsedStates(firstState, used);
 477         // combine equal final states
 478         for (State s1 = firstState.next; s1 != null; s1 = s1.next) // firstState cannot be final
 479             if (used[s1.nr] && s1.endOf != null && s1.firstAction == null && !s1.ctx)
 480                 for (State s2 = s1.next; s2 != null; s2 = s2.next)
 481                     if (used[s2.nr] && s1.endOf == s2.endOf && s2.firstAction == null & !s2.ctx) {
 482                         used[s2.nr] = false; newState[s2.nr] = s1;
 483                     }
 484         for (State state = firstState; state != null; state = state.next)
 485             if (used[state.nr])
 486                 for (Action a = state.firstAction; a != null; a = a.next)
 487                     if (!used[a.target.state.nr])
 488                         a.target.state = newState[a.target.state.nr];
 489         // delete unused states
 490         lastState = firstState; lastStateNr = 0; // firstState has number 0
 491         for (State state = firstState.next; state != null; state = state.next)
 492             if (used[state.nr]) {state.nr = ++lastStateNr; lastState = state;}
 493             else lastState.next = state.next;
 494     }
 495     
 496     State TheState(Node p) {
 497         State state;
 498         if (p == null) {state = NewState(); state.endOf = curSy; return state;}
 499         else return p.state;
 500     }
 501     
 502     void Step(State from, Node p, BitArray stepped) {
 503         if (p == null) return;
 504         stepped[p.n] = true;
 505         switch (p.typ) {
 506             case Node.clas: case Node.chr: {
 507                 NewTransition(from, TheState(p.next), p.typ, p.val, p.code);
 508                 break;
 509             }
 510             case Node.alt: {
 511                 Step(from, p.sub, stepped); Step(from, p.down, stepped);
 512                 break;
 513             }
 514             case Node.iter: {
 515                 if (Tab.DelSubGraph(p.sub)) {
 516                     parser.SemErr("contents of {...} must not be deletable");
 517                     return;
 518                 }
 519                 if (p.next != null && !stepped[p.next.n]) Step(from, p.next, stepped);
 520                 Step(from, p.sub, stepped);
 521                 if (p.state != from) {
 522                     Step(p.state, p, new BitArray(tab.nodes.Count));
 523                 }
 524                 break;
 525             }
 526             case Node.opt: {
 527                 if (p.next != null && !stepped[p.next.n]) Step(from, p.next, stepped);
 528                 Step(from, p.sub, stepped);
 529                 break;
 530             }
 531         }
 532     }
 533 
 534     // Assigns a state n.state to every node n. There will be a transition from
 535     // n.state to n.next.state triggered by n.val. All nodes in an alternative
 536     // chain are represented by the same state.
 537     // Numbering scheme:
 538     //  - any node after a chr, clas, opt, or alt, must get a new number
 539     //  - if a nested structure starts with an iteration the iter node must get a new number
 540     //  - if an iteration follows an iteration, it must get a new number
 541     void NumberNodes(Node p, State state, bool renumIter) {
 542         if (p == null) return;
 543         if (p.state != null) return; // already visited;
 544         if (state == null || (p.typ == Node.iter && renumIter)) state = NewState();
 545         p.state = state;
 546         if (Tab.DelGraph(p)) state.endOf = curSy;
 547         switch (p.typ) {
 548             case Node.clas: case Node.chr: {
 549                 NumberNodes(p.next, null, false);
 550                 break;
 551             }
 552             case Node.opt: {
 553                 NumberNodes(p.next, null, false);
 554                 NumberNodes(p.sub, state, true);
 555                 break;
 556             }
 557             case Node.iter: {
 558                 NumberNodes(p.next, state, true);
 559                 NumberNodes(p.sub, state, true);
 560                 break;
 561             }
 562             case Node.alt: {
 563                 NumberNodes(p.next, null, false);
 564                 NumberNodes(p.sub, state, true);
 565                 NumberNodes(p.down, state, renumIter);
 566                 break;
 567             }
 568         }
 569     }
 570     
 571     void FindTrans (Node p, bool start, BitArray marked) {
 572         if (p == null || marked[p.n]) return;
 573         marked[p.n] = true;
 574         if (start) Step(p.state, p, new BitArray(tab.nodes.Count)); // start of group of equally numbered nodes
 575         switch (p.typ) {
 576             case Node.clas: case Node.chr: {
 577                 FindTrans(p.next, true, marked);
 578                 break;
 579             }
 580             case Node.opt: {
 581                 FindTrans(p.next, true, marked); FindTrans(p.sub, false, marked);
 582                 break;
 583             }
 584             case Node.iter: {
 585                 FindTrans(p.next, false, marked); FindTrans(p.sub, false, marked);
 586                 break;
 587             }
 588             case Node.alt: {
 589                 FindTrans(p.sub, false, marked); FindTrans(p.down, false, marked);
 590                 break;
 591             }
 592         }
 593     }
 594     
 595     public void ConvertToStates(Node p, Symbol sym) {
 596         curSy = sym;
 597         if (Tab.DelGraph(p)) {
 598             parser.SemErr("token might be empty");
 599             return;
 600         }
 601         NumberNodes(p, firstState, true);
 602         FindTrans(p, true, new BitArray(tab.nodes.Count));
 603         if (p.typ == Node.iter) {
 604             Step(firstState, p, new BitArray(tab.nodes.Count));
 605         }
 606     }
 607     
 608     // match string against current automaton; store it either as a fixedToken or as a litToken
 609     public void MatchLiteral(string s, Symbol sym) {
 610         s = tab.Unescape(s.Substring(1, s.Length-2));
 611         int i, len = s.Length;
 612         State state = firstState;
 613         Action a = null;
 614         for (i = 0; i < len; i++) { // try to match s against existing DFA
 615             a = FindAction(state, s[i]);
 616             if (a == null) break;
 617             state = a.target.state;
 618         }
 619         // if s was not totally consumed or leads to a non-final state => make new DFA from it
 620         if (i != len || state.endOf == null) {
 621             state = firstState; i = 0; a = null;
 622             dirtyDFA = true;
 623         }
 624         for (; i < len; i++) { // make new DFA for s[i..len-1], ML: i is either 0 or len
 625             State to = NewState();
 626             NewTransition(state, to, Node.chr, s[i], Node.normalTrans);
 627             state = to;
 628         }
 629         Symbol matchedSym = state.endOf;
 630         if (state.endOf == null) {
 631             state.endOf = sym;
 632         } else if (matchedSym.tokenKind == Symbol.fixedToken || (a != null && a.tc == Node.contextTrans)) {
 633             // s matched a token with a fixed definition or a token with an appendix that will be cut off
 634             parser.SemErr("tokens " + sym.name + " and " + matchedSym.name + " cannot be distinguished");
 635         } else { // matchedSym == classToken || classLitToken
 636             matchedSym.tokenKind = Symbol.classLitToken;
 637             sym.tokenKind = Symbol.litToken;
 638         }
 639     }
 640     
 641     void SplitActions(State state, Action a, Action b) {
 642         Action c; CharSet seta, setb, setc;
 643         seta = a.Symbols(tab); setb = b.Symbols(tab);
 644         if (seta.Equals(setb)) {
 645             a.AddTargets(b);
 646             state.DetachAction(b);
 647         } else if (seta.Includes(setb)) {
 648             setc = seta.Clone(); setc.Subtract(setb);
 649             b.AddTargets(a);
 650             a.ShiftWith(setc, tab);
 651         } else if (setb.Includes(seta)) {
 652             setc = setb.Clone(); setc.Subtract(seta);
 653             a.AddTargets(b);
 654             b.ShiftWith(setc, tab);
 655         } else {
 656             setc = seta.Clone(); setc.And(setb);
 657             seta.Subtract(setc);
 658             setb.Subtract(setc);
 659             a.ShiftWith(seta, tab);
 660             b.ShiftWith(setb, tab);
 661             c = new Action(0, 0, Node.normalTrans);  // typ and sym are set in ShiftWith
 662             c.AddTargets(a);
 663             c.AddTargets(b);
 664             c.ShiftWith(setc, tab);
 665             state.AddAction(c);
 666         }
 667     }
 668     
 669     bool Overlap(Action a, Action b) {
 670         CharSet seta, setb;
 671         if (a.typ == Node.chr)
 672             if (b.typ == Node.chr) return a.sym == b.sym;
 673             else {setb = tab.CharClassSet(b.sym); return setb[a.sym];}
 674         else {
 675             seta = tab.CharClassSet(a.sym);
 676             if (b.typ == Node.chr) return seta[b.sym];
 677             else {setb = tab.CharClassSet(b.sym); return seta.Intersects(setb);}
 678         }
 679     }
 680     
 681     void MakeUnique(State state) {
 682         bool changed;
 683         do {
 684             changed = false;
 685             for (Action a = state.firstAction; a != null; a = a.next)
 686                 for (Action b = a.next; b != null; b = b.next)
 687                     if (Overlap(a, b)) { SplitActions(state, a, b); changed = true; }
 688         } while (changed);
 689     }
 690     
 691     void MeltStates(State state) {
 692         bool ctx;
 693         BitArray targets;
 694         Symbol endOf;
 695         for (Action action = state.firstAction; action != null; action = action.next) {
 696             if (action.target.next != null) {
 697                 GetTargetStates(action, out targets, out endOf, out ctx);
 698                 Melted melt = StateWithSet(targets);
 699                 if (melt == null) {
 700                     State s = NewState(); s.endOf = endOf; s.ctx = ctx;
 701                     for (Target targ = action.target; targ != null; targ = targ.next)
 702                         s.MeltWith(targ.state);
 703                     MakeUnique(s);
 704                     melt = NewMelted(targets, s);
 705                 }
 706                 action.target.next = null;
 707                 action.target.state = melt.state;
 708             }
 709         }
 710     }
 711     
 712     void FindCtxStates() {
 713         for (State state = firstState; state != null; state = state.next)
 714             for (Action a = state.firstAction; a != null; a = a.next)
 715                 if (a.tc == Node.contextTrans) a.target.state.ctx = true;
 716     }
 717     
 718     public void MakeDeterministic() {
 719         State state;
 720         lastSimState = lastState.nr;
 721         maxStates = 2 * lastSimState; // heuristic for set size in Melted.set
 722         FindCtxStates();
 723         for (state = firstState; state != null; state = state.next)
 724             MakeUnique(state);
 725         for (state = firstState; state != null; state = state.next)
 726             MeltStates(state);
 727         DeleteRedundantStates();
 728         CombineShifts();
 729     }
 730     
 731     public void PrintStates() {
 732         trace.WriteLine();
 733         trace.WriteLine("---------- states ----------");
 734         for (State state = firstState; state != null; state = state.next) {
 735             bool first = true;
 736             if (state.endOf == null) trace.Write("               ");
 737             else trace.Write("E({0,12})", tab.Name(state.endOf.name));
 738             trace.Write("{0,3}:", state.nr);
 739             if (state.firstAction == null) trace.WriteLine();
 740             for (Action action = state.firstAction; action != null; action = action.next) {
 741                 if (first) {trace.Write(" "); first = false;} else trace.Write("                    ");
 742                 if (action.typ == Node.clas) trace.Write(((CharClass)tab.classes[action.sym]).name);
 743                 else trace.Write("{0, 3}", Ch(action.sym));
 744                 for (Target targ = action.target; targ != null; targ = targ.next)
 745                     trace.Write(" {0, 3}", targ.state.nr);
 746                 if (action.tc == Node.contextTrans) trace.WriteLine(" context"); else trace.WriteLine();
 747             }
 748         }
 749         trace.WriteLine();
 750         trace.WriteLine("---------- character classes ----------");
 751         tab.WriteCharClasses();
 752     }
 753     
 754 //---------------------------- actions --------------------------------
 755 
 756     public Action FindAction(State state, char ch) {
 757         for (Action a = state.firstAction; a != null; a = a.next)
 758             if (a.typ == Node.chr && ch == a.sym) return a;
 759             else if (a.typ == Node.clas) {
 760                 CharSet s = tab.CharClassSet(a.sym);
 761                 if (s[ch]) return a;
 762             }
 763         return null;
 764     }
 765     
 766     public void GetTargetStates(Action a, out BitArray targets, out Symbol endOf, out bool ctx) { 
 767         // compute the set of target states
 768         targets = new BitArray(maxStates); endOf = null;
 769         ctx = false;
 770         for (Target t = a.target; t != null; t = t.next) {
 771             int stateNr = t.state.nr;
 772             if (stateNr <= lastSimState) targets[stateNr] = true;
 773             else targets.Or(MeltedSet(stateNr));
 774             if (t.state.endOf != null)
 775                 if (endOf == null || endOf == t.state.endOf)
 776                     endOf = t.state.endOf;
 777                 else
 778                     errors.SemErr("Tokens " + endOf.name + " and " + t.state.endOf.name + " cannot be distinguished");
 779             if (t.state.ctx) {
 780                 ctx = true;
 781                 // The following check seems to be unnecessary. It reported an error
 782                 // if a symbol + context was the prefix of another symbol, e.g.
 783                 //   s1 = "a" "b" "c".
 784                 //   s2 = "a" CONTEXT("b").
 785                 // But this is ok.
 786                 // if (t.state.endOf != null) {
 787                 //   Console.WriteLine("Ambiguous context clause");
 788                 //     errors.count++;
 789                 // }
 790             }
 791         }
 792     }
 793     
 794 //------------------------- melted states ------------------------------
 795 
 796     Melted firstMelted;    // head of melted state list
 797     
 798     Melted NewMelted(BitArray set, State state) {
 799         Melted m = new Melted(set, state);
 800         m.next = firstMelted; firstMelted = m;
 801         return m;
 802     }
 803     
 804     BitArray MeltedSet(int nr) {
 805         Melted m = firstMelted;
 806         while (m != null) {
 807             if (m.state.nr == nr) return m.set; else m = m.next;
 808         }
 809         throw new FatalError("compiler error in Melted.Set");
 810     }
 811 
 812     Melted StateWithSet(BitArray s) {
 813         for (Melted m = firstMelted; m != null; m = m.next)
 814             if (Sets.Equals(s, m.set)) return m;
 815         return null;
 816     }
 817 
 818 //------------------------ comments --------------------------------
 819 
 820     public Comment firstComment;    // list of comments
 821 
 822     string CommentStr(Node p) {
 823         StringBuilder s = new StringBuilder();
 824         while (p != null) {
 825             if (p.typ == Node.chr) {
 826                 s.Append((char)p.val);
 827             } else if (p.typ == Node.clas) {
 828                 CharSet set = tab.CharClassSet(p.val);
 829                 if (set.Elements() != 1) parser.SemErr("character set contains more than 1 character");
 830                 s.Append((char)set.First());
 831             } else parser.SemErr("comment delimiters may not be structured");
 832             p = p.next;
 833         }
 834         if (s.Length == 0 || s.Length > 2) {
 835             parser.SemErr("comment delimiters must be 1 or 2 characters long");
 836             s = new StringBuilder("?");
 837         }
 838         return s.ToString();
 839     }
 840     
 841     public void NewComment(Node from, Node to, bool nested) {
 842         Comment c = new Comment(CommentStr(from), CommentStr(to), nested);
 843         c.next = firstComment; firstComment = c;
 844     }
 845 
 846 
 847 //------------------------ scanner generation ----------------------
 848 
 849     void GenComBody(Comment com) {
 850         gen.WriteLine(  "\t\t\tfor(;;) {");
 851         gen.Write    (  "\t\t\t\tif ({0}) ", ChCond(com.stop[0])); gen.WriteLine("{");
 852         if (com.stop.Length == 1) {
 853             gen.WriteLine("\t\t\t\t\tlevel--;");
 854             gen.WriteLine("\t\t\t\t\tif (level == 0) { oldEols = line - line0; NextCh(); return true; }");
 855             gen.WriteLine("\t\t\t\t\tNextCh();");
 856         } else {
 857             gen.WriteLine("\t\t\t\t\tNextCh();");
 858             gen.WriteLine("\t\t\t\t\tif ({0}) {{", ChCond(com.stop[1]));
 859             gen.WriteLine("\t\t\t\t\t\tlevel--;");
 860             gen.WriteLine("\t\t\t\t\t\tif (level == 0) { oldEols = line - line0; NextCh(); return true; }");
 861             gen.WriteLine("\t\t\t\t\t\tNextCh();");
 862             gen.WriteLine("\t\t\t\t\t}");
 863         }
 864         if (com.nested) {
 865             gen.Write    ("\t\t\t\t}"); gen.Write(" else if ({0}) ", ChCond(com.start[0])); gen.WriteLine("{");
 866             if (com.start.Length == 1)
 867                 gen.WriteLine("\t\t\t\t\tlevel++; NextCh();");
 868             else {
 869                 gen.WriteLine("\t\t\t\t\tNextCh();");
 870                 gen.Write    ("\t\t\t\t\tif ({0}) ", ChCond(com.start[1])); gen.WriteLine("{");
 871                 gen.WriteLine("\t\t\t\t\t\tlevel++; NextCh();");
 872                 gen.WriteLine("\t\t\t\t\t}");
 873             }
 874         }
 875         gen.WriteLine(    "\t\t\t\t} else if (ch == Buffer.EOF) return false;");
 876         gen.WriteLine(    "\t\t\t\telse NextCh();");
 877         gen.WriteLine(    "\t\t\t}");
 878     }
 879     
 880     void GenComment(Comment com, int i) {
 881         gen.WriteLine();
 882         gen.Write    ("\tbool Comment{0}() ", i); gen.WriteLine("{");
 883         gen.WriteLine("\t\tint level = 1, pos0 = pos, line0 = line, col0 = col, charPos0 = charPos;");
 884         if (com.start.Length == 1) {
 885             gen.WriteLine("\t\tNextCh();");
 886             GenComBody(com);
 887         } else {
 888             gen.WriteLine("\t\tNextCh();");
 889             gen.Write    ("\t\tif ({0}) ", ChCond(com.start[1])); gen.WriteLine("{");
 890             gen.WriteLine("\t\t\tNextCh();");
 891             GenComBody(com);
 892             gen.WriteLine("\t\t} else {");
 893             gen.WriteLine("\t\t\tbuffer.Pos = pos0; NextCh(); line = line0; col = col0; charPos = charPos0;");
 894             gen.WriteLine("\t\t}");
 895             gen.WriteLine("\t\treturn false;");
 896         }
 897         gen.WriteLine("\t}");
 898     }
 899     
 900     string SymName(Symbol sym) {
 901         if (Char.IsLetter(sym.name[0])) { // real name value is stored in Tab.literals
 902             foreach (DictionaryEntry e in tab.literals)
 903                 if ((Symbol)e.Value == sym) return (string)e.Key;
 904         }
 905         return sym.name;
 906     }
 907     
 908     void GenLiterals () {
 909         if (ignoreCase) {
 910             gen.WriteLine("\t\tswitch (t.val.ToLower()) {");
 911         } else {
 912             gen.WriteLine("\t\tswitch (t.val) {");
 913         }
 914         foreach (IList ts in new IList[] { tab.terminals, tab.pragmas }) {
 915             foreach (Symbol sym in ts) {
 916                 if (sym.tokenKind == Symbol.litToken) {
 917                     string name = SymName(sym);
 918                     if (ignoreCase) name = name.ToLower();
 919                     // sym.name stores literals with quotes, e.g. "\"Literal\""
 920                     gen.WriteLine("\t\t\tcase {0}: t.kind = {1}; break;", name, sym.n);
 921                 }
 922             }
 923         }
 924         gen.WriteLine("\t\t\tdefault: break;");
 925         gen.Write("\t\t}");
 926     }
 927     
 928     void WriteState(State state) {
 929         Symbol endOf = state.endOf;
 930         gen.WriteLine("\t\t\tcase {0}:", state.nr);
 931         if (endOf != null && state.firstAction != null) {
 932             gen.WriteLine("\t\t\t\trecEnd = pos; recKind = {0};", endOf.n);
 933         }
 934         bool ctxEnd = state.ctx;
 935         for (Action action = state.firstAction; action != null; action = action.next) {
 936             if (action == state.firstAction) gen.Write("\t\t\t\tif (");
 937             else gen.Write("\t\t\t\telse if (");
 938             if (action.typ == Node.chr) gen.Write(ChCond((char)action.sym));
 939             else PutRange(tab.CharClassSet(action.sym));
 940             gen.Write(") {");
 941             if (action.tc == Node.contextTrans) {
 942                 gen.Write("apx++; "); ctxEnd = false;
 943             } else if (state.ctx)
 944                 gen.Write("apx = 0; ");
 945             gen.Write("AddCh(); goto case {0};", action.target.state.nr);
 946             gen.WriteLine("}");
 947         }
 948         if (state.firstAction == null)
 949             gen.Write("\t\t\t\t{");
 950         else
 951             gen.Write("\t\t\t\telse {");
 952         if (ctxEnd) { // final context state: cut appendix
 953             gen.WriteLine();
 954             gen.WriteLine("\t\t\t\t\ttlen -= apx;");
 955             gen.WriteLine("\t\t\t\t\tSetScannerBehindT();");
 956             gen.Write("\t\t\t\t\t");
 957         }
 958         if (endOf == null) {
 959             gen.WriteLine("goto case 0;}");
 960         } else {
 961             gen.Write("t.kind = {0}; ", endOf.n);
 962             if (endOf.tokenKind == Symbol.classLitToken) {
 963                 gen.WriteLine("t.val = new String(tval, 0, tlen); CheckLiteral(); return t;}");
 964             } else {
 965                 gen.WriteLine("break;}");
 966             }
 967         }
 968     }
 969     
 970     void WriteStartTab() {
 971         for (Action action = firstState.firstAction; action != null; action = action.next) {
 972             int targetState = action.target.state.nr;
 973             if (action.typ == Node.chr) {
 974                 gen.WriteLine("\t\tstart[" + action.sym + "] = " + targetState + "; ");
 975             } else {
 976                 CharSet s = tab.CharClassSet(action.sym);
 977                 for (CharSet.Range r = s.head; r != null; r = r.next) {
 978                     gen.WriteLine("\t\tfor (int i = " + r.from + "; i <= " + r.to + "; ++i) start[i] = " + targetState + ";");
 979                 }
 980             }
 981         }
 982         gen.WriteLine("\t\tstart[Buffer.EOF] = -1;");
 983     }
 984 
 985     public void WriteScanner() {
 986         Generator g = new Generator(tab);
 987         fram = g.OpenFrame("Scanner.frame");
 988         gen = g.OpenGen("Scanner.cs");
 989         if (dirtyDFA) MakeDeterministic();
 990 
 991         g.GenCopyright();
 992         g.SkipFramePart("-->begin");
 993 
 994         g.CopyFramePart("-->namespace");
 995         if (tab.nsName != null && tab.nsName.Length > 0) {
 996             gen.Write("namespace ");
 997             gen.Write(tab.nsName);
 998             gen.Write(" {");
 999         }
1000         g.CopyFramePart("-->declarations");
1001         gen.WriteLine("\tconst int maxT = {0};", tab.terminals.Count - 1);
1002         gen.WriteLine("\tconst int noSym = {0};", tab.noSym.n);
1003         if (ignoreCase)
1004             gen.Write("\tchar valCh;       // current input character (for token.val)");
1005         g.CopyFramePart("-->initialization");
1006         WriteStartTab();
1007         g.CopyFramePart("-->casing1");
1008         if (ignoreCase) {
1009             gen.WriteLine("\t\tif (ch != Buffer.EOF) {");
1010             gen.WriteLine("\t\t\tvalCh = (char) ch;");
1011             gen.WriteLine("\t\t\tch = char.ToLower((char) ch);");
1012             gen.WriteLine("\t\t}");
1013         }
1014         g.CopyFramePart("-->casing2");
1015         gen.Write("\t\t\ttval[tlen++] = ");
1016         if (ignoreCase) gen.Write("valCh;"); else gen.Write("(char) ch;");
1017         g.CopyFramePart("-->comments");
1018         Comment com = firstComment; 
1019         int comIdx = 0;
1020         while (com != null) {
1021             GenComment(com, comIdx);
1022             com = com.next; comIdx++;
1023         }
1024         g.CopyFramePart("-->literals"); GenLiterals();
1025         g.CopyFramePart("-->scan1");
1026         gen.Write("\t\t\t");
1027         if (tab.ignored.Elements() > 0) { PutRange(tab.ignored); } else { gen.Write("false"); }
1028         g.CopyFramePart("-->scan2");
1029         if (firstComment != null) {
1030             gen.Write("\t\tif (");
1031             com = firstComment; comIdx = 0;
1032             while (com != null) {
1033                 gen.Write(ChCond(com.start[0]));
1034                 gen.Write(" && Comment{0}()", comIdx);
1035                 if (com.next != null) gen.Write(" ||");
1036                 com = com.next; comIdx++;
1037             }
1038             gen.Write(") return NextToken();");
1039         }
1040         if (hasCtxMoves) { gen.WriteLine(); gen.Write("\t\tint apx = 0;"); } /* pdt */
1041         g.CopyFramePart("-->scan3");
1042         for (State state = firstState.next; state != null; state = state.next)
1043             WriteState(state);
1044         g.CopyFramePart(null);
1045         if (tab.nsName != null && tab.nsName.Length > 0) gen.Write("}");
1046         gen.Close();
1047     }
1048     
1049     public DFA (Parser parser) {
1050         this.parser = parser;
1051         tab = parser.tab;
1052         errors = parser.errors;
1053         trace = parser.trace;
1054         firstState = null; lastState = null; lastStateNr = -1;
1055         firstState = NewState();
1056         firstMelted = null; firstComment = null;
1057         ignoreCase = false;
1058         dirtyDFA = false;
1059         hasCtxMoves = false;
1060     }
1061     
1062 } // end DFA
1063 
1064 } // end namespace