mqt-core 3.3.2__cp314-cp314t-macosx_11_0_arm64.whl

mqt/core/include/mqt-core/qasm3/InstVisitor.hpp

@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "Statement_fwd.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+
+namespace qasm3 {
+
+class InstVisitor {
+public:
+  virtual void
+  visitGateStatement(std::shared_ptr<GateDeclaration> gateStatement) = 0;
+  virtual void visitVersionDeclaration(
+      std::shared_ptr<VersionDeclaration> versionDeclaration) = 0;
+  virtual void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> declarationStatement) = 0;
+  virtual void
+  visitInitialLayout(std::shared_ptr<InitialLayout> initialLayout) = 0;
+  virtual void visitOutputPermutation(
+      std::shared_ptr<OutputPermutation> outputPermutation) = 0;
+  virtual void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> gateCallStatement) = 0;
+  virtual void visitAssignmentStatement(
+      std::shared_ptr<AssignmentStatement> assignmentStatement) = 0;
+  virtual void
+  visitBarrierStatement(std::shared_ptr<BarrierStatement> barrierStatement) = 0;
+  virtual void
+  visitResetStatement(std::shared_ptr<ResetStatement> resetStatement) = 0;
+  virtual void visitIfStatement(std::shared_ptr<IfStatement> ifStatement) = 0;
+
+  virtual ~InstVisitor() = default;
+};
+
+class DefaultInstVisitor : public InstVisitor {
+public:
+  void visitGateStatement(
+      std::shared_ptr<GateDeclaration> /*gateStatement*/) override {}
+  void visitVersionDeclaration(
+      std::shared_ptr<VersionDeclaration> /*versionDeclaration*/) override {}
+  void visitDeclarationStatement(
+      std::shared_ptr<DeclarationStatement> /*declarationStatement*/) override {
+  }
+  void visitInitialLayout(
+      std::shared_ptr<InitialLayout> /*initialLayout*/) override {}
+  void visitOutputPermutation(
+      std::shared_ptr<OutputPermutation> /*outputPermutation*/) override {}
+  void visitGateCallStatement(
+      std::shared_ptr<GateCallStatement> /*gateCallStatement*/) override {}
+  void visitAssignmentStatement(
+      std::shared_ptr<AssignmentStatement> /*assignmentStatement*/) override {}
+  void visitBarrierStatement(
+      std::shared_ptr<BarrierStatement> /*barrierStatement*/) override {}
+  void visitResetStatement(
+      std::shared_ptr<ResetStatement> /*resetStatement*/) override {}
+  void visitIfStatement(std::shared_ptr<IfStatement> /*ifStatement*/) override {
+  }
+};
+
+template <typename T> class ExpressionVisitor {
+public:
+  virtual T
+  visitBinaryExpression(std::shared_ptr<BinaryExpression> binaryExpression) = 0;
+  virtual T
+  visitUnaryExpression(std::shared_ptr<UnaryExpression> unaryExpression) = 0;
+  virtual T visitConstantExpression(std::shared_ptr<Constant> constant) = 0;
+  virtual T visitIdentifierExpression(
+      std::shared_ptr<IdentifierExpression> identifierExpression) = 0;
+  virtual T
+  visitIdentifierList(std::shared_ptr<IdentifierList> identifierList) = 0;
+  virtual T visitIndexedIdentifier(
+      std::shared_ptr<IndexedIdentifier> indexedIdentifier) = 0;
+  virtual T visitMeasureExpression(
+      std::shared_ptr<MeasureExpression> measureExpression) = 0;
+
+  // A manually implemented visitor function with a templated return type.
+  // This is impossible as a virtual function in expression, which is why
+  // we define it manually.
+  T visit(const std::shared_ptr<Expression>& expression) {
+    if (expression == nullptr) {
+      throw std::runtime_error("Expression is null");
+    }
+    if (const auto binaryExpression =
+            std::dynamic_pointer_cast<BinaryExpression>(expression)) {
+      return visitBinaryExpression(binaryExpression);
+    }
+    if (const auto unaryExpression =
+            std::dynamic_pointer_cast<UnaryExpression>(expression)) {
+      return visitUnaryExpression(unaryExpression);
+    }
+    if (const auto constantInt =
+            std::dynamic_pointer_cast<Constant>(expression)) {
+      return visitConstantExpression(constantInt);
+    }
+    if (const auto identifierExpression =
+            std::dynamic_pointer_cast<IdentifierExpression>(expression)) {
+      return visitIdentifierExpression(identifierExpression);
+    }
+    if (const auto identifierList =
+            std::dynamic_pointer_cast<IdentifierList>(expression)) {
+      return visitIdentifierList(identifierList);
+    }
+    if (const auto indexedIdentifier =
+            std::dynamic_pointer_cast<IndexedIdentifier>(expression)) {
+      return visitIndexedIdentifier(indexedIdentifier);
+    }
+    if (const auto measureExpression =
+            std::dynamic_pointer_cast<MeasureExpression>(expression)) {
+      return visitMeasureExpression(measureExpression);
+    }
+    throw std::runtime_error("Unhandled expression type.");
+  }
+
+  virtual ~ExpressionVisitor() = default;
+};
+
+template <typename T> class Type;
+using ResolvedType = Type<uint64_t>;
+template <typename T> class DesignatedType;
+template <typename T> class UnsizedType;
+template <typename T> class ArrayType;
+
+template <typename T> class TypeVisitor {
+public:
+  virtual ~TypeVisitor() = default;
+
+  virtual std::shared_ptr<ResolvedType>
+  visitDesignatedType(DesignatedType<T>* designatedType) = 0;
+  virtual std::shared_ptr<ResolvedType>
+  visitUnsizedType(UnsizedType<T>* unsizedType) = 0;
+  virtual std::shared_ptr<ResolvedType>
+  visitArrayType(ArrayType<T>* arrayType) = 0;
+};
+} // namespace qasm3

mqt/core/include/mqt-core/qasm3/NestedEnvironment.hpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include <map>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace qasm3 {
+template <typename T> class NestedEnvironment {
+  std::vector<std::map<std::string, T>> env{};
+
+public:
+  NestedEnvironment() { env.emplace_back(); };
+
+  void push() { env.emplace_back(); }
+
+  void pop() { env.pop_back(); }
+
+  std::optional<T> find(std::string key) {
+    for (auto it = env.rbegin(); it != env.rend(); ++it) {
+      auto found = it->find(key);
+      if (found != it->end()) {
+        return found->second;
+      }
+    }
+    return std::nullopt;
+  }
+
+  void emplace(std::string key, T value) { env.back().emplace(key, value); }
+};
+} // namespace qasm3

mqt/core/include/mqt-core/qasm3/Parser.hpp

@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+/*
+ * This file is part of MQT QFR library which is released under the MIT license.
+ * See file README.md or go to https://www.cda.cit.tum.de/research/quantum/ for
+ * more information.
+ */
+
+#pragma once
+
+#include "Scanner.hpp"
+#include "Statement_fwd.hpp"
+#include "Token.hpp"
+#include "Types_fwd.hpp"
+
+#include <istream>
+#include <memory>
+#include <optional>
+#include <stack>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace qc {
+// forward declarations
+class Permutation;
+} // namespace qc
+
+namespace qasm3 {
+class Parser final {
+  struct ScannerState {
+  private:
+    std::unique_ptr<std::istream> is;
+
+  public:
+    Token last{0, 0};
+    Token t{0, 0};
+    Token next{0, 0};
+    std::unique_ptr<Scanner> scanner;
+    std::optional<std::string> filename;
+    bool isImplicitInclude;
+
+    bool scan() {
+      last = t;
+      t = next;
+      next = scanner->next();
+
+      return t.kind != Token::Kind::Eof;
+    }
+
+    explicit ScannerState(
+        std::istream* in,
+        std::optional<std::string> debugFilename = std::nullopt,
+        const bool implicitInclude = false)
+        : scanner(std::make_unique<Scanner>(in)),
+          filename(std::move(debugFilename)),
+          isImplicitInclude(implicitInclude) {
+      scan();
+    }
+
+    explicit ScannerState(
+        std::unique_ptr<std::istream> in,
+        std::optional<std::string> debugFilename = std::nullopt,
+        const bool implicitInclude = false)
+        : is(std::move(in)), scanner(std::make_unique<Scanner>(is.get())),
+          filename(std::move(debugFilename)),
+          isImplicitInclude(implicitInclude) {
+      scan();
+    }
+  };
+
+  std::stack<ScannerState> scanner;
+  std::shared_ptr<DebugInfo> includeDebugInfo{nullptr};
+
+  [[noreturn]] void error(const Token& token, const std::string& msg);
+
+  [[nodiscard]] Token last() const;
+
+  [[nodiscard]] Token current() const;
+
+  [[nodiscard]] Token peek() const;
+
+  Token expect(const Token::Kind& expected,
+               const std::optional<std::string>& context = std::nullopt);
+
+public:
+  explicit Parser(std::istream& is, bool implicitlyIncludeStdgates = true);
+
+  ~Parser() = default;
+
+  std::shared_ptr<VersionDeclaration> parseVersionDeclaration();
+
+  std::vector<std::shared_ptr<Statement>> parseProgram();
+
+  std::shared_ptr<Statement> parseStatement();
+
+  std::shared_ptr<QuantumStatement> parseQuantumStatement();
+
+  void parseInclude();
+
+  std::shared_ptr<AssignmentStatement> parseAssignmentStatement();
+
+  std::shared_ptr<AssignmentStatement> parseMeasureStatement();
+
+  std::shared_ptr<ResetStatement> parseResetStatement();
+
+  std::shared_ptr<BarrierStatement> parseBarrierStatement();
+
+  std::shared_ptr<Statement> parseDeclaration(bool isConst);
+
+  std::shared_ptr<GateDeclaration> parseGateDefinition();
+
+  std::shared_ptr<GateDeclaration> parseOpaqueGateDefinition();
+
+  std::shared_ptr<GateCallStatement> parseGateCallStatement();
+
+  std::shared_ptr<GateModifier> parseGateModifier();
+
+  std::shared_ptr<IndexOperator> parseIndexOperator();
+
+  std::shared_ptr<IndexedIdentifier> parseIndexedIdentifier();
+
+  std::shared_ptr<GateOperand> parseGateOperand();
+
+  std::shared_ptr<DeclarationExpression> parseDeclarationExpression();
+
+  std::shared_ptr<MeasureExpression> parseMeasureExpression();
+
+  std::shared_ptr<Expression> exponentiation();
+
+  std::shared_ptr<Expression> factor();
+
+  std::shared_ptr<Expression> term();
+
+  std::shared_ptr<Expression> comparison();
+
+  std::shared_ptr<Expression> parseExpression();
+
+  std::shared_ptr<IdentifierList> parseIdentifierList();
+
+  std::pair<std::shared_ptr<Type<std::shared_ptr<Expression>>>, bool>
+  parseType();
+
+  std::shared_ptr<Expression> parseTypeDesignator();
+
+  static qc::Permutation parsePermutation(std::string s);
+
+  void scan();
+
+  std::shared_ptr<DebugInfo> makeDebugInfo(Token const& begin,
+                                           Token const& /*end*/);
+
+  std::shared_ptr<DebugInfo> makeDebugInfo(Token const& token);
+
+  [[nodiscard]] bool isAtEnd() const {
+    return current().kind == Token::Kind::Eof;
+  }
+  std::shared_ptr<IfStatement> parseIfStatement();
+  std::vector<std::shared_ptr<Statement>> parseBlockOrStatement();
+};
+
+} // namespace qasm3

mqt/core/include/mqt-core/qasm3/Scanner.hpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2023 - 2025 Chair for Design Automation, TUM
+ * Copyright (c) 2025 Munich Quantum Software Company GmbH
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Licensed under the MIT License
+ */
+
+#pragma once
+
+#include "Token.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <iosfwd>
+#include <optional>
+#include <string>
+#include <unordered_map>
+
+namespace qasm3 {
+class Scanner {
+  std::istream* is;
+  std::unordered_map<std::string, Token::Kind> keywords;
+  char ch = 0;
+  size_t line = 1;
+  size_t col = 0;
+
+  [[nodiscard]] static bool isSpace(char c);
+
+  [[nodiscard]] static bool isFirstIdChar(char c);
+
+  [[nodiscard]] static bool isNum(char c);
+
+  [[nodiscard]] static bool isHex(char c);
+
+  [[nodiscard]] static bool hasTimingSuffix(char first, char second);
+
+  static char readUtf8Codepoint(std::istream* in);
+
+  void nextCh();
+
+  [[nodiscard]] char peek() const;
+
+  std::optional<Token> consumeWhitespaceAndComments();
+
+  static bool isValidDigit(uint8_t base, char c);
+
+  std::string consumeNumberLiteral(uint8_t base);
+
+  static uint64_t parseIntegerLiteral(const std::string& str, uint8_t base);
+
+  Token consumeNumberLiteral();
+
+  Token consumeHardwareQubit();
+
+  Token consumeString();
+
+  Token consumeName();
+
+  void error(const std::string& msg) const;
+
+  void expect(char expected);
+
+public:
+  explicit Scanner(std::istream* in);
+
+  ~Scanner() = default;
+
+  Token next();
+};
+} // namespace qasm3