Introspection: Difference between revisions

=={{header|Ada}}==

Ada doesn't allow you to ask about compiler versions, but you can query specific parameters of the target, such as the range of the standard integer type, or the precision of the standard floating point type:

procedure Introspection is

use Ada.Integer_Text_IO, Ada.Text_IO;

Put (Float'Digits);

New_Line;

All Ada compilers recognize obsolete parts of a programs and either automatically recompile them or fail to link the program.

 

=={{header|Aikido}}==

The version of the Aikido interpreter is in the global scope variable <em>version</em>. AIkido doesn't have <code>abs</code> but it does have <code>fabs</code>. Getting the variables in main involves getting their names and then evaluating them as an expression in order to retrieve their type.

import math

 

 

 

Here is the result:

fabs(bloop) is 1.4

There are 3 integer variables in the global scope

Their sum is 1936

 

=={{header|ALGOL 68}}==

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

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

print (("Integer range: ", -max int, " .. ", max int, new line));

print (("Integer digits: ", int width, new line));

print (("Float range: ", -max real, " .. ", max real, new line));

print (("Float digits: ", real width, new line))

{{out}}

<pre>

{{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) - MODEs BYTE, SEMA, FORMAT etc are not available in ELLA Algol68RS}}

MODE SSMODES = UNION(SHORT SHORT BITS, SHORT SHORT BYTES, #SHORT SHORT CHAR,#

SHORT SHORT INT, SHORT SHORT REAL, SHORT SHORT COMPL);

sep := ", "

OD

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.3.3 algol68g-2.3.3].}}

{{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''.}}

 

OP TYPEOF = (INT skip)STRING: "INT";

OP TYPEOF = (COMPL skip)STRING: "COMPL";

 

{{out}}

<pre>

{{works with|ELLA ALGOL 68|Any (with appropriate job cards)}}

 

 

[]INT x = (5,4,3,2,1);

 

print(("x =", x, new line));

{{out}}

<pre>

LWB x = +1, UPB x = +5

</pre>

 

=={{header|AutoHotkey}}==

{

MsgBox % "you are using" . A_AhkVersion . "`nplease upgrade to" . "1.0.48.03"

if IsFunc("abs")

MsgBox % abs(bloop)

 

=={{header|AWK}}==

{{works with|gawk|4.1.0}} PROCINFO is a gawk-extension

# syntax: GAWK -f INTROSPECTION.AWK

BEGIN {

}

function abs(x) { if (x >= 0) { return x } else { return -x } }

{{out}}

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

ON ERROR LOCAL PRINT "Variable 'bloop' doesn't exist" : END

INPUT #F%,V$

CLOSE #F%

 

=={{header|C}}==

 

{{works with|C|94 and later}}

#pragma error("C compiler must adhere to at least C99 for the following code.")

#else

/* rest of file */

 

However, there is no facility in C for checking whether individual variables

doing this kind of check in a shell script and defining symbols

such as HAVE_ABS which ''can'' be checked by the preprocessor.

=={{header|C sharp|C#}}==

There has to be some caveats made with C#. There are no truly "global" variables - just publicly exported ones from individual classes/types. I chose to make a couple of public static variables in my program's class. Also, the "version" of the compiler is difficult to impossible to get at. There are no predefined compiler constants that can be compared against as in C/C++ but then again, it's hardly the thing that counts in C#. What really counts is the version of .NET and the framework you're working with since that determines what C++ features you can use and the various calls that can be made. Consequently, I check the .NET version to make sure it's past 4.0 and exit if not.

using System.Reflection;

 

}

}

 

{{out}}

<pre>bloop's abs value = 10

2 exported ints which total to -30</pre>

 

=={{header|Clojure}}==

Partial answer...

; check Java version

(let [version (Double/parseDouble (re-find #"\d*\.\d*" (System/getProperty "java.version")))]

(println "Version ok")

(throw (Error. "Bad version"))))

 

=={{header|Common Lisp}}==

(major (parse-integer ver :start 0 :end (position #\. ver))))

#+lispworks (assert (>= 5 major) () "Requires Lispworks version 5 or above")

#+clisp (assert (>= 2 major) () "Requires CLISP 2.n")

(if (and (fboundp 'abs)

(boundp 'bloop))

The ''list-all-packages'' and ''do-symbols'' forms enable a lisp program to examine all symbols and these can be tested to identify integer variables.

(ints '()))

(loop for pkg in (list-all-packages)

(incf sum (symbol-value s)))))

(format t "there are ~d integer variables adding up to ~d~%"

 

=={{header|D}}==

With extra credit.

immutable x = 3, y = 100, z = 3_000;

short w = 1; // Not an int, must be ignored.

tot += mixin("." ~ name);

writeln("Total of the module-level ints (could overflow): ", tot);

{{out}}

<pre>The expression is compilable.

=={{header|E}}==

Version:

 

(There is no built-in version comparison, and the author of this example assumes that implementing a version comparison algorithm isn't the point of this task.)

 

Existence:

def &x := meta.getState().fetch("&bloop", fn { fail("no bloop") })

if (!x.__respondsTo("abs", 0)) { fail("no abs") }

x.abs()

 

This will return either bloop.abs(), "no bloop", or "no abs".

 

Sum of integers:

var sum := 0

for &x in interp.getTopScope() { sum += try { x :int } catch _ { 0 } }

sum

<code>try</code> rather than an ordinary type check is used because in general a slot might be broken; this way we skip over all read failures as well as non-integers. The block around the code ensures that the sum variable itself will not be involved in the computation.

 

=={{header|EchoLisp}}==

(version)

→ EchoLisp - 2.50.3

 

 

 

=={{header|Erlang}}==

Erlang does not have global variables so I look for a function bloop/0 that returns an integer.

Moreover, I sum the available modules, instead of the unavailable global integers.

-module( introspection ).

 

exit_if_too_old( Release ) when Release < "R13A" -> erlang:exit( too_old_release );

exit_if_too_old( _Release ) -> ok.

{{out}}

<pre>

=={{header|Factor}}==

Check for build number and execute a quotation if it's too old. (There are no such things as versions for Factor yet.)

[ build > ] 2dip if ; inline

 

[ [ ] ] dip if-older ; inline

 

 

It is possible to test if a function or a variable exists (<code>search</code>), but that shouldn't be used outside of parsing.

get [

"abs" search [ execute( n -- n' ) ] when*

] [ 0 ] if*

 

On the other hand, it is possible to search the global namespace for integer variables:

 

0 0

nip dup integer? [ + [ 1 + ] dip ] [ drop ] if

] assoc-each

 

=={{header|Forth}}==

Standard Forth doesn't necessarily provide for version numbers, but you can query information about the environment at interpretation time:

 

0xffffffff <> [IF] .( Requires 32 bits! ) bye [THEN]

[THEN]

[defined] abs [if]

bloop @ abs

[[4tH]] is able to fulfill all requirements. Note that since only one variable has been declared, the sum of all integer (user)variables is consequently the value of that variable.

{{Works with|4tH|3.62.2}}

 

-32 value bloop

 

0 last cell+ first over over - .( User variables: ) .

{{out}}

<pre>

=={{header|FreeBASIC}}==

Version 1:

 

#If __FB_VERSION__ < "1.06.0"

Print "bloop does not exist"

#EndIf

{{out}}

<pre>introspection.bas(4) error: Compiler version is too old - needs to be 1.06.0 or later</pre>

Version 2:

 

#If __FB_VERSION__ < "1.05.0" '' version 1.05.0 is now OK

Print "bloop does not exist"

#EndIf

{{out}}

<pre>Abs(bloop) = 15</pre>

Version 3 (version code omitted for brevity):

Dim bloop As Integer = -15

#IfDef bloop

Print "bloop does not exist"

#EndIf

{{out}}

<pre>Abs is not available</pre>

Version 4 (version code omitted for brevity):

'Dim bloop As Integer = -15 '' bloop declaration commented out

#IfDef bloop

Print "bloop does not exist"

#EndIf

{{out}}

<pre>bloop does not exist</pre>

 

=={{header|GAP}}==

CheckEval := function(fun, val)

local f, x;

od;

return s;

 

=={{header|Go}}==

Task variance: "exit if it is too old" is not done here. Go version strings do not present an easily interpreted chronology. This version of the program simply prints the version string.

 

import (

fmt.Println(" abs(bloop): ", math.Abs(bloop))

}

{{out}}

<pre>

=={{header|Haskell}}==

 

import Control.Monad

import System.Info

 

main = when (compilerName == "ghc" && compilerVersion < minGHCVersion) $

 

No means exists of checking whether a variable exists at runtime. The set of variables that exist in any given scope is fixed at compile-time.

=={{header|Icon}} and {{header|Unicon}}==

 

 

procedure main(A)

return (major < maj) | ((major = maj) & (minor < min))

}

Sample run:

<pre>->introspect

=={{header|Inform 7}}==

Inform 7 doesn't have built-in functionality for checking the runtime version number, but the version number is available and can be read by including a snippet of Inform 6 code. The address and format of the version number vary according to the virtual machine being targeted.

 

When play begins:

 

To decide which version is current runtime version: (- ($32-->0) -).

 

It's not possible to check for the existence of functions (invoking a nonexistent phrase causes a compile-time error) or list global variables.

 

=={{header|Io}}==

 

 

Io can also inspect the source code of methods written in Io:

 

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

110 WHEN EXCEPTION USE ERROR

120 PRINT ABS(BLOOP)

150 PRINT EXSTRING$(EXTYPE)

160 CONTINUE

 

=={{header|J}}==

Exit if we're running an old version of J (earlier than version 6, which is current as of this writing), giving version number as the exit status:

Compute <tt>abs(bloop)</tt> if <tt>abs</tt> is a function and <tt>bloop</tt> is data:

'''Extra credit''': report the number of integer variables in global scope, and their sum:

 

This last expression is longer than the others, because it has a couple of extra guard checks; in J, the programmer doesn't need to care if the data is a single number or an array, or what hardware representation is used for numbers (32-bit int, IEEE float, etc).

=={{header|Java}}==

You can't see if a variable or function is available in Java (it will be a compile time error if you try to use them when you they aren't available), but you can check the version number using the <tt>System</tt> class:

public static void main(String[] args) {

String vers = System.getProperty("java.version");

}

}

 

=={{header|JavaScript}}==

Testing whether the variable “bloop” exists:

 

 

The <code>typeof</code> operator explicitly does not throw an error when given an undeclared variable.

Test whether <code>Math.abs()</code> is available:

 

 

<code>abs</code> is a method of the Math object, methods are properties, and the <code>in</code> operator tests whether an object has the named property.

 

 

VERSION < v"0.4" && exit(1)

 

@show abs(bloop)

end

vars = filter(x -> eval(x) isa Integer, names(Main))

println("Integer variables: ", join(vars, ", "), ".")

 

{{out}}

Integer variables: a, b, c.

Sum of integers in the global scope: 6.</pre>

=={{header|Kotlin}}==

We will use Java reflection for this task as Kotlin's own reflection facilities do not appear to be able to deal generically with top-level entities at the present time (i.e. ::class isn't yet supported):

 

import java.lang.reflect.Method

}

println("\nThere are $count global integer variables and their sum is $sum")

 

{{out}}

 

=={{header|Lasso}}==

 

decimal(lasso_version(-lassoversion)) < 9.2 ? abort

 

-> 26

 

Lassos equivalence of global variables are thread variables. They have scope that lasts for the entire call in contrast to local variables that are confined to the page or method they are created within.

 

bloob = -26,

positive = 450

}

 

-> 424

 

=={{header|Lingo}}==

*verify the version/revision of your currently running (compiler/interpreter/byte-compiler/runtime environment/whatever your language uses) and exit if it is too old.

-- "11.5.9"

 

_player.itemDelimiter="."

 

*check whether the variable "bloop" exists and whether the math-function "abs()" is available and if yes compute abs(bloop).

bloopExists = not voidP(value("bloop"))

-- or for global scope:

-- bloopExists = not voidP(_global.bloop)

absExists = value("abs(1)")=1

 

*Report the number of integer variables in global scope, and their sum.

sum = 0

repeat with v in the globals

end repeat

put cnt

 

=={{header|Locomotive Basic}}==

To get the BASIC ROM version number, we need to use a Z80 machine code routine which copies the version number (major/minor/patchlevel) to RAM where BASIC can then read it. Here is the assembly:

 

 

push bc

pop de

pop bc

 

The following BASIC program POKEs that routine into memory and quits prematurely if BASIC 1.0 is detected (meaning the machine is a CPC464), as opposed to the more standard 1.1 or later:

 

20 FOR i=0 to 34:READ a:POKE s+i,a:NEXT

30 DATA &c5,&d5,&e5,&f5,&01,&00,&df,&ed,&49,&01,&86,&7f,&ed,&49

70 PRINT "BASIC ROM version is ";PEEK(&4040);".";PEEK(&4041);".";PEEK(&4042)

80 IF PEEK(&4041)=0 THEN PRINT "Uh oh, you are still using BASIC 1.0":END

 

The second subtask, testing for the presence of a variable, is done here by trying to get the memory address of the variable. If that fails, it is obviously is not yet defined:

 

10 IF RND>.5 THEN bloop=-100*RND

20 ON ERROR GOTO 100

50 PRINT "ABS of bloop is",ABS(bloop)

90 END

 

(Like the Spectrum version, we have omitted checking for ABS because it is a builit-in function of the BASIC interpreter and therefore always present.)

'''Extra credit''': Finally, we can traverse the memory area where BASIC stores its integer, real, and string variables and add together all integers (type 1):

 

20 foo%=-4:bar%=7:baz%=9:somereal=3.141

30 varstart=&ae68 ' for CPC 664 and 6128

160 WEND

170 PRINT "There are"num"integer variables."

 

{{out}}

=={{header|Logo}}==

{{works with|UCB Logo}}

if logoversion < 6.0 [print [too old!]]

 

if and [name? "a] [number? :a] [

print ifelse procedure? "abs [abs :a] [ifelse :a < 0 [minus :a] [:a]]

 

=={{header|Logtalk}}==

:- object(my_application).

 

 

:- end_object.

 

=={{header|Lua}}==

 

 

=={{header|Maple}}==

The "version" kernel option returns a string similar to

The following does the trick for the first bit.

(There is also an internal "version" procedure, which returns a build ID, but this is less obvious to use, as you'd need a table mapping versions to build IDs. Besides, it prints stuff.)

 

It doesn't really make sense to ask whether a variable "exists"; it springs into existence by uttering it in code. So I'll interpret the problem as asking whether it is assigned some kind of numeric value to which abs() can be applied.

1/2

Note that it is not necessary to check that the name "bloop" is assigned (though it is possible to do so), since an unassigned name is a first-class value in Maple. Another possible interpretation is that the symbolic expression

is a perfectly good expression in Maple, so checking for the the "existence" of "bloop" isn't necessary in the first place. (One probably would not bother to check that abs() was actually there either, unless one expected that the standard library was broken.)

 

Here are the number and sum of the assigned integer globals in my current (fresh) session.

3

 

> eval(`+`(anames(integer)));

17

If I change it, I get:

> foo := 25:

> nops([anames](integer));

 

> eval(`+`(anames(integer)));

 

If[NameQ["bloop"] && NameQ["Abs"],

 

{{out}}

<pre>7</pre>

 

 

{{out}}

 

=={{header|MATLAB}} / {{header|Octave}}==

v = version;

v(v=='.')=' ';

printf('abs(bloob) is %f\n',abs(bloob));

return;

Extra credit task:

% find all integers

varlist = whos;

printf('sum of integer scalars: %i\n',intsum);

printf('sum of all integer elements: %i\n',intsumall);

 

=={{header|Maxima}}==

build_info();

/* build_info("5.27.0", "2012-05-08 11:27:57", "i686-pc-mingw32", "GNU Common Lisp (GCL)", "GCL 2.6.8") */

 

/* Sum of integer variables */

 

=={{header|MAXScript}}==

(

versionNumber = maxVersion()

)

 

 

=={{header|NetRexx}}==

 

The language does however return a string identifying the version of NetRexx in effect when the current class was last processed. This information can be retrieved through the '''<tt>version</tt>''' ''special variable''.

options replace format comments java crossref symbols binary

 

end

return

{{out}}

<pre>

 

=={{header|Nim}}==

 

var bloop = -12

 

when compiles abs(bloop):

{{out}}

 

=={{header|OCaml}}==

 

 

(fun major minor micro -> major, minor, micro) ;;

 

Checking if an identifier (a value or a function) is bound doesn't make any sens in OCaml, which is strongly staticaly typed.

Oforth does not have global variables, only global constants.

 

| bl m |

System.VERSION println

 

System.Out "bloop value is : " << bl value << cr

 

{{out}}

ok

</pre>

 

=={{header|Oz}}==

We cannot check whether a variable is in scope (static property).

We <em>can</em> check whether a module exports a certain value. However, for system modules the compiler will refuse to compile if we try to use a non-existing value.

Version = {Property.get 'oz.version'}

%% Version is an atom like '1.4.0'. So we can not compare it directly.

else

{System.showInfo "Your Mozart version is too old."}

 

=={{header|PARI/GP}}==

{{works with|PARI/GP|2.4.3 and above}}

 

 

=={{header|Perl}}==

{{works with|Perl|5.x}}

require 5.6.1; # ditto

 

To check if a variable exists, do a name lookup of it in the package symbol table:

no strict 'refs'; # referring to variable by name goes against 'strict' pragma

 

To check if certain built-in function is available (maybe you are using a stripped down build of perl binary, for example), one can use eval, but make sure the statement you are eval'ing doesn't have side effect:

 

To check if a package or object provides certain method name, use 'can':

my $cpl = Math::Complex->new(1,1);

 

print "object \$cpl does not have 'explode' method\n"

unless $cpl->can('explode');

Keep in mind that what a package has as method names are not equal to what method names can be called on this package, due to things like AUTOLOAD.

For most uses, introspection is meaningless, just call the method (and catch exceptions if it's important).

 

An example that solves the task:

our $bloop = -12;

if (defined $::bloop) {

else {

say '$bloop is not defined';

Note that this program will exit with a message "Perl v5.10.0 required" if run under perl version lower than 5.10 and it actually uses a feature introduced in that version (<code>say</code>).

The program checks whether the variable is actually defined and not if it just exists.

 

Extra task:

package test;

use Regexp::Common;

my $num = @ints;

my $sum = sum @ints;

It prints:

<pre>

This example uses the <code>test</code> namespace instead of the default, because there already are some integer numbers in the <code>main</code> namespace like the PID, etc.

The program to sum those numbers would be:

use Regexp::Common;

use List::Util qw(sum);

my $num = @ints;

my $sum = sum @ints;

<pre>

4 integers, sum = 74717

</pre>

 

 

 

 

{{out}}

 

 

=={{header|PHP}}==

 

 

if (version_compare(PHP_VERSION, '5.3.0', '<' ))

echo(array_sum($GLOBALS) . " is the total of variables in global scope.\n");

 

 

=={{header|PicoLisp}}==

(bye) )

 

(num? bloop) # When 'bloop' is bound to a number

(getd 'abs) # and 'abs' defined as a function

 

=={{header|PL/I}}==

===Version 1===

S = SYSVERSION();

if substr(S, 6, 6) < '050000' then

do; put skip list ('Version of compiler is too old'); stop; end;

===Version 2===

/*********************************************************************

* 02-11.2013 Walter Pachl

Else

Put Skip List('Version is '!!s);

{{out}}

<pre>Version is PL/I for Win* 7.5</pre>

Variable pop_internal_version contains Poplog version in numeric form (as an integer) -- this one is most convenient for version checks. For printing one can use pop_version (which is a string containing more information).

 

if pop_internal_version < 150000 then

sysexit()

 

Pop11 variables are named by words. Pop11 word is a unique version of string stored in dictionary. So we need first convert strings to words and then query about words. Pop11 variables can store any value including functions and in fact when one accesses a function like abs by name one merely access a variable abs which happen to hold predefined function abs. To follow spirit of the task as closely as possible we check if abs indeed holds functional value.

 

define check_and_call(x, y);

lvars wx=consword(x), wy=consword(y);

vars bloop = -5;

;;; Now prints 5

 

Note that here bloop is defined as "permanent" variable, Pop11 also have lexical variables which are not available for introspection.

The compiler directive <code>#COMPILER</code>, introduced with PB/Win 8 and PB/CC <!--uncertain version here--> 4, will fail the compile if the compiler does not match at least one of the listed compilers, and is not at least the (optional) minimum version of that compiler.

 

 

=={{header|PowerShell}}==

if ($PSVersionTable['PSVersion'] -lt '2.0') {

exit

| Where-Object { $_.Value -is [int] } `

| Measure-Object -Sum Value `

 

=={{header|PureBasic}}==

CompilerError "You failed the version check!"

CompilerEndIf

Abs(bloop)

CompilerEndIf

 

=={{header|Python}}==

import sys

major, minor, bugfix = sys.version_info[:3]

 

if defined2('bloop') and defined2('abs') and callable(abs):

You can combine both tests, (But loose sight of which variable in missing/not callable by wrapping the whole function call in a try-except statement:

print abs(bloop)

except (NameError, TypeError):

Here is one way to print the sum of all the global integer variables:

variables = vars(__builtins__).copy()

variables.update(globals())

print sum(v for v in variables.itervalues() if type(v) == int)

 

 

=={{header|R}}==

{{works with|R|2.14.1}}

if(getRversion() < "2.14.1")

{

warning("Your version of R is older than 2.14.1")

q() # exit R, with the option to cancel

The constants <code>version</code> and <code>R.version</code> give further information about the version that is running. The function <code>R.Version()</code> provides the same information as a list.

 

We now perform three checks: we want to know if bloop is in the user workspace (global environment), if abs exists somewhere, and if abs is a function.

if(exists("bloop", envir=globalenv()) && exists("abs") && is.function(abs))

{

abs(bloop)

Finally, we count how many integers are in the user workspace, and find their total. Note that a number followed by the letter L is considered to be an integer. See [[Integer_literals#R]] for more information.

qqq <- 45L

www <- -3L

the_ints <- mget(varnames[is_int], globalenv())

#Add them up

 

=={{header|Racket}}==

 

The usual hack:

#lang racket

(unless (string<=? "5.3" (version)) (error "ancient version"))

 

Proper comparison:

(require version/utils)

(unless (version<=? "5.3" (version)) (error "ancient version"))

 

=={{header|Raven}}==

if 'version >= 20071104 required' print bye

 

'bloop' GLOBAL keys in && 'abs' CORE keys in

 

=={{header|Retro}}==

 

 

 

 

 

 

Retro has no direct way to check for data types of functions. Assuming that a word class is defined for integer variables, we could do something like this:

 

 

After execution the stack will have the number of variables found, and the accumulated sum of their values.

=={{header|REXX}}==

Test to see if the version is at least version 4.

/* theREXXinterpreterName level mm Mon yyyy */

parse version . level .

Test to see if the version is at least version 4, another example.

if level<4 then do

say

say x /*this displays everything.*/

exit /*or maybe: EXIT 13 */

Test to see if the REXX variable "bloop" exists, version 1.

Test to see if the REXX variable "bloop" exists, version 2.

Programming note: &nbsp; note the use of the double apostrophe &nbsp; (<big>''' ' ' '''</big>) &nbsp; which is within a quoted string (with apostrophes) &nbsp; [in the above and below REXX programming examples].

 

<br>Another test to see if the REXX variable "bloop" exists.

if symbol('bloop')=='VAR' then say 'the "bloop" variable exists.'

In REXX, the ABS function is a built-in function (BIF).

However, most REXX interpreters will allow this type of test:

else say 'function XYZ was found.'

exit

return 0

/*──────────────────────────────────────────────────────────────────────────────────────*/

 

=={{header|Ring}}==

# Project: Introspection

func abs(bloop)

return fabs(bloop)

Output:

<pre>

Function 'abc' is not defined

</pre>

 

=={{header|Ruby}}==

 

'''Extra credit:'''

int_vars = []

sum = 0

a_float = 3.14

 

 

{{out}}

Note: The warning is because it accessed the global variable which was made invalid.<br>

The meaning of these variables can be found many places, including [http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Variables_and_Constants here].

 

=={{header|Scala}}==

val minimalVersion = 1.7

 

val bloop = Option(-42)

if (bloop.isDefined) bloop.get.abs

=={{header|Slate}}==

No version string included inside the system presently.

 

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

"uncomment the following to see what happens if bloop exists"

"Smalltalk at: #bloop put: -10."

] .

Transcript show: 'Num of global numeric vars: '; show: (hm printString); cr ;

 

=={{header|Tcl}}==

if {[info exists bloop] && [llength [info functions abs]]} {

puts [expr abs($bloop)]

 

'''Extra credit:'''

variable sum_global_int 0

variable n_global_int 0

puts "number of global ints = $n_global_int"

puts "their sum = $sum_global_int"

 

=={{header|TI-89 BASIC}}==

 

Prgm

Local l, i, vers

© There is no way to get a list of global variables.

 

=={{header|Toka}}==

Starting with Release 1.1, Toka allows for checking the version number:

 

 

Release 1.0 can be detected by doing:

 

 

Basic introspection is possible via '''`'''

 

 

=={{header|UNIX Shell}}==

{{works with|ksh93}}

There's no way to introspect the builtin arithmetic functions. We'll just try it and see if there's an error.

*93[[:alpha:]]+*) :;; #this appears to be ksh93, we're OK

*) echo "version appears to be too old"

done

print "${int_vars[*]}"

 

{{works with|bash}}

bash does not have a builtin math function "abs" -- we'll check for a user-defined shell function instead.

echo "version is too old"

exit

echo "${int_vars[*]}"

echo $sum

 

=={{header|Ursala}}==

1 by the time it's displayed.

 

#import flo

#import lag

#cast %e

 

{{out}}

<pre>1.000000e+00</pre>

To determine the version of the environment -- typically meaning which version of Microsoft Office is running -- the <code>Application</code> object has a <code>Version</code> property:

 

 

=={{header|Yabasic}}==

 

=={{header|zkl}}==

if (Language.version[1] < 10) System.exit("Too old");

var bloop=-123;

{{out}}<pre>123</pre>

The concept of global vars doesn't really exist, only instance data.

self.vars; --> L(L("a",5),L("n",3),L("x",1),L("z","zoo"))

sum:=self.vars.reduce(fcn(p,[(nm,v)],r){

if((1).isType(v)){r.inc();p+v;} else p},0,num:=Ref(0));

{{out}}<pre>Num int vars = 2. Sum = 8</pre>

 

=={{header|ZX Spectrum Basic}}==

 

20 IF totram < 65535 THEN PRINT "Your 16k Spectrum is too old": STOP

30 REM variables must exist before they are used, otherwise we get an error

50 REM I haven't implemented this, because I have forgotten the handler address

60 LET bloob = -4: REM make sure bloob exists, by creating it.

 

{{omit from|GUISS}}

{{omit from|M4}}

{{omit from|M4}}

{{omit from|ML/I}}

[[Category:Initialization]]