Pragmatic directives: Difference between revisions

* <code>ifdef</code>/<code>ifndef</code>/<code>else</code>/<code>endif</code>: The assembler will skip anything inside an IFDEF block if the designated label wasn't defined. IFNDEF and ELSE are the opposite. To make an IFDEF statement true, you only need to have that label defined in your source. (The value doesn't matter as long as it appears.) Here's an example:

ifdef NMOS_6502

txa

else

phx ;NMOS_6502 doesn't have this instruction.

* <code>db</code>/<code>dw</code>/<code>byte</code>/<code>word</code>: Defines a data block. The assembler treats these values as arbitrary bytes rather than machine instructions. Used for tables of values, etc.

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.3.5 algol68g-2.3.5] - most compiler directives are permitted as '''pragma'''s options - also ' '''pr''' read "filename.a68" '''pr''' ' is permitted to "include" a file.}}

{{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 implementation specific PRAGMA.}}

PRAGMAT portcheck PRAGMAT

PROC (REAL)REAL s = sin();

<pre>

10 PROC (REAL)REAL s = sin();

{{works with|GWBASIC}}

'''

'''

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

==={{header|QBasic}}===

TROFF : REM deactivate system trace pragma

REM QBasic debugging features make these instructions unnecessary

=={{header|C}}==

The C Preprocessor is well explained on the [https://gcc.gnu.org/onlinedocs/cpp/index.html#Top GNU] site. The pragma page is [https://gcc.gnu.org/onlinedocs/cpp/Pragmas.html here].

/*Almost every C program has the below line,

the #include preprocessor directive is used to

/*Enlightened ?*/

On compilation and output, the compiler type is detected rather than the actual OS :

<pre>

Go has a feature called [http://golang.org/pkg/go/build/#overview build constraints] that work on the level of whole files. A comment line reading

will cause the entire file to be excluded from a build unless <expression> is true. The elements, called tags, in the expression are typically things like the target operating system or hardware architecture. For example

will include the file if the target OS is linux, but will exclude the file otherwise. Arbitrary tags can be passed on the command line of the go command. A file could begin

and the build command

would only include the file on Tuesdays.

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

Icon and Unicon have a number of pragmatic modes. Most of these are controlled via keywords (See [[Special_variables#Icon_and_Unicon]])).

Additionally, tracing can be controlled via the environment variable 'TRACE'.

For example,

disables access to the file system (and disables some other features, including the ability to exit the program, because the system exit mechanism is a system feature and thus not trusted). You cannot turn this off after it has been turned on (so you will need to shut down J and start it again if you want to use those features).

Or, for example, y is the usual name for the right argument of a verb.

But y is also a regular variable. So J also offers a reserved word y. which serves the same role. But this is disabled by default (because mostly it's just an unnecessary complication).

But you can enable the reserved word mechanism:

3 :'y.' 8

8

8

3 :'y.]y=.7' 8

=={{header|Julia}}==

Julia has a number of macros which act as compiler directives. For example, the <code>@inbounds</code> macro disables runtime checking of array bounds within a block of code marked by this macro, which sometimes improves performance. Example:

y = rand(100, 100)

end

end

=={{header|Kotlin}}==

The closest things which Kotlin has to pragmatic directives are annotations which always begin with the @ character. For example, the following code would normally produce a compiler warning that the variable 's' is never used. However, the presence of the @Suppress annotation suppresses the warning:

@Suppress("UNUSED_VARIABLE")

fun main(args: Array<String>) {

val s = "To be suppressed"

=={{header|Lua}}==

Lua itself really doesn't have anything equivalent. However, if being used in a mixed/hosted/embedded environment, the <code>ffi</code> library might be encountered, which supports <code>pragma pack</code> to facilitate native type interchange:

ffi.cdef[[

#pragma pack(1)

]]

print(ffi.sizeof(ffi.new("foo")))

{{out}}

<pre>5

NetRexx provides three pragma-like instructions: <tt>OPTIONS</tt>, <tt>NUMERIC</tt> and <tt>TRACE</tt>.

* '''<tt>OPTIONS</tt>''' provides the ability to pass special requests to the language processor (i.e. a compiler or interpreter).

:where ''wordlist'' is one or more symbols separated by blanks. The individual words in ''wordlist'' might control optimizations, enforce standards, enable implementation-dependent features, etc.

nobinary nocomments nocompact console crossref decimal nodiag noexplicit noformat java logo noreplace nosavelog nosourcedir -

* '''<tt>NUMERIC</tt>''' is used to change the way in which arithmetic operations are carried out by a program.

:*'''<tt>numeric digits</tt>''' controls the precision under which arithmetic operations will be evaluated. The default for ''exprd'' is '''9''' i.e. '''<tt>numeric digits 9</tt>'''.<br />There is normally no limit to the value for <tt>'''numeric digits'''</tt> (except the constraints imposed by the amount of storage and other resources available) but note that high precisions are likely to be expensive in processing time.

:*'''<tt>numeric form</tt>''' controls which form of exponential notation is to be used for the results of operations.

* '''<tt>TRACE</tt>''' is used to control the tracing of the execution of NetRexx methods, and is primarily used for debugging.

:where ''tracesetting'' is one of:

:*'''<tt>all</tt>'''

And here are some examples:

# Define a type Color as pure which implies that value names are declared in their own scope

...

{.pop.}

=={{header|Perl}}==

Pragmatic modules have local scope and are utilized using the use directive:

To disable behaviour of a pragmatic module:

=={{header|Phix}}==

While technically code rather than a directive, the requires() builtin can hopefully avoid fruitless efforts to run something where it is simply never going to work, eg

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #004600;">JS</span><span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">--requires(WINDOWS) -- (one of only, or

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span>

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

=={{header|PicoLisp}}==

an array.

For example:

i=101;

will cause unpredictible results.

And :

declare (t(100),i) fixed binary;

i=101;

t(i)=0;

will issue the message : "The SubscriptRange condition was raised." at execution time.

<br>Or, it can be handle by an on-unit.

declare (t(100),i) fixed binary;

i=101;

t(i)=0;

e:on SubscriptRange system; /* default dehaviour */

<br>And the same way for a string,

the '''StringRange''' condition is raised when a substring reference is beyond

You can use #Requires statements in any script. You cannot use them in

functions, cmdlets, or snap-ins.

#Requires -Version <N>[.<n>]

#Requires –PSSnapin <PSSnapin-Name> [-Version <N>[.<n>]]

#Requires –ShellId <ShellId>

#Requires -RunAsAdministrator

For a full description:

Get-Help about_Requires

=={{header|Python}}==

;Python 3.2:

Type "copyright", "credits" or "license()" for more information.

>>> import __future__

>>> __future__.all_feature_names

['nested_scopes', 'generators', 'division', 'absolute_import', 'with_statement', 'print_function', 'unicode_literals', 'barry_as_FLUFL']

('barry_as_FLUFL' is an April fools [http://www.python.org/dev/peps/pep-0401/ joke])

;Python 2.7:

Type "copyright", "credits" or "license()" for more information.

>>> import __future__

>>> __future__.all_feature_names

['nested_scopes', 'generators', 'division', 'absolute_import', 'with_statement', 'print_function', 'unicode_literals']

=={{header|Racket}}==

{{works with|rakudo|2015-10-20}}

The Perl 6 pragma mechanism is nearly identical to Perl 5's, piggybacking on the notation for importing modules (pragmas are distinguished by case from normal modules, which are generally of mixed case). By convention pragmas are lowercase, unless they are indicating the use of an unsafe feature, in which case they are in all caps.

augment class Int {

method times (&what) { what() xx self } # pretend like we're Ruby

Unlike Perl 5, there is no <tt>use strict;</tt> pragma, however, since Perl 6 is strict by default. Importation of a pragma is lexically scoped as in Perl 5, but note that unlike in Perl 5, <i>all</i> importation is lexical in Perl 6, so pragmas are not special that way.

=={{header|Scala}}==

===tailrec===

=={{header|Tcl}}==

Pragmatic directives remain effective, until they are deactivated, or the end of the script is reached:

=={{header|Wren}}==

Import statements can appear anywhere a variable declaration is allowed and in particular within conditional structures. This enables us to do things such as the following:

class Windows {

static message { "Using Windows" }

static lineSeparator { "\\r\\n" }

class Linux {

static message { "Using Linux" }

static lineSeparator { "\\n" }

import "os" for Platform

os = Linux

}

{{out}}