Make typeMap/idMap publicly accessible

[Happy-Ferret]

Curious.

Any good reason against making typeMap and idMap public, so its contents can be accessed by the consumer?

I've spent the past 6 hours trying to painfully retrieve a Type's index from idMap through reflection, and I'm still not close to a solution.

If it was IdMap instead, one could simply loop over it and retrieve the index like so:

	for i, k := range token.TokMap.IdMap {
		switch k {
		case intLit.Type:
			fmt.Println(i)
		}
	}

[awalterschulze]

What do you want to use it for?

…

On Tue, 2 Jul 2019 at 07:29, Happy-Ferret ***@***.***> wrote: Curious. Any good reason against making typeMap <https://github.com/goccmack/gocc/blob/master/internal/token/gen/golang/token.go#L90> and idMap public, so its contents can be accessed by the consumer? I've spent the past 6 hours trying to painfully retrieve a Type's index from idMap through reflection, and I'm still not close to a solution. If it was IdMap instead, one could simply loop over it and retrieve the index like so: for i, k := range token.TokMap.IdMap { switch k { case intLit.Type: fmt.Println(i) } } — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub <#92?email_source=notifications&email_token=AAN6YLL4ZKIUNPCCNWRHRNTP5LYTNA5CNFSM4H4YOEHKYY3PNVWWK3TUL52HS4DFUVEXG43VMWVGG33NNVSW45C7NFSM4G4ZQFPA>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AAN6YLPX2ZBVPX7CKWILRW3P5LYTNANCNFSM4H4YOEHA> .

[Happy-Ferret]

NVM. After some head scratching it turned out to be much easier than I had thought.

t := reflect.ValueOf(token.TokMap)
v := t.FieldByName("typeMap").Index(int(intLit.Type))

// Prints integer type
println(v)

I'm in the process of writing a small language compiler and needed that information for the debug output.

Here's the full -- quick and dirty. I'm, obviously, going to make it generic for types other than int32 -- implementation of catching an overflow (message is my own package for outputting compiler errors. I didn't like the verbose output of the gocc generated errors package):

func NewIntegerLiteral(integer Attrib) (Expression, error) {
	intLit, ok := integer.(*token.Token)
	if !ok {
		return nil, Error("NewIntegerLiteral", "*token.Token", "integer", integer)
	}

	maxInt := 0x7fffffff
	minInt := -0x80000000
	number, _ := strconv.Atoi(string(intLit.Lit))

	if number > maxInt || number < minInt {
		t := reflect.ValueOf(token.TokMap)
		v := t.FieldByName("typeMap").Index(int(intLit.Type))

		message.Errorf("Arithmetic overflow detected! %v overflows %v (Line: %v, Column: %v)", number, v, intLit.Pos.Line, intLit.Pos.Column)
	}

	return &IntegerLiteral{Token: intLit, Value: string(intLit.Lit)}, nil
}

[awalterschulze]

Very interesting. Why print out the error, instead of returning it? Warning: I don’t know if FieldByName works for private fields for all versions of Go.

…

On Tue, 2 Jul 2019 at 08:30, Happy-Ferret ***@***.***> wrote: NVM. After some head scratching it turned out to be much easier than I had thought. t := reflect.ValueOf(token.TokMap)v := t.FieldByName("typeMap").Index(int(intLit.Type)) // Prints integer typeprintln(v) I'm in the process of writing a small language compiler and needed that information for the debug output. Here's the full -- quick and dirty. I'm, obviously, going to make it generic for types other than int32 -- implementation of catching an overflow (message is my own package for outputting compiler errors. I didn't like the verbose output of the gocc generated errors package): func NewIntegerLiteral(integer Attrib) (Expression, error) { intLit, ok := integer.(*token.Token) if !ok { return nil, Error("NewIntegerLiteral", "*token.Token", "integer", integer) } maxInt := 0x7fffffff minInt := -0x80000000 number, _ := strconv.Atoi(string(intLit.Lit)) if number > maxInt || number < minInt { t := reflect.ValueOf(token.TokMap) v := t.FieldByName("typeMap").Index(int(intLit.Type)) message.Errorf("Arithmetic overflow detected! %v overflows %v (Line: %v, Column: %v)", number, v, intLit.Pos.Line, intLit.Pos.Column) } return &IntegerLiteral{Token: intLit, Value: string(intLit.Lit)}, nil } — You are receiving this because you commented. Reply to this email directly, view it on GitHub <#92?email_source=notifications&email_token=AAN6YLMZHPIPFJSYBERI64LP5L7Z7A5CNFSM4H4YOEHKYY3PNVWWK3TUL52HS4DFVREXG43VMVBW63LNMVXHJKTDN5WW2ZLOORPWSZGODZALFOI#issuecomment-507556537>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AAN6YLPPCR4ZW4L6LEPQ4ZLP5L7Z7ANCNFSM4H4YOEHA> .

[Happy-Ferret]

Why print out the error, instead of returning it?

Admittedly, because this project makes me feel like an utter newbie.

If I simply return the error with fmt.Errorf, the output is formatted to:
ERROR Error in S21: sub(15,-), Pos(offset=284, line=14, column=21): Arithmetic overflow detected! -2147483649 overflows int (Line: 14, Column: 9)

So my message package looks like this instead:

package message

import (
	"fmt"
	"os"

	colorable "github.com/mattn/go-colorable"
	"github.com/sirupsen/logrus"
)

func init() {
	timestampFormat := "Mon Jan 2 15:04:05 -0700 MST 2006"
	var disableTimestamp bool

	if len(os.Getenv("TCTimestamp")) == 1 {
		disableTimestamp = false
	} else {
		disableTimestamp = true
	}
	logrus.SetFormatter(&logrus.TextFormatter{ForceColors: true, DisableLevelTruncation: true, DisableTimestamp: disableTimestamp, FullTimestamp: true, TimestampFormat: timestampFormat})
	logrus.SetOutput(colorable.NewColorableStdout())
}

// Error throws an error and aborts the running process.
func Error(v interface{}) {
	logrus.Error(v)
	os.Exit(1)
}

// Errorf formats an error message according to a format specifier,
// throws the error and aborts the running process.
func Errorf(format string, v ...interface{}) {
	logrus.Error(fmt.Sprintf(format, v...))
	os.Exit(1)
}

// Warning displays a warning log message.
func Warning(v interface{}) {
	logrus.Warning(v)
}

// Info displays an informational log message.
func Info(v interface{}) {
	logrus.Info(v)
}

[awalterschulze]

You can still return the error log it after parsing, instead of logging it at the moment of the failure.