refactor - making more use of the Char enum

Author: ColinEberhardt

assembly/nfa/characters.ts renamed to assembly/char.ts

@@ -1,13 +1,29 @@
-export const enum CharClass {
+export const enum Char {
   None = -1,
-
-  Dot = 0x2e, // "."
+  HorizontalTab = 0x09,
+  VerticalTab = 0x0b,
+  FormFeed = 0x0c,
+  CarriageReturn = 0x0d,
+  LineFeed = 0x0a,
   Dollar = 0x24, // "$"
-  Caret = 0x5e, // "^"
-
+  LeftParenthesis = 0x28,
+  RightParenthesis = 0x29,
+  Asterisk = 0x2a, // "*"
+  Comma = 0x2c, // "*"
+  Plus = 0x2b, // "+"
+  Dot = 0x2e, // "."
+  Zero = 0x30,
+  Question = 0x3f, // "?"
+  A = 0x41,
   D = 0x44,
   S = 0x53,
   W = 0x57,
+  LeftSquareBracket = 0x5b, // "["
+  Backslash = 0x5c, // "\"
+  RightSquareBracket = 0x5d, // "]"
+  Caret = 0x5e, // "^"
+  Underscore = 0x5f,
+  a = 0x61,
   d = 0x64,
   f = 0x66,
   n = 0x6e,
@@ -16,32 +32,25 @@ export const enum CharClass {
   t = 0x74,
   v = 0x76,
   w = 0x77,
-}
-
-export const enum QuantifierClass {
-  Star = 0x2a, // "*"
-  Plus = 0x2b, // "+"
-  Question = 0x3f, // "?"
+  LeftCurlyBrace = 0x7b /* { */,
+  VerticalBar = 0x7c /* | */,
+  RightCurlyBrace = 0x7d /*  */,
 }
 
 export function isDigit(code: u32): bool {
-  return code - 48 < 10;
+  return code - Char.Zero < 10;
 }
 
 export function isLowercaseAlpha(code: u32): bool {
-  return code - 97 < 26;
+  return code - Char.a < 26;
 }
 
 export function isUppercaseAlpha(code: u32): bool {
-  return code - 65 < 26;
+  return code - Char.A < 26;
 }
 
 export function isAlpha(code: u32): bool {
-  return (code | 32) - 97 < 26;
-}
-
-export function isUnderscore(code: u32): bool {
-  return code == 95;
+  return (code | 32) - Char.a < 26;
 }
 
 export function isWhitespace(code: u32): bool {

assembly/nfa/matcher.ts

@@ -1,10 +1,4 @@
-import {
-  isDigit,
-  isAlpha,
-  isUnderscore,
-  isWhitespace,
-  CharClass,
-} from "./characters";
+import { isDigit, isAlpha, isWhitespace, Char } from "../char";
 
 import {
   CharacterNode,
@@ -31,7 +25,7 @@ export abstract class Matcher {
 }
 
 export class CharacterMatcher extends Matcher {
-  constructor(public character: CharClass) {
+  constructor(public character: Char) {
     super();
   }
 
@@ -41,36 +35,41 @@ export class CharacterMatcher extends Matcher {
 }
 
 export class CharacterClassMatcher extends Matcher {
-  constructor(public charClass: CharClass) {
+  constructor(public charClass: Char) {
     super();
   }
 
   matches(code: u32): bool {
     switch (this.charClass) {
-      case CharClass.d:
+      case Char.d:
         return isDigit(code);
-      case CharClass.D:
+      case Char.D:
         return !isDigit(code);
-      case CharClass.Dot:
-        return code != 13 && code != 10 && code != 8232 && code != 8233;
-      case CharClass.w:
-        return isAlpha(code) || isUnderscore(code) || isDigit(code);
-      case CharClass.W:
-        return !(isAlpha(code) || isUnderscore(code) || isDigit(code));
-      case CharClass.s:
+      case Char.Dot:
+        return (
+          code != Char.CarriageReturn &&
+          code != Char.LineFeed &&
+          code != 8232 &&
+          code != 8233
+        );
+      case Char.w:
+        return isAlpha(code) || code == Char.Underscore || isDigit(code);
+      case Char.W:
+        return !(isAlpha(code) || code == Char.Underscore || isDigit(code));
+      case Char.s:
         return isWhitespace(code);
-      case CharClass.S:
+      case Char.S:
         return !isWhitespace(code);
-      case CharClass.t:
-        return code == 9;
-      case CharClass.r:
-        return code == 13;
-      case CharClass.n:
-        return code == 10;
-      case CharClass.v:
-        return code == 11;
-      case CharClass.f:
-        return code == 12;
+      case Char.t:
+        return code == Char.HorizontalTab;
+      case Char.r:
+        return code == Char.CarriageReturn;
+      case Char.n:
+        return code == Char.LineFeed;
+      case Char.v:
+        return code == Char.VerticalTab;
+      case Char.f:
+        return code == Char.FormFeed;
 
       default:
         throw new Error(

assembly/nfa/nfa.ts

@@ -11,7 +11,7 @@ import {
   AssertionNode,
 } from "../parser/node";
 
-import { QuantifierClass } from "./characters";
+import { Char } from "../char";
 import { Matcher } from "./matcher";
 
 export class State {
@@ -158,11 +158,11 @@ function automataForNode(expression: Node | null): Automata {
     const c = expression as RepetitionNode;
     const auto = automataForNode(c.expression);
     const quantifier = c.quantifier;
-    if (quantifier == QuantifierClass.Question) {
+    if (quantifier == Char.Question) {
       return zeroOrOne(auto);
-    } else if (quantifier == QuantifierClass.Plus) {
+    } else if (quantifier == Char.Plus) {
       return oneOrMore(auto);
-    } else if (quantifier == QuantifierClass.Star) {
+    } else if (quantifier == Char.Asterisk) {
       return closure(auto);
     } else {
       throw new Error(

assembly/parser/node.ts

@@ -1,4 +1,4 @@
-import { CharClass, QuantifierClass } from "../nfa/characters";
+import { Char } from "../char";
 import { replaceAtIndex } from "../util";
 
 export const enum NodeType {
@@ -107,14 +107,14 @@ export class CharacterNode extends Node {
 }
 
 export class AssertionNode extends Node {
-  constructor(public kind: CharClass) {
+  constructor(public kind: Char) {
     super(NodeType.Assertion);
   }
 
-  static is(node: Node, kind: CharClass = CharClass.None): bool {
+  static is(node: Node, kind: Char = Char.None): bool {
     return (
       node.type == NodeType.Assertion &&
-      ((node as AssertionNode).kind == kind || kind == CharClass.None)
+      ((node as AssertionNode).kind == kind || kind == Char.None)
     );
   }
 
@@ -124,7 +124,7 @@ export class AssertionNode extends Node {
 }
 
 export class CharacterClassNode extends Node {
-  constructor(public charClass: CharClass) {
+  constructor(public charClass: Char) {
     super(NodeType.CharacterClass);
   }
 
@@ -138,7 +138,7 @@ export class CharacterClassNode extends Node {
 }
 
 export class RepetitionNode extends Node {
-  constructor(public expression: Node, public quantifier: QuantifierClass) {
+  constructor(public expression: Node, public quantifier: Char) {
     super(NodeType.Repetition);
   }