libqasm
library for handling cQASM files
cqasm-v1-semantic-gen.hpp
Go to the documentation of this file.
1 
5 #pragma once
6 
7 #include <iostream>
8 #include "cqasm-tree.hpp"
10 #include "cqasm-v1-values.hpp"
11 #include "cqasm-v1-error-model.hpp"
12 #include "cqasm-v1-instruction.hpp"
13 
14 namespace cqasm {
15 namespace v1 {
16 
148 namespace semantic {
149 
150 // Base classes used to construct the tree.
152 template <class T> using Maybe = cqasm::tree::Maybe<T>;
153 template <class T> using One = cqasm::tree::One<T>;
154 template <class T> using Any = cqasm::tree::Any<T>;
155 template <class T> using Many = cqasm::tree::Many<T>;
156 template <class T> using OptLink = cqasm::tree::OptLink<T>;
157 template <class T> using Link = cqasm::tree::Link<T>;
158 
159 // Forward declarations for all classes.
160 class Node;
161 class Annotated;
162 class AnnotationData;
163 class Block;
164 class BreakStatement;
165 class Bundle;
166 class BundleExt;
167 class ContinueStatement;
168 class ErrorModel;
169 class ForLoop;
170 class ForeachLoop;
171 class GotoInstruction;
172 class IfElse;
173 class IfElseBranch;
174 class Instruction;
175 class InstructionBase;
176 class Mapping;
177 class Program;
178 class RepeatUntilLoop;
179 class SetInstruction;
180 class Statement;
181 class Structured;
182 class Subcircuit;
183 class Variable;
184 class Version;
185 class WhileLoop;
186 class VisitorBase;
187 template <typename T = void>
188 class Visitor;
189 class RecursiveVisitor;
190 class Dumper;
191 
195 enum class NodeType {
197  Block,
199  Bundle,
200  BundleExt,
202  ErrorModel,
203  ForLoop,
204  ForeachLoop,
206  IfElse,
207  IfElseBranch,
208  Instruction,
209  Mapping,
210  Program,
213  Subcircuit,
214  Variable,
215  Version,
216  WhileLoop
217 };
218 
222 class Node : public Base {
223 public:
224 
228  virtual NodeType type() const = 0;
229 
233  virtual One<Node> copy() const = 0;
234 
238  virtual One<Node> clone() const = 0;
239 
243  virtual bool equals(const Node& rhs) const = 0;
244 
248  virtual bool operator==(const Node& rhs) const = 0;
249 
253  inline bool operator!=(const Node& rhs) const {
254  return !(*this == rhs);
255  }
256 
257 protected:
258 
262  virtual void visit_internal(VisitorBase &visitor, void *retval=nullptr) = 0;
263 
264 public:
265 
269  template <typename T>
270  T visit(Visitor<T> &visitor);
271 
275  void dump(std::ostream &out=std::cout, int indent=0);
276 
281  void dump_seq(std::ostream &out=std::cout, int indent=0);
282 
287  virtual Annotated *as_annotated();
288 
293  virtual const Annotated *as_annotated() const;
294 
299  virtual AnnotationData *as_annotation_data();
300 
305  virtual const AnnotationData *as_annotation_data() const;
306 
311  virtual Block *as_block();
312 
317  virtual const Block *as_block() const;
318 
323  virtual BreakStatement *as_break_statement();
324 
329  virtual const BreakStatement *as_break_statement() const;
330 
335  virtual Bundle *as_bundle();
336 
341  virtual const Bundle *as_bundle() const;
342 
347  virtual BundleExt *as_bundle_ext();
348 
353  virtual const BundleExt *as_bundle_ext() const;
354 
359  virtual ContinueStatement *as_continue_statement();
360 
365  virtual const ContinueStatement *as_continue_statement() const;
366 
371  virtual ErrorModel *as_error_model();
372 
377  virtual const ErrorModel *as_error_model() const;
378 
383  virtual ForLoop *as_for_loop();
384 
389  virtual const ForLoop *as_for_loop() const;
390 
395  virtual ForeachLoop *as_foreach_loop();
396 
401  virtual const ForeachLoop *as_foreach_loop() const;
402 
407  virtual GotoInstruction *as_goto_instruction();
408 
413  virtual const GotoInstruction *as_goto_instruction() const;
414 
419  virtual IfElse *as_if_else();
420 
425  virtual const IfElse *as_if_else() const;
426 
431  virtual IfElseBranch *as_if_else_branch();
432 
437  virtual const IfElseBranch *as_if_else_branch() const;
438 
443  virtual Instruction *as_instruction();
444 
449  virtual const Instruction *as_instruction() const;
450 
455  virtual InstructionBase *as_instruction_base();
456 
461  virtual const InstructionBase *as_instruction_base() const;
462 
467  virtual Mapping *as_mapping();
468 
473  virtual const Mapping *as_mapping() const;
474 
479  virtual Program *as_program();
480 
485  virtual const Program *as_program() const;
486 
491  virtual RepeatUntilLoop *as_repeat_until_loop();
492 
497  virtual const RepeatUntilLoop *as_repeat_until_loop() const;
498 
503  virtual SetInstruction *as_set_instruction();
504 
509  virtual const SetInstruction *as_set_instruction() const;
510 
515  virtual Statement *as_statement();
516 
521  virtual const Statement *as_statement() const;
522 
527  virtual Structured *as_structured();
528 
533  virtual const Structured *as_structured() const;
534 
539  virtual Subcircuit *as_subcircuit();
540 
545  virtual const Subcircuit *as_subcircuit() const;
546 
551  virtual Variable *as_variable();
552 
557  virtual const Variable *as_variable() const;
558 
563  virtual Version *as_version();
564 
569  virtual const Version *as_version() const;
570 
575  virtual WhileLoop *as_while_loop();
576 
581  virtual const WhileLoop *as_while_loop() const;
582 
586  virtual void serialize(
587  ::tree::cbor::MapWriter &map,
588  const ::tree::base::PointerMap &ids
589  ) const = 0;
590 
594  static std::shared_ptr<Node> deserialize(
595  const ::tree::cbor::MapReader &map,
596  ::tree::base::IdentifierMap &ids
597  );
598 
599 };
600 
604 class Annotated : public Node {
605 public:
606 
611 
615  Annotated(const Any<AnnotationData> &annotations = Any<AnnotationData>());
616 
621  Annotated *as_annotated() override;
622 
627  const Annotated *as_annotated() const override;
628 
632  static std::shared_ptr<Annotated> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
633 
634 };
635 
639 class AnnotationData : public Node {
640 public:
641 
647 
654 
659 
663  AnnotationData(const cqasm::v1::primitives::Str &interface = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Str>(), const cqasm::v1::primitives::Str &operation = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Str>(), const Any<cqasm::v1::values::Node> &operands = cqasm::v1::primitives::initialize<Any<cqasm::v1::values::Node>>());
664 
668  void find_reachable(::tree::base::PointerMap &map) const override;
669 
673  void check_complete(const ::tree::base::PointerMap &map) const override;
674 
678  NodeType type() const override;
679 
680 protected:
681 
685  void visit_internal(VisitorBase &visitor, void *retval) override;
686 
687 public:
688 
693  AnnotationData *as_annotation_data() override;
694 
699  const AnnotationData *as_annotation_data() const override;
700 
704  One<Node> copy() const override;
705 
709  One<Node> clone() const override;
710 
714  bool equals(const Node &rhs) const override;
715 
719  bool operator==(const Node &rhs) const override;
720 
724  void serialize(
725  ::tree::cbor::MapWriter &map,
726  const ::tree::base::PointerMap &ids
727  ) const override;
728 
732  static std::shared_ptr<AnnotationData> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
733 
734 };
735 
739 class Block : public Node {
740 public:
741 
746 
750  Block(const Any<Statement> &statements = Any<Statement>());
751 
755  void find_reachable(::tree::base::PointerMap &map) const override;
756 
760  void check_complete(const ::tree::base::PointerMap &map) const override;
761 
765  NodeType type() const override;
766 
767 protected:
768 
772  void visit_internal(VisitorBase &visitor, void *retval) override;
773 
774 public:
775 
780  Block *as_block() override;
781 
786  const Block *as_block() const override;
787 
791  One<Node> copy() const override;
792 
796  One<Node> clone() const override;
797 
801  bool equals(const Node &rhs) const override;
802 
806  bool operator==(const Node &rhs) const override;
807 
811  void serialize(
812  ::tree::cbor::MapWriter &map,
813  const ::tree::base::PointerMap &ids
814  ) const override;
815 
819  static std::shared_ptr<Block> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
820 
821 };
822 
826 class Statement : public Annotated {
827 public:
828 
832  Statement(const Any<AnnotationData> &annotations = Any<AnnotationData>());
833 
838  Statement *as_statement() override;
839 
844  const Statement *as_statement() const override;
845 
849  static std::shared_ptr<Statement> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
850 
851 };
852 
856 class Structured : public Statement {
857 public:
858 
862  Structured(const Any<AnnotationData> &annotations = Any<AnnotationData>());
863 
868  Structured *as_structured() override;
869 
874  const Structured *as_structured() const override;
875 
879  static std::shared_ptr<Structured> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
880 
881 };
882 
886 class BreakStatement : public Structured {
887 public:
888 
893 
897  void find_reachable(::tree::base::PointerMap &map) const override;
898 
902  void check_complete(const ::tree::base::PointerMap &map) const override;
903 
907  NodeType type() const override;
908 
909 protected:
910 
914  void visit_internal(VisitorBase &visitor, void *retval) override;
915 
916 public:
917 
922  BreakStatement *as_break_statement() override;
923 
928  const BreakStatement *as_break_statement() const override;
929 
933  One<Node> copy() const override;
934 
938  One<Node> clone() const override;
939 
943  bool equals(const Node &rhs) const override;
944 
948  bool operator==(const Node &rhs) const override;
949 
953  void serialize(
954  ::tree::cbor::MapWriter &map,
955  const ::tree::base::PointerMap &ids
956  ) const override;
957 
961  static std::shared_ptr<BreakStatement> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
962 
963 };
964 
969 class Bundle : public Annotated {
970 public:
971 
976 
980  Bundle(const Many<Instruction> &items = Many<Instruction>(), const Any<AnnotationData> &annotations = Any<AnnotationData>());
981 
985  void find_reachable(::tree::base::PointerMap &map) const override;
986 
990  void check_complete(const ::tree::base::PointerMap &map) const override;
991 
995  NodeType type() const override;
996 
997 protected:
998 
1002  void visit_internal(VisitorBase &visitor, void *retval) override;
1003 
1004 public:
1005 
1010  Bundle *as_bundle() override;
1011 
1016  const Bundle *as_bundle() const override;
1017 
1021  One<Node> copy() const override;
1022 
1026  One<Node> clone() const override;
1027 
1031  bool equals(const Node &rhs) const override;
1032 
1036  bool operator==(const Node &rhs) const override;
1037 
1041  void serialize(
1042  ::tree::cbor::MapWriter &map,
1043  const ::tree::base::PointerMap &ids
1044  ) const override;
1045 
1049  static std::shared_ptr<Bundle> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1050 
1051 };
1052 
1057 class BundleExt : public Statement {
1058 public:
1059 
1064 
1069 
1073  void find_reachable(::tree::base::PointerMap &map) const override;
1074 
1078  void check_complete(const ::tree::base::PointerMap &map) const override;
1079 
1083  NodeType type() const override;
1084 
1085 protected:
1086 
1090  void visit_internal(VisitorBase &visitor, void *retval) override;
1091 
1092 public:
1093 
1098  BundleExt *as_bundle_ext() override;
1099 
1104  const BundleExt *as_bundle_ext() const override;
1105 
1109  One<Node> copy() const override;
1110 
1114  One<Node> clone() const override;
1115 
1119  bool equals(const Node &rhs) const override;
1120 
1124  bool operator==(const Node &rhs) const override;
1125 
1129  void serialize(
1130  ::tree::cbor::MapWriter &map,
1131  const ::tree::base::PointerMap &ids
1132  ) const override;
1133 
1137  static std::shared_ptr<BundleExt> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1138 
1139 };
1140 
1145 public:
1146 
1151 
1155  void find_reachable(::tree::base::PointerMap &map) const override;
1156 
1160  void check_complete(const ::tree::base::PointerMap &map) const override;
1161 
1165  NodeType type() const override;
1166 
1167 protected:
1168 
1172  void visit_internal(VisitorBase &visitor, void *retval) override;
1173 
1174 public:
1175 
1180  ContinueStatement *as_continue_statement() override;
1181 
1186  const ContinueStatement *as_continue_statement() const override;
1187 
1191  One<Node> copy() const override;
1192 
1196  One<Node> clone() const override;
1197 
1201  bool equals(const Node &rhs) const override;
1202 
1206  bool operator==(const Node &rhs) const override;
1207 
1211  void serialize(
1212  ::tree::cbor::MapWriter &map,
1213  const ::tree::base::PointerMap &ids
1214  ) const override;
1215 
1219  static std::shared_ptr<ContinueStatement> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1220 
1221 };
1222 
1226 class ErrorModel : public Annotated {
1227 public:
1228 
1233 
1238 
1243 
1247  ErrorModel(const cqasm::v1::error_model::ErrorModelRef &model = cqasm::v1::primitives::initialize<cqasm::v1::error_model::ErrorModelRef>(), const cqasm::v1::primitives::Str &name = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Str>(), const Any<cqasm::v1::values::Node> &parameters = cqasm::v1::primitives::initialize<Any<cqasm::v1::values::Node>>(), const Any<AnnotationData> &annotations = Any<AnnotationData>());
1248 
1252  void find_reachable(::tree::base::PointerMap &map) const override;
1253 
1257  void check_complete(const ::tree::base::PointerMap &map) const override;
1258 
1262  NodeType type() const override;
1263 
1264 protected:
1265 
1269  void visit_internal(VisitorBase &visitor, void *retval) override;
1270 
1271 public:
1272 
1277  ErrorModel *as_error_model() override;
1278 
1283  const ErrorModel *as_error_model() const override;
1284 
1288  One<Node> copy() const override;
1289 
1293  One<Node> clone() const override;
1294 
1298  bool equals(const Node &rhs) const override;
1299 
1303  bool operator==(const Node &rhs) const override;
1304 
1308  void serialize(
1309  ::tree::cbor::MapWriter &map,
1310  const ::tree::base::PointerMap &ids
1311  ) const override;
1312 
1316  static std::shared_ptr<ErrorModel> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1317 
1318 };
1319 
1323 class ForLoop : public Structured {
1324 public:
1325 
1330 
1335 
1341 
1346 
1351 
1355  void find_reachable(::tree::base::PointerMap &map) const override;
1356 
1360  void check_complete(const ::tree::base::PointerMap &map) const override;
1361 
1365  NodeType type() const override;
1366 
1367 protected:
1368 
1372  void visit_internal(VisitorBase &visitor, void *retval) override;
1373 
1374 public:
1375 
1380  ForLoop *as_for_loop() override;
1381 
1386  const ForLoop *as_for_loop() const override;
1387 
1391  One<Node> copy() const override;
1392 
1396  One<Node> clone() const override;
1397 
1401  bool equals(const Node &rhs) const override;
1402 
1406  bool operator==(const Node &rhs) const override;
1407 
1411  void serialize(
1412  ::tree::cbor::MapWriter &map,
1413  const ::tree::base::PointerMap &ids
1414  ) const override;
1415 
1419  static std::shared_ptr<ForLoop> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1420 
1421 };
1422 
1428 class ForeachLoop : public Structured {
1429 public:
1430 
1435 
1440 
1445 
1450 
1454  ForeachLoop(const One<cqasm::v1::values::Node> &lhs = cqasm::v1::primitives::initialize<One<cqasm::v1::values::Node>>(), const cqasm::v1::primitives::Int &frm = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Int>(), const cqasm::v1::primitives::Int &to = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Int>(), const One<Block> &body = One<Block>(), const Any<AnnotationData> &annotations = Any<AnnotationData>());
1455 
1459  void find_reachable(::tree::base::PointerMap &map) const override;
1460 
1464  void check_complete(const ::tree::base::PointerMap &map) const override;
1465 
1469  NodeType type() const override;
1470 
1471 protected:
1472 
1476  void visit_internal(VisitorBase &visitor, void *retval) override;
1477 
1478 public:
1479 
1484  ForeachLoop *as_foreach_loop() override;
1485 
1490  const ForeachLoop *as_foreach_loop() const override;
1491 
1495  One<Node> copy() const override;
1496 
1500  One<Node> clone() const override;
1501 
1505  bool equals(const Node &rhs) const override;
1506 
1510  bool operator==(const Node &rhs) const override;
1511 
1515  void serialize(
1516  ::tree::cbor::MapWriter &map,
1517  const ::tree::base::PointerMap &ids
1518  ) const override;
1519 
1523  static std::shared_ptr<ForeachLoop> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1524 
1525 };
1526 
1530 class InstructionBase : public Annotated {
1531 public:
1532 
1538 
1543 
1548  InstructionBase *as_instruction_base() override;
1549 
1554  const InstructionBase *as_instruction_base() const override;
1555 
1559  static std::shared_ptr<InstructionBase> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1560 
1561 };
1562 
1567 public:
1568 
1573 
1578 
1582  void find_reachable(::tree::base::PointerMap &map) const override;
1583 
1587  void check_complete(const ::tree::base::PointerMap &map) const override;
1588 
1592  NodeType type() const override;
1593 
1594 protected:
1595 
1599  void visit_internal(VisitorBase &visitor, void *retval) override;
1600 
1601 public:
1602 
1607  GotoInstruction *as_goto_instruction() override;
1608 
1613  const GotoInstruction *as_goto_instruction() const override;
1614 
1618  One<Node> copy() const override;
1619 
1623  One<Node> clone() const override;
1624 
1628  bool equals(const Node &rhs) const override;
1629 
1633  bool operator==(const Node &rhs) const override;
1634 
1638  void serialize(
1639  ::tree::cbor::MapWriter &map,
1640  const ::tree::base::PointerMap &ids
1641  ) const override;
1642 
1646  static std::shared_ptr<GotoInstruction> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1647 
1648 };
1649 
1653 class IfElse : public Structured {
1654 public:
1655 
1660 
1665 
1669  IfElse(const Many<IfElseBranch> &branches = Many<IfElseBranch>(), const Maybe<Block> &otherwise = Maybe<Block>(), const Any<AnnotationData> &annotations = Any<AnnotationData>());
1670 
1674  void find_reachable(::tree::base::PointerMap &map) const override;
1675 
1679  void check_complete(const ::tree::base::PointerMap &map) const override;
1680 
1684  NodeType type() const override;
1685 
1686 protected:
1687 
1691  void visit_internal(VisitorBase &visitor, void *retval) override;
1692 
1693 public:
1694 
1699  IfElse *as_if_else() override;
1700 
1705  const IfElse *as_if_else() const override;
1706 
1710  One<Node> copy() const override;
1711 
1715  One<Node> clone() const override;
1716 
1720  bool equals(const Node &rhs) const override;
1721 
1725  bool operator==(const Node &rhs) const override;
1726 
1730  void serialize(
1731  ::tree::cbor::MapWriter &map,
1732  const ::tree::base::PointerMap &ids
1733  ) const override;
1734 
1738  static std::shared_ptr<IfElse> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1739 
1740 };
1741 
1745 class IfElseBranch : public Node {
1746 public:
1747 
1752 
1757 
1762 
1766  void find_reachable(::tree::base::PointerMap &map) const override;
1767 
1771  void check_complete(const ::tree::base::PointerMap &map) const override;
1772 
1776  NodeType type() const override;
1777 
1778 protected:
1779 
1783  void visit_internal(VisitorBase &visitor, void *retval) override;
1784 
1785 public:
1786 
1791  IfElseBranch *as_if_else_branch() override;
1792 
1797  const IfElseBranch *as_if_else_branch() const override;
1798 
1802  One<Node> copy() const override;
1803 
1807  One<Node> clone() const override;
1808 
1812  bool equals(const Node &rhs) const override;
1813 
1817  bool operator==(const Node &rhs) const override;
1818 
1822  void serialize(
1823  ::tree::cbor::MapWriter &map,
1824  const ::tree::base::PointerMap &ids
1825  ) const override;
1826 
1830  static std::shared_ptr<IfElseBranch> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1831 
1832 };
1833 
1839 public:
1840 
1845 
1850 
1855 
1859  Instruction(const cqasm::v1::instruction::InstructionRef &instruction = cqasm::v1::primitives::initialize<cqasm::v1::instruction::InstructionRef>(), const cqasm::v1::primitives::Str &name = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Str>(), const One<cqasm::v1::values::Node> &condition = cqasm::v1::primitives::initialize<One<cqasm::v1::values::Node>>(), const Any<cqasm::v1::values::Node> &operands = cqasm::v1::primitives::initialize<Any<cqasm::v1::values::Node>>(), const Any<AnnotationData> &annotations = Any<AnnotationData>());
1860 
1864  void find_reachable(::tree::base::PointerMap &map) const override;
1865 
1869  void check_complete(const ::tree::base::PointerMap &map) const override;
1870 
1874  NodeType type() const override;
1875 
1876 protected:
1877 
1881  void visit_internal(VisitorBase &visitor, void *retval) override;
1882 
1883 public:
1884 
1889  Instruction *as_instruction() override;
1890 
1895  const Instruction *as_instruction() const override;
1896 
1900  One<Node> copy() const override;
1901 
1905  One<Node> clone() const override;
1906 
1910  bool equals(const Node &rhs) const override;
1911 
1915  bool operator==(const Node &rhs) const override;
1916 
1920  void serialize(
1921  ::tree::cbor::MapWriter &map,
1922  const ::tree::base::PointerMap &ids
1923  ) const override;
1924 
1928  static std::shared_ptr<Instruction> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
1929 
1930 };
1931 
1935 class Mapping : public Annotated {
1936 public:
1937 
1942 
1947 
1951  Mapping(const cqasm::v1::primitives::Str &name = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Str>(), const One<cqasm::v1::values::Node> &value = cqasm::v1::primitives::initialize<One<cqasm::v1::values::Node>>(), const Any<AnnotationData> &annotations = Any<AnnotationData>());
1952 
1956  void find_reachable(::tree::base::PointerMap &map) const override;
1957 
1961  void check_complete(const ::tree::base::PointerMap &map) const override;
1962 
1966  NodeType type() const override;
1967 
1968 protected:
1969 
1973  void visit_internal(VisitorBase &visitor, void *retval) override;
1974 
1975 public:
1976 
1981  Mapping *as_mapping() override;
1982 
1987  const Mapping *as_mapping() const override;
1988 
1992  One<Node> copy() const override;
1993 
1997  One<Node> clone() const override;
1998 
2002  bool equals(const Node &rhs) const override;
2003 
2007  bool operator==(const Node &rhs) const override;
2008 
2012  void serialize(
2013  ::tree::cbor::MapWriter &map,
2014  const ::tree::base::PointerMap &ids
2015  ) const override;
2016 
2020  static std::shared_ptr<Mapping> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
2021 
2022 };
2023 
2027 class Program : public Node {
2028 public:
2029 
2034 
2039 
2044 
2049 
2054 
2060 
2067 
2071  Program(const One<Version> &version = One<Version>(), const cqasm::v1::primitives::Int &num_qubits = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Int>(), const Maybe<ErrorModel> &error_model = Maybe<ErrorModel>(), const Any<Subcircuit> &subcircuits = Any<Subcircuit>(), const Any<Mapping> &mappings = Any<Mapping>(), const Any<Variable> &variables = Any<Variable>(), const cqasm::v1::primitives::Version &api_version = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Version>());
2072 
2076  void find_reachable(::tree::base::PointerMap &map) const override;
2077 
2081  void check_complete(const ::tree::base::PointerMap &map) const override;
2082 
2086  NodeType type() const override;
2087 
2088 protected:
2089 
2093  void visit_internal(VisitorBase &visitor, void *retval) override;
2094 
2095 public:
2096 
2101  Program *as_program() override;
2102 
2107  const Program *as_program() const override;
2108 
2112  One<Node> copy() const override;
2113 
2117  One<Node> clone() const override;
2118 
2122  bool equals(const Node &rhs) const override;
2123 
2127  bool operator==(const Node &rhs) const override;
2128 
2132  void serialize(
2133  ::tree::cbor::MapWriter &map,
2134  const ::tree::base::PointerMap &ids
2135  ) const override;
2136 
2140  static std::shared_ptr<Program> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
2141 
2142 };
2143 
2147 class RepeatUntilLoop : public Structured {
2148 public:
2149 
2154 
2159 
2164 
2168  void find_reachable(::tree::base::PointerMap &map) const override;
2169 
2173  void check_complete(const ::tree::base::PointerMap &map) const override;
2174 
2178  NodeType type() const override;
2179 
2180 protected:
2181 
2185  void visit_internal(VisitorBase &visitor, void *retval) override;
2186 
2187 public:
2188 
2193  RepeatUntilLoop *as_repeat_until_loop() override;
2194 
2199  const RepeatUntilLoop *as_repeat_until_loop() const override;
2200 
2204  One<Node> copy() const override;
2205 
2209  One<Node> clone() const override;
2210 
2214  bool equals(const Node &rhs) const override;
2215 
2219  bool operator==(const Node &rhs) const override;
2220 
2224  void serialize(
2225  ::tree::cbor::MapWriter &map,
2226  const ::tree::base::PointerMap &ids
2227  ) const override;
2228 
2232  static std::shared_ptr<RepeatUntilLoop> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
2233 
2234 };
2235 
2240 public:
2241 
2246 
2251 
2256 
2260  void find_reachable(::tree::base::PointerMap &map) const override;
2261 
2265  void check_complete(const ::tree::base::PointerMap &map) const override;
2266 
2270  NodeType type() const override;
2271 
2272 protected:
2273 
2277  void visit_internal(VisitorBase &visitor, void *retval) override;
2278 
2279 public:
2280 
2285  SetInstruction *as_set_instruction() override;
2286 
2291  const SetInstruction *as_set_instruction() const override;
2292 
2296  One<Node> copy() const override;
2297 
2301  One<Node> clone() const override;
2302 
2306  bool equals(const Node &rhs) const override;
2307 
2311  bool operator==(const Node &rhs) const override;
2312 
2316  void serialize(
2317  ::tree::cbor::MapWriter &map,
2318  const ::tree::base::PointerMap &ids
2319  ) const override;
2320 
2324  static std::shared_ptr<SetInstruction> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
2325 
2326 };
2327 
2332 class Subcircuit : public Annotated {
2333 public:
2334 
2340 
2346 
2352 
2358 
2362  Subcircuit(const cqasm::v1::primitives::Str &name = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Str>(), const cqasm::v1::primitives::Int &iterations = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Int>(), const Any<Bundle> &bundles = Any<Bundle>(), const Any<AnnotationData> &annotations = Any<AnnotationData>(), const Maybe<Block> &body = Maybe<Block>());
2363 
2367  void find_reachable(::tree::base::PointerMap &map) const override;
2368 
2372  void check_complete(const ::tree::base::PointerMap &map) const override;
2373 
2377  NodeType type() const override;
2378 
2379 protected:
2380 
2384  void visit_internal(VisitorBase &visitor, void *retval) override;
2385 
2386 public:
2387 
2392  Subcircuit *as_subcircuit() override;
2393 
2398  const Subcircuit *as_subcircuit() const override;
2399 
2403  One<Node> copy() const override;
2404 
2408  One<Node> clone() const override;
2409 
2413  bool equals(const Node &rhs) const override;
2414 
2418  bool operator==(const Node &rhs) const override;
2419 
2423  void serialize(
2424  ::tree::cbor::MapWriter &map,
2425  const ::tree::base::PointerMap &ids
2426  ) const override;
2427 
2431  static std::shared_ptr<Subcircuit> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
2432 
2433 };
2434 
2438 class Variable : public Annotated {
2439 public:
2440 
2445 
2450 
2454  Variable(const cqasm::v1::primitives::Str &name = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Str>(), const One<cqasm::v1::types::Node> &typ = cqasm::v1::primitives::initialize<One<cqasm::v1::types::Node>>(), const Any<AnnotationData> &annotations = Any<AnnotationData>());
2455 
2459  void find_reachable(::tree::base::PointerMap &map) const override;
2460 
2464  void check_complete(const ::tree::base::PointerMap &map) const override;
2465 
2469  NodeType type() const override;
2470 
2471 protected:
2472 
2476  void visit_internal(VisitorBase &visitor, void *retval) override;
2477 
2478 public:
2479 
2484  Variable *as_variable() override;
2485 
2490  const Variable *as_variable() const override;
2491 
2495  One<Node> copy() const override;
2496 
2500  One<Node> clone() const override;
2501 
2505  bool equals(const Node &rhs) const override;
2506 
2510  bool operator==(const Node &rhs) const override;
2511 
2515  void serialize(
2516  ::tree::cbor::MapWriter &map,
2517  const ::tree::base::PointerMap &ids
2518  ) const override;
2519 
2523  static std::shared_ptr<Variable> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
2524 
2525 };
2526 
2530 class Version : public Node {
2531 public:
2532 
2537 
2541  Version(const cqasm::v1::primitives::Version &items = cqasm::v1::primitives::initialize<cqasm::v1::primitives::Version>());
2542 
2546  void find_reachable(::tree::base::PointerMap &map) const override;
2547 
2551  void check_complete(const ::tree::base::PointerMap &map) const override;
2552 
2556  NodeType type() const override;
2557 
2558 protected:
2559 
2563  void visit_internal(VisitorBase &visitor, void *retval) override;
2564 
2565 public:
2566 
2571  Version *as_version() override;
2572 
2577  const Version *as_version() const override;
2578 
2582  One<Node> copy() const override;
2583 
2587  One<Node> clone() const override;
2588 
2592  bool equals(const Node &rhs) const override;
2593 
2597  bool operator==(const Node &rhs) const override;
2598 
2602  void serialize(
2603  ::tree::cbor::MapWriter &map,
2604  const ::tree::base::PointerMap &ids
2605  ) const override;
2606 
2610  static std::shared_ptr<Version> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
2611 
2612 };
2613 
2617 class WhileLoop : public Structured {
2618 public:
2619 
2624 
2629 
2634 
2638  void find_reachable(::tree::base::PointerMap &map) const override;
2639 
2643  void check_complete(const ::tree::base::PointerMap &map) const override;
2644 
2648  NodeType type() const override;
2649 
2650 protected:
2651 
2655  void visit_internal(VisitorBase &visitor, void *retval) override;
2656 
2657 public:
2658 
2663  WhileLoop *as_while_loop() override;
2664 
2669  const WhileLoop *as_while_loop() const override;
2670 
2674  One<Node> copy() const override;
2675 
2679  One<Node> clone() const override;
2680 
2684  bool equals(const Node &rhs) const override;
2685 
2689  bool operator==(const Node &rhs) const override;
2690 
2694  void serialize(
2695  ::tree::cbor::MapWriter &map,
2696  const ::tree::base::PointerMap &ids
2697  ) const override;
2698 
2702  static std::shared_ptr<WhileLoop> deserialize(const ::tree::cbor::MapReader &map, ::tree::base::IdentifierMap &ids);
2703 
2704 };
2705 
2710 public:
2711 
2715  virtual ~VisitorBase() = default;
2716 
2717 protected:
2718 
2719  friend class Node;
2720  friend class Annotated;
2721  friend class AnnotationData;
2722  friend class Block;
2723  friend class BreakStatement;
2724  friend class Bundle;
2725  friend class BundleExt;
2726  friend class ContinueStatement;
2727  friend class ErrorModel;
2728  friend class ForLoop;
2729  friend class ForeachLoop;
2730  friend class GotoInstruction;
2731  friend class IfElse;
2732  friend class IfElseBranch;
2733  friend class Instruction;
2734  friend class InstructionBase;
2735  friend class Mapping;
2736  friend class Program;
2737  friend class RepeatUntilLoop;
2738  friend class SetInstruction;
2739  friend class Statement;
2740  friend class Structured;
2741  friend class Subcircuit;
2742  friend class Variable;
2743  friend class Version;
2744  friend class WhileLoop;
2745 
2749  virtual void raw_visit_node(Node &node, void *retval) = 0;
2750 
2754  virtual void raw_visit_annotated(Annotated &node, void *retval) = 0;
2755 
2759  virtual void raw_visit_annotation_data(AnnotationData &node, void *retval) = 0;
2760 
2764  virtual void raw_visit_block(Block &node, void *retval) = 0;
2765 
2769  virtual void raw_visit_break_statement(BreakStatement &node, void *retval) = 0;
2770 
2774  virtual void raw_visit_bundle(Bundle &node, void *retval) = 0;
2775 
2779  virtual void raw_visit_bundle_ext(BundleExt &node, void *retval) = 0;
2780 
2784  virtual void raw_visit_continue_statement(ContinueStatement &node, void *retval) = 0;
2785 
2789  virtual void raw_visit_error_model(ErrorModel &node, void *retval) = 0;
2790 
2794  virtual void raw_visit_for_loop(ForLoop &node, void *retval) = 0;
2795 
2799  virtual void raw_visit_foreach_loop(ForeachLoop &node, void *retval) = 0;
2800 
2804  virtual void raw_visit_goto_instruction(GotoInstruction &node, void *retval) = 0;
2805 
2809  virtual void raw_visit_if_else(IfElse &node, void *retval) = 0;
2810 
2814  virtual void raw_visit_if_else_branch(IfElseBranch &node, void *retval) = 0;
2815 
2819  virtual void raw_visit_instruction(Instruction &node, void *retval) = 0;
2820 
2824  virtual void raw_visit_instruction_base(InstructionBase &node, void *retval) = 0;
2825 
2829  virtual void raw_visit_mapping(Mapping &node, void *retval) = 0;
2830 
2834  virtual void raw_visit_program(Program &node, void *retval) = 0;
2835 
2839  virtual void raw_visit_repeat_until_loop(RepeatUntilLoop &node, void *retval) = 0;
2840 
2844  virtual void raw_visit_set_instruction(SetInstruction &node, void *retval) = 0;
2845 
2849  virtual void raw_visit_statement(Statement &node, void *retval) = 0;
2850 
2854  virtual void raw_visit_structured(Structured &node, void *retval) = 0;
2855 
2859  virtual void raw_visit_subcircuit(Subcircuit &node, void *retval) = 0;
2860 
2864  virtual void raw_visit_variable(Variable &node, void *retval) = 0;
2865 
2869  virtual void raw_visit_version(Version &node, void *retval) = 0;
2870 
2874  virtual void raw_visit_while_loop(WhileLoop &node, void *retval) = 0;
2875 
2876 };
2877 
2888 template <typename T>
2889 class Visitor : public VisitorBase {
2890 protected:
2891 
2895  void raw_visit_node(Node &node, void *retval) override;
2896 
2900  void raw_visit_annotated(Annotated &node, void *retval) override;
2901 
2905  void raw_visit_annotation_data(AnnotationData &node, void *retval) override;
2906 
2910  void raw_visit_block(Block &node, void *retval) override;
2911 
2915  void raw_visit_break_statement(BreakStatement &node, void *retval) override;
2916 
2920  void raw_visit_bundle(Bundle &node, void *retval) override;
2921 
2925  void raw_visit_bundle_ext(BundleExt &node, void *retval) override;
2926 
2930  void raw_visit_continue_statement(ContinueStatement &node, void *retval) override;
2931 
2935  void raw_visit_error_model(ErrorModel &node, void *retval) override;
2936 
2940  void raw_visit_for_loop(ForLoop &node, void *retval) override;
2941 
2945  void raw_visit_foreach_loop(ForeachLoop &node, void *retval) override;
2946 
2950  void raw_visit_goto_instruction(GotoInstruction &node, void *retval) override;
2951 
2955  void raw_visit_if_else(IfElse &node, void *retval) override;
2956 
2960  void raw_visit_if_else_branch(IfElseBranch &node, void *retval) override;
2961 
2965  void raw_visit_instruction(Instruction &node, void *retval) override;
2966 
2970  void raw_visit_instruction_base(InstructionBase &node, void *retval) override;
2971 
2975  void raw_visit_mapping(Mapping &node, void *retval) override;
2976 
2980  void raw_visit_program(Program &node, void *retval) override;
2981 
2985  void raw_visit_repeat_until_loop(RepeatUntilLoop &node, void *retval) override;
2986 
2990  void raw_visit_set_instruction(SetInstruction &node, void *retval) override;
2991 
2995  void raw_visit_statement(Statement &node, void *retval) override;
2996 
3000  void raw_visit_structured(Structured &node, void *retval) override;
3001 
3005  void raw_visit_subcircuit(Subcircuit &node, void *retval) override;
3006 
3010  void raw_visit_variable(Variable &node, void *retval) override;
3011 
3015  void raw_visit_version(Version &node, void *retval) override;
3016 
3020  void raw_visit_while_loop(WhileLoop &node, void *retval) override;
3021 
3022 public:
3023 
3027  virtual T visit_node(Node &node) = 0;
3028 
3032  virtual T visit_annotated(Annotated &node) {
3033  return visit_node(node);
3034  }
3035 
3040  return visit_node(node);
3041  }
3042 
3046  virtual T visit_block(Block &node) {
3047  return visit_node(node);
3048  }
3049 
3054  return visit_structured(node);
3055  }
3056 
3060  virtual T visit_bundle(Bundle &node) {
3061  return visit_annotated(node);
3062  }
3063 
3067  virtual T visit_bundle_ext(BundleExt &node) {
3068  return visit_statement(node);
3069  }
3070 
3075  return visit_structured(node);
3076  }
3077 
3081  virtual T visit_error_model(ErrorModel &node) {
3082  return visit_annotated(node);
3083  }
3084 
3088  virtual T visit_for_loop(ForLoop &node) {
3089  return visit_structured(node);
3090  }
3091 
3095  virtual T visit_foreach_loop(ForeachLoop &node) {
3096  return visit_structured(node);
3097  }
3098 
3103  return visit_instruction_base(node);
3104  }
3105 
3109  virtual T visit_if_else(IfElse &node) {
3110  return visit_structured(node);
3111  }
3112 
3117  return visit_node(node);
3118  }
3119 
3123  virtual T visit_instruction(Instruction &node) {
3124  return visit_instruction_base(node);
3125  }
3126 
3131  return visit_annotated(node);
3132  }
3133 
3137  virtual T visit_mapping(Mapping &node) {
3138  return visit_annotated(node);
3139  }
3140 
3144  virtual T visit_program(Program &node) {
3145  return visit_node(node);
3146  }
3147 
3152  return visit_structured(node);
3153  }
3154 
3159  return visit_instruction_base(node);
3160  }
3161 
3165  virtual T visit_statement(Statement &node) {
3166  return visit_annotated(node);
3167  }
3168 
3172  virtual T visit_structured(Structured &node) {
3173  return visit_statement(node);
3174  }
3175 
3179  virtual T visit_subcircuit(Subcircuit &node) {
3180  return visit_annotated(node);
3181  }
3182 
3186  virtual T visit_variable(Variable &node) {
3187  return visit_annotated(node);
3188  }
3189 
3193  virtual T visit_version(Version &node) {
3194  return visit_node(node);
3195  }
3196 
3200  virtual T visit_while_loop(WhileLoop &node) {
3201  return visit_structured(node);
3202  }
3203 
3204 };
3205 
3209  template <typename T>
3210  void Visitor<T>::raw_visit_node(Node &node, void *retval) {
3211  if (retval == nullptr) {
3212  this->visit_node(node);
3213  } else {
3214  *((T*)retval) = this->visit_node(node);
3215  };
3216  }
3217 
3221  template <>
3222  void Visitor<void>::raw_visit_node(Node &node, void *retval);
3223 
3227  template <typename T>
3228  void Visitor<T>::raw_visit_annotated(Annotated &node, void *retval) {
3229  if (retval == nullptr) {
3230  this->visit_annotated(node);
3231  } else {
3232  *((T*)retval) = this->visit_annotated(node);
3233  };
3234  }
3235 
3239  template <>
3240  void Visitor<void>::raw_visit_annotated(Annotated &node, void *retval);
3241 
3245  template <typename T>
3247  if (retval == nullptr) {
3248  this->visit_annotation_data(node);
3249  } else {
3250  *((T*)retval) = this->visit_annotation_data(node);
3251  };
3252  }
3253 
3257  template <>
3258  void Visitor<void>::raw_visit_annotation_data(AnnotationData &node, void *retval);
3259 
3263  template <typename T>
3264  void Visitor<T>::raw_visit_block(Block &node, void *retval) {
3265  if (retval == nullptr) {
3266  this->visit_block(node);
3267  } else {
3268  *((T*)retval) = this->visit_block(node);
3269  };
3270  }
3271 
3275  template <>
3276  void Visitor<void>::raw_visit_block(Block &node, void *retval);
3277 
3281  template <typename T>
3283  if (retval == nullptr) {
3284  this->visit_break_statement(node);
3285  } else {
3286  *((T*)retval) = this->visit_break_statement(node);
3287  };
3288  }
3289 
3293  template <>
3294  void Visitor<void>::raw_visit_break_statement(BreakStatement &node, void *retval);
3295 
3299  template <typename T>
3300  void Visitor<T>::raw_visit_bundle(Bundle &node, void *retval) {
3301  if (retval == nullptr) {
3302  this->visit_bundle(node);
3303  } else {
3304  *((T*)retval) = this->visit_bundle(node);
3305  };
3306  }
3307 
3311  template <>
3312  void Visitor<void>::raw_visit_bundle(Bundle &node, void *retval);
3313 
3317  template <typename T>
3318  void Visitor<T>::raw_visit_bundle_ext(BundleExt &node, void *retval) {
3319  if (retval == nullptr) {
3320  this->visit_bundle_ext(node);
3321  } else {
3322  *((T*)retval) = this->visit_bundle_ext(node);
3323  };
3324  }
3325 
3329  template <>
3330  void Visitor<void>::raw_visit_bundle_ext(BundleExt &node, void *retval);
3331 
3335  template <typename T>
3337  if (retval == nullptr) {
3338  this->visit_continue_statement(node);
3339  } else {
3340  *((T*)retval) = this->visit_continue_statement(node);
3341  };
3342  }
3343 
3347  template <>
3349 
3353  template <typename T>
3354  void Visitor<T>::raw_visit_error_model(ErrorModel &node, void *retval) {
3355  if (retval == nullptr) {
3356  this->visit_error_model(node);
3357  } else {
3358  *((T*)retval) = this->visit_error_model(node);
3359  };
3360  }
3361 
3365  template <>
3366  void Visitor<void>::raw_visit_error_model(ErrorModel &node, void *retval);
3367 
3371  template <typename T>
3372  void Visitor<T>::raw_visit_for_loop(ForLoop &node, void *retval) {
3373  if (retval == nullptr) {
3374  this->visit_for_loop(node);
3375  } else {
3376  *((T*)retval) = this->visit_for_loop(node);
3377  };
3378  }
3379 
3383  template <>
3384  void Visitor<void>::raw_visit_for_loop(ForLoop &node, void *retval);
3385 
3389  template <typename T>
3391  if (retval == nullptr) {
3392  this->visit_foreach_loop(node);
3393  } else {
3394  *((T*)retval) = this->visit_foreach_loop(node);
3395  };
3396  }
3397 
3401  template <>
3402  void Visitor<void>::raw_visit_foreach_loop(ForeachLoop &node, void *retval);
3403 
3407  template <typename T>
3409  if (retval == nullptr) {
3410  this->visit_goto_instruction(node);
3411  } else {
3412  *((T*)retval) = this->visit_goto_instruction(node);
3413  };
3414  }
3415 
3419  template <>
3421 
3425  template <typename T>
3426  void Visitor<T>::raw_visit_if_else(IfElse &node, void *retval) {
3427  if (retval == nullptr) {
3428  this->visit_if_else(node);
3429  } else {
3430  *((T*)retval) = this->visit_if_else(node);
3431  };
3432  }
3433 
3437  template <>
3438  void Visitor<void>::raw_visit_if_else(IfElse &node, void *retval);
3439 
3443  template <typename T>
3445  if (retval == nullptr) {
3446  this->visit_if_else_branch(node);
3447  } else {
3448  *((T*)retval) = this->visit_if_else_branch(node);
3449  };
3450  }
3451 
3455  template <>
3456  void Visitor<void>::raw_visit_if_else_branch(IfElseBranch &node, void *retval);
3457 
3461  template <typename T>
3463  if (retval == nullptr) {
3464  this->visit_instruction(node);
3465  } else {
3466  *((T*)retval) = this->visit_instruction(node);
3467  };
3468  }
3469 
3473  template <>
3474  void Visitor<void>::raw_visit_instruction(Instruction &node, void *retval);
3475 
3479  template <typename T>
3481  if (retval == nullptr) {
3482  this->visit_instruction_base(node);
3483  } else {
3484  *((T*)retval) = this->visit_instruction_base(node);
3485  };
3486  }
3487 
3491  template <>
3493 
3497  template <typename T>
3498  void Visitor<T>::raw_visit_mapping(Mapping &node, void *retval) {
3499  if (retval == nullptr) {
3500  this->visit_mapping(node);
3501  } else {
3502  *((T*)retval) = this->visit_mapping(node);
3503  };
3504  }
3505 
3509  template <>
3510  void Visitor<void>::raw_visit_mapping(Mapping &node, void *retval);
3511 
3515  template <typename T>
3516  void Visitor<T>::raw_visit_program(Program &node, void *retval) {
3517  if (retval == nullptr) {
3518  this->visit_program(node);
3519  } else {
3520  *((T*)retval) = this->visit_program(node);
3521  };
3522  }
3523 
3527  template <>
3528  void Visitor<void>::raw_visit_program(Program &node, void *retval);
3529 
3533  template <typename T>
3535  if (retval == nullptr) {
3536  this->visit_repeat_until_loop(node);
3537  } else {
3538  *((T*)retval) = this->visit_repeat_until_loop(node);
3539  };
3540  }
3541 
3545  template <>
3547 
3551  template <typename T>
3553  if (retval == nullptr) {
3554  this->visit_set_instruction(node);
3555  } else {
3556  *((T*)retval) = this->visit_set_instruction(node);
3557  };
3558  }
3559 
3563  template <>
3564  void Visitor<void>::raw_visit_set_instruction(SetInstruction &node, void *retval);
3565 
3569  template <typename T>
3570  void Visitor<T>::raw_visit_statement(Statement &node, void *retval) {
3571  if (retval == nullptr) {
3572  this->visit_statement(node);
3573  } else {
3574  *((T*)retval) = this->visit_statement(node);
3575  };
3576  }
3577 
3581  template <>
3582  void Visitor<void>::raw_visit_statement(Statement &node, void *retval);
3583 
3587  template <typename T>
3588  void Visitor<T>::raw_visit_structured(Structured &node, void *retval) {
3589  if (retval == nullptr) {
3590  this->visit_structured(node);
3591  } else {
3592  *((T*)retval) = this->visit_structured(node);
3593  };
3594  }
3595 
3599  template <>
3600  void Visitor<void>::raw_visit_structured(Structured &node, void *retval);
3601 
3605  template <typename T>
3606  void Visitor<T>::raw_visit_subcircuit(Subcircuit &node, void *retval) {
3607  if (retval == nullptr) {
3608  this->visit_subcircuit(node);
3609  } else {
3610  *((T*)retval) = this->visit_subcircuit(node);
3611  };
3612  }
3613 
3617  template <>
3618  void Visitor<void>::raw_visit_subcircuit(Subcircuit &node, void *retval);
3619 
3623  template <typename T>
3624  void Visitor<T>::raw_visit_variable(Variable &node, void *retval) {
3625  if (retval == nullptr) {
3626  this->visit_variable(node);
3627  } else {
3628  *((T*)retval) = this->visit_variable(node);
3629  };
3630  }
3631 
3635  template <>
3636  void Visitor<void>::raw_visit_variable(Variable &node, void *retval);
3637 
3641  template <typename T>
3642  void Visitor<T>::raw_visit_version(Version &node, void *retval) {
3643  if (retval == nullptr) {
3644  this->visit_version(node);
3645  } else {
3646  *((T*)retval) = this->visit_version(node);
3647  };
3648  }
3649 
3653  template <>
3654  void Visitor<void>::raw_visit_version(Version &node, void *retval);
3655 
3659  template <typename T>
3660  void Visitor<T>::raw_visit_while_loop(WhileLoop &node, void *retval) {
3661  if (retval == nullptr) {
3662  this->visit_while_loop(node);
3663  } else {
3664  *((T*)retval) = this->visit_while_loop(node);
3665  };
3666  }
3667 
3671  template <>
3672  void Visitor<void>::raw_visit_while_loop(WhileLoop &node, void *retval);
3673 
3681 class RecursiveVisitor : public Visitor<void> {
3682 public:
3683 
3687  void visit_annotated(Annotated &node) override;
3688 
3692  void visit_annotation_data(AnnotationData &node) override;
3693 
3697  void visit_block(Block &node) override;
3698 
3702  void visit_break_statement(BreakStatement &node) override;
3703 
3707  void visit_bundle(Bundle &node) override;
3708 
3712  void visit_bundle_ext(BundleExt &node) override;
3713 
3717  void visit_continue_statement(ContinueStatement &node) override;
3718 
3722  void visit_error_model(ErrorModel &node) override;
3723 
3727  void visit_for_loop(ForLoop &node) override;
3728 
3732  void visit_foreach_loop(ForeachLoop &node) override;
3733 
3737  void visit_goto_instruction(GotoInstruction &node) override;
3738 
3742  void visit_if_else(IfElse &node) override;
3743 
3747  void visit_if_else_branch(IfElseBranch &node) override;
3748 
3752  void visit_instruction(Instruction &node) override;
3753 
3757  void visit_instruction_base(InstructionBase &node) override;
3758 
3762  void visit_mapping(Mapping &node) override;
3763 
3767  void visit_program(Program &node) override;
3768 
3772  void visit_repeat_until_loop(RepeatUntilLoop &node) override;
3773 
3777  void visit_set_instruction(SetInstruction &node) override;
3778 
3782  void visit_statement(Statement &node) override;
3783 
3787  void visit_structured(Structured &node) override;
3788 
3792  void visit_subcircuit(Subcircuit &node) override;
3793 
3797  void visit_variable(Variable &node) override;
3798 
3802  void visit_version(Version &node) override;
3803 
3807  void visit_while_loop(WhileLoop &node) override;
3808 
3809 };
3810 
3814 class Dumper : public RecursiveVisitor {
3815 protected:
3816 
3820  std::ostream &out;
3821 
3825  int indent = 0;
3826 
3830  ::tree::base::PointerMap *ids;
3834  bool in_link = false;
3835 
3839  void write_indent();
3840 
3841 public:
3842 
3846  Dumper(std::ostream &out, int indent=0, ::tree::base::PointerMap *ids = nullptr) : out(out), indent(indent), ids(ids) {};
3847 
3851  void visit_node(Node &node) override;
3855  void visit_annotated(Annotated &node) override;
3856 
3860  void visit_annotation_data(AnnotationData &node) override;
3861 
3865  void visit_block(Block &node) override;
3866 
3870  void visit_break_statement(BreakStatement &node) override;
3871 
3875  void visit_bundle(Bundle &node) override;
3876 
3880  void visit_bundle_ext(BundleExt &node) override;
3881 
3885  void visit_continue_statement(ContinueStatement &node) override;
3886 
3890  void visit_error_model(ErrorModel &node) override;
3891 
3895  void visit_for_loop(ForLoop &node) override;
3896 
3900  void visit_foreach_loop(ForeachLoop &node) override;
3901 
3905  void visit_goto_instruction(GotoInstruction &node) override;
3906 
3910  void visit_if_else(IfElse &node) override;
3911 
3915  void visit_if_else_branch(IfElseBranch &node) override;
3916 
3920  void visit_instruction(Instruction &node) override;
3921 
3925  void visit_instruction_base(InstructionBase &node) override;
3926 
3930  void visit_mapping(Mapping &node) override;
3931 
3935  void visit_program(Program &node) override;
3936 
3940  void visit_repeat_until_loop(RepeatUntilLoop &node) override;
3941 
3945  void visit_set_instruction(SetInstruction &node) override;
3946 
3950  void visit_statement(Statement &node) override;
3951 
3955  void visit_structured(Structured &node) override;
3956 
3960  void visit_subcircuit(Subcircuit &node) override;
3961 
3965  void visit_variable(Variable &node) override;
3966 
3970  void visit_version(Version &node) override;
3971 
3975  void visit_while_loop(WhileLoop &node) override;
3976 
3977 };
3978 
3982 template <typename T>
3984  T retval;
3985  this->visit_internal(visitor, &retval);
3986  return retval;
3987 }
3988 
3992 template <>
3993 void Node::visit(Visitor<void> &visitor);
3994 
3998 std::ostream &operator<<(std::ostream &os, const Node &object);
3999 
4000 } // namespace semantic
4001 } // namespace v1
4002 } // namespace cqasm
4003 
The file version identifier.
Visitor class that debug-dumps a tree to a stream.
NodeType
Enumeration of all node types.
cqasm::v1::primitives::Str name
The name of the subcircuit.
::tree::base::Base Base
Definition: cqasm-tree.hpp:20
void raw_visit_for_loop(ForLoop &node, void *retval) override
Internal visitor function for ForLoop nodes.
void raw_visit_annotation_data(AnnotationData &node, void *retval) override
Internal visitor function for AnnotationData nodes.
virtual T visit_structured(Structured &node)
Fallback function for Structured nodes.
Represents a node that carries annotation data.
A C-style for loop.
::tree::base::Maybe< T > Maybe
Definition: cqasm-tree.hpp:23
void raw_visit_variable(Variable &node, void *retval) override
Internal visitor function for Variable nodes.
void raw_visit_break_statement(BreakStatement &node, void *retval) override
Internal visitor function for BreakStatement nodes.
T visit(Visitor< T > &visitor)
Visit this object.
tree::Maybe< ErrorModel > ErrorModelRef
Optional reference to an error model, used within the semantic tree.
Any< Variable > variables
This list of all user-defined variables at any point in the code.
virtual T visit_instruction_base(InstructionBase &node)
Fallback function for InstructionBase nodes.
::tree::base::Link< T > Link
Definition: cqasm-tree.hpp:35
tree::Maybe< Instruction > InstructionRef
Optional reference to an instruction, used within the semantic tree.
cqasm::v1::primitives::Str name
Name as it appears in the cQASM file.
::tree::base::OptLink< T > OptLink
Definition: cqasm-tree.hpp:38
cqasm::tree::Any< T > Any
This file contains the Instruction class and support types, each instance representing an instruction...
virtual T visit_annotated(Annotated &node)
Fallback function for Annotated nodes.
cqasm::tree::One< T > One
void raw_visit_foreach_loop(ForeachLoop &node, void *retval) override
Internal visitor function for ForeachLoop nodes.
A list of parallel instructions.
One< cqasm::v1::values::Node > lhs
The assignment target.
This file contains the ErrorModel class and support types, each instance representing an error model ...
cqasm::v1::primitives::Str interface
The interface this annotation is intended for.
void raw_visit_set_instruction(SetInstruction &node, void *retval) override
Internal visitor function for SetInstruction nodes.
error_model::ErrorModelRef deserialize(const ::tree::cbor::MapReader &map)
Deserializes the given primitive object from CBOR.
cqasm::v1::instruction::InstructionRef instruction
Instruction type as registered through the API.
cqasm::v1::primitives::Int to
The last value.
One< cqasm::v1::values::Node > condition
Condition (c- notation).
cqasm::v1::primitives::Str name
Name as it appears in the cQASM file.
virtual T visit_bundle(Bundle &node)
Visitor function for Bundle nodes.
Toplevel namespace with entry points for the new API.
Any< cqasm::v1::values::Node > parameters
Error model parameters.
One< Block > body
The loop body.
virtual T visit_version(Version &node)
Visitor function for Version nodes.
Any kind of instruction.
Any< cqasm::v1::values::Node > operands
Any operands attached to the annotation.
bool operator!=(const Node &rhs) const
Pointer-based inequality operator.
void raw_visit_block(Block &node, void *retval) override
Internal visitor function for Block nodes.
void raw_visit_node(Node &node, void *retval) override
Internal visitor function for nodes of any type.
Many< InstructionBase > items
The list of parallel instructions.
A mapping (alias) for an expression.
virtual T visit_subcircuit(Subcircuit &node)
Visitor function for Subcircuit nodes.
Any< Subcircuit > subcircuits
The list of subcircuit.
Defines classes representing the values (collective name for constants, references, and dynamically evaluated expressions) available within cQASM&#39;s type system, as well as some utility functions.
A single condition + block for use in an if-else chain.
One< Version > version
File version.
Internal class for implementing the visitor pattern.
Base class for the visitor pattern for the tree.
void raw_visit_error_model(ErrorModel &node, void *retval) override
Internal visitor function for ErrorModel nodes.
std::int64_t Int
Integer primitive used within the AST and semantic trees.
Visitor base class defaulting to DFS pre-order traversal.
cqasm::v1::error_model::ErrorModelRef model
Error model type as registered through the API.
Main class for all nodes.
A version 1.2+ assignment instruction.
void raw_visit_goto_instruction(GotoInstruction &node, void *retval) override
Internal visitor function for GotoInstruction nodes.
Version number primitive used within the AST and semantic trees.
void serialize(const error_model::ErrorModelRef &obj, ::tree::cbor::MapWriter &map)
cqasm::v1::primitives::Int frm
The first value.
Dumper(std::ostream &out, int indent=0, ::tree::base::PointerMap *ids=nullptr)
Construct a dumping visitor.
A bundle of instructions, to be executed in parallel.
Maybe< Block > otherwise
The final else block, if any.
One< cqasm::v1::values::Node > lhs
Reference to the variable used for looping.
cqasm::v1::primitives::Int iterations
An optional integer expression representing the number of iterations for this subcircuit.
One< cqasm::v1::values::Node > condition
The condition for starting another iteration.
Main class for all nodes.
Any kind of statement.
cqasm::tree::Maybe< T > Maybe
void raw_visit_instruction_base(InstructionBase &node, void *retval) override
Internal visitor function for InstructionBase nodes.
Any version 1.2+ structured control-flow statement.
One< cqasm::v1::values::Node > condition
The condition.
void raw_visit_subcircuit(Subcircuit &node, void *retval) override
Internal visitor function for Subcircuit nodes.
Represents an annotation.
T initialize()
Generates a default value for the given primitive type.
virtual T visit_repeat_until_loop(RepeatUntilLoop &node)
Visitor function for RepeatUntilLoop nodes.
std::ostream & operator<<(std::ostream &os, const Node &object)
Stream << overload for tree nodes (writes debug dump).
Defines primitive types for use in trees generated by tree-gen.
virtual T visit_for_loop(ForLoop &node)
Visitor function for ForLoop nodes.
void raw_visit_instruction(Instruction &node, void *retval) override
Internal visitor function for Instruction nodes.
virtual T visit_set_instruction(SetInstruction &node)
Visitor function for SetInstruction nodes.
Many< IfElseBranch > branches
The if-else branches.
virtual T visit_bundle_ext(BundleExt &node)
Visitor function for BundleExt nodes.
Namespace for the "new" cQASM 1.x API.
void raw_visit_structured(Structured &node, void *retval) override
Internal visitor function for Structured nodes.
One< cqasm::v1::values::Node > rhs
The value to assign.
void raw_visit_repeat_until_loop(RepeatUntilLoop &node, void *retval) override
Internal visitor function for RepeatUntilLoop nodes.
cqasm::v1::primitives::Version items
The list of version components, ordered major to minor.
void raw_visit_while_loop(WhileLoop &node, void *retval) override
Internal visitor function for WhileLoop nodes.
cqasm::tree::Link< T > Link
Wrapper for pulling parts of tree-gen&#39;s support library into libqasm.
virtual T visit_break_statement(BreakStatement &node)
Visitor function for BreakStatement nodes.
virtual T visit_block(Block &node)
Visitor function for Block nodes.
cqasm::v1::primitives::Str name
The name of the variable.
The file version identifier.
void raw_visit_statement(Statement &node, void *retval) override
Internal visitor function for Statement nodes.
std::ostream & out
Output stream to dump to.
Maybe< SetInstruction > initialize
The optional initializing assignment, run before the loop starts.
virtual T visit_goto_instruction(GotoInstruction &node)
Visitor function for GotoInstruction nodes.
cqasm::v1::primitives::Str operation
The operation within the interface that this annotation is intended for.
virtual T visit_while_loop(WhileLoop &node)
Visitor function for WhileLoop nodes.
One< cqasm::v1::values::Node > value
The value it maps to.
virtual T visit_instruction(Instruction &node)
Visitor function for Instruction nodes.
void raw_visit_version(Version &node, void *retval) override
Internal visitor function for Version nodes.
One< cqasm::v1::types::Node > typ
The type of the variable.
A single condition + block for use in an if-else chain.
::tree::base::Any< T > Any
Definition: cqasm-tree.hpp:29
std::string Str
String primitive used within the AST and semantic trees.
Many< Instruction > items
The list of parallel instructions.
virtual T visit_annotation_data(AnnotationData &node)
Visitor function for AnnotationData nodes.
void raw_visit_program(Program &node, void *retval) override
Internal visitor function for Program nodes.
cqasm::v1::primitives::Int num_qubits
The required qubit register size.
One< Block > body
The loop body.
Any< Bundle > bundles
The instruction bundles contained by this subcircuit.
::tree::base::Many< T > Many
Definition: cqasm-tree.hpp:32
void raw_visit_if_else(IfElse &node, void *retval) override
Internal visitor function for IfElse nodes.
cqasm::v1::primitives::Version api_version
API version.
void raw_visit_bundle(Bundle &node, void *retval) override
Internal visitor function for Bundle nodes.
Maybe< Block > body
The statements contained by this subcircuit.
virtual T visit_error_model(ErrorModel &node)
Visitor function for ErrorModel nodes.
Maybe< SetInstruction > update
The updating assignment, done at the end of the loop body and upon continue.
void raw_visit_mapping(Mapping &node, void *retval) override
Internal visitor function for Mapping nodes.
void raw_visit_continue_statement(ContinueStatement &node, void *retval) override
Internal visitor function for ContinueStatement nodes.
virtual T visit_foreach_loop(ForeachLoop &node)
Visitor function for ForeachLoop nodes.
virtual T visit_if_else_branch(IfElseBranch &node)
Visitor function for IfElseBranch nodes.
Any< Mapping > mappings
The list of all user-defined mappings after parsing.
Any< AnnotationData > annotations
Zero or more annotations attached to this object.
A complete program.
Any version 1.2+ structured control-flow statement.
virtual T visit_program(Program &node)
Visitor function for Program nodes.
A version 1.2+ goto instruction.
void raw_visit_annotated(Annotated &node, void *retval) override
Internal visitor function for Annotated nodes.
One< cqasm::v1::values::Node > condition
The condition for starting another iteration.
Any< cqasm::v1::values::Node > operands
Operands for the instruction.
cqasm::tree::Many< T > Many
Link< Subcircuit > target
Link to the target subcircuit, used as a label.
cqasm::v1::primitives::Str name
The name of the mapping.
::tree::base::PointerMap * ids
When non-null, the print node IDs from here instead of link contents.
void raw_visit_bundle_ext(BundleExt &node, void *retval) override
Internal visitor function for BundleExt nodes.
virtual T visit_variable(Variable &node)
Visitor function for Variable nodes.
One< cqasm::v1::values::Node > condition
The condition for stopping iteration.
cqasm::tree::OptLink< T > OptLink
::tree::base::One< T > One
Definition: cqasm-tree.hpp:26
void raw_visit_if_else_branch(IfElseBranch &node, void *retval) override
Internal visitor function for IfElseBranch nodes.
Represents a node that carries annotation data.
Any< Statement > statements
The statements contained by the block.
A bundle of instructions, to be executed in parallel.
Maybe< ErrorModel > error_model
Error model information.
virtual T visit_if_else(IfElse &node)
Visitor function for IfElse nodes.
virtual T visit_mapping(Mapping &node)
Visitor function for Mapping nodes.
virtual T visit_statement(Statement &node)
Fallback function for Statement nodes.
virtual T visit_continue_statement(ContinueStatement &node)
Visitor function for ContinueStatement nodes.