qasm-ts 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qasm-ts",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "QASM, the low-level programming language for quantum circuit specification, implemented in TypeScript.",
   "main": "dist/main.js",
   "scripts": {

package/src/ast.ts

@@ -1,192 +0,0 @@
-
-/** Base class representing a basic AST node. */
-class AstNode {}
-
-/** Class representing a qubit register. */
-class QReg extends AstNode {
-    size:number;
-    id:string;
-    constructor(id:string, size:number) {
-       super();
-       this.id = id;
-       this.size = size;
-    } 
-}
-
-/** Class representing a classical register. */
-class CReg extends AstNode {
-    size:number;
-    id:string;
-    constructor(id:string, size:number) {
-        super();
-        this.id = id;
-        this.size = size;
-    } 
-}
-
-/** Class representing an identifier. */
-class Id extends AstNode {
-    id:string;
-    constructor(id:string) {
-        super();
-        this.id = id;
-    }
-}
-
-/** Class representing a barrier. */
-class Barrier extends AstNode {
-    index:number;
-    register:string;
-    constructor(register:string, index?:number) {
-        super();
-        this.index = index || null;
-        this.register = register;
-    }
-}
-
-/** Class representing a variable. */
-class Variable extends AstNode {
-    value:string;
-    constructor(value:string) {
-       super();
-       this.value= value|| null;
-    }
-}
-
-/** Class representing a measurement. */
-class Measure extends AstNode {
-    src_index:number;
-    src_register:string;
-    dest_index:number;
-    dest_register:string;
-    constructor(src_register:string, dest_register:string, src_index?:number,
-       dest_index?:number) {
-       super();
-       this.src_index = src_index != undefined ? src_index : null;
-       this.src_register = src_register;
-       this.dest_index = dest_index != undefined ? dest_index : null;
-       this.dest_register = dest_register;
-    } 
-}
-
-/** Class representing a gate application. */
-class ApplyGate extends AstNode {
-    name:string;
-    qubits:Array<[string, number?]>;
-    params:Array<AstNode>;
-    constructor(name:string, qubits:Array<[string, number?]>,
-        params:Array<AstNode>) {
-        super();
-        this.name = name;
-        this.qubits = qubits;
-        this.params = params;
-    } 
-}
-
-/** Class representing a gate. */
-class Gate extends AstNode {
-    name:string;
-    registers:Array<string>;
-    params:Array<string>;
-    nodes:Array<AstNode>;
-    constructor(name:string, registers:Array<string>, params:Array<string>, nodes:Array<AstNode>) {
-        super();
-        this.name = name;
-        this.registers = registers;
-        this.params = params;
-        this.nodes = nodes;
-    }
-}
-/** Class representing conditional. */
-class If extends AstNode {
-    register:string;
-    param:number;
-    gate:AstNode;
-    constructor(register:string, param:number, gate:AstNode) {
-        super();
-        this.register = register;
-        this.param = param;
-        this.gate = gate;
-    }
-}
-
-/** Class representing minus. */
-class Minus extends AstNode {}
-
-/** Class representing plus. */
-class Plus extends AstNode {}
-
-/** Class representing times. */
-class Times extends AstNode {}
-
-/** Class representing power. */
-class Power extends AstNode {}
-
-/** Class representing division. */
-class Divide extends AstNode {}
-
-/** Class representing pi. */
-class Pi extends AstNode {}
-
-/** Class representing the square root. */
-class Sqrt extends AstNode {}
-
-/** Class representing natural logarithm. */
-class Ln extends AstNode {}
-
-/** Class representing exponentiation. */
-class Exp extends AstNode {}
-
-/** Class representing tagnent. */
-class Tan extends AstNode {}
-
-/** Class representing cosine. */
-class Cos extends AstNode {}
-
-/** Class representing sine. */
-class Sin extends AstNode {}
-
-/** Class representing an integer. */
-class NNInteger extends AstNode {
-    value:number;
-    constructor(value:number) {
-       super();
-       this.value = value;
-    }
-}
-
-/** Class representing a real. */
-class Real extends AstNode {
-    value:number;
-    constructor(value:number) {
-       super();
-       this.value = value;
-    }
-}
-
-export {
-    AstNode,
-    QReg,
-    CReg,
-    Barrier,
-    Measure,
-    ApplyGate,
-    Gate,
-    If,
-    Id,
-    Divide,
-    Plus,
-    Minus,
-    Times,
-    Power,
-    Sin,
-    Cos,
-    Tan,
-    Exp,
-    Ln,
-    Sqrt,
-    Pi,
-    NNInteger,
-    Real,
-    Variable
-};

package/src/errors.ts

@@ -1,102 +0,0 @@
- /** Class representing a bad argument exception. */
- class BadArgumentError extends Error {
-    constructor(message?: string) {
-       super(message);
-       Object.setPrototypeOf(this, new.target.prototype);
-       this.name = BadArgumentError.name;
-    } 
-}
-
-/** Class representing a bad quantum register exception. */
-class BadQregError extends Error {
-    constructor(message?: string) {
-        super(message);
-        Object.setPrototypeOf(this, new.target.prototype);
-        this.name = BadQregError.name;
-    }
-}
-
-/** Class representing a bad equality exception. */
-class BadEqualsError extends Error {
-    constructor(message?: string) {
-       super(message);
-       Object.setPrototypeOf(this, new.target.prototype);
-       this.name = BadEqualsError.name;
-    } 
-}
-
-/** Class representing a bad classical register exception. */
-class BadCregError extends Error {
-    constructor(message?: string) {
-       super(message);
-       Object.setPrototypeOf(this, new.target.prototype);
-       this.name = BadCregError.name;
-    } 
-}
-
-/** Class representing a bad conditional exception. */
-class BadConditionalError extends Error {
-    constructor(message?: string) {
-       super(message);
-       Object.setPrototypeOf(this, new.target.prototype);
-       this.name = BadConditionalError.name;
-    }
-}
-
-/** Class representing a bad barrier exception. */
-class BadBarrierError extends Error {
-    constructor(message?: string) {
-       super(message);
-       Object.setPrototypeOf(this, new.target.prototype);
-       this.name = BadBarrierError.name;
-    } 
-}
-
-/** Class representing a bad measurement exception. */
-class BadMeasurementError extends Error {
-    constructor(message?: string) {
-       super(message);
-       Object.setPrototypeOf(this, new.target.prototype);
-       this.name = BadMeasurementError.name;
-    } 
-}
-
-/** Class representing a bad gate exception. */
-class BadGateError extends Error {
-    constructor(message?: string) {
-       super(message);
-       Object.setPrototypeOf(this, new.target.prototype);
-       this.name = BadGateError.name;
-    }
-}
-
-/** Class representing a bad parameter exception. */
-class BadParameterError extends Error {
-    constructor(message?: string) {
-       super(message);
-       Object.setPrototypeOf(this, new.target.prototype);
-       this.name = BadParameterError.name;
-    } 
-}
-
-/** Class representing a missing semicolon exception. */
-class MissingSemicolonError extends Error {
-    constructor(message?: string) {
-    super(message);
-    Object.setPrototypeOf(this, new.target.prototype);
-    this.name = MissingSemicolonError.name;
-    } 
-}
-
-export {
-    BadArgumentError,
-    BadCregError,
-    BadQregError,
-    BadConditionalError,
-    BadBarrierError,
-    BadMeasurementError,
-    BadGateError,
-    BadEqualsError,
-    BadParameterError,
-    MissingSemicolonError
-};

package/src/lexer.ts

@@ -1,319 +0,0 @@
-import { Token, lookup } from './token';
-import { BadEqualsError, MissingSemicolonError } from './errors';
-
-/**
- * Returns whether a given character could be an element of a numeric value.
- * @param c - The character.
- * @return Whether the character is numeric.
- */
-function isNumeric(c:string): boolean {
-    return (c == '.') || !isNaN(parseInt(c));
-}
-
-/**
- * Returns whether a given character is a letter.
- * @param c - The character.
- * @return Whether the character is a letter.
- */
-function isLetter(c:string): boolean {
-    if (c.match(/[a-z]/i)) {
-       return true;
-    }
-
-    return false;
-}
-
-/**
- * Returns whether a given character is alphanumeric.
- * @param c - The character.
- * @return Whether the character is alphanumeric.
- */
-function isAlpha(c:string): boolean {
-    if (c.match(/^[0-9a-zA-Z]+$/)) {
-       return true;
-    }
-    return false;
-}
-
-/**
- * Returns whether a given character is a newline character.
- * @param c - The character.
- * @return Whether the character is a newline.
- */
-function isNewline(c:string): boolean {
-    if (c.match(/\n|\r(?!\n)|\u2028|\u2029|\r\n/g)) {
-       return true;
-    }
-    return false;
-}
-
-/** Class representing a lexer. */
-class Lexer {
-    /** The string to lex. */
-    input:string;
-    /** The lexer's current cursor location. */
-    cursor:number;
-    /**
-     * Creates a lexer.
-     * @param input - The string to lex.
-     * @param cursor - The starting cursor position.
-     */
-    constructor(input:string, cursor:number = 0) {
-       this.input = input;
-       this.cursor = cursor;
-    }
-    verifyInput = (): boolean => {
-       const lines = this.input.split(/\n|\r(?!\n)|\u2028|\u2029|\r\n/g);
-       for(let i = 0; i < lines.length; i++) {
-           if (
-                !lines[i].startsWith('//')
-                && !(lines[i].length == 0)
-                && !(lines[i].includes('gate'))
-                && !(lines[i].trim() == '{' || lines[i].trim() == '}') 
-                && !lines[i].includes(';')
-            ){
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Calling this method lexes the code represented by the provided string.
-     * @return An array of tokens and their corresponding values.
-     */
-    lex = (): Array<[Token, (number | String)?]> => {
-        let tokens:Array<[Token, (number | String)?]> = [];
-        let token:[Token, (number | String)?];
-        if (!this.verifyInput()) {
-            throw MissingSemicolonError;
-        }
-        while (this.cursor < this.input.length) {
-            token = this.nextToken();
-            if (token) {
-                tokens.push(token);
-            }
-        }
-        return tokens;
-    }
-    
-    /**
-    * Reads a character and advances the cursor.
-    * @param num - Optional cursor position modifier.
-    */
-    readChar = (num:number=1): string => {
-        this.cursor += num;
-        return this.input[this.cursor - num];
-    }
-
-    /**
-     * Advances the cusor past the next comment.
-     */
-    skipComment = () => {
-        let char = '';
-        while(!isNewline(char)) {
-          char = this.readChar();
-        } 
-    }
-
-    /**
-     * Determines whether the next character to process equals a given character.
-     * @param c - The given character.
-     * @return Whether the next character equals the given character.
-     */
-    peekEq = (c:string): boolean => (this.peek() == c);
-
-    /**
-     * Reads a character without advancing the cursor.
-     * @param index - Optional peek position offset.
-     */
-    peek = (): string => this.input[this.cursor]
-        
-    /**
-     * Reads a numeric value.
-     * @return The numeric value as a string.
-     */
-    readNumeric = (): string => {
-        let num = '';
-        while (isNumeric(this.peek())) {
-            num += this.readChar();
-        }
-        return num; 
-    }
-
-    /**
-     * Reads an identifier.
-     * @return The identifier as a string.
-     */
-    readIdentifier = (): string => {
-        let id = '';
-        while (isAlpha(this.peek())) {
-            id += this.readChar();
-        }
-        return id; 
-    }
-
-    /**
-     * Reads a string literal.
-     * @param terminator - The literal's termination character.
-     * @return The literal as a string.
-     */
-    readStringLiteral = (terminator:string): string => {
-        let lit = '';
-        let char = '';
-        while (!(terminator == char)) {
-            char = this.readChar();
-            lit += char; 
-        }
-        return lit; 
-    }
-
-    /**
-     * Advances the cusor past the next block of whitespace.
-     */
-    skipWhitespace = (): null => {
-        while (' \t\n\r\v'.indexOf(this.peek()) > -1) {
-            this.cursor += 1;
-        }
-        return null;
-    }
-
-    /**
-     * Lexes the next token.
-     * @return The next token and its corresponding value.
-     */
-     nextToken = (): [Token, (number | String)?] => {
-        this.skipWhitespace();
-
-        if (this.cursor == this.input.length) {
-           return [Token.EndOfFile];
-        }
-
-        let char = this.peek();
-        this.readChar();
-
-        switch(char) {
-            case '=':
-               if (this.peekEq('=')) {
-                  this.readChar();
-                  return [Token.Equals];
-                } else {
-                  throw BadEqualsError;
-                } 
-            case '-':
-               if (this.peekEq('>')) {
-                  this.readChar();
-                  return [Token.Arrow];
-                } else {
-                  return [Token.Minus];
-                } 
-            case '+':
-               return [Token.Plus];
-            case '*':
-                return [Token.Times];
-            case '^':
-                return [Token.Power];
-            case ';':
-                return [Token.Semicolon];
-            case ',':
-                return [Token.Comma];
-            case '(':
-                return [Token.LParen];
-            case '[':
-                return [Token.LSParen];
-            case '{':
-                return [Token.LCParen];
-            case ')':
-                return [Token.RParen];
-            case ']':
-                return [Token.RSParen];
-            case '}':
-                return [Token.RCParen];
-            case '/':
-                if (this.peekEq('/')) {
-                    this.skipComment();
-                    return;
-                } else {
-                    return [Token.Divide];
-                } 
-            case 'g':
-                if ((this.input[this.cursor] == 'a')
-                    && (this.input[this.cursor + 1] == 't') 
-                    && (this.input[this.cursor + 2] == 'e') 
-                ){
-                        this.readChar(3);
-                        return [Token.Gate];
-                }
-                let literal = char + this.readIdentifier();
-                return [lookup(literal), new String(literal)];
-            case 'q':
-                if ((this.input[this.cursor] == 'r')
-                    && (this.input[this.cursor + 1] == 'e') 
-                    && (this.input[this.cursor + 2] == 'g') 
-                ){
-                    this.readChar(3);
-                    return [Token.QReg];
-                 }
-                 let qregLit = char + this.readIdentifier();
-                 return [lookup(qregLit), new String(qregLit)];
-            case 'c':
-                if ((this.input[this.cursor] == 'r')
-                    && (this.input[this.cursor + 1] == 'e') 
-                    && (this.input[this.cursor + 2] == 'g') 
-                ){
-                    this.readChar(3);
-                    return [Token.QReg];
-                 }
-                 let cregLit = char + this.readIdentifier();
-                 return [lookup(cregLit), new String(cregLit)];
-            case 'b':
-                if ((this.input[this.cursor] == 'a')
-                    && (this.input[this.cursor + 1] == 'r') 
-                    && (this.input[this.cursor + 2] == 'r') 
-                    && (this.input[this.cursor + 3] == 'i') 
-                    && (this.input[this.cursor + 4] == 'e') 
-                    && (this.input[this.cursor + 5] == 'r') 
-                ){
-                    this.readChar(6);
-                    return [Token.Barrier];
-                }
-                let barLit = char + this.readIdentifier();
-                return [lookup(barLit), new String(barLit)];
-            case 'm':
-                if ((this.input[this.cursor] == 'e')
-                    && (this.input[this.cursor + 1] == 'a') 
-                    && (this.input[this.cursor + 2] == 's') 
-                    && (this.input[this.cursor + 3] == 'u') 
-                    && (this.input[this.cursor + 4] == 'r') 
-                    && (this.input[this.cursor + 5] == 'e') 
-                ){
-                    this.readChar(6);
-                    return [Token.Measure];
-                }
-                let measureLit = char + this.readIdentifier();
-                return [lookup(measureLit), new String(measureLit)];
-            case '\"':
-                let stringLiteral = char + this.readStringLiteral('\"');
-                return [Token.String, new String(stringLiteral)];
-            case '\’':
-                let singleStringLiteral = char + this.readStringLiteral('\’');
-                return [Token.String, new String(singleStringLiteral)];
-            default:
-                if (isLetter(char)) {
-                    let literal = char + this.readIdentifier();
-                    return [lookup(literal), new String(literal)];
-                } else if (isNumeric(char)) {
-                    let num = char + this.readNumeric();
-                    if (num.indexOf('.') != -1) {
-                        return [Token.Real, parseFloat(num)];
-                    } else {
-                        return [Token.NNInteger, parseFloat(num)];
-                    }
-                } else {
-                    return [Token.Illegal];
-                } 
-        }
-    }
-}
-export default Lexer;
-     

package/src/main.ts

@@ -1,27 +0,0 @@
-import Parser from './parser';
-import Lexer from './lexer';
-import * as fs from 'fs';
-
-/**
- * Returns the abstract syntax tree for a given string of QASM code.
- * @param qasm - The code string.
- * @return The corresponding AST.
- */
- function parseString(qasm:string) {
-    const lexer = new Lexer(qasm, 0);
-    const tokens = lexer.lex();
-    const parser = new Parser(tokens);
-    const ast = parser.parse();
-    return ast; 
-}
-
-/**
- * Returns the abstract syntax tree for a given QASM file.
- * @param file - The file location.
- * @return The corresponding AST.
- */
-exports.parse = function(file:string) {
-    return parseString(fs.readFileSync(file, 'utf8'));
-}
-
-exports.parseString = parseString;

package/src/parser.ts

@@ -1,531 +0,0 @@
-import {
-    Token,
-    notParam
-} from './token';
-
-import {
-    BadArgumentError,
-    BadCregError,
-    BadQregError,
-    BadConditionalError,
-    BadBarrierError,
-    BadMeasurementError,
-    BadGateError,
-    BadParameterError
-} from './errors';
-
-import {
-    AstNode,
-    QReg,
-    CReg,
-    Barrier,
-    Measure,
-    Gate,
-    If,
-    ApplyGate,
-    Divide,
-    Power,
-    Times,
-    Plus,
-    Minus,
-    Sin,
-    Cos,
-    Tan,
-    Exp,
-    Ln,
-    Sqrt,
-    Pi,
-    NNInteger,
-    Real,
-    Variable
-} from './ast';
-
-/** Class representing a token parser. */
-class Parser {
-
-    /** The tokens to parse. */
-    tokens:Array<[Token, (number | String)?]>;
-
-    /** The allowed gates. */
-    gates:Array<string>;
-
-    /**
-     * Creates a parser.
-     * @param tokens - Tokens to parse.
-     */
-    constructor(tokens:Array<[Token, (number | String)?]>) {
-       this.tokens = tokens;
-       this.gates = [
-           'x',
-           'y',
-           'z',
-           'u1',
-           'u2',
-           'u3',
-           's',
-           'sdg',
-           'h',
-           'tdg',
-           'cx',
-           'cy',
-           'cz',
-           't',
-           'ccx',
-           'reset',
-           'cu1',
-           'ccy',
-           'ccz'
-       ]
-    }
-
-    /**
-     * Calling this method parses the code represented by the provided tokens.
-     * @return The abstract syntax tree.
-     */
-    parse(): Array<AstNode> {
-        let ast:Array<AstNode> = [];
-        let i = 0;
-        while (i < (this.tokens.length - 1)) {
-           let nodes = this.parseNode(this.tokens.slice(i));
-           ast = ast.concat(
-               nodes ? nodes : []
-            );
-            while (!(this.matchNext(this.tokens.slice(i), [Token.Semicolon]))) {
-                if (this.matchNext(this.tokens.slice(i), [Token.LCParen])) {
-                    while (!(this.matchNext(this.tokens.slice(i), [Token.RCParen]))) {
-                        i++; 
-                    }
-                    break; 
-                }
-                i++; 
-            }
-            i++; 
-        }
-        return ast; 
-    }
-
-    /**
-    * Delegates the parsing of the next set of tokens to the appropriate method.
-    * @param tokens - Remaining tokens to parse.
-    * @param allowVariables - Whether encountered identifiers should be consider
-        variable initializations or references.
-    * @return A set of AST nodes.
-    */
-    parseNode(tokens:Array<[Token, (number | String)?]>, allowVariables=false): Array<AstNode> {
-        const token = tokens[0];
-        switch(token[0]) {
-            case Token.QReg:
-                return [this.qreg(tokens.slice(1))];
-            case Token.CReg:
-                return [this.creg(tokens.slice(1))];
-            case Token.Barrier:
-                return [this.barrier(tokens.slice(1))];
-            case Token.Measure:
-                return [this.measure(tokens.slice(1))];
-            case Token.Id:
-                if (!(token[1].toString().indexOf('QASM') != -1) &&
-                    !(token[1].toString().indexOf('include') != -1)) {
-                    if (this.gates.includes(token[1].toString())) {
-                        return [this.application(tokens, token[1].toString())];
-                    } else if (allowVariables) {
-                        return [new Variable(token[1].toString())];
-                    } else {
-                        throw BadGateError;
-                    }
-                } else {
-                    return [];
-                }
-            case Token.Gate:
-                return [this.gate(tokens.slice(1))];
-            case Token.If:
-                return [this.conditional(tokens.slice(1))];
-            case Token.Power:
-                return [new Power()];
-            case Token.Divide:
-                return [new Divide()];
-            case Token.Times:
-                return [new Times()];
-            case Token.Plus:
-                return [new Plus()];
-            case Token.Minus:
-                return [new Minus()];
-            case Token.Pi:
-                return [new Pi()];
-            case Token.Sin:
-                return [new Sin()];
-            case Token.Cos:
-                return [new Cos()];
-            case Token.Exp:
-                return [new Exp()];
-            case Token.Ln:
-                return [new Ln()];
-            case Token.Sqrt:
-                return [new Sqrt()];
-            case Token.Tan:
-                return [new Tan()];
-            case Token.NNInteger:
-                return [new NNInteger(Number(token[1]))];
-            case Token.Real:
-                return [new Real(Number(token[1]))];
-        }
-    }
-
-    /**
-     * Checks if the next tokens match those expected.
-     * @param tokens - Remaining tokens to parse.
-     * @param expectedTokens - Expected tokens.
-     * @return Whether these is a match.
-     */
-    matchNext(tokens:Array<[Token, (number | String)?]>, expectedTokens:Array<Token>): boolean {
-        let matches = true;
-        let i = 0;
-        if (tokens.length == 0) {
-            return false;
-        }
-        while (i < expectedTokens.length) {
-            if (tokens[i][0] != expectedTokens[i]) {
-                matches = false;
-                break; 
-            }
-            i++; 
-        }
-        return matches;
-    }
-
-    /**
-     * Parses a quantum register.
-     * @param tokens - Remaining tokens to parse.
-     * @return An AST node representing the quantum register.
-     */
-    qreg(tokens:Array<[Token, (number | String)?]>): AstNode {
-        if (this.matchNext(tokens, [Token.Id, Token.LSParen, Token.NNInteger, Token.RSParen, Token.Semicolon])) {
-            const id = tokens[0][1];
-            const size = tokens[2][1];
-            return new QReg(id.toString(), Number(size));
-        } else {
-            throw BadQregError;
-        } 
-    }
-
-    /**
-     * Parses a classical register.
-     * @param tokens - Remaining tokens to parse.
-     * @return An AST node representing the classical register.
-     */
-    creg(tokens:Array<[Token, (number | String)?]>): AstNode {
-        if (this.matchNext(tokens, [Token.Id, Token.LSParen, Token.NNInteger,
-            Token.RSParen, Token.Semicolon])) {
-            const id = tokens[0][1];
-            const size = tokens[2][1];
-            return new CReg(id.toString(), Number(size));
-        } else {
-            throw BadCregError;
-        } 
-    }
-
-    /**
-     * Parses a conditional.
-     * @param tokens - Remaining tokens to parse.
-     * @return An AST node representing the conditional.
-     */
-    conditional(tokens:Array<[Token, (number | String)?]>): AstNode {
-        if (this.matchNext(tokens, [Token.LParen, Token.Id, Token.Equals, Token.NNInteger, Token.RParen])) {
-            let id = tokens[1][1];
-            let val = tokens[3][1];
-            let node = this.parseNode(tokens.slice(5));
-            return new If(id.toString(), Number(val), node);
-        } else {
-            throw BadConditionalError;
-        } 
-    }
-
-    /**
-     * Parses a barrier.
-     * @param tokens - Remaining tokens to parse.
-     * @return An AST node representing the barrier.
-     */
-    barrier(tokens:Array<[Token, (number | String)?]>): AstNode {
-        if (this.matchNext(tokens, [Token.Id, Token.Semicolon])) {
-            let id = tokens[0][1];
-            return new Barrier(id.toString());
-        } else if (this.matchNext(tokens, [Token.Id, Token.LParen,
-            Token.NNInteger, Token.RParen, Token.Semicolon])) {
-                let id = tokens[0][1];
-                let index = tokens[2][1];
-                return new Barrier(id.toString(), Number(index));
-             } else {
-                throw BadBarrierError;
-        } 
-    }
-         
-    /**
-     * Parses a measurement.
-     * @param tokens - Remaining tokens to parse.
-     * @return An AST node representing the measurement.
-     */
-    measure(tokens:Array<[Token, (number | String)?]>): AstNode {
-        let first_id:string;
-        let second_id:string;
-        let first_index:number;
-        let second_index:number;
-        if (this.matchNext(tokens, [Token.Id, Token.Arrow])) {
-            first_id = tokens[0][1].toString();
-            tokens = tokens.slice(2);
-        } else if (this.matchNext(tokens, [Token.Id, Token.LSParen, Token.NNInteger, Token.RSParen, Token.Arrow])) {
-            first_id = tokens[0][1].toString();
-            first_index = Number(tokens[2][1]);
-            tokens = tokens.slice(5);
-        } else {
-            throw BadMeasurementError;
-        }
-        if (this.matchNext(tokens, [Token.Id, Token.Semicolon])) {
-            second_id = tokens[0][1].toString();
-            tokens = tokens.slice(2);
-        } else if (this.matchNext(tokens, [Token.Id, Token.LSParen, Token.NNInteger, Token.RSParen, Token.Semicolon])) {
-            second_id = tokens[0][1].toString();
-            second_index = Number(tokens[2][1]);
-            tokens = tokens.slice(5);
-         } else {
-            throw BadMeasurementError;
-         }
-         if (first_index != undefined && second_index != undefined) {
-            return new Measure(first_id, second_id, first_index, second_index);
-         } else if (first_index != undefined) {
-            return new Measure(first_id, second_id, first_index=first_index);
-         } else if (second_index != undefined) {
-            return new Measure(first_id, second_id, second_index=second_index);
-        }
-        return new Measure(first_id, second_id);
-    }
-
-    /**
-     * Parses an application of one of the allowed gates.
-     * @param tokens - Remaining tokens to parse.
-     * @return An AST node representing the gate application.
-     */
-    application(tokens:Array<[Token, (number | String)?]>, op:string): Array<AstNode> {
-        let params:Array<AstNode> = [];
-        let list:Array<[string, number?]> = [];
-        let applications:Array<AstNode> = [];
-        let id:string;
-        if (tokens[0][1] == op) {
-            tokens = tokens.slice(1);
-        }
-        if (this.matchNext(tokens, [Token.LParen])) {
-            if (this.matchNext(tokens.slice(1), [Token.RParen])) {
-                params = [];
-                tokens = tokens.slice(2);
-            } else {
-                params = this.matchParamList(tokens.slice(1));
-                let count = 0;
-                let commas = 0;
-                for (let i in params) {
-                    commas += 1;
-                    for (let j in params[i]) {
-                        count++; 
-                    }
-                }
-
-                tokens = tokens.slice(count + (commas - 1) + 2);
-            }
-        }
-        let args = this.matchArgList(tokens);
-        for (let arg in args) {
-            id = args[arg][0];
-            list.push(args[arg]);
-        }
-        applications.push(new ApplyGate(op, list, params));
-        return applications;
-    }
-
-    /**
-     * Parses a subroutine used in a custom gate definition.
-     * @param tokens - Expression tokens to parse.
-     * @return A parsed subroutine.
-     */
-    sub(tokens:Array<[Token, (number | String)?]>): Array<AstNode> {
-        let ast:Array<AstNode> = [];
-        let i = 0;
-        if (this.matchNext(tokens.slice(i), [Token.LCParen])) {
-            tokens = tokens.slice(1);
-        }
-        while ((i < (tokens.length - 1)) && (tokens[i][0] != Token.RCParen)) {
-            let nodes = this.parseNode(tokens.slice(i));
-            ast = ast.concat(
-                nodes ? nodes : []
-                );
-            while ((!this.matchNext(tokens.slice(i), [Token.Semicolon])) &&
-                (!this.matchNext(tokens.slice(i), [Token.RCParen]))) {
-                i++;
-            }
-            if (this.matchNext(tokens.slice(i), [Token.RCParen])) {
-                break; 
-            }
-            i++; 
-        }
-        return ast; 
-    }
- 
-    /**
-     * Parses a parameter value.
-     * @param tokens - Tokens to parse.
-     * @return An AST node representing the parameter value.
-     */
-    matchParam(tokens:Array<[Token, (number | String)?]>): AstNode {
-        let param:AstNode;
-        if (!(notParam(tokens[0][0]))) {
-            param = this.parseNode([tokens[0]], true);
-        } else {
-            throw BadParameterError;
-        }
-        return param;
-    }
-
-    /**
-     * Parses a list of parameter values.
-     * @param tokens - Tokens to parse.
-     * @return An array of AST nodes representing the parameter values.
-     */
-    matchParamList(tokens:Array<[Token, (number | String)?]>): Array<Array<AstNode>> {
-        let args:Array<Array<AstNode>> = [];
-        let i:number = 0;
-        let j:number = 0;
-        args[0] = [];
-        while(!this.matchNext(tokens.slice(j), [Token.RParen])) {
-            while(!this.matchNext(tokens.slice(j), [Token.Comma]) &&
-               !this.matchNext(tokens.slice(j), [Token.RParen])) {
-               if (notParam(tokens[j][0])) {
-                  throw BadParameterError;
-               }
-               let next = this.matchParam(tokens.slice(j));
-               args[i].push(next);
-               j++;
-            }
-           if (this.matchNext(tokens.slice(j), [Token.RParen])) {
-                break; 
-            }
-            i++;
-            j++;
-            args[i] = [];
-        }
-        return args;
-    }
-
-    /**
-     * Parses an argument value.
-     * @param tokens - Tokens to parse.
-     * @return An AST node representing the argument value.
-     */
-    matchArg(tokens:Array<[Token, (number | String)?]>): number {
-        let index:number;
-        if (this.matchNext(tokens, [Token.LSParen])) {
-            tokens = tokens.slice(1);
-            if (this.matchNext(tokens, [Token.NNInteger])) {
-                index = Number(tokens[0][1]);
-                tokens = tokens.slice(1);
-            } else {
-                throw BadArgumentError;
-            }
-            if (this.matchNext(tokens, [Token.RSParen])) {
-                return index;
-            } else {
-                throw BadArgumentError;
-            } 
-        }
-    }
-
-    /**
-     * Parses a list of argument values.
-     * @param tokens - Tokens to parse.
-     * @return An array of AST nodes representing the argument values.
-     */
-    matchArgList(tokens:Array<[Token, (number | String)?]>): Array<[string,number?]> {
-        let args:Array<[string, number?]> = [];
-        let next:[string, number?];
-        let id:string;
-        let j:number = 0;
-        while(j < tokens.length && !this.matchNext(tokens.slice(j),[Token.Semicolon])) {
-            if (this.matchNext(tokens.slice(j), [Token.Id])) {
-                id = tokens[j][1].toString();
-                let index = this.matchArg(tokens.slice(j + 1));
-                next = [id, index];
-                args.push(next);
-                if (index != undefined) {
-                    j += 4;
-                } else { 
-                    j++;
-                }
-                if (this.matchNext(tokens.slice(j), [Token.Comma])) {
-                    j++; 
-                }
-            } else {
-                throw BadArgumentError;
-            }
-        }
-        return args;
-    }
-
-    /**
-     * Parses a list of identifiers.
-     * @param tokens - Tokens to parse.
-     * @return An array of AST nodes representing the identifiers.
-     */
-    matchIdList(tokens:Array<[Token, (number | String)?]>): Array<string> {
-        let args:Array<string> = [];
-        let head:string;
-        if (this.matchNext(tokens, [Token.Id])) {
-            head = tokens[0][1].toString();
-        }
-        tokens = tokens.slice(1);
-        args.push(head);
-        if (this.matchNext(tokens, [Token.Comma])) {
-           tokens = tokens.slice(1);
-           let sub = this.matchIdList(tokens);
-           args = args.concat(sub);
-        }
-        return args;
-    }
-
-    /**
-     * Parses a gate.
-     * @param tokens - Remaining tokens to parse.
-     * @return An AST node representing the gate.
-     */
-    gate(tokens:Array<[Token, (number | String)?]>): AstNode {
-        let name:string;
-        let params:Array<string>;
-        let registers:Array<string>;
-        let applications:Array<AstNode>;
-        if (this.matchNext(tokens, [Token.Id])) {
-            name = tokens[0][1].toString();
-        } else {
-            throw BadGateError;
-        }
-        tokens = tokens.slice(1);
-        if (this.matchNext(tokens, [Token.LParen])) {
-           tokens = tokens.slice(1);
-           if (this.matchNext(tokens, [Token.RParen])) {
-                params = [];
-                tokens = tokens.slice(1);
-           } else {
-                params = this.matchIdList(tokens);
-                let count = 0;
-                for (let i in params) {
-                    count++; 
-                }
-                tokens = tokens.slice(count + 1);
-           }
-        }
-        registers = this.matchIdList(tokens);
-        let count = 0;
-        for (let i in registers) {
-            count++; 
-        }
-        tokens = tokens.slice(count + (count - 1));
-        applications = this.sub(tokens);
-        this.gates.push(name);
-        return new Gate(name, registers, params, applications);
-    }
-}
-
-export default Parser;

package/src/token.ts

@@ -1,92 +0,0 @@
-enum Token {
-    Illegal,
-    EndOfFile,
-    Real,
-    NNInteger,
-    Id,
-    OpenQASM,
-    Semicolon,
-    Comma,
-    LParen,
-    LSParen,
-    LCParen,
-    RParen,
-    RSParen,
-    RCParen,
-    Arrow,
-    Equals,
-    Plus,
-    Minus,
-    Times,
-    Divide,
-    Power,
-    Sin,
-    Cos,
-    Tan,
-    Exp,
-    Ln,
-    Sqrt,
-    Pi,
-    QReg,
-    CReg,
-    Barrier,
-    Gate,
-    Measure,
-    Reset,
-    Include,
-    If,
-    String
-}
-
-const lookupMap:object = {
-    'if': Token.If,
-    'sin': Token.Sin,
-    'cos': Token.Cos,
-    'tan': Token.Tan,
-    'exp': Token.Exp,
-    'ln': Token.Ln,
-    'sqrt': Token.Sqrt,
-    'pi': Token.Pi,
-    '+': Token.Plus,
-    '-': Token.Minus,
-    '/': Token.Divide,
-    '*': Token.Times,
-    '^': Token.Power
-}
-
-/**
- * Returns the token that represents a given string.
- * @param ident - The string.
- * @return The corresponding token.
- */
-function lookup(ident: string): Token {
-    return ident in lookupMap ? lookupMap[ident]: Token.Id;
-}
-
-/**
- * Returns the string representation of a token.
- * @param tokens - The token.
- * @return The string representation of the token.
- */
-function inverseLookup(token:Token): string {
-    return Object.keys(lookupMap).find((ident) => lookupMap[ident] == token);
-}
-
-/**
- * Determines whether a token denotes a parameter.
- * @param tokens - The token.
- * @return Whether the token does NOT denote a parameter.
- */
-function notParam(token:Token): boolean {
-    if (token == Token.NNInteger || token == Token.Real || token == Token.Id || this.inverseLookup(token)) {
-        return false;
-    }
-    return true;
-}
-
-export {
-     Token,
-     notParam,
-     lookup,
-     inverseLookup
- };