cl/convert:NodeConvert & name gen & file gen for macro

cl/convert.go

@@ -20,6 +20,22 @@ func ModInit(deps []string, outputDir string, modulePath string) error {
 
 type NodeConverter = convert.NodeConverter
 
+type ProcessSymbol = convert.ProcessSymbol
+
+func NewProcessSymbol() *ProcessSymbol {
+	return convert.NewProcessSymbol()
+}
+
+type NameMethod = convert.NameMethod
+
+type Node = convert.Node
+
+func NewNode(name string, kind NodeKind) Node {
+	return convert.NewNode(name, kind)
+}
+
+type NodeKind = convert.NodeKind
+
 type ConvConfig struct {
 	OutputDir string
 	PkgPath   string
@@ -28,6 +44,7 @@ type ConvConfig struct {
 	FileMap   map[string]*llconfig.FileInfo
 	ConvSym   func(name *ast.Object, mangleName string) (goName string, err error)
 	NodeConv  NodeConverter
+	Symbols   *convert.ProcessSymbol
 
 	// CfgFile   string // llcppg.cfg
 	TypeMap        map[string]string // llcppg.pub
@@ -46,6 +63,7 @@ func Convert(config *ConvConfig) (pkg Package, err error) {
 		FileMap:   config.FileMap,
 		ConvSym:   config.ConvSym,
 		NodeConv:  config.NodeConv,
+		Symbols:   config.Symbols,
 
 		TypeMap:        config.TypeMap,
 		Deps:           config.Deps,

cl/internal/convert/convert.go

@@ -8,6 +8,7 @@ import (
 	"github.com/goplus/llcppg/ast"
 	cfg "github.com/goplus/llcppg/cmd/gogensig/config"
 	llconfig "github.com/goplus/llcppg/config"
+	ctoken "github.com/goplus/llcppg/token"
 )
 
 var (
@@ -41,6 +42,7 @@ type Config struct {
 	FileMap   map[string]*llconfig.FileInfo
 	ConvSym   func(name *ast.Object, mangleName string) (goName string, err error)
 	NodeConv  NodeConverter
+	Symbols   *ProcessSymbol
 
 	// CfgFile   string // llcppg.cfg
 	TypeMap        map[string]string // llcppg.pub
@@ -94,6 +96,7 @@ func NewConverter(config *Config) (*Converter, error) {
 		Name:           config.PkgName,
 		OutputDir:      config.OutputDir,
 		ConvSym:        config.ConvSym,
+		Symbols:        config.Symbols,
 		LibCommand:     config.Libs,
 		TrimPrefixes:   config.TrimPrefixes,
 		KeepUnderScore: config.KeepUnderScore,
@@ -123,10 +126,28 @@ func (p *Converter) Process() {
 		}
 	}
 
+	processNode := func(goFile string, process func() error) {
+		p.GenPkg.SetGoFile(goFile)
+		if err := process(); err != nil {
+			log.Panicln(err)
+		}
+	}
+
 	for _, macro := range p.Pkg.Macros {
-		processDecl(macro.Loc.File, func() error {
-			return p.GenPkg.NewMacro(macro)
-		})
+		if len(macro.Tokens) == 2 && macro.Tokens[1].Token == ctoken.LITERAL {
+			goName, goFile, err := p.Conf.NodeConv.ConvMacro(macro)
+			// todo(zzy):goName to New Macro
+			if err != nil {
+				if errors.Is(err, ErrSkip) {
+					continue
+				}
+				// todo(zzy):refine error handing
+				log.Panicln(err)
+			}
+			processNode(goFile, func() error {
+				return p.GenPkg.NewMacro(macro, goName)
+			})
+		}
 	}
 
 	for _, decl := range p.Pkg.Decls {

cl/internal/convert/convert_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/goplus/llcppg/cl/internal/cltest"
 	"github.com/goplus/llcppg/cl/internal/convert"
 	"github.com/goplus/llcppg/cmd/gogensig/config"
+	"github.com/goplus/llcppg/cmd/gogensig/node"
 	"github.com/goplus/llcppg/cmd/gogensig/unmarshal"
 	llcppg "github.com/goplus/llcppg/config"
 	"github.com/goplus/llgo/xtool/env"
@@ -220,19 +221,31 @@ func testFrom(t *testing.T, dir string, gen bool, validateFunc func(t *testing.T
 		t.Fatal(err)
 	}
 
+	symbols := convert.NewProcessSymbol()
+
 	cvt, err := convert.NewConverter(&convert.Config{
 		PkgPath:   ".",
 		PkgName:   cfg.Name,
 		ConvSym:   cltest.GetConvSym(symbPath),
 		OutputDir: outputDir,
 		Pkg:       convertPkg.File,
 		FileMap:   convertPkg.FileMap,
-
+		NodeConv: node.NewNodeConverter(
+			&node.NodeConverterConfig{
+				PkgName: cfg.Name,
+				// symbol table
+				FileMap:      convertPkg.FileMap,
+				TypeMap:      cfg.TypeMap,
+				TrimPrefixes: cfg.TrimPrefixes,
+				Symbols:      symbols,
+			},
+		),
 		TypeMap:        cfg.TypeMap,
 		Deps:           cfg.Deps,
 		TrimPrefixes:   cfg.TrimPrefixes,
 		Libs:           cfg.Libs,
 		KeepUnderScore: cfg.KeepUnderScore,
+		Symbols:        symbols,
 	})
 	if err != nil {
 		t.Fatal(err)

cl/internal/convert/package.go

@@ -52,6 +52,7 @@ type PackageConfig struct {
 	Name           string // current package name
 	OutputDir      string
 	ConvSym        func(name *ast.Object, mangleName string) (goName string, err error)
+	Symbols        *ProcessSymbol
 	GenConf        *gogen.Config
 	TrimPrefixes   []string
 	LibCommand     string // use to gen link command like $(pkg-config --libs xxx)
@@ -67,12 +68,18 @@ func NewPackage(config *PackageConfig) (*Package, error) {
 			EnableTypesalias: true,
 		}
 	}
+	var symbols *ProcessSymbol
+	if config.Symbols == nil {
+		symbols = NewProcessSymbol()
+	} else {
+		symbols = config.Symbols
+	}
 	p := &Package{
 		p:               gogen.NewPackage(config.PkgPath, config.Name, config.GenConf),
 		conf:            config,
 		incompleteTypes: NewIncompleteTypes(),
 		locMap:          NewThirdTypeLoc(),
-		symbols:         NewProcessSymbol(),
+		symbols:         symbols,
 	}
 
 	// default have load llgo/c
@@ -678,41 +685,45 @@ func (p *Package) createEnumItems(items []*ast.EnumItem, enumType types.Type) er
 	return nil
 }
 
-func (p *Package) NewMacro(macro *ast.Macro) error {
-	if !p.curFile.InCurPkg() {
-		return nil
-	}
-
+func (p *Package) NewMacro(macro *ast.Macro, goName string) error {
 	// simple const macro define (#define NAME value)
 	if len(macro.Tokens) == 2 && macro.Tokens[1].Token == ctoken.LITERAL {
 		value := macro.Tokens[1].Lit
 		defs := p.NewConstGroup()
-		node := Node{name: macro.Name, kind: Macro}
-		name, _, exist, err := p.RegisterNode(node, p.constName, p.lookupPub)
-		if err != nil {
-			return fmt.Errorf("NewMacro: %s fail: %w", macro.Name, err)
-		}
-		if exist {
-			if debugLog {
-				log.Printf("NewMacro: %s is processed\n", macro.Name)
-			}
-			return nil
+
+		obj := p.lookupPub("", goName)
+		if obj != nil {
+			return fmt.Errorf("NewMacro: %s is already defined", macro.Name)
 		}
+
+		// node := Node{name: macro.Name, kind: Macro}
+
+		// todo(zzy): remove this,current only to register name to ProcessSymbol,to keep other logic correct
+		// _, _, exist, err := p.RegisterNode(node, p.constName, p.lookupPub)
+		// if err != nil {
+		// 	return fmt.Errorf("NewMacro: %s fail: %w", macro.Name, err)
+		// }
+		// if exist {
+		// 	if debugLog {
+		// 		log.Printf("NewMacro: %s is processed\n", macro.Name)
+		// 	}
+		// 	return nil
+		// }
 		if debugLog {
-			log.Printf("NewMacro: %s = %s\n", name, value)
+			log.Printf("NewMacro: %s = %s\n", goName, value)
 		}
 		if str, err := litToString(value); err == nil {
-			defs.New(str, nil, name)
+			defs.New(str, nil, goName)
 		} else if _, err := litToUint(value); err == nil {
 			defs.New(&goast.BasicLit{
 				Kind:  token.INT,
 				Value: value,
-			}, nil, name)
+			}, nil, goName)
 		} else if _, err := litToFloat(value, 64); err == nil {
 			defs.New(&goast.BasicLit{
 				Kind:  token.FLOAT,
 				Value: value,
-			}, nil, name)
+			}, nil, goName)
 		}
 	}
 	return nil
@@ -722,6 +733,13 @@ func (p *Package) NewConstGroup() *ConstGroup {
 	return NewConstGroup(p.p, p.p.Types.Scope())
 }
 
+func (p *Package) SetGoFile(fileName string) error {
+	_, err := p.p.SetCurFile(fileName, true)
+	// todo(zzy):avoid mark every time
+	p.p.Unsafe().MarkForceUsed(p.p)
+	return err
+}
+
 type ConstGroup struct {
 	defs *gogen.ConstDefs
 }
@@ -959,10 +977,10 @@ func (it *IncompleteTypes) IterateIncomplete(fn func(*Incomplete) error) error {
 	return nil
 }
 
-type nodeKind int
+type NodeKind int
 
 const (
-	FuncDecl nodeKind = iota + 1
+	FuncDecl NodeKind = iota + 1
 	TypeDecl
 	TypedefDecl
 	EnumTypeDecl
@@ -972,7 +990,19 @@ const (
 
 type Node struct {
 	name string
-	kind nodeKind
+	kind NodeKind
+}
+
+func NewNode(name string, kind NodeKind) Node {
+	return Node{name: name, kind: kind}
+}
+
+func (n Node) Name() string {
+	return n.name
+}
+
+func (n Node) Kind() NodeKind {
+	return n.kind
 }
 
 type ProcessSymbol struct {

cl/internal/convert/package_bulitin_test.go

@@ -105,7 +105,7 @@ func TestRedefPubName(t *testing.T) {
 			Loc:    &ast.Location{File: "temp.h"},
 			Name:   "Bar",
 			Tokens: []*ast.Token{{Token: ctoken.IDENT, Lit: "Bar"}, {Token: ctoken.LITERAL, Lit: "1"}},
-		})
+		}, "Bar")
 		if err == nil {
 			t.Fatal("expect a error")
 		}

cl/internal/convert/package_test.go

@@ -1165,14 +1165,16 @@ func TestRedef(t *testing.T) {
 		Name:   "MACRO_FOO",
 		Tokens: []*ast.Token{{Token: token.IDENT, Lit: "MACRO_FOO"}, {Token: token.LITERAL, Lit: "1"}},
 	}
-	err = pkg.NewMacro(macro)
+	err = pkg.NewMacro(macro, macro.Name)
 	if err != nil {
 		t.Fatal("unexpect redefine err")
 	}
 
-	err = pkg.NewMacro(macro)
-	if err != nil {
-		t.Fatal("unexpect redefine err")
+	// NOTE(zzy):in upper layer logic to avoid reprocess node after refactor.
+	// So here we expect a redefine error.
+	err = pkg.NewMacro(macro, macro.Name)
+	if err == nil {
+		t.Fatal("expect a redefine error")
 	}
 
 	var buf bytes.Buffer

cmd/gogensig/gogensig.go

@@ -27,6 +27,7 @@ import (
 	"github.com/goplus/llcppg/ast"
 	"github.com/goplus/llcppg/cl"
 	"github.com/goplus/llcppg/cmd/gogensig/config"
+	"github.com/goplus/llcppg/cmd/gogensig/node"
 	"github.com/goplus/llcppg/cmd/gogensig/unmarshal"
 	llcppg "github.com/goplus/llcppg/config"
 	"github.com/qiniu/x/errors"
@@ -79,6 +80,8 @@ func main() {
 	symbTable, err := config.NewSymbolTable(symbFile)
 	check(err)
 
+	symbols := cl.NewProcessSymbol()
+
 	pkg, err := cl.Convert(&cl.ConvConfig{
 		PkgName: conf.Name,
 		ConvSym: func(name *ast.Object, mangleName string) (goName string, err error) {
@@ -88,6 +91,16 @@ func main() {
 			}
 			return item.GoName, nil
 		},
+		NodeConv: node.NewNodeConverter(
+			&node.NodeConverterConfig{
+				PkgName:      conf.Name,
+				SymbTable:    symbTable,
+				FileMap:      convertPkg.FileMap,
+				TypeMap:      conf.TypeMap,
+				TrimPrefixes: conf.TrimPrefixes,
+				Symbols:      symbols,
+			},
+		),
 		Pkg:            convertPkg.File,
 		FileMap:        convertPkg.FileMap,
 		TypeMap:        conf.TypeMap,