add ability to specify startup/shutdown functions

Signed-off-by: Robert Landers <landers.robert@gmail.com>

Author: withinboredom

docs/extensions.md

@@ -267,6 +267,31 @@ $user->updateInfo(null, 25, null);          // Name and active are null
 
 This design ensures that your Go code has complete control over how the object's state is accessed and modified, providing better encapsulation and type safety.
 
+### Module Initialization and Shutdown
+
+The generator supports defining module initialization and shutdown functions using the `//export_php:module` directive.
+This allows you to perform setup and cleanup operations when your extension is loaded and unloaded.
+
+```go
+//export_php:module init=initializeModule, shutdown=cleanupModule
+```
+
+The `init` parameter specifies a function that will be called when the module is initialized, and the `shutdown` parameter specifies a function that will be called when the module is shut down. Both parameters are optional; you can specify either one, both, or none.
+
+The specified functions should be defined in your Go code:
+
+```go
+func initializeModule() {
+// Perform initialization tasks
+// For example, set up global resources, initialize data structures, etc.
+}
+
+func cleanupModule() {
+// Perform cleanup tasks
+// For example, free resources, close connections, etc.
+}
+```
+
 ### Declaring Constants
 
 The generator supports exporting Go constants to PHP using two directives: `//export_php:const` for global constants and `//export_php:classconstant` for class constants. This allows you to share configuration values, status codes, and other constants between Go and PHP code.

internal/extgen/cfile.go

@@ -23,6 +23,7 @@ type cTemplateData struct {
 	Classes   []phpClass
 	Constants []phpConstant
 	Namespace string
+	Module    *phpModule
 }
 
 func (cg *cFileGenerator) generate() error {
@@ -68,6 +69,7 @@ func (cg *cFileGenerator) getTemplateContent() (string, error) {
 		Classes:   cg.generator.Classes,
 		Constants: cg.generator.Constants,
 		Namespace: cg.generator.Namespace,
+		Module:    cg.generator.Module,
 	}); err != nil {
 		return "", err
 	}

internal/extgen/generator.go

@@ -15,6 +15,7 @@ type Generator struct {
 	Classes    []phpClass
 	Constants  []phpConstant
 	Namespace  string
+	Module     *phpModule
 }
 
 // EXPERIMENTAL
@@ -86,6 +87,12 @@ func (g *Generator) parseSource() error {
 	}
 	g.Namespace = ns
 
+	module, err := parser.ParseModule(g.SourceFile)
+	if err != nil {
+		return fmt.Errorf("parsing module: %w", err)
+	}
+	g.Module = module
+
 	return nil
 }
 

internal/extgen/moduleParser.go

@@ -0,0 +1,73 @@
+package extgen
+
+import (
+	"bufio"
+	"os"
+	"regexp"
+	"strings"
+)
+
+var phpModuleParser = regexp.MustCompile(`//\s*export_php:module\s*(.*)`)
+
+// phpModule represents a PHP module with optional init and shutdown functions
+type phpModule struct {
+	InitFunc     string // Name of the init function
+	ShutdownFunc string // Name of the shutdown function
+}
+
+// ModuleParser parses PHP module directives from Go source files
+type ModuleParser struct{}
+
+// parse parses the source file for PHP module directives
+func (mp *ModuleParser) parse(filename string) (*phpModule, error) {
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if matches := phpModuleParser.FindStringSubmatch(line); matches != nil {
+			moduleInfo := strings.TrimSpace(matches[1])
+			return mp.parseModuleInfo(moduleInfo)
+		}
+	}
+
+	// No module directive found
+	return nil, nil
+}
+
+// parseModuleInfo parses the module info string to extract init and shutdown function names
+func (mp *ModuleParser) parseModuleInfo(moduleInfo string) (*phpModule, error) {
+	module := &phpModule{}
+	
+	// Split the module info by commas
+	parts := strings.Split(moduleInfo, ",")
+	
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		
+		// Split each part by equals sign
+		keyValue := strings.SplitN(part, "=", 2)
+		if len(keyValue) != 2 {
+			continue
+		}
+		
+		key := strings.TrimSpace(keyValue[0])
+		value := strings.TrimSpace(keyValue[1])
+		
+		switch key {
+		case "init":
+			module.InitFunc = value
+		case "shutdown":
+			module.ShutdownFunc = value
+		}
+	}
+	
+	return module, nil
+}

internal/extgen/parser.go

@@ -25,3 +25,9 @@ func (p *SourceParser) ParseNamespace(filename string) (string, error) {
 	namespaceParser := NamespaceParser{}
 	return namespaceParser.parse(filename)
 }
+
+// EXPERIMENTAL
+func (p *SourceParser) ParseModule(filename string) (*phpModule, error) {
+	moduleParser := &ModuleParser{}
+	return moduleParser.parse(filename)
+}

internal/extgen/templates/extension.c.tpl

@@ -167,14 +167,28 @@ PHP_MINIT_FUNCTION({{.BaseName}}) {
     {{- end}}
     {{- end}}
     {{- end}}
+    
+    {{if and .Module .Module.InitFunc}}
+    {{.Module.InitFunc}}_wrapper();
+    {{end}}
+    
+    return SUCCESS;
+}
+
+{{if .Module}}
+{{if .Module.ShutdownFunc}}
+PHP_MSHUTDOWN_FUNCTION({{.BaseName}}) {
+    {{.Module.ShutdownFunc}}_wrapper();
     return SUCCESS;
 }
+{{end}}
+{{end}}
 
 zend_module_entry {{.BaseName}}_module_entry = {STANDARD_MODULE_HEADER,
                                          "{{.BaseName}}",
                                          ext_functions,             /* Functions */
                                          PHP_MINIT({{.BaseName}}),  /* MINIT */
-                                         NULL,                      /* MSHUTDOWN */
+                                         {{if and .Module .Module.ShutdownFunc}}PHP_MSHUTDOWN({{.BaseName}}),{{else}}NULL,{{end}}  /* MSHUTDOWN */
                                          NULL,                      /* RINIT */
                                          NULL,                      /* RSHUTDOWN */
                                          NULL,                      /* MINFO */