/**

* @copyright Copyright (c) 2025-2026

* UK Research and Innovation,

* Science and Technology Facilities Council,

* Hartree Centre

**/

#include "compiler.h"

#include "codegen.h"

#include "qasm3Lexer.h"

#include "qasm3Parser.h"

#include "qubitCountPass.h"

#include "utils.h"

#include <algorithm>

#include <any>

#include <cstddef>

#include <cstdlib>

#include <exception>

#include <format>

#include <fstream>

#include <iostream>

#include <stdexcept>

#include <string>

#include <string_view>

#include <utility>

#include <vector>

namespace {

const std::string qascInternalQuESTQureg{ "qascInternalQuestQureg" };

enum class OpType { QASC_UNARY_EXPRESSION, QASC_BINARY_EXPRESSION };

} // namespace

std::string Compiler::warningMessage(antlr4::ParserRuleContext* ctx,

const std::string& msg) {

if (ctx == nullptr) {

throw std::runtime_error(std::string("\033[1;31m")

+ "error: " + "\033[0m" + "null context.\n");

}

std::string error = currentFilename_ + " " + std::string("\033[1;35m")

+ "warning: " + "\033[0m" + msg + "\n"

+ std::to_string(ctx->getStart()->getLine()) + " | ";

ssize_t startIdx = ctx->start->getStartIndex();

ssize_t stopIdx = ctx->stop->getStopIndex();

error += ctx->start->getInputStream()->getText(

antlr4::misc::Interval(startIdx, stopIdx))

+ "\n";

return (error);

}

std::string Compiler::errorMessage(antlr4::ParserRuleContext* ctx,

const std::string& msg) {

std::string error;

if (ctx == nullptr) {

error = std::string("\033[1;31m") + "error: " + "\033[0m"

+ "null context.\n";

} else {

error = currentFilename_ + " " + std::string("\033[1;31m")

+ "error: " + "\033[0m" + msg + "\n"

+ std::to_string(ctx->getStart()->getLine()) + " | ";

ssize_t startIdx = ctx->start->getStartIndex();

ssize_t stopIdx = ctx->stop->getStopIndex();

error += ctx->start->getInputStream()->getText(

antlr4::misc::Interval(startIdx, stopIdx))

+ "\n";

}

return (error);

}

void CodeChunk::add(std::string& instr) {

code_.emplace_back(instr);

}

void CodeChunk::add(std::string&& instr) {

code_.emplace_back(instr);

}

void CodeChunk::pop() {

code_.pop_back();

}

void CodeChunk::print() const {

for (auto& instr : code_) {

Utils::print(std::format("{}", instr));

}

}

void CodeChunk::clear() {

code_.clear();

}

std::string CodeChunk::last() const {

return code_.back();

}

ssize_t CodeChunk::size() const {

return code_.size();

}

void CodeChunk::insert(ssize_t index, std::string&& value) {

code_.insert(code_.cbegin() + index, value);

}

void CodeChunk::replace(size_t index, const std::string& value) {

assert(index < code_.size() && "indexing CodeChunk should always be valid");

code_[index] = value;

}

std::string CodeChunk::toStr() const {

std::string codestr{};

for (const auto& instr : code_) {

codestr += instr;

}

return codestr;

}

std::string CodeChunk::toStrTo(size_t lineNumber) const {

if (lineNumber > code_.size()) {

return this->toStr();

}

std::string codestr{};

for (size_t i = 0; i < lineNumber; ++i) {

const auto& instr = code_[i];

codestr += instr;

}

return codestr;

}

std::string CodeChunk::toStrFrom(size_t lineNumber) const {

std::string codestr{};

for (size_t i = lineNumber; i < code_.size(); ++i) {

const auto& instr = code_[i];

codestr += instr;

}

return codestr;

}

std::any Compiler::visitProgram(qasm3Parser::ProgramContext* ctx) {

// do the pass to count numQubits;

firstPass(ctx);

code_.add(Generator::emitDepsHeaders());

code_.add("using namespace qasc;\n");

visitChildren(ctx);

if (!startedMain_) {

tryRegisterMainFn();

}

code_.insert(firstLineInMainIdx_, Generator::emitInputs(inputs_));

// check if user has defined main themselves, if so, return early

if (std::find_if(definedFuncs_.begin(), definedFuncs_.end(),

[](const auto& fnSig) { return "main" == fnSig.fnName; })

!= definedFuncs_.end()) {

return true;

}

if (outputFilename_ != "<noname>") {

if (!outputs_.empty()) {

code_.add(Generator::emitOutput(outputFilename_, outputs_));

} else if (!potentialOutputs_.empty()) {

code_.add(

Generator::emitOutput(outputFilename_, potentialOutputs_));

}

}

if (isQbackendInit_ && !callingFromInclude_) {

code_.add(Generator::emitQuestFree());

}

tryFinalizingMainFn();

return true;

}

std::any Compiler::visitVersion(qasm3Parser::VersionContext* ctx) {

return true;

}

std::any Compiler::visitStatement(qasm3Parser::StatementContext* ctx) {

return visitChildren(ctx);

}

std::any Compiler::visitAnnotation(qasm3Parser::AnnotationContext* ctx) {

throw std::runtime_error(

errorMessage(ctx, "annotation directives are not supported."));

}

std::any Compiler::visitScope(qasm3Parser::ScopeContext* ctx) {

scopeLvl_++;

code_.add(Generator::emitLeftBracket());

if (callingFromMainFn_ && !includeCodeForMainFn_.empty()) {

auto codeFromIncludesVec = getCodeFromIncludes();

std::string codeFromIncludes;

for (const auto& code : codeFromIncludesVec) {

codeFromIncludes += code;

}

code_.add(std::move(codeFromIncludes));

}

visitChildren(ctx);

code_.add(Generator::emitRightBracket());

scopeLvl_--;

return true;

}

std::any Compiler::visitPragma(qasm3Parser::PragmaContext* ctx) {

throw std::runtime_error(

errorMessage(ctx, "pragma directives are not supported."));

}

std::any Compiler::visitStatementOrScope(

qasm3Parser::StatementOrScopeContext* ctx) {

return visitChildren(ctx);

}

std::any Compiler::visitCalibrationGrammarStatement(

qasm3Parser::CalibrationGrammarStatementContext* ctx) {

throw std::runtime_error(

errorMessage(ctx, "calibration grammar statements are not supported."));

}

void Compiler::getDefinedFuncsFromInclude(

const std::vector<FuncSignature>& otherDefinedFuncs) {

for (auto& fnSignature : otherDefinedFuncs) {

definedFuncs_.push_back(fnSignature);

}

}

std::any Compiler::visitIncludeStatement(

qasm3Parser::IncludeStatementContext* ctx) {

auto includeFile = ctx->StringLiteral()->getText();

includeFile = std::string(includeFile.begin() + 1, includeFile.end() - 1);

if (includeFile == "stdgates.inc" || includeFile == "qelib1.inc") {

Utils::print(

std::format("{}", warningMessage(ctx, "ignoring include file.")));

return true;

}

auto includePath = includeFile;

std::ifstream stream;

if (inputFilename_ != "<noname>") {

auto index = inputFilename_.find_last_of('/');

std::string srcPath = "";

if (index != std::string::npos) {

srcPath = std::string(inputFilename_.begin(),

inputFilename_.begin() + index + 1);

}

includePath = srcPath + includePath;

}

stream.open(includePath);

antlr4::ANTLRInputStream input(stream);

antlr4cpp::qasm3Lexer lexer(&input);

antlr4::CommonTokenStream tokens(&lexer);

qasm3Parser parser(&tokens);

stream.close();

qasm3Parser::ProgramContext* tree = parser.program();

tempFilename_ = currentFilename_;

currentFilename_ = includeFile;

Compiler compiler(true);

compiler.visitProgram(tree);

if (compiler.totalNumQubits() != "0") {

totalNumQubits_ += " + " + compiler.totalNumQubits();

}

currentFilename_ = tempFilename_;

getDefinedFuncsFromInclude(compiler.definedFuncs_);

std::string headerDef = includeFile;

std::replace(headerDef.begin(), headerDef.end(), '.', '_');

std::transform(headerDef.begin(), headerDef.end(), headerDef.begin(),

::toupper);

// if we have nested includes (A includes B which includes C)

// remember to take everything

// NOTE: but if we have duplicated includes with expressions

// that require main it will cause errors. But that's on user

for (const auto& codeFromInclude : compiler.includeCodeForMainFn_) {

includeCodeForMainFn_.emplace_back(codeFromInclude);

}

// handle code from include that should be run inside main function

if (compiler.includeMainLineNumber() != -1) {

const auto mainLineNumber = compiler.includeMainLineNumber();

code_.add(Generator::emitIncludeCode(

headerDef, compiler.getCodeTo(mainLineNumber)));

// this will be added to main later on when main is registered

// we defer it to first handle all include files

includeCodeForMainFn_.emplace_back(

compiler.getCodeFrom(mainLineNumber));

} else {

code_.add(Generator::emitIncludeCode(headerDef, compiler.getCode()));

}

return true;

}

std::any Compiler::visitBreakStatement(

qasm3Parser::BreakStatementContext* ctx) {

code_.add(Generator::emitBreakStmt());

return true;

}

std::any Compiler::visitContinueStatement(

qasm3Parser::ContinueStatementContext* ctx) {

code_.add(Generator::emitContinueStmt());

return true;

}

std::any Compiler::visitEndStatement(qasm3Parser::EndStatementContext* ctx) {

tryRegisterMainFn();

code_.add(Generator::emitEndStmt());

return true;

}

std::any Compiler::visitForStatement(qasm3Parser::ForStatementContext* ctx) {

tryRegisterMainFn();

auto id = ctx->Identifier()->getText();

if (ctx->rangeExpression()) {

auto start = ctx->rangeExpression()->expression(0)->getText();

start = Utils::replacePowerOp(start);

start = Utils::replaceAllCastExpr(start);

auto end = ctx->rangeExpression()->expression(1)->getText();

end = Utils::replacePowerOp(end);

end = Utils::replaceAllCastExpr(end);

std::string increment = "1";

if (ctx->rangeExpression()->expression().size() == 3) {

increment = ctx->rangeExpression()->expression(2)->getText();

increment = Utils::replacePowerOp(increment);

increment = Utils::replaceAllCastExpr(increment);

// [x:y:z] z is actually end, and y is increment

std::swap(end, increment);

}

code_.add(Generator::emitForStmt(id, start, end, increment));

} else if (ctx->setExpression()) {

code_.add(Generator::emitForStmt(id, ctx->setExpression()->getText()));

} else if (ctx->expression()) {

code_.add(Generator::emitForStmt(id, ctx->expression()->getText()));

} else {

throw std::runtime_error(errorMessage(

ctx, "for loop supports only range and set expressions."));

}

ctx->statementOrScope()->accept(this);

return true;

}

std::any Compiler::visitIfStatement(qasm3Parser::IfStatementContext* ctx) {

tryRegisterMainFn();

if (!ctx->expression()) {

throw std::runtime_error(

errorMessage(ctx, "missing expressions in if statement."));

}

auto expr = ctx->expression()->getText();

expr = Utils::replacePowerOp(expr);

expr = Utils::replaceAllCastExpr(expr);

code_.add(Generator::emitIfStmt(expr));

ctx->if_body->accept(this);

if (ctx->ELSE()) {

code_.add(Generator::emitElseStmt());

ctx->else_body->accept(this);

}

return true;

}

std::any Compiler::visitReturnStatement(

qasm3Parser::ReturnStatementContext* ctx) {

tryRegisterMainFn();

if (ctx->measureExpression()) {

code_.add("return ");

ctx->measureExpression()->accept(this);

return true;

}

if (!ctx->expression()) {

code_.add(Generator::emitReturnStmt(""));

} else {

code_.add(Generator::emitReturnStmt(ctx->expression()->getText()));

}

return true;

}

std::any Compiler::visitWhileStatement(

qasm3Parser::WhileStatementContext* ctx) {

tryRegisterMainFn();

auto expr = ctx->expression()->getText();

expr = Utils::replacePowerOp(expr);

expr = Utils::replaceAllCastExpr(expr);

code_.add(Generator::emitWhileStmt(expr));

ctx->statementOrScope()->accept(this);

return true;

}

std::any Compiler::visitSwitchStatement(

qasm3Parser::SwitchStatementContext* ctx) {

tryRegisterMainFn();

auto expr = ctx->expression()->getText();

expr = Utils::replacePowerOp(expr);

expr = Utils::replaceAllCastExpr(expr);

code_.add(Generator::emitSwitchStmt(expr));

code_.add(Generator::emitLeftBracket());

for (auto c : ctx->switchCaseItem()) {

c->accept(this);

}

code_.add(Generator::emitRightBracket());

return true;

}

std::any Compiler::visitSwitchCaseItem(

qasm3Parser::SwitchCaseItemContext* ctx) {

if (ctx->CASE()) {

for (auto& e : ctx->expressionList()->expression()) {

auto expr = e->getText();

expr = Utils::replacePowerOp(expr);

expr = Utils::replaceAllCastExpr(expr);

code_.add(Generator::emitCaseStmt(expr));

code_.add(Generator::emitLeftBracket());

ctx->scope()->accept(this);

code_.add(Generator::emitBreakStmt());

code_.add(Generator::emitRightBracket());

}

return true;

} else if (ctx->DEFAULT()) {

code_.add(Generator::emitDefaultStmt());

}

code_.add(Generator::emitLeftBracket());

ctx->scope()->accept(this);

code_.add(Generator::emitBreakStmt());

code_.add(Generator::emitRightBracket());

return true;

}

std::any Compiler::visitBarrierStatement(

qasm3Parser::BarrierStatementContext* ctx) {

Utils::print(

std::format("{}", warningMessage(ctx, "ignoring barrier statement.")));

return true;

}

std::any Compiler::visitBoxStatement(qasm3Parser::BoxStatementContext* ctx) {

tryRegisterMainFn();

ctx->scope()->accept(this);

return true;

}

std::any Compiler::visitDelayStatement(

qasm3Parser::DelayStatementContext* ctx) {

warningMessage(ctx, "ignoring delay statement.");

return true;

}

std::any Compiler::visitGateCallStatement(

qasm3Parser::GateCallStatementContext* ctx) {

if (ctx->gateOperandList()) {

for (auto& operand : ctx->gateOperandList()->gateOperand()) {

if (operand->HardwareQubit()) {

throw std::runtime_error(errorMessage(

ctx, "addressing hardware qubits is not supported."));

}

}

}

tryRegisterMainFn();

if (callingFromDefStmt_) {

definedFuncs_.back().callsGates = true;

} else {

initQuantumBackend();

}

std::string statement = ctx->getText();

if (statement.find("gphase") != statement.npos) {

statement = Utils::processExpression(statement);

code_.add(std::move(statement) + "\n");

return true;

}

auto gateName{ ctx->Identifier()->getText() };

auto gatePower{ 1 };

std::string gatePowerStr{ "" };

handleGateModifier(ctx->gateModifier(), gateName, gatePower, gatePowerStr);

if (applyingInverse_) {

gateName = "inv_" + gateName;

applyingInverse_ = false;

}

std::string gateCall = gateName + "(";

if (ctx->expressionList()) {

std::string params = ctx->expressionList()->getText();

params = Utils::processExpression(params);

gateCall += params + ", ";

}

if (ctx->gateOperandList()) {

std::string qubits = ctx->gateOperandList()->getText();

qubits = Utils::processExpression(qubits);

qubits = Utils::replaceQuregSlice(qubits);

gateCall += qubits + ");\n";

}

if (gatePower > 1) {

code_.add(

std::format("for (auto gatePowerIdx = 0; gatePowerIdx < {}; "

"++gatePowerIdx)",

gatePowerStr));

code_.add(" {\n");

}

code_.add(std::move(gateCall));

if (gatePower > 1) {

code_.add("\n}\n");

}

return true;

}

std::any Compiler::visitMeasureArrowAssignmentStatement(

qasm3Parser::MeasureArrowAssignmentStatementContext* ctx) {

tryRegisterMainFn();

if (callingFromDefStmt_) {

definedFuncs_.back().callsGates = true;

} else {

initQuantumBackend();

}

auto varName = ctx->indexedIdentifier()->getText();

varName = Utils::replaceArrayCommaExpr(varName);

currentAssignmentName_ = varName;

if (!ctx->indexedIdentifier()->indexOperator().empty()) {

if (!ctx->indexedIdentifier()

->indexOperator(0)

->rangeExpression()

.empty()) {

processingSlice_ = true;

if (ctx->indexedIdentifier()->indexOperator().size() > 1

|| !ctx->indexedIdentifier()

->indexOperator(0)

->COMMA()

.empty()) {

throw std::runtime_error(errorMessage(

ctx, std::format("currently only 1D slices are "

"allowed. From {}",

ctx->getText())));

}

code_.add(

std::format("setSlice({}, ",

ctx->indexedIdentifier()->Identifier()->getText()));

} else if (ctx->indexedIdentifier()

->indexOperator(0)

->setExpression()) {

throw std::runtime_error(

errorMessage(ctx,

"set indexing expression in quantum measurements "

"are not supported."));

} else {

code_.add(Generator::emitAssignmentFront(varName, "=")

+ "one_qubit_");

}

} else {

code_.add(Generator::emitAssignmentFront(varName, "="));

}

ctx->measureExpression()->accept(this);

if (processingSlice_) {

// remove ;\n and add , instead

code_.pop();

code_.add(", ");

ctx->indexedIdentifier()->indexOperator(0)->accept(this);

if (ctx->SEMICOLON()) {

code_.add(";\n");

}

processingSlice_ = false;

}

currentAssignmentName_ = "";

return true;

}

std::any Compiler::visitResetStatement(

qasm3Parser::ResetStatementContext* ctx) {

tryRegisterMainFn();

if (callingFromDefStmt_) {

definedFuncs_.back().callsGates = true;

} else {

initQuantumBackend();

}

std::string qubits = ctx->gateOperand()->getText();

qubits = Utils::processExpression(qubits);

qubits = Utils::replaceQuregSlice(qubits);

code_.add("reset(" + qubits + ");\n");

return true;

}

std::any Compiler::visitAliasDeclarationStatement(

qasm3Parser::AliasDeclarationStatementContext* ctx) {

callingFromDeclaration_ = true;

callingFromAliasDeclaration_ = true;

const auto id = ctx->Identifier()->toString();

if (!ctx->aliasExpression()) {

throw std::runtime_error(

errorMessage(ctx, "invalid alias expressions."));

}

if (!ctx->aliasExpression()->DOUBLE_PLUS().empty()) {

throw std::runtime_error(errorMessage(

ctx, "concatenated alias expressions are not supported."));

}

code_.add(std::format("auto {} = ", id));

for (auto& expr : ctx->aliasExpression()->expression()) {

expr->accept(this);

}

if (ctx->SEMICOLON()) {

code_.add(";\n");

}

callingFromAliasDeclaration_ = false;

callingFromDeclaration_ = false;

return true;

}

std::any Compiler::visitClassicalDeclarationStatement(

qasm3Parser::ClassicalDeclarationStatementContext* ctx) {

callingFromDeclaration_ = true;

if (ctx->scalarType()) {

Compiler::generateScalarDeclaration<

qasm3Parser::ClassicalDeclarationStatementContext>(ctx);

} else if (ctx->arrayType()) {

Compiler::generateArrayDeclaration<

qasm3Parser::ClassicalDeclarationStatementContext>(ctx);

} else {

throw std::runtime_error(errorMessage(

ctx, std::format("error in classical declaration in {}.",

ctx->getText())));

}

callingFromDeclaration_ = false;

return true;

}

std::any Compiler::visitConstDeclarationStatement(

qasm3Parser::ConstDeclarationStatementContext* ctx) {

callingFromDeclaration_ = true;

code_.add(Generator::emitConstMod(startedMain_));

if (ctx->scalarType()) {

Compiler::generateScalarDeclaration<

qasm3Parser::ConstDeclarationStatementContext>(ctx);

} else {

throw std::runtime_error(errorMessage(

ctx,

std::format("error in const declaration in {}.", ctx->getText())));

}

callingFromDeclaration_ = false;

return true;

}

std::any Compiler::visitIoDeclarationStatement(

qasm3Parser::IoDeclarationStatementContext* ctx) {

callingFromDeclaration_ = true;

if (ctx->scalarType()) {

auto type{ extractScalarType(ctx, ctx->scalarType()->getText()) };

if (type == "float") {

type = "double";

}

const auto id{ ctx->Identifier()->getText() };

if (type != "double" && type != "std::complex<double>") {

std::string bitArraySize = "32";

std::string isAngle = "";

if (type.find(", true>") != type.npos) {

isAngle = ", true";

}

if (ctx->scalarType()->BIT() || ctx->scalarType()->BOOL()) {

bitArraySize = "1";

}

if (ctx->scalarType()->designator()

&& ctx->scalarType()->designator()->expression()) {

bitArraySize

= ctx->scalarType()->designator()->expression()->getText();

}

auto commaPos = type.find(',');

type = type.substr(0, commaPos + 1);

type += std::format(" {}{}>", bitArraySize, isAngle);

}

if (ctx->OUTPUT()) {

code_.add(Generator::emitIoDeclStmt(type, id, ""));

outputs_.emplace_back(Output{ type, id, 0 });

} else if (ctx->INPUT()) {

inputs_.emplace_back(Input{ type, id, 0 });

} else {

throw std::runtime_error(errorMessage(

ctx,

std::format("error in IO declaration in {}.", ctx->getText())));

}

} else if (ctx->arrayType()) {

const int numDim

= ctx->arrayType()->expressionList()->expression().size();

std::string type

= extractScalarType(ctx, ctx->arrayType()->scalarType()->getText());

if (type == "float") {

type = "double";

}

if (type != "double" && type != "std::complex<double>") {

std::string bitArraySize = "32";

std::string isAngle = "";

if (type.find(", true>") != type.npos) {

isAngle = ", true";

}

if (ctx->arrayType()->scalarType()->BIT()

|| ctx->arrayType()->scalarType()->BOOL()) {

bitArraySize = "1";

}

if (ctx->arrayType()->scalarType()->designator()

&& ctx->arrayType()->scalarType()->designator()->expression()) {

bitArraySize = ctx->arrayType()

->scalarType()

->designator()

->expression()

->getText();

}

auto commaPos = type.find(',');

type = type.substr(0, commaPos + 1);

type += std::format(" {}{}>", bitArraySize, isAngle);

}

const auto id{ ctx->Identifier()->getText() };

std::string defaultIntializer{ "" };

for (int i = 0; i < numDim; ++i) {

auto expr

= ctx->arrayType()->expressionList()->expression(i)->getText();

std::string sndArg = ", 0)"; // default 0 initialization

if (numDim - i - 1 != 0) {

sndArg

= ", " + Utils::createNDimVectorStr(numDim - i - 1, type);

}

defaultIntializer += "(" + expr + sndArg;

}

for (int i = 1; i < numDim; ++i) {

defaultIntializer += ")";

}

if (ctx->OUTPUT()) {

code_.add(Generator::emitIoDeclStmt(

Generator::emitNdArray(numDim, type), id, defaultIntializer));

outputs_.emplace_back(Output{ type, id, numDim });

} else if (ctx->INPUT()) {

if (numDim > 1) {

throw std::runtime_error(errorMessage(

ctx, "multidimensional inputs are not supported."));

}

inputs_.emplace_back(Input{ type, id, numDim });

} else {

throw std::runtime_error(errorMessage(

ctx,

std::format("error in IO declaration in {}.", ctx->getText())));

}

} else {

throw std::runtime_error(errorMessage(

ctx,

std::format("error in IO declaration in {}.", ctx->getText())));

}

callingFromDeclaration_ = false;

return true;

}

std::any Compiler::visitOldStyleDeclarationStatement(

qasm3Parser::OldStyleDeclarationStatementContext* ctx) {

tryRegisterMainFn();

const auto regName = ctx->Identifier()->getText();

if (!ctx->designator()) {

throw std::runtime_error(errorMessage(

ctx, std::format("did not specify register size in {}.",

ctx->getText())));

}

auto expression = ctx->designator()->expression()->getText();

expression = Utils::replacePowerOp(expression);

expression = Utils::replaceAllCastExpr(expression);

if (ctx->CREG()) {

const auto defaultInitializer = "(0)";

const auto type = std::format("QasmType<unsigned int, {}>", expression);

code_.add(Generator::emitClassicalDeclStmt(type, regName,

defaultInitializer));

if (scopeLvl_ == 0) {

potentialOutputs_.emplace_back(Output{ type, regName, 0 });

}

} else if (ctx->QREG()) {

code_.add(

std::format("auto {} = QuregSlice({});\n", regName, expression));

if (regName == lastQuregName_) {

initQuantumBackend();

}

} else {

throw std::runtime_error(errorMessage(

ctx, std::format("error in register declaration in {}.",

ctx->getText())));

}

return true;

}

std::any Compiler::visitQuantumDeclarationStatement(

qasm3Parser::QuantumDeclarationStatementContext* ctx) {

if (!callingFromDefStmt_) {

tryRegisterMainFn();

}

const auto qregName = ctx->Identifier()->getText();

std::string expression = "1";

if (ctx->qubitType()->designator()

&& ctx->qubitType()->designator()->expression()) {

expression = ctx->qubitType()->designator()->expression()->getText();

expression = Utils::replacePowerOp(expression);

expression = Utils::replaceAllCastExpr(expression);

}

if (expression.size() > 0

&& (expression[0] == '-' || expression[0] == '0')) {

throw std::runtime_error(

errorMessage(ctx,

"invalid qubit declaration. Number of qubits should "

"be positive."));

}

code_.add(std::format("auto {} = QuregSlice({});\n", qregName, expression));

if (qregName == lastQuregName_) {

initQuantumBackend();

}

return true;

}

std::any Compiler::visitDefStatement(qasm3Parser::DefStatementContext* ctx) {

callingFromDefStmt_ = true;

std::string returnType{ "" };

const auto codeSizeOnDefEnter = code_.size();

if (!ctx->returnSignature()) {

returnType = "void";

} else {

returnType = extractScalarType(

ctx, ctx->returnSignature()->scalarType()->getText());

}

const auto fnName = ctx->Identifier()->getText();

if (fnName == "main") {

callingFromMainFn_ = true;

startedMain_ = true;

returnType = "int";

}

definedFuncs_.emplace_back(fnName, returnType);

std::string args{ "" };

if (ctx->argumentDefinitionList()) {

args = std::any_cast<std::string>(

ctx->argumentDefinitionList()->accept(this));

}

if (fnName == "main") {

if (args != "") {

args.append(", ");

}

args.append("int argc, char* argv[]");

}

code_.add(Generator::emitFuncDefStmt(returnType, fnName, args));

if (fnName == "main") {

firstLineInMainIdx_ = code_.size() + 1;

}

ctx->scope()->accept(this);

auto& fnSignature = definedFuncs_.back();

size_t numArrArgs = 0;

bool hasArrArg = false;

bool hasQuregArg = false;

for (auto& argType : fnSignature.argTypes) {

if (argType.find("std::vector") != std::string::npos) {

++numArrArgs;

}

}

if (numArrArgs > 0) {

hasArrArg = true;

}

if (std::find(fnSignature.argTypes.begin(), fnSignature.argTypes.end(),

"QuregSlice & ")

!= fnSignature.argTypes.end()) {

hasQuregArg = true;

}

std::string templateExpr{ "" };

if (hasQuregArg && hasArrArg) {

templateExpr += "template <QasmQuregT T";

for (size_t i = 0; i < numArrArgs; ++i) {

templateExpr += std::format(", typename VecT{}", i);

}

templateExpr += ">\n";

} else if (hasQuregArg) {

templateExpr = "template <QasmQuregT T>\n";

} else if (hasArrArg) {

templateExpr = "template <typename VecT0 ";

for (size_t i = 1; i < numArrArgs; ++i) {

templateExpr += std::format(", typename VecT{}", i);

}

templateExpr += ">\n";

}

code_.insert(codeSizeOnDefEnter, std::move(templateExpr));

if (fnName == "main") {

code_.pop(); // remove } from scope body

if (code_.last().starts_with("return")) {

code_.pop(); // remove last return

}

if (outputFilename_ != "<noname>") {

if (!outputs_.empty()) {

code_.add(Generator::emitOutput(outputFilename_, outputs_));

} else if (!potentialOutputs_.empty()) {

code_.add(

Generator::emitOutput(outputFilename_, potentialOutputs_));

}

}

if (isQbackendInit_) {

code_.add(Generator::emitQuestFree());

}

code_.add("return 0;\n");

code_.add("}\n");

callingFromMainFn_ = false;

}

const auto codeSizeOnDefExit = code_.size();

// user has used an expression that required registering c++ main function.

// defining function inside c++ main function body is invalid, so

// the function definition has to be moved before the main function.

if (startedMain_ && codeSizeOnDefEnter > firstLineInMainIdx_) {

int i = codeSizeOnDefExit - codeSizeOnDefEnter;

std::vector<std::string> fullDefStmt(i);

while (i > 0) {

--i;