prototype-3x5/src/parser.ts

import { escapeHtml } from './helpers';
import { AtLeast, Choose, End, Pattern, Peek, Regex, Sequence, Use } from './peg';
import {
    InterpolatedPiece, Script, ScriptPiece, SimplifyWord, TextWord, Word as WordType
} from './words';

const Comment = Regex(/#([^\\\n]|\\[^])*/y)
  .expects("#")
  .map(() => []);

const PreWordWhitespace = Regex(/([^\S\n;]|\\\n)+/y).expects("whitespace");

const BackslashEscape = Sequence(
  Regex(/\\/y).expects("BACKSLASH"),
  Regex(/./y).expects("CHAR")
).map(([, [char]]) => ({ text: char }));

const BARE_WORD_CHAR = /[^\s\\;\[\]]+/y;

let BracketScript: Pattern<Script>;
const Bracket: Pattern<ScriptPiece> = Sequence(
  Regex(/\[/y).expects("["),
  Use(() => BracketScript)
)
  .expects("[")
  .map(([, script]) => ({ script }));

const BareWord = Sequence(
  Regex(/(?!["{])/y),
  AtLeast(
    1,
    Choose<InterpolatedPiece>(
      BackslashEscape,
      Bracket,
      Regex(BARE_WORD_CHAR)
        .expects("CHAR")
        .map(([text]) => ({ bare: text }))
    )
  )
).map(([, pieces], pos) => SimplifyWord(pieces, pos));

const QuotedWord = Sequence(
  Regex(/"/y).expects('"'),
  AtLeast(
    0,
    Choose<InterpolatedPiece>(
      BackslashEscape,
      Bracket,
      Regex(/[^"\\\[]+/y)
        .expects("CHAR")
        .map(([text]) => ({ text }))
    )
  ),
  Regex(/"/y).expects('"')
).map(([, pieces], pos) => SimplifyWord(pieces, pos));

export const TemplateBlock = Sequence(
  AtLeast(
    0,
    Choose<InterpolatedPiece>(
      Regex(/\\\n\s*/y)
        .map(() => ({ text: " " }))
        .expects("BACKSLASH"),
      BackslashEscape,
      Bracket,
      Regex(/[^\\\[]+/y)
        .expects("CHAR")
        .map(([text]) => ({ text }))
    )
  ),
  End()
).map(([pieces], pos) => SimplifyWord(pieces, pos));

const Brace: Pattern<string> = Sequence(
  Regex(/\{/y).expects("{"),
  AtLeast(
    0,
    Choose(
      Use(() => Brace)
        .expects("{")
        .map((text) => `{${text}}`),
      Regex(/\\[^]/y)
        .expects("BACKSLASH")
        .map(([escape]) => escape),
      Regex(/[^\\{}]+/y)
        .expects("CHAR")
        .map(([text]) => text)
    )
  ),
  Regex(/\}/y).expects("}")
).map(([, fragments]) => fragments.join(""));

export const WordPattern = Choose<WordType>(
  Brace.map((text, pos) => ({ text, pos } as TextWord)),
  QuotedWord,
  BareWord
);

const CommandTerminator = Regex(/[\n;]/y)
  .expects("NEWLINE | ;")
  .map(() => true);

const Command = Sequence(
  WordPattern,
  AtLeast(
    0,
    Sequence(PreWordWhitespace, WordPattern).map(([, word]) => word)
  ),
  AtLeast(0, PreWordWhitespace)
).map(([word, moreWords]) => [word].concat(moreWords));

function scriptTmpl(endPattern: Pattern<unknown>) {
  return Sequence(
    AtLeast(
      0,
      Choose(
        PreWordWhitespace.map(() => []),
        CommandTerminator.map(() => []),
        Sequence(Comment, Choose(CommandTerminator, Peek(endPattern))).map(
          () => []
        ),
        Sequence(Command, Choose(CommandTerminator, Peek(endPattern))).map(
          ([words]) => words
        )
      )
    ),
    endPattern
  ).map(([commands]) => commands.filter((command) => command.length > 0));
}

const Script = scriptTmpl(End());
BracketScript = scriptTmpl(Regex(/\]/y).expects("]"));

const ERROR_CONTEXT = /(?<=([^\n]{0,50}))([^\n]{0,50})/y;

/**
 * Parse out a Notcl script into an easier-to-interpret representation.
 * No script is actually executed yet.
 *
 * @param - code to parse
 * @returns - parsed list of commands, or error message on failure
 */
export function parse(code: string): [true, Script] | [false, string] {
  /* Parse */
  const [commands, errorPos, expected] = Script.match(code, 0);

  if (commands) {
    return [true, commands[0]];
  } else {
    ERROR_CONTEXT.lastIndex = errorPos;
    const [, before, after] = ERROR_CONTEXT.exec(code)!;
    return [
      false,
      `<pre>Error at position ${errorPos}
${escapeHtml(before + "" + after)}
${"-".repeat(before.length)}^

Expected: ${escapeHtml(expected)}</pre>`,
    ];
  }
}