visitor

package main

import (
	"fmt"

	"github.com/itsubaki/qasm/visitor"
)

func main() {
	env := visitor.NewEnviron()
	env.Gate["x"] = &visitor.Gate{
		Name: "x",
	}

	g, ok := env.GetGate("x")
	fmt.Println(g.Name, ok)

	enclosed := env.NewEnclosed()
	encg, ok := enclosed.GetGate("x")
	fmt.Println(encg.Name, ok)

}

Output:

x true
x true

package main

import (
	"fmt"

	"github.com/itsubaki/qasm/visitor"
)

func main() {
	env := visitor.NewEnviron()
	env.Subroutine["qft"] = &visitor.Subroutine{
		Name: "qft",
	}

	enclosed := env.NewEnclosed()
	sub, ok := enclosed.GetSubroutine("qft")
	fmt.Println(sub.Name, ok)

}

Output:

qft true

package main

import (
	"fmt"

	"github.com/itsubaki/q"
	"github.com/itsubaki/qasm/visitor"
)

func main() {
	env := visitor.NewEnviron()
	env.Qubit["q0"] = []q.Qubit{0, 1}
	env.ClassicalBit["c0"] = []int64{0, 1}

	enclosed := env.NewEnclosed()
	enclosed.Qubit["q1"] = []q.Qubit{2, 3}
	enclosed.ClassicalBit["c1"] = []int64{2, 3}

	fmt.Println(enclosed.GetQubit("q0"))
	fmt.Println(enclosed.GetQubit("q1"))
	fmt.Println(enclosed.GetClassicalBit("c0"))
	fmt.Println(enclosed.GetClassicalBit("c1"))

}

Output:

[0 1] true
[2 3] true
[0 1] true
[2 3] true

package main

import (
	"fmt"

	"github.com/itsubaki/qasm/visitor"
)

func main() {
	env := visitor.NewEnviron()

	env.SetVariable("a", 42)
	fmt.Println("env:", env.Variable)

	enclosed := env.NewEnclosed()
	enclosed.SetVariable("a", 43)
	fmt.Println("env:", env.Variable)
	fmt.Println("enclosed:", enclosed.Variable)

	enclosed.SetVariable("b", 100)
	enclosed.SetVariable("b", 101)
	fmt.Println("env:", env.Variable)
	fmt.Println("enclosed:", enclosed.Variable)

}

Output:

env: map[a:42]
env: map[a:43]
enclosed: map[]
env: map[a:43]
enclosed: map[b:101]

text := `
	OPENQASM 3.0;
	`

lexer := parser.Newqasm3Lexer(antlr.NewInputStream(text))
p := parser.Newqasm3Parser(antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel))

qsim := q.New()
env := visitor.NewEnviron()
v := visitor.New(qsim, env)

if err := v.Run(p.Program()); err != nil {
	fmt.Println(err)
}

fmt.Println(env.Version)

Output:

3.0

text := `
	const int a = 42;
	const int a = 43;
	`

lexer := parser.Newqasm3Lexer(antlr.NewInputStream(text))
p := parser.Newqasm3Parser(antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel))

qsim := q.New()
env := visitor.NewEnviron()
v := visitor.New(qsim, env)

if err := v.Run(p.Program()); err != nil {
	fmt.Println(err)
}

Output:

visit: identifier=a: already declared

text := `
	include "../testdata/stdgates.qasm";
	`

lexer := parser.Newqasm3Lexer(antlr.NewInputStream(text))
p := parser.Newqasm3Parser(antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel))

tree := p.Program()
fmt.Println(tree.ToStringTree(nil, p))

qsim := q.New()
env := visitor.NewEnviron()
v := visitor.New(qsim, env)

if err := v.Visit(tree); err != nil {
	fmt.Println(err)
}

fmt.Println(slices.Sorted(maps.Keys(env.Gate)))
for _, s := range qsim.State() {
	fmt.Println(s)
}

Output:

(program (statementOrScope (statement (includeStatement include "../testdata/stdgates.qasm" ;))) <EOF>)
[cx h i x y z]

text := `
	include "file_not_found.qasm";
	`

lexer := parser.Newqasm3Lexer(antlr.NewInputStream(text))
p := parser.Newqasm3Parser(antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel))

tree := p.Program()
fmt.Println(tree.ToStringTree(nil, p))

qsim := q.New()
env := visitor.NewEnviron()
v := visitor.New(qsim, env)

if err := v.Visit(tree); err != nil {
	fmt.Println(err)
}

Output:

(program (statementOrScope (statement (includeStatement include "file_not_found.qasm" ;))) <EOF>)
read file=file_not_found.qasm: open file_not_found.qasm: no such file or directory

text := `
	include "../testdata/invalid.qasm";
	qubit q;
	h q;
	`

lexer := parser.Newqasm3Lexer(antlr.NewInputStream(text))
p := parser.Newqasm3Parser(antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel))

tree := p.Program()
fmt.Println(tree.ToStringTree(nil, p))

qsim := q.New()
env := visitor.NewEnviron()
v := visitor.New(qsim, env)

if err := v.Visit(tree); err != nil {
	fmt.Println(err)
}

Output:

(program (statementOrScope (statement (includeStatement include "../testdata/invalid.qasm" ;))) (statementOrScope (statement (quantumDeclarationStatement (qubitType qubit) q ;))) (statementOrScope (statement (gateCallStatement h (gateOperandList (gateOperand (indexedIdentifier q))) ;))) <EOF>)
include: identifier=invalid: identifier not found

text := `
	pragma qiskit.simulator noise model "qpu1.noise";
	`

lexer := parser.Newqasm3Lexer(antlr.NewInputStream(text))
p := parser.Newqasm3Parser(antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel))

tree := p.Program()
fmt.Println(tree.ToStringTree(nil, p))

qsim := q.New()
env := visitor.NewEnviron()
v := visitor.New(qsim, env)

fmt.Println(v.Visit(tree))

Output:

(program (statementOrScope (statement (pragma pragma qiskit.simulator noise model "qpu1.noise";))) <EOF>)
qiskit.simulator noise model "qpu1.noise";

text := `
	qubit q;
	U(pi/2, 0, pi) q;
	reset q;
	`

lexer := parser.Newqasm3Lexer(antlr.NewInputStream(text))
p := parser.Newqasm3Parser(antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel))

tree := p.Program()
fmt.Println(tree.ToStringTree(nil, p))

qsim := q.New()
env := visitor.NewEnviron()
v := visitor.New(qsim, env)

if err := v.Visit(tree); err != nil {
	fmt.Println(err)
}

for _, s := range qsim.State() {
	fmt.Println(s)
}

Output:

(program (statementOrScope (statement (quantumDeclarationStatement (qubitType qubit) q ;))) (statementOrScope (statement (gateCallStatement U ( (expressionList (expression (expression pi) / (expression 2)) , (expression 0) , (expression pi)) ) (gateOperandList (gateOperand (indexedIdentifier q))) ;))) (statementOrScope (statement (resetStatement reset (gateOperand (indexedIdentifier q)) ;))) <EOF>)
[0][  0]( 1.0000 0.0000i): 1.0000

text := `
	OPENQASM 3.0;
	`

lexer := parser.Newqasm3Lexer(antlr.NewInputStream(text))
p := parser.Newqasm3Parser(antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel))

tree := p.Program()
fmt.Println(tree.ToStringTree(nil, p))

qsim := q.New()
env := visitor.NewEnviron()
v := visitor.New(qsim, env)

if err := v.Visit(tree); err != nil {
	fmt.Println(err)
}

fmt.Println(env.Version)

Output:

(program (version OPENQASM 3.0 ;) <EOF>)
3.0