pointer
Enable an AI agent to recognise a pointer, assess whether it still identifies its intended target, and decide whether it may be followed, shared, updated or retired.
Research draft, second pass
A second pass drafted this model: the structure a model of this thing needs, and what is known about it in the world. The line under this one says how the second half was obtained - researched against sources, or recalled without web access, in which case nothing here was read anywhere and every claim is a lead to verify. Unreviewed either way.
Researched by: Codex + Grok
Purpose and description
Enable an AI agent to recognise a pointer, assess whether it still identifies its intended target, and decide whether it may be followed, shared, updated or retired.
A pointer is a typed reference to a storage location (an address or handle) used by a program or data structure to locate another object without embedding that object.
It can be Interpret the reference using an explicit namespace and context.; Resolve the pointer and record the returned target, intermediate steps and observation conditions.; Compare the resolved target with evidence of the intended target.; Rebase or translate the pointer while checking that its target binding is preserved.; Retarget or retire the pointer when authorised, preserving the previous binding where needed.; Assess whether following or sharing the pointer would expose restricted information or trigger an unintended action..
Distinguishing features
A pointer has a referential role: an interpreter can use it to identify or locate something beyond the pointer's own expression.
A copy or embedded representation supplies target content; a pointer supplies a means of referring to that content.
A label merely names or describes something unless a convention or context makes it usable as a reference.
A search expression requests matching candidates; a pointer purports to designate a target, even when resolution fails or returns several candidates.
A hyperlink combines a reference with an activation mechanism; a pointer may exist without a clickable interface.
Scope
+ The pointer's recorded expression and reference mechanism
+ The target or target fragment it is intended to identify
+ The namespace, base or contextual anchor required to interpret it
+ Resolution behaviour and evidence of successful or failed targeting
+ Changes to the pointer's binding and conditions for following or disclosing it
- The target's substantive content, quality and lifecycle except where these affect the reference
- Documents, messages and interfaces that contain pointers
- The implementation and operation of resolver services
- Physical pointing devices and graphical cursor controls
- Programming-language memory pointers and their allocation semantics, pending confirmation of registry intent
Characteristics
- Reference mechanism
- Locator-based, identifier-based, position-based, context-dependent, other or unresolved Determines what an interpreter must know to identify the target.
- Pointer expression
- Recorded reference expression, including significant syntax Allows an agent to inspect the actual reference and detect consequential edits.
- Interpretation context
- Required namespace, base location, containing object, contextual anchor or resolver convention The same expression may designate different targets when interpreted in different contexts.
- Intended target
- Target entity and any selected fragment, with evidence for the intended binding Makes it possible to distinguish reaching something from reaching the right thing.
- Target selection policy
- Fixed version, current version, context-selected target, other or unknown Determines whether a changed result is expected behaviour or a broken reference.
- Observed resolution state
- Untested, resolved, ambiguous, not found, access denied, resolver unavailable or malformed Separates distinct reasons that following the pointer may succeed or fail.
- Resolution evidence age
- Elapsed seconds since the recorded resolution observation Helps an agent decide whether previous resolution evidence needs refreshing.
- Observed target correspondence
- Matches intended target, mismatches, partially matches or unverified A successful resolution alone does not establish a correct binding.
Also called
Where this came from
wikidata · CC0 1.0
Drafted structure
Bundle to layer to finding to question, as the second pass will find it: 5 bundles · 9 layers · 16 findings · 29 questions.
Reference expression What makes the recorded expression function as a pointer and how it must be interpreted.
An agent cannot judge a pointer from its visible text alone when syntax and context determine its referent.
Referential role
Establish whether the expression designates a target rather than merely describing or reproducing it.
Designation test
Record the evidence that this expression is intended to direct an interpreter to a target.
- What makes this expression a reference rather than a label, quotation, embedded copy or search request? definition
- Which convention or originating context establishes its referential role? provenance
Interpretation dependencies
Identify the syntax and contextual inputs needed to interpret the pointer.
Expression and context
Record the reference expression together with dependencies that affect what it designates.
- Which parts of the expression encode the target, and which encode a fragment, version or interpretation instruction? definition
- Which namespace, base location or contextual anchor must accompany this pointer for it to retain its meaning? boundary
- Which changes to spelling, escaping or normalisation could change its referent? boundary
Target binding The intended referent, its granularity and the rules governing continuity of that binding.
A pointer can remain resolvable while silently referring to the wrong object, fragment or version.
Intended referent
Specify what the pointer is meant to designate and how that intent is known.
Target and selector
Distinguish the target as a whole from any selected part or occurrence.
- Does the pointer designate an entire object, a fragment, a position or a particular occurrence? boundary
- What evidence establishes the intended target independently of the current resolution result? provenance
Binding continuity
Determine which changes preserve the reference and which constitute retargeting.
Version and retargeting policy
Record whether the pointer follows change or remains bound to a fixed target state.
- Is the pointer intended to select a fixed version, the current version or a target chosen by context? definition
- Would relocation, identifier reuse or movement of the selected fragment preserve the intended binding? boundary
- Who may change the binding, and what evidence must distinguish an authorised retargeting from an accidental substitution? action
Resolution evidence How the pointer was followed, what was reached and how confidently that result can be used.
Resolution depends on time and context, and reaching a destination does not prove correspondence with the intended referent.
Resolution observation
Capture a bounded observation of the pointer's behaviour.
Resolution path and outcome
Record interpretation and resolution steps, including any intermediate references and failure point.
- When, with which resolver, context and access conditions was this pointer last checked? measurement
- What target or candidates were returned, through which intermediate references, or at which step did resolution fail? measurement
- If resolution failed, what evidence separates a missing target from denied access, unavailable infrastructure or an invalid expression? measurement
Correspondence check
Assess whether the observed destination satisfies the intended binding.
Resolved target verification
Compare the reached object and selected fragment against available evidence of intent.
- Which identity, version or fragment evidence supports or contradicts correspondence with the intended target? measurement
- What change or elapsed interval should require a fresh resolution and correspondence check before use? action
Reference use and maintenance Conditions for following, disclosing, transporting and repairing the pointer.
Using a pointer may require context, expose access-bearing information or alter what another interpreter will reach.
Following and disclosure
Identify consequences attached to activating or sharing this particular reference.
Use conditions
Record what must be established before the pointer is followed or passed to another party.
- Does following this pointer only identify or retrieve a target, or can its activation invoke an operation? boundary
- Does the expression contain credentials, capability tokens or restricted target information that constrain who may receive it? boundary
- What authorisation and interpreter behaviour are required before an agent may follow or share it? action
Transport and repair
Preserve or deliberately change the binding when the pointer or its surrounding context changes.
Binding-preserving maintenance
Assess copying, rebasing, replacement and retirement against the intended referent.
- If the pointer is copied into another document, interface or namespace, what context must travel with it or be rewritten? action
- What evidence would justify repairing this reference to a proposed replacement target rather than marking the binding unresolved? action
- When this pointer is replaced or retired, which known uses and previous bindings must remain traceable? action
Evidence and external alignment What the world already says about this thing, gathered so the model can be checked against it.
A model that cannot be lined up against existing standards, identifiers and practice cannot be adopted by anyone who already uses them.
Reported evidence
Findings from the breadth pass, kept separate from the structural claims.
Kinds and varieties
Reported by the breadth pass; each item needs checking against its source before it becomes normative.
- typed memory pointer (C/C++/Rust raw pointer)
- null / optional pointer
- function pointer / procedure pointer
- smart pointer (unique, shared, weak)
- file / stream pointer (offset into a sequential resource)
- instruction pointer / program counter
- far / segmented / capability pointer (address plus bounds or rights)
- GUI mouse / caret pointer (on-screen pointing glyph)
- Which of these kinds and varieties hold for the sense of pointer this model covers, and on what evidence? provenance
Identifiers and schemes
Reported by the breadth pass; each item needs checking against its source before it becomes normative.
- Wikidata - Q4433125 (pointer, programming) - Distinct from Q38904 Pointer (dog) and Q2094996 pointing device.
- ISO/IEC language type - C pointer type T* / C++ std::unique_ptr<T>, std::shared_ptr<T> - Type constructors, not instance identifiers.
- POSIX / C library - FILE* stream; off_t file offset - Handle and offset that together act as a file pointer.
- Which of these identifiers and schemes hold for the sense of pointer this model covers, and on what evidence? provenance
Standards and regulation
Reported by the breadth pass; each item needs checking against its source before it becomes normative.
- ISO/IEC 9899 (ISO/IEC JTC 1/SC 22) - C pointer types, null pointer, undefined behaviour of invalid dereference
- ISO/IEC 14882 (ISO/IEC JTC 1/SC 22) - C++ pointers and smart pointers
- ISO/IEC/IEEE 9945 POSIX (ISO/IEC JTC 1/SC 22 and IEEE) - file position and FILE streams
- ECMA-262 (Ecma International TC39) - object references, not C-style pointers
- CHERI / capability hardware (University of Cambridge, SRI, Arm Morello) - capability pointers with bounds and permissions
- Which of these standards and regulation hold for the sense of pointer this model covers, and on what evidence? provenance
Real-world use
Reported by the breadth pass; each item needs checking against its source before it becomes normative.
- C and C++ programs pass and store addresses of objects, arrays, and functions; pointer arithmetic walks buffers and data structures.
- Operating-system kernels and device drivers use pointers to map physical and virtual memory and to share kernel objects.
- File I/O APIs keep a current-position pointer (seek offset) into a file or stream.
- CPUs expose an instruction pointer / program counter that names the next instruction.
- GUI systems draw a mouse pointer (cursor) whose hotspot is the coordinate used for hit-testing.
- Garbage-collected and managed runtimes hide raw pointers behind references; FFI and systems code still expose them at the boundary.
- Which of these real-world use hold for the sense of pointer this model covers, and on what evidence? provenance
Typical measurements
Reported by the breadth pass; each item needs checking against its source before it becomes normative.
- address width - 16, 32, or 64 (historically also 8-128) - bit
- object size of a pointer - 2-16 (commonly 4 or 8; CHERI capabilities 16) - byte
- alignment of the pointee - 1-64 depending on type and ABI - byte
- file-position offset - 0 to file size (often 2^63-1 max) - byte
- Which of these typical measurements hold for the sense of pointer this model covers, and on what evidence? provenance
Failure modes and hazards
Reported by the breadth pass; each item needs checking against its source before it becomes normative.
- Null dereference: using a null pointer as if it named a live object.
- Dangling pointer / use-after-free: the pointee has been deallocated or has gone out of scope.
- Buffer overrun via pointer arithmetic past the allocated object (undefined behaviour; a leading cause of memory-safety CVEs).
- Type confusion / invalid cast: treating storage as a different type than was allocated.
- Uninitialized pointer: reading a pointer variable before it is set.
- Pointer injection / corruption (memory-safety exploits, arbitrary-write primitives).
- Double-free and invalid-free when a pointer is used as an ownership token incorrectly.
- Information leak of addresses (ASLR bypass) when pointer values are disclosed.
- Which of these failure modes and hazards hold for the sense of pointer this model covers, and on what evidence? provenance
Regional variation
Reported by the breadth pass; each item needs checking against its source before it becomes normative.
- US/English systems programming: 'pointer' almost always means a memory address; 'cursor' is used for UI and for database/file position.
- British and ISO C text also use 'pointer'; UI documentation more often says 'pointer' or 'mouse pointer' interchangeably with 'cursor'.
- Some European language standards and textbooks translate as Zeiger (German), pointeur (French), puntero (Spanish), указатель (Russian).
- Capability and CHERI research (UK/US) treats a pointer as an unforgeable bounded capability, not a bare integer address.
- In database and COBOL practice, 'pointer' may mean a record locater or file position rather than a machine address.
- Which of these regional variation hold for the sense of pointer this model covers, and on what evidence? provenance
Neighbouring kinds and how to tell them apart
Reported by the breadth pass; each item needs checking against its source before it becomes normative.
- reference (managed / language-level) - A reference names an object and typically forbids arithmetic, reseating (in C++), or null (in some languages); a pointer is an address-like value that can be null, copied, and (in C) offset.
- handle / capability - A handle is an opaque identifier resolved by a kernel or runtime; a raw pointer is the address itself. Capability pointers add bounds and rights to the address.
- iterator - An iterator is a traversal object over a collection; it may be implemented with a pointer but has a container-relative contract (begin/end, invalidation rules).
- index / offset - An index is an integer relative to a base (array or file); a pointer is usually an absolute address, though a file pointer is an offset.
- mouse pointer / cursor (GUI) - The on-screen glyph and hotspot coordinate used for pointing; not a memory address. Test: does it name a storage location or a screen position?
- Pointer (dog breed) - A gundog breed (Wikidata Q38904); unrelated to INF.MED except homonymy.
- smart pointer - A value type that stores a raw pointer plus ownership/lifetime policy; the raw pointer is the payload, not the same abstraction.
- Which of these neighbouring kinds and how to tell them apart hold for the sense of pointer this model covers, and on what evidence? provenance
Sources
- ISO/IEC 9899:2018 - Information technology - Programming languages - C - Defines pointer types, pointer arithmetic, null pointer, and conversion rules in the C language standard.
- ISO/IEC 14882:2020 - Programming languages - C++ - Defines raw pointers, pointer-to-member, and the standard smart-pointer library (unique_ptr, shared_ptr, weak_ptr).
- ECMA-262 ECMAScript Language Specification - Shows the neighbouring reference model (object references without pointer arithmetic) used in managed languages.
- ISO/IEC/IEEE 9945 (POSIX) - Information technology - Portable Operating System Interface - File-offset / FILE* stream pointer behaviour and lseek semantics.
What the second pass must settle
- Does the registry intend pointer to mean an informational reference, a memory pointer, a visual pointing cue or a broader concept spanning these?
- Do existing Vercy models for reference, link, identifier or locator already own this concept, requiring reuse rather than a separate model?
- Should informal contextual references such as 'see above' belong here, and what minimum evidence makes their target identifiable?
- Should pointers that deliberately designate collections or several targets share this model with pointers expected to resolve uniquely?
- Where should the boundary fall between a pointer that conveys access authority and the neighbouring credential, capability or action model?