Address of a variable: Difference between revisions

Content added Content deleted

Inline

Revision as of 21:55, 28 March 2013

Demonstrate how to get the address of a variable and how to set the address of a variable.

Ada

Get The Address

<lang ada>The_Address : System.Address; I : Integer; The_Address := I'Address;</lang>

Set The Address

Set the address of a variable to address A100 in hexadecimal <lang ada>I : Integer; for I'Address use 16#A100#;</lang> Set the address of one variable to the address of another variable, creating an overlay. <lang ada>I : Integer; J : Integer; for I'Address use J'Address;</lang>

ALGOL 68

Basically ALGOL 68 refuses to let the programmer access the memory directly. The language does allow "references" any variables. These references are effectively the address a particular variable. But the value of the actual address is not available for printing or any arithmetic. <lang algol68>[4]INT test := (222,444,666,888); REF INT reference := test[3]; REF INT(reference) := reference + 111; print(("test value is now: ",test))</lang> Output:

test value is now:        +222       +444       +777       +888

The other reason specific addresses are using in languages like C to manipulate devices. For this purpose site are expected to implement channels for their programmers to use. To quote the ALGOL 68 Revised Report: A "channel" corresponds to one or more physical devices (e.g., a card reader, a card punch or a line printer, or even to a set up in nuclear physics the results of which are collected by the computer), or to a filestore maintained by the operating system[1].

To establish a channel with such a device there is a special standard procedure:<lang algol68>PROC establish = (REF FILE file, STRING idf, CHANNEL chan, INT p, l, c) INT: ~</lang> Where the idf string is text describing which device to open, and possibly options. And chan is the actual device type. Standard CHANNELs in ALGOL 68 are stand in channel, stand out channel, and stand back channel. These determine the type of the pre opened stdio FILEs stand in, stand out, and stand back. A site would be expected to implement their own CHANNELs for network connections, database queries and particle accelerators etc.

Argile

Get the address

Works with: Argile version 1.0.0

<lang Argile>use std, array (: array.arg also defines pointer operators :) let var = 42 let ptr = &var (: value of ptr is address of var :) print var (: prints 42 :) (*ptr)++ (: increments value pointed by ptr :) print var (: prints 43 :)</lang>

Set the address

Since we cannot set address of a variable, we use a macro that returns a reference.

Works with: Argile version 1.0.0

<lang Argile>use std, array =:mac:= -> int& { * (0x400000 as int*) } printf "%x\n" mac (: may crash depending on operating system :) </lang>

AutoHotkey

Getting or setting the address of a variable is not supported as a builtin function. However, you can get the address of contents pointed to by the variable structure var <lang AutoHotkey>msgbox % &var</lang>

BASIC

Many BASICs, especially older flavors like QuickBASIC, lack the ability to set a variable's address (and indeed, they pretty much all lack the ability to work with pointers in any fashion). <lang qbasic>'get a variable's address: DIM x AS INTEGER, y AS LONG y = VARPTR(x)

'can't set the address, but can access a given memory location... 1 byte at a time DIM z AS INTEGER z = PEEK(y) z = z + (PEEK(y) * 256)</lang>

BBC BASIC

The original BBC BASIC doesn't provide an address-of operator, but BBC BASIC for Windows does: <lang bbcbasic>REM get a variable's address: y% = ^x%

REM can't set a variable's address, but can access a given memory location (4 bytes): x% = !y%</lang>

With BBC BASIC on other platforms the address of a variable can be found by calling a short piece of machine code, see BeebWiki.

C#

Use of pointers in C# is restricted to unsafe sections of code, which is enabled in Microsoft's C# compiler with the commandline parameter /unsafe or in Mono's C# compiler with -unsafe (or --unsafe in older versions).

Get the address

Note that void* is a "pure" address which doesn't carry the type information anymore. If you need the type information (e.g. to recover the variable itself in a type safe manner), use a pointer to the appropriate type instead; in this case int*.

<lang csharp>unsafe {

 int i = 5;
 void* address_of_i = &i;

}</lang>

C / C++

Works with: gcc

/ g++

Get the address

Note that void* is a "pure" address which doesn't carry the type information anymore. If you need the type information (e.g. to recover the variable itself in a type safe manner), use a pointer to the appropriate type instead; in this case int*.

int i;
void* address_of_i = &i;

Set the address

While C++ doesn't directly support putting a variable at a given address, the same effect can be achieved by creating a reference to that address:

int& i = *(int*)0xA100;

Overlaying of variables is done with anonymous unions; however at global/namespace scope such variables have to be static (i.e. local to the current file):

static union
{
  int i;
  int j;
};

C++ only: An alternative (and cleaner) solution is to use references:

int i;
int& j = i;

Note that in this case, the variables can be non-static.

COBOL

Using OpenCOBOL 1.1pre-release, which includes a few features from the draft 20xx standard efforts.

Get Address

use the ADDRESS OF clause. <lang cobol> data division. working-storage section. 01 ptr usage pointer. 01 var pic x(64).

procedure division. set ptr to address of var. </lang>

Set Address

Set address of a variable: using BASED clause. there are other methods, in particular LINKAGE SECTION variables <lang cobol> OCOBOL*> Rosetta Code set address example

     *> tectonics: cobc -x setaddr.cob && ./setaddr 
      program-id. setaddr.
      data division.
      working-storage section.
      01 prealloc  pic x(8) value 'somedata'.
      01 var       pic x(8) based.
      procedure division.
      set address of var to address of prealloc
      display var end-display
      goback.
      end program setaddr.

</lang>

Common Lisp

Simulated Address of Variable

Common Lisp has no means to take a simple address reference to a place (the Lisp term for any one of many types of assignable storage locations). For instance, to access the slot of a structure, we need the structure itself (which is essentially a pointer) and a symbol denoting the slot name. To access an array, we need that array object, and an index. To access a local variable, we need the closure object, which is only accessible to code within the lexical scope, which is a long-winded way of saying, we can only access a variable via an expression which is in the lexical scope of the variable.

Yet, thanks to Lisp macros and lexical closures, we can create reference values which behave like address of places. A tiny module for doing this is found in ~~Lisppaste #71952~~ (now it's available here), required by the following example:

<lang lisp>;;; Demonstration of references by swapping two variables using a function rather than a macro

Needs http://paste.lisp.org/display/71952

(defun swap (ref-left ref-right)

 ;; without with-refs we would have to write this:
 ;; (psetf (deref ref-left) (deref ref-right)
 ;;        (deref ref-right) (deref ref-left))
 (with-refs ((l ref-left) (r ref-right))
   (psetf l r r l)))

(defvar *x* 42) (defvar *y* 0)

(swap (ref *x*) (ref *y*))

*y* -> 42 *x* -> 0</lang>

These references are completely safe to use. There is no way that a place can disappear, leaving a reference dangling, because if a reference is a live object, it prevents the object which contains the referenced place from becoming garbage. Also note that if two references are taken to the same memory location, they are two distinct objects. A function could be provided to test two references for referential equality (do they point to the same object).

Varible-Like Moniker for External Location

Works with: CLISP

Works with: Linux

Works with: Cygwin

What does it mean to "set the address of a variable?" One interpretation of this task is: rather than let the programming language compiler or run-time allocate a named storage location in its usual ways, force the allocation of a variable at some particular memory location, such as a hardware register, or a variable in a foreign library. Lisp implementations have foreign function interfaces for doing this sort of thing.

Here is an example specific to CLISP running on either Linux or Cygwin. It creates a Lisp errno variable which is located in the C Library's errno. The C Library's errno is actually thread-specific, whose location is retrieved by calling a hidden function.

We wrap this function with a Lisp foreign call which is properly annotated as returning a C pointer to int. When we call this function, we get an object that behaves like a reference to that location. All we need then is a macro which looks like a storage location.

<lang lisp>(use-package :ffi)

(defmacro def-libc-call-out (name &rest args)

 `(def-call-out ,name
    (:language :stdc)
    #-cygwin(:library "libc.so.6")
    #+cygwin (:library "cygwin1.dll")
    ,@args))

(progn

 (def-libc-call-out errno-location
   #-cygwin (:name "__errno_location")
   #+cygwin (:name "__errno")
   (:arguments)
   (:return-type (c-pointer int)))

 (defun get-errno ()
   (let ((loc (errno-location)))
     (foreign-value loc)))

 (defun set-errno (value)
   (let ((loc (errno-location)))
     (setf (foreign-value loc) value)))

 (defsetf get-errno set-errno)

 (define-symbol-macro errno (get-errno)))</lang>

Test:

[1]> (setf errno 42)
42
[2]> errno
0   ;; Oops! the REPL itself executed a bunch of code which cleared errno
[3]> (progn (delete-file "nonexistent") errno)
2   ;; Aha! 2 is ENOENT: No such file or directory

Creative Basic

<lang Creative Basic> To get the address of a variable without using the Windows API:

DEF X:INT DEF pPointer:POINTER pPointer=X 'To print in the console after opening it with the OPENCONSOLE command. PRINT pPointer 'To print in an open window add the appropriate Window variable '("Win" here) followed by a comma. PRINT Win,pPOINTER

To get the address of a variable using the Windows API Lstrcpy function called in Creative Basic: (This may give users of another language without a native way to get the address of a variable to work around that problem.)

DEF Win:WINDOW DEF Close:CHAR DEF ScreenSizeX,ScreenSizeY,Col:INT

'***Map Function*** DECLARE "Kernel32",Lstrcpy(P1:POINTER,P2:POINTER),INT 'The pointers replace the VB3 variable type of Any.

'Note: This is translated from VB3 or earlier code, and "Ptr" is *not* a Creative Basic pointer. DEF Ptr:INT DEF X1:INT DEF X2:STRING

X1=123

'***Call function*** Ptr=Lstrcpy(X1,X1)

GETSCREENSIZE(ScreenSizeX,ScreenSizeY)

WINDOW Win,0,0,ScreenSizeX,ScreenSizeY,@MINBOX|@MAXBOX|@SIZE|@MAXIMIZED,0,"Skel Win",MainHandler

'***Display address*** PRINT Win, "The address of x1 is: " + Hex$(Ptr)

     X2="X2"

WAITUNTIL Close=1

CLOSEWINDOW Win

END

SUB MainHandler

SELECT @CLASS

CASE @IDCLOSEWINDOW

Close=1

ENDSELECT

RETURN

The address can also be printed in console window by issuing the OPENCONSOLE command followed by the PRINT command.

Note: The Windows Dev Center (http://msdn.microsoft.com/en-us/library/windows/desktop/ms647490%28v=vs.85%29.aspx) says improper use of the Lstrcpy function may compromise security. You are advised to see the Windows Dev site before using the Lstrcopy function.

There does not appear to be a way to set the address of a variable in Creative Basic. </lang>

D

Take the address of a variable: <lang d>int i; int* ip = &i;</lang>

Using a numeric value: <lang d>int* ip = cast(int*)0xdeadf00d;</lang>

Locating a "regular" variable at a specific address is not possible.

The closest thing is passing a dereferenced pointer to a reference parameter.

<lang d>void test(ref int i) {

   writefln(&i);

}

void main() {

   test(* (cast(int*)0xdeadf00d) );

}</lang>

Delphi

Turbo/Borland Pascal and Delphi (Object Pascal) support the @ ( address of ) operator and the var : [type] absolute declaration.

To get the address of any variable, structure, procedure or function use the @ operator.

 var
   Int : integer ;
   p   : ^integer ;
 begin
   P := @int ;
   writeln(p^);
 end;

A variable can be declared as absolute ie: to reside at a specific address.

 Var
   CrtMode : integer absolute $0040 ;
   Str     : string[100] ;
   StrLen  : byte absolute Str ;

Forth

Variables and created memory blocks return their address when referenced. The "fetch" operator @ could also be pronounced "dereference".

variable foo
foo .  \ some large number, an address
8 foo !
foo @ .  \ 8

You can define a constant or value with an address, which then acts like a variable. This can be used to refer to fixed addresses (such as I/O ports), graphics buffers, or allocated memory.

$3F8 constant LPT1:
8 LPT1: !

100 cells allocate throw value buffer
42 buffer 20 cells + !

Fortran

Works with: Fortran version 90 and later

<lang fortran>program test_loc

 implicit none
 integer :: i
 real :: r

 i = loc (r)
 write (*, '(i0)') i

end program test_loc</lang> Note: loc is a common extension that is implemented by e.g. the Intel Fortran Compiler, G95 and gfortran.

Go

Go has pointers. Just like in C, you can "take the address" of an addressable value by using the & operator, and access the value pointed to by a pointer using the * operator.

Unlike in C, pointers are not readily convertible to integers. You may print out the address of a pointer, either using the Print function on the pointer, or using the %p format specifier in formatted output (just like in C). If you really want, you may convert a pointer to an integer using the unsafe package

The following demonstrates getting the address of a variable. It is not possible in Go to set the address of a variable. <lang go>package main

import (

   "fmt"
   "unsafe"

)

func main() {

   myVar := 3.14
   myPointer := &myVar
   fmt.Println(myPointer)
   fmt.Printf("%p\n", myPointer)

   addr := int64(uintptr(unsafe.Pointer(myPointer)))
   fmt.Printf("0x%x\n", addr)

}</lang> Example output:

0xf840026018
0xf840026018
0xf840026018

IWBASIC

There are three ways to get the address of a variable in IWBASIC. The first is to use the address of operator:

DEF X:INT PRINT &X: REM This will print in the console window (after OPENCONSOLE is issued.) 'To Print in an open window the appropriate Window variable is specified: PRINT Win,&X.

The second is to use a pointer:

DEF X:INT DEF pPointer:POINTER PRINT pPointer or PRINT Win,pPointer

The third is to use the Windows API function Lstrcpy. That is done in the same way as the Creative Basic example; however, the function would be declared as follows: DECLARE IMPORT,Lstrcpy(P1:POINTER,P2:POINTER),INT. </lang>

J

J hides the details of pointers and memory allocation from the programmer, so it is rarely, if ever, necessary to do this. However, for those times when there is no better substitute, J provides access to these low-level details:

<lang> var =: 52 NB. Any variable (including data, functions, operators etc)

  var_addr =: 15!:6<'var'       NB.  Get address
  new_var  =: 15!:7 var_addr    NB.  Set address</lang>

Java

There is no way to access addresses in Java. However, the default hashCode() method defined in the Object class, "is typically implemented by converting the internal address of the object into an integer". Therefore, in some Java implementations at least, the hash code returned by Object.hashCode() reflects at least part of the address of an object. For objects whose classes have overridden the hashCode() method, you can still access the original hash code through the System.identityHashCode() function.

Modula-2

Get Address

<lang modula2>MODULE GetAddress;

FROM SYSTEM IMPORT ADR; FROM InOut IMPORT WriteInt, WriteLn;

VAR var : INTEGER;

       adr : LONGINT;

BEGIN

   adr := ADR(var);    (*get the address*)
   WriteInt(adr, 0);
   WriteLn;

END GetAddress.</lang>

Set Address

<lang modula2>MODULE SetAddress;

CONST adress = 134664460;

VAR var [adress] : INTEGER;

BEGIN

   (*do nothing*)

END SetAddress.</lang>

NewLISP

Get Address

<lang NewLISP> (set 'a '(1 2 3)) (address a) </lang>

Oberon-2

Get Address

VAR a: LONGINT;
VAR b: INTEGER;

b := 10;
a := SYSTEM.ADR(b); (* Sets variable a to the address of variable b *)

Set Address

SYSTEM.PUT(a, b); (* Sets the address of b to the address of a *)

OCaml

OCaml is a high-level programming language, and thus does not expose the addresses of variables to the programmer.

ooRexx

ooRexx is a high-level programming language, and thus does not expose the addresses of variables to the programmer. Variables can be accessed by name using the VAR(), SYMBOL(), and VALUE() built-in functions.

OxygenBasic


'GETTING ADDRESS OF VARIABLE

int a=1,b=2,c=3
print "Adrress of b: " @b


'SETTING ADDRESS OF INDIRECT (BYREF) VARIABLE

int *aa,*bb,*cc

@bb=@b 'setting address of bb to address of b

print "Value of bb: " bb 'result: 2

PARI/GP

In GP you can sent the address to built-in commands like issquare <lang parigp>issquare(n, &m)</lang> but you cannot directly compute with it. You can view the address of a variable and other debugging information with the

\x

command.

In PARI you can use standard C commands.

Pascal

See Delphi

Perl

To get the address, get the reference to a variable, and either stringify it, or use Scalar::Util's refaddr() to get just the address. Also see Devel::Peek. <lang perl>use Scalar::Util qw(refaddr); print refaddr(\my $v), "\n"; # 135691508</lang> Use Devel::Pointer::PP if you want to dereference a certain address in memory.

Changing the address of a variable is not easily possible, but see perlapi. Wanting to go against the automatic memory management is a sign that this is only used to hack around the deficiencies of dafter languages. I can imagine address munging is commonly used to make variable aliasing possible, but Perl already has a higher level syntax for that.

Simple reference (address) manipulation. <lang perl>my $a = 12; my $b = \$a; # get reference $$b = $$b + 30; # access referenced value print $a; # prints 42</lang>

Example how to make variable overlay. <lang perl>my $a = 12; our $b; # you can overlay only global variables (this line is only for strictness)

b = \$a;

print $b; # prints 12 $b++; print $a; # prints 13</lang>

Perl 6

<lang perl6>my $x; say $x.WHERE;</lang>

Output:

7857931379550584425

How you set the address of a variable (or any other object) is outside the purview of the Perl 6 language, but Perl 6 supports pluggable object representations, and any given representation scheme could conceivably allow an existing address to be treated as an object candidate where that makes sense. Memory-mapped structs are not unreasonable and are likely to be supported on VMs that allow it.

PicoLisp

The PicoLisp function 'adr' returns the address of a variable. A variable may be either a symbol or a cons pair in PicoLisp.

The returned address is a number representing an encoded pointer. For symbols, it is a negative number, and for cons pairs a positive number. The same function 'adr' can then be used to convert that pointer back to the original object. <lang PicoLisp>: (setq X 7) -> 7

(adr 'X)

-> -2985527269106

(val (adr -2985527269106))

-> 7

(set (adr -2985527269106) '(a b c))

-> (a b c)

X

-> (a b c)</lang>

PL/I

<lang PL/I> declare p pointer; k = addr(b); /* Obtain address of variable, stored in integer variable k */ p = addr(q); /* assigns address to pointer variable p. */ </lang>

PowerBASIC

<lang powerbasic>'get a variable's address: DIM x AS INTEGER, y AS LONG y = VARPTR(x)

'can't set the address of a single variable, but can access memory locations DIM z AS INTEGER z = PEEK(INTEGER, y)

'or can do it one byte at a time DIM zz(1) AS BYTE zz(0) = PEEK(BYTE, y) zz(1) = PEEK(BYTE, y + 1) '(MAK creates an INTEGER, LONG, or QUAD out of the next smaller type) z = MAK(INTEGER, zz(0), zz(1))

'*can* set the address of an array DIM zzz(1) AS BYTE AT y 'zzz(0) = low byte of x, zzz(1) = high byte of x</lang>

PureBasic

Get the address of a variable using the '@' operator. <lang PureBasic>a.i = 5 MessageRequester("Address",Str(@a))</lang>

Set the address of a structured pointer. The pointer can be dereferenced to interact with it's data. Ensure that there is access to the memory address that is assigned to the pointer (i.e. part of allocated memory). <lang PureBasic>a.i = 5

b.Integer = @a ;set *b equal to the address of variable a
c.Integer = $A100 ;set *c to point at memory location $A100 (in hex)

MessageRequester("Address",Str(*b)) ;display the address being pointed at by *b MessageRequester("Value",Str(*b\i)) ;de-reference the pointer *b to display the data being pointed at</lang>

Python

Python traditionally doesn't support low-level operations on memory addresses, except in the limited sense that one can use the mmap module where it's available, and manipulate offsets into memory map objects...including serializing other objects into and out of the memory mapping. New versions of Python support a ctypes module which permits some low level address operations on C-type objects (see C-types Reference for details).

The Python id() function returns a unique ID for any object. This just happens to be implemented as the base address of the object in C Python[2]; but that is not guaranteed by the semantics of the language and should not be considered a standard, nor used as such. But for comparison purposes the ID can be used as an address, since different extant objects will have different IDs.

<lang python>foo = object() # Create (instantiate) an empty object address = id(foo)</lang>

In addition some folks have written binary Python modules which implement "peek" and "poke" operations, but these are non-standard.

Retro

Retro is only able to directly access memory as 32-bit values within a linear address space.

Get The Address

<lang Retro>variable a &a</lang>

Set The Address

Create variable b and point it to address 100 <lang Retro>variable b 100 @last !d->xt</lang>

Byte Addressing

Retro includes a standard library allowing for creation and access of byte-level data. This is done by creating a pool, which the library functions can then access individual bytes from. The pool has a physical address, which can be set or read, and virtual addresses (starting with zero, and increasing linearly) which are used by the library functions.

To read the address of the currently active pool:

<lang Retro>needs bad' ^bad'pool @</lang>

Or to set the pool to a specific physical location such as address 100:

REXX

REXX has no way of getting the address of varables within the langage itself, but since each
REXX variable can be accessed by name and its name passed to (say) subroutines [PROCEDUREs],
with the use of the VALUE and SYMBOL built-in functions (BIFs), it's possible to determine
the state of any variable (defined or not, its value, length).

Ruby

The Ruby object_id method returns an object ID that is unique among active objects. It turns out that for the official Ruby implementation, the object ID is based on the address. For non-immediate objects (i.e. anything other than a Fixnum, Symbol, true, false, or nil), the address can be obtained by shifting the object ID one to the left. For more information, see the source code for the object_id method:[3].

For classes that do not override the to_s method, the to_s method also shows the address.

<lang ruby>>foo = Object.new # => #<Object:0x10ae32000> >id = foo.object_id # => 2238812160 >"%x" % (id << 1) # => "10ae32000" </lang>

Smalltalk

This task does not really make sense in Smalltalk: for one, all we could ask for is the address of an object, not a variable, which is a binding of a name to a value in a lexical scoping (similar to Scheme). Second, the underlying memory management (garbage collector) is usually free to move objects around, and most implementations do so when objects are tenured or memory areas are defragmented (also similar). So its usefulness is limited to VM developers and debuggers ;-)

you asked for it, and here it is:

Works with: Smalltalk/X

<lang smalltalk>|p| p := Point x:10 y:20. ObjectMemory addressOf:p. ObjectMemory collectGarbage. ObjectMemory addressOf:p</lang> to deal with non-Smalltalk objects, all Smalltalks provide libraries to pass-in and out parameters to foreign function calls (FFI). For those, we can allocate a block of memory and fidle around with its "address":

Works with: Smalltalk/X

<lang smalltalk>|ptr| ptr := ExternalBytes new:10. ptr address. ptr byteAt:1 put: 16rFF.</lang>

Tcl

It is highly unusual to want to directly manipulate the address of a variable in Tcl, as it is a thoroughly unsafe operation. Indeed, Tcl does not expose any mechanism to do so at the script level. However, Tcl does contain a C-level API function, Tcl_LinkVar, to arrange for a variable's value to always reflect the contents of a particular address in memory. (See Machine Address for an example of how to do that.)

However, that's not the only way of doing it. You can also use the critcl library to put C code directly inside a Tcl script and so work with addresses directly that way.

Library: critcl

<lang tcl>package require critcl

This code assumes an ILP32 architecture, like classic x86 or VAX.

critcl::cproc peek {int addr} int {

   union {
      int i;
      int *a;
   } u;

   u.i = addr;
   return *u.a;

} critcl::cproc poke {int addr int value} void {

   union {
       int i;
       int *a;
   } u;

   u.i = addr;
   *u.a = value;

} package provide poker 1.0</lang> Demonstrating: <lang tcl>package require poker

Increment a memory location; this will probably crash if you try for real.
We don't define how to get a good address, but it's not usually a problem
for embedded programming...

set where 0x12340 poke $where [expr {[peek $where] + 1}]</lang> Have great care with this sort of code; the damage you can do by writing to random locations is considerable and being able to read from anywhere could allow information to flow to otherwise unauthorized programs.

Toka

Get the Address

The default behaviour of a data element in Toka is to return its address. This makes obtaining the address trivial:

variable foo
foo .

Set the Address

You can manually assign a name to any memory address (or other number), but you should make sure it's part of allocated memory first.

 hex abcdef is-data foo
 foo .

Visual Basic .NET

Visual Basic uses managed memory that can be moved around at any time. If a memory address for a variable is needed, the address is created first and then its contents copied.

Get the Address

Allocates a stable address in unmanaged memory, copies a variable to it, then returns the address itself.

 Dim x = 5
 Dim ptrX As IntPtr
 ptrX = Marshal.AllocHGlobal(Marshal.SizeOf(GetType(Integer)))
 Marshal.StructureToPtr(5, ptrX, False)
 Dim addressX = ptrX.ToInt64

Set the Address

Sets the pointer to the address A100 in hex.

 Dim ptrX As New IntPtr(&HA100)

XPL0

It is easy to get the address of a variable (relative to the beginning of its data segment), but there is no way to set the address of a variable. However, pointers can be used to access specific addresses. The example shows how the pointer B(0) is used to access the variable A and set it to hex 1234ABCD. The Peek and Poke intrinsics can be used to access specific hardware addresses. The absolute hardware address of a program's data segment can be obtained using the GetReg intrinsic. The '@' operator works exactly like 'addr' for integers but returns a 'real' pointer, instead of a 32-bit relative address, when used on a 'real' variable.

<lang XPL0>include c:\cxpl\codes; int A, B; [B:= addr A; HexOut(0, B); CrLf(0); B(0):= $1234ABCD; HexOut(0, A); CrLf(0); ]</lang>

Output:

00000F48
1234ABCD

Yorick

Yorick has pointers, but they are typically used in an opaque fashion. Pointer arithmetic is not supported, not is referencing arbitrary memory locations. However, a pointer address may be copied to other variables. Here is an interactive example that illustrates some of this.

> foo = 1
> bar = &foo
> bar
0x15f42c18
> baz = bar
> *baz = 5
> *bar
5
> *baz
5