model

type Array ¶

type Array struct {
	// contains filtered or unexported fields
}

Array is PHP's ordered hash map. It preserves insertion order and allows both integer and string keys, so it doubles as list and dictionary.

func NewArray() *Array

func (a *Array) Append(val any)

func (a *Array) Get(key any) (any, bool)

func (a *Array) Keys() []any

func (a *Array) Len() int

func (a *Array) Range(fn func(key, val any) bool)

func (a *Array) Set(key, val any)

type ArrayItem ¶

type ArrayItem struct {
	Key Expr
	Val Expr
}

ArrayItem is one entry of an ArrayLit. Key is nil for list-style entries.

type ArrayItemValue ¶

type ArrayItemValue struct {
	Key any
	Val any
}

ArrayItemValue is a runtime (already-evaluated) array entry, the value-level counterpart of the ArrayItem AST node. The transpiled __array/__pair helpers produce these. Key is nil for list-style appends.

type ArrayLit ¶

type ArrayLit struct {
	Items []ArrayItem
}

ArrayLit is `array(...)`, `[...]` or `{...}` (map/list literal).

type Assign ¶

type Assign struct {
	Target Expr // Var, PropAccess or Index
	Op     string
	Value  Expr
}

Assign is `Target = Value`. Op may be "=", ".=", "+=", "[]=" (append). expr-lang cannot mutate, so assignment is handled entirely by the runner.

type AssignExpr ¶

type AssignExpr struct {
	Target Expr
	Op     string
	Value  Expr
	Line   int
}

AssignExpr is assignment used as an expression, e.g. the PHP idiom `if (($x = f()) !== false)`. The README forbids assignment in conditions, but minitpl relies on it, so it is supported with Var/Index/Prop targets. As a statement it is lowered to *Assign by the parser.

type Binary ¶

type Binary struct {
	Op    string
	Left  Expr
	Right Expr
}

Binary is an infix operator. Op covers arithmetic (+ - * / %), string concat ("."), comparison (== != === !== < <= > >=) and logical (&& ||).

type Break ¶

type Break struct{}

Break exits the nearest loop or switch.

type Call ¶

type Call struct {
	Name     string
	Fallback string
	Args     []Expr
}

Call is a free-function call: `name(args...)`.

Name is the primary (possibly namespace-qualified) function name. Fallback is the global-namespace name to try if Name is undefined — PHP resolves an unqualified call inside a namespace by first looking in the current namespace and then falling back to the global function of the same short name. Fallback is "" for calls that need no fallback (the common, non-namespaced case), in which case the call resolves as a bare env identifier exactly as before.

type Cast ¶

type Cast struct {
	Type string
	X    Expr
}

Cast is a type cast like `(bool)$x`, `(int)$x`, `(string)$x`, `(array)$x`.

type Catch ¶

type Catch struct {
	Var  string
	Body []Stmt
}

Catch is one `catch (...) { ... }` clause. Var is the bound variable name (without `$`); the caught error is assigned to it so `echo $e` prints it.

type Class ¶

type Class struct {
	Name    string
	Fields  []Field
	Consts  []Field // class constants (Name + value Expr)
	Methods map[string]*FuncDecl
}

Class is the resolved, runnable form of a ClassDecl: field defaults plus a method table keyed by method name.

type ClassConst ¶

type ClassConst struct {
	Class string
	Name  string
}

ClassConst is `Class::NAME` / `self::NAME` class-constant access.

type ClassDecl ¶

type ClassDecl struct {
	Name     string
	Abstract bool
	Fields   []Field
	Consts   []Field // class constants (Name + value Expr), referenced as Class::NAME
	Methods  []*FuncDecl
}

ClassDecl is a trimmed-down class: fields + methods + class constants, no inheritance. Abstract is tolerated (parsed) but not enforced (README omits abstract classes; minitpl's Hook is abstract only to declare constants).

type Closure ¶

type Closure struct {
	Params []Param
	Body   []Stmt
}

Closure is an anonymous function expression `function($a,$b){ ... }`. minitpl uses one as the usort() comparator. `use (...)` capture is not supported (the engine's closures capture nothing).

type Continue ¶

type Continue struct{}

Continue restarts the nearest loop.

type Echo ¶

type Echo struct {
	Args []Expr
}

Echo writes the evaluated arguments to the output buffer.

type Expr ¶

type Expr interface {
	Node
	// contains filtered or unexported methods
}

Expr is an expression: something that evaluates to a value. Expressions are the unit the runner transpiles into go-expr (expr-lang) source and evaluates through the embedded VM.

type ExprStmt ¶

type ExprStmt struct {
	X Expr
}

ExprStmt is an expression evaluated for its side effects (e.g. a method call).

type Field ¶

type Field struct {
	Name    string
	Default Expr // nil if none
}

Field is a class property declaration (also reused for class constants).

type For ¶

type For struct {
	Init Stmt
	Cond Expr
	Post Stmt
	Body []Stmt
}

For is `for (Init; Cond; Post) { Body }`. `while` is parsed into a For with nil Init/Post.

type Foreach ¶

type Foreach struct {
	Source Expr
	KeyVar string // "" if not captured
	ValVar string
	Body   []Stmt
}

Foreach is `foreach (Source as [KeyVar =>] ValVar) { Body }`.

type Func ¶

type Func struct {
	Decl *FuncDecl
	Go   any // an arbitrary Go func, invoked via reflection by the runtime
}

Func is a callable value: either a user-defined PHP function (Decl set) or a host Go function (Go set). Registered host functions use Go.

type FuncDecl ¶

type FuncDecl struct {
	Class  string // "" for free functions
	Name   string
	Params []Param
	Body   []Stmt
}

FuncDecl is a free function or a class method declared with the `function Class::method()` syntax described in the README.

type If ¶

type If struct {
	Cond Expr
	Then []Stmt
	Else []Stmt // may itself contain a single nested *If for elseif chains
}

If is `if (Cond) { Then } elseif... else { Else }`.

type Include ¶

type Include struct {
	Path Expr
	Once bool
}

Include pulls in another file (include / include_once / require).

type Index ¶

type Index struct {
	Base  Expr
	Index Expr
}

Index is `Base[Index]` element access.

type InlineHTML ¶

type InlineHTML struct {
	Text string
}

InlineHTML is raw text outside of <?php ... ?> tags. It is emitted verbatim.

type ListExpr ¶

type ListExpr struct {
	Elems []Expr
}

ListExpr is `list($a, $b, ...)`, valid only as an assignment target. Elements may be nil for skipped positions (`list(, $b)`).

type Lit ¶

type Lit struct {
	Value any
}

Lit is a literal scalar: nil, bool, int64, float64 or string.

type MethodCall ¶

type MethodCall struct {
	Base   Expr
	Method string
	Args   []Expr
}

MethodCall is `Base->method(args...)` or `Base.method(args...)`.

type New ¶

type New struct {
	Class string
	Args  []Expr
}

New is `new ClassName` / `new ClassName(args...)`.

type Node ¶

type Node interface {
	// contains filtered or unexported methods
}

Node is the root interface for every AST element.

type Object ¶

type Object struct {
	Class *Class
	Props map[string]any
}

Object is a class instance: a property bag plus a pointer back to its class. Because methods live on the Class (resolved by the runtime), an Object passed into expr-lang exposes its Props for `$obj->field` style access.

func NewObject(c *Class) *Object

type Param ¶

type Param struct {
	Name    string
	Default Expr // nil if required
}

Param is a single function parameter with an optional default value.

type Program ¶

type Program struct {
	Stmts []Stmt
}

Program is the top-level result of parsing a single PHP file.

type PropAccess ¶

type PropAccess struct {
	Base Expr
	Name string
}

PropAccess is field access. The README allows both `$obj->field` and the new `obj.field` notation; both parse to this node.

type Return ¶

type Return struct {
	Value Expr // may be nil
}

Return exits the current function with an optional value.

type Stmt ¶

type Stmt interface {
	Node
	// contains filtered or unexported methods
}

Stmt is a statement: something executed for its side effects (echo, control flow, assignment, declarations). Statements are interpreted directly by the runner because expr-lang has no concept of statements, loops or mutation.

type Switch ¶

type Switch struct {
	Cond    Expr
	Cases   []SwitchCase
	Default []Stmt
}

Switch is `switch (Cond) { case V: ...; default: ... }`. Case bodies fall through unless they break (PHP semantics); the runner handles break/return.

type SwitchCase ¶

type SwitchCase struct {
	Value Expr
	Body  []Stmt
}

SwitchCase is one `case Value:` arm of a Switch.

type Ternary ¶

type Ternary struct {
	Cond Expr
	Then Expr
	Else Expr
}

Ternary is `Cond ? Then : Else`.

type Throw ¶

type Throw struct {
	X Expr
}

Throw raises an exception. The VM has no exception model; it surfaces as a runtime error (sufficient for minitpl's error-path `throw`s, which the happy compile path never hits).

type Try ¶

type Try struct {
	Body    []Stmt
	Catches []Catch
	Finally []Stmt
}

Try is `try { Body } catch (Type $var) { ... } finally { ... }`. The VM has no exception class hierarchy, so catch type filters are parsed but ignored: the first catch clause handles any error raised in Body (a throw or a runtime error from a forwarded Go call). Finally always runs.

type Unary ¶

type Unary struct {
	Op string
	X  Expr
}

Unary is a prefix operator: "!", "-", "+".

type Var ¶

type Var struct {
	Name string
}

Var is a `$name` reference (the `$` is stripped during parsing).