unsupported Perl syntax: `(?<`

I want to parse the result of the cmd 'gpg --list-keys' to display it on the browser.
The cmd ouput is like this:

    pub   rsa3072 2021-08-03 [SC] [expires: 2023-08-03]
          07C47E284765D5593171C18F00B11D51A071CB55
    uid           [ultimate] user1 <user1@example.com>
    sub   rsa3072 2021-08-03 [E] [expires: 2023-08-03]
    
    pub   rsa3072 2021-08-04 [SC]
          37709ABD4D96324AB8CBFC3B441812AFBCE7A013
    uid           [ultimate] user2 <user2@example.com>
    sub   rsa3072 2021-08-04 [E]

I expect something like this :

    {
    	{uid : user1@example.com},
    	{uid : user2@example.com},
    }

Here is the code:

    type GPGList struct{
    	uid string
    }
    
    //find list keys
    func Findlistkeys(){
    	pathexec, _ := exec.LookPath("gpg")
    	cmd := exec.Command(pathexec, "--list-keys")
    	cmdOutput := &bytes.Buffer{}
        cmd.Stdout = cmdOutput
        printCommand(cmd)
        err := cmd.Run()
        printError(err)
        output := cmdOutput.Bytes()
        printOutput(output)
        GPG := GPGList{}
        parseOutput(output, &GPG)
        fmt.Println(GPG)
    }
    
    func printCommand(cmd *exec.Cmd) {
    	fmt.Printf("==> Executing: %s\n", strings.Join(cmd.Args, " "))
    }
    
    func printError(err error) {
    	if err != nil {
    			os.Stderr.WriteString(fmt.Sprintf("==> Error: %s\n", err.Error()))
    	}
    }
    
    func printOutput(outs []byte) {
    	if len(outs) > 0 {
    			fmt.Printf("==> Output: %s\n", string(outs))
    	}
    }
    
    func parseOutput(outs []byte, GPG *GPGList) {
    	var uid = regexp.MustCompile(`(?<=\<)(.*?)(?=\>)`)
    	fmt.Println(uid)
    }

It ends with the following message :

    panic: regexp: Compile(`(?<=\<)(.*?)(?=\>)`): error parsing regexp: invalid or unsupported Perl syntax: `(?<

So far I'm stack with the regex.
It don't understand why it don't want to compile...
What is wrong with it?

I've tested the regex on online simulator and it looks OK, yet there is something wrong with it.
Any suggestion please?

The regexp package uses the syntax accepted by RE2. From https://github.com/google/re2/wiki/Syntax

> (?<=re) after text matching re (NOT SUPPORTED)

Hence the error message:

> error parsing regexp: invalid or unsupported Perl syntax: (?<

The online simulator is likely testing a different regular expression syntax. You will need to find an alternative regular expression encoding or a different regular expression package.

An alternative encoding you can try is \<([^\>]*)\> (playground). This is quite simple and may not match your original intent.

Here is another solution based on gpg --list-keys --with-colons machine readable output.

It is still a slow solution, but easy to write, easy to update, does not use regular expressions.

A smart folk can come with an even faster solution without adding a crazy wall of complexity. (just loop over the string until < then capture the string until >)

this is based on a simple csv reader, so you can plug it onto the output stream of a command.Exec instance, or whatever else.

The big advantage is that it does not need to buffer the whole data in memory, it can stream decode.

package main

import (
	"encoding/csv"
	"fmt"
	"io"
	"regexp"
	"strings"
)

func main() {
	fmt.Printf("%#v\n", extractEmailsCSV(csvInput))
}

var uid = regexp.MustCompile(`\<(.*?)\>`)

func extractEmailsRegexp(input string) (out []string) {
	submatchall := uid.FindAllString(input, -1)
	for _, element := range submatchall {
		element = strings.Trim(element, "<")
		element = strings.Trim(element, ">")
		out = append(out, element)
	}
	return
}

func extractEmailsCSV(input string) (out []string) {
	r := strings.NewReader(input)
	csv := csv.NewReader(r)
	csv.Comma = ':'
	csv.ReuseRecord = true
	csv.FieldsPerRecord = -1

	for {
		records, err := csv.Read()
		if err == io.EOF {
			break
		} else if err != nil {
			panic(err)
		}

		if len(records) < 10 {
			continue
		}

		r := records[9]
		if strings.Contains(r, "@") {
			begin := strings.Index(r, "<")
			end := strings.Index(r, ">")
			if begin+end > 0 {
				out = append(out, r[begin+1:end])
			}
		}
	}
	return
}

var regexpInput = `
    pub   rsa3072 2021-08-03 [SC] [expires: 2023-08-03]
          07C47E284765D5593171C18F00B11D51A071CB55
    uid           [ultimate] user1 <user1@example.com>
    sub   rsa3072 2021-08-03 [E] [expires: 2023-08-03]

    pub   rsa3072 2021-08-04 [SC]
          37709ABD4D96324AB8CBFC3B441812AFBCE7A013
    uid           [ultimate] user2 <user2@example.com>
    sub   rsa3072 2021-08-04 [E]
`

var csvInput = `pub:u:1024:17:51FF9A17136C5B87:1999-04-24::59:-:Tony Nelson <tnelson@techie.com>:
uid:u::::::::Tony Nelson <tnelson@conceptech.com>:
`

We dont exactly have the same benchmark setup, but anyways. If you think it bloats the comparison feel free to provide better bench setup.

Here is the benchmark setup

package main

import (
	"strings"
	"testing"
)

func BenchmarkCSV_1(b *testing.B) {
	input := strings.Repeat(csvInput, 1)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = extractEmailsCSV(input)
	}
}
func BenchmarkRegExp_1(b *testing.B) {
	input := strings.Repeat(regexpInput, 1)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = extractEmailsRegexp(input)
	}
}

func BenchmarkCSV_10(b *testing.B) {
	input := strings.Repeat(csvInput, 10)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = extractEmailsCSV(input)
	}
}
func BenchmarkRegExp_10(b *testing.B) {
	input := strings.Repeat(regexpInput, 10)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = extractEmailsRegexp(input)
	}
}

func BenchmarkCSV_100(b *testing.B) {
	input := strings.Repeat(csvInput, 100)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = extractEmailsCSV(input)
	}
}
func BenchmarkRegExp_100(b *testing.B) {
	input := strings.Repeat(regexpInput, 100)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = extractEmailsRegexp(input)
	}
}

And here is the result

BenchmarkCSV_1
BenchmarkCSV_1-4        	  242736	      4200 ns/op	    5072 B/op	      18 allocs/op
BenchmarkRegExp_1
BenchmarkRegExp_1-4     	  252232	      4466 ns/op	     400 B/op	       9 allocs/op
BenchmarkCSV_10
BenchmarkCSV_10-4       	   68257	     17335 ns/op	    7184 B/op	      40 allocs/op
BenchmarkRegExp_10
BenchmarkRegExp_10-4    	   29871	     39947 ns/op	    3414 B/op	      68 allocs/op
BenchmarkCSV_100
BenchmarkCSV_100-4      	    7538	    141609 ns/op	   25872 B/op	     223 allocs/op
BenchmarkRegExp_100
BenchmarkRegExp_100-4   	    1726	    674718 ns/op	   37858 B/op	     615 allocs/op

In terms of raw speed and allocations regular expression is better on small dataset, though as soon there is a little bit of data regular expressions are slower and allocates mores by a significant factor.

read also https://pkg.go.dev/testing

My conclusion is, don't use regular expressions ... also, optimizing regexp are hard if not impossible, where as optimizing an algorithm to parse some text input is doable, if not easy.

to summarize, even the fastest and best runtime is nothing without a well thought programmer to drive it.

So I updated the regex...but since (?<=\<)(.*?)(?=\>) was working on online simulator, I really got surprised.
Why can't regex work the same with all languages...

    func parseOutput(outs []byte, GPG *GPGList) {
var uid = regexp.MustCompile(`\<(.*?)\>`)
submatchall := uid.FindAllString(string(outs), -1)
for _, element := range submatchall {
element = strings.Trim(element, "<")
element = strings.Trim(element, ">")
fmt.Println(element)
}
}