Special variables: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
No edit summary |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
| (32 intermediate revisions by 17 users not shown) | |||
Line 1:
{{task|Basic language learning}}[[Category:Special variables]]
Special variables have a predefined meaning within a computer programming language.
Line 7:
List the special variables used within the language.
<br><br>
=={{header|11l}}==
Refer to [https://11l-lang.org/doc/built-in-global-vars Built-in global variables] for the complete special variables (those variables are global).
=={{header|6502 Assembly}}==
The first 256 bytes of the CPU's address space are collectively known as "zero page RAM" and are common to all 6502 computers (except the custom 6502-based Hu6280 used in the PC Engine/TurboGrafx16.) This section of RAM is faster to load from, as the instructions that use it only take one byte to represent the memory address rather than two. On some implementations, certain zero-page RAM addresses are special, such as address $00 on Commodore 64 (which controls the memory management unit) and address $FF on Easy6502 (which contains the last keyboard input). In addition to loading faster, only the zero page can used indexed indirect addressing modes (the only exception being <code>JMP</code>, which CANNOT jump indirectly using zero page unless you pad it with a high byte of 00.)
The 16-bit 65816 and the Motorola 6809 (which are very similar to the 6502) call the zero page the "direct page" because it can be relocated on those systems. They have a dedicated register which tells the CPU where the direct page actually is. Like on the 6502, it's only 256 bytes in size. This allows the programmer to improve their program's performance by moving the direct page to wherever the majority of the loading will be taking place. Your code may cause problems if you load from the "wrong" direct page, however, so be careful!
=={{header|Ada}}==
Line 18 ⟶ 25:
There are far too many attributes to list here, but a standard informative list can be found in Annex K of the documentation if you have it installed.
Or Here: [http://www2.adacore.com/gap-static/GNAT_Book/html/aarm/AA-K.html Annex K - Language-Defined Attributes]
=={{header|ALGOL 68}}==
Line 27 ⟶ 31:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}
<
FORMAT f = $g": ["g"]"l$;
Line 82 ⟶ 86:
END CO
));
SKIP</
Sample output:
<pre>
Line 115 ⟶ 119:
]
</pre>
===[[ALGOL 68G]]===
{{wont work with|ALGOL 68|Revision 1 - too many extensions to language used, but constants can be defined in a custom prelude.}}
Line 120 ⟶ 125:
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}
[[ALGOL 68G]] provides some further constants to the scientifically motivated coder:
<
printf(($g": [", g, "] & [",g,"]"l$,
Line 234 ⟶ 239:
" joule", mksa joule, cgs joule,
" erg", mksa erg, cgs erg
))</
Output:
<pre>
Line 351 ⟶ 356:
=={{header|ALGOL W}}==
<
integer I_W % field width for integer output %
Line 395 ⟶ 400:
if the relevant EXCEPTION variable is null, the exception is ignored,
otherwise it is processed according to the settings of XCPLIMIT etc.
%</
=={{header|Arturo}}==
There are no "special" variables in Arturo, as such. There are pre-defined, built-in functions & constants but every symbol can be re-defined at will, even during runtime.
=={{header|AutoHotkey}}==
Refer to [http://www.autohotkey.com/docs/Variables.htm#BuiltIn Built-in Variables] for the complete special variables (those variables are global, except noticed).
=={{header|AWK}}==
Line 418 ⟶ 430:
* RSTART - An informative variable that provides the start index of the currently matched substring
* SUBSEP - A control variable that specifies the subscript separator for multidimensional arrays
=={{header|Batch File}}==
By typing the <code>SET</code> command (without any parameters) in the command prompt, it will display the current environment variables and their current values.<br>
However, there are some special variables that are not listed in the variables displayed by the SET command because their values might change over time. These variables are as follows:<br>
<pre>%CD% - expands to the current directory string.
%DATE% - expands to current date using same format as DATE command.
%TIME% - expands to current time using same format as TIME command.
%RANDOM% - expands to a random decimal number between 0 and 32767.
%ERRORLEVEL% - expands to the current ERRORLEVEL value
%CMDEXTVERSION% - expands to the current Command Processor Extensions
version number.
%CMDCMDLINE% - expands to the original command line that invoked the
Command Processor.
%HIGHESTNUMANODENUMBER% - expands to the highest NUMA node number
on this machine.</pre>
(Source: by typing <code>SET/?</code> command in the command prompt)
=={{header|BBC BASIC}}==
Line 451 ⟶ 486:
@wparam% The WPARAM value (for use with ON MOUSE, ON MOVE and ON SYS)
</pre>
=={{header|bc}}==
Line 489 ⟶ 501:
The names of the built-in functions <code>alc, arg, asc, chr, chu, clk, d2x, dbg, den, div, fil, flg, glf, fre, get, low, lst, mem, mod, new, pee, pok, put, ren, rev, rmv, sim, str, swi, sys, tbl, upp, utf, whl, x2d</code> can be used as variable names or names of user defined object member functions, but not as names of user defined functions. Conversely, the name <code>hash</code> can be used for user defined functions, but not for variables. Currentlty, <code>hash</code> is the only predefined object type.
If Bracmat starts in interactive mode, a few more variables are predefined: <code>!v</code> evaluates to a string telling which version of Bracmat you are running. <code>!w</code> and <code>!c</code> evaluate to sections 11 and 12 of the GPL. More vital is the variable <code>main</code>, which is the interpreter's main loop. Setting it to another value changes the behaviour of the interpreter. When running in interactive mode, <code>!</code> or <code>!""</code> evaluates to the last answer, so the empty string is the name of yet another special variable. These variables can be reassigned.
=={{header|C}}==
Line 495 ⟶ 507:
Furthermore one could consider <code>errno</code> from <code><errno.h></code> as a special variable although it actually is a macro which expands to an modifiable lvalue of type <code>int</code>. Many library functions set it to a positive value in case of an error.
=={{header|C++}}==
Besides <code>errno</code> like C, C++ has the <code>this</code> pointer so objects can refer to themselves.
<syntaxhighlight lang="cpp">#include <iostream>
struct SpecialVariables
{
int i = 0;
SpecialVariables& operator++()
{
// 'this' is a special variable that is a pointer to the current
// class instance. It can optionally be used to refer to elements
// of the class.
this->i++; // has the same meaning as 'i++'
// returning *this lets the object return a reference to itself
return *this;
}
};
int main()
{
SpecialVariables sv;
auto sv2 = ++sv; // makes a copy of sv after it was incremented
std::cout << " sv :" << sv.i << "\n sv2:" << sv2.i << "\n";
}</syntaxhighlight>
{{out}}
<pre>
sv :1
sv2:1
</pre>
=={{header|Clojure}}==
The following snippet prints a list of the special variables defined in clojure.core, in *earmuff* form. For further information, consult the [http://clojuredocs.org/quickref/shortdesc/Clojure%20Core documentation].
<
(apply str (interpose " " (sort (filter #(.startsWith % "*") (map str (keys (ns-publics 'clojure.core)))))))
</syntaxhighlight>
{{Out}}
<pre>*1 *2 *3 *agent* *allow-unresolved-vars* *assert* *clojure-version* *command-line-args* *compile-files* *compile-path*
Line 512 ⟶ 559:
The following code snippet prints a list of all 44 special variables defined by the Common Lisp standard. For further information about each of them consult the [http://www.lispworks.com/documentation/HyperSpec/Front/X_Alph_9.htm online documentation].
<
(flet ((special-var-p (s)
(and (char= (aref s 0) #\*)
Line 523 ⟶ 570:
lst)))
(format t "~a~%" (sort (special-variables) #'string<))</
{{Out}}
Line 580 ⟶ 627:
One special boolean variable is __ctfe, that is read-only and it's true inside functions when they are evaluated at compile-time, and false otherwise.
=={{header|DWScript}}==
Line 599 ⟶ 637:
Dyalect has a special <code>this</code> which is available inside methods:
<
this + this
}
print(8.
=={{header|Déjà Vu}}==
Calls to some of the standard library functions can be optimized into certain opcodes or sequences of opcodes, namely:
<pre>set setglobal local get getlocal return recurse drop dup swap rot over
[] {} pop-from push-to push-through has get-from set-to raise reraise
call for pass</pre>
In addition, <code>eva</code> is special:
<syntaxhighlight lang="dejavu">!print "hey" #is really short for
eva!print "hey"</syntaxhighlight>
EVA is the part of the standard library that takes care of communication with the outside world. It makes extensive use of the method call syntax, unlike the rest of the standard library, that is why it is special.
=={{header|Erlang}}==
Erlang has no special variables.
What it does have are special functions, module_info/0 and module_info/1. These are added to a module automatically, without being present in the code.
<syntaxhighlight lang="erlang">
-module( special_variables ).
Line 613 ⟶ 661:
task() -> ok.
</syntaxhighlight>
{{out}}
<pre>
Line 664 ⟶ 712:
Fortran offers no special variables such as Pi, e, etc. as a part of the language, not even the modern special floating-point "values" such as NaN. Indeed, the syntax has no reserved words generally so that <code>GO TO</code> could be the name of a variable without damage to GO TO statements, though it is generally agreed that calling a variable END is provocative... It does have some ''numbers'' that are special: 5 is the input/output "unit number" for keyboard input and 6 for output to "standard output", the screen on desktop computers; in the past there have been other values that were associated to devices such as the card reader, card punch, lineprinter, paper tape reader, and so on at any given installation. But these constants are not given names as mnemonics for their special values, except by the programmer. There is no equivalent of SYSOUT as in WRITE(SYSOUT,''etc'' without definition by the programmer.
Certain statements involve special names in what appear to be assignments of values to or from a special name that has a value just like a named variable does, but these are ''not'' proper variables at all. For instance, in <
1 ERR = 666,IOSTAT = IOSTAT) !Hopefully, named in good style, etc.
IF (EXIST) THEN !So, does the named file already exist?
...etc.</
ERR is a special name, but only inside the context of the INQUIRE (and OPEN, and WRITE, ''etc.'') statement, it is not the name of an existing variable outside that statement whether defined by the language or by the programmer, and if the programmer were to define a variable called ERR it would have no relevance within that INQUIRE statement - though <code>ERR = ERR</code> ''would'' be workable if an ASSIGN statement had assigned statement label 666 to variable ERR. Similarly, the variable named FILENAME is declared by the programmer and because there are no reserved words, could be just FILE. Likewise, EXIST is declared (as LOGICAL) and IOSTAT (as INTEGER) as a mnemonic aid and also to save on the trouble of remembering whether the assignment works left-to-right or right-to-left in each case. It is right-to-left for FILE = ''filename'', input to the INQUIRE statement and left-to-right for EXIST = ''variable'', an output of the INQUIRE statement.
=={{header|FreeBASIC}}==
FreeBASIC has no 'special variables'.
=={{header|Go}}==
Line 683 ⟶ 734:
=={{header|Icon}} and {{header|Unicon}}==
Icon and Unicon have special variables known as keywords which are syntactically are preceded by an &.
<syntaxhighlight lang="unicon">
# &keyword # type returned(indicators) - brief description
# indicators:
Line 760 ⟶ 811:
&y # integer(=G) - pointer vertical position
# keywords may also fail if the corresponding feature is not present.
# Other variants of Icon (e.g. MT-Icon) will have different mixes of keywords.</
=={{header|IS-BASIC}}==
<
BLUE - The code of colour blue.
CYAN - The code of colour cyan.
DATE$ - The current date in the standard format.
EXLINE - The number of the last statement that caused an exception.
EXTYPE - The error code of the last
FREE - The amount of memory free and avaible to the current program.
GREEN - The code of colour green.
INF - The largest positive number that the IS-BASIC can
MAGENTA - The code of colour magenta.
PI - Value of the Pi. This is rounded to 3.141592654
Line 777 ⟶ 828:
TIME$ - The current time in the standard format.
WHITE - The code of colour white.
YELLOW - The code of colour yellow.
VERNUM - Version number of the BASIC</syntaxhighlight>
=={{header|J}}==
Line 793 ⟶ 845:
Note that the result of an adverb or conjunction that uses either x or y and one of these other names is always a verb. In this case, x and/or y represent arguments passed to the derived verb.
Some examples:
<syntaxhighlight lang="j"> {{ y }} 1
1
1000 {{ x + y }} 1
1001
100 {{ m + y }} 1
101
(1000) 100 {{ x + m + y }} 1
1101
100 {{ m + n + y }} 10 (1)
111
(1000) 100 {{ x + m + n + y }} 10 (1)
1111
(1000) + {{ x u n u y }} 10 (1)
1011
(1000) 100 {{ x v m v y }} + (1)
1101</syntaxhighlight>
These names may be used as regular names, but that is bad practice except in the context of debugging or illustration.
Line 946 ⟶ 1,016:
tolist topara ucpboxdraw
unboxfkeys unboxskeys winmax </pre>
=={{header|Java}}==
Java is heavily object-oriented, and is mostly statically-typed. There aren't many special variables, or aggregates, similar to dynamically-typed languages.<br />
There is ''null'', which is used to represent an object which has no reference assigned.
<syntaxhighlight lang="java">
Object object = null
</syntaxhighlight>
There is ''true'' and ''false'' which are used to denote a ''Boolean'' value.
<syntaxhighlight lang="java">
boolean value = true
</syntaxhighlight>
There is the ''this'' and ''super'' variables, used to reference the current class and parent class, respectively.
<syntaxhighlight lang="java">
this.object
</syntaxhighlight>
<syntaxhighlight lang="java">
super(value)
</syntaxhighlight>
To avoid confusion to anyone unfamiliar with Java, there is the ability to import static, final, variables from other classes.<br />
While these are not 'special variables' they may appear that way to a new user.
<syntaxhighlight lang="java">
import static java.lang.Math.*;
</syntaxhighlight>
<syntaxhighlight lang="java">
double area = PI * (2 * 2);
</syntaxhighlight>
There is the first parameter of the ''main'' method, which is of type ''String[]''.<br />
It is non-null and includes any arguments depicted during execution.
<syntaxhighlight lang="java">
public static void main(String[] args)
</syntaxhighlight>
<br />
Additionally ...<br />
Java has only a few special variables. There is a <code>String</code>-Array for passing command-line-arguments to the program, and there is a <code>Class</code>-Object that can be accessed in a variable-like manner. It is used for reflection, (like examining and modifing class members, their type and modifiers during runtime).
There is the <code>System</code>-"Object" that contains various (mostly static) data about the enviroment the Java VM runs on, and it's cousin <code>Runtime</code> that provides data that is more prone to change during runtime, like available CPU cores and RAM.
Line 955 ⟶ 1,059:
Inside an object there is <code>this</code>, a reference that points to the object itself (like 127.0.0.1 in networking) and are used to qualify member access. There is also <code>super</code> that does the same for the base class (actually "the next class in the inheritance tree"). Both are not demonstrated in the example below.
<
public class SpecialVariables {
Line 986 ⟶ 1,090:
}
</syntaxhighlight>
=={{header|JavaScript}}==
Line 992 ⟶ 1,096:
<code>this</code> evaluates to the object the immediately enclosing function was called on as a method, if it was. If it was not called as a method, <code>this</code> is either the global environment object (usually <code>window</code> in browsers) in non-strict mode, or <code>undefined</code> in strict mode. <code>this</code> is an expression resembling a variable, but not actually a variable; for example, it is a syntax error to assign to it.
<
foo: 1,
bar: function () { return this.foo; }
};
obj.bar(); // returns 1</
When a function is entered, the ''variable'' <code>arguments</code> is bound to an “arguments object” which is an array-like object containing the function's arguments, as well as some other information. This how [[varargs]] functions are implemented in JavaScript. If the function's parameters contain “<code>arguments</code>” explicitly, then it is ''not'' overridden and functions as an ordinary parameter.
<
var s = "";
for (var i = 0; i < arguments.length; i++) {
Line 1,007 ⟶ 1,111:
return s;
}
concat("a", "b", "c"); // returns "abc"</
=={{header|jq}}==
Variables in jq are identifiers preceded by the sigil "$", e.g. <code>$x</code>. There are no predefined variables, but jq does allow variables to be assigned string values on the command line.
For example:<
"string"</
(*) Windows users would write "$x|type".
=={{header|Julia}}==
Julia starts with the <code>Base</code> module loaded. Taking "special variables" to mean names in the default global namespace (<code>Base</code>) that aren't functions, types, or modules, then you can obtain them with
<
{{out}}
<pre>":, ARGS, CPU_CORES, C_NULL, DL_LOAD_PATH, DevNull, ENDIAN_BOM, ENV, I, Inf, Inf16, Inf32, InsertionSort, JULIA_HOME, LOAD_PATH, MS_ASYNC, MS_INVALIDATE, MS_SYNC, MergeSort, NaN, NaN16, NaN32, OS_NAME, QuickSort, RTLD_DEEPBIND, RTLD_FIRST, RTLD_GLOBAL, RTLD_LAZY, RTLD_LOCAL, RTLD_NODELETE, RTLD_NOLOAD, RTLD_NOW, RoundDown, RoundFromZero, RoundNearest, RoundToZero, RoundUp, STDERR, STDIN, STDOUT, VERSION, WORD_SIZE, catalan, cglobal, e, eu, eulergamma, golden, im, pi, γ, π, φ"</pre>
Line 1,032 ⟶ 1,136:
The following program illustrates their usage:
<
class President(val name: String) {
Line 1,055 ⟶ 1,159:
val pres3 = President("Theodore")
pres3.age = 158
}</
{{out}}
Line 1,071 ⟶ 1,175:
In Lasso parameters can be referenced as numerical locals within methods or unbound captures. [http://lassoguide.com/language/variables.html?#parameter-pseudo-locals]
<
<
test('y','z') // y:z</
=={{header|Lingo}}==
Line 1,104 ⟶ 1,208:
Further to those, LiveCode comes with a plethora of built-in constants, which are readily listed with the following command:
<
=={{header|Lua}}==
Line 1,115 ⟶ 1,218:
To list all global variables:
<
The list will include built-in global functions, whose availability depends on the implementation and compile time configuration.
=={{header|M2000 Interpreter}}==
There some read only variables. We can use Help dir$ to get help about dir$.
Line 1,123 ⟶ 1,227:
All identifiers can be change to be used as variables, using a dot. For modules/functions in a group we have to define these variables using a dot.
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
Let inkey$="hello", dir$="Something Else"
Line 1,154 ⟶ 1,258:
Check3
</syntaxhighlight>
Line 1,171 ⟶ 1,275:
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">Grid[Partition[Names["$*"],4]]
->
$Aborted $ActivationGroupID $ActivationKey $ActivationUserRegistered
Line 1,218 ⟶ 1,320:
$TimeZone $TopDirectory $TraceOff $TraceOn
$TracePattern $TracePostAction $TracePreAction $Urgent
$UserAddOnsDirectory $UserBaseDirectory $UserBasePacletsDirectory $UserDocumentsDirectory</
=={{header|Maxima}}==
<
fpprec; /* precision for big floats */
obase; /* number base for output */
Line 1,230 ⟶ 1,329:
/* Other variables are read-only, and give the list of user-defined variables, functions... */
infolists; /* give the names of all available lists */
[labels, values, functions, macros, arrays, myoptions, props, aliases, rules, gradefs, dependencies, let_rule_packages, structures]</
=={{header|MIPS Assembly}}==
When multiplying two registers, the product is always stored in the <code>$HI</code> and <code>$LO</code> registers. Their contents can be read into your standard registers with the commands <code>mfhi $reg</code> and <code>mflo $reg</code>.
<syntaxhighlight lang="mips">
li $t0,0x4500
li $t1,0xFFFF
multu $t0,$t1 ;unsigned multiplication of $t0 and $t1
mfhi $t0 ;load the top 32 bits of the product into $t0
mflo $t1 ;load the bottom 32 bits of the product into $t1</syntaxhighlight>
Division is a similar story, except <code>$HI</code> holds the remainder and <code>$LO</code> holds the quotient.
When using <code>JAL functionName</code> to call a function, the <code>$ra</code> register holds the return address.
=={{header|ML/I}}==
===Input===
<
"" Special variables
"" There are four different kinds of variables in ML/I.
Line 1,265 ⟶ 1,378:
All other S-variables have implementation defined meanings.
>
SVARDEMO</
===Output===
<
T1 is the number of arguments to current macro call - value is 2
T2 is the number of macro calls so far - value is 5
Line 1,282 ⟶ 1,395:
S7, S8 and S9 are currently unused.
All other S-variables have implementation defined meanings.</
=={{header|Nanoquery}}==
Nanoquery has a number of immutable special variables which can be listed by executing the following program:
<syntaxhighlight lang
{{out}}
<pre>{{dbsize, 0}, {col, 1}, {workingdir, C:\Users\Will\Programs\Nanoquery}, {false, false}, {interactive, false}, {main, true}, {packages, [, Nanoquery.Objects, Nanoquery.Exceptions]}, {libpath, C:\Users\Will\Programs\Nanoquery\nanoquery-2.3_1866}, {args, [-b, rosetta-code/specialvars.nq]}, {rec, 1}, {filename, }, {null, null}, {__file__, C:\Users\Will\Programs\Nanoquery\rosetta-code\specialvars.nq}, {true, true}, {prompt, [\S | rec\R col\C] % }, {cols, 0}, {lockedfiles, []}, {__calls__, [<global>:1]}}</pre>
Line 1,320 ⟶ 1,433:
<code>'''ask''', '''class''', '''digits''', '''form''', '''length''', '''null''', '''source''', '''sourceline''', '''super''', '''this''', '''trace''', '''version'''</code>.
<
options replace format comments java crossref savelog symbols binary
Line 1,354 ⟶ 1,467:
return
</syntaxhighlight>
;Output
<pre>
Line 1,376 ⟶ 1,489:
<ask>answer</ask>
</pre>
=={{header|Nim}}==
In Nim, there is only one special variable, named <code>result</code>. It is implicitly declared in procedure which returns a result and is initialized with binary zeroes. Statement <code>return value</code> is in fact a shortcut for:
<syntaxhighlight lang="nim">result = value
return</syntaxhighlight>
There are also variables declared in modules and exported. As some modules are implicitly imported, their exported variables are automatically visible. Modules implicitly imported are: “system” (which imports “iterators”, “assertions”, “dollars”, “io” and “widestr”), “threads” and “channels”, the latter two being activated if option <code>--thread:on</code> is used.
These implicit imports add these variables to the list of visible objects:
:– some hooks and handlers used in system programming: <code>globalRaiseHook</code>, <code>localRaiseHook</code>, <code>outOfMemHook</code>, <code>unhandledExceptionHook</code>, <code>errorMessageWriter</code>, <code>onUnhandledException</code>;
:– a read-only variable, <code>nimvm</code> which is true in Nim VM context and false otherwise;
:– the three standard files: <code>stdin</code>, <code>stdout</code>, <code>stderr</code>.
=={{header|OASYS}}==
Line 1,387 ⟶ 1,513:
Some predefined variables from the <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Sys.html Sys]</code> module:
<
(** The command line arguments given to the process.
The first element is the command name used to invoke the program.
Line 1,424 ⟶ 1,550:
where [major], [minor], and [patchlevel] are integers, and
[additional-info] is an arbitrary string. The [[.patchlevel]] and
[[+additional-info]] parts may be absent. *)</
Some predefined variables from the <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html Pervasives]</code> module:
<
(** The greatest representable integer. *)
Line 1,442 ⟶ 1,568:
val epsilon_float : float
(** The difference between [1.0] and the smallest exactly representable
floating-point number greater than [1.0]. *)</
=={{header|Oforth}}==
Line 1,466 ⟶ 1,592:
System.ISLUNIX
</pre>
=={{header|Pascal}}==
Pascal does not have any predefined special variables.
However, two identifiers ''can'' become “special”:
If you list in the <tt>program</tt> parameter list the identifiers of the spelling <tt>input</tt> and/or <tt>output</tt>, they will identify <tt>text</tt> variables referring to an implementation-defined input and output facility.
<syntaxhighlight lang="pascal">program foo(input, output);
begin
{ In this program, `input` and `output` have special meaning. }
end.</syntaxhighlight>
Neverthless, these identifiers are in no way ''reserved''.
<syntaxhighlight lang="pascal">program foo(output);
var
input: integer;
begin
{ In this program only `output` has special meaning. }
end.</syntaxhighlight>
Note that some run-time libraries of compilers usually ship a variety of predefined variables, but these are not part of the programming language itself.
=={{header|PARI/GP}}==
Line 1,509 ⟶ 1,652:
%ENV # associative container holding the environment variables
%SIG # associative container holding signal handlers</pre>
=={{header|Phix}}==
{{libheader|Phix/basics}}
Phix has no special variables.
Line 1,615 ⟶ 1,671:
=={{header|PL/I}}==
<syntaxhighlight lang="pl/i">
Special variables in PL/I are termed "Pseudo-variables".
They are used only on the LHS of an assignment statement.
Line 1,637 ⟶ 1,693:
and may be used when a re-try of the conversion is to be
attempted with modified data).
</syntaxhighlight>
=={{header|PowerShell}}==
This is the list:
<syntaxhighlight lang="powershell">
<#
$$
Line 1,682 ⟶ 1,738:
$True
#>
</syntaxhighlight>
For descriptions:
<syntaxhighlight lang="powershell">
help about_automatic_variables
</syntaxhighlight>
=={{header|PureBasic}}==
Line 1,693 ⟶ 1,749:
=={{header|Python}}==
By default, Python starts execution in a namespace which has direct access to names defined in the globals() dict and the __builtins__ dict. The members of which can be found by the following code:
<
print( '\n'.join(' '.join(names[i:i+8]) for i in range(0, len(names), 8)) )</
;Output
<pre>ArithmeticError AssertionError AttributeError BaseException BufferError BytesWarning DeprecationWarning EOFError
Line 1,713 ⟶ 1,769:
round set setattr slice sorted staticmethod str sum
super tuple type vars zip</pre>
=={{header|Quackery}}==
The trite answer would be that Quackery has no variables.
It does, however, have Ancillary Stacks which stand in for variables, in that they are places where values can reside. Their behaviour is to place a pointer to themselves on the stack (''the stack'' refers to the Quackery Data Stack, the place from which words take arguments and return results), so that they can have values moved to and from them.
Ancillary Stacks might also, arguably, be considered slightly outside the language proper. To use a metaphor, if Quackery is a workshop, and Quackery words are tools for working on data, then the stack is the workbench that data resides on while it is being worked upon, and Ancillary Stacks are the storage spaces where one can put things to keep the workbench tidy. If asked to list the tools in a workshop, would you necessarily list shelves and cupboards as tools?
If predefined system constants are to be included, (i.e. words that take no arguments and always return the same value, a category which includes Ancillary Stacks) then there are several, including but not limited to <code>space</code> which returns 32, <code>carriage</code> which returns 13 (and is taken to mean whatever the host system regards as a carriage return/line feed), <code>[]</code>, which returns the empty nest <code>[ ]</code>, <code>true</code> which returns 1 and <code>false</code> which returns 0.
However, I suspect the most useful answer is "those things which need to be taken into consideration whilst coding in Quackery, because they give words side-effects rather than the words being purely functional in their behaviour."
With this definition there is only one word that requires mention; <code>base</code>. <code>base</code> is a system ancillary stack that holds the current base for numerical i/o and converting numerical strings to and from numbers and so forth. It has a default value of 10 — i.e. Quackery regards numbers as decimal unless that assumption is overridden by putting a different value on the top of the ancillary stack called <code>base</code>.
=={{header|Racket}}==
Line 1,727 ⟶ 1,797:
names that are bound to these parameters are not special, and can be
changed or hidden.)
=={{header|Raku}}==
(formerly Perl 6)
It is probably useful to briefly explain normal variables in Raku before tackling special variables.
Variables in Raku have a prefix sigil to distinguish them from named subroutines, functions, classes, and so on. There is a system of sigils to mark the fundamental structural type of the variable:
<syntaxhighlight lang="raku" line> $foo scalar (object)
@foo ordered array
%foo unordered hash (associative array)
&foo code/rule/token/regex
::foo package/module/class/role/subset/enum/type/grammar</syntaxhighlight>
Sigils indicate overall interface, not the exact type of the bound object. Different sigils imply different minimal abilities. Ordinary sigils indicate normally scoped variables, either lexical or package scoped. Oddly scoped variables include a secondary sigil (a twigil) that indicates what kind of strange scoping the variable is subject to:
<syntaxhighlight lang="raku" line> $foo # ordinary scoping
$.foo # object attribute public accessor
$^foo # self-declared formal positional parameter
$:foo # self-declared formal named parameter
$*foo # dynamically overridable global variable
$?foo # compiler hint variable
$=foo # POD variable
$<foo> # match variable, short for $/{'foo'}
$!foo # object attribute private storage
$~foo # the foo sublanguage seen by the parser at this lexical spot</syntaxhighlight>
A selection (not comprehensive) of Raku's automatically set and/or pre-defined compile-time and run-time variables.
<syntaxhighlight lang="raku" line># Lexical variables
$_ # implicit variable lexically scoped to the current block
$! # current Exception object
$/ # last match
$0, $1, $2... # captured values from match: $/[0], $/[1], $/[2] ...
# Compile-time variables
$?PACKAGE # current package
$?CLASS # current class
$?MODULE # current module
$?ROLE # current role
$?DISTRIBUTION # which OS distribution am I compiling under
$?FILE # current filename of source file
$?LINE # current line number in source file
&?ROUTINE # current sub or method (itself)
&?BLOCK # current block (itself)
# Dynamic variables
$*USAGE # value of the auto-generated USAGE message
$*PROGRAM-NAME # path to the current executable
$*PROGRAM # location (in the form of an IO::Path object) of the Raku program being executed
@*ARGS # command-line arguments
$*ARGFILES # the magic command-line input handle
$*CWD # current working directory
$*DISTRO # which OS distribution am I running under
%*ENV # system environment variables
$*ERR # standard error handle
$*EXECUTABLE-NAME # name of the Raku executable that is currently running
$*EXECUTABLE # IO::Path absolute path of the Raku executable that is currently running
$*IN # standard input handle; is an IO object
$*KERNEL # operating system running under
$*OUT # standard output handle
$*RAKU # Raku version running under
$*PID # system process id
$*TZ # local time zone
$*USER # system user id
# Run-time variables
$*COLLATION # object that can be used to configure Unicode collation levels
$*TOLERANCE # used by the =~= operator to decide if two values are approximately equal
$*DEFAULT-READ-ELEMS # affects the number of bytes read by default by IO::Handle.read</syntaxhighlight>
Also, not really a variable but...
<syntaxhighlight lang="raku" line> * # A standalone term that has no fixed value, instead it captures the notion of "Whatever",
# the meaning of which is decided lazily by whatever it is an argument to.
# See the docs on Whatever: https://docs.raku.org/type/Whatever</syntaxhighlight>
=={{header|REXX}}==
Line 1,751 ⟶ 1,897:
In each case, the three special variable names ('''RC''', '''RESULT''', and '''SIGL''') may be in lower/upper/mixed case.
<br><br>The scope of the special variables is LOCAL.
<
/*line two. */
/*line three.*/ say copies('═',79)
Line 1,779 ⟶ 1,925:
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────HALVE subroutine────────────────────*/
halve: return arg(1) / 2 /*a simple halving function. */</
'''output''' using:
:::* Regina REXX
Line 1,847 ⟶ 1,993:
Note that RETURN transfers control but does not set SIGL.
<
Say 'rc='rc
'dir 33.*'
Line 1,869 ⟶ 2,015:
Novalue:
Say 'NOVALUE encountered in line' sigl':' sourceline(sigl)
Exit </
{{out}}
<pre> Datentr„ger in Laufwerk E: ist E_DESKTOP
Line 1,919 ⟶ 2,065:
for (_ <- 1 to 10) doIt() // Discarded val
def f: T; def f_=(t: T) // Combo for creating mutable f member.</pre>
=={{header|Smalltalk}}==
Talking about special (reserved) names, there are:
Line 1,931 ⟶ 2,078:
* nil
Technically, these could be redefined, but the system would not work if any of them was. Therefore most compilers refuse code which obviously attempts to do so, and we can think of them as being reserved names as well.
Global binding names are returned by <syntaxhighlight lang
Things like the shell environment, command line argument, version numbers etc. are usually not exposed via globals, but instead held in private class variables (static variables), which can be accessed via getter messages (which, by the way, makes it easier to insert a dialect compatibility layer). An example for this would be: <
Name conventions:
Line 1,992 ⟶ 2,139:
:This local variable holds the Tcl list of arguments supplied to the current procedure after all the other formal arguments have been satisfied. Note that it needs to be explicitly listed in the formal arguments ''and'' be last in the list of formal arguments to have this behavior.
==
The following variables are reserved for special purposes within the Bourne shell:
Line 2,045 ⟶ 2,192:
=={{header|Ursa}}==
<
# interpreter on the command line
string<> args
Line 2,059 ⟶ 2,206:
# represents true
boolean true</
=={{header|VBA}}==
VBA does not have special variables.
=={{header|XLISP}}==
XLISP provides the following built-in variables:
Line 2,083 ⟶ 2,231:
CLASS</pre>
==
Wren has two special variables ''this'' and ''super''. When used in a constructor or instance method of a class. ''this'' refers to the current instance and ''super'' refers to a super-class whose constructor or (typically overridden) method you wish to invoke. Here's an example.
<syntaxhighlight lang="wren">class Parent {
construct new(name) {
_name = name
}
name { _name }
}
class Child is Parent {
construct new(name, parentName) {
_name = name
super(parentName) // call parent's constructor
}
name { _name } // overrides Parent's name method
printNames() {
System.print("My name is %(this.name) and my parent's name is %(super.name).")
}
}
var c = Child.new("John", "Fred")
c.printNames()</syntaxhighlight>
{{out}}
<pre>
My name is John and my parent's name is Fred.
</pre>
=={{header|Z80 Assembly}}==
It's somewhat debatable whether processor registers count as "variables," since they don't have a location in the address space but their contents can change. Excluding those for now, there are a few memory locations that have special meaning:
The following memory locations can be called as functions using the <code>RST</code> instructions. Each appears to take a byte as an operand, but in fact there are only 8 different "operands" and each is hardcoded in, which means that only one byte is needed to describe both the <code>RST</code> and the destination byte. Unfortunately, there is very little room for code in these areas, since each is only '''8 bytes long!''' Most of the time you'll put a jump to the actual routine you want to execute in these areas. The last one, <code>RST 38</code>, may allow more room for code depending on the system.
* &0000 - called with RST 00
* &0008 - called with RST 08
* &0010 - called with RST 10
* &0018 - called with RST 18
* &0020 - called with RST 20
* &0028 - called with RST 28
* &0030 - called with RST 30
* &0038 - called with RST 38
The memory location &0066 is special because it contains the NMI routine. NMI stands for "Non-Maskable Interrupt" and is a hardware interrupt that can't be stopped by a <code>DI</code> command. When an NMI occurs, the CPU will save the program counter on the stack and jump to &0066, and execute from there. The <code>RETN</code> instruction is used to return back to the main program. Usually an <code>ORG </code> directive is the easiest way to guarantee that your code will begin at the correct address for NMI. Since you can't predict exactly what state your program will be in when an NMI happens, it's important that the NMI routine uses either the stack or the exchange commands to preserve the register state at the start and restores it before returning. Otherwise, your NMI could ruin whatever your program was doing at the time.
Depending on the hardware, programming the NMI routine may not actually be your responsibility. It's usually only required when programming for a ROM-cartridge game console like the Sega Master System. On home computers, the NMI routine at &0066 is typically built into the firmware by the manufacturer and cannot be changed; however that routine will often contain a jump to another memory location that you can change indirectly using system calls and parameter passing.
<syntaxhighlight lang="z80">org &0066
NMI_HANDLER: ;this label is optional, the CPU doesn't need it to know how to jump here.
retn ;in this example, the NMI routine will immediately return without doing anything.</syntaxhighlight>
The <code>I</code> register handles the interrupt operation in <code>IM 2</code> mode. The Game Boy does not have this register, as it handles interrupts differently.
The <code>r</code> register handles memory refresh. You should '''not''' write to this register, as doing so can damage your hardware. But reading from this register is safe. It basically contains a pseudo-random value, and while its randomness isn't sufficient to reliably seed a PRNG, it can be used to add a little "salt" to a random value. (It should be noted that the Game Boy doesn't have this register, so don't bother trying.)
<syntaxhighlight lang="z80"> ld a,r ;read from the refresh register.</syntaxhighlight>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">__DATE__, __DEBUG__, __FILE__, __LINE__, __NAME__, __TIME__</syntaxhighlight>
As in the C preprocessor. Some (like __DEBUG__) can be changed, others (like __LINE__, __TIME__) are constants.
=={{header|ZX Spectrum Basic}}==
The ZX Spectrum does Not make a difference between capital or lower character variable names. A normal variable can be severall letters long, any DEF FN, FOR/NEXT, DIM (STRING or DATA) array name is a single letter variable name. None of these are special variables. for 128k zx spectrum matters that In REVERSED SENSE some variable names are IMposible becouse of the tokenized form in the 48k basic eg 'not' will be NOT !!!!
Line 2,161 ⟶ 2,370:
* 23732 P-RAMT - Address of last byte of physical RAM.
<
20 PRINT "The ramtop address is "; PEEK (23730) + 256 * PEEK (23731): REM ramtop
30 POKE 23609,50: REM set keyboard pip to 50</
{{omit from|GUISS|Does not have any variables at all}}
{{omit from|68000 Assembly|Existence of special variables depends entirely on the implementation}}
{{omit from|8086 Assembly|Existence of special variables depends entirely on the implementation}}
{{omit from|x86 Assembly|Existence of special variables depends entirely on the implementation}}
{{omit from|ARM Assembly|Existence of special variables depends entirely on the implementation}}
| |||