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

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

=={{header|Arturo}}==

bloop: 3 - 5

sum map select keys symbols 'sym -> integer? var sym

'sym -> var sym

{{out}}

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

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

Identifying the version of the C++ standard used by the compiler in C++ is syntactically very similar to the way of checking the C standard version (also seen on this page).

#pragma error("The following code requires at least C++11.")

#else

// ...

As in C, the introspective capabilities of C++ are very limited.

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

=={{header|Jsish}}==

if (Info.version() < Util.verConvert('2.8.6')) {

puts("need at least version 2.8.6 of jsish for this application");

}

}

{{out}}

=={{header|Julia}}==

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

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

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

{{out}}

=={{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)));

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

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

In Nim, many checks are done at compile time. So, you have the choice to emit an error or warning at compile time or exit at runtime.

error "This compiler is too old" # Error at compile time.

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

=={{header|OxygenBasic}}==

Compile time introspection

$ rtlversion "0.4.0"

#endif

#endif

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

The requires procedure behaves like a compiler directive, although it is in fact just a normal executable routine.

<span style="color: #7060A8;">requires<span style="color: #0000FF;">(<span style="color: #008000;">"0.8.2"<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- crashes on 0.8.1 and earlier </span>

<span style="color: #7060A8;">requires<span style="color: #0000FF;">(<span style="color: #000000;">WINDOWS<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- crashes on Linux </span>

<span style="color: #7060A8;">requires<span style="color: #0000FF;">(<span style="color: #000000;">64<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- crashes on 32-bit

If passed a string it compares it (intelligently) against the interpreter/compiler version and terminates in error with a suitable message should it be too old to cope. Otherwise the parameter must be an integer: <32 checks the platform, >=32 checks the word size. In the latter case when (interpreting and) it needs to, it hunts for a suitable alternative runtime and offers to re-run with that, maybe you need bigger ints, or maybe you only ship a 32-bit libcurl.dll.

The version() routine used by the above can also be called directly and returns a string:

<span style="color: #0000FF;">?<span style="color: #7060A8;">version<span style="color: #0000FF;">(<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- eg "0.8.0"

Normally only really useful for display, but you can of course break that down into an integer triplet with scanf(), as requires does, maybe something works on 0.7.7 and 0.7.9 but not 0.7.8.

Phix has a builtin abs() routine, which will be auto-included if referenced.

<span style="color: #000080;font-style:italic;">--include pmaths.e -- (an auto-include, ok but not needed)

--include complex.e -- (not an auto-include, needed if used)</span>

<span style="color: #0000FF;">?<span style="color: #7060A8;">call_func<span style="color: #0000FF;">(<span style="color: #000000;">r_abs<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #0000FF;">-<span style="color: #000000;">42<span style="color: #0000FF;">}<span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if

Using complex_abs() is probably closer to the task requirement in that if complex.e is not included it will not be found/called.<br>

In this case it happens to give exactly the same result, however under the hood it is first promoting the -42 to -42+0i before returning sqrt((-42)*(-42)+(0)*(0)).

normally hidden away out of sight in builtins\VM.

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins<span style="color: #0000FF;">/<span style="color: #000000;">VM<span style="color: #0000FF;">/<span style="color: #000000;">pStack<span style="color: #0000FF;">.<span style="color: #000000;">e</span> <span style="color: #000080;font-style:italic;">-- :%opGetST

-- copies from pglobals.e:</span>

<span style="color: #0000FF;">?<span style="color: #000000;">var_id<span style="color: #0000FF;">(<span style="color: #000000;">0<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- bloop+burp = 42</span>

<span style="color: #0000FF;">?<span style="color: #000000;">bloop<span style="color: #0000FF;">+<span style="color: #000000;">burp</span> <span style="color: #000080;font-style:italic;">-- "", doh

{{out}}

Other routines of interest include

<span style="color: #0000FF;">?<span style="color: #7060A8;">platform<span style="color: #0000FF;">(<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- WINDOWS=2, LINUX=3</span>

<span style="color: #0000FF;">?<span style="color: #7060A8;">machine_bits<span style="color: #0000FF;">(<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- 32 or 64</span>

<span style="color: #0000FF;">?<span style="color: #7060A8;">get_interpreter<span style="color: #0000FF;">(<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- eg "C:\Program Files (x86)\Phix\p.exe"

-- or perhaps "/home/pete/phix/p" on Linux

Phix supports the absolute bare minimum use of #ifdef, for compatibility with OpenEuphoria, however it is almost always better

=={{header|Phixmonti}}==

The program will not be executed if the variable or function has not been defined.

=={{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|Raku}}==

(formerly Perl 6)

if MY::{'$bloop'}.defined and CORE::{'&abs'}.defined { say abs $bloop }

my @ints = ($_ when Int for PROCESS::.values);

say "Number of PROCESS vars of type Int: ", +@ints;

{{out}}

<pre>123

=={{header|Raven}}==

if 'version >= 20071104 required' print bye

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

=={{header|Retro}}==

This will exit if the version is less than 2019.6:

The existence of functions can be checked using '''d:lookup'''. In this, a helper function is provided to improve readability.

Checks for existence of "bloop" and "n:abs"

'bloop 'n:abs [ find nip ] bi@ and

[ 'bloop executeByName 'n:abs executeByName ] if

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:

#0 #0 [ dup d:class fetch &class:integer eq? [ d:xt fetch + [ n:inc ] dip ] [ drop ] choose ] d:for-each

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>