phpv

type AttrStream interface {
	Attr(v interface{}) interface{}
}

type AttributeGetter interface {
	GetAttributes() []*ZAttribute
}

type BoundedCallable struct {
	Callable
	This ZObject
	Args []*ZVal
}

type CallSiteLocProvider interface {
	CallSiteLoc() *Loc
}

type Callable interface {
	Val
	Name() string
	Call(ctx Context, args []*ZVal) (*ZVal, error)
}

type CallableVal struct{}

type Cloneable interface {
	Clone() any
}

type ClosureInstanceKeyProvider interface {
	ClosureInstanceKey() uintptr
}

type ClosureStaticVarKeyProvider interface {
	ClosureStaticVarKey() uintptr
}

type Compilable interface {
	Compile(ctx Context) error
}

type CompileDelayed struct {
	V Runnable
}

type CompoundWritable interface {
	Writable
	IsCompoundWritable()
}

type Context interface {
	context.Context
	ZArrayAccess
	ZCountable
	ZIterable
	io.Writer

	// return value of GetScriptFile will change depending on which
	// currently include()'d or require()'d file is running
	GetScriptFile() ZString

	Global() GlobalContext
	Func() FuncContext
	Parent(n int) Context
	This() ZObject
	Class() ZClass
	Loc() *Loc
	Tick(ctx Context, l *Loc) error
	MemAlloc(ctx Context, s uint64) error

	Errorf(format string, a ...any) error
	Error(err error, t ...PhpErrorType) error
	FuncErrorf(format string, a ...any) error
	FuncError(err error, t ...PhpErrorType) error

	// In the following functions, args can also take logopt types:
	// examples:
	//   Warn("testing %d", 123, logopt.NoFuncName(true))
	//   Notice("note %s", "asdf", logopt.NoLoc(true))
	//   Notice("nope", logopt.Data{NoLoc: false})
	Warn(format string, args ...any) error
	Notice(format string, args ...any) error
	Deprecated(format string, args ...any) error
	UserDeprecated(format string, args ...any) error

	LogError(err *PhpError, optionArg ...logopt.Data)

	WarnDeprecated() error

	GetFuncName() string

	GetConfig(name ZString, def *ZVal) *ZVal
	GetGlobalConfig(name ZString, def *ZVal) *ZVal

	Call(ctx Context, f Callable, args []Runnable, this ...ZObject) (*ZVal, error)
	CallZVal(ctx Context, f Callable, args []*ZVal, this ...ZObject) (*ZVal, error)
	CallZValInternal(ctx Context, f Callable, args []*ZVal, this ...ZObject) (*ZVal, error)
	CallZValNoCalledIn(ctx Context, f Callable, args []*ZVal, this ...ZObject) (*ZVal, error)

	GetStackTrace(ctx Context) []*StackTraceEntry

	HeaderContext() *HeaderContext
}

type FuncArg struct {
	VarName            ZString
	Ref                bool
	PreferRef          bool // ZEND_SEND_PREFER_REF: silently accepts non-ref values (no warning)
	Required           bool
	Variadic           bool // ...param (collects remaining args into array)
	DefaultValue       Val
	DefaultValueExpr   string // PHP source representation of the default value expression (e.g. constant name), preserved for reflection
	Hint               *TypeHint
	SkipTypeCheck      bool          // if true, the Hint is used for display only (no type enforcement)
	Promotion          ZObjectAttr   // Non-zero if this is a constructor promoted property
	SetPromotion       ZObjectAttr   // PHP 8.4 asymmetric visibility for CPP (0 = same as Promotion)
	ImplicitlyNullable bool          // type hint + NULL default without explicit ?
	Attributes         []*ZAttribute // PHP 8.0 attributes
	Loc                *Loc          // Source location of this parameter

	// Property hooks for promoted properties (PHP 8.4)
	PromotionHooks *ZClassProp // non-nil if promoted property has hooks
}

type FuncCallExpression interface {
	IsFuncCallExpression()
}

type FuncContext interface {
	Context
}

type FuncDeclLoc interface {
	GetDeclLoc() *Loc
}

type FuncGetArgs interface {
	GetArgs() []*FuncArg
}

type FuncUse struct {
	VarName ZString
	Value   *ZVal
	Ref     bool
}

type GeneratorBodyCallable interface {
	IsGeneratorBody() bool
}

type GeneratorCallerContext interface {
	// GetCallingTrace returns the stack trace entries from the context that
	// resumed this generator, plus a synthetic Generator->method() frame.
	// The entries should be appended after the generator's own frames.
	GetCallingTrace() []*StackTraceEntry
}

type GlobalContext interface {
	Context

	Flush()

	Argv() []string

	RegisterFunction(name ZString, f Callable) error
	GetFunction(ctx Context, name ZString) (Callable, error)

	RegisterShutdownFunction(f Callable)

	RegisterClass(name ZString, c ZClass) error
	UnregisterClass(name ZString)
	GetClass(ctx Context, name ZString, autoload bool) (ZClass, error)
	SetCompilingClass(c ZClass)
	GetCompilingClass() ZClass

	RegisterAutoload(handler Callable, prepend bool)
	UnregisterAutoload(handler Callable) bool
	UnregisterAutoloadByName(name string) bool
	ClearAutoloadFunctions()
	GetAutoloadFunctions() []Callable
	GetAutoloadExtensions() string
	SetAutoloadExtensions(exts string)

	RestoreConfig(name ZString)
	SetLocalConfig(name ZString, value *ZVal) (*ZVal, bool)
	IterateConfig() iter.Seq2[string, IniValue]

	ConstantSet(k ZString, v Val) bool
	ConstantGet(k ZString) (Val, bool)
	ConstantForceSet(k ZString, v Val) // overwrite even if already set
	ConstantSetAttributes(k ZString, attrs []*ZAttribute)
	ConstantGetAttributes(k ZString) []*ZAttribute

	RegisterLazyFunc(name ZString, r Runnables, p int)
	RegisterLazyClass(name ZString, r Runnables, p int)

	Open(ctx Context, fn, mode ZString, useIncludePath bool, streamCtx ...Resource) (Stream, error)
	Exists(fn ZString) (bool, error)
	Chdir(d ZString) error
	Getwd() ZString

	Getenv(key string) (string, bool)
	Setenv(key, value string) error
	Unsetenv(key string) error

	Include(ctx Context, fn ZString) (*ZVal, error)
	Require(ctx Context, fn ZString) (*ZVal, error)
	IncludeOnce(ctx Context, fn ZString) (*ZVal, error)
	RequireOnce(ctx Context, fn ZString) (*ZVal, error)

	GetLoadedExtensions() []string

	Random() *random.State

	GetUserErrorHandler() (Callable, PhpErrorType, *ZVal)
	SetUserErrorHandler(handler Callable, filter PhpErrorType, originalVal *ZVal)
	RestoreUserErrorHandler()
	SetUserExceptionHandler(handler Callable, originalVal *ZVal) *ZVal
	RestoreUserExceptionHandler()

	WriteErr(p []byte) (n int, err error)
	ShownDeprecated(key string) bool

	NextResourceID() int
	NextObjectID() int
	ReleaseObjectID(id int)

	// RegisterTempObject registers an object ID as a "temporary" that should be
	// released if it has refcount 0 at the next statement boundary.
	// isFree should return true if the object has no PHP references (refcount == 0).
	RegisterTempObject(id int, isFree func() bool)
	// DrainTempObjects checks all registered temporary objects and releases any
	// that are still unreferenced (refcount == 0). Called at statement boundaries.
	DrainTempObjects()

	GetDeclaredClasses() []ZString
	GetDefinedFunctions(ctx Context, excludeDisabled bool) (*ZArray, error)

	RegisterDestructor(obj ZObject)
	UnregisterDestructor(obj ZObject)

	CheckOpenBasedir(ctx Context, path string, funcName string) error
	IsWithinOpenBasedir(path string) bool

	// OpenFile opens a file for reading through the global file access layer.
	// This centralizes file access so it can be scoped to an fs.FS in the future.
	// The caller must close the returned ReadCloser.
	OpenFile(ctx Context, path string) (io.ReadCloser, error)

	IsUploadedFile(path string) bool
	UnregisterUploadedFile(path string)

	GetIncludedFiles() []string

	// MemMgrTracker returns the memory tracker for PHP-level allocation tracking.
	MemMgrTracker() MemTracker

	LastCallable() Callable
	ClearLastCallable()

	RegisterTickFunction(cb Callable, args []*ZVal)
	UnregisterTickFunction(cb Callable)
	CallTickFunctions(ctx Context) error
	HasTickFunctions() bool

	SetStrictTypes(v bool)
	GetStrictTypes() bool

	IsFunctionDisabled(name ZString) bool

	SetNextCallSuppressCalledIn(v bool)

	SetSkipNextDynPropDeprecation(v bool)
	TakeSkipNextDynPropDeprecation() bool
}

type HeaderContext struct {
	Sent         bool
	OutputOrigin *Loc
	Headers      http.Header
	Sender       HeaderSender
	StatusCode   int
	Callbacks    []Callable
}

type HeaderSender func(headers http.Header, statusCode int) error

type HookCallable struct {
	CallableVal
	Hook     Runnable
	HookName string // e.g. "MyClass::$prop::get"
	Params   []*FuncArg
}

type IniConfig interface {
	Get(name ZString) *IniValue
	CanIniSet(name ZString) bool
	RestoreConfig(ctx Context, name ZString)
	SetLocal(ctx Context, name ZString, value *ZVal) *ZVal
	SetGlobal(ctx Context, name ZString, value *ZVal) *ZVal
	IterateConfig() iter.Seq2[string, IniValue]
	Parse(ctx Context, r io.Reader) error
	EvalConfigValue(ctx Context, expr ZString) (*ZVal, error)
	LoadDefaults(ctx Context)
}

type IniValue struct {
	// values that are set in system php.ini or others
	Global *ZVal

	// values that are set by the user script,
	// using ini_set() or .htacess, or
	// user .ini files
	Local *ZVal
}

type Loc struct {
	Filename   string
	Line, Char int
}

type MemTracker interface {
	MemAlloc(size int64) error
	MemFree(size int64)
}

type MethodCallable struct {
	Callable
	Class       ZClass
	CalledClass ZClass // for late static binding; nil means same as Class
	Static      bool
	AliasName   string // non-empty when the method was called via a trait alias
}

type NamedArgument interface {
	ArgName() ZString
	Inner() Runnable
}

type ParenthesizedExpression interface {
	IsParenthesizedExpression()
}

type PhpError struct {
	Err      error
	FuncName string
	Code     PhpErrorType
	Loc      *Loc

	PhpStackTrace StackTrace
	GoStackTrace  []byte

	IsInternal bool // true when error originates from internal (non-userspace) code
}

type PhpErrorType int

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

type PreEvaluatedArg interface {
	IsPreEvaluatedArg()
}

type ReadonlyRefChecker interface {
	CheckReadonlyRef(ctx Context) error
}

type Resource interface {
	Val
	GetResourceType() ResourceType
	GetResourceID() int
}

type ResourceType int

type RunNull struct{}

type Runnable interface {
	Run(Context) (*ZVal, error)
	Dump(io.Writer) error
}

type RunnableChild interface {
	Runnable
	GetParentNode() Runnable
	SetParentNode(Runnable)
}

type Runnables []Runnable

type SpreadArgument interface {
	Inner() Runnable
}

type StackTrace []*StackTraceEntry

type StackTraceEntry struct {
	FuncName     string
	BareFuncName string // just the method/function name without class prefix
	Filename     string
	ClassName    string
	MethodType   string
	Line         int
	Args         []*ZVal
	Object       ZObject // the $this object for instance method calls
	IsInternal   bool    // true when called from internal code (e.g., output buffer callbacks)
}

type StaticVarEntry struct {
	Name ZString
	Val  *ZVal
}

type StaticVarGetter interface {
	GetStaticVars(ctx Context) []StaticVarEntry
}

type Stream interface {
	Resource
	Read(p []byte) (int, error)
	Write(p []byte) (n int, err error)
	Seek(offset int64, whence int) (int64, error)
	ReadByte() (byte, error)
	Close() error
	SetAttr(k string, v interface{})
	Attr(v interface{}) interface{}
	Stat() (os.FileInfo, error)
	Flush() error
	Sync() error
}

type TypeHint struct {
	Nullable     bool        // true if the type is explicitly nullable (?Type)
	Union        []*TypeHint // for union types (int|string), each alternative
	Intersection []*TypeHint // for intersection types (A&B), all must match
	// contains filtered or unexported fields
}

type UndefinedChecker interface {
	IsUnDefined(ctx Context) bool
	VarName() ZString
}

type Val interface {
	GetType() ZType                          // GetType returns the type of the value
	ZVal() *ZVal                             // ZVal returns a ZVal pointing to this value
	Value() Val                              // Value returns the raw value, in case it was in a ZVal
	AsVal(ctx Context, t ZType) (Val, error) // AsVal converts the value to another type
	String() string                          // String should only be used on ZtString values
}

type Writable interface {
	WriteValue(ctx Context, value *ZVal) error
}

type WriteContextSetter interface {
	SetWriteContext(bool)
}

type WritePreparable interface {
	PrepareWrite(ctx Context) error
}

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

type ZArrayAccess interface {
	OffsetGet(ctx Context, key Val) (*ZVal, error)
	OffsetSet(ctx Context, key Val, value *ZVal) error
	OffsetUnset(ctx Context, key Val) error
	OffsetExists(ctx Context, key Val) (bool, error)
	OffsetCheck(ctx Context, key Val) (*ZVal, bool, error)
}

type ZAttribute struct {
	ClassName   ZString    // fully qualified attribute class name
	Args        []*ZVal    // evaluated arguments (nil if no args)
	ArgExprs    []Runnable // unevaluated argument expressions for lazy evaluation (nil if fully resolved)
	ArgNames    []ZString  // named argument names parallel to Args (empty string = positional)
	Resolving   bool       // true while lazy args are being resolved (prevents re-entrant deprecation)
	StrictTypes bool       // true if declare(strict_types=1) was in effect at the declaration site
}

type ZBool bool

type ZClass interface {
	GetName() ZString
	InstanceOf(parent ZClass) bool
	Implements(intf ZClass) bool
	BaseName() ZString
	GetStaticProps(ctx Context) (*ZHashTable, error)
	GetProp(name ZString) (*ZClassProp, bool)
	GetMethod(name ZString) (*ZClassMethod, bool)
	GetMethods() map[ZString]*ZClassMethod
	GetType() ZClassType
	Handlers() *ZClassHandlers
	GetParent() ZClass
	NextInstanceID() int
}

type ZClassAttr int

type ZClassConst struct {
	Value          Val
	Modifiers      ZObjectAttr
	Resolving      bool          // true while the constant is being resolved (circular reference detection)
	Attributes     []*ZAttribute // PHP 8.0 attributes
	TypeHint       *TypeHint     // PHP 8.3 typed class constants
	DocComment     ZString       // doc comment (/** ... */) associated with this constant
	DeclaringClass ZClass        // the class that originally declared this constant (nil = same class)
}

type ZClassHandlers struct {
	Constructor        *ZClassMethod
	HandleInvoke       func(ctx Context, o ZObject, args []Runnable) (*ZVal, error)
	HandleDecRef       func(ctx Context, o ZObject)                         // called when object refcount is decremented during scope cleanup
	HandleCastArray    func(ctx Context, o ZObject) (*ZArray, error)        // override (array) cast
	HandleCompare      func(ctx Context, a, b ZObject) (int, error)         // override == comparison; return 0=equal, non-0=not-equal
	HandleCast         func(ctx Context, o ZObject, t ZType) (Val, error)   // override type casting (int, float, bool)
	HandleDoOperation  func(ctx Context, op int, a, b *ZVal) (*ZVal, error) // override arithmetic/bitwise operators; op is tokenizer.ItemType
	HandleForeachByRef func(ctx Context, o ZObject) (*ZArray, error)        // provide internal array for foreach by-reference (e.g., ArrayObject/ArrayIterator)
	// HandleIssetDim overrides isset($obj[$key]) behavior. Return true if the key exists
	// and the value is considered "set" (not null). Only called for isset(), not for direct
	// offsetExists() calls.
	HandleIssetDim func(ctx Context, o ZObject, key *ZVal) (bool, error)
	// HandleReadDim provides internal dimension read without going through PHP-level offsetGet.
	// Used by empty() to get values without triggering user-level method calls.
	HandleReadDim func(ctx Context, o ZObject, key *ZVal) (*ZVal, error)
	// HandlePropGet intercepts property read access before __get. Return (nil, nil) to fall through to normal handling.
	// If HandlePropGetEager is true, HandlePropGet is called before hash table lookup (intercepts ALL property reads).
	HandlePropGetEager bool
	HandlePropGet      func(ctx Context, o ZObject, key ZString) (*ZVal, error)
	// HandlePropSet intercepts property write access before __set. Return false to fall through to normal handling.
	HandlePropSet func(ctx Context, o ZObject, key ZString, value *ZVal) (bool, error)
	// HandlePropIsset intercepts isset($obj->prop) before __isset. Return (false, false, nil) to fall through.
	// First bool is the isset result, second bool indicates whether the handler handled it.
	HandlePropIsset func(ctx Context, o ZObject, key ZString) (bool, bool, error)
	// HandlePropUnset intercepts unset($obj->prop) before __unset. Return false to fall through.
	HandlePropUnset func(ctx Context, o ZObject, key ZString) (bool, error)
	// DenySerialize, when true, causes serialization to throw an Exception with
	// "Serialization of 'ClassName' is not allowed". This is checked before any
	// PHP-level __serialize method, so subclass overrides are ignored.
	DenySerialize bool
	// DenyUnserialize, when true, causes unserialization to throw an Exception with
	// "Unserialization of 'ClassName' is not allowed". Checked before __unserialize.
	DenyUnserialize bool
}

type ZClassMethod struct {
	Name                ZString
	Modifiers           ZObjectAttr
	Method              Callable
	Class               ZClass
	Empty               bool
	Loc                 *Loc
	LocEnd              *Loc          // end line of the method body
	Attributes          []*ZAttribute // PHP 8.0 attributes
	FromTrait           ZClass        // non-nil if this method was imported from a trait
	Prototype           ZClass        // interface/class that defines the prototype for this method
	ReturnType          *TypeHint     // return type hint for the method (for reflection)
	TentativeReturnType bool          // if true, ReturnType is a tentative return type (PHP 8.1)
	DocComment          ZString       // doc comment (/** ... */) associated with this method
}

type ZClassProp struct {
	VarName      ZString
	Default      Val
	Modifiers    ZObjectAttr
	SetModifiers ZObjectAttr // PHP 8.4 asymmetric visibility: separate write visibility (0 = same as Modifiers)
	TypeHint     *TypeHint
	Attributes   []*ZAttribute // PHP 8.0 attributes
	DocComment   ZString       // doc comment (/** ... */) associated with this property

	// Property hooks (PHP 8.4)
	GetHook         Runnable      // get { ... } hook body
	SetHook         Runnable      // set($value) { ... } hook body
	SetParam        ZString       // parameter name for set hook (default "$value")
	HasHooks        bool          // true if property declared with hook syntax (even abstract)
	IsBacked        bool          // true if hooks reference $this->prop (backing store exists)
	GetIsAbstract   bool          // true if get hook is abstract (get;)
	SetIsAbstract   bool          // true if set hook is abstract (set;)
	GetIsFinal      bool          // true if get hook is declared final
	SetIsFinal      bool          // true if set hook is declared final
	HasGetDeclared  bool          // true if get hook was declared (even abstract)
	HasSetDeclared  bool          // true if set hook was declared (even abstract)
	SetParamHasType bool          // true if set hook parameter has explicit type hint
	GetHookLoc      *Loc          // source location of get hook declaration
	SetHookLoc      *Loc          // source location of set hook declaration
	GetHookLocEnd   *Loc          // end source location of get hook
	SetHookLocEnd   *Loc          // end source location of set hook
	GetHookAttrs    []*ZAttribute // attributes on get hook
	SetHookAttrs    []*ZAttribute // attributes on set hook
}

type ZClassTraitAlias struct {
	TraitName  ZString     // optional: the trait the method belongs to
	MethodName ZString     // original method name
	NewName    ZString     // alias name (empty = just visibility change)
	NewAttr    ZObjectAttr // new visibility (0 = unchanged)
}

type ZClassTraitInsteadof struct {
	TraitName  ZString   // the trait whose method wins
	MethodName ZString   // the method name being resolved
	InsteadOf  []ZString // traits whose methods are excluded
}

type ZClassTraitUse struct {
	TraitNames []ZString
	Aliases    []ZClassTraitAlias
	Insteadof  []ZClassTraitInsteadof
}

type ZClassType int

type ZClosure interface {
	FuncGetArgs
	Callable
	Runnable

	GetClass() ZClass
	IsStatic() bool   // true for static function() {} and static fn() =>
	GetThis() ZObject // the captured $this (nil for static closures / free functions)
}

type ZCountable interface {
	Count(ctx Context) ZInt
}

type ZFloat float64

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

type ZInt int64

type ZIterable interface {
	NewIterator() ZIterator
}

type ZIterator interface {
	Current(ctx Context) (*ZVal, error)
	Key(ctx Context) (*ZVal, error)
	Next(ctx Context) (*ZVal, error)
	Prev(ctx Context) (*ZVal, error)
	Reset(ctx Context) (*ZVal, error)
	ResetIfEnd(ctx Context) (*ZVal, error)
	End(ctx Context) (*ZVal, error)
	Valid(ctx Context) bool
	Iterate(ctx Context) iter.Seq2[*ZVal, *ZVal]
	IterateRaw(ctx Context) iter.Seq2[*ZVal, *ZVal]
}

type ZNull struct{}

type ZObject interface {
	ZObjectAccess
	Val

	GetOpaque(c ZClass) interface{}
	SetOpaque(c ZClass, v interface{})
	GetClass() ZClass
	NewIterator() ZIterator
	HashTable() *ZHashTable
	Clone(ctx Context) (ZObject, error)
	GetParent() ZObject
	GetKin(className string) ZObject
	IterProps(ctx Context) iter.Seq[*ZClassProp]

	// IncrJsonApplyCount increments the json_encode recursion guard counter.
	// Returns the count before incrementing; if > 0 the object is already
	// being json-encoded.
	IncrJsonApplyCount() int32
	// DecrJsonApplyCount decrements the json_encode recursion guard counter.
	DecrJsonApplyCount()

	// IncrSerializeApplyCount increments the serialize recursion guard counter.
	// Returns the count before incrementing; if > 0 the object is already
	// being serialized.
	IncrSerializeApplyCount() int32
	// DecrSerializeApplyCount decrements the serialize recursion guard counter.
	DecrSerializeApplyCount()
}

type ZObjectAccess interface {
	ObjectGet(ctx Context, key Val) (*ZVal, error)
	ObjectSet(ctx Context, key Val, value *ZVal) error
}

type ZObjectAttr int

type ZString string

type ZStringArray struct {
	*ZString
}

type ZType int

type ZVal struct {
	Name *ZString
	// contains filtered or unexported fields
}