update to handle tagging specific functions

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

Author: withinboredom

docs/extensions.md

@@ -272,26 +272,28 @@ This design ensures that your Go code has complete control over how the object's
 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:
+To define an initialization function, tag it with `//export_php:module init`:
 
 ```go
+//export_php:module init
 func initializeModule() {
-// Perform initialization tasks
-// For example, set up global resources, initialize data structures, etc.
+    // Perform initialization tasks
+    // For example, set up global resources, initialize data structures, etc.
 }
+```
+
+To define a shutdown function, tag it with `//export_php:module shutdown`:
 
+```go
+//export_php:module shutdown
 func cleanupModule() {
-// Perform cleanup tasks
-// For example, free resources, close connections, etc.
+    // Perform cleanup tasks
+    // For example, free resources, close connections, etc.
 }
 ```
 
+You can define either one, both, or none of these functions. The initialization function will be called when the PHP module is loaded, and the shutdown function will be called when the PHP module is unloaded.
+
 ### 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/gofile.go

@@ -25,6 +25,7 @@ type goTemplateData struct {
 	InternalFunctions []string
 	Functions         []phpFunction
 	Classes           []phpClass
+	Module            *phpModule
 }
 
 func (gg *GoFileGenerator) generate() error {
@@ -62,6 +63,7 @@ func (gg *GoFileGenerator) buildContent() (string, error) {
 		InternalFunctions: internalFunctions,
 		Functions:         gg.generator.Functions,
 		Classes:           classes,
+		Module:            gg.generator.Module,
 	})
 
 	if err != nil {

internal/extgen/moduleParser.go

@@ -2,17 +2,20 @@ package extgen
 
 import (
 	"bufio"
+	"fmt"
 	"os"
 	"regexp"
 	"strings"
 )
 
-var phpModuleParser = regexp.MustCompile(`//\s*export_php:module\s*(.*)`)
+var phpModuleParser = regexp.MustCompile(`//\s*export_php:module\s+(init|shutdown)`)
 
 // phpModule represents a PHP module with optional init and shutdown functions
 type phpModule struct {
 	InitFunc     string // Name of the init function
+	InitCode     string // Code of the init function
 	ShutdownFunc string // Name of the shutdown function
+	ShutdownCode string // Code of the shutdown function
 }
 
 // ModuleParser parses PHP module directives from Go source files
@@ -27,47 +30,93 @@ func (mp *ModuleParser) parse(filename string) (*phpModule, error) {
 	defer file.Close()
 
 	scanner := bufio.NewScanner(file)
+	module := &phpModule{}
+	var currentDirective string
+	var lineNumber int
+
 	for scanner.Scan() {
+		lineNumber++
 		line := strings.TrimSpace(scanner.Text())
+		
 		if matches := phpModuleParser.FindStringSubmatch(line); matches != nil {
-			moduleInfo := strings.TrimSpace(matches[1])
-			return mp.parseModuleInfo(moduleInfo)
+			directiveType := matches[1]
+			currentDirective = directiveType
+			continue
+		}
+
+		// If we have a current directive and encounter a non-comment line
+		// that doesn't start with "func ", reset the current directive
+		if currentDirective != "" && (line == "" || (!strings.HasPrefix(line, "//") && !strings.HasPrefix(line, "func "))) {
+			currentDirective = ""
+			continue
+		}
+
+		if currentDirective != "" && strings.HasPrefix(line, "func ") {
+			funcName, funcCode, err := mp.extractGoFunction(scanner, line)
+			if err != nil {
+				return nil, fmt.Errorf("extracting Go function at line %d: %w", lineNumber, err)
+			}
+
+			switch currentDirective {
+			case "init":
+				module.InitFunc = funcName
+				module.InitCode = funcCode
+			case "shutdown":
+				module.ShutdownFunc = funcName
+				module.ShutdownCode = funcCode
+			}
+
+			currentDirective = ""
 		}
 	}
 
-	// No module directive found
-	return nil, nil
+	// If we found no module functions, return nil
+	if module.InitFunc == "" && module.ShutdownFunc == "" {
+		return nil, nil
+	}
+
+	return module, scanner.Err()
 }
 
-// parseModuleInfo parses the module info string to extract init and shutdown function names
-func (mp *ModuleParser) parseModuleInfo(moduleInfo string) (*phpModule, error) {
-	module := &phpModule{}
+// extractGoFunction extracts the function name and code from a function declaration
+func (mp *ModuleParser) extractGoFunction(scanner *bufio.Scanner, firstLine string) (string, string, error) {
+	// Extract function name from the first line
+	funcNameRegex := regexp.MustCompile(`func\s+([a-zA-Z0-9_]+)`)
+	matches := funcNameRegex.FindStringSubmatch(firstLine)
+	if len(matches) < 2 {
+		return "", "", fmt.Errorf("could not extract function name from line: %s", firstLine)
+	}
+	funcName := matches[1]
 
-	// Split the module info by commas
-	parts := strings.Split(moduleInfo, ",")
+	// Collect the function code
+	goFunc := firstLine + "\n"
+	braceCount := 0
 
-	for _, part := range parts {
-		part = strings.TrimSpace(part)
-		if part == "" {
-			continue
+	// Count opening braces in the first line
+	for _, char := range firstLine {
+		if char == '{' {
+			braceCount++
 		}
+	}
+	
+	// Continue reading until we find the matching closing brace
+	for braceCount > 0 && scanner.Scan() {
+		line := scanner.Text()
+		goFunc += line + "\n"
 
-		// Split each part by equals sign
-		keyValue := strings.SplitN(part, "=", 2)
-		if len(keyValue) != 2 {
-			continue
+		for _, char := range line {
+			switch char {
+			case '{':
+				braceCount++
+			case '}':
+				braceCount--
+			}
 		}
 
-		key := strings.TrimSpace(keyValue[0])
-		value := strings.TrimSpace(keyValue[1])
-		
-		switch key {
-		case "init":
-			module.InitFunc = value
-		case "shutdown":
-			module.ShutdownFunc = value
+		if braceCount == 0 {
+			break
 		}
 	}
 
-	return module, nil
+	return funcName, goFunc, nil
 }