Special variables: Difference between revisions

{{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$;

END CO

));

Sample output:

<pre>

{{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$,

" joule", mksa joule, cgs joule,

" erg", mksa erg, cgs erg

Output:

<pre>

 

=={{header|ALGOL W}}==

 

integer I_W % field width for integer output %

if the relevant EXCEPTION variable is null, the exception is ignored,

otherwise it is processed according to the settings of XCPLIMIT etc.

 

=={{header|Arturo}}==

Besides <code>errno</code> like C, C++ has the <code>this</code> pointer so objects can refer to themselves.

 

 

struct SpecialVariables

auto sv2 = ++sv; // makes a copy of sv after it was incremented

std::cout << " sv :" << sv.i << "\n sv2:" << sv2.i << "\n";

{{out}}

<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)))))))

{{Out}}

<pre>*1 *2 *3 *agent* *allow-unresolved-vars* *assert* *clojure-version* *command-line-args* *compile-files* *compile-path*

 

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) #\*)

lst)))

 

 

{{Out}}

Dyalect has a special <code>this</code> which is available inside methods:

 

this + this

}

 

=={{header|Déjà Vu}}==

call for pass</pre>

In addition, <code>eva</code> is special:

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.

 

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.

-module( special_variables ).

 

 

task() -> ok.

{{out}}

<pre>

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.

 

1 ERR = 666,IOSTAT = IOSTAT) !Hopefully, named in good style, etc.

IF (EXIST) THEN !So, does the named file already exist?

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|Icon}} and {{header|Unicon}}==

Icon and Unicon have special variables known as keywords which are syntactically are preceded by an &.

# &keyword # type returned(indicators) - brief description

# indicators:

&y # integer(=G) - pointer vertical position

# keywords may also fail if the corresponding feature is not present.

 

=={{header|IS-BASIC}}==

BLUE - The code of colour blue.

CYAN - The code of colour cyan.

WHITE - The code of colour white.

YELLOW - The code of colour yellow.

 

=={{header|J}}==

 

Some examples:

1

1000 {{ x + y }} 1

1011

(1000) 100 {{ x v m v y }} + (1)

 

These names may be used as regular names, but that is bad practice except in the context of debugging or illustration.

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 {

}

 

 

=={{header|JavaScript}}==

<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; }

};

 

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++) {

return s;

}

 

=={{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.

 

(*) 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>

 

The following program illustrates their usage:

 

class President(val name: String) {

val pres3 = President("Theodore")

pres3.age = 158

 

{{out}}

In Lasso parameters can be referenced as numerical locals within methods or unbound captures. [http://lassoguide.com/language/variables.html?#parameter-pseudo-locals]

 

 

 

=={{header|Lingo}}==

 

Further to those, LiveCode comes with a plethora of built-in constants, which are readily listed with the following command:

 

=={{header|Lua}}==

To list all global variables:

 

 

The list will include built-in global functions, whose availability depends on the implementation and compile time configuration.

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.

 

Module Checkit {

Let inkey$="hello", dir$="Something Else"

Check3

 

 

 

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

->

$Aborted $ActivationGroupID $ActivationKey $ActivationUserRegistered

$TimeZone $TopDirectory $TraceOff $TraceOn

$TracePattern $TracePostAction $TracePreAction $Urgent

 

=={{header|Maxima}}==

fpprec; /* precision for big floats */

obase; /* number base for output */

/* Other variables are read-only, and give the list of user-defined variables, functions... */

infolists; /* give the names of all available lists */

 

=={{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>.

 

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

 

Division is a similar story, except <code>$HI</code> holds the remainder and <code>$LO</code> holds the quotient.

=={{header|ML/I}}==

===Input===

"" Special variables

"" There are four different kinds of variables in ML/I.

All other S-variables have implementation defined meanings.

>

 

===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

S7, S8 and S9 are currently unused.

 

 

=={{header|Nanoquery}}==

Nanoquery has a number of immutable special variables which can be listed by executing the following program:

{{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>

<code>'''ask''', '''class''', '''digits''', '''form''', '''length''', '''null''', '''source''', '''sourceline''', '''super''', '''this''', '''trace''', '''version'''</code>.

 

options replace format comments java crossref savelog symbols binary

 

 

return

;Output

<pre>

 

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:

 

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.

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.

where [major], [minor], and [patchlevel] are integers, and

[additional-info] is an arbitrary string. The [[.patchlevel]] and

 

Some predefined variables from the <code>[http://caml.inria.fr/pub/docs/manual-ocaml/libref/Pervasives.html Pervasives]</code> module:

 

(** The greatest representable integer. *)

 

val epsilon_float : float

(** The difference between [1.0] and the smallest exactly representable

 

=={{header|Oforth}}==

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.

begin

{ In this program, `input` and `output` have special meaning. }

Neverthless, these identifiers are in no way ''reserved''.

var

input: integer;

begin

{ In this program only `output` has special meaning. }

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|PL/I}}==

Special variables in PL/I are termed "Pseudo-variables".

They are used only on the LHS of an assignment statement.

and may be used when a re-try of the conversion is to be

attempted with modified data).

 

=={{header|PowerShell}}==

This is the list:

<#

$$

$True

#>

For descriptions:

help about_automatic_variables

 

=={{header|PureBasic}}==

=={{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:

;Output

<pre>ArithmeticError AssertionError AttributeError BaseException BufferError BytesWarning DeprecationWarning EOFError

 

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:

@foo ordered array

%foo unordered hash (associative array)

&foo code/rule/token/regex

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:

$.foo # object attribute public accessor

$^foo # self-declared formal positional parameter

$<foo> # match variable, short for $/{'foo'}

$!foo # object attribute private storage

 

A selection (not comprehensive) of Raku's automatically set and/or pre-defined compile-time and run-time variables.

 

 

$_ # implicit variable lexically scoped to the current block

$*COLLATION # object that can be used to configure Unicode collation levels

$*TOLERANCE # used by the =~= operator to decide if two values are approximately equal

 

Also, not really a variable but...

# the meaning of which is decided lazily by whatever it is an argument to.

 

=={{header|REXX}}==

In each case, the three special variable names &nbsp; ('''RC''', &nbsp; '''RESULT''', &nbsp; and &nbsp; '''SIGL''') &nbsp; may be in lower/upper/mixed case.

<br><br>The scope of the special variables is &nbsp; LOCAL.

/*line two. */

/*line three.*/ say copies('═',79)

exit /*stick a fork in it, we're done.*/

/*──────────────────────────────────HALVE subroutine────────────────────*/

'''output''' using:

:::* Regina REXX

Note that RETURN transfers control but does not set SIGL.

 

Say 'rc='rc

'dir 33.*'

Novalue:

Say 'NOVALUE encountered in line' sigl':' sourceline(sigl)

{{out}}

<pre> Datentr„ger in Laufwerk E: ist E_DESKTOP

* 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.

 

Name conventions:

 

=={{header|Ursa}}==

# interpreter on the command line

string<> args

 

# represents true

 

=={{header|VBA}}==

=={{header|Wren}}==

Wren has two special variables ''this'' and ''super''. These can only be 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.

construct new(name) {

_name = name

 

var c = Child.new("John", "Fred")

 

{{out}}

 

 

 

NMI_HANDLER: ;this label is optional, the CPU doesn't need it to know how to jump here.

 

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.)

 

=={{header|zkl}}==

As in the C preprocessor. Some (like __DEBUG__) can be changed, others (like __LINE__, __TIME__) are constants.

 

* 23732 P-RAMT - Address of last byte of physical RAM.

 

20 PRINT "The ramtop address is "; PEEK (23730) + 256 * PEEK (23731): REM ramtop

 

{{omit from|GUISS|Does not have any variables at all}}