signed vs unsigned integers

[caio-northfleet-neon]

Hi,
Just wondering how to differentiate signed vs unsigned integers. In terms of the scanner, handling the sequence of digits is just fine, but how does the parser would know when to call strconv.ParseInt vs strconv.ParseUInt in:

		kind := t.Kind()
		switch kind { // nolint: exhaustive
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			n, err := strconv.ParseInt(v.String(), 0, sizeOfKind(kind))
			if err != nil {
				return nil, err
			}
			v = reflect.New(t).Elem()
			v.SetInt(n)

		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			n, err := strconv.ParseUint(v.String(), 0, sizeOfKind(kind))
			if err != nil {
				return nil, err
			}
			v = reflect.New(t).Elem()
			v.SetUint(n)

In particular, I am trying to use the protobuf example to parse some .proto files, but one of them has a message constructed like the following:

extend google.protobuf.MessageOptions {
  optional uint64 message_hash = 1000;
}

message Message {
  option (message_hash) = 15130946181659604402;
}

The parser does not know that the message_hash is an unsigned integer, so it infers it as a signed integer and the strconv.ParseInt returns a value out of range error.

Any ideas?

[alecthomas]

I typically parse into *big.Int in situations like that.

[caio-northfleet-neon]

Does the default lexer knows how to handle the *big.Int? Do you have an example on how to declare the grammar and initialize the parser?

[caio-northfleet-neon]

So I changed the Value struct to have a:

	Uint      *uint64  `| @Int`

And it kind of solved the issue for now. I think that's what you meant by parsing into a *big.Int above.

Thanks!

[alecthomas]

The lexer doesn't handle big.Int, it's the parser, and it works because big.Int implements encoding.TextUnmarshaler which Participle supports natively. You just need to replace int with *big.Int.