Initial sketch of a Parser class

pgonzal · pgonzal · commit b37f452a3ad7 · 2018-06-21T19:11:05.000-07:00
diff --git a/libraries/rushell/src/Parser.ts b/libraries/rushell/src/Parser.ts
@@ -0,0 +1,133 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+
+import { ParseError } from './ParseError';
+import { Tokenizer, Token, TokenKind } from './Tokenizer';
+import {
+  AstNode,
+  AstScript,
+  AstCommand,
+  AstCompoundWord,
+  AstText
+} from './AstNode';
+
+// tslint:disable:no-constant-condition
+
+export class Parser {
+  private readonly _tokenizer: Tokenizer;
+  private _peekedToken: Token | undefined;
+
+  public constructor(tokenizer: Tokenizer) {
+    this._tokenizer = tokenizer;
+    this._peekedToken = undefined;
+  }
+
+  public parse(): AstScript {
+    const script: AstScript = new AstScript();
+
+    const startingToken: Token = this._peekToken();
+
+    const astCommand: AstCommand | undefined = this._parseCommand();
+
+    if (!astCommand) {
+      throw new ParseError('Expecting a command', startingToken.range);
+    }
+
+    const nextToken: Token = this._peekToken();
+
+    if (nextToken.kind !== TokenKind.EndOfInput) {
+      throw new ParseError(`Unexpected token: ${TokenKind[nextToken.kind]}`, nextToken.range);
+    }
+
+    script.body = astCommand;
+
+    return script;
+  }
+
+  private _parseCommand(): AstCommand | undefined {
+    this._skipWhitespace();
+
+    const startingToken: Token = this._peekToken();
+
+    const command: AstCommand = new AstCommand();
+    command.commandPath = this._parseCompoundWord();
+    if (!command.commandPath) {
+      throw new ParseError('Expecting a command path', startingToken.range);
+    }
+
+    while (this._skipWhitespace()) {
+      const compoundWord: AstCompoundWord | undefined = this._parseCompoundWord();
+      if (!compoundWord) {
+        break;
+      }
+      command.arguments.push(compoundWord);
+    }
+
+    return command;
+  }
+
+  private _parseCompoundWord(): AstCompoundWord | undefined {
+    const compoundWord: AstCompoundWord = new AstCompoundWord();
+
+    while (true) {
+      const node: AstNode | undefined = this._parseText();
+      if (!node) {
+        break;
+      }
+      compoundWord.parts.push(node);
+    }
+
+    if (compoundWord.parts.length === 0) {
+      // We didn't parse a word
+      return undefined;
+    }
+
+    return compoundWord;
+  }
+
+  private _parseText(): AstText | undefined {
+    const token: Token = this._peekToken();
+
+    if (token.kind === TokenKind.Text) {
+      this._getToken();
+
+      const astText: AstText = new AstText();
+      astText.token = token;
+      return astText;
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Skips any whitespace tokens.  Returns true if any whitespace was actually encountered.
+   */
+  private _skipWhitespace(): boolean {
+    let sawWhitespace: boolean = false;
+    while (this._peekToken().kind === TokenKind.Spaces) {
+      this._getToken();
+      sawWhitespace = true;
+    }
+    if (this._peekToken().kind === TokenKind.EndOfInput) {
+      sawWhitespace = true;
+    }
+    return sawWhitespace;
+  }
+
+  private _getToken(): Token {
+    let token: Token;
+    if (this._peekedToken) {
+      token = this._peekedToken;
+      this._peekedToken = undefined;
+      return token;
+    }
+    return this._tokenizer.getToken();
+  }
+
+  private _peekToken(): Token {
+    if (!this._peekedToken) {
+      this._peekedToken = this._tokenizer.getToken();
+    }
+    return this._peekedToken;
+  }
+}
diff --git a/libraries/rushell/src/Tokenizer.ts b/libraries/rushell/src/Tokenizer.ts
@@ -7,10 +7,13 @@ import { ParseError } from './ParseError';
 export enum TokenKind {
   // One or more spaces/tabs
   Spaces,
+
   // A single newline sequence such as CRLF or LF
   NewLine,
+
   // An unrecognized character
   OtherCharacter,
+
   // A sequence of characters that doesn't contain any symbols with special meaning
   // Characters can be escaped, in which case the Token.text may differ from the
   // Token.range.toString()
