chore: import upstream snapshot with attribution

internal/parser/languages/dfm.go

@@ -0,0 +1,112 @@
+package languages
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/zzet/gortex/internal/graph"
+	"github.com/zzet/gortex/internal/parser"
+)
+
+var (
+	dfmObjectRe = regexp.MustCompile(`(?i)^\s*(?:object|inherited|inline)\s+(\w+)\s*:\s*(\w+)`)
+	dfmEventRe  = regexp.MustCompile(`(?i)^\s*(On\w+)\s*=\s*(\w+)\s*$`)
+	dfmEndRe    = regexp.MustCompile(`(?i)^\s*end\b`)
+	// dfmListOpenRe / dfmBinOpenRe match a property whose value continues onto
+	// later lines: a `( … )` set/collection or a `{ … }` binary-data blob. Those
+	// lines carry arbitrary text (including literal `object`/`end` tokens) that
+	// must not be parsed as structure.
+	dfmListOpenRe = regexp.MustCompile(`=\s*\(\s*$`)
+	dfmBinOpenRe  = regexp.MustCompile(`=\s*\{\s*$`)
+)
+
+// DFMExtractor extracts Delphi / FireMonkey form-definition files (.dfm, .fmx).
+// Each `object Name: TType` declaration becomes a node — the top-level form is a
+// type, nested controls are fields of it — with a reference to the component
+// class TType, and each `OnEvent = Handler` assignment references the Pascal
+// event-handler method, so a form is linked to the component types and unit
+// methods it uses. The Language() key is distinct so it cannot clobber the
+// Pascal extractor; the emitted nodes are labelled `pascal` to group with Delphi.
+type DFMExtractor struct{}
+
+// NewDFMExtractor constructs a Delphi form-definition extractor.
+func NewDFMExtractor() *DFMExtractor { return &DFMExtractor{} }
+
+func (e *DFMExtractor) Language() string     { return "dfm" }
+func (e *DFMExtractor) Extensions() []string { return []string{".dfm", ".fmx"} }
+
+func (e *DFMExtractor) Extract(filePath string, src []byte) (*parser.ExtractionResult, error) {
+	result := &parser.ExtractionResult{}
+	lines := strings.Split(string(src), "\n")
+	fileNode := &graph.Node{
+		ID: filePath, Kind: graph.KindFile, Name: filePath,
+		FilePath: filePath, StartLine: 1, EndLine: len(lines), Language: "pascal",
+	}
+	result.Nodes = append(result.Nodes, fileNode)
+
+	// stack holds the node ID of each currently-open object, innermost last, so
+	// a nested control attaches to its IMMEDIATE parent (true tree nesting), not
+	// the form root. closer is non-empty while inside a multi-line property
+	// value (")" for a set, "}" for binary data) whose lines must be skipped.
+	var stack []string
+	seen := map[string]bool{}
+	closer := ""
+	for i, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if closer != "" {
+			if strings.HasSuffix(trimmed, closer) {
+				closer = ""
+			}
+			continue
+		}
+		switch {
+		case dfmObjectRe.MatchString(line):
+			m := dfmObjectRe.FindStringSubmatch(line)
+			name, typ := m[1], m[2]
+			id := filePath + "::" + name
+			parent := ""
+			if len(stack) > 0 {
+				parent = stack[len(stack)-1]
+			}
+			if !seen[id] {
+				seen[id] = true
+				kind := graph.KindField
+				if len(stack) == 0 {
+					kind = graph.KindType // the top-level form/frame
+				}
+				result.Nodes = append(result.Nodes, &graph.Node{
+					ID: id, Kind: kind, Name: name,
+					FilePath: filePath, StartLine: i + 1, EndLine: i + 1, Language: "pascal",
+					Meta: map[string]any{"dfm_type": typ},
+				})
+				result.Edges = append(result.Edges, &graph.Edge{
+					From: fileNode.ID, To: id, Kind: graph.EdgeDefines, FilePath: filePath, Line: i + 1,
+				})
+				if parent != "" {
+					// MemberOf the immediate parent control, not the form root.
+					result.Edges = append(result.Edges, &graph.Edge{
+						From: id, To: parent, Kind: graph.EdgeMemberOf, FilePath: filePath, Line: i + 1,
+					})
+				}
+				result.Edges = append(result.Edges, &graph.Edge{
+					From: id, To: "unresolved::" + typ, Kind: graph.EdgeReferences, FilePath: filePath, Line: i + 1,
+				})
+			}
+			stack = append(stack, id)
+		case dfmListOpenRe.MatchString(line):
+			closer = ")"
+		case dfmBinOpenRe.MatchString(line):
+			closer = "}"
+		case dfmEventRe.MatchString(line):
+			m := dfmEventRe.FindStringSubmatch(line)
+			result.Edges = append(result.Edges, &graph.Edge{
+				From: fileNode.ID, To: "unresolved::" + m[2], Kind: graph.EdgeReferences, FilePath: filePath, Line: i + 1,
+			})
+		case dfmEndRe.MatchString(line):
+			if len(stack) > 0 {
+				stack = stack[:len(stack)-1]
+			}
+		}
+	}
+	return result, nil
+}