Directive (programming)
In computer programming, a directive or pragma is a language construct that specifies how a compiler should process its input. Directives are not part of the grammar of a programming language, and may vary from compiler to compiler. They can be processed by a preprocessor to specify compiler behavior, or function as a form of in-band parameterization.
In some cases directives specify global behavior, while in other cases they only affect a local section, such as a block of programming code. In some cases, such as some C programs, directives are optional compiler hints, and may be ignored, but normally they are prescriptive, and must be followed. However, a directive does not perform any action in the language itself, but rather only a change in the behavior of the compiler.
This term could be used to refer to proprietary third party tags and commands embedded in code that result in additional executable processing that extend the existing compiler, assembler and language constructs present in the development environment. The term "directive" is also applied in a variety of ways that are similar to the term command.
The C preprocessor
In C and C++, the language supports a simple macro preprocessor. Source lines that should be handled by the preprocessor, such as#define and #include are referred to as preprocessor directives.Another C construct, the
#pragma directive, is used to instruct the compiler to use pragmatic or implementation-dependent features. Two notable users of this directive are OpenMP and OpenACC.Syntactic constructs similar to C's preprocessor directives, such as C#'s
#if, are also typically called "directives", although in these cases there may not be any real preprocessing phase involved.All preprocessor commands begin with a hash symbol.
History
Directives date to ALGOL 68, where they are known as , and denoted pragmat or pr; in newer languages, notably C, this has been abbreviated to "pragma".A common use of pragmats in ALGOL 68 is in specifying a stropping regime, meaning "how keywords are indicated". Various such directives follow, specifying the POINT, UPPER, RES, or quote regimes. Note the use of stropping for the pragmat keyword itself, either in the POINT or quote regimes:
.PR POINT.PR
.PR UPPER.PR
.PR RES.PR
'pr' quote 'pr'
Today directives are best known in the C language, of early 1970s vintage, and continued through the current C99 standard, where they are either instructions to the C preprocessor, or, in the form of
#pragma, directives to the compiler itself. They are also used to some degree in more modern languages; see below.Other languages
- In Ada, compiler directives are called pragmas.
- In Common Lisp, directives are called declarations, and are specified using the
declareconstruct. With one exception, declarations are optional, and do not affect the semantics of the program. The one exception isspecial, which must be specified where appropriate. - In Turbo Pascal, directives are called significant comments, because in the language grammar they follow the same syntax as comments. In Turbo Pascal, a significant comment is a comment whose first character is a dollar sign and whose second character is a letter; for example, the equivalent of C's
#include "file"directive is the significant comment. - In Perl, the keyword "
", which imports modules, can also be used to specify directives, such asuse strict;oruse utf8;. - Haskell pragmas are specified using a specialized comment syntax, e.g.
. - Python has two directives –
from __future__ import feature, which changes language features, and thecodingdirective to specify the encoding of a source code file. A more general directive statement was proposed and rejected in ; these all date to 2001. - ECMAScript also adopts the
usesyntax for directives, with the difference that pragmas are declared as string literals, rather than a function call. - In Visual Basic, the keyword "
Option" is used for directives: - *
Option Explicit On|Off- When on disallows implicit declaration of variables at first use requiring explicit declaration beforehand. - *
Option Compare Binary- Results in string comparisons based on a sort order derived from the internal binary representations of the characters - e.g. for the English/European code page A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø. Affects intrinsic operators, the Select Case block, and VB runtime library string functions. - *
Option Compare Text- Results in string comparisons based on a case-insensitive text sort order determined by your system's locale - e.g. for the English/European code page < < < < < <. Affects intrinsic operators, the Select Case block, and VB runtime library string functions. - *
Option Strict On|Off- When on disallows: - ** typeless programming - where declarations which lack an explicit type are implicitly typed as Object.
- ** late-binding on values statically typed as Object.
- ** implicit narrowing conversions - requiring all conversions to narrower types be explicit in code using conversion operators.
- *
Option Infer On|Off- When on enables the compiler to infer the type of local variables from their initializers. - In Ruby, interpreter directives are referred to as pragmas and are specified by top-of-file comments that follow a
key: valuenotation. For example,coding: UTF-8indicates that the file is encoded via the UTF-8 character encoding. - In C#, compiler directives are called pre-processing directives. There are a number of different compiler directives including #pragma, which is specifically used to control compiler warnings and debugger checksums.
Assembly language
- In assembly language, directives, also referred to as pseudo-operations or "pseudo-ops", generally specify such information as the target machine, mark separations between code sections, invoke macros, define reserved memory areas, and so on. Assemblers use a specific syntax to differentiate pseudo-ops from instruction mnemonics, such as prefacing the pseudo-op with a period, such as the pseudo-op
.END, which might direct the assembler to stop assembling code.PL/SQL
- Oracle Corporation's PL/SQL procedural language includes a set of compiler directives, known as "pragmas".