From fdf232d47454d08a85bc614166cbbf0560085343 Mon Sep 17 00:00:00 2001 From: Nadim Kobeissi Date: Sat, 19 Aug 2023 12:05:30 +0200 Subject: [PATCH] Verifpal 0.27.1 --- .golangci.yml | 5 +- .goreleaser.yml | 39 +- Makefile | 8 +- README.md | 8 +- assets/email.txt | 11 +- assets/releasenotes.txt | 4 +- assets/version.txt | 2 +- cmd/verifpal/main.go | 2 +- cmd/vplogic/libcoq.go | 1725 ------------------- cmd/vplogic/libpeg.go | 3498 --------------------------------------- go.mod | 6 +- go.sum | 257 +-- 12 files changed, 37 insertions(+), 5528 deletions(-) delete mode 100644 cmd/vplogic/libcoq.go delete mode 100644 cmd/vplogic/libpeg.go diff --git a/.golangci.yml b/.golangci.yml index a653ccd..a49e7b9 100755 --- a/.golangci.yml +++ b/.golangci.yml @@ -12,12 +12,9 @@ linters: - unused - gosimple - gofmt - - structcheck - - varcheck + - unused - ineffassign - - deadcode - typecheck - - depguard - dogsled - dupl - funlen diff --git a/.goreleaser.yml b/.goreleaser.yml index 10dc179..f280c90 100755 --- a/.goreleaser.yml +++ b/.goreleaser.yml @@ -1,10 +1,5 @@ project_name: verifpal -gitlab_urls: - api: https://source.symbolic.software/api/v4/ - download: https://source.symbolic.software - skip_tls_verify: false - before: hooks: - go generate ./... @@ -23,9 +18,7 @@ builds: - arm64 archives: - - replacements: - darwin: macos - format: zip + - format: zip files: - LICENSE - examples/* @@ -37,15 +30,14 @@ changelog: sort: asc release: - gitlab: - owner: verifpal + github: + owner: symbolicsoft name: verifpal brews: - - tap: - owner: verifpal + - repository: + owner: symbolicsoft name: verifpal - url_template: "https://source.symbolic.software/verifpal/verifpal/-/releases/{{ .Tag }}/downloads/{{ .ArtifactName }}" commit_author: name: drone email: drone@symbolic.software @@ -53,14 +45,13 @@ brews: homepage: "https://verifpal.com" description: "Cryptographic protocol analysis for students and engineers." -scoop: - bucket: - owner: verifpal - name: verifpal - url_template: "https://source.symbolic.software/verifpal/verifpal/-/releases/{{ .Tag }}/downloads/{{ .ArtifactName }}" - commit_author: - name: drone - email: drone@symbolic.software - homepage: "https://verifpal.com" - description: "Cryptographic protocol analysis for students and engineers." - license: "https://www.gnu.org/licenses/gpl-3.0.en.html" +scoops: + - repository: + owner: symbolicsoft + name: verifpal + commit_author: + name: drone + email: drone@symbolic.software + homepage: "https://verifpal.com" + description: "Cryptographic protocol analysis for students and engineers." + license: "https://www.gnu.org/licenses/gpl-3.0.en.html" diff --git a/Makefile b/Makefile index d4d636b..7c7be81 100644 --- a/Makefile +++ b/Makefile @@ -38,13 +38,13 @@ freebsd: dep: @/bin/echo -n "[Verifpal] Installing dependencies" - @go install github.com/logrusorgru/aurora + @go mod download github.com/logrusorgru/aurora @/bin/echo -n "." - @go install github.com/mna/pigeon + @go mod download github.com/mna/pigeon @/bin/echo -n "." - @go install github.com/spf13/cobra + @go mod download github.com/spf13/cobra @/bin/echo -n "." - @go install github.com/josephspurrier/goversioninfo/cmd/goversioninfo + @go mod download github.com/josephspurrier/goversioninfo @/bin/echo " OK" update: diff --git a/README.md b/README.md index fc4eaf7..39c77ea 100644 --- a/README.md +++ b/README.md @@ -38,20 +38,20 @@ The [Verifpal User Manual](https://verifpal.com/res/pdf/manual.pdf) is an essent On Windows, the best way to install Verifpal is through the [Scoop](https://scoop.sh) package manager, since you'll also get automatic updates: ``` -scoop bucket add verifpal https://source.symbolic.software/verifpal/verifpal.git +scoop bucket add verifpal https://github.com/symbolicsoft/verifpal.git scoop install verifpal ``` On Linux and macOS, the best way to install Verifpal is through the [Homebrew](https://brew.sh) package manager, since you'll also get automatic updates: ``` -brew tap verifpal.com/source https://source.symbolic.software/verifpal/verifpal +brew tap verifpal.com/source https://github.com/symbolicsoft/verifpal brew install verifpal ``` Otherwise, you can: -- *Download and install a release manually*: Releases for Windows, Linux, macOS and FreeBSD are available [here](https://source.symbolic.software/verifpal/verifpal/-/releases). +- *Download and install a release manually*: Releases for Windows, Linux, macOS and FreeBSD are available [here](https://github.com/symbolicsoft/verifpal/releases). - *Compile from source*: Keep reading! ### Building Verifpal from Source @@ -67,7 +67,7 @@ Verifpal relies on the [Aurora](https://github.com/logrusorgru/aurora) ANSI colo Builds will be available under `build/`. ### Verifpal for Visual Studio Code -Verifpal comes with a Visual Studio Code extension that offers syntax highlighting, automatic formatting, live analysis, diagram visualizations and much more, allowing developers to obtain insights on their model as they are writing it. To install it, simply search for "Verifpal" from inside Visual Studio Code. More information available [here](https://source.symbolic.software/verifpal/verifpal-vscode/-/blob/master/README.md). +Verifpal comes with a Visual Studio Code extension that offers syntax highlighting, automatic formatting, live analysis, diagram visualizations and much more, allowing developers to obtain insights on their model as they are writing it. To install it, simply search for "Verifpal" from inside Visual Studio Code. More information available [here](https://github.com/symbolicsoft/verifpal-vscode). ## Discussion Sign up to the [Verifpal Mailing List](https://lists.symbolic.software/mailman/listinfo/verifpal) to stay informed on the latest news and announcements regarding Verifpal, and to participate in Verifpal discussions. diff --git a/assets/email.txt b/assets/email.txt index c6abf81..c9e9ff5 100644 --- a/assets/email.txt +++ b/assets/email.txt @@ -8,17 +8,10 @@ Verifpal 0VERSION0 is now available. Verifpal updates bring new features, perfor 1RELEASENOTES1 ------------------------------- -2. PGP-Signed Releases +2. GitHub Releases ------------------------------- Official signed, pre-compiled release builds are provided for Windows, Linux, macOS and FreeBSD in x86, amd64 and arm64 variants, here: -https://source.symbolic.software/verifpal/verifpal/-/releases/v0VERSION0 - -Verifpal releases are signed using the following PGP key: -https://source.symbolic.software/verifpal/verifpal/-/blob/master/assets/pgp.txt - -In order to verify the PGP signature of your downloaded Verifpal release binary, please first verify the signature of the checksum file, verifpal_0VERSION0_checksums.txt, against its signature, verifpal_0VERSION0_checksums.txt.sig. Both files are located in the releases directory linked above. - -Once the signature of the checksum file is verified, ensure that the SHA256SUM of your downloaded release archive matches the one listed inside the checksum file for your chosen platform. +https://github.com/symbolicsoft/verifpal/releases/v0VERSION0 ------------------------------- 3. Updating Via Package Manager diff --git a/assets/releasenotes.txt b/assets/releasenotes.txt index 59c919a..73224da 100644 --- a/assets/releasenotes.txt +++ b/assets/releasenotes.txt @@ -1,3 +1,3 @@ -Verifpal 0.27.0 fixes an analysis bug caused by an ill-thought "performance optimization". It also updates a few dependencies. +Verifpal 0.27.1 introduces nothing new: it's simply an update to move Verifpal's package management URLs to the new GitHub repository. -Thanks to Oskar Goldhahn (NTNU) for detecting the issue. +That's right: Verifpal is moving to https://github.com/symbolicsoft/verifpal. Please update your links! diff --git a/assets/version.txt b/assets/version.txt index 1b58cc1..83b4730 100644 --- a/assets/version.txt +++ b/assets/version.txt @@ -1 +1 @@ -0.27.0 +0.27.1 diff --git a/cmd/verifpal/main.go b/cmd/verifpal/main.go index 3c8d509..931f0b6 100644 --- a/cmd/verifpal/main.go +++ b/cmd/verifpal/main.go @@ -20,7 +20,7 @@ import ( "verifpal.com/cmd/vplogic" ) -const version = "0.27.0" +const version = "0.27.1" var rootCmd = &cobra.Command{ Use: "verifpal", diff --git a/cmd/vplogic/libcoq.go b/cmd/vplogic/libcoq.go deleted file mode 100644 index 48f4e7e..0000000 --- a/cmd/vplogic/libcoq.go +++ /dev/null @@ -1,1725 +0,0 @@ -/* SPDX-FileCopyrightText: © 2019-2022 Nadim Kobeissi - * SPDX-License-Identifier: GPL-3.0-only */ -// 806d8db3ce9f3ded40fd35fdba02fb84 - -package vplogic - -import "strings" - -var libcoq = strings.Join([]string{ - "Require Import Coq.Lists.List Coq.Bool.Bool Coq.Arith.PeanoNat", - " Lia Coq.Strings.String.", - " Import ListNotations.", - "", - "Inductive generator :=", - "| G.", - "", - "Inductive guard_status: Type :=", - "| guarded", - "| unguarded.", - "", - "Inductive constant : Type :=", - "| Nil", - "| cnstn : string -> constant", - "with primitive : Type :=", - "| ENC : value -> value -> primitive", - "| DEC : value -> value -> primitive", - "| AEAD_ENC : value -> value -> value -> primitive", - "| AEAD_DEC : value -> value -> value -> primitive", - "| PKE_ENC : value -> value -> primitive", - "| PKE_DEC : value -> value -> primitive", - "| HASH1 : value -> primitive", - "| HASH2 : value -> value -> primitive", - "| HASH3 : value -> value -> value -> primitive", - "| HASH4 : value -> value -> value -> value -> primitive", - "| HASH5 : value -> value -> value -> value -> value -> primitive", - "| MAC : value -> value -> primitive", - "| HKDF1: value -> value -> value -> primitive", - "| HKDF2: value -> value -> value -> primitive", - "| HKDF3: value -> value -> value -> primitive", - "| HKDF4: value -> value -> value -> primitive", - "| HKDF5: value -> value -> value -> primitive", - "| PW_HASH1 : value -> primitive", - "| PW_HASH2 : value -> value -> primitive", - "| PW_HASH3 : value -> value -> value -> primitive", - "| PW_HASH4 : value -> value -> value -> value -> primitive", - "| PW_HASH5 : value -> value -> value -> value -> value -> primitive", - "| SIGN: value -> value -> primitive", - "| SIGNVERIF: value -> value -> value -> primitive", - "| RINGSIGN: value -> value -> value -> value -> primitive", - "| RINGSIGNVERIF: value -> value -> value -> value -> value -> primitive", - "| BLIND: value -> value -> primitive", - "| UNBLIND: value -> value -> value -> primitive", - "| SHAMIR_SPLIT1: value -> primitive", - "| SHAMIR_SPLIT2: value -> primitive", - "| SHAMIR_SPLIT3: value -> primitive", - "| SHAMIR_JOIN: value -> value -> primitive", - "| CONCAT2 : value -> value -> primitive", - "| CONCAT3 : value -> value -> value -> primitive", - "| CONCAT4 : value -> value -> value -> value -> primitive", - "| CONCAT5 : value -> value -> value -> value -> value -> primitive", - "| SPLIT1: value -> primitive", - "| SPLIT2: value -> primitive", - "| SPLIT3: value -> primitive", - "| SPLIT4: value -> primitive", - "| SPLIT5: value -> primitive", - " with equation : Type :=", - "| PUBKEY : generator -> value -> equation", - "| DH : generator -> value -> value -> equation", - " with value : Type :=", - "| pass : constant -> value", - "| const : constant -> value ", - "| eq : equation -> value", - "| prim : primitive -> value", - "| default.", - "", - "Inductive qualifier : Type :=", - "| public", - "| private.", - "", - "Inductive declaration : Type :=", - "| assignment", - "| generation", - "| knowledge.", - "", - "Inductive leak_status : Type :=", - "| leaked", - "| unleaked.", - "", - "Inductive expression : Type :=", - "| EXP: declaration -> qualifier -> value -> leak_status -> expression.", - "", - "(* if qualifier = public -> can learn*)", - "(* if leak_status = leaked -> can learn*)", - "(* if sent over the wire -> can learn*)", - "(* when learning, need to check if attacker already knows equivalent value,", - " but maybe this isn't necessary *)", - "", - "(* ", - "Variable enc_dec :", - " forall (k m : value), DEC k (ENC k m) = m. *)", - "", - "(* It has no axioms attached to Hash *)", - "", - "(* ", - "", - "Variable pke_enc_correcntess : ", - " PKE_DEC k (PKE_ENC((PUBKEY G k), m)) = m *)", - "", - "(* Variable public : value -> Prop.", - "Variable encryption_constructor : value -> value -> value.", - "Variable hash_constructor : value -> value. *)", - "", - "Inductive knows : value -> Type :=", - "(*equations*)", - "| public_key_generation (a ga: value) : knows a -> ga = (eq(PUBKEY G a)) -> knows ga", - "| dh_agreement_primitive (ga b a gab: value) (p: primitive): knows ga -> ga = ", - " (eq(PUBKEY G a)) -> knows b -> b = prim p -> gab = (eq(DH G a b)) -> knows gab", - "| dh_agreement_constant (ga b a gab: value) (c: constant): knows ga -> ga = ", - " eq(PUBKEY G a) -> knows b -> b = const c -> gab = (eq(DH G a b)) -> knows gab", - "(*core primitives*) ", - " (* todo: assert*)", - "| concat2_constructor (a b out: value) : knows a -> knows b -> out = prim(CONCAT2 a b)", - " -> knows out", - "| concat2_corerule_one (val a b : value) : knows val -> val = prim (CONCAT2 a b) -> knows a", - "| concat2_corerule_two (val a b : value) : knows val -> val = prim (CONCAT2 a b) -> knows b", - "", - "| concat3_constructor (a b c out: value) : knows a -> knows b -> knows c", - " -> out = prim(CONCAT3 a b c) -> knows out", - "| concat3_corerule_one (val a b c : value) : knows val -> val = prim (CONCAT3 a b c) -> knows a", - "| concat3_corerule_two (val a b c : value) : knows val -> val = prim (CONCAT3 a b c) -> knows b", - "| concat3_corerule_three (val a b c : value) : knows val -> val = prim (CONCAT3 a b c) -> knows c", - "", - "| concat4_constructor (a b c d out: value) : knows a -> knows b -> knows c -> knows d", - " -> out = prim(CONCAT4 a b c d) -> knows out", - "| concat4_corerule_one (val a b c d: value) : knows val -> val = prim (CONCAT4 a b c d) -> knows a", - "| concat4_corerule_two (val a b c d: value) : knows val -> val = prim (CONCAT4 a b c d) -> knows b", - "| concat4_corerule_three (val a b c d: value) : knows val -> val = prim (CONCAT4 a b c d) -> knows c", - "| concat4_corerule_four (val a b c d: value) : knows val -> val = prim (CONCAT4 a b c d) -> knows d", - "", - "| concat5_constructor (a b c d e out: value) : knows a -> knows b -> knows c -> knows d -> knows e", - " -> out = prim(CONCAT5 a b c d e) -> knows out", - "| concat5_corerule_one (val a b c d e: value) : knows val -> val = prim (CONCAT5 a b c d e) -> knows a", - "| concat5_corerule_two (val a b c d e: value) : knows val -> val = prim (CONCAT5 a b c d e) -> knows b", - "| concat5_corerule_three (val a b c d e: value) : knows val -> val = prim (CONCAT5 a b c d e) -> knows c", - "| concat5_corerule_four (val a b c d e: value) : knows val -> val = prim (CONCAT5 a b c d e) -> knows d", - "| concat5_corerule_fives (val a b c d e: value) : knows val -> val = prim (CONCAT5 a b c d e) -> knows e", - "", - "(*hashing primitives*)", - "| hash1_constructor (a out: value) : knows a -> out = prim(HASH1 a) -> knows out", - "| hash2_constructor (a b out: value) : knows a -> knows b -> out = prim(HASH2 a b) -> knows out", - "| hash3_constructor (a b c out: value) : knows a -> knows b -> knows c -> out = prim(HASH3 a b c) -> knows out", - "| hash4_constructor (a b c d out: value) : knows a -> knows b -> knows c -> knows d -> out = prim(HASH4 a b c d) -> knows out", - "| hash5_constructor (a b c d e out: value) : knows a -> knows b -> knows c -> knows d -> knows e -> out = prim(HASH5 a b c d e) -> knows out", - "| mac_constructor (a b out: value) : knows a -> knows b -> out = prim(MAC a b) -> knows out", - "| hkdf1_constructor (salt ikm info out: value) : knows salt -> knows ikm -> knows info", - " -> out = prim(HKDF1 salt ikm info) -> knows out", - "| hkdf2_constructor (salt ikm info out: value) : knows salt -> knows ikm -> knows info", - " -> out = prim(HKDF2 salt ikm info) -> knows out", - "| hkdf3_constructor (salt ikm info out: value) : knows salt -> knows ikm -> knows info", - " -> out = prim(HKDF3 salt ikm info) -> knows out", - "| hkdf4_constructor (salt ikm info out: value) : knows salt -> knows ikm -> knows info", - " -> out = prim(HKDF4 salt ikm info) -> knows out", - "| hkdf5_constructor (salt ikm info out: value) : knows salt -> knows ikm -> knows info", - " -> out = prim(HKDF5 salt ikm info) -> knows out", - " |pw_hash1_constructor (a out: value) : knows a -> out = prim(PW_HASH1 a) -> knows out", - " |pw_hash2_constructor (a b out: value) : knows a -> knows b -> out = prim(PW_HASH2 a b) -> knows out", - " |pw_hash3_constructor (a b c out: value) : knows a -> knows b -> knows c -> out = prim(PW_HASH3 a b c) -> knows out", - " |pw_hash4_constructor (a b c d out: value) : knows a -> knows b -> knows c -> knows d -> out = prim(PW_HASH4 a b c d) -> knows out", - " |pw_hash5_constructor (a b c d e out: value) : knows a -> knows b -> knows c -> knows d -> knows e -> out = prim(PW_HASH5 a b c d e) -> knows out", - "", - "(*encryption primitives*)", - " (*symmetric encryption*)", - "| enc_constructor (k m out: value) : knows k -> knows m -> out = prim(ENC k m) -> knows out", - "| enc_decomposerule (k c m : value) : knows k -> knows c -> c = prim(ENC k m) -> knows m", - "| dec_constructor (k c m out: value) : knows k -> knows c -> c = prim(ENC k m)", - " -> out = prim(DEC k c) -> knows out", - "| dec_rewriterule (c k m: value) : knows c -> c = prim(DEC k (prim(ENC k m))) -> knows m", - " (*authenticated encryption with additional data*)", - "| aead_enc_constructor (k m ad out: value) : knows k -> knows m -> knows ad", - " -> out = prim(AEAD_ENC k m ad) -> knows out", - "| aead_enc_decomposerule (k c ad m: value): knows k -> knows c -> c = prim(AEAD_ENC k m ad)", - " -> knows ad -> knows m", - " (*public key encryption*)", - "| pke_enc_constructor (gk m k out: value): knows gk -> gk = eq(PUBKEY G k) -> knows m", - " -> out = prim(PKE_ENC gk m) -> knows out", - "| pke_enc_decomposerule (k c gk m: value): knows k -> knows gk -> gk = eq(PUBKEY G k)", - " -> knows c -> c = prim(PKE_ENC gk m) -> knows m", - "| pke_dec_constructor(k c gk m out: value): knows k -> knows c -> c = prim(PKE_ENC gk m)", - " -> out = prim(PKE_DEC k (prim(PKE_ENC gk m))) -> knows out", - "| pke_dec_rewriterule(c k m: value): knows c -> c = prim(PKE_DEC k (prim(PKE_ENC (eq(PUBKEY G k))m)))", - " -> knows m", - "", - "(*signature primitives*)", - " (*classical digital signatures*)", - "| sign_constructor(k m out: value): knows k -> knows m -> out = prim(SIGN k m) -> knows out", - "| signverif_constructor(gk m s k out: value): knows gk -> gk = eq(PUBKEY G k) -> knows m -> knows s -> ", - " s = prim(SIGN k m) -> out = prim(SIGNVERIF gk m s) -> knows out", - "| signverif_rewriterule(val k m s: value): knows val -> val = prim(SIGNVERIF (eq(PUBKEY G k)) m (prim(SIGN k m))) -> knows m", - "", - " (*ring signatures*)", - "| ringsign_constructor(ka gkb gkc m kb kc out: value): knows ka -> knows gkb -> gkb = eq(PUBKEY G kb) ->", - " knows gkc -> gkc = eq(PUBKEY G kc) -> knows m -> out = prim(RINGSIGN ka gkb gkc m) -> knows out", - "", - " (*unsure about ringsignverif*)", - " (*todo: ringsignverif_constructor*)", - "| ringsignverif_constructor(gka gkb gkc m s out ka kb kc: value): knows gka -> gka = eq(PUBKEY G ka)", - " -> knows gkb -> gkb = eq(PUBKEY G kb) -> knows gkc -> gkc = eq(PUBKEY G kc) -> knows m", - " -> knows s -> s = prim(RINGSIGN ka gkb gkc m) -> out = prim(RINGSIGNVERIF gka gkb gkc m s) -> knows out", - "| ringsignverif_rewriterule(gka gkb gkc m s ka kb kc: value): knows gka -> gka = eq(PUBKEY G ka) -> knows gkb -> gkb = eq(PUBKEY G kb)", - " -> knows gkc -> gkc = eq(PUBKEY G kc) -> knows m -> knows s -> s = prim(RINGSIGN ka gkb gkc m) -> knows m", - "", - " (*blind signatures*)", - "| blind_constructor(k m out: value): knows k -> knows m -> out = prim(BLIND k m) -> knows out", - "| blind_decomposerule(k b m: value): knows k -> knows b -> b = prim(BLIND k m) -> knows m", - "| unblind_constructor(k m s a out: value): knows k -> knows m -> knows s -> ", - " s = prim(SIGN a (prim(BLIND k m))) -> out = prim(UNBLIND k m s) -> knows out", - "| unblind_rewriterule(u k m a out: value): knows u ->", - " u = prim(UNBLIND k m (prim(SIGN a (prim(BLIND k m))))) -> out = prim(SIGN a m) -> knows out", - "", - "(*secret sharing*)", - " (*unsure about shamir_split/shamir_join*)", - "| shamir_split1_constructor(k out: value): knows k -> out = prim(SHAMIR_SPLIT1 k) -> knows out", - "| shamir_split2_constructor(k out: value): knows k -> out = prim(SHAMIR_SPLIT2 k) -> knows out", - "| shamir_split3_constructor(k out: value): knows k -> out = prim(SHAMIR_SPLIT3 k) -> knows out", - " (*todo: shamir_split_recomposerule*)", - " (*todo: shamir_join_constructor*)", - " (*todo: shamir_join_rebuildrule*).", - "", - "Lemma concat2_rule : forall (a b val : value),", - " knows val -> val = prim (CONCAT2 a b) ->", - " (knows a * knows b)%type.", - "Proof using.", - " intros a b val Hk Hv.", - " pose proof (concat2_corerule_one _ _ _ Hk Hv).", - " pose proof (concat2_corerule_two _ _ _ Hk Hv).", - " auto.", - "Qed.", - "", - "Lemma concat2_cons_rule : forall (a b val : value), knows a -> knows b -> val = prim (CONCAT2 a b) ->", - " knows val.", - "Proof using.", - " intros. apply concat2_constructor with (a := a) (b := b); assumption.", - "Qed.", - "", - "Theorem insecure : forall (a c m k : value), knows c -> knows a -> k = prim (HASH1 a) ->", - " c = prim (ENC k m) -> knows m.", - "Proof using.", - " intros.", - " pose proof (hash1_constructor _ _ H0 H1).", - " apply enc_decomposerule with (k := k) (c := c); assumption.", - "Qed.", - "", - " (* the task is to come up with natural deduction style rules for \"knows\"*)", - "", - "Fixpoint value_beq (v1 v2: value) : bool := ", - " match v1, v2 with", - " | const c1, const c2 => match c1, c2 with", - " | cnstn a, cnstn a' => eqb a a'", - " | Nil, Nil => true", - " | _, _ => false", - " end", - " | eq e1, eq e2 => match e1, e2 with", - " | PUBKEY g1 k1, PUBKEY g2 k2 => value_beq k1 k2", - " | DH _ exp1 exp2, DH _ exp1' exp2' => ((value_beq exp1 exp1') && (value_beq exp2 exp2')) || ((value_beq exp1 exp2') && (value_beq exp2 exp1'))", - " | _, _ => false", - " end", - " | prim p1, prim p2 => match p1, p2 with", - " | ENC k1 m1, ENC k2 m2 => (value_beq k1 k2) && (value_beq m1 m2)", - " | DEC k1 e1, DEC k2 e2 => (value_beq k1 k2) && (value_beq e1 e2)", - " | AEAD_ENC k1 m1 ad1, AEAD_ENC k2 m2 ad2 => ((value_beq k1 k2) && (value_beq m1 m2)) && (value_beq ad1 ad2)", - " | AEAD_DEC k1 e1 ad1, AEAD_DEC k2 e2 ad2 => ((value_beq k1 k2) && (value_beq e1 e2)) && (value_beq ad1 ad2)", - " | PKE_ENC gk1 m1, PKE_ENC gk2 m2 => (value_beq gk1 gk2) && (value_beq m1 m2)", - " | PKE_DEC k1 e1, PKE_DEC k2 e2 => (value_beq k1 k2) && (value_beq e1 e2)", - " | HASH1 a1, HASH1 a2 => value_beq a1 a2", - " | HASH2 a1 b1, HASH2 a2 b2 => (value_beq a1 a2) && (value_beq b1 b2)", - " | HASH3 a1 b1 c1, HASH3 a2 b2 c2 => ((value_beq a1 a2) && (value_beq b1 b2)) && (value_beq c1 c2)", - " | HASH4 a1 b1 c1 d1, HASH4 a2 b2 c2 d2 => ((value_beq a1 a2) && (value_beq b1 b2)) && ((value_beq c1 c2) && (value_beq d1 d2))", - " | HASH5 a1 b1 c1 d1 e1, HASH5 a2 b2 c2 d2 e2 => (((value_beq a1 a2) && (value_beq b1 b2)) && ((value_beq c1 c2) && (value_beq d1 d2))) && (value_beq e1 e2)", - " | MAC a1 b1, MAC a2 b2 => (value_beq a1 a2) && (value_beq b1 b2)", - " | HKDF1 s1 k1 i1, HKDF1 s2 k2 i2 => ((value_beq s1 s2) && (value_beq k1 k2)) && (value_beq i1 i2)", - " | HKDF2 s1 k1 i1, HKDF2 s2 k2 i2 => ((value_beq s1 s2) && (value_beq k1 k2)) && (value_beq i1 i2)", - " | HKDF3 s1 k1 i1, HKDF3 s2 k2 i2 => ((value_beq s1 s2) && (value_beq k1 k2)) && (value_beq i1 i2)", - " | HKDF4 s1 k1 i1, HKDF4 s2 k2 i2 => ((value_beq s1 s2) && (value_beq k1 k2)) && (value_beq i1 i2)", - " | HKDF5 s1 k1 i1, HKDF5 s2 k2 i2 => ((value_beq s1 s2) && (value_beq k1 k2)) && (value_beq i1 i2)", - " | PW_HASH1 a1, PW_HASH1 a2 => value_beq a1 a2", - " | PW_HASH2 a1 b1, PW_HASH2 a2 b2 => (value_beq a1 a2) && (value_beq b1 b2)", - " | PW_HASH3 a1 b1 c1, PW_HASH3 a2 b2 c2 => ((value_beq a1 a2) && (value_beq b1 b2)) && (value_beq c1 c2)", - " | PW_HASH4 a1 b1 c1 d1, PW_HASH4 a2 b2 c2 d2 => ((value_beq a1 a2) && (value_beq b1 b2)) && ((value_beq c1 c2) && (value_beq d1 d2))", - " | PW_HASH5 a1 b1 c1 d1 e1, PW_HASH5 a2 b2 c2 d2 e2 => (((value_beq a1 a2) && (value_beq b1 b2)) && ((value_beq c1 c2) && (value_beq d1 d2))) && (value_beq e1 e2)", - " | SIGN k1 m1, SIGN k2 m2 => (value_beq k1 k2) && (value_beq m1 m2)", - " | SIGNVERIF gk m s, SIGNVERIF gk' m' s' => ((value_beq gk gk') && (value_beq m m')) && (value_beq s s')", - " | RINGSIGN ka1 gkb1 gkc1 m1, RINGSIGN ka2 gkb2 gkc2 m2 => ((value_beq ka1 ka2) && (value_beq gkb1 gkb2)) && (", - " (value_beq gkc1 gkc2) && (value_beq m1 m2))", - " | RINGSIGNVERIF gka1 gkb1 gkc1 m1 s1, RINGSIGNVERIF gka2 gkb2 gkc2 m2 s2 => ", - " (((value_beq gka1 gka2) && (value_beq gkb1 gkb2)) && ((value_beq gkc1 gkc2) && (value_beq m1 m2))) && (value_beq s1 s2)", - " | SHAMIR_SPLIT1 k1, SHAMIR_SPLIT1 k2 => value_beq k1 k2", - " | SHAMIR_SPLIT2 k1, SHAMIR_SPLIT2 k2 => value_beq k1 k2", - " | SHAMIR_SPLIT3 k1, SHAMIR_SPLIT3 k2 => value_beq k1 k2", - " | SHAMIR_JOIN sa1 sb1, SHAMIR_JOIN sa2 sb2 => (value_beq sa1 sa2) && (value_beq sb1 sb2)", - " | CONCAT2 a1 b1, CONCAT2 a2 b2 => (value_beq a1 a2) && (value_beq b1 b2)", - " | CONCAT3 a1 b1 c1, CONCAT3 a2 b2 c2 => ((value_beq a1 a2) && (value_beq b1 b2)) && (value_beq c1 c2)", - " | CONCAT4 a1 b1 c1 d1, CONCAT4 a2 b2 c2 d2 => ((value_beq a1 a2) && (value_beq b1 b2)) && ((value_beq c1 c2) && (value_beq d1 d2))", - " | CONCAT5 a1 b1 c1 d1 e1, CONCAT5 a2 b2 c2 d2 e2 => (((value_beq a1 a2) && (value_beq b1 b2)) && ((value_beq c1 c2) && (value_beq d1 d2))) && (value_beq e1 e2)", - " | SPLIT1 a1, SPLIT1 a2 => value_beq a1 a2", - " | SPLIT2 a1, SPLIT2 a2 => value_beq a1 a2", - " | SPLIT3 a1, SPLIT3 a2 => value_beq a1 a2", - " | SPLIT4 a1, SPLIT4 a2 => value_beq a1 a2", - " | SPLIT5 a1, SPLIT5 a2 => value_beq a1 a2", - " | _, _ => false", - " end", - " | pass a, pass b => match a, b with", - " | cnstn a, cnstn b => eqb a b", - " | Nil, Nil => true", - " | _ , _ => false", - " end", - " | default, default => true", - " | _, _ => false", - " end.", - "", - "Fixpoint has_nested_value (main v: value) : bool :=", - " match main with", - " | default => false", - " | const _ => value_beq v main", - " | pass _ => value_beq v main", - " | eq e => match e with", - " | PUBKEY _ exp => has_nested_value exp v", - " | DH _ exp1 exp2 => (has_nested_value exp1 v) || (has_nested_value exp2 v)", - " end", - " | prim p => match p with", - " | ENC k m => (has_nested_value k v) || (has_nested_value m v)", - " | DEC k c => (has_nested_value k v) || (has_nested_value c v)", - " | AEAD_ENC k m ad => ((has_nested_value k v) || (has_nested_value m v)) || (has_nested_value ad v)", - " | AEAD_DEC k c ad => ((has_nested_value k v) || (has_nested_value c v)) || (has_nested_value ad v)", - " | PKE_ENC gk m => (has_nested_value gk v) || (has_nested_value m v)", - " | PKE_DEC k m => (has_nested_value k v) || (has_nested_value m v)", - " | HASH1 a => has_nested_value a v", - " | HASH2 a b => (has_nested_value a v) || (has_nested_value b v)", - " | HASH3 a b c => ((has_nested_value a v) || (has_nested_value b v)) || (has_nested_value c v)", - " | HASH4 a b c d => ((has_nested_value a v) || (has_nested_value b v)) || ((has_nested_value c v) || (has_nested_value d v))", - " | HASH5 a b c d e => ((has_nested_value a v) || (has_nested_value b v)) || ((has_nested_value c v) || (has_nested_value d v)) || (has_nested_value e v)", - " | MAC a b => (has_nested_value a v) || (has_nested_value b v)", - " | HKDF1 s k i => ((has_nested_value s v) || (has_nested_value k v)) || (has_nested_value i v)", - " | HKDF2 s k i => ((has_nested_value s v) || (has_nested_value k v)) || (has_nested_value i v)", - " | HKDF3 s k i => ((has_nested_value s v) || (has_nested_value k v)) || (has_nested_value i v)", - " | HKDF4 s k i => ((has_nested_value s v) || (has_nested_value k v)) || (has_nested_value i v)", - " | HKDF5 s k i => ((has_nested_value s v) || (has_nested_value k v)) || (has_nested_value i v)", - " | PW_HASH1 a => has_nested_value a v", - " | PW_HASH2 a b => (has_nested_value a v) || (has_nested_value b v)", - " | PW_HASH3 a b c => ((has_nested_value a v) || (has_nested_value b v)) || (has_nested_value c v)", - " | PW_HASH4 a b c d => ((has_nested_value a v) || (has_nested_value b v)) || ((has_nested_value c v) || (has_nested_value d v))", - " | PW_HASH5 a b c d e => ((has_nested_value a v) || (has_nested_value b v)) || ((has_nested_value c v) || (has_nested_value d v)) || (has_nested_value e v)", - " | SIGN k m => (has_nested_value k v) || (has_nested_value m v)", - " | SIGNVERIF k m s => ((has_nested_value k v) || (has_nested_value m v)) || (has_nested_value s v)", - " | RINGSIGN ka gkb gkc m => ((has_nested_value ka v) || (has_nested_value gkb v)) || ((has_nested_value gkc v) || (has_nested_value m v))", - " | RINGSIGNVERIF ka gkb gkc m s => ((has_nested_value ka v) || (has_nested_value gkb v)) || ((has_nested_value gkc v) || (has_nested_value m v)) || (has_nested_value s v)", - " | BLIND k m => (has_nested_value k v) || (has_nested_value m v)", - " | UNBLIND k m s => ((has_nested_value k v) || (has_nested_value m v)) || (has_nested_value s v) ", - " | SHAMIR_SPLIT1 k => has_nested_value k v", - " | SHAMIR_SPLIT2 k => has_nested_value k v", - " | SHAMIR_SPLIT3 k => has_nested_value k v", - " | SHAMIR_JOIN sa sb => (has_nested_value sa v) || (has_nested_value sb v)", - " | CONCAT2 a b => (has_nested_value a v) || (has_nested_value b v)", - " | CONCAT3 a b c => ((has_nested_value a v) || (has_nested_value b v)) || (has_nested_value c v)", - " | CONCAT4 a b c d => ((has_nested_value a v) || (has_nested_value b v)) || ((has_nested_value c v) || (has_nested_value d v))", - " | CONCAT5 a b c d e => ((has_nested_value a v) || (has_nested_value b v)) || ((has_nested_value c v) || (has_nested_value d v)) || (has_nested_value e v)", - " | SPLIT1 a => has_nested_value a v", - " | SPLIT2 a => has_nested_value a v", - " | SPLIT3 a => has_nested_value a v", - " | SPLIT4 a => has_nested_value a v", - " | SPLIT5 a => has_nested_value a v", - " end", - " end.", - "Definition is_primitive (v: value): bool :=", - " match v with", - " | prim p => true", - " | _ => false", - " end.", - "", - "Definition is_constant (v: value): bool :=", - " match v with", - " | const c => true", - " | _ => false", - " end.", - "", - "Definition is_equation (v: value): bool :=", - " match v with", - " | eq e => true", - " | _ => false", - " end.", - "", - "Fixpoint shallow_search (l: list value) (v: value) : bool :=", - " match l with", - " | [] => false", - " | h :: t => match value_beq h v with", - " | true => true", - " | false => shallow_search t v", - " end", - " end.", - "", - "Definition deep_search (l : list value) (v : value) := filter (fun x => has_nested_value x v) l.", - "Fixpoint remove_value_list (l: list value) (v: value) : list value :=", - " match l with", - " | [] => []", - " | h :: t => match value_beq h v with ", - " | true => t", - " | false => [h] ++ (remove_value_list t v)", - " end", - " end.", - "", - "Fixpoint merge_lists (l1 l2: list value) : list value :=", - " match l1 with", - " | [] => l2", - " | h :: t => [h] ++ (merge_lists t (remove_value_list l2 h))", - " end.", - "", - "Inductive principal : Type :=", - "| PRINCIPAL : string -> list expression -> principal.", - "", - "Inductive message : Type :=", - "| MSG : guard_status -> value -> message.", - "", - "Inductive block : Type :=", - "| pblock : principal -> block", - "| mblock : message -> block.", - "", - "Inductive state : Type :=", - "| STATE: list block -> state.", - "", - "", - "Fixpoint absorb_expression (l: list expression) : list value :=", - " match l with", - " | [] => [] ", - " | h :: t => match h with", - " | EXP dec qual val ls => match qual, ls with", - " | private, not_leaked => absorb_expression t", - " | _, _ => [val] ++ absorb_expression t", - " end", - " end", - " end.", - "", - "Fixpoint has_password (v: value) : list value :=", - " match v with", - " | prim p => match p with", - " | CONCAT2 a b => has_password a ++ has_password b", - " | CONCAT3 a b c => has_password a ++ has_password b ++ has_password c", - " | CONCAT4 a b c d => has_password a ++ has_password b ++ has_password c ++ has_password d", - " | CONCAT5 a b c d e => has_password a ++ has_password b ++ has_password c ++ has_password d ++ has_password e", - " | SPLIT1 a => has_password a", - " | SPLIT2 a => has_password a", - " | SPLIT3 a => has_password a", - " | SPLIT4 a => has_password a", - " | SPLIT5 a => has_password a", - " | PW_HASH1 a => []", - " | PW_HASH2 a b => []", - " | PW_HASH3 a b c => []", - " | PW_HASH4 a b c d => []", - " | PW_HASH5 a b c d e => []", - " | HASH1 a => has_password a", - " | HASH2 a b => has_password a ++ has_password b", - " | HASH3 a b c => has_password a ++ has_password b ++ has_password c", - " | HASH4 a b c d => has_password a ++ has_password b ++ has_password c ++ has_password d", - " | HASH5 a b c d e => has_password a ++ has_password b ++ has_password c ++ has_password d ++ has_password e", - " | HKDF1 salt ikm info => has_password salt ++ has_password ikm ++ has_password info", - " | HKDF2 salt ikm info => has_password salt ++ has_password ikm ++ has_password info", - " | HKDF3 salt ikm info => has_password salt ++ has_password ikm ++ has_password info", - " | HKDF4 salt ikm info => has_password salt ++ has_password ikm ++ has_password info", - " | HKDF5 salt ikm info => has_password salt ++ has_password ikm ++ has_password info", - " | AEAD_ENC k m ad => has_password k ++ has_password ad", - " | AEAD_DEC k c ad => has_password k ++ has_password c ++ has_password ad", - " | ENC k m => has_password k", - " | DEC k c => has_password k ++ has_password c", - " | MAC k m => has_password k", - " | SIGN k m => has_password k", - " | SIGNVERIF k m s => has_password k ++ has_password m ++ has_password s ", - " | PKE_ENC gk m => has_password gk", - " | PKE_DEC k c => has_password k ++ has_password c", - " | SHAMIR_SPLIT1 k => has_password k", - " | SHAMIR_SPLIT2 k => has_password k", - " | SHAMIR_SPLIT3 k => has_password k", - " | SHAMIR_JOIN sa sb => has_password sa ++ has_password sb", - " | RINGSIGN ka gkb gkc m => has_password ka ++ has_password gkb ++ has_password gkc", - " | RINGSIGNVERIF gka gkb gkc m s => has_password gka ++ has_password gkb ++ has_password gkc ++ has_password m ++ has_password s", - " | BLIND k m => has_password k", - " | UNBLIND k m s => has_password k ++ has_password m ++ has_password s", - " end", - " | eq e => match e with", - " | PUBKEY _ exp => has_password exp", - " | DH _ exp1 exp2 => has_password exp1 ++ has_password exp2", - " end", - " | const c => match c with", - " | Nil => []", - " | cnstn c => []", - " end", - " | pass a => [v]", - " | default => []", - "end.", - "", - "Fixpoint absorb_passwords_expression (l: list expression) : list value :=", - " match l with", - " | [] => [] ", - " | h :: t => match h with", - " | EXP dec qual val ls => has_password val ++ absorb_passwords_expression t", - " end", - " end.", - "", - "Definition absorb_principal (p: principal) : list value :=", - " match p with", - " | PRINCIPAL _ pk => merge_lists (absorb_expression pk) (absorb_passwords_expression pk)", - "end.", - "", - "Definition absorb_message (m: message) : value :=", - " match m with", - " | MSG _ val => val", - "end.", - "", - "Definition absorb_block (b: block) : list value :=", - " match b with", - " | pblock p => absorb_principal p", - " | mblock m => [absorb_message m]", - "end.", - "", - "Fixpoint init_attacker (l: list block) : list value := ", - " match l with", - " | [] => []", - " | h :: t => absorb_block h ++ init_attacker t", - "end.", - "", - "Fixpoint gather_principal_expressions (l: list block) (pname: string) : list expression :=", - " match l with", - " | [] => []", - " | h :: t => match h with", - " | mblock _ => gather_principal_expressions t pname", - " | pblock pb => match pb with", - " | PRINCIPAL hpname hplist => match eqb pname hpname with", - " | true => hplist ++ gather_principal_expressions t pname", - " | false => gather_principal_expressions t pname", - " end", - " end", - " end", - " end.", - "", - "Fixpoint gather_principals (pnames: list string) (l: list block) : list principal :=", - " match pnames with ", - " | [] => []", - " | p1 :: r => [PRINCIPAL p1 (gather_principal_expressions l p1)] ++ gather_principals r l", - " end.", - "", - "Fixpoint get_values_expression_list (l: list expression) : list value :=", - " match l with", - " | [] => []", - " | h :: t => match h with", - " | EXP _ _ v _ => [v] ++ get_values_expression_list t", - " end", - " end.", - "", - "Fixpoint gather_principal_values (l: list principal) : list (list value) :=", - " match l with", - " | [] => []", - " | h :: t => match h with", - " | PRINCIPAL pname plist => [get_values_expression_list plist] ++ gather_principal_values t", - " end", - " end.", - "", - "Definition rewrite_diff (old new: value) : value :=", - " match old, new with", - " | const c1, const c2 => match value_beq old new with", - " | true => old", - " | false => new", - " end", - " | pass a1, pass a2 => match value_beq old new with", - " | true => old", - " | false => new", - " end", - " | prim p1, prim p2 => match p1, p2 with", - " | ENC k1 m1, ENC k2 m2 => match value_beq k1 k2, value_beq m1 m2 with", - " | true, true => old", - " | false, true => prim(ENC k2 m1)", - " | true, false => prim(ENC k1 m2)", - " | false, false => new", - " end", - " | DEC k1 c1, DEC k2 c2 => match value_beq k1 k2, value_beq c1 c2 with", - " | true, true => old", - " | false, true => prim(DEC k2 c1)", - " | true, false => prim(DEC k1 c2)", - " | false, false => new", - " end", - " | AEAD_ENC k1 m1 ad1, AEAD_ENC k2 m2 ad2 =>", - " match value_beq k1 k2, value_beq m1 m2, value_beq ad1 ad2 with", - " | true, true, true => old", - " | false, true, true => prim(AEAD_ENC k2 m1 ad1)", - " | true, false, true => prim(AEAD_ENC k1 m2 ad1)", - " | true, true, false => prim(AEAD_ENC k1 m1 ad2)", - " | true, false, false => prim(AEAD_ENC k1 m2 ad2)", - " | false, true, false => prim(AEAD_ENC k2 m1 ad1)", - " | false, false, true => prim(AEAD_ENC k2 m2 ad1)", - " | false, false, false => new", - " end", - " | AEAD_DEC k1 c1 ad1, AEAD_DEC k2 c2 ad2 =>", - " match value_beq k1 k2, value_beq c1 c2, value_beq ad1 ad2 with", - " | true, true, true => old", - " | false, true, true => prim(AEAD_DEC k2 c1 ad1)", - " | true, false, true => prim(AEAD_DEC k1 c2 ad1)", - " | true, true, false => prim(AEAD_DEC k1 c1 ad2)", - " | true, false, false => prim(AEAD_DEC k1 c2 ad2)", - " | false, true, false => prim(AEAD_DEC k2 c1 ad1)", - " | false, false, true => prim(AEAD_DEC k2 c2 ad1)", - " | false, false, false => new", - " end", - " | PKE_ENC gk1 m1, ENC gk2 m2 => match value_beq gk1 gk2, value_beq m1 m2 with", - " | true, true => old", - " | false, true => prim(PKE_ENC gk2 m1)", - " | true, false => prim(PKE_ENC gk1 m2)", - " | false, false => new", - " end", - " | PKE_DEC k1 c1, PKE_DEC k2 c2 => match value_beq k1 k2, value_beq c1 c2 with", - " | true, true => old", - " | false, true => prim(PKE_DEC k2 c1)", - " | true, false => prim(PKE_DEC k1 c2)", - " | false, false => new", - " end", - " | HASH1 a1, HASH1 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | HASH2 a1 b1, HASH2 a2 b2 => match value_beq a1 a2, value_beq b1 b2 with", - " | true, true => old", - " | false, true => prim(HASH2 a2 b1)", - " | true, false => prim(HASH2 a1 b2)", - " | false, false => new", - " end", - " | HASH3 a1 b1 c1, HASH3 a2 b2 c2 =>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2 with", - " | true, true, true => old", - " | false, true, true => prim(HASH3 a2 b1 c1)", - " | true, false, true => prim(HASH3 a1 b2 c1)", - " | true, true, false => prim(HASH3 a1 b1 c2)", - " | true, false, false => prim(HASH3 a1 b2 c2)", - " | false, true, false => prim(HASH3 a2 b1 c1)", - " | false, false, true => prim(HASH3 a2 b2 c1)", - " | false, false, false => new", - " end", - " | HASH4 a1 b1 c1 d1, HASH4 a2 b2 c2 d2 =>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2, value_beq d1 d2 with", - " | true, true, true, true => old", - " | false, true, true, true => prim(HASH4 a2 b1 c1 d1)", - " | true, false, true, true => prim(HASH4 a1 b2 c1 d1)", - " | true, true, false, true => prim(HASH4 a1 b1 c2 d1)", - " | true, true, true, false => prim(HASH4 a1 b1 c1 d2)", - " | false, false, true, true => prim(HASH4 a2 b2 c1 d1)", - " | false, true, false, true => prim(HASH4 a2 b1 c2 d1)", - " | false, true, true, false => prim(HASH4 a2 b1 c1 d2)", - " | true, false, false, true => prim(HASH4 a1 b2 c2 d1)", - " | true, false, true, false => prim(HASH4 a1 b2 c1 d2)", - " | true, true, false, false => prim(HASH4 a1 b1 c2 d2)", - " | true, false, false, false => prim(HASH4 a1 b2 c2 d2)", - " | false, true, false, false => prim(HASH4 a2 b1 c2 d2)", - " | false, false, true, false => prim(HASH4 a2 b2 c1 d2)", - " | false, false, false, true => prim(HASH4 a2 b2 c2 d1)", - " | false, false, false, false => new", - " end", - " | HASH5 a1 b1 c1 d1 e1, HASH5 a2 b2 c2 d2 e2=>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2, value_beq d1 d2, value_beq e1 e2 with", - " | true, true, true, true, true => old", - " | false, true, true, true, true => prim(HASH5 a2 b1 c1 d1 e1)", - " | true, false, true, true, true => prim(HASH5 a1 b2 c1 d1 e1)", - " | true, true, false, true, true => prim(HASH5 a1 b1 c2 d1 e1)", - " | true, true, true, false, true => prim(HASH5 a1 b1 c1 d2 e1)", - " | true, true, true, true, false => prim(HASH5 a1 b1 c1 d1 e2)", - " | false, false, true, true, true => prim(HASH5 a2 b2 c1 d1 e1)", - " | false, true, false, true, true => prim(HASH5 a2 b1 c2 d1 e1)", - " | false, true, true, false, true => prim(HASH5 a2 b1 c1 d2 e1)", - " | false, true, true, true, false => prim(HASH5 a2 b1 c1 d1 e2)", - " | true, false, false, true, true => prim(HASH5 a1 b2 c2 d1 e1)", - " | true, false, true, false, true => prim(HASH5 a1 b2 c1 d2 e1)", - " | true, false, true, true, false => prim(HASH5 a1 b2 c1 d1 e2)", - " | true, true, false, false, true => prim(HASH5 a1 b1 c2 d2 e1)", - " | true, true, false, true, false => prim(HASH5 a1 b1 c2 d1 e2)", - " | true, true, true, false, false => prim(HASH5 a1 b1 c1 d2 e2)", - " | true, true, false, false, false => prim(HASH5 a1 b1 c2 d2 e2)", - " | true, false, true, false, false => prim(HASH5 a1 b2 c1 d2 e2)", - " | true, false, false, true, false => prim(HASH5 a1 b2 c2 d1 e2)", - " | true, false, false, false, true => prim(HASH5 a1 b2 c2 d2 e1)", - " | false, true, true, false, false => prim(HASH5 a2 b1 c1 d2 e2)", - " | false, true, false, true, false => prim(HASH5 a2 b1 c2 d1 e2)", - " | false, true, false, false, true => prim(HASH5 a2 b1 c2 d2 e1)", - " | false, false, true, true, false => prim(HASH5 a2 b2 c1 d1 e2)", - " | false, false, true, false, true => prim(HASH5 a2 b2 c1 d2 e1)", - " | false, false, false, true, true => prim(HASH5 a2 b2 c2 d1 e1)", - " | true, false, false, false, false => prim(HASH5 a1 b2 c2 d2 e2)", - " | false, true, false, false, false => prim(HASH5 a2 b1 c2 d2 e2)", - " | false, false, true, false, false => prim(HASH5 a2 b2 c1 d2 e2)", - " | false, false, false, true, false => prim(HASH5 a2 b2 c2 d1 e2)", - " | false, false, false, false, true => prim(HASH5 a2 b2 c2 d2 e1)", - " | false, false, false, false, false => new", - " end", - " | MAC k1 m1, MAC k2 m2 => match value_beq k1 k2, value_beq m1 m2 with", - " | true, true => old", - " | false, true => prim(MAC k2 m1)", - " | true, false => prim(MAC k1 m2)", - " | false, false => new", - " end", - " | HKDF1 salt1 ikm1 info1, HKDF1 salt2 ikm2 info2 =>", - " match value_beq salt1 salt2, value_beq ikm1 ikm2, value_beq info1 info2 with", - " | true, true, true => old", - " | false, true, true => prim(HKDF1 salt2 ikm1 info1)", - " | true, false, true => prim(HKDF1 salt1 ikm2 info1)", - " | true, true, false => prim(HKDF1 salt1 ikm1 info2)", - " | true, false, false => prim(HKDF1 salt1 ikm2 info2)", - " | false, true, false => prim(HKDF1 salt2 ikm1 info1)", - " | false, false, true => prim(HKDF1 salt2 ikm2 info1)", - " | false, false, false => new", - " end", - " | HKDF2 salt1 ikm1 info1, HKDF2 salt2 ikm2 info2 =>", - " match value_beq salt1 salt2, value_beq ikm1 ikm2, value_beq info1 info2 with", - " | true, true, true => old", - " | false, true, true => prim(HKDF2 salt2 ikm1 info1)", - " | true, false, true => prim(HKDF2 salt1 ikm2 info1)", - " | true, true, false => prim(HKDF2 salt1 ikm1 info2)", - " | true, false, false => prim(HKDF2 salt1 ikm2 info2)", - " | false, true, false => prim(HKDF2 salt2 ikm1 info1)", - " | false, false, true => prim(HKDF2 salt2 ikm2 info1)", - " | false, false, false => new", - " end", - " | HKDF3 salt1 ikm1 info1, HKDF3 salt2 ikm2 info2 =>", - " match value_beq salt1 salt2, value_beq ikm1 ikm2, value_beq info1 info2 with", - " | true, true, true => old", - " | false, true, true => prim(HKDF3 salt2 ikm1 info1)", - " | true, false, true => prim(HKDF3 salt1 ikm2 info1)", - " | true, true, false => prim(HKDF3 salt1 ikm1 info2)", - " | true, false, false => prim(HKDF3 salt1 ikm2 info2)", - " | false, true, false => prim(HKDF3 salt2 ikm1 info1)", - " | false, false, true => prim(HKDF3 salt2 ikm2 info1)", - " | false, false, false => new", - " end", - " | HKDF4 salt1 ikm1 info1, HKDF4 salt2 ikm2 info2 =>", - " match value_beq salt1 salt2, value_beq ikm1 ikm2, value_beq info1 info2 with", - " | true, true, true => old", - " | false, true, true => prim(HKDF4 salt2 ikm1 info1)", - " | true, false, true => prim(HKDF4 salt1 ikm2 info1)", - " | true, true, false => prim(HKDF4 salt1 ikm1 info2)", - " | true, false, false => prim(HKDF4 salt1 ikm2 info2)", - " | false, true, false => prim(HKDF4 salt2 ikm1 info1)", - " | false, false, true => prim(HKDF4 salt2 ikm2 info1)", - " | false, false, false => new", - " end", - " | HKDF5 salt1 ikm1 info1, HKDF5 salt2 ikm2 info2 =>", - " match value_beq salt1 salt2, value_beq ikm1 ikm2, value_beq info1 info2 with", - " | true, true, true => old", - " | false, true, true => prim(HKDF5 salt2 ikm1 info1)", - " | true, false, true => prim(HKDF5 salt1 ikm2 info1)", - " | true, true, false => prim(HKDF5 salt1 ikm1 info2)", - " | true, false, false => prim(HKDF5 salt1 ikm2 info2)", - " | false, true, false => prim(HKDF5 salt2 ikm1 info1)", - " | false, false, true => prim(HKDF5 salt2 ikm2 info1)", - " | false, false, false => new", - " end", - " | PW_HASH1 a1, PW_HASH1 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | PW_HASH2 a1 b1, PW_HASH2 a2 b2 => match value_beq a1 a2, value_beq b1 b2 with", - " | true, true => old", - " | false, true => prim(PW_HASH2 a2 b1)", - " | true, false => prim(PW_HASH2 a1 b2)", - " | false, false => new", - " end", - " | PW_HASH3 a1 b1 c1, PW_HASH3 a2 b2 c2 =>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2 with", - " | true, true, true => old", - " | false, true, true => prim(PW_HASH3 a2 b1 c1)", - " | true, false, true => prim(PW_HASH3 a1 b2 c1)", - " | true, true, false => prim(PW_HASH3 a1 b1 c2)", - " | true, false, false => prim(PW_HASH3 a1 b2 c2)", - " | false, true, false => prim(PW_HASH3 a2 b1 c1)", - " | false, false, true => prim(PW_HASH3 a2 b2 c1)", - " | false, false, false => new", - " end", - " | PW_HASH4 a1 b1 c1 d1, PW_HASH4 a2 b2 c2 d2 =>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2, value_beq d1 d2 with", - " | true, true, true, true => old", - " | false, true, true, true => prim(PW_HASH4 a2 b1 c1 d1)", - " | true, false, true, true => prim(PW_HASH4 a1 b2 c1 d1)", - " | true, true, false, true => prim(PW_HASH4 a1 b1 c2 d1)", - " | true, true, true, false => prim(PW_HASH4 a1 b1 c1 d2)", - " | false, false, true, true => prim(PW_HASH4 a2 b2 c1 d1)", - " | false, true, false, true => prim(PW_HASH4 a2 b1 c2 d1)", - " | false, true, true, false => prim(PW_HASH4 a2 b1 c1 d2)", - " | true, false, false, true => prim(PW_HASH4 a1 b2 c2 d1)", - " | true, false, true, false => prim(PW_HASH4 a1 b2 c1 d2)", - " | true, true, false, false => prim(PW_HASH4 a1 b1 c2 d2)", - " | true, false, false, false => prim(PW_HASH4 a1 b2 c2 d2)", - " | false, true, false, false => prim(PW_HASH4 a2 b1 c2 d2)", - " | false, false, true, false => prim(PW_HASH4 a2 b2 c1 d2)", - " | false, false, false, true => prim(PW_HASH4 a2 b2 c2 d1)", - " | false, false, false, false => new", - " end", - " | PW_HASH5 a1 b1 c1 d1 e1, PW_HASH5 a2 b2 c2 d2 e2=>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2, value_beq d1 d2, value_beq e1 e2 with", - " | true, true, true, true, true => old", - " | false, true, true, true, true => prim(PW_HASH5 a2 b1 c1 d1 e1)", - " | true, false, true, true, true => prim(PW_HASH5 a1 b2 c1 d1 e1)", - " | true, true, false, true, true => prim(PW_HASH5 a1 b1 c2 d1 e1)", - " | true, true, true, false, true => prim(PW_HASH5 a1 b1 c1 d2 e1)", - " | true, true, true, true, false => prim(PW_HASH5 a1 b1 c1 d1 e2)", - " | false, false, true, true, true => prim(PW_HASH5 a2 b2 c1 d1 e1)", - " | false, true, false, true, true => prim(PW_HASH5 a2 b1 c2 d1 e1)", - " | false, true, true, false, true => prim(PW_HASH5 a2 b1 c1 d2 e1)", - " | false, true, true, true, false => prim(PW_HASH5 a2 b1 c1 d1 e2)", - " | true, false, false, true, true => prim(PW_HASH5 a1 b2 c2 d1 e1)", - " | true, false, true, false, true => prim(PW_HASH5 a1 b2 c1 d2 e1)", - " | true, false, true, true, false => prim(PW_HASH5 a1 b2 c1 d1 e2)", - " | true, true, false, false, true => prim(PW_HASH5 a1 b1 c2 d2 e1)", - " | true, true, false, true, false => prim(PW_HASH5 a1 b1 c2 d1 e2)", - " | true, true, true, false, false => prim(PW_HASH5 a1 b1 c1 d2 e2)", - " | true, true, false, false, false => prim(PW_HASH5 a1 b1 c2 d2 e2)", - " | true, false, true, false, false => prim(PW_HASH5 a1 b2 c1 d2 e2)", - " | true, false, false, true, false => prim(PW_HASH5 a1 b2 c2 d1 e2)", - " | true, false, false, false, true => prim(PW_HASH5 a1 b2 c2 d2 e1)", - " | false, true, true, false, false => prim(PW_HASH5 a2 b1 c1 d2 e2)", - " | false, true, false, true, false => prim(PW_HASH5 a2 b1 c2 d1 e2)", - " | false, true, false, false, true => prim(PW_HASH5 a2 b1 c2 d2 e1)", - " | false, false, true, true, false => prim(PW_HASH5 a2 b2 c1 d1 e2)", - " | false, false, true, false, true => prim(PW_HASH5 a2 b2 c1 d2 e1)", - " | false, false, false, true, true => prim(PW_HASH5 a2 b2 c2 d1 e1)", - " | true, false, false, false, false => prim(PW_HASH5 a1 b2 c2 d2 e2)", - " | false, true, false, false, false => prim(PW_HASH5 a2 b1 c2 d2 e2)", - " | false, false, true, false, false => prim(PW_HASH5 a2 b2 c1 d2 e2)", - " | false, false, false, true, false => prim(PW_HASH5 a2 b2 c2 d1 e2)", - " | false, false, false, false, true => prim(PW_HASH5 a2 b2 c2 d2 e1)", - " | false, false, false, false, false => new", - " end", - " | SIGN k1 m1, SIGN k2 m2 => match value_beq k1 k2, value_beq m1 m2 with", - " | true, true => old", - " | false, true => prim(SIGN k2 m1)", - " | true, false => prim(SIGN k1 m2)", - " | false, false => new", - " end", - " | SIGNVERIF k1 m1 s1, SIGNVERIF k2 m2 s2 =>", - " match value_beq k1 k2, value_beq m1 m2, value_beq s1 s2 with", - " | true, true, true => old", - " | false, true, true => prim(SIGNVERIF k2 m1 s1)", - " | true, false, true => prim(SIGNVERIF k1 m2 s1)", - " | true, true, false => prim(SIGNVERIF k1 m1 s2)", - " | true, false, false => prim(SIGNVERIF k1 m2 s2)", - " | false, true, false => prim(SIGNVERIF k2 m1 s1)", - " | false, false, true => prim(SIGNVERIF k2 m2 s1)", - " | false, false, false => new", - " end", - " | RINGSIGN ka1 gkb1 gkc1 m1, RINGSIGN ka2 gkb2 gkc2 m2 =>", - " match value_beq ka1 ka2, value_beq gkb1 gkb2, value_beq gkc1 gkc2, value_beq m1 m2 with", - " | true, true, true, true => old", - " | false, true, true, true => prim(RINGSIGN ka2 gkb1 gkc1 m1)", - " | true, false, true, true => prim(RINGSIGN ka1 gkb2 gkc1 m1)", - " | true, true, false, true => prim(RINGSIGN ka1 gkb1 gkc2 m1)", - " | true, true, true, false => prim(RINGSIGN ka1 gkb1 gkc1 m2)", - " | false, false, true, true => prim(RINGSIGN ka2 gkb2 gkc1 m1)", - " | false, true, false, true => prim(RINGSIGN ka2 gkb1 gkc2 m1)", - " | false, true, true, false => prim(RINGSIGN ka2 gkb1 gkc1 m2)", - " | true, false, false, true => prim(RINGSIGN ka1 gkb2 gkc2 m1)", - " | true, false, true, false => prim(RINGSIGN ka1 gkb2 gkc1 m2)", - " | true, true, false, false => prim(RINGSIGN ka1 gkb1 gkc2 m2)", - " | true, false, false, false => prim(RINGSIGN ka1 gkb2 gkc2 m2)", - " | false, true, false, false => prim(RINGSIGN ka2 gkb1 gkc2 m2)", - " | false, false, true, false => prim(RINGSIGN ka2 gkb2 gkc1 m2)", - " | false, false, false, true => prim(RINGSIGN ka2 gkb2 gkc2 m1)", - " | false, false, false, false => new", - " end", - " | RINGSIGNVERIF gka1 gkb1 gkc1 m1 s1, RINGSIGNVERIF gka2 gkb2 gkc2 m2 s2=>", - " match value_beq gka1 gka2, value_beq gkb1 gkb2, value_beq gkc1 gkc2, value_beq m1 m2, value_beq s1 s2 with", - " | true, true, true, true, true => old", - " | false, true, true, true, true => prim(RINGSIGNVERIF gka2 gkb1 gkc1 m1 s1)", - " | true, false, true, true, true => prim(RINGSIGNVERIF gka1 gkb2 gkc1 m1 s1)", - " | true, true, false, true, true => prim(RINGSIGNVERIF gka1 gkb1 gkc2 m1 s1)", - " | true, true, true, false, true => prim(RINGSIGNVERIF gka1 gkb1 gkc1 m2 s1)", - " | true, true, true, true, false => prim(RINGSIGNVERIF gka1 gkb1 gkc1 m1 s2)", - " | false, false, true, true, true => prim(RINGSIGNVERIF gka2 gkb2 gkc1 m1 s1)", - " | false, true, false, true, true => prim(RINGSIGNVERIF gka2 gkb1 gkc2 m1 s1)", - " | false, true, true, false, true => prim(RINGSIGNVERIF gka2 gkb1 gkc1 m2 s1)", - " | false, true, true, true, false => prim(RINGSIGNVERIF gka2 gkb1 gkc1 m1 s2)", - " | true, false, false, true, true => prim(RINGSIGNVERIF gka1 gkb2 gkc2 m1 s1)", - " | true, false, true, false, true => prim(RINGSIGNVERIF gka1 gkb2 gkc1 m2 s1)", - " | true, false, true, true, false => prim(RINGSIGNVERIF gka1 gkb2 gkc1 m1 s2)", - " | true, true, false, false, true => prim(RINGSIGNVERIF gka1 gkb1 gkc2 m2 s1)", - " | true, true, false, true, false => prim(RINGSIGNVERIF gka1 gkb1 gkc2 m1 s2)", - " | true, true, true, false, false => prim(RINGSIGNVERIF gka1 gkb1 gkc1 m2 s2)", - " | true, true, false, false, false => prim(RINGSIGNVERIF gka1 gkb1 gkc2 m2 s2)", - " | true, false, true, false, false => prim(RINGSIGNVERIF gka1 gkb2 gkc1 m2 s2)", - " | true, false, false, true, false => prim(RINGSIGNVERIF gka1 gkb2 gkc2 m1 s2)", - " | true, false, false, false, true => prim(RINGSIGNVERIF gka1 gkb2 gkc2 m2 s1)", - " | false, true, true, false, false => prim(RINGSIGNVERIF gka2 gkb1 gkc1 m2 s2)", - " | false, true, false, true, false => prim(RINGSIGNVERIF gka2 gkb1 gkc2 m1 s2)", - " | false, true, false, false, true => prim(RINGSIGNVERIF gka2 gkb1 gkc2 m2 s1)", - " | false, false, true, true, false => prim(RINGSIGNVERIF gka2 gkb2 gkc1 m1 s2)", - " | false, false, true, false, true => prim(RINGSIGNVERIF gka2 gkb2 gkc1 m2 s1)", - " | false, false, false, true, true => prim(RINGSIGNVERIF gka2 gkb2 gkc2 m1 s1)", - " | true, false, false, false, false => prim(RINGSIGNVERIF gka1 gkb2 gkc2 m2 s2)", - " | false, true, false, false, false => prim(RINGSIGNVERIF gka2 gkb1 gkc2 m2 s2)", - " | false, false, true, false, false => prim(RINGSIGNVERIF gka2 gkb2 gkc1 m2 s2)", - " | false, false, false, true, false => prim(RINGSIGNVERIF gka2 gkb2 gkc2 m1 s2)", - " | false, false, false, false, true => prim(RINGSIGNVERIF gka2 gkb2 gkc2 m2 s1)", - " | false, false, false, false, false => new", - " end", - " | BLIND k1 m1, BLIND k2 m2 => match value_beq k1 k2, value_beq m1 m2 with", - " | true, true => old", - " | false, true => prim(BLIND k2 m1)", - " | true, false => prim(BLIND k1 m2)", - " | false, false => new", - " end", - " | UNBLIND k1 m1 s1, UNBLIND k2 m2 s2 =>", - " match value_beq k1 k2, value_beq m1 m2, value_beq s1 s2 with", - " | true, true, true => old", - " | false, true, true => prim(UNBLIND k2 m1 s1)", - " | true, false, true => prim(UNBLIND k1 m2 s1)", - " | true, true, false => prim(UNBLIND k1 m1 s2)", - " | true, false, false => prim(UNBLIND k1 m2 s2)", - " | false, true, false => prim(UNBLIND k2 m1 s1)", - " | false, false, true => prim(UNBLIND k2 m2 s1)", - " | false, false, false => new", - " end", - " | SHAMIR_SPLIT1 a1, SHAMIR_SPLIT1 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | SHAMIR_SPLIT2 a1, SHAMIR_SPLIT2 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | SHAMIR_SPLIT3 a1, SHAMIR_SPLIT3 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | SHAMIR_JOIN sa1 sb1, SHAMIR_JOIN sa2 sb2 => match value_beq sa1 sa2, value_beq sb1 sb2 with", - " | true, true => old", - " | false, true => prim(SHAMIR_JOIN sa2 sb1)", - " | true, false => prim(SHAMIR_JOIN sa1 sb2)", - " | false, false => new", - " end", - " | CONCAT2 a1 b1, CONCAT2 a2 b2 => match value_beq a1 a2, value_beq b1 b2 with", - " | true, true => old", - " | false, true => prim(CONCAT2 a2 b1)", - " | true, false => prim(CONCAT2 a1 b2)", - " | false, false => new", - " end", - " | CONCAT3 a1 b1 c1, CONCAT3 a2 b2 c2 =>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2 with", - " | true, true, true => old", - " | false, true, true => prim(CONCAT3 a2 b1 c1)", - " | true, false, true => prim(CONCAT3 a1 b2 c1)", - " | true, true, false => prim(CONCAT3 a1 b1 c2)", - " | true, false, false => prim(CONCAT3 a1 b2 c2)", - " | false, true, false => prim(CONCAT3 a2 b1 c1)", - " | false, false, true => prim(CONCAT3 a2 b2 c1)", - " | false, false, false => new", - " end", - " | CONCAT4 a1 b1 c1 d1, CONCAT4 a2 b2 c2 d2 =>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2, value_beq d1 d2 with", - " | true, true, true, true => old", - " | false, true, true, true => prim(CONCAT4 a2 b1 c1 d1)", - " | true, false, true, true => prim(CONCAT4 a1 b2 c1 d1)", - " | true, true, false, true => prim(CONCAT4 a1 b1 c2 d1)", - " | true, true, true, false => prim(CONCAT4 a1 b1 c1 d2)", - " | false, false, true, true => prim(CONCAT4 a2 b2 c1 d1)", - " | false, true, false, true => prim(CONCAT4 a2 b1 c2 d1)", - " | false, true, true, false => prim(CONCAT4 a2 b1 c1 d2)", - " | true, false, false, true => prim(CONCAT4 a1 b2 c2 d1)", - " | true, false, true, false => prim(CONCAT4 a1 b2 c1 d2)", - " | true, true, false, false => prim(CONCAT4 a1 b1 c2 d2)", - " | true, false, false, false => prim(CONCAT4 a1 b2 c2 d2)", - " | false, true, false, false => prim(CONCAT4 a2 b1 c2 d2)", - " | false, false, true, false => prim(CONCAT4 a2 b2 c1 d2)", - " | false, false, false, true => prim(CONCAT4 a2 b2 c2 d1)", - " | false, false, false, false => new", - " end", - " | CONCAT5 a1 b1 c1 d1 e1, CONCAT5 a2 b2 c2 d2 e2=>", - " match value_beq a1 a2, value_beq b1 b2, value_beq c1 c2, value_beq d1 d2, value_beq e1 e2 with", - " | true, true, true, true, true => old", - " | false, true, true, true, true => prim(CONCAT5 a2 b1 c1 d1 e1)", - " | true, false, true, true, true => prim(CONCAT5 a1 b2 c1 d1 e1)", - " | true, true, false, true, true => prim(CONCAT5 a1 b1 c2 d1 e1)", - " | true, true, true, false, true => prim(CONCAT5 a1 b1 c1 d2 e1)", - " | true, true, true, true, false => prim(CONCAT5 a1 b1 c1 d1 e2)", - " | false, false, true, true, true => prim(CONCAT5 a2 b2 c1 d1 e1)", - " | false, true, false, true, true => prim(CONCAT5 a2 b1 c2 d1 e1)", - " | false, true, true, false, true => prim(CONCAT5 a2 b1 c1 d2 e1)", - " | false, true, true, true, false => prim(CONCAT5 a2 b1 c1 d1 e2)", - " | true, false, false, true, true => prim(CONCAT5 a1 b2 c2 d1 e1)", - " | true, false, true, false, true => prim(CONCAT5 a1 b2 c1 d2 e1)", - " | true, false, true, true, false => prim(CONCAT5 a1 b2 c1 d1 e2)", - " | true, true, false, false, true => prim(CONCAT5 a1 b1 c2 d2 e1)", - " | true, true, false, true, false => prim(CONCAT5 a1 b1 c2 d1 e2)", - " | true, true, true, false, false => prim(CONCAT5 a1 b1 c1 d2 e2)", - " | true, true, false, false, false => prim(CONCAT5 a1 b1 c2 d2 e2)", - " | true, false, true, false, false => prim(CONCAT5 a1 b2 c1 d2 e2)", - " | true, false, false, true, false => prim(CONCAT5 a1 b2 c2 d1 e2)", - " | true, false, false, false, true => prim(CONCAT5 a1 b2 c2 d2 e1)", - " | false, true, true, false, false => prim(CONCAT5 a2 b1 c1 d2 e2)", - " | false, true, false, true, false => prim(CONCAT5 a2 b1 c2 d1 e2)", - " | false, true, false, false, true => prim(CONCAT5 a2 b1 c2 d2 e1)", - " | false, false, true, true, false => prim(CONCAT5 a2 b2 c1 d1 e2)", - " | false, false, true, false, true => prim(CONCAT5 a2 b2 c1 d2 e1)", - " | false, false, false, true, true => prim(CONCAT5 a2 b2 c2 d1 e1)", - " | true, false, false, false, false => prim(CONCAT5 a1 b2 c2 d2 e2)", - " | false, true, false, false, false => prim(CONCAT5 a2 b1 c2 d2 e2)", - " | false, false, true, false, false => prim(CONCAT5 a2 b2 c1 d2 e2)", - " | false, false, false, true, false => prim(CONCAT5 a2 b2 c2 d1 e2)", - " | false, false, false, false, true => prim(CONCAT5 a2 b2 c2 d2 e1)", - " | false, false, false, false, false => new", - " end", - " | SPLIT1 a1, SPLIT1 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | SPLIT2 a1, SPLIT2 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | SPLIT3 a1, SPLIT3 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | SPLIT4 a1, SPLIT4 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | SPLIT5 a1, SPLIT5 a2 => match value_beq a1 a2 with", - " | true => old", - " | false => new", - " end", - " | _ , _ => new", - " end", - " | eq e1, eq e2 => match e1, e2 with", - " | PUBKEY _ exp1, PUBKEY _ exp2 => match value_beq exp1 exp2 with", - " | true => old", - " | false => new", - " end", - " | DH _ expa1 expb1, DH _ expa2 expb2 => match value_beq expa1 expa2, value_beq expb1 expb2 with", - " | true, true => old", - " | true, false => eq(DH G expa1 expb2)", - " | false, true => eq(DH G expa2 expb1)", - " | false, false => new", - " end", - " | _ , _ => new", - " end ", - " | _, _ => new ", - "end.", - " ", - "", - "Fixpoint apply_rewrites (l: list value) (v: value) : value := ", - " match v with", - " | default => default", - " | const c => v", - " | pass a => v", - " | eq e => match e with", - " | PUBKEY _ exp => eq(PUBKEY G (apply_rewrites l exp))", - " | DH _ exp1 exp2 => eq(DH G (apply_rewrites l exp1) (apply_rewrites l exp2))", - " end", - " | prim p => match p with", - " | ENC k m => prim(ENC (apply_rewrites l k) (apply_rewrites l m))", - " | DEC k c => match c with", - " | prim p' => match p' with", - " | ENC k' m => match value_beq k k' with ", - " | true => m", - " | false => prim(DEC (apply_rewrites l k) (prim(ENC (apply_rewrites l k) m)))", - " end", - " | _ => prim(DEC (apply_rewrites l k) (apply_rewrites l c))", - " end", - " | _ => prim(DEC (apply_rewrites l k) (apply_rewrites l c)) ", - " end", - " | AEAD_ENC k m ad => prim(AEAD_ENC (apply_rewrites l k) (apply_rewrites l m) (apply_rewrites l ad))", - " | AEAD_DEC k c ad => match c with", - " | prim p' => match p' with", - " | AEAD_ENC k' m ad' => match value_beq k k', value_beq ad ad' with", - " | true, true => m", - " | true, false => prim(AEAD_DEC k c (apply_rewrites l ad))", - " | false, true => prim(AEAD_DEC (apply_rewrites l k) (prim (AEAD_ENC (apply_rewrites l k') m ad)) ad)", - " | false, false => prim(AEAD_DEC (apply_rewrites l k) (prim (AEAD_ENC (apply_rewrites l k') m (apply_rewrites l ad))) (apply_rewrites l ad))", - " end", - " | _ => prim(AEAD_DEC (apply_rewrites l k) (apply_rewrites l c) (apply_rewrites l ad))", - " end", - " | _ => prim(AEAD_DEC (apply_rewrites l k) (apply_rewrites l c) (apply_rewrites l ad))", - " end", - " | PKE_ENC gk m => prim(PKE_ENC (apply_rewrites l gk) (apply_rewrites l m))", - " | PKE_DEC k c => match c with", - " | prim p' => match p' with", - " | PKE_ENC gk m => match gk with", - " | eq e => match e with", - " | PUBKEY _ exp => match value_beq exp k with", - " | true => m", - " | false => prim(PKE_DEC (apply_rewrites l k) (prim(PKE_ENC (apply_rewrites l exp) m)))", - " end", - " | _ => prim(PKE_DEC k (apply_rewrites l c))", - " end", - " | _ => prim(PKE_DEC (apply_rewrites l k) (apply_rewrites l c))", - " end", - " | _ => prim(PKE_DEC (apply_rewrites l k) (apply_rewrites l c))", - " end", - " | _ => prim(PKE_DEC (apply_rewrites l k) (apply_rewrites l c))", - " end", - " | HASH1 a => prim(HASH1 (apply_rewrites l a))", - " | HASH2 a b => prim(HASH2 (apply_rewrites l a) (apply_rewrites l b))", - " | HASH3 a b c => prim(HASH3 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c))", - " | HASH4 a b c d => prim(HASH4 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c) (apply_rewrites l d))", - " | HASH5 a b c d e => prim(HASH5 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c) (apply_rewrites l d) (apply_rewrites l e))", - " | MAC k m => prim(MAC (apply_rewrites l k) (apply_rewrites l m))", - " | HKDF1 salt ikm info => prim(HKDF1 (apply_rewrites l salt) (apply_rewrites l ikm) (apply_rewrites l info))", - " | HKDF2 salt ikm info => prim(HKDF2 (apply_rewrites l salt) (apply_rewrites l ikm) (apply_rewrites l info))", - " | HKDF3 salt ikm info => prim(HKDF3 (apply_rewrites l salt) (apply_rewrites l ikm) (apply_rewrites l info))", - " | HKDF4 salt ikm info => prim(HKDF4 (apply_rewrites l salt) (apply_rewrites l ikm) (apply_rewrites l info))", - " | HKDF5 salt ikm info => prim(HKDF5 (apply_rewrites l salt) (apply_rewrites l ikm) (apply_rewrites l info))", - " | PW_HASH1 a => prim(PW_HASH1 (apply_rewrites l a))", - " | PW_HASH2 a b => prim(PW_HASH2 (apply_rewrites l a) (apply_rewrites l b))", - " | PW_HASH3 a b c => prim(PW_HASH3 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c))", - " | PW_HASH4 a b c d => prim(PW_HASH4 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c) (apply_rewrites l d))", - " | PW_HASH5 a b c d e => prim(PW_HASH5 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c) (apply_rewrites l d) (apply_rewrites l e))", - " | SIGN k m => prim(SIGN (apply_rewrites l k) (apply_rewrites l m))", - " | SIGNVERIF k m s => match s with", - " | prim p' => match p' with", - " | SIGN k' m' => match value_beq k k', value_beq m m' with", - " | true, true => m", - " | true, false => prim(SIGNVERIF k (apply_rewrites l m) (prim(SIGN k (apply_rewrites l m'))))", - " | false, true => prim(SIGNVERIF (apply_rewrites l k) m (prim(SIGN (apply_rewrites l k') m')))", - " | false, false => prim(SIGNVERIF (apply_rewrites l k) (apply_rewrites l m) (prim(SIGN (apply_rewrites l k') (apply_rewrites l m'))))", - " end", - " | _ => prim(SIGNVERIF (apply_rewrites l k) (apply_rewrites l m) (apply_rewrites l s))", - " end", - " | _ => prim(SIGNVERIF (apply_rewrites l k) (apply_rewrites l m) (apply_rewrites l s))", - " end", - " | RINGSIGN ka gkb gkc m => prim(RINGSIGN (apply_rewrites l ka) (apply_rewrites l gkb) (apply_rewrites l gkc) (apply_rewrites l m))", - " | RINGSIGNVERIF gka gkb gkc m s => match s with", - " | prim p' => match p' with", - " | RINGSIGN ka' gkb' gkc' m' => match value_beq m m' with", - " | false => prim(RINGSIGNVERIF gka gkb gkc (apply_rewrites l m) (prim(RINGSIGN ka' gkb' gkc' (apply_rewrites l m))))", - " | true => match gka, gkb, gkc with", - " | eq e1, eq e2, eq e3 => match e1, e2, e3 with", - " | PUBKEY _ ka, PUBKEY _ kb, PUBKEY _ kc => match (value_beq ka' ka) && (((value_beq gkb' gkb) && (value_beq gkc' gkc)) || ((value_beq gkb' gkc) && (value_beq gkc' gkb))) with", - " | true => m", - " | false => match (value_beq ka' kb) && (((value_beq gkb' gkc) && (value_beq gkc' gka)) || ((value_beq gkb' gka) && (value_beq gkc' gkc))) with", - " | true => m", - " | false => match (value_beq ka' kc) && (((value_beq gkb' gkb) && (value_beq gkc' gka)) || ((value_beq gkb' gka) && (value_beq gkc' gkb))) with", - " | true => m", - " | false => prim(RINGSIGNVERIF (apply_rewrites l gka) (apply_rewrites l gkb) (apply_rewrites l gkc) m (prim(RINGSIGN (apply_rewrites l ka') (apply_rewrites l gkb') (apply_rewrites l gkc') m')))", - " end", - " end", - " end", - " | _, _, _ => prim(RINGSIGNVERIF (apply_rewrites l gka) (apply_rewrites l gkb) (apply_rewrites l gkc) m (prim(RINGSIGN ka' gkb' gkc' m')))", - " end", - " | _, _, _ => prim(RINGSIGNVERIF (apply_rewrites l gka) (apply_rewrites l gkb) (apply_rewrites l gkc) m (prim(RINGSIGN ka' gkb' gkc' m')))", - " end ", - " end", - " | _ => prim(RINGSIGNVERIF gka gkb gkc m (apply_rewrites l s))", - " end", - " | _ => prim(RINGSIGNVERIF gka gkb gkc m (apply_rewrites l s))", - " end", - " | BLIND k m => prim(BLIND (apply_rewrites l k) (apply_rewrites l m))", - " | UNBLIND k m s => match s with", - " | prim p' => match p' with", - " | SIGN a b => match b with", - " | prim p'' => match p'' with", - " | BLIND k' m' => match value_beq k k', value_beq m m' with", - " | true, true => prim(SIGN a m)", - " | true, false => prim(UNBLIND k (apply_rewrites l m) (prim(SIGN a (prim(BLIND k' (apply_rewrites l m'))))))", - " | false, true => prim(UNBLIND (apply_rewrites l k) m (prim(SIGN a (prim(BLIND (apply_rewrites l k') m')))))", - " | false, false => prim(UNBLIND (apply_rewrites l k) (apply_rewrites l m) (prim(SIGN a (prim(BLIND (apply_rewrites l k') (apply_rewrites l m'))))))", - " end", - " | _ => prim(UNBLIND k m (prim(SIGN a (apply_rewrites l b))))", - " end", - " | _ => prim(UNBLIND k m (prim(SIGN a (apply_rewrites l b))))", - " end", - " | _ => prim(UNBLIND k m (apply_rewrites l s))", - " end", - " | _ => prim(UNBLIND k m (apply_rewrites l s))", - " end", - " | SHAMIR_SPLIT1 k => prim(SHAMIR_SPLIT1 (apply_rewrites l k))", - " | SHAMIR_SPLIT2 k => prim(SHAMIR_SPLIT2 (apply_rewrites l k))", - " | SHAMIR_SPLIT3 k => prim(SHAMIR_SPLIT3 (apply_rewrites l k))", - " | SHAMIR_JOIN psa psb => match psa, psb with", - " | prim sa, prim sb => match sa, sb with", - " | SHAMIR_SPLIT1 k, SHAMIR_SPLIT2 k' => match value_beq k k' with", - " | true => k", - " | false => prim(SHAMIR_JOIN (apply_rewrites l psa) (apply_rewrites l psb))", - " end", - " | SHAMIR_SPLIT1 k, SHAMIR_SPLIT3 k' => match value_beq k k' with", - " | true => k", - " | false => prim(SHAMIR_JOIN (apply_rewrites l psa) (apply_rewrites l psb))", - " end", - " | SHAMIR_SPLIT2 k, SHAMIR_SPLIT1 k' => match value_beq k k' with", - " | true => k", - " | false => prim(SHAMIR_JOIN (apply_rewrites l psa) (apply_rewrites l psb))", - " end", - " | SHAMIR_SPLIT2 k, SHAMIR_SPLIT3 k' => match value_beq k k' with", - " | true => k", - " | false => prim(SHAMIR_JOIN (apply_rewrites l psa) (apply_rewrites l psb))", - " end", - " | SHAMIR_SPLIT3 k, SHAMIR_SPLIT1 k' => match value_beq k k' with", - " | true => k", - " | false => prim(SHAMIR_JOIN (apply_rewrites l psa) (apply_rewrites l psb))", - " end", - " | SHAMIR_SPLIT3 k, SHAMIR_SPLIT2 k' => match value_beq k k' with", - " | true => k", - " | false => prim(SHAMIR_JOIN (apply_rewrites l psa) (apply_rewrites l psb))", - " end", - " | _, _ => prim(SHAMIR_JOIN (apply_rewrites l psa) (apply_rewrites l psb))", - " end", - " | _, _ => prim(SHAMIR_JOIN (apply_rewrites l psa) (apply_rewrites l psb))", - " end", - " | CONCAT2 a b => prim(CONCAT2 (apply_rewrites l a) (apply_rewrites l b))", - " | CONCAT3 a b c => prim(CONCAT3 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c))", - " | CONCAT4 a b c d => prim(CONCAT4 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c) (apply_rewrites l d))", - " | CONCAT5 a b c d e => prim(CONCAT5 (apply_rewrites l a) (apply_rewrites l b) (apply_rewrites l c) (apply_rewrites l d) (apply_rewrites l e))", - " | SPLIT1 a => prim(SPLIT1 (apply_rewrites l a))", - " | SPLIT2 a => prim(SPLIT2 (apply_rewrites l a))", - " | SPLIT3 a => prim(SPLIT3 (apply_rewrites l a))", - " | SPLIT4 a => prim(SPLIT4 (apply_rewrites l a))", - " | SPLIT5 a => prim(SPLIT5 (apply_rewrites l a))", - " end", - " end.", - "", - "Fixpoint rewrite_list (l: list value) (i n: nat): list value :=", - " match n with", - " | 0 => l", - " | S n' => match ((List.length l) =? i) with", - " | true => l", - " | false => match l with", - " | [] => []", - " | h :: t =>", - " let v := (nth i l default) in", - " let v' := apply_rewrites l v in", - " let diff := rewrite_diff v v' in", - " match value_beq v diff with", - " | true => rewrite_list l (i+1) n'", - " | false => rewrite_list ((remove_value_list l v) ++ [diff]) 0 n'", - " end", - " end", - " end", - " end.", - "", - "Fixpoint rewrite_principals (l: list (list value)) (n: nat) : list(list value) :=", - " match l with", - " | [] => [[]]", - " | h :: t => [(rewrite_list h 0 n)] ++ (rewrite_principals t n)", - " end.", - "", - "", - "Fixpoint decompose_primitive (l: list value) (p: primitive) (n: nat) : list value :=", - " match n with", - " | 0 => l", - " | S n' => match p with", - " | ENC k m => let l' := (merge_lists l (find l k n')) in", - " match shallow_search l' k with", - " | true => l' ++ [m]", - " | false => l'", - " end", - " | DEC k c => let l' := (merge_lists l (find l k n')) in", - " match shallow_search l' k with", - " | true => l' ++ [c]", - " | false => l'", - " end", - " | AEAD_ENC k m ad => let l' := (merge_lists l (find l k n')) in", - " match shallow_search l' k with", - " | true => l' ++ [m]", - " | false => l'", - " end", - " | AEAD_DEC k c ad => let l' := (merge_lists l (find l k n')) in", - " match shallow_search l' k with", - " | true => l' ++ [c]", - " | false => l'", - " end", - " | PKE_ENC gk m => match gk with", - " | eq e => match e with", - " | PUBKEY _ exp => let l' := (merge_lists l (find l exp n')) in", - " match shallow_search l' exp with", - " | true => l' ++ [m]", - " | false => l'", - " end", - " | _ => l", - " end", - " | _ => l", - " end", - " | PKE_DEC k c => let l' := (merge_lists l (find l k n')) in", - " match shallow_search l' k with", - " | true => l' ++ [c]", - " | false => l'", - " end", - " | BLIND k m => let l' := (merge_lists l (find l k n')) in", - " match shallow_search l' k with", - " | true => l' ++ [m]", - " | false => l'", - " end", - " | _ => l", - " end", - " end", - "with reconstruct_primitive (l: list value) (p: primitive) (n: nat) : list value :=", - " match n with", - " | 0 => l", - " | S n' => match p with", - " | ENC k m => let l' := find l k n' in", - " let l'' := find l' m n' in", - " match shallow_search l'' k, shallow_search l'' m with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | DEC k c => let l' := find l k n' in", - " let l'' := find l' c n' in", - " match shallow_search l'' k, shallow_search l'' c with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | AEAD_ENC k m ad => let l' := find l k n' in", - " let l'' := find l' m n' in", - " let l''' := find l'' ad n' in", - " match shallow_search l''' k, shallow_search l''' m, shallow_search l''' ad with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | AEAD_DEC k c ad => let l' := find l k n' in", - " let l'' := find l' c n' in", - " let l''' := find l'' ad n' in", - " match shallow_search l''' k, shallow_search l''' c, shallow_search l''' ad with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | PKE_ENC gk m => let l' := find l gk n' in", - " let l'' := find l' m n' in", - " match shallow_search l'' gk, shallow_search l'' m with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | PKE_DEC k c => let l' := find l k n' in", - " let l'' := find l' c n' in", - " match shallow_search l'' k, shallow_search l'' c with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | HASH1 a => let l' := find l a n' in", - " match shallow_search l' a with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | HASH2 a b => let l' := find l a n' in", - " let l'' := find l' b n' in", - " match shallow_search l'' a, shallow_search l'' b with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | HASH3 a b c => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " match shallow_search l''' a, shallow_search l''' b, shallow_search l''' c with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | HASH4 a b c d => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " let l'''' := find l''' d n' in", - " match shallow_search l'''' a, shallow_search l'''' b, shallow_search l'''' c, shallow_search l'''' d with", - " | true, true, true, true => l'''' ++ [prim p]", - " | _, _, _, _ => l''''", - " end", - " | HASH5 a b c d e => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " let l'''' := find l''' d n' in", - " let l''''' := find l'''' e n' in", - " match shallow_search l''''' a, shallow_search l''''' b, shallow_search l''''' c, shallow_search l''''' d, shallow_search l''''' e with", - " | true, true, true, true, true => l''''' ++ [prim p]", - " | _, _, _, _, _ => l'''''", - " end", - " | MAC k m => let l' := find l k n' in", - " let l'' := find l' m n' in", - " match shallow_search l'' k, shallow_search l'' m with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | HKDF1 salt ikm info => let l' := find l salt n' in", - " let l'' := find l' ikm n' in", - " let l''' := find l'' info n' in", - " match shallow_search l''' salt, shallow_search l''' ikm, shallow_search l''' info with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | HKDF2 salt ikm info => let l' := find l salt n' in", - " let l'' := find l' ikm n' in", - " let l''' := find l'' info n' in", - " match shallow_search l''' salt, shallow_search l''' ikm, shallow_search l''' info with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | HKDF3 salt ikm info => let l' := find l salt n' in", - " let l'' := find l' ikm n' in", - " let l''' := find l'' info n' in", - " match shallow_search l''' salt, shallow_search l''' ikm, shallow_search l''' info with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | HKDF4 salt ikm info => let l' := find l salt n' in", - " let l'' := find l' ikm n' in", - " let l''' := find l'' info n' in", - " match shallow_search l''' salt, shallow_search l''' ikm, shallow_search l''' info with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | HKDF5 salt ikm info => let l' := find l salt n' in", - " let l'' := find l' ikm n' in", - " let l''' := find l'' info n' in", - " match shallow_search l''' salt, shallow_search l''' ikm, shallow_search l''' info with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | PW_HASH1 a => let l' := find l a n' in", - " match shallow_search l' a with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | PW_HASH2 a b => let l' := find l a n' in", - " let l'' := find l' b n' in", - " match shallow_search l'' a, shallow_search l'' b with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | PW_HASH3 a b c => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " match shallow_search l''' a, shallow_search l''' b, shallow_search l''' c with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | PW_HASH4 a b c d => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " let l'''' := find l''' d n' in", - " match shallow_search l'''' a, shallow_search l'''' b, shallow_search l'''' c, shallow_search l'''' d with", - " | true, true, true, true => l'''' ++ [prim p]", - " | _, _, _, _ => l''''", - " end", - " | PW_HASH5 a b c d e => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " let l'''' := find l''' d n' in", - " let l''''' := find l'''' e n' in", - " match shallow_search l''''' a, shallow_search l''''' b, shallow_search l''''' c, shallow_search l''''' d, shallow_search l''''' e with", - " | true, true, true, true, true => l''''' ++ [prim p]", - " | _, _, _, _, _ => l'''''", - " end", - " | SIGN k m => let l' := find l k n' in", - " let l'' := find l' m n' in", - " match shallow_search l'' k, shallow_search l'' m with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - "", - " | SIGNVERIF k m s => let l' := find l k n' in", - " let l'' := find l' m n' in", - " let l''' := find l'' s n' in", - " match shallow_search l''' k, shallow_search l''' m, shallow_search l''' s with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | RINGSIGN ka gkb gkc m => let l' := find l ka n' in", - " let l'' := find l' gkb n' in", - " let l''' := find l'' gkc n' in", - " let l'''' := find l''' m n' in", - " match shallow_search l'''' ka, shallow_search l'''' gkb, shallow_search l'''' gkc, shallow_search l'''' m with", - " | true, true, true, true => l'''' ++ [prim p]", - " | _, _, _, _ => l''''", - " end", - " | RINGSIGNVERIF gka gkb gkc m s => let l' := find l gka n' in", - " let l'' := find l' gkb n' in", - " let l''' := find l'' gkc n' in", - " let l'''' := find l''' m n' in", - " let l''''' := find l'''' s n' in", - " match shallow_search l''''' gka, shallow_search l''''' gkb, shallow_search l''''' gkc, shallow_search l''''' m, shallow_search l''''' s with", - " | true, true, true, true, true => l''''' ++ [prim p]", - " | _, _, _, _, _ => l'''''", - " end", - " | BLIND k m => let l' := find l k n' in", - " let l'' := find l' m n' in", - " match shallow_search l'' k, shallow_search l'' m with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | UNBLIND k m b => let l' := find l k n' in", - " let l'' := find l' m n' in", - " let l''' := find l'' b n' in", - " match shallow_search l''' k, shallow_search l''' m, shallow_search l''' b with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | SHAMIR_SPLIT1 k => let l' := find l k n' in", - " match shallow_search l' k with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | SHAMIR_SPLIT2 k => let l' := find l k n' in", - " match shallow_search l' k with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | SHAMIR_SPLIT3 k => let l' := find l k n' in", - " match shallow_search l' k with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | SHAMIR_JOIN sa sb => let l' := find l sa n' in", - " let l'' := find l' sb n' in", - " match shallow_search l'' sa, shallow_search l'' sb with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | CONCAT2 a b => let l' := find l a n' in", - " let l'' := find l' b n' in", - " match shallow_search l'' a, shallow_search l'' b with", - " | true, true => l'' ++ [prim p]", - " | _, _ => l''", - " end", - " | CONCAT3 a b c => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " match shallow_search l''' a, shallow_search l''' b, shallow_search l''' c with", - " | true, true, true => l''' ++ [prim p]", - " | _, _, _ => l'''", - " end", - " | CONCAT4 a b c d => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " let l'''' := find l''' d n' in", - " match shallow_search l'''' a, shallow_search l'''' b, shallow_search l'''' c, shallow_search l'''' d with", - " | true, true, true, true => l'''' ++ [prim p]", - " | _, _, _, _ => l''''", - " end", - " | CONCAT5 a b c d e => let l' := find l a n' in", - " let l'' := find l' b n' in", - " let l''' := find l'' c n' in", - " let l'''' := find l''' d n' in", - " let l''''' := find l'''' e n' in", - " match shallow_search l''''' a, shallow_search l''''' b, shallow_search l''''' c, shallow_search l''''' d, shallow_search l''''' e with", - " | true, true, true, true, true => l''''' ++ [prim p]", - " | _, _, _, _, _ => l'''''", - " end", - " | SPLIT1 a => let l' := find l a n' in", - " match shallow_search l' a with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | SPLIT2 a => let l' := find l a n' in", - " match shallow_search l' a with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | SPLIT3 a => let l' := find l a n' in", - " match shallow_search l' a with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | SPLIT4 a => let l' := find l a n' in", - " match shallow_search l' a with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " | SPLIT5 a => let l' := find l a n' in", - " match shallow_search l' a with", - " | true => l' ++ [prim p]", - " | false => l'", - " end", - " end", - " end", - "with reconstruct_equation (l: list value) (e: equation) (n: nat) : list value :=", - " match n with", - " | 0 => l", - " | S n' => match e with", - " | PUBKEY _ exp => let l' := find l exp n' in", - " match shallow_search l' exp with", - " | true => l' ++ [eq e]", - " | false => l'", - " end", - " | DH _ exp1 exp2 => let l' := find l exp1 n' in", - " match shallow_search l' exp1 with", - " | true => let l'' := find l' exp2 n' in", - " match shallow_search l'' exp2 with", - " | true => l'' ++ [eq e]", - " | false => let gexp2 := (eq (PUBKEY G exp2)) in", - " let l''' := find l'' gexp2 n' in", - " match shallow_search l''' gexp2 with", - " | true => l''' ++ [eq e]", - " | false => l'''", - " end", - " end", - " | false => let gexp1 := (eq (PUBKEY G exp1)) in", - " let l'' := find l' gexp1 n' in", - " match shallow_search l'' gexp1 with", - " | true => let l''' := find l'' exp2 n' in", - " match shallow_search l''' exp2 with", - " | true => l''' ++ [eq e]", - " | false => l'''", - " end", - " | false => l''", - " end", - " end", - " end", - " end", - "with find (l: list value) (goal: value) (n: nat) : list value := ", - " match n with", - " | 0 => l", - " | S n' => match shallow_search l goal with", - " | true => l", - " | false => match goal with", - " | const c => l", - " | pass a => l", - " | default => l", - " | eq e => reconstruct_equation l e n'", - " | prim p => let l' := decompose_primitive l p n' in", - " match shallow_search l' goal with", - " | true => l'", - " | false => reconstruct_primitive l' p n'", - " end ", - " end", - " end", - " end.", - "", - "Fixpoint analysis_decompose (l: list value) (i n: nat): list value :=", - "match n with", - "| 0 => l", - "| S n' => match ((List.length l) =? i) with", - " | true => l", - " | false => match l with", - " | [] => []", - " | h :: t =>", - " let v := (nth i l default) in", - " match v with", - " | prim p => let l' := decompose_primitive l p n' in", - " match (List.length l =? List.length l') with", - " | true => analysis_decompose l (i+1) n'", - " | false => analysis_decompose l' 0 n'", - " end", - " | _ => analysis_decompose l (i+1) n'", - " end", - " end", - " end", - "end.", - "", - "Fixpoint analysis_concat (l: list value) : list value :=", - " match l with", - " | [] => []", - " | h :: t => match h with", - " | prim p => match p with", - " | CONCAT2 a b => [a; b] ++ analysis_concat t", - " | CONCAT3 a b c => [a; b; c] ++ analysis_concat t", - " | CONCAT4 a b c d => [a; b; c; d] ++ analysis_concat t", - " | CONCAT5 a b c d e => [a; b; c; d; e] ++ analysis_concat t", - " | _ => [h] ++ analysis_concat t", - " end", - " | _ => [h] ++ analysis_concat t", - " end", - " end.", - "", - "", - "Inductive query : Type :=", - " | confidentiality: value -> query.", - "", - "Definition resolve_query (q: query) (l: list value) : bool := ", - " match q with", - " | confidentiality v => shallow_search l v", - " end.", - "", - "Definition recompose (l: list value) (v: value) : list value :=", - " match ((shallow_search l (prim(SHAMIR_SPLIT1 v)) && shallow_search l (prim(SHAMIR_SPLIT2 v)))", - " || (shallow_search l (prim(SHAMIR_SPLIT1 v)) && shallow_search l (prim(SHAMIR_SPLIT3 v)))", - " || (shallow_search l (prim(SHAMIR_SPLIT2 v)) && shallow_search l (prim(SHAMIR_SPLIT3 v))) ", - " ) with", - " | true => l ++ [v]", - " | false => l", - " end.", - "", - "Fixpoint recompose_analysis (l: list value) (pl: list (list value)) (n: nat) : list value :=", - "match n with", - " | 0 => l", - " | S n' => match pl with", - " | [] => l", - " | h :: t => match h with", - " | [] => merge_lists l (recompose_analysis l t n')", - " | h' :: t' => let l' := recompose l h' in", - " merge_lists l' (recompose_analysis l' ([t']++ t) n')", - " end", - " end", - " end.", - "", - "Fixpoint reconstruct_analysis (l: list value) (pl: list(list value)) (n: nat) : list value :=", - " match n with", - " | 0 => l", - " | S n' => match pl with", - " | [] => l", - " | h :: t => match h with", - " | [] => merge_lists l (reconstruct_analysis l t n')", - " | h' :: t' => match h' with", - " | prim p => let l' := reconstruct_primitive l p n' in", - " merge_lists l' (reconstruct_analysis l' ([t'] ++ t) n')", - " | eq e => let l' := reconstruct_equation l e n' in", - " merge_lists l' (reconstruct_analysis l' ([t'] ++ t) n')", - " | _ => merge_lists l (reconstruct_analysis l ([t'] ++ t) n')", - " end", - " end", - " end", - " end.", - " ", - "", - "Fixpoint analysis (q: query) (ak: list value) (p: list (list value)) (n: nat) : bool :=", - " match n with", - " | 0 => true", - " | S n' => match ak with", - " | [] => true", - " | _ => let ak2 := analysis_decompose ak 0 n' in", - " let ak3 := analysis_concat ak2 in", - " let ak4 := recompose_analysis ak3 p n' in", - " let ak5 := reconstruct_analysis ak4 p n'", - " in match resolve_query q ak with", - " | true => false", - " | false => match (List.length ak =? List.length ak5) with", - " | true => true", - " | false => analysis q ak5 p n'", - " end", - " end", - " end", - " end.", - ""}, - "\n") diff --git a/cmd/vplogic/libpeg.go b/cmd/vplogic/libpeg.go deleted file mode 100644 index a5c12f4..0000000 --- a/cmd/vplogic/libpeg.go +++ /dev/null @@ -1,3498 +0,0 @@ -// Code generated by pigeon; DO NOT EDIT. - -/* SPDX-FileCopyrightText: © 2019-2022 Nadim Kobeissi - * SPDX-License-Identifier: GPL-3.0-only */ - -// This file is generated automatically from libpeg.peg. -// Do not modify. - -package vplogic - -import ( - "bytes" - "errors" - "fmt" - "io" - "io/ioutil" - "math" - "os" - "path/filepath" - "sort" - "strconv" - "strings" - "sync" - "unicode" - "unicode/utf8" -) - -var libpegReserved = []string{ - "attacker", "passive", "active", "principal", - "knows", "generates", "leaks", - "phase", "public", "private", "password", - "confidentiality", "authentication", - "freshness", "unlinkability", "equivalence", - "precondition", "ringsign", "ringsignverif", - "primitive", "pw_hash", "hash", "hkdf", - "aead_enc", "aead_dec", "enc", "dec", - "mac", "assert", "sign", "signverif", - "pke_enc", "pke_dec", "shamir_split", - "shamir_join", "concat", "split", "unnamed", -} - -var libpegUnnamedCounter = 0 - -func libpegCheckIfReserved(s string) error { - found := false - switch { - case strInSlice(s, libpegReserved): - found = true - case strings.HasPrefix(s, "attacker"): - found = true - case strings.HasPrefix(s, "unnamed"): - found = true - } - if found { - return fmt.Errorf("cannot use reserved keyword in Name: %s", s) - } - return nil -} - -func libpegParseModel(filePath string, verbose bool) (Model, error) { - fileName := filepath.Base(filePath) - if len(fileName) > 64 { - return Model{}, fmt.Errorf("model file name must be 64 characters or less") - } - if filepath.Ext(fileName) != ".vp" { - return Model{}, fmt.Errorf("model file name must have a '.vp' extension") - } - if verbose { - InfoMessage(fmt.Sprintf( - "Parsing model '%s'...", fileName, - ), "verifpal", false) - } - parsed, err := ParseFile(filePath) - if err != nil { - return Model{}, err - } - m := parsed.(Model) - m.FileName = fileName - return m, nil -} - -var g = &grammar{ - rules: []*rule{ - { - name: "Model", - pos: position{line: 79, col: 1, offset: 1779}, - expr: &actionExpr{ - pos: position{line: 79, col: 10, offset: 1788}, - run: (*parser).callonModel1, - expr: &seqExpr{ - pos: position{line: 79, col: 10, offset: 1788}, - exprs: []interface{}{ - &ruleRefExpr{ - pos: position{line: 79, col: 10, offset: 1788}, - name: "_", - }, - &zeroOrMoreExpr{ - pos: position{line: 79, col: 12, offset: 1790}, - expr: &ruleRefExpr{ - pos: position{line: 79, col: 12, offset: 1790}, - name: "Comment", - }, - }, - &labeledExpr{ - pos: position{line: 79, col: 21, offset: 1799}, - label: "Attacker", - expr: &zeroOrOneExpr{ - pos: position{line: 79, col: 30, offset: 1808}, - expr: &ruleRefExpr{ - pos: position{line: 79, col: 30, offset: 1808}, - name: "Attacker", - }, - }, - }, - &labeledExpr{ - pos: position{line: 79, col: 40, offset: 1818}, - label: "Blocks", - expr: &zeroOrOneExpr{ - pos: position{line: 79, col: 47, offset: 1825}, - expr: &oneOrMoreExpr{ - pos: position{line: 79, col: 48, offset: 1826}, - expr: &ruleRefExpr{ - pos: position{line: 79, col: 48, offset: 1826}, - name: "Block", - }, - }, - }, - }, - &labeledExpr{ - pos: position{line: 79, col: 57, offset: 1835}, - label: "Queries", - expr: &zeroOrOneExpr{ - pos: position{line: 79, col: 65, offset: 1843}, - expr: &ruleRefExpr{ - pos: position{line: 79, col: 65, offset: 1843}, - name: "Queries", - }, - }, - }, - &zeroOrMoreExpr{ - pos: position{line: 79, col: 74, offset: 1852}, - expr: &ruleRefExpr{ - pos: position{line: 79, col: 74, offset: 1852}, - name: "Comment", - }, - }, - &ruleRefExpr{ - pos: position{line: 79, col: 83, offset: 1861}, - name: "_", - }, - &ruleRefExpr{ - pos: position{line: 79, col: 85, offset: 1863}, - name: "EOF", - }, - }, - }, - }, - }, - { - name: "Attacker", - pos: position{line: 101, col: 1, offset: 2415}, - expr: &actionExpr{ - pos: position{line: 101, col: 13, offset: 2427}, - run: (*parser).callonAttacker1, - expr: &seqExpr{ - pos: position{line: 101, col: 13, offset: 2427}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 101, col: 13, offset: 2427}, - val: "attacker", - ignoreCase: false, - want: "\"attacker\"", - }, - &ruleRefExpr{ - pos: position{line: 101, col: 24, offset: 2438}, - name: "_", - }, - &litMatcher{ - pos: position{line: 101, col: 26, offset: 2440}, - val: "[", - ignoreCase: false, - want: "\"[\"", - }, - &ruleRefExpr{ - pos: position{line: 101, col: 30, offset: 2444}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 101, col: 32, offset: 2446}, - label: "Type", - expr: &zeroOrOneExpr{ - pos: position{line: 101, col: 37, offset: 2451}, - expr: &ruleRefExpr{ - pos: position{line: 101, col: 37, offset: 2451}, - name: "AttackerType", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 101, col: 51, offset: 2465}, - name: "_", - }, - &litMatcher{ - pos: position{line: 101, col: 53, offset: 2467}, - val: "]", - ignoreCase: false, - want: "\"]\"", - }, - &ruleRefExpr{ - pos: position{line: 101, col: 57, offset: 2471}, - name: "_", - }, - }, - }, - }, - }, - { - name: "AttackerType", - pos: position{line: 108, col: 1, offset: 2595}, - expr: &actionExpr{ - pos: position{line: 108, col: 17, offset: 2611}, - run: (*parser).callonAttackerType1, - expr: &choiceExpr{ - pos: position{line: 108, col: 18, offset: 2612}, - alternatives: []interface{}{ - &litMatcher{ - pos: position{line: 108, col: 18, offset: 2612}, - val: "active", - ignoreCase: false, - want: "\"active\"", - }, - &litMatcher{ - pos: position{line: 108, col: 27, offset: 2621}, - val: "passive", - ignoreCase: false, - want: "\"passive\"", - }, - }, - }, - }, - }, - { - name: "Block", - pos: position{line: 112, col: 1, offset: 2665}, - expr: &actionExpr{ - pos: position{line: 112, col: 10, offset: 2674}, - run: (*parser).callonBlock1, - expr: &seqExpr{ - pos: position{line: 112, col: 10, offset: 2674}, - exprs: []interface{}{ - &zeroOrMoreExpr{ - pos: position{line: 112, col: 10, offset: 2674}, - expr: &ruleRefExpr{ - pos: position{line: 112, col: 10, offset: 2674}, - name: "Comment", - }, - }, - &labeledExpr{ - pos: position{line: 112, col: 19, offset: 2683}, - label: "Block", - expr: &choiceExpr{ - pos: position{line: 112, col: 26, offset: 2690}, - alternatives: []interface{}{ - &ruleRefExpr{ - pos: position{line: 112, col: 26, offset: 2690}, - name: "Phase", - }, - &ruleRefExpr{ - pos: position{line: 112, col: 32, offset: 2696}, - name: "Principal", - }, - &ruleRefExpr{ - pos: position{line: 112, col: 42, offset: 2706}, - name: "Message", - }, - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 112, col: 51, offset: 2715}, - name: "_", - }, - &zeroOrMoreExpr{ - pos: position{line: 112, col: 53, offset: 2717}, - expr: &ruleRefExpr{ - pos: position{line: 112, col: 53, offset: 2717}, - name: "Comment", - }, - }, - }, - }, - }, - }, - { - name: "Principal", - pos: position{line: 116, col: 1, offset: 2750}, - expr: &actionExpr{ - pos: position{line: 116, col: 14, offset: 2763}, - run: (*parser).callonPrincipal1, - expr: &seqExpr{ - pos: position{line: 116, col: 14, offset: 2763}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 116, col: 14, offset: 2763}, - val: "principal", - ignoreCase: false, - want: "\"principal\"", - }, - &ruleRefExpr{ - pos: position{line: 116, col: 26, offset: 2775}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 116, col: 28, offset: 2777}, - label: "Name", - expr: &ruleRefExpr{ - pos: position{line: 116, col: 33, offset: 2782}, - name: "PrincipalName", - }, - }, - &ruleRefExpr{ - pos: position{line: 116, col: 47, offset: 2796}, - name: "_", - }, - &litMatcher{ - pos: position{line: 116, col: 49, offset: 2798}, - val: "[", - ignoreCase: false, - want: "\"[\"", - }, - &ruleRefExpr{ - pos: position{line: 116, col: 53, offset: 2802}, - name: "_", - }, - &zeroOrMoreExpr{ - pos: position{line: 116, col: 55, offset: 2804}, - expr: &ruleRefExpr{ - pos: position{line: 116, col: 55, offset: 2804}, - name: "Comment", - }, - }, - &labeledExpr{ - pos: position{line: 116, col: 64, offset: 2813}, - label: "Expressions", - expr: &zeroOrMoreExpr{ - pos: position{line: 116, col: 77, offset: 2826}, - expr: &ruleRefExpr{ - pos: position{line: 116, col: 77, offset: 2826}, - name: "Expression", - }, - }, - }, - &zeroOrMoreExpr{ - pos: position{line: 116, col: 90, offset: 2839}, - expr: &ruleRefExpr{ - pos: position{line: 116, col: 90, offset: 2839}, - name: "Comment", - }, - }, - &ruleRefExpr{ - pos: position{line: 116, col: 99, offset: 2848}, - name: "_", - }, - &litMatcher{ - pos: position{line: 116, col: 101, offset: 2850}, - val: "]", - ignoreCase: false, - want: "\"]\"", - }, - &ruleRefExpr{ - pos: position{line: 116, col: 105, offset: 2854}, - name: "_", - }, - }, - }, - }, - }, - { - name: "PrincipalName", - pos: position{line: 131, col: 1, offset: 3149}, - expr: &actionExpr{ - pos: position{line: 131, col: 18, offset: 3166}, - run: (*parser).callonPrincipalName1, - expr: &labeledExpr{ - pos: position{line: 131, col: 18, offset: 3166}, - label: "Name", - expr: &ruleRefExpr{ - pos: position{line: 131, col: 23, offset: 3171}, - name: "Identifier", - }, - }, - }, - }, - { - name: "Qualifier", - pos: position{line: 136, col: 1, offset: 3274}, - expr: &actionExpr{ - pos: position{line: 136, col: 14, offset: 3287}, - run: (*parser).callonQualifier1, - expr: &choiceExpr{ - pos: position{line: 136, col: 15, offset: 3288}, - alternatives: []interface{}{ - &litMatcher{ - pos: position{line: 136, col: 15, offset: 3288}, - val: "private", - ignoreCase: false, - want: "\"private\"", - }, - &litMatcher{ - pos: position{line: 136, col: 25, offset: 3298}, - val: "public", - ignoreCase: false, - want: "\"public\"", - }, - &litMatcher{ - pos: position{line: 136, col: 34, offset: 3307}, - val: "password", - ignoreCase: false, - want: "\"password\"", - }, - }, - }, - }, - }, - { - name: "Message", - pos: position{line: 147, col: 1, offset: 3495}, - expr: &actionExpr{ - pos: position{line: 147, col: 12, offset: 3506}, - run: (*parser).callonMessage1, - expr: &seqExpr{ - pos: position{line: 147, col: 12, offset: 3506}, - exprs: []interface{}{ - &labeledExpr{ - pos: position{line: 147, col: 12, offset: 3506}, - label: "Sender", - expr: &zeroOrOneExpr{ - pos: position{line: 147, col: 19, offset: 3513}, - expr: &ruleRefExpr{ - pos: position{line: 147, col: 19, offset: 3513}, - name: "PrincipalName", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 147, col: 34, offset: 3528}, - name: "_", - }, - &choiceExpr{ - pos: position{line: 147, col: 37, offset: 3531}, - alternatives: []interface{}{ - &litMatcher{ - pos: position{line: 147, col: 37, offset: 3531}, - val: "->", - ignoreCase: false, - want: "\"->\"", - }, - &litMatcher{ - pos: position{line: 147, col: 42, offset: 3536}, - val: "→", - ignoreCase: false, - want: "\"→\"", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 147, col: 47, offset: 3543}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 147, col: 49, offset: 3545}, - label: "Recipient", - expr: &zeroOrOneExpr{ - pos: position{line: 147, col: 59, offset: 3555}, - expr: &ruleRefExpr{ - pos: position{line: 147, col: 59, offset: 3555}, - name: "PrincipalName", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 147, col: 74, offset: 3570}, - name: "_", - }, - &litMatcher{ - pos: position{line: 147, col: 76, offset: 3572}, - val: ":", - ignoreCase: false, - want: "\":\"", - }, - &ruleRefExpr{ - pos: position{line: 147, col: 80, offset: 3576}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 147, col: 82, offset: 3578}, - label: "Constants", - expr: &zeroOrOneExpr{ - pos: position{line: 147, col: 92, offset: 3588}, - expr: &ruleRefExpr{ - pos: position{line: 147, col: 92, offset: 3588}, - name: "MessageConstants", - }, - }, - }, - }, - }, - }, - }, - { - name: "MessageConstants", - pos: position{line: 168, col: 1, offset: 4142}, - expr: &actionExpr{ - pos: position{line: 168, col: 21, offset: 4162}, - run: (*parser).callonMessageConstants1, - expr: &labeledExpr{ - pos: position{line: 168, col: 21, offset: 4162}, - label: "MessageConstants", - expr: &oneOrMoreExpr{ - pos: position{line: 168, col: 38, offset: 4179}, - expr: &choiceExpr{ - pos: position{line: 168, col: 39, offset: 4180}, - alternatives: []interface{}{ - &ruleRefExpr{ - pos: position{line: 168, col: 39, offset: 4180}, - name: "GuardedConstant", - }, - &ruleRefExpr{ - pos: position{line: 168, col: 55, offset: 4196}, - name: "Constant", - }, - }, - }, - }, - }, - }, - }, - { - name: "Expression", - pos: position{line: 178, col: 1, offset: 4370}, - expr: &actionExpr{ - pos: position{line: 178, col: 15, offset: 4384}, - run: (*parser).callonExpression1, - expr: &seqExpr{ - pos: position{line: 178, col: 15, offset: 4384}, - exprs: []interface{}{ - &zeroOrMoreExpr{ - pos: position{line: 178, col: 15, offset: 4384}, - expr: &ruleRefExpr{ - pos: position{line: 178, col: 15, offset: 4384}, - name: "Comment", - }, - }, - &labeledExpr{ - pos: position{line: 178, col: 24, offset: 4393}, - label: "Expression", - expr: &choiceExpr{ - pos: position{line: 178, col: 36, offset: 4405}, - alternatives: []interface{}{ - &ruleRefExpr{ - pos: position{line: 178, col: 36, offset: 4405}, - name: "Knows", - }, - &ruleRefExpr{ - pos: position{line: 178, col: 42, offset: 4411}, - name: "Generates", - }, - &ruleRefExpr{ - pos: position{line: 178, col: 52, offset: 4421}, - name: "Leaks", - }, - &ruleRefExpr{ - pos: position{line: 178, col: 58, offset: 4427}, - name: "Assignment", - }, - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 178, col: 70, offset: 4439}, - name: "_", - }, - &zeroOrMoreExpr{ - pos: position{line: 178, col: 72, offset: 4441}, - expr: &ruleRefExpr{ - pos: position{line: 178, col: 72, offset: 4441}, - name: "Comment", - }, - }, - }, - }, - }, - }, - { - name: "Knows", - pos: position{line: 182, col: 1, offset: 4479}, - expr: &actionExpr{ - pos: position{line: 182, col: 10, offset: 4488}, - run: (*parser).callonKnows1, - expr: &seqExpr{ - pos: position{line: 182, col: 10, offset: 4488}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 182, col: 10, offset: 4488}, - val: "knows", - ignoreCase: false, - want: "\"knows\"", - }, - &ruleRefExpr{ - pos: position{line: 182, col: 18, offset: 4496}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 182, col: 20, offset: 4498}, - label: "Qualifier", - expr: &zeroOrOneExpr{ - pos: position{line: 182, col: 30, offset: 4508}, - expr: &ruleRefExpr{ - pos: position{line: 182, col: 30, offset: 4508}, - name: "Qualifier", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 182, col: 41, offset: 4519}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 182, col: 43, offset: 4521}, - label: "Constants", - expr: &zeroOrOneExpr{ - pos: position{line: 182, col: 53, offset: 4531}, - expr: &ruleRefExpr{ - pos: position{line: 182, col: 53, offset: 4531}, - name: "Constants", - }, - }, - }, - }, - }, - }, - }, - { - name: "Generates", - pos: position{line: 196, col: 1, offset: 4883}, - expr: &actionExpr{ - pos: position{line: 196, col: 14, offset: 4896}, - run: (*parser).callonGenerates1, - expr: &seqExpr{ - pos: position{line: 196, col: 14, offset: 4896}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 196, col: 14, offset: 4896}, - val: "generates", - ignoreCase: false, - want: "\"generates\"", - }, - &ruleRefExpr{ - pos: position{line: 196, col: 26, offset: 4908}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 196, col: 28, offset: 4910}, - label: "Constants", - expr: &zeroOrOneExpr{ - pos: position{line: 196, col: 38, offset: 4920}, - expr: &ruleRefExpr{ - pos: position{line: 196, col: 38, offset: 4920}, - name: "Constants", - }, - }, - }, - }, - }, - }, - }, - { - name: "Leaks", - pos: position{line: 207, col: 1, offset: 5165}, - expr: &actionExpr{ - pos: position{line: 207, col: 10, offset: 5174}, - run: (*parser).callonLeaks1, - expr: &seqExpr{ - pos: position{line: 207, col: 10, offset: 5174}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 207, col: 10, offset: 5174}, - val: "leaks", - ignoreCase: false, - want: "\"leaks\"", - }, - &ruleRefExpr{ - pos: position{line: 207, col: 18, offset: 5182}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 207, col: 20, offset: 5184}, - label: "Constants", - expr: &zeroOrOneExpr{ - pos: position{line: 207, col: 30, offset: 5194}, - expr: &ruleRefExpr{ - pos: position{line: 207, col: 30, offset: 5194}, - name: "Constants", - }, - }, - }, - }, - }, - }, - }, - { - name: "Assignment", - pos: position{line: 218, col: 1, offset: 5431}, - expr: &actionExpr{ - pos: position{line: 218, col: 15, offset: 5445}, - run: (*parser).callonAssignment1, - expr: &seqExpr{ - pos: position{line: 218, col: 15, offset: 5445}, - exprs: []interface{}{ - &labeledExpr{ - pos: position{line: 218, col: 15, offset: 5445}, - label: "Left", - expr: &zeroOrOneExpr{ - pos: position{line: 218, col: 20, offset: 5450}, - expr: &ruleRefExpr{ - pos: position{line: 218, col: 20, offset: 5450}, - name: "Constants", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 218, col: 31, offset: 5461}, - name: "_", - }, - &litMatcher{ - pos: position{line: 218, col: 33, offset: 5463}, - val: "=", - ignoreCase: false, - want: "\"=\"", - }, - &ruleRefExpr{ - pos: position{line: 218, col: 37, offset: 5467}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 218, col: 39, offset: 5469}, - label: "Right", - expr: &zeroOrOneExpr{ - pos: position{line: 218, col: 45, offset: 5475}, - expr: &ruleRefExpr{ - pos: position{line: 218, col: 45, offset: 5475}, - name: "Value", - }, - }, - }, - }, - }, - }, - }, - { - name: "Constant", - pos: position{line: 234, col: 1, offset: 5824}, - expr: &actionExpr{ - pos: position{line: 234, col: 13, offset: 5836}, - run: (*parser).callonConstant1, - expr: &seqExpr{ - pos: position{line: 234, col: 13, offset: 5836}, - exprs: []interface{}{ - &labeledExpr{ - pos: position{line: 234, col: 13, offset: 5836}, - label: "Const", - expr: &ruleRefExpr{ - pos: position{line: 234, col: 19, offset: 5842}, - name: "Identifier", - }, - }, - &zeroOrOneExpr{ - pos: position{line: 234, col: 30, offset: 5853}, - expr: &seqExpr{ - pos: position{line: 234, col: 31, offset: 5854}, - exprs: []interface{}{ - &ruleRefExpr{ - pos: position{line: 234, col: 31, offset: 5854}, - name: "_", - }, - &litMatcher{ - pos: position{line: 234, col: 33, offset: 5856}, - val: ",", - ignoreCase: false, - want: "\",\"", - }, - &ruleRefExpr{ - pos: position{line: 234, col: 37, offset: 5860}, - name: "_", - }, - }, - }, - }, - }, - }, - }, - }, - { - name: "Constants", - pos: position{line: 256, col: 1, offset: 6254}, - expr: &actionExpr{ - pos: position{line: 256, col: 14, offset: 6267}, - run: (*parser).callonConstants1, - expr: &labeledExpr{ - pos: position{line: 256, col: 14, offset: 6267}, - label: "Constants", - expr: &oneOrMoreExpr{ - pos: position{line: 256, col: 24, offset: 6277}, - expr: &ruleRefExpr{ - pos: position{line: 256, col: 24, offset: 6277}, - name: "Constant", - }, - }, - }, - }, - }, - { - name: "Phase", - pos: position{line: 265, col: 1, offset: 6434}, - expr: &actionExpr{ - pos: position{line: 265, col: 10, offset: 6443}, - run: (*parser).callonPhase1, - expr: &seqExpr{ - pos: position{line: 265, col: 10, offset: 6443}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 265, col: 10, offset: 6443}, - val: "phase", - ignoreCase: false, - want: "\"phase\"", - }, - &ruleRefExpr{ - pos: position{line: 265, col: 18, offset: 6451}, - name: "_", - }, - &litMatcher{ - pos: position{line: 265, col: 20, offset: 6453}, - val: "[", - ignoreCase: false, - want: "\"[\"", - }, - &ruleRefExpr{ - pos: position{line: 265, col: 24, offset: 6457}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 265, col: 26, offset: 6459}, - label: "Number", - expr: &oneOrMoreExpr{ - pos: position{line: 265, col: 33, offset: 6466}, - expr: &charClassMatcher{ - pos: position{line: 265, col: 33, offset: 6466}, - val: "[0-9]", - ranges: []rune{'0', '9'}, - ignoreCase: false, - inverted: false, - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 265, col: 40, offset: 6473}, - name: "_", - }, - &litMatcher{ - pos: position{line: 265, col: 42, offset: 6475}, - val: "]", - ignoreCase: false, - want: "\"]\"", - }, - &ruleRefExpr{ - pos: position{line: 265, col: 46, offset: 6479}, - name: "_", - }, - }, - }, - }, - }, - { - name: "GuardedConstant", - pos: position{line: 278, col: 1, offset: 6701}, - expr: &actionExpr{ - pos: position{line: 278, col: 20, offset: 6720}, - run: (*parser).callonGuardedConstant1, - expr: &seqExpr{ - pos: position{line: 278, col: 20, offset: 6720}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 278, col: 20, offset: 6720}, - val: "[", - ignoreCase: false, - want: "\"[\"", - }, - &labeledExpr{ - pos: position{line: 278, col: 24, offset: 6724}, - label: "Guarded", - expr: &ruleRefExpr{ - pos: position{line: 278, col: 32, offset: 6732}, - name: "Constant", - }, - }, - &litMatcher{ - pos: position{line: 278, col: 41, offset: 6741}, - val: "]", - ignoreCase: false, - want: "\"]\"", - }, - &zeroOrOneExpr{ - pos: position{line: 278, col: 45, offset: 6745}, - expr: &seqExpr{ - pos: position{line: 278, col: 46, offset: 6746}, - exprs: []interface{}{ - &ruleRefExpr{ - pos: position{line: 278, col: 46, offset: 6746}, - name: "_", - }, - &litMatcher{ - pos: position{line: 278, col: 48, offset: 6748}, - val: ",", - ignoreCase: false, - want: "\",\"", - }, - &ruleRefExpr{ - pos: position{line: 278, col: 52, offset: 6752}, - name: "_", - }, - }, - }, - }, - }, - }, - }, - }, - { - name: "Primitive", - pos: position{line: 291, col: 1, offset: 6994}, - expr: &actionExpr{ - pos: position{line: 291, col: 14, offset: 7007}, - run: (*parser).callonPrimitive1, - expr: &seqExpr{ - pos: position{line: 291, col: 14, offset: 7007}, - exprs: []interface{}{ - &labeledExpr{ - pos: position{line: 291, col: 14, offset: 7007}, - label: "Name", - expr: &ruleRefExpr{ - pos: position{line: 291, col: 19, offset: 7012}, - name: "PrimitiveName", - }, - }, - &litMatcher{ - pos: position{line: 291, col: 33, offset: 7026}, - val: "(", - ignoreCase: false, - want: "\"(\"", - }, - &ruleRefExpr{ - pos: position{line: 291, col: 37, offset: 7030}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 291, col: 39, offset: 7032}, - label: "Arguments", - expr: &oneOrMoreExpr{ - pos: position{line: 291, col: 49, offset: 7042}, - expr: &ruleRefExpr{ - pos: position{line: 291, col: 49, offset: 7042}, - name: "Value", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 291, col: 56, offset: 7049}, - name: "_", - }, - &litMatcher{ - pos: position{line: 291, col: 58, offset: 7051}, - val: ")", - ignoreCase: false, - want: "\")\"", - }, - &labeledExpr{ - pos: position{line: 291, col: 62, offset: 7055}, - label: "Check", - expr: &zeroOrOneExpr{ - pos: position{line: 291, col: 68, offset: 7061}, - expr: &litMatcher{ - pos: position{line: 291, col: 68, offset: 7061}, - val: "?", - ignoreCase: false, - want: "\"?\"", - }, - }, - }, - &zeroOrOneExpr{ - pos: position{line: 291, col: 73, offset: 7066}, - expr: &seqExpr{ - pos: position{line: 291, col: 74, offset: 7067}, - exprs: []interface{}{ - &ruleRefExpr{ - pos: position{line: 291, col: 74, offset: 7067}, - name: "_", - }, - &litMatcher{ - pos: position{line: 291, col: 76, offset: 7069}, - val: ",", - ignoreCase: false, - want: "\",\"", - }, - &ruleRefExpr{ - pos: position{line: 291, col: 80, offset: 7073}, - name: "_", - }, - }, - }, - }, - }, - }, - }, - }, - { - name: "PrimitiveName", - pos: position{line: 308, col: 1, offset: 7388}, - expr: &actionExpr{ - pos: position{line: 308, col: 18, offset: 7405}, - run: (*parser).callonPrimitiveName1, - expr: &labeledExpr{ - pos: position{line: 308, col: 18, offset: 7405}, - label: "Name", - expr: &ruleRefExpr{ - pos: position{line: 308, col: 23, offset: 7410}, - name: "Identifier", - }, - }, - }, - }, - { - name: "Equation", - pos: position{line: 312, col: 1, offset: 7470}, - expr: &actionExpr{ - pos: position{line: 312, col: 13, offset: 7482}, - run: (*parser).callonEquation1, - expr: &seqExpr{ - pos: position{line: 312, col: 13, offset: 7482}, - exprs: []interface{}{ - &labeledExpr{ - pos: position{line: 312, col: 13, offset: 7482}, - label: "First", - expr: &ruleRefExpr{ - pos: position{line: 312, col: 19, offset: 7488}, - name: "Constant", - }, - }, - &seqExpr{ - pos: position{line: 312, col: 29, offset: 7498}, - exprs: []interface{}{ - &ruleRefExpr{ - pos: position{line: 312, col: 29, offset: 7498}, - name: "_", - }, - &litMatcher{ - pos: position{line: 312, col: 31, offset: 7500}, - val: "^", - ignoreCase: false, - want: "\"^\"", - }, - &ruleRefExpr{ - pos: position{line: 312, col: 35, offset: 7504}, - name: "_", - }, - }, - }, - &labeledExpr{ - pos: position{line: 312, col: 38, offset: 7507}, - label: "Second", - expr: &ruleRefExpr{ - pos: position{line: 312, col: 45, offset: 7514}, - name: "Constant", - }, - }, - }, - }, - }, - }, - { - name: "Value", - pos: position{line: 324, col: 1, offset: 7671}, - expr: &choiceExpr{ - pos: position{line: 324, col: 10, offset: 7680}, - alternatives: []interface{}{ - &ruleRefExpr{ - pos: position{line: 324, col: 10, offset: 7680}, - name: "Primitive", - }, - &ruleRefExpr{ - pos: position{line: 324, col: 20, offset: 7690}, - name: "Equation", - }, - &ruleRefExpr{ - pos: position{line: 324, col: 29, offset: 7699}, - name: "Constant", - }, - }, - }, - }, - { - name: "Queries", - pos: position{line: 326, col: 1, offset: 7709}, - expr: &actionExpr{ - pos: position{line: 326, col: 12, offset: 7720}, - run: (*parser).callonQueries1, - expr: &seqExpr{ - pos: position{line: 326, col: 12, offset: 7720}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 326, col: 12, offset: 7720}, - val: "queries", - ignoreCase: false, - want: "\"queries\"", - }, - &ruleRefExpr{ - pos: position{line: 326, col: 22, offset: 7730}, - name: "_", - }, - &litMatcher{ - pos: position{line: 326, col: 24, offset: 7732}, - val: "[", - ignoreCase: false, - want: "\"[\"", - }, - &ruleRefExpr{ - pos: position{line: 326, col: 28, offset: 7736}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 326, col: 30, offset: 7738}, - label: "Queries", - expr: &zeroOrMoreExpr{ - pos: position{line: 326, col: 39, offset: 7747}, - expr: &ruleRefExpr{ - pos: position{line: 326, col: 39, offset: 7747}, - name: "Query", - }, - }, - }, - &litMatcher{ - pos: position{line: 326, col: 47, offset: 7755}, - val: "]", - ignoreCase: false, - want: "\"]\"", - }, - &ruleRefExpr{ - pos: position{line: 326, col: 51, offset: 7759}, - name: "_", - }, - }, - }, - }, - }, - { - name: "Query", - pos: position{line: 330, col: 1, offset: 7787}, - expr: &actionExpr{ - pos: position{line: 330, col: 10, offset: 7796}, - run: (*parser).callonQuery1, - expr: &seqExpr{ - pos: position{line: 330, col: 10, offset: 7796}, - exprs: []interface{}{ - &zeroOrMoreExpr{ - pos: position{line: 330, col: 10, offset: 7796}, - expr: &ruleRefExpr{ - pos: position{line: 330, col: 10, offset: 7796}, - name: "Comment", - }, - }, - &labeledExpr{ - pos: position{line: 330, col: 19, offset: 7805}, - label: "Query", - expr: &choiceExpr{ - pos: position{line: 330, col: 26, offset: 7812}, - alternatives: []interface{}{ - &ruleRefExpr{ - pos: position{line: 330, col: 26, offset: 7812}, - name: "QueryConfidentiality", - }, - &ruleRefExpr{ - pos: position{line: 330, col: 47, offset: 7833}, - name: "QueryAuthentication", - }, - &ruleRefExpr{ - pos: position{line: 330, col: 67, offset: 7853}, - name: "QueryFreshness", - }, - &ruleRefExpr{ - pos: position{line: 330, col: 82, offset: 7868}, - name: "QueryUnlinkability", - }, - &ruleRefExpr{ - pos: position{line: 330, col: 101, offset: 7887}, - name: "QueryEquivalence", - }, - }, - }, - }, - &zeroOrMoreExpr{ - pos: position{line: 330, col: 119, offset: 7905}, - expr: &ruleRefExpr{ - pos: position{line: 330, col: 119, offset: 7905}, - name: "Comment", - }, - }, - }, - }, - }, - }, - { - name: "QueryConfidentiality", - pos: position{line: 334, col: 1, offset: 7938}, - expr: &actionExpr{ - pos: position{line: 334, col: 25, offset: 7962}, - run: (*parser).callonQueryConfidentiality1, - expr: &seqExpr{ - pos: position{line: 334, col: 25, offset: 7962}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 334, col: 25, offset: 7962}, - val: "confidentiality?", - ignoreCase: false, - want: "\"confidentiality?\"", - }, - &ruleRefExpr{ - pos: position{line: 334, col: 44, offset: 7981}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 334, col: 46, offset: 7983}, - label: "Const", - expr: &zeroOrOneExpr{ - pos: position{line: 334, col: 52, offset: 7989}, - expr: &ruleRefExpr{ - pos: position{line: 334, col: 52, offset: 7989}, - name: "Constant", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 334, col: 62, offset: 7999}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 334, col: 64, offset: 8001}, - label: "Options", - expr: &zeroOrOneExpr{ - pos: position{line: 334, col: 72, offset: 8009}, - expr: &ruleRefExpr{ - pos: position{line: 334, col: 72, offset: 8009}, - name: "QueryOptions", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 334, col: 86, offset: 8023}, - name: "_", - }, - }, - }, - }, - }, - { - name: "QueryAuthentication", - pos: position{line: 349, col: 1, offset: 8363}, - expr: &actionExpr{ - pos: position{line: 349, col: 24, offset: 8386}, - run: (*parser).callonQueryAuthentication1, - expr: &seqExpr{ - pos: position{line: 349, col: 24, offset: 8386}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 349, col: 24, offset: 8386}, - val: "authentication?", - ignoreCase: false, - want: "\"authentication?\"", - }, - &ruleRefExpr{ - pos: position{line: 349, col: 42, offset: 8404}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 349, col: 44, offset: 8406}, - label: "Message", - expr: &zeroOrOneExpr{ - pos: position{line: 349, col: 52, offset: 8414}, - expr: &ruleRefExpr{ - pos: position{line: 349, col: 52, offset: 8414}, - name: "Message", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 349, col: 61, offset: 8423}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 349, col: 63, offset: 8425}, - label: "Options", - expr: &zeroOrOneExpr{ - pos: position{line: 349, col: 71, offset: 8433}, - expr: &ruleRefExpr{ - pos: position{line: 349, col: 71, offset: 8433}, - name: "QueryOptions", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 349, col: 85, offset: 8447}, - name: "_", - }, - }, - }, - }, - }, - { - name: "QueryFreshness", - pos: position{line: 364, col: 1, offset: 8771}, - expr: &actionExpr{ - pos: position{line: 364, col: 19, offset: 8789}, - run: (*parser).callonQueryFreshness1, - expr: &seqExpr{ - pos: position{line: 364, col: 19, offset: 8789}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 364, col: 19, offset: 8789}, - val: "freshness?", - ignoreCase: false, - want: "\"freshness?\"", - }, - &ruleRefExpr{ - pos: position{line: 364, col: 32, offset: 8802}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 364, col: 34, offset: 8804}, - label: "Const", - expr: &zeroOrOneExpr{ - pos: position{line: 364, col: 40, offset: 8810}, - expr: &ruleRefExpr{ - pos: position{line: 364, col: 40, offset: 8810}, - name: "Constant", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 364, col: 50, offset: 8820}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 364, col: 52, offset: 8822}, - label: "Options", - expr: &zeroOrOneExpr{ - pos: position{line: 364, col: 60, offset: 8830}, - expr: &ruleRefExpr{ - pos: position{line: 364, col: 60, offset: 8830}, - name: "QueryOptions", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 364, col: 74, offset: 8844}, - name: "_", - }, - }, - }, - }, - }, - { - name: "QueryUnlinkability", - pos: position{line: 379, col: 1, offset: 9172}, - expr: &actionExpr{ - pos: position{line: 379, col: 23, offset: 9194}, - run: (*parser).callonQueryUnlinkability1, - expr: &seqExpr{ - pos: position{line: 379, col: 23, offset: 9194}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 379, col: 23, offset: 9194}, - val: "unlinkability?", - ignoreCase: false, - want: "\"unlinkability?\"", - }, - &ruleRefExpr{ - pos: position{line: 379, col: 40, offset: 9211}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 379, col: 42, offset: 9213}, - label: "Consts", - expr: &zeroOrOneExpr{ - pos: position{line: 379, col: 49, offset: 9220}, - expr: &ruleRefExpr{ - pos: position{line: 379, col: 49, offset: 9220}, - name: "Constants", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 379, col: 60, offset: 9231}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 379, col: 62, offset: 9233}, - label: "Options", - expr: &zeroOrOneExpr{ - pos: position{line: 379, col: 70, offset: 9241}, - expr: &ruleRefExpr{ - pos: position{line: 379, col: 70, offset: 9241}, - name: "QueryOptions", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 379, col: 84, offset: 9255}, - name: "_", - }, - }, - }, - }, - }, - { - name: "QueryEquivalence", - pos: position{line: 394, col: 1, offset: 9569}, - expr: &actionExpr{ - pos: position{line: 394, col: 21, offset: 9589}, - run: (*parser).callonQueryEquivalence1, - expr: &seqExpr{ - pos: position{line: 394, col: 21, offset: 9589}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 394, col: 21, offset: 9589}, - val: "equivalence?", - ignoreCase: false, - want: "\"equivalence?\"", - }, - &ruleRefExpr{ - pos: position{line: 394, col: 36, offset: 9604}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 394, col: 38, offset: 9606}, - label: "Consts", - expr: &zeroOrOneExpr{ - pos: position{line: 394, col: 45, offset: 9613}, - expr: &ruleRefExpr{ - pos: position{line: 394, col: 45, offset: 9613}, - name: "Constants", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 394, col: 56, offset: 9624}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 394, col: 58, offset: 9626}, - label: "Options", - expr: &zeroOrOneExpr{ - pos: position{line: 394, col: 66, offset: 9634}, - expr: &ruleRefExpr{ - pos: position{line: 394, col: 66, offset: 9634}, - name: "QueryOptions", - }, - }, - }, - &ruleRefExpr{ - pos: position{line: 394, col: 80, offset: 9648}, - name: "_", - }, - }, - }, - }, - }, - { - name: "QueryOptions", - pos: position{line: 409, col: 1, offset: 9958}, - expr: &actionExpr{ - pos: position{line: 409, col: 17, offset: 9974}, - run: (*parser).callonQueryOptions1, - expr: &seqExpr{ - pos: position{line: 409, col: 17, offset: 9974}, - exprs: []interface{}{ - &litMatcher{ - pos: position{line: 409, col: 17, offset: 9974}, - val: "[", - ignoreCase: false, - want: "\"[\"", - }, - &ruleRefExpr{ - pos: position{line: 409, col: 21, offset: 9978}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 409, col: 23, offset: 9980}, - label: "Options", - expr: &zeroOrMoreExpr{ - pos: position{line: 409, col: 32, offset: 9989}, - expr: &ruleRefExpr{ - pos: position{line: 409, col: 32, offset: 9989}, - name: "QueryOption", - }, - }, - }, - &litMatcher{ - pos: position{line: 409, col: 46, offset: 10003}, - val: "]", - ignoreCase: false, - want: "\"]\"", - }, - &ruleRefExpr{ - pos: position{line: 409, col: 50, offset: 10007}, - name: "_", - }, - }, - }, - }, - }, - { - name: "QueryOption", - pos: position{line: 416, col: 1, offset: 10144}, - expr: &actionExpr{ - pos: position{line: 416, col: 16, offset: 10159}, - run: (*parser).callonQueryOption1, - expr: &seqExpr{ - pos: position{line: 416, col: 16, offset: 10159}, - exprs: []interface{}{ - &labeledExpr{ - pos: position{line: 416, col: 16, offset: 10159}, - label: "OptionName", - expr: &ruleRefExpr{ - pos: position{line: 416, col: 27, offset: 10170}, - name: "Identifier", - }, - }, - &ruleRefExpr{ - pos: position{line: 416, col: 38, offset: 10181}, - name: "_", - }, - &litMatcher{ - pos: position{line: 416, col: 40, offset: 10183}, - val: "[", - ignoreCase: false, - want: "\"[\"", - }, - &ruleRefExpr{ - pos: position{line: 416, col: 44, offset: 10187}, - name: "_", - }, - &labeledExpr{ - pos: position{line: 416, col: 46, offset: 10189}, - label: "Message", - expr: &ruleRefExpr{ - pos: position{line: 416, col: 54, offset: 10197}, - name: "Message", - }, - }, - &ruleRefExpr{ - pos: position{line: 416, col: 62, offset: 10205}, - name: "_", - }, - &litMatcher{ - pos: position{line: 416, col: 64, offset: 10207}, - val: "]", - ignoreCase: false, - want: "\"]\"", - }, - &ruleRefExpr{ - pos: position{line: 416, col: 68, offset: 10211}, - name: "_", - }, - }, - }, - }, - }, - { - name: "Identifier", - pos: position{line: 428, col: 1, offset: 10429}, - expr: &actionExpr{ - pos: position{line: 428, col: 15, offset: 10443}, - run: (*parser).callonIdentifier1, - expr: &labeledExpr{ - pos: position{line: 428, col: 15, offset: 10443}, - label: "Identifier", - expr: &oneOrMoreExpr{ - pos: position{line: 428, col: 26, offset: 10454}, - expr: &charClassMatcher{ - pos: position{line: 428, col: 26, offset: 10454}, - val: "[a-zA-Z0-9_]", - chars: []rune{'_'}, - ranges: []rune{'a', 'z', 'A', 'Z', '0', '9'}, - ignoreCase: false, - inverted: false, - }, - }, - }, - }, - }, - { - name: "Comment", - pos: position{line: 433, col: 1, offset: 10544}, - expr: &seqExpr{ - pos: position{line: 433, col: 12, offset: 10555}, - exprs: []interface{}{ - &ruleRefExpr{ - pos: position{line: 433, col: 12, offset: 10555}, - name: "_", - }, - &litMatcher{ - pos: position{line: 433, col: 14, offset: 10557}, - val: "//", - ignoreCase: false, - want: "\"//\"", - }, - &zeroOrMoreExpr{ - pos: position{line: 433, col: 19, offset: 10562}, - expr: &charClassMatcher{ - pos: position{line: 433, col: 19, offset: 10562}, - val: "[^\\n]", - chars: []rune{'\n'}, - ignoreCase: false, - inverted: true, - }, - }, - &ruleRefExpr{ - pos: position{line: 433, col: 26, offset: 10569}, - name: "_", - }, - }, - }, - }, - { - name: "_", - displayName: "\"whitespace\"", - pos: position{line: 435, col: 1, offset: 10572}, - expr: &zeroOrMoreExpr{ - pos: position{line: 435, col: 19, offset: 10590}, - expr: &charClassMatcher{ - pos: position{line: 435, col: 19, offset: 10590}, - val: "[ \\t\\n\\r]", - chars: []rune{' ', '\t', '\n', '\r'}, - ignoreCase: false, - inverted: false, - }, - }, - }, - { - name: "EOF", - pos: position{line: 437, col: 1, offset: 10602}, - expr: ¬Expr{ - pos: position{line: 437, col: 8, offset: 10609}, - expr: &anyMatcher{ - line: 437, col: 9, offset: 10610, - }, - }, - }, - }, -} - -func (c *current) onModel1(Attacker, Blocks, Queries interface{}) (interface{}, error) { - switch { - case Attacker == nil: - return nil, errors.New("no `attacker` block defined") - case Blocks == nil: - return nil, errors.New("no principal or message blocks defined") - case Queries == nil: - return nil, errors.New("no `queries` block defined") - } - b := Blocks.([]interface{}) - q := Queries.([]interface{}) - db := make([]Block, len(b)) - dq := make([]Query, len(q)) - for i, v := range b { - db[i] = v.(Block) - } - for i, v := range q { - dq[i] = v.(Query) - } - return Model{ - Attacker: Attacker.(string), - Blocks: db, - Queries: dq, - }, nil -} - -func (p *parser) callonModel1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onModel1(stack["Attacker"], stack["Blocks"], stack["Queries"]) -} - -func (c *current) onAttacker1(Type interface{}) (interface{}, error) { - if Type == nil { - return nil, errors.New("`attacker` is declared with missing attacker type") - } - return Type, nil -} - -func (p *parser) callonAttacker1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onAttacker1(stack["Type"]) -} - -func (c *current) onAttackerType1() (interface{}, error) { - return string(c.text), nil -} - -func (p *parser) callonAttackerType1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onAttackerType1() -} - -func (c *current) onBlock1(Block interface{}) (interface{}, error) { - return Block, nil -} - -func (p *parser) callonBlock1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onBlock1(stack["Block"]) -} - -func (c *current) onPrincipal1(Name, Expressions interface{}) (interface{}, error) { - e := Expressions.([]interface{}) - de := make([]Expression, len(e)) - for i, v := range e { - de[i] = v.(Expression) - } - id := principalNamesMapAdd(Name.(string)) - return Block{ - Kind: "principal", - Principal: Principal{ - Name: Name.(string), - ID: id, - Expressions: de, - }, - }, nil -} - -func (p *parser) callonPrincipal1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onPrincipal1(stack["Name"], stack["Expressions"]) -} - -func (c *current) onPrincipalName1(Name interface{}) (interface{}, error) { - err := libpegCheckIfReserved(Name.(string)) - return strings.Title(Name.(string)), err -} - -func (p *parser) callonPrincipalName1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onPrincipalName1(stack["Name"]) -} - -func (c *current) onQualifier1() (interface{}, error) { - switch string(c.text) { - default: - return typesEnumPrivate, nil - case "public": - return typesEnumPublic, nil - case "password": - return typesEnumPassword, nil - } -} - -func (p *parser) callonQualifier1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQualifier1() -} - -func (c *current) onMessage1(Sender, Recipient, Constants interface{}) (interface{}, error) { - switch { - case Sender == nil: - return nil, errors.New("message sender is not defined") - case Recipient == nil: - return nil, errors.New("message recipient is not defined") - case Constants == nil: - return nil, errors.New("message constants are not defined") - } - senderID := principalNamesMapAdd(Sender.(string)) - recipientID := principalNamesMapAdd(Recipient.(string)) - return Block{ - Kind: "message", - Message: Message{ - Sender: senderID, - Recipient: recipientID, - Constants: Constants.([]*Constant), - }, - }, nil -} - -func (p *parser) callonMessage1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onMessage1(stack["Sender"], stack["Recipient"], stack["Constants"]) -} - -func (c *current) onMessageConstants1(MessageConstants interface{}) (interface{}, error) { - var da []*Constant - a := MessageConstants.([]interface{}) - for _, v := range a { - c := v.(*Value).Data.(*Constant) - da = append(da, c) - } - return da, nil -} - -func (p *parser) callonMessageConstants1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onMessageConstants1(stack["MessageConstants"]) -} - -func (c *current) onExpression1(Expression interface{}) (interface{}, error) { - return Expression, nil -} - -func (p *parser) callonExpression1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onExpression1(stack["Expression"]) -} - -func (c *current) onKnows1(Qualifier, Constants interface{}) (interface{}, error) { - switch { - case Qualifier == nil: - return nil, errors.New("`knows` declaration is missing qualifier") - case Constants == nil: - return nil, errors.New("`knows` declaration is missing constant name(s)") - } - return Expression{ - Kind: typesEnumKnows, - Qualifier: Qualifier.(typesEnum), - Constants: Constants.([]*Constant), - }, nil -} - -func (p *parser) callonKnows1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onKnows1(stack["Qualifier"], stack["Constants"]) -} - -func (c *current) onGenerates1(Constants interface{}) (interface{}, error) { - if Constants == nil { - return nil, errors.New("`generates` declaration is missing constant name(s)") - } - return Expression{ - Kind: typesEnumGenerates, - Qualifier: typesEnumEmpty, - Constants: Constants.([]*Constant), - }, nil -} - -func (p *parser) callonGenerates1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onGenerates1(stack["Constants"]) -} - -func (c *current) onLeaks1(Constants interface{}) (interface{}, error) { - if Constants == nil { - return nil, errors.New("`leaks` declaration is missing constant name(s)") - } - return Expression{ - Kind: typesEnumLeaks, - Qualifier: typesEnumEmpty, - Constants: Constants.([]*Constant), - }, nil -} - -func (p *parser) callonLeaks1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onLeaks1(stack["Constants"]) -} - -func (c *current) onAssignment1(Left, Right interface{}) (interface{}, error) { - if Left == nil || Right == nil { - return nil, errors.New("invalid value assignment") - } - switch Right.(*Value).Kind { - case typesEnumConstant: - err := errors.New("cannot assign value to value") - return nil, err - } - return Expression{ - Kind: typesEnumAssignment, - Constants: Left.([]*Constant), - Assigned: Right.(*Value), - }, nil -} - -func (p *parser) callonAssignment1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onAssignment1(stack["Left"], stack["Right"]) -} - -func (c *current) onConstant1(Const interface{}) (interface{}, error) { - var err error - name := Const.(string) - err = libpegCheckIfReserved(name) - if err != nil { - return &Value{}, err - } - switch name { - case "_": - name = fmt.Sprintf("unnamed_%d", libpegUnnamedCounter) - libpegUnnamedCounter = libpegUnnamedCounter + 1 - } - id := valueNamesMapAdd(name) - return &Value{ - Kind: typesEnumConstant, - Data: &Constant{ - Name: name, - ID: id, - }, - }, err -} - -func (p *parser) callonConstant1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onConstant1(stack["Const"]) -} - -func (c *current) onConstants1(Constants interface{}) (interface{}, error) { - var da []*Constant - a := Constants.([]interface{}) - for _, c := range a { - da = append(da, c.(*Value).Data.(*Constant)) - } - return da, nil -} - -func (p *parser) callonConstants1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onConstants1(stack["Constants"]) -} - -func (c *current) onPhase1(Number interface{}) (interface{}, error) { - a := Number.([]interface{}) - da := make([]uint8, len(a)) - for i, v := range a { - da[i] = v.([]uint8)[0] - } - n, err := strconv.Atoi(b2s(da)) - return Block{ - Kind: "phase", - Phase: Phase{ - Number: n, - }, - }, err -} - -func (p *parser) callonPhase1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onPhase1(stack["Number"]) -} - -func (c *current) onGuardedConstant1(Guarded interface{}) (interface{}, error) { - g := Guarded.(*Value) - err := libpegCheckIfReserved(g.Data.(*Constant).Name) - return &Value{ - Kind: typesEnumConstant, - Data: &Constant{ - Name: g.Data.(*Constant).Name, - ID: g.Data.(*Constant).ID, - Guard: true, - }, - }, err -} - -func (p *parser) callonGuardedConstant1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onGuardedConstant1(stack["Guarded"]) -} - -func (c *current) onPrimitive1(Name, Arguments, Check interface{}) (interface{}, error) { - args := []*Value{} - for _, a := range Arguments.([]interface{}) { - args = append(args, a.(*Value)) - } - primEnum, err := primitiveGetEnum(Name.(string)) - return &Value{ - Kind: typesEnumPrimitive, - Data: &Primitive{ - ID: primEnum, - Arguments: args, - Output: 0, - Check: Check != nil, - }, - }, err -} - -func (p *parser) callonPrimitive1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onPrimitive1(stack["Name"], stack["Arguments"], stack["Check"]) -} - -func (c *current) onPrimitiveName1(Name interface{}) (interface{}, error) { - return strings.ToUpper(Name.(string)), nil -} - -func (p *parser) callonPrimitiveName1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onPrimitiveName1(stack["Name"]) -} - -func (c *current) onEquation1(First, Second interface{}) (interface{}, error) { - return &Value{ - Kind: typesEnumEquation, - Data: &Equation{ - Values: []*Value{ - First.(*Value), - Second.(*Value), - }, - }, - }, nil -} - -func (p *parser) callonEquation1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onEquation1(stack["First"], stack["Second"]) -} - -func (c *current) onQueries1(Queries interface{}) (interface{}, error) { - return Queries, nil -} - -func (p *parser) callonQueries1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQueries1(stack["Queries"]) -} - -func (c *current) onQuery1(Query interface{}) (interface{}, error) { - return Query, nil -} - -func (p *parser) callonQuery1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQuery1(stack["Query"]) -} - -func (c *current) onQueryConfidentiality1(Const, Options interface{}) (interface{}, error) { - switch { - case Const == nil: - return nil, errors.New("`confidentiality` query is missing constant") - case Options == nil: - Options = []QueryOption{} - } - return Query{ - Kind: typesEnumConfidentiality, - Constants: []*Constant{Const.(*Value).Data.(*Constant)}, - Message: Message{}, - Options: Options.([]QueryOption), - }, nil -} - -func (p *parser) callonQueryConfidentiality1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQueryConfidentiality1(stack["Const"], stack["Options"]) -} - -func (c *current) onQueryAuthentication1(Message, Options interface{}) (interface{}, error) { - switch { - case Message == nil: - return nil, errors.New("`authentication` query is missing message") - case Options == nil: - Options = []QueryOption{} - } - return Query{ - Kind: typesEnumAuthentication, - Constants: []*Constant{}, - Message: (Message.(Block)).Message, - Options: Options.([]QueryOption), - }, nil -} - -func (p *parser) callonQueryAuthentication1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQueryAuthentication1(stack["Message"], stack["Options"]) -} - -func (c *current) onQueryFreshness1(Const, Options interface{}) (interface{}, error) { - switch { - case Const == nil: - return nil, errors.New("`freshness` query is missing constant") - case Options == nil: - Options = []QueryOption{} - } - return Query{ - Kind: typesEnumFreshness, - Constants: []*Constant{Const.(*Value).Data.(*Constant)}, - Message: Message{}, - Options: Options.([]QueryOption), - }, nil -} - -func (p *parser) callonQueryFreshness1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQueryFreshness1(stack["Const"], stack["Options"]) -} - -func (c *current) onQueryUnlinkability1(Consts, Options interface{}) (interface{}, error) { - switch { - case Consts == nil: - return nil, errors.New("`unlinkability` query is missing constants") - case Options == nil: - Options = []QueryOption{} - } - return Query{ - Kind: typesEnumUnlinkability, - Constants: Consts.([]*Constant), - Message: Message{}, - Options: Options.([]QueryOption), - }, nil -} - -func (p *parser) callonQueryUnlinkability1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQueryUnlinkability1(stack["Consts"], stack["Options"]) -} - -func (c *current) onQueryEquivalence1(Consts, Options interface{}) (interface{}, error) { - switch { - case Consts == nil: - return nil, errors.New("`equivalence` query is missing constants") - case Options == nil: - Options = []QueryOption{} - } - return Query{ - Kind: typesEnumEquivalence, - Constants: Consts.([]*Constant), - Message: Message{}, - Options: Options.([]QueryOption), - }, nil -} - -func (p *parser) callonQueryEquivalence1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQueryEquivalence1(stack["Consts"], stack["Options"]) -} - -func (c *current) onQueryOptions1(Options interface{}) (interface{}, error) { - o := Options.([]interface{}) - do := make([]QueryOption, len(o)) - for i, v := range o { - do[i] = v.(QueryOption) - } - return do, nil -} - -func (p *parser) callonQueryOptions1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQueryOptions1(stack["Options"]) -} - -func (c *current) onQueryOption1(OptionName, Message interface{}) (interface{}, error) { - optionEnum := typesEnumEmpty - switch OptionName.(string) { - case "precondition": - optionEnum = typesEnumPrecondition - } - return QueryOption{ - Kind: optionEnum, - Message: (Message.(Block)).Message, - }, nil -} - -func (p *parser) callonQueryOption1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onQueryOption1(stack["OptionName"], stack["Message"]) -} - -func (c *current) onIdentifier1(Identifier interface{}) (interface{}, error) { - identifier := strings.ToLower(string(c.text)) - return identifier, nil -} - -func (p *parser) callonIdentifier1() (interface{}, error) { - stack := p.vstack[len(p.vstack)-1] - _ = stack - return p.cur.onIdentifier1(stack["Identifier"]) -} - -var ( - // errNoRule is returned when the grammar to parse has no rule. - errNoRule = errors.New("grammar has no rule") - - // errInvalidEntrypoint is returned when the specified entrypoint rule - // does not exit. - errInvalidEntrypoint = errors.New("invalid entrypoint") - - // errInvalidEncoding is returned when the source is not properly - // utf8-encoded. - errInvalidEncoding = errors.New("invalid encoding") - - // errMaxExprCnt is used to signal that the maximum number of - // expressions have been parsed. - errMaxExprCnt = errors.New("max number of expresssions parsed") -) - -// Option is a function that can set an option on the parser. It returns -// the previous setting as an Option. -type Option func(*parser) Option - -// MaxExpressions creates an Option to stop parsing after the provided -// number of expressions have been parsed, if the value is 0 then the parser will -// parse for as many steps as needed (possibly an infinite number). -// -// The default for maxExprCnt is 0. -func MaxExpressions(maxExprCnt uint64) Option { - return func(p *parser) Option { - oldMaxExprCnt := p.maxExprCnt - p.maxExprCnt = maxExprCnt - return MaxExpressions(oldMaxExprCnt) - } -} - -// Entrypoint creates an Option to set the rule name to use as entrypoint. -// The rule name must have been specified in the -alternate-entrypoints -// if generating the parser with the -optimize-grammar flag, otherwise -// it may have been optimized out. Passing an empty string sets the -// entrypoint to the first rule in the grammar. -// -// The default is to start parsing at the first rule in the grammar. -func Entrypoint(ruleName string) Option { - return func(p *parser) Option { - oldEntrypoint := p.entrypoint - p.entrypoint = ruleName - if ruleName == "" { - p.entrypoint = g.rules[0].name - } - return Entrypoint(oldEntrypoint) - } -} - -// Statistics adds a user provided Stats struct to the parser to allow -// the user to process the results after the parsing has finished. -// Also the key for the "no match" counter is set. -// -// Example usage: -// -// input := "input" -// stats := Stats{} -// _, err := Parse("input-file", []byte(input), Statistics(&stats, "no match")) -// if err != nil { -// log.Panicln(err) -// } -// b, err := json.MarshalIndent(stats.ChoiceAltCnt, "", " ") -// if err != nil { -// log.Panicln(err) -// } -// fmt.Println(string(b)) -func Statistics(stats *Stats, choiceNoMatch string) Option { - return func(p *parser) Option { - oldStats := p.Stats - p.Stats = stats - oldChoiceNoMatch := p.choiceNoMatch - p.choiceNoMatch = choiceNoMatch - if p.Stats.ChoiceAltCnt == nil { - p.Stats.ChoiceAltCnt = make(map[string]map[string]int) - } - return Statistics(oldStats, oldChoiceNoMatch) - } -} - -// Debug creates an Option to set the debug flag to b. When set to true, -// debugging information is printed to stdout while parsing. -// -// The default is false. -func Debug(b bool) Option { - return func(p *parser) Option { - old := p.debug - p.debug = b - return Debug(old) - } -} - -// Memoize creates an Option to set the memoize flag to b. When set to true, -// the parser will cache all results so each expression is evaluated only -// once. This guarantees linear parsing time even for pathological cases, -// at the expense of more memory and slower times for typical cases. -// -// The default is false. -func Memoize(b bool) Option { - return func(p *parser) Option { - old := p.memoize - p.memoize = b - return Memoize(old) - } -} - -// AllowInvalidUTF8 creates an Option to allow invalid UTF-8 bytes. -// Every invalid UTF-8 byte is treated as a utf8.RuneError (U+FFFD) -// by character class matchers and is matched by the any matcher. -// The returned matched value, c.text and c.offset are NOT affected. -// -// The default is false. -func AllowInvalidUTF8(b bool) Option { - return func(p *parser) Option { - old := p.allowInvalidUTF8 - p.allowInvalidUTF8 = b - return AllowInvalidUTF8(old) - } -} - -// Recover creates an Option to set the recover flag to b. When set to -// true, this causes the parser to recover from panics and convert it -// to an error. Setting it to false can be useful while debugging to -// access the full stack trace. -// -// The default is true. -func Recover(b bool) Option { - return func(p *parser) Option { - old := p.recover - p.recover = b - return Recover(old) - } -} - -// GlobalStore creates an Option to set a key to a certain value in -// the globalStore. -func GlobalStore(key string, value interface{}) Option { - return func(p *parser) Option { - old := p.cur.globalStore[key] - p.cur.globalStore[key] = value - return GlobalStore(key, old) - } -} - -// InitState creates an Option to set a key to a certain value in -// the global "state" store. -func InitState(key string, value interface{}) Option { - return func(p *parser) Option { - old := p.cur.state[key] - p.cur.state[key] = value - return InitState(key, old) - } -} - -// ParseFile parses the file identified by filename. -func ParseFile(filename string, opts ...Option) (i interface{}, err error) { - f, err := os.Open(filename) - if err != nil { - return nil, err - } - defer func() { - if closeErr := f.Close(); closeErr != nil { - err = closeErr - } - }() - return ParseReader(filename, f, opts...) -} - -// ParseReader parses the data from r using filename as information in the -// error messages. -func ParseReader(filename string, r io.Reader, opts ...Option) (interface{}, error) { - b, err := ioutil.ReadAll(r) - if err != nil { - return nil, err - } - - return Parse(filename, b, opts...) -} - -// Parse parses the data from b using filename as information in the -// error messages. -func Parse(filename string, b []byte, opts ...Option) (interface{}, error) { - return newParser(filename, b, opts...).parse(g) -} - -// position records a position in the text. -type position struct { - line, col, offset int -} - -func (p position) String() string { - return strconv.Itoa(p.line) + ":" + strconv.Itoa(p.col) + " [" + strconv.Itoa(p.offset) + "]" -} - -// savepoint stores all state required to go back to this point in the -// parser. -type savepoint struct { - position - rn rune - w int -} - -type current struct { - pos position // start position of the match - text []byte // raw text of the match - - // state is a store for arbitrary key,value pairs that the user wants to be - // tied to the backtracking of the parser. - // This is always rolled back if a parsing rule fails. - state storeDict - - // globalStore is a general store for the user to store arbitrary key-value - // pairs that they need to manage and that they do not want tied to the - // backtracking of the parser. This is only modified by the user and never - // rolled back by the parser. It is always up to the user to keep this in a - // consistent state. - globalStore storeDict -} - -type storeDict map[string]interface{} - -// the AST types... - -type grammar struct { - pos position - rules []*rule -} - -type rule struct { - pos position - name string - displayName string - expr interface{} -} - -type choiceExpr struct { - pos position - alternatives []interface{} -} - -type actionExpr struct { - pos position - expr interface{} - run func(*parser) (interface{}, error) -} - -type recoveryExpr struct { - pos position - expr interface{} - recoverExpr interface{} - failureLabel []string -} - -type seqExpr struct { - pos position - exprs []interface{} -} - -type throwExpr struct { - pos position - label string -} - -type labeledExpr struct { - pos position - label string - expr interface{} -} - -type expr struct { - pos position - expr interface{} -} - -type andExpr expr -type notExpr expr -type zeroOrOneExpr expr -type zeroOrMoreExpr expr -type oneOrMoreExpr expr - -type ruleRefExpr struct { - pos position - name string -} - -type stateCodeExpr struct { - pos position - run func(*parser) error -} - -type andCodeExpr struct { - pos position - run func(*parser) (bool, error) -} - -type notCodeExpr struct { - pos position - run func(*parser) (bool, error) -} - -type litMatcher struct { - pos position - val string - ignoreCase bool - want string -} - -type charClassMatcher struct { - pos position - val string - basicLatinChars [128]bool - chars []rune - ranges []rune - classes []*unicode.RangeTable - ignoreCase bool - inverted bool -} - -type anyMatcher position - -// errList cumulates the errors found by the parser. -type errList []error - -func (e *errList) add(err error) { - *e = append(*e, err) -} - -func (e errList) err() error { - if len(e) == 0 { - return nil - } - e.dedupe() - return e -} - -func (e *errList) dedupe() { - var cleaned []error - set := make(map[string]bool) - for _, err := range *e { - if msg := err.Error(); !set[msg] { - set[msg] = true - cleaned = append(cleaned, err) - } - } - *e = cleaned -} - -func (e errList) Error() string { - switch len(e) { - case 0: - return "" - case 1: - return e[0].Error() - default: - var buf bytes.Buffer - - for i, err := range e { - if i > 0 { - buf.WriteRune('\n') - } - buf.WriteString(err.Error()) - } - return buf.String() - } -} - -// parserError wraps an error with a prefix indicating the rule in which -// the error occurred. The original error is stored in the Inner field. -type parserError struct { - Inner error - pos position - prefix string - expected []string -} - -// Error returns the error message. -func (p *parserError) Error() string { - return p.prefix + ": " + p.Inner.Error() -} - -// newParser creates a parser with the specified input source and options. -func newParser(filename string, b []byte, opts ...Option) *parser { - stats := Stats{ - ChoiceAltCnt: make(map[string]map[string]int), - } - - p := &parser{ - filename: filename, - errs: new(errList), - data: b, - pt: savepoint{position: position{line: 1}}, - recover: true, - cur: current{ - state: make(storeDict), - globalStore: make(storeDict), - }, - maxFailPos: position{col: 1, line: 1}, - maxFailExpected: make([]string, 0, 20), - Stats: &stats, - // start rule is rule [0] unless an alternate entrypoint is specified - entrypoint: g.rules[0].name, - } - p.setOptions(opts) - - if p.maxExprCnt == 0 { - p.maxExprCnt = math.MaxUint64 - } - - return p -} - -// setOptions applies the options to the parser. -func (p *parser) setOptions(opts []Option) { - for _, opt := range opts { - opt(p) - } -} - -type resultTuple struct { - v interface{} - b bool - end savepoint -} - -const choiceNoMatch = -1 - -// Stats stores some statistics, gathered during parsing -type Stats struct { - // ExprCnt counts the number of expressions processed during parsing - // This value is compared to the maximum number of expressions allowed - // (set by the MaxExpressions option). - ExprCnt uint64 - - // ChoiceAltCnt is used to count for each ordered choice expression, - // which alternative is used how may times. - // These numbers allow to optimize the order of the ordered choice expression - // to increase the performance of the parser - // - // The outer key of ChoiceAltCnt is composed of the name of the rule as well - // as the line and the column of the ordered choice. - // The inner key of ChoiceAltCnt is the number (one-based) of the matching alternative. - // For each alternative the number of matches are counted. If an ordered choice does not - // match, a special counter is incremented. The name of this counter is set with - // the parser option Statistics. - // For an alternative to be included in ChoiceAltCnt, it has to match at least once. - ChoiceAltCnt map[string]map[string]int -} - -type parser struct { - filename string - pt savepoint - cur current - - data []byte - errs *errList - - depth int - recover bool - debug bool - - memoize bool - // memoization table for the packrat algorithm: - // map[offset in source] map[expression or rule] {value, match} - memo map[int]map[interface{}]resultTuple - - // rules table, maps the rule identifier to the rule node - rules map[string]*rule - // variables stack, map of label to value - vstack []map[string]interface{} - // rule stack, allows identification of the current rule in errors - rstack []*rule - - // parse fail - maxFailPos position - maxFailExpected []string - maxFailInvertExpected bool - - // max number of expressions to be parsed - maxExprCnt uint64 - // entrypoint for the parser - entrypoint string - - allowInvalidUTF8 bool - - *Stats - - choiceNoMatch string - // recovery expression stack, keeps track of the currently available recovery expression, these are traversed in reverse - recoveryStack []map[string]interface{} -} - -// push a variable set on the vstack. -func (p *parser) pushV() { - if cap(p.vstack) == len(p.vstack) { - // create new empty slot in the stack - p.vstack = append(p.vstack, nil) - } else { - // slice to 1 more - p.vstack = p.vstack[:len(p.vstack)+1] - } - - // get the last args set - m := p.vstack[len(p.vstack)-1] - if m != nil && len(m) == 0 { - // empty map, all good - return - } - - m = make(map[string]interface{}) - p.vstack[len(p.vstack)-1] = m -} - -// pop a variable set from the vstack. -func (p *parser) popV() { - // if the map is not empty, clear it - m := p.vstack[len(p.vstack)-1] - if len(m) > 0 { - // GC that map - p.vstack[len(p.vstack)-1] = nil - } - p.vstack = p.vstack[:len(p.vstack)-1] -} - -// push a recovery expression with its labels to the recoveryStack -func (p *parser) pushRecovery(labels []string, expr interface{}) { - if cap(p.recoveryStack) == len(p.recoveryStack) { - // create new empty slot in the stack - p.recoveryStack = append(p.recoveryStack, nil) - } else { - // slice to 1 more - p.recoveryStack = p.recoveryStack[:len(p.recoveryStack)+1] - } - - m := make(map[string]interface{}, len(labels)) - for _, fl := range labels { - m[fl] = expr - } - p.recoveryStack[len(p.recoveryStack)-1] = m -} - -// pop a recovery expression from the recoveryStack -func (p *parser) popRecovery() { - // GC that map - p.recoveryStack[len(p.recoveryStack)-1] = nil - - p.recoveryStack = p.recoveryStack[:len(p.recoveryStack)-1] -} - -func (p *parser) print(prefix, s string) string { - if !p.debug { - return s - } - - fmt.Printf("%s %d:%d:%d: %s [%#U]\n", - prefix, p.pt.line, p.pt.col, p.pt.offset, s, p.pt.rn) - return s -} - -func (p *parser) in(s string) string { - p.depth++ - return p.print(strings.Repeat(" ", p.depth)+">", s) -} - -func (p *parser) out(s string) string { - p.depth-- - return p.print(strings.Repeat(" ", p.depth)+"<", s) -} - -func (p *parser) addErr(err error) { - p.addErrAt(err, p.pt.position, []string{}) -} - -func (p *parser) addErrAt(err error, pos position, expected []string) { - var buf bytes.Buffer - if p.filename != "" { - buf.WriteString(p.filename) - } - if buf.Len() > 0 { - buf.WriteString(":") - } - buf.WriteString(fmt.Sprintf("%d:%d (%d)", pos.line, pos.col, pos.offset)) - if len(p.rstack) > 0 { - if buf.Len() > 0 { - buf.WriteString(": ") - } - rule := p.rstack[len(p.rstack)-1] - if rule.displayName != "" { - buf.WriteString("rule " + rule.displayName) - } else { - buf.WriteString("rule " + rule.name) - } - } - pe := &parserError{Inner: err, pos: pos, prefix: buf.String(), expected: expected} - p.errs.add(pe) -} - -func (p *parser) failAt(fail bool, pos position, want string) { - // process fail if parsing fails and not inverted or parsing succeeds and invert is set - if fail == p.maxFailInvertExpected { - if pos.offset < p.maxFailPos.offset { - return - } - - if pos.offset > p.maxFailPos.offset { - p.maxFailPos = pos - p.maxFailExpected = p.maxFailExpected[:0] - } - - if p.maxFailInvertExpected { - want = "!" + want - } - p.maxFailExpected = append(p.maxFailExpected, want) - } -} - -// read advances the parser to the next rune. -func (p *parser) read() { - p.pt.offset += p.pt.w - rn, n := utf8.DecodeRune(p.data[p.pt.offset:]) - p.pt.rn = rn - p.pt.w = n - p.pt.col++ - if rn == '\n' { - p.pt.line++ - p.pt.col = 0 - } - - if rn == utf8.RuneError && n == 1 { // see utf8.DecodeRune - if !p.allowInvalidUTF8 { - p.addErr(errInvalidEncoding) - } - } -} - -// restore parser position to the savepoint pt. -func (p *parser) restore(pt savepoint) { - if p.debug { - defer p.out(p.in("restore")) - } - if pt.offset == p.pt.offset { - return - } - p.pt = pt -} - -// Cloner is implemented by any value that has a Clone method, which returns a -// copy of the value. This is mainly used for types which are not passed by -// value (e.g map, slice, chan) or structs that contain such types. -// -// This is used in conjunction with the global state feature to create proper -// copies of the state to allow the parser to properly restore the state in -// the case of backtracking. -type Cloner interface { - Clone() interface{} -} - -var statePool = &sync.Pool{ - New: func() interface{} { return make(storeDict) }, -} - -func (sd storeDict) Discard() { - for k := range sd { - delete(sd, k) - } - statePool.Put(sd) -} - -// clone and return parser current state. -func (p *parser) cloneState() storeDict { - if p.debug { - defer p.out(p.in("cloneState")) - } - - state := statePool.Get().(storeDict) - for k, v := range p.cur.state { - if c, ok := v.(Cloner); ok { - state[k] = c.Clone() - } else { - state[k] = v - } - } - return state -} - -// restore parser current state to the state storeDict. -// every restoreState should applied only one time for every cloned state -func (p *parser) restoreState(state storeDict) { - if p.debug { - defer p.out(p.in("restoreState")) - } - p.cur.state.Discard() - p.cur.state = state -} - -// get the slice of bytes from the savepoint start to the current position. -func (p *parser) sliceFrom(start savepoint) []byte { - return p.data[start.position.offset:p.pt.position.offset] -} - -func (p *parser) getMemoized(node interface{}) (resultTuple, bool) { - if len(p.memo) == 0 { - return resultTuple{}, false - } - m := p.memo[p.pt.offset] - if len(m) == 0 { - return resultTuple{}, false - } - res, ok := m[node] - return res, ok -} - -func (p *parser) setMemoized(pt savepoint, node interface{}, tuple resultTuple) { - if p.memo == nil { - p.memo = make(map[int]map[interface{}]resultTuple) - } - m := p.memo[pt.offset] - if m == nil { - m = make(map[interface{}]resultTuple) - p.memo[pt.offset] = m - } - m[node] = tuple -} - -func (p *parser) buildRulesTable(g *grammar) { - p.rules = make(map[string]*rule, len(g.rules)) - for _, r := range g.rules { - p.rules[r.name] = r - } -} - -func (p *parser) parse(g *grammar) (val interface{}, err error) { - if len(g.rules) == 0 { - p.addErr(errNoRule) - return nil, p.errs.err() - } - - // TODO : not super critical but this could be generated - p.buildRulesTable(g) - - if p.recover { - // panic can be used in action code to stop parsing immediately - // and return the panic as an error. - defer func() { - if e := recover(); e != nil { - if p.debug { - defer p.out(p.in("panic handler")) - } - val = nil - switch e := e.(type) { - case error: - p.addErr(e) - default: - p.addErr(fmt.Errorf("%v", e)) - } - err = p.errs.err() - } - }() - } - - startRule, ok := p.rules[p.entrypoint] - if !ok { - p.addErr(errInvalidEntrypoint) - return nil, p.errs.err() - } - - p.read() // advance to first rune - val, ok = p.parseRule(startRule) - if !ok { - if len(*p.errs) == 0 { - // If parsing fails, but no errors have been recorded, the expected values - // for the farthest parser position are returned as error. - maxFailExpectedMap := make(map[string]struct{}, len(p.maxFailExpected)) - for _, v := range p.maxFailExpected { - maxFailExpectedMap[v] = struct{}{} - } - expected := make([]string, 0, len(maxFailExpectedMap)) - eof := false - if _, ok := maxFailExpectedMap["!."]; ok { - delete(maxFailExpectedMap, "!.") - eof = true - } - for k := range maxFailExpectedMap { - expected = append(expected, k) - } - sort.Strings(expected) - if eof { - expected = append(expected, "EOF") - } - p.addErrAt(errors.New("no match found, expected: "+listJoin(expected, ", ", "or")), p.maxFailPos, expected) - } - - return nil, p.errs.err() - } - return val, p.errs.err() -} - -func listJoin(list []string, sep string, lastSep string) string { - switch len(list) { - case 0: - return "" - case 1: - return list[0] - default: - return strings.Join(list[:len(list)-1], sep) + " " + lastSep + " " + list[len(list)-1] - } -} - -func (p *parser) parseRule(rule *rule) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseRule " + rule.name)) - } - - if p.memoize { - res, ok := p.getMemoized(rule) - if ok { - p.restore(res.end) - return res.v, res.b - } - } - - start := p.pt - p.rstack = append(p.rstack, rule) - p.pushV() - val, ok := p.parseExpr(rule.expr) - p.popV() - p.rstack = p.rstack[:len(p.rstack)-1] - if ok && p.debug { - p.print(strings.Repeat(" ", p.depth)+"MATCH", string(p.sliceFrom(start))) - } - - if p.memoize { - p.setMemoized(start, rule, resultTuple{val, ok, p.pt}) - } - return val, ok -} - -func (p *parser) parseExpr(expr interface{}) (interface{}, bool) { - var pt savepoint - - if p.memoize { - res, ok := p.getMemoized(expr) - if ok { - p.restore(res.end) - return res.v, res.b - } - pt = p.pt - } - - p.ExprCnt++ - if p.ExprCnt > p.maxExprCnt { - panic(errMaxExprCnt) - } - - var val interface{} - var ok bool - switch expr := expr.(type) { - case *actionExpr: - val, ok = p.parseActionExpr(expr) - case *andCodeExpr: - val, ok = p.parseAndCodeExpr(expr) - case *andExpr: - val, ok = p.parseAndExpr(expr) - case *anyMatcher: - val, ok = p.parseAnyMatcher(expr) - case *charClassMatcher: - val, ok = p.parseCharClassMatcher(expr) - case *choiceExpr: - val, ok = p.parseChoiceExpr(expr) - case *labeledExpr: - val, ok = p.parseLabeledExpr(expr) - case *litMatcher: - val, ok = p.parseLitMatcher(expr) - case *notCodeExpr: - val, ok = p.parseNotCodeExpr(expr) - case *notExpr: - val, ok = p.parseNotExpr(expr) - case *oneOrMoreExpr: - val, ok = p.parseOneOrMoreExpr(expr) - case *recoveryExpr: - val, ok = p.parseRecoveryExpr(expr) - case *ruleRefExpr: - val, ok = p.parseRuleRefExpr(expr) - case *seqExpr: - val, ok = p.parseSeqExpr(expr) - case *stateCodeExpr: - val, ok = p.parseStateCodeExpr(expr) - case *throwExpr: - val, ok = p.parseThrowExpr(expr) - case *zeroOrMoreExpr: - val, ok = p.parseZeroOrMoreExpr(expr) - case *zeroOrOneExpr: - val, ok = p.parseZeroOrOneExpr(expr) - default: - panic(fmt.Sprintf("unknown expression type %T", expr)) - } - if p.memoize { - p.setMemoized(pt, expr, resultTuple{val, ok, p.pt}) - } - return val, ok -} - -func (p *parser) parseActionExpr(act *actionExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseActionExpr")) - } - - start := p.pt - val, ok := p.parseExpr(act.expr) - if ok { - p.cur.pos = start.position - p.cur.text = p.sliceFrom(start) - state := p.cloneState() - actVal, err := act.run(p) - if err != nil { - p.addErrAt(err, start.position, []string{}) - } - p.restoreState(state) - - val = actVal - } - if ok && p.debug { - p.print(strings.Repeat(" ", p.depth)+"MATCH", string(p.sliceFrom(start))) - } - return val, ok -} - -func (p *parser) parseAndCodeExpr(and *andCodeExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseAndCodeExpr")) - } - - state := p.cloneState() - - ok, err := and.run(p) - if err != nil { - p.addErr(err) - } - p.restoreState(state) - - return nil, ok -} - -func (p *parser) parseAndExpr(and *andExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseAndExpr")) - } - - pt := p.pt - state := p.cloneState() - p.pushV() - _, ok := p.parseExpr(and.expr) - p.popV() - p.restoreState(state) - p.restore(pt) - - return nil, ok -} - -func (p *parser) parseAnyMatcher(any *anyMatcher) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseAnyMatcher")) - } - - if p.pt.rn == utf8.RuneError && p.pt.w == 0 { - // EOF - see utf8.DecodeRune - p.failAt(false, p.pt.position, ".") - return nil, false - } - start := p.pt - p.read() - p.failAt(true, start.position, ".") - return p.sliceFrom(start), true -} - -func (p *parser) parseCharClassMatcher(chr *charClassMatcher) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseCharClassMatcher")) - } - - cur := p.pt.rn - start := p.pt - - // can't match EOF - if cur == utf8.RuneError && p.pt.w == 0 { // see utf8.DecodeRune - p.failAt(false, start.position, chr.val) - return nil, false - } - - if chr.ignoreCase { - cur = unicode.ToLower(cur) - } - - // try to match in the list of available chars - for _, rn := range chr.chars { - if rn == cur { - if chr.inverted { - p.failAt(false, start.position, chr.val) - return nil, false - } - p.read() - p.failAt(true, start.position, chr.val) - return p.sliceFrom(start), true - } - } - - // try to match in the list of ranges - for i := 0; i < len(chr.ranges); i += 2 { - if cur >= chr.ranges[i] && cur <= chr.ranges[i+1] { - if chr.inverted { - p.failAt(false, start.position, chr.val) - return nil, false - } - p.read() - p.failAt(true, start.position, chr.val) - return p.sliceFrom(start), true - } - } - - // try to match in the list of Unicode classes - for _, cl := range chr.classes { - if unicode.Is(cl, cur) { - if chr.inverted { - p.failAt(false, start.position, chr.val) - return nil, false - } - p.read() - p.failAt(true, start.position, chr.val) - return p.sliceFrom(start), true - } - } - - if chr.inverted { - p.read() - p.failAt(true, start.position, chr.val) - return p.sliceFrom(start), true - } - p.failAt(false, start.position, chr.val) - return nil, false -} - -func (p *parser) incChoiceAltCnt(ch *choiceExpr, altI int) { - choiceIdent := fmt.Sprintf("%s %d:%d", p.rstack[len(p.rstack)-1].name, ch.pos.line, ch.pos.col) - m := p.ChoiceAltCnt[choiceIdent] - if m == nil { - m = make(map[string]int) - p.ChoiceAltCnt[choiceIdent] = m - } - // We increment altI by 1, so the keys do not start at 0 - alt := strconv.Itoa(altI + 1) - if altI == choiceNoMatch { - alt = p.choiceNoMatch - } - m[alt]++ -} - -func (p *parser) parseChoiceExpr(ch *choiceExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseChoiceExpr")) - } - - for altI, alt := range ch.alternatives { - // dummy assignment to prevent compile error if optimized - _ = altI - - state := p.cloneState() - - p.pushV() - val, ok := p.parseExpr(alt) - p.popV() - if ok { - p.incChoiceAltCnt(ch, altI) - return val, ok - } - p.restoreState(state) - } - p.incChoiceAltCnt(ch, choiceNoMatch) - return nil, false -} - -func (p *parser) parseLabeledExpr(lab *labeledExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseLabeledExpr")) - } - - p.pushV() - val, ok := p.parseExpr(lab.expr) - p.popV() - if ok && lab.label != "" { - m := p.vstack[len(p.vstack)-1] - m[lab.label] = val - } - return val, ok -} - -func (p *parser) parseLitMatcher(lit *litMatcher) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseLitMatcher")) - } - - start := p.pt - for _, want := range lit.val { - cur := p.pt.rn - if lit.ignoreCase { - cur = unicode.ToLower(cur) - } - if cur != want { - p.failAt(false, start.position, lit.want) - p.restore(start) - return nil, false - } - p.read() - } - p.failAt(true, start.position, lit.want) - return p.sliceFrom(start), true -} - -func (p *parser) parseNotCodeExpr(not *notCodeExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseNotCodeExpr")) - } - - state := p.cloneState() - - ok, err := not.run(p) - if err != nil { - p.addErr(err) - } - p.restoreState(state) - - return nil, !ok -} - -func (p *parser) parseNotExpr(not *notExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseNotExpr")) - } - - pt := p.pt - state := p.cloneState() - p.pushV() - p.maxFailInvertExpected = !p.maxFailInvertExpected - _, ok := p.parseExpr(not.expr) - p.maxFailInvertExpected = !p.maxFailInvertExpected - p.popV() - p.restoreState(state) - p.restore(pt) - - return nil, !ok -} - -func (p *parser) parseOneOrMoreExpr(expr *oneOrMoreExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseOneOrMoreExpr")) - } - - var vals []interface{} - - for { - p.pushV() - val, ok := p.parseExpr(expr.expr) - p.popV() - if !ok { - if len(vals) == 0 { - // did not match once, no match - return nil, false - } - return vals, true - } - vals = append(vals, val) - } -} - -func (p *parser) parseRecoveryExpr(recover *recoveryExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseRecoveryExpr (" + strings.Join(recover.failureLabel, ",") + ")")) - } - - p.pushRecovery(recover.failureLabel, recover.recoverExpr) - val, ok := p.parseExpr(recover.expr) - p.popRecovery() - - return val, ok -} - -func (p *parser) parseRuleRefExpr(ref *ruleRefExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseRuleRefExpr " + ref.name)) - } - - if ref.name == "" { - panic(fmt.Sprintf("%s: invalid rule: missing name", ref.pos)) - } - - rule := p.rules[ref.name] - if rule == nil { - p.addErr(fmt.Errorf("undefined rule: %s", ref.name)) - return nil, false - } - return p.parseRule(rule) -} - -func (p *parser) parseSeqExpr(seq *seqExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseSeqExpr")) - } - - vals := make([]interface{}, 0, len(seq.exprs)) - - pt := p.pt - state := p.cloneState() - for _, expr := range seq.exprs { - val, ok := p.parseExpr(expr) - if !ok { - p.restoreState(state) - p.restore(pt) - return nil, false - } - vals = append(vals, val) - } - return vals, true -} - -func (p *parser) parseStateCodeExpr(state *stateCodeExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseStateCodeExpr")) - } - - err := state.run(p) - if err != nil { - p.addErr(err) - } - return nil, true -} - -func (p *parser) parseThrowExpr(expr *throwExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseThrowExpr")) - } - - for i := len(p.recoveryStack) - 1; i >= 0; i-- { - if recoverExpr, ok := p.recoveryStack[i][expr.label]; ok { - if val, ok := p.parseExpr(recoverExpr); ok { - return val, ok - } - } - } - - return nil, false -} - -func (p *parser) parseZeroOrMoreExpr(expr *zeroOrMoreExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseZeroOrMoreExpr")) - } - - var vals []interface{} - - for { - p.pushV() - val, ok := p.parseExpr(expr.expr) - p.popV() - if !ok { - return vals, true - } - vals = append(vals, val) - } -} - -func (p *parser) parseZeroOrOneExpr(expr *zeroOrOneExpr) (interface{}, bool) { - if p.debug { - defer p.out(p.in("parseZeroOrOneExpr")) - } - - p.pushV() - val, _ := p.parseExpr(expr.expr) - p.popV() - // whether it matched or not, consider it a match - return val, true -} diff --git a/go.mod b/go.mod index 571b0c1..7ca3dbe 100644 --- a/go.mod +++ b/go.mod @@ -3,17 +3,17 @@ module verifpal.com -go 1.19 +go 1.21 require ( github.com/logrusorgru/aurora v2.0.3+incompatible - github.com/spf13/cobra v1.6.1 + github.com/spf13/cobra v1.7.0 ) require ( github.com/akavel/rsrc v0.10.2 // indirect github.com/bketelsen/crypt v0.0.4 // indirect - github.com/inconshreveable/mousetrap v1.0.1 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/josephspurrier/goversioninfo v1.3.0 // indirect github.com/mna/pigeon v1.1.0 // indirect github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect diff --git a/go.sum b/go.sum index babdf22..913185f 100644 --- a/go.sum +++ b/go.sum @@ -18,15 +18,6 @@ cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmW cloud.google.com/go v0.78.0/go.mod h1:QjdrLG0uq+YwhjoVOLsS1t7TW8fs36kLs4XO5R5ECHg= cloud.google.com/go v0.79.0/go.mod h1:3bzgcEeQlzbuEAYu4mrWhKqWjmpprinYgKJLgKHnbb8= cloud.google.com/go v0.81.0/go.mod h1:mk/AM35KwGk/Nm2YSeZbxXdrNK3KZOYHmLkOqC2V6E0= -cloud.google.com/go v0.83.0/go.mod h1:Z7MJUsANfY0pYPdw0lbnivPx4/vhy/e2FEkSkF7vAVY= -cloud.google.com/go v0.84.0/go.mod h1:RazrYuxIK6Kb7YrzzhPoLmCVzl7Sup4NrbKPg8KHSUM= -cloud.google.com/go v0.87.0/go.mod h1:TpDYlFy7vuLzZMMZ+B6iRiELaY7z/gJPaqbMx6mlWcY= -cloud.google.com/go v0.90.0/go.mod h1:kRX0mNRHe0e2rC6oNakvwQqzyDmg57xJ+SZU1eT2aDQ= -cloud.google.com/go v0.93.3/go.mod h1:8utlLll2EF5XMAV15woO4lSbWQlk8rer9aLOfLh7+YI= -cloud.google.com/go v0.94.1/go.mod h1:qAlAugsXlC+JWO+Bke5vCtc9ONxjQT3drlTTnAplMW4= -cloud.google.com/go v0.97.0/go.mod h1:GF7l59pYBVlXQIBLx3a761cZ41F9bBH3JUlihCt2Udc= -cloud.google.com/go v0.98.0/go.mod h1:ua6Ush4NALrHk5QXDWnjvZHN93OuF0HfuEPq9I1X0cM= -cloud.google.com/go v0.99.0/go.mod h1:w0Xx2nLzqWJPuozYQX+hFfCSI8WioryfRDzkoI/Y2ZA= cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o= cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE= cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc= @@ -36,7 +27,6 @@ cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM7 cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE= cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk= cloud.google.com/go/firestore v1.1.0/go.mod h1:ulACoGHTpvq5r8rxGJ4ddJZBZqakUQqClKRT5SZwBmk= -cloud.google.com/go/firestore v1.6.1/go.mod h1:asNXNOzBdyVQmEU+ggO8UPodTkEVFW5Qx+rwHnAz+EY= cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I= cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw= cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA= @@ -49,49 +39,23 @@ cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9 dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= -github.com/DataDog/datadog-go v3.2.0+incompatible/go.mod h1:LButxg5PwREeZtORoXG3tL4fMGNddJ+vMq1mwgfaqoQ= -github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= -github.com/akavel/rsrc v0.10.2 h1:Zxm8V5eI1hW4gGaYsJQUhxpjkENuG91ki8B4zCrvEsw= github.com/akavel/rsrc v0.10.2/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c= -github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= -github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= -github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= -github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o= github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY= -github.com/armon/go-metrics v0.3.10/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= -github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= -github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= -github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= -github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM= github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/census-instrumentation/opencensus-proto v0.3.0/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU= -github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= -github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= -github.com/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag= -github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I= github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc= github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk= -github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI= -github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20211001041855-01bcc9b48dfe/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= -github.com/cncf/xds/go v0.0.0-20211130200136-a8f946100490/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs= github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= -github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -101,32 +65,18 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po= github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= github.com/envoyproxy/go-control-plane v0.9.9-0.20210217033140-668b12f5399d/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk= -github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ= -github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0= -github.com/envoyproxy/go-control-plane v0.10.1/go.mod h1:AY7fTTXNdv/aJ2O5jwpxAPOWUZ7hQAEvzN5Pf27BkQQ= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= -github.com/envoyproxy/protoc-gen-validate v0.6.2/go.mod h1:2t7qjJNvHPx8IjnBOzl9E9/baC+qXE/TeeyBRzgJDws= github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4= -github.com/fatih/color v1.9.0/go.mod h1:eQcE1qtQxscV5RaZvpXrrb8Drkc3/DdQ+uUYCNjL+zU= -github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= -github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= -github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= -github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= -github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= -github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= -github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA= -github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= -github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= @@ -135,7 +85,6 @@ github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4= github.com/golang/mock v1.5.0/go.mod h1:CWnOUgYIOo4TcNZ0wHX3YZCqsaM1I1Jvs6v3mP3KVu8= -github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs= github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= @@ -153,7 +102,6 @@ github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM= github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= -github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= @@ -167,12 +115,10 @@ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs= github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0= -github.com/google/martian/v3 v3.2.1/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc= github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM= @@ -184,35 +130,20 @@ github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLe github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20210601050228-01bbb1931b22/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20210609004039-a478d1d731e9/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= -github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg= github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk= -github.com/googleapis/gax-go/v2 v2.1.0/go.mod h1:Q3nei7sK6ybPYH7twZdmQpAd1MKb7pfu6SK+H1/DsU0= -github.com/googleapis/gax-go/v2 v2.1.1/go.mod h1:hddJymUZASv3XPyGkUpKj8pPO47Rmb0eJc8R6ouapiM= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw= github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q= -github.com/hashicorp/consul/api v1.11.0/go.mod h1:XjsvQN+RJGWI2TWy1/kqaE16HrR2J/FWgkYjdZQsX9M= github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8= -github.com/hashicorp/consul/sdk v0.8.0/go.mod h1:GBvyrGALthsZObzUGsfgHZQDXjg4lOjagTIwIR1vPms= github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4= -github.com/hashicorp/go-cleanhttp v0.5.0/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80= -github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48= -github.com/hashicorp/go-hclog v0.12.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= -github.com/hashicorp/go-hclog v1.0.0/go.mod h1:whpDNt7SSdeAju8AWKIWsul05p54N/39EeqMAyrmvFQ= github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= -github.com/hashicorp/go-immutable-radix v1.3.1/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60= github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM= github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk= -github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA= -github.com/hashicorp/go-retryablehttp v0.5.3/go.mod h1:9B5zBasrRhHXnJnui7y6sL7es7NDiJgTc6Er0maI1Xs= github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU= -github.com/hashicorp/go-rootcerts v1.0.2/go.mod h1:pqUvnprVnM5bf7AOirdbb01K4ccR319Vf4pU3K5EGc8= github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU= github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4= github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro= @@ -220,149 +151,74 @@ github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/b github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90= github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= -github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4= -github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64= github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ= -github.com/hashicorp/mdns v1.0.1/go.mod h1:4gW7WsVCke5TE7EPeYliwHlRUyBtfCwuFwuMg2DmyNY= -github.com/hashicorp/mdns v1.0.4/go.mod h1:mtBihi+LeNXGtG8L9dX59gAEa12BDtBQSp4v/YAJqrc= github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I= -github.com/hashicorp/memberlist v0.2.2/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= -github.com/hashicorp/memberlist v0.3.0/go.mod h1:MS2lj3INKhZjWNqd3N0m3J+Jxf3DAOnAH9VT3Sh9MUE= github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc= -github.com/hashicorp/serf v0.9.5/go.mod h1:UWDWwZeL5cuWDJdl0C6wrvrUwEqtQ4ZKBKKENpqIUyk= -github.com/hashicorp/serf v0.9.6/go.mod h1:TXZNMjZQijwlDvp+r0b63xZ45H7JmCmgg4gpTwn9UV4= -github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= -github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= -github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= -github.com/inconshreveable/mousetrap v1.0.1 h1:U3uMjPSQEBMNp1lFxmllqCPM6P5u/Xq7Pgzkat/bFNc= -github.com/inconshreveable/mousetrap v1.0.1/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= github.com/josephspurrier/goversioninfo v1.3.0 h1:pmgDhWnG8I59p5kCR09J73s/gy9JqRPAtiaUK8jixtE= github.com/josephspurrier/goversioninfo v1.3.0/go.mod h1:JWzv5rKQr+MmW+LvM412ToT/IkYDZjaclF2pKDss8IY= -github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= -github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= github.com/json-iterator/go v1.1.11/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4= -github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo= github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU= github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= -github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= -github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= -github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/logrusorgru/aurora v2.0.3+incompatible h1:tOpm7WcpBTn4fjmVfgpQq0EfczGlG91VSDkswnjF5A8= github.com/logrusorgru/aurora v2.0.3+incompatible/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4= -github.com/lyft/protoc-gen-star v0.5.3/go.mod h1:V0xaHgaf5oCCqmcxYcWiDfTiKsZsRc87/1qhoTACD8w= -github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= -github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= -github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= -github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/mattn/go-isatty v0.0.10/go.mod h1:qgIWMr58cqv1PHHyhnkY9lrL7etaEgOFcMEpPG5Rm84= -github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE= -github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= -github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= -github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= -github.com/miekg/dns v1.1.26/go.mod h1:bPDLeHnStXmXAq1m/Ch/hvfNHr14JKNPMBo3VZKjuso= -github.com/miekg/dns v1.1.41/go.mod h1:p6aan82bvRIyn+zDIv9xYNUpwa73JcSh9BKwknJysuI= github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= -github.com/mitchellh/cli v1.1.0/go.mod h1:xcISNoH86gajksDmfB23e/pu+B+GeFRMYmoHXxx3xhI= github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= -github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0= github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI= github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg= github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY= github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= -github.com/mitchellh/mapstructure v1.4.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/mna/pigeon v1.1.0 h1:EjlvVbkGnNGemf8OrjeJX0nH8orujY/HkJgzJtd7kxc= github.com/mna/pigeon v1.1.0/go.mod h1:rkFeDZ0gc+YbnrXPw0q2RlI0QRuKBBPu67fgYIyGRNg= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= -github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= -github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk= -github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= -github.com/pascaldekloe/goe v0.1.0/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc= -github.com/pelletier/go-toml v1.9.4/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= -github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= -github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= -github.com/posener/complete v1.2.3/go.mod h1:WZIdtGGp+qx0sLrYKtIRAruyNpv6hFCicSgv7Sy7s/s= -github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= -github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo= -github.com/prometheus/client_golang v1.4.0/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU= -github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= -github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= -github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= -github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= -github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= -github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= -github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts= -github.com/sagikazarmark/crypt v0.3.0/go.mod h1:uD/D+6UF4SrIR1uGEv7bBNkNqLGqUr43MRiaGWX1Nig= github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= -github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= -github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA= -github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= -github.com/spf13/afero v1.3.3/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4= -github.com/spf13/afero v1.6.0/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I= -github.com/spf13/cast v1.4.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= -github.com/spf13/cobra v1.3.0 h1:R7cSvGu+Vv+qX0gW5R/85dx2kmmJT5z5NM8ifdYjdn0= -github.com/spf13/cobra v1.3.0/go.mod h1:BrRVncBjOJa/eUcVVm9CE+oC6as8k+VYr4NY7WCi9V4= -github.com/spf13/cobra v1.4.0 h1:y+wJpx64xcgO1V+RcnwW0LEHxTKRi2ZDPSBjWnrg88Q= -github.com/spf13/cobra v1.4.0/go.mod h1:Wo4iy3BUC+X2Fybo0PDqwJIv3dNRiZLHQymsfxlB84g= -github.com/spf13/cobra v1.6.1 h1:o94oiPyS4KD1mPy2fmcYYHHfCxLqYjJOhGsCHFZtEzA= -github.com/spf13/cobra v1.6.1/go.mod h1:IOw/AERYS7UzyrGinqmz6HLUo219MORXGxhbaJUqzrY= -github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I= +github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0= github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= -github.com/spf13/viper v1.10.0/go.mod h1:SoyBPwAtKDzypXNDFKN5kzH7ppppbGZtls1UpIy5AsM= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= -github.com/tv42/httpunix v0.0.0-20150427012821-b75d8614f926/go.mod h1:9ESjWnEqriFuLhtthL60Sar/7RFoluCcXsuvEwTV5KM= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= -github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= -go.etcd.io/etcd/api/v3 v3.5.1/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= -go.etcd.io/etcd/client/pkg/v3 v3.5.1/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ= -go.etcd.io/etcd/client/v2 v2.305.1/go.mod h1:pMEacxZW7o8pg4CrFE7pquyCJJzZvkvdD2RibOCCCGs= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8= go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= @@ -370,20 +226,15 @@ go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= -go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI= go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc= go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU= go.uber.org/zap v1.17.0/go.mod h1:MXVU+bhUf/A7Xi2HNOnopQOrmycQ5Ih87HtOu4q5SSo= -golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= -golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= -golang.org/x/crypto v0.0.0-20210817164053-32db794688a5/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -419,13 +270,10 @@ golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.5.0/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= -golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38= golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= -golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -434,11 +282,9 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= -golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= @@ -461,10 +307,6 @@ golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= -golang.org/x/net v0.0.0-20210410081132-afb366fc7cd1/go.mod h1:9tjilg8BloeKEkVJvy7fQ90B1CfIiPueXVOjqfkSzI8= -golang.org/x/net v0.0.0-20210503060351-7fd8e65b6420/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20210813160813-60bc85c4be6d/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -477,12 +319,6 @@ golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210514164344-f6687ab2804c/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210805134026-6f1e6394065a/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20210819190943-2bc19b11175f/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20211005180243-6b3c2da341f1/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= -golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= @@ -496,30 +332,20 @@ golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -538,29 +364,12 @@ golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210220050731-9a76102bfb43/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210303074136-134d130e1a04/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210305230114-8fe3ee5dd75b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210315160823-c6e025ad8005/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210514084401-e8d321eab015/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210603125802-9665404d3644/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210616094352-59db8d763f22/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210806184541-e5e7981a1069/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210816183151-1e6c022a8912/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210823070655-63515b42dcdf/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210908233432-aa78b53d3365/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211007075335-d3039528d8ac/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211124211545-fe61309f8881/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211205182925-97ca703d548d/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -570,8 +379,6 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -590,7 +397,6 @@ golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgw golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190830223141-573d9926052a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.0.0-20190907020128-2ca718005c18/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20191112195655-aa38f8e97acc/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= @@ -627,17 +433,11 @@ golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4f golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= -golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= -golang.org/x/tools v0.1.8 h1:P1HhGGuLW4aAclzjtmJdf0mJOjVUZUzOTqkAkWL+l6w= golang.org/x/tools v0.1.8/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE= google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M= @@ -661,17 +461,6 @@ google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjR google.golang.org/api v0.41.0/go.mod h1:RkxM5lITDfTzmyKFPt+wGrCJbVfniCr2ool8kTBzRTU= google.golang.org/api v0.43.0/go.mod h1:nQsDGjRXMo4lvh5hP0TKqF244gqhGcr/YSIykhUk/94= google.golang.org/api v0.44.0/go.mod h1:EBOGZqzyhtvMDoxwS97ctnh0zUmYY6CxqXsc1AvkYD8= -google.golang.org/api v0.47.0/go.mod h1:Wbvgpq1HddcWVtzsVLyfLp8lDg6AA241LmgIL59tHXo= -google.golang.org/api v0.48.0/go.mod h1:71Pr1vy+TAZRPkPs/xlCf5SsU8WjuAWv1Pfjbtukyy4= -google.golang.org/api v0.50.0/go.mod h1:4bNT5pAuq5ji4SRZm+5QIkjny9JAyVD/3gaSihNefaw= -google.golang.org/api v0.51.0/go.mod h1:t4HdrdoNgyN5cbEfm7Lum0lcLDLiise1F8qDKX00sOU= -google.golang.org/api v0.54.0/go.mod h1:7C4bFFOvVDGXjfDTAsgGwDgAxRDeQ4X8NvUedIt6z3k= -google.golang.org/api v0.55.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= -google.golang.org/api v0.56.0/go.mod h1:38yMfeP1kfjsl8isn0tliTjIb1rJXcQi4UXlbqivdVE= -google.golang.org/api v0.57.0/go.mod h1:dVPlbZyBo2/OjBpmvNdpn2GRm6rPy75jyU7bmhdrMgI= -google.golang.org/api v0.59.0/go.mod h1:sT2boj7M9YJxZzgeZqXogmhfmRWDtPzT31xkieUbuZU= -google.golang.org/api v0.61.0/go.mod h1:xQRti5UdCmoCEqFxcz93fTl338AVqDgyaDRuOZ3hg9I= -google.golang.org/api v0.62.0/go.mod h1:dKmwPCydfsad4qCH08MSdgWjfHOyfpd4VtDGgRFdavw= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= @@ -719,29 +508,7 @@ google.golang.org/genproto v0.0.0-20210303154014-9728d6b83eeb/go.mod h1:FWY/as6D google.golang.org/genproto v0.0.0-20210310155132-4ce2db91004e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210319143718-93e7006c17a6/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no= google.golang.org/genproto v0.0.0-20210402141018-6c239bbf2bb1/go.mod h1:9lPAdzaEmUacj36I+k7YKbEc5CXzPIeORRgDAUOu28A= -google.golang.org/genproto v0.0.0-20210513213006-bf773b8c8384/go.mod h1:P3QM42oQyzQSnHPnZ/vqoCdDmzH28fzWByN9asMeM8A= google.golang.org/genproto v0.0.0-20210602131652-f16073e35f0c/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= -google.golang.org/genproto v0.0.0-20210604141403-392c879c8b08/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= -google.golang.org/genproto v0.0.0-20210608205507-b6d2f5bf0d7d/go.mod h1:UODoCrxHCcBojKKwX1terBiRUaqAsFqJiF615XL43r0= -google.golang.org/genproto v0.0.0-20210624195500-8bfb893ecb84/go.mod h1:SzzZ/N+nwJDaO1kznhnlzqS8ocJICar6hYhVyhi++24= -google.golang.org/genproto v0.0.0-20210713002101-d411969a0d9a/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= -google.golang.org/genproto v0.0.0-20210716133855-ce7ef5c701ea/go.mod h1:AxrInvYm1dci+enl5hChSFPOmmUF1+uAa/UsgNRWd7k= -google.golang.org/genproto v0.0.0-20210728212813-7823e685a01f/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= -google.golang.org/genproto v0.0.0-20210805201207-89edb61ffb67/go.mod h1:ob2IJxKrgPT52GcgX759i1sleT07tiKowYBGbczaW48= -google.golang.org/genproto v0.0.0-20210813162853-db860fec028c/go.mod h1:cFeNkxwySK631ADgubI+/XFU/xp8FD5KIVV4rj8UC5w= -google.golang.org/genproto v0.0.0-20210821163610-241b8fcbd6c8/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210828152312-66f60bf46e71/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210831024726-fe130286e0e2/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210903162649-d08c68adba83/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210909211513-a8c4777a87af/go.mod h1:eFjDcFEctNawg4eG61bRv87N7iHBWyVhJu7u1kqDUXY= -google.golang.org/genproto v0.0.0-20210924002016-3dee208752a0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211008145708-270636b82663/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211028162531-8db9c33dc351/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211129164237-f09f9a12af12/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211203200212-54befc351ae9/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211206160659-862468c7d6e0/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= -google.golang.org/genproto v0.0.0-20211208223120-3a66f561d7aa/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38= google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= @@ -761,15 +528,7 @@ google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA5 google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= google.golang.org/grpc v1.36.1/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU= -google.golang.org/grpc v1.37.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= -google.golang.org/grpc v1.37.1/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= google.golang.org/grpc v1.38.0/go.mod h1:NREThFqKR1f3iQ6oBuvc5LadQuXVGo9rkm5ZGrQdJfM= -google.golang.org/grpc v1.39.0/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= -google.golang.org/grpc v1.39.1/go.mod h1:PImNr+rS9TWYb2O4/emRugxiyHZ5JyHW5F+RPnDzfrE= -google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.40.1/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34= -google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU= -google.golang.org/grpc/cmd/protoc-gen-go-grpc v1.1.0/go.mod h1:6Kw0yEErY5E/yWrBtf03jp27GLLJujG4z/JK95pnjjw= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0= google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= @@ -782,20 +541,12 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc= -gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= -gopkg.in/ini.v1 v1.66.2/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= -gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= -gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=