Address of a variable: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Commodore BASIC}}: Formatting) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (11 intermediate revisions by 6 users not shown) | |||
Line 526:
===Get Address===
<syntaxhighlight lang="cobol">
WORKING-STORAGE SECTION.
01 ptr
01 var
PROCEDURE DIVISION.
===Set Address===
Line 538:
<syntaxhighlight lang="cobol">
OCOBOL*> Rosetta Code set address example
*> tectonics: cobc -x setaddr.cob && ./setaddr
DATA DIVISION.
WORKING-STORAGE SECTION.
01 prealloc PIC X(8) VALUE 'somedata'.
SET ADDRESS OF var TO ADDRESS OF prealloc
DISPLAY var END-DISPLAY
*> 'somedata'
GOBACK.
END PROGRAM setaddr.
</syntaxhighlight>
=={{header|Commodore BASIC}}==
{{works with|BASIC|7.0 (C-128)}}
The address of a variable in BASIC is readonly, but accessible via the <
<syntaxhighlight lang="basic">100 REM ALLOCATE ALL VARS FIRST SO THEY DON'T MOVE
110 X=123:Y=456:PX=0:PY=0:I=0:T=0
120 PRINT "BEFORE:X
130 PX=POINTER(X):PY=POINTER(Y)
140 REM VARS ARE STORED IN RAM BANK 1
Line 565 ⟶ 571:
190 : POKE PX+I,T
200 NEXT I
210 PRINT "
{{works with|BASIC|2.0 (VIC-20, C-64)}}
With older machines, there's no built-in mechanism in BASIC to find a variable's address, but you can use the internal state of the BASIC interpreter to achieve similar results. Here's a VIC-20/C-64 version that works the same as the above C-128 program:
<syntaxhighlight lang="basic">100 X=PEEK(71)+256*PEEK(72):PX=X:X=123
110 Y=PEEK(71)+256*PEEK(72):PY=Y:Y=456
120 PRINT "BEFORE:X ="XCHR$(20)", Y ="Y
130 FOR I=0 TO 6
140 : T = PEEK(PY+I)
150 : POKE PY+I,PEEK(PX+I)
160 : POKE PX+I,T
170 NEXT I
180 PRINT "AFTER: X ="XCHR$(20)", Y ="Y</syntaxhighlight>
They same idea should work on other Commodore computers as well, though at least the address being <tt>PEEK</tt>ed will have to change.
{{Out}}
AFTER: X= 456,Y= 123</pre>
=={{header|Common Lisp}}==
Line 1,224 ⟶ 1,245:
2 2
sin(x) + cos(x)</syntaxhighlight>
=={{header|M2000 Interpreter}}==
From version 12, VarPtr() can return address for variables and array items.
We can't set an address to a variable. We can link a variable name with an existing variable. Is the same as passing by reference.
<syntaxhighlight lang="m2000 interpreter">
module checkVarptr {
declare GetMem8 lib "msvbvm60.GetMem8" {Long addr, Long retValue}
long long x=1234567812345678&&, z
dim k(2,2,2) as long long
call GetMem8(VarPtr(x), VarPtr(z))
call GetMem8(VarPtr(x), VarPtr(k(1,0,1)))
print z=x
print k(1,0,1)=x
link z to m
print VarPtr(z)=VarPtr(m)
checkref(&z)
sub checkref(&p)
print VarPtr(z)=VarPtr(p)
end sub
}
checkVarptr
module checkVarptr {
// Using byref at GemMem8 signature
declare GetMem8 lib "msvbvm60.GetMem8" {long &addr, long &retValue}
declare PutMem8 lib "msvbvm60.PutMem8" {long &addr, retValue as long long}
long long x=1234567812345678&&, z
dim k(2,2,2) as long long
call GetMem8(&x, &z)
call GetMem8(&x, &k(1,0,1))
print z=x
print k(1,0,1)=x
checkref(&z)
print z=987654321987654321&&
sub checkref(&p)
print VarPtr(z)=VarPtr(p)
call PutMem8(&p, 987654321987654321&&)
end sub
}
checkVarptr
</syntaxhighlight>
{{out}}
<pre>
True
True
True
True
</pre>
=={{header|Modula-2}}==
Line 1,292 ⟶ 1,362:
=={{header|Oberon-2}}==
===Get Address===
<syntaxhighlight lang="oberon2">
VAR a: LONGINT;
VAR b: INTEGER;
Line 1,298 ⟶ 1,368:
b := 10;
a := SYSTEM.ADR(b); (* Sets variable a to the address of variable b *)
</syntaxhighlight>
===Set Address===
<syntaxhighlight lang="oberon2">
SYSTEM.PUT(a, b); (* Sets the address of b to the address of a *)
</syntaxhighlight>
=={{header|OCaml}}==
Line 1,716 ⟶ 1,786:
In addition some folks have written binary Python modules which implement "peek" and "poke" operations, but these are non-standard.
=={{header|Quackery}}==
Quackery does not have variables, and its memory model is based on dynamic arrays ("nests" in Quackery parlance) rather than a single continuous block of RAM, so, for example, an entry on the return stack has two parts; a pointer to a nest and a numerical offset into the nest (i.e. the location of an item within the nest) If the offset is non-negative, the offset is from the (zero-based) start of the nest, and if the offset is negative it is from the end of the nest, with the last item in the nest being at position -1.
The word <code>peek</code> returns a item located within a nest, given a nest and an offset.
The word <code>poke</code> takes a Quackery object, a nest, and an offset as arguments and returns a new nest, similar to the argument nest, except with the contents of the offset location replaced by the specified object. (Nests are immutable except under specific circumstances.)
Illustrating this as a dialogue in the shell (the Quackery REPL.)
<pre>/O> [ 10 11 12 13 14 ] is mynest ( create a named nest containing numbers )
... ' mynest 2 peek echo ( print the content of item #2 in mynest )
...
12
Stack empty.
/O> 99999 ' mynest 2 poke echo ( replace 12 with 99999 and print result )
...
[ 10 11 99999 13 14 ]
Stack empty.</pre>
<code>quid</code> returns a numerical value associated with an object in Quackery. See the discussion of <code>id()</code> in the [[Address of a variable#Python|Python entry]]. Quackery is implemented in Python, and <code>quid</code> in Quackery is equivalent to <code>id()</code> in Python.
=={{header|QB64}}==
Line 2,225 ⟶ 2,318:
You can, of course, assign a variable of one reference type to another which under the hood copies the pointer so that both variables access the same data store.
<syntaxhighlight lang="
var b = a // now 'a' and 'b' both point to the same List data
b[3] = 5
Line 2,351 ⟶ 2,444:
=={{header|Zig}}==
{{works with|Zig|0.11.0}}
<syntaxhighlight lang="zig">const std = @import("std");
pub fn main() !void {
const stdout = std.io.getStdOut().writer();
Line 2,358 ⟶ 2,452:
var address_of_i: *i32 = &i;
try stdout.print("{x}\n", .{@
}</syntaxhighlight>
| |||