text:
Ada Programming/Attributes/'Model Mantissa

Description
Model number version of S’Machine_Mantissa.

Yields the largest value of p such that every value expressible in the canonical form (for the type T), having a p-digit mantissa and an exponent between T'Machine_Emin and T'Machine_Emax, is a machine number of the type T. This attribute yields a value of the type universal_integer.


text:
Ada Programming/Attributes/'Model Small

Description
Smallest positive model number of subtype.

Yields the value T 'Machine_RadixT 'Model_Emin – 1. The value of this attribute is of the type universal_real.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

title: Ada Programming/Attributes/'Model Small


text:
Ada Programming/Attributes/'Old

Description
The value of X on entry, has same type as X.

Each X'Old in a postcondition expression that is enabled, other than those that occur in subexpressions that are determined to be unevaluated, denotes a constant that is implicitly declared at the beginning of the subprogram body, entry body, or accept statement.

title: Ada Programming/Attributes/'Old


text:
Ada Programming/Attributes/'Output

Description
Writes the value of X to Stream, including any bounds or discriminants.

title: Ada Programming/Attributes/'Output


text:
Ada Programming/Attributes/'Overlaps Storage

Description
Returns True if the representation of X2 shares at least one bit with the representation of the object denoted by X.

The actual parameter shall be a name that denotes an object. The object denoted by the actual parameter can be of any type. This function evaluates the names of the objects involved and returns True if the representation of the object denoted by the actual parameter shares at least one bit with the representation of the object denoted by X; otherwise, it returns False.


text:
Ada Programming/Attributes/'Partition ID

Description
Identifies the partition in which D was elaborated.

Denotes a value of the type universal_integer that identifies the partition in which D was elaborated. If D denotes the declaration of a remote call interface library unit the given partition is the one where the body of D was elaborated.


text:
Ada Programming/Attributes/'Priority

Description
Returns the priority of P.

Denotes a non-aliased component of the protected object P. This component is of type System.Any_Priority and its value is the priority of P. P'Priority denotes a variable if and only if P denotes a variable. A reference to this attribute shall appear only within the body of P.

title: Ada Programming/Attributes/'Priority


text:
Ada Programming/Attributes/'Read

Description
Reads the value of X from Stream.

title: Ada Programming/Attributes/'Read


text:
Ada Programming/Attributes/'Result

Description
Within a postcondition expression for F, denotes the return object of the function call for which the postcondition expression is evaluated.

Within a postcondition expression for F, denotes the return object of the function call for which the postcondition expression is evaluated. The type of this attribute is that of the result subtype of the function or access-to-function type except within a Post'Class postcondition expression for a function with a controlling result or with a controlling access result; in those cases the type of the attribute is described above as part of the Name Resolution Rules for Post'Class.

title: Ada Programming/Attributes/'Result


text:
Ada Programming/Attributes/'Round

Description
Fixed-point value obtained by rounding X (away from 0, if X is midway between two values).

The function returns the value obtained by rounding X (away from 0, if X is midway between two values of the type of S).

title: Ada Programming/Attributes/'Round


text:
Ada Programming/Attributes/'Safe First

Description
Returns lower bound of the safe range.

Yields the lower bound of the safe range (see 3.5.7) of the type T. If the Numerics Annex is not supported, the value of this attribute is implementation defined.

The value of this attribute is of the type universal_real.

title: Ada Programming/Attributes/'Safe First


text:
Ada Programming/Attributes/'Safe Last

Description
Returns upper bound of the safe range.

Yields the upper bound of the safe range (see 3.5.7) of the type T. If the Numerics Annex is not supported, the value of this attribute is implementation defined. The value of this attribute is of the type universal_real.

title: Ada Programming/Attributes/'Safe Last


text:
Ada Programming/Attributes/'Scale

Description
Position of the fixed-point relative to the rightmost significant digits of values of subtype S.

S'Scale denotes the scale of the subtype S, defined as the value N such that S'Delta = 10.0**(–N). The scale indicates the position of the point relative to the rightmost significant digits of values of subtype S. The value of this attribute is of the type universal_integer.

title: Ada Programming/Attributes/'Scale


text:
Ada Programming/Attributes/'Scaling

Description
Scaling by a power of the hardware radix.

Let v be the value X · T 'Machine_RadixAdjustment. If v is a machine number of the type T, or if |v| ≥ T 'Model_Small, the function yields v; otherwise, it yields either one of the machine numbers of the type T adjacent to v. Constraint_Error is optionally raised if v is outside the base range of S. A zero result has the sign of X when S'Signed_Zeros is True.

title: Ada Programming/Attributes/'Scaling


text:
Ada Programming/Attributes/'Signed Zeros

Description
True if positive and negative signed zeros are representable.

Yields the value True if the hardware representation for the type T has the capability of representing both positively and negatively signed zeros, these being generated and used by the predefined operations of the type T as specified in IEC 559:1989; yields the value False otherwise. The value of this attribute is of the predefined type Boolean.


text:
Ada Programming/Attributes/'Small

Description
Small of the fixed-point type.

S'Small denotes the small of the type of S. The value of this attribute is of the type universal_real.

title: Ada Programming/Attributes/'Small


text:
Ada Programming/Attributes/'Storage Pool

Description
Returns Storage pool of the access subtype.

Denotes the storage pool of the type of S. The type of this attribute is Root_Storage_Pool'Class.


text:
Ada Programming/Attributes/'Storage Size

Description
Number of storage elements reserved for the storage pool.

Denotes the number of storage elements reserved for the task. The value of this attribute is of the type universal_integer. The Storage_Size includes the size of the task's stack, if any. The language does not specify whether or not it includes other storage associated with the task (such as the “task control block” used by some implementations.)


text:
Ada Programming/Attributes/'Stream Size

Description
Number of bits read from or written to a stream by the default implementations of S’Read and S’Write.

If S is definite, denotes the size (in bits) that the implementation would choose for the following objects of subtype S:

 * A record component of subtype S when the record type is packed.
 * The formal parameter of an instance of Unchecked_Conversion that converts from subtype S to some other subtype.

If S is indefinite, the meaning is implementation defined. The value of this attribute is of the type universal_integer.

title: Ada Programming/Attributes/'Stream Size


text:
Ada Programming/Attributes/'Unchecked Access

Description
Same as X’Access but lacks accessibility rules/checks.

All rules and semantics that apply to X'Access apply also to X'Unchecked_Access, except that, for the purposes of accessibility rules and checks, it is as if X were declared immediately within a library package.


text:
Ada Programming/Attributes/'Version

Description
Yields string that identifies the version of the compilation unit that contains the declaration of the program unit.

title: Ada Programming/Attributes/'Version


text:
Ada Programming/Attributes/'Wide Image

Description
Image of the value of X as a Wide_String.

S'Wide_Image calls S'Put_Image passing Arg (which will typically store a sequence of character values in a text buffer) and then returns the result of retrieving the contents of that buffer with function Wide_Get.

X'Wide_Image denotes the result of calling function S'Wide_Image with Arg being X, where S is the nominal subtype of X (Ada 2022).

title: Ada Programming/Attributes/'Wide Image


text:
Ada Programming/Attributes/'Wide Value

Description
Returns a value given an image of the value as a Wide_String argument (X).

This function returns a value given an image of the value as a Wide_String, ignoring any leading or trailing spaces.

title: Ada Programming/Attributes/'Wide Value


text:
Ada Programming/Attributes/'Wide Wide Image

Description
Image of the value of X as a Wide_Wide_String.

S'Wide_Wide_Image calls S'Put_Image passing Arg (which will typically store a sequence of character values in a text buffer) and then returns the result of retrieving the contents of that buffer with function Wide_Wide_Get.

X'Wide_Wide_Image denotes the result of calling function S'Wide_Wide_Image with Arg being X, where S is the nominal subtype of X (Ada 2022).


text:
Ada Programming/Attributes/'Wide Wide Value

Description
Returns a value given an image of the value as a Wide_Wide_String argument (X).

This function returns a value given an image of the value as a Wide_Wide_String, ignoring any leading or trailing spaces.


text:
Ada Programming/Attributes/'Wide Wide Width

Description
Maximum length of Wide_Wide_String returned by S’Image.

S'Wide_Wide_Width denotes the maximum length of a Wide_Wide_String returned by S'Wide_Wide_Image over all values of the subtype S, assuming a default implementation of S'Put_Image. It denotes zero for a subtype that has a null range. Its type is universal_integer.


text:
Ada Programming/Attributes/'Wide Width

Description
Maximum length of Wide_String returned by S’Image.

S'Wide_Width denotes the maximum length of a Wide_String returned by S'Wide_Image over all values of the subtype S, assuming a default implementation of S'Put_Image. It denotes zero for a subtype that has a null range. Its type is universal_integer

title: Ada Programming/Attributes/'Wide Width


text:
Ada Programming/Attributes/'Write

Description
Writes X to Stream.

title: Ada Programming/Attributes/'Write


text:
Ada Programming/Attributes/'Parallel Reduce

Description
Reduction expression that yields a result equivalent to replacing the attribute identifier with Reduce and the prefix of the attribute with the value_sequence.

X'Parallel_Reduce is a reduction expression that yields a result equivalent to replacing the attribute identifier with Reduce and the prefix of the attribute with the value_sequence:

[parallel for Item of X => Item]


text:
Ada Programming/Attributes/'Preelaborate Initialization

Description
Returns whether the type of S has preelaborable initialization.

For a nonformal composite subtype S declared within the visible part of a package or a generic package, or a generic formal private subtype or formal derived subtype:

This attribute is of Boolean type, and its value reflects whether the type of S has preelaborable initialization.


text:
Ada Programming/Attributes/'Put Image

Description
Writes an image of the value of X.

title: Ada Programming/Attributes/'Put Image


text:
Ada Programming/Attributes/'Reduce

Description
This attribute represents a reduction expression, and is in the form of a reduction_attribute_reference.

title: Ada Programming/Attributes/'Reduce


text:
Ada Programming/Attributes/'Relative Deadline

Description
Relative deadline of P.

Denotes a non-aliased component of the protected object P. This component is of type Ada.Real_Time.Time_Span and its value is the relative deadline of P. P'Relative_Deadline denotes a variable if and only if P denotes a variable. A reference to this attribute shall appear only within the body of P.


text:
Ada Programming/Attributes/'Abort Signal

Description
Provides the entity for the special exception used to signal task abort or asynchronous transfer of control. Normally this attribute should only be used in the tasking runtime (it is highly peculiar, and completely outside the normal semantics of Ada, for a user program to intercept the abort exception).

Example
( is the only allowed prefix).


text:
Ada Programming/Attributes/'Address Size

Description
Is a static constant giving the number of bits in an. It is the same value as System.Address’Size, but has the advantage of being static, while a direct reference to System.Address’Size is nonstatic because Address is a private type.

Example
( is the only allowed prefix)


text:
Ada Programming/Attributes/'Asm Input

Description
The  attribute denotes a function that takes two parameters. The first is a string, the second is an expression of the type designated by the prefix. The first (string) argument is required to be a static expression, and is the constraint for the parameter, (e.g., what kind of register is required). The second argument is the value to be used as the input argument. The possible values for the constant are the same as those used in the RTL, and are dependent on the configuration file used to built the GCC back end.

title: Ada Programming/Attributes/'Asm Input


text:
Ada Programming/Attributes/'Asm Output

Description
The  attribute denotes a function that takes two parameters. The first is a string, the second is the name of a variable of the type designated by the attribute prefix. The first (string) argument is required to be a static expression and designates the constraint for the parameter (e.g., what kind of register is required). The second argument is the variable to be updated with the result. The possible values for constraint are the same as those used in the RTL, and are dependent on the configuration file used to build the GCC back end. If there are no output operands, then this argument may either be omitted, or explicitly given as.

title: Ada Programming/Attributes/'Asm Output


text:
Ada Programming/Attributes/'Bit

Description
, where  is any object, yields the bit offset within the storage unit (byte) that contains the first bit of storage allocated for the object. The value of this attribute is of the type universal_integer and is always a nonnegative number smaller than.

For an object that is a variable or a constant allocated in a register, the value is zero. (The use of this attribute does not force the allocation of a variable to memory).

For an object that is a formal parameter, this attribute applies to either the matching actual parameter or to a copy of the matching actual parameter.

For an access object the value is zero. Note that  is subject to an   for the designated object. Similarly for a record component  is subject to a discriminant check and   and   are subject to index checks.

This attribute is designed to be compatible with the DEC Ada 83 definition and implementation of the  attribute.

title: Ada Programming/Attributes/'Bit


text:
Ada Programming/Attributes/'Bit Position

Description
, where  is a record object and   is one of the fields of the record type, yields the bit offset within the record contains the first bit of storage allocated for the object. The value of this attribute is of the type universal_integer. The value depends only on the field  and is independent of the alignment of the containing record.


text:
Ada Programming/Attributes/'Code Address

Description
The  attribute may be applied to subprograms in Ada 95 and Ada 2005, but the intended effect seems to be to provide an address value which can be used to call the subprogram by means of an address clause as in the following example: A call to   is then expected to result in a call to. In Ada 83, where there were no access-to-subprogram values, this was a common work-around for getting the effect of an indirect call. GNAT implements the above use of  and the technique illustrated by the example code works correctly.

However, for some purposes, it is useful to have the address of the start of the generated code for the subprogram. On some architectures, this is not necessarily the same as the  value described above. For example, the  value may reference a subprogram descriptor rather than the subprogram itself.

The  attribute, which can only be applied to subprogram entities, always returns the address of the start of the generated code of the specified subprogram, which may or may not be the same value as is returned by the corresponding   attribute.


text:
Ada Programming/Attributes/'Compiler Version

Description
( is the only allowed prefix) yields a static string identifying the version of the compiler being used to compile the unit containing the attribute reference.


text:
Ada Programming/Attributes/'Default Bit Order

Description
( is the only allowed prefix), provides the value   as a   value (0 for , 1 for  ). This is used to construct the definition of  in package.


text:
Ada Programming/Attributes/'Elaborated

Description
The prefix of the  attribute must be a unit name. The value is a Boolean which indicates whether or not the given unit has been elaborated. This attribute is primarily intended for internal use by the generated code for dynamic elaboration checking, but it can also be used in user programs. The value will always be True once elaboration of all units has been completed. An exception is for units which need no elaboration, the value is always False for such units.

title: Ada Programming/Attributes/'Elaborated


text:
Ada Programming/Attributes/'Elab Body

Description
This attribute can only be applied to a program unit name. It returns the entity for the corresponding elaboration procedure for elaborating the body of the referenced unit. This is used in the main generated elaboration procedure by the binder and is not normally used in any other context. However, there may be specialized situations in which it is useful to be able to call this elaboration procedure from Ada code, e.g., if it is necessary to do selective re-elaboration to fix some error.

title: Ada Programming/Attributes/'Elab Body


text:
Ada Programming/Attributes/'Elab Spec

This attribute can only be applied to a program unit name. It returns the entity for the corresponding elaboration procedure for elaborating the spec of the referenced unit. This is used in the main generated elaboration procedure by the binder and is not normally used in any other context. However, there may be specialized situations in which it is useful to be able to call this elaboration procedure from Ada code, e.g., if it is necessary to do selective re-elaboration to fix some error.

title: Ada Programming/Attributes/'Elab Spec


text:
Ada Programming/Attributes/'Emax

Description
The  attribute is provided for compatibility with Ada 83. See the Ada 83 reference manual for an exact description of the semantics of this attribute.

title: Ada Programming/Attributes/'Emax


text:
Ada Programming/Attributes/'Enabled

Description
The  attribute allows an application program to check at compile time to see if the designated check is currently enabled. The prefix is a simple identifier, referencing any predefined check name (other than ) or a check name introduced by pragma Check_Name. If no argument is given for the attribute, the check is for the general state of the check, if an argument is given, then it is an entity name, and the check indicates whether an  or   has been given naming the entity (if not, then the argument is ignored).

Note that instantiations inherit the check status at the point of the instantiation, so a useful idiom is to have a library package that introduces a check name with, and then contains generic packages or subprograms which use the   attribute to see if the check is enabled. A user of this package can then issue a  or   before instantiating the package or subprogram, controlling whether the check will be present.

title: Ada Programming/Attributes/'Enabled


text:
Ada Programming/Attributes/'Epsilon

Description
The  attribute is provided for compatibility with Ada 83. See the Ada 83 reference manual for an exact description of the semantics of this attribute.

title: Ada Programming/Attributes/'Epsilon


text:
Ada Programming/Attributes/'Fixed Value

Description
For every fixed-point type,   denotes a function with the following specification: The value returned is the fixed-point value   such that: The effect is thus similar to first converting the argument to the integer type used to represent  , and then doing an unchecked conversion to the fixed-point type. The difference is that there are full range checks, to ensure that the result is in range. This attribute is primarily intended for use in implementation of the input-output functions for fixed-point values.

title: Ada Programming/Attributes/'Fixed Value


text:
Ada Programming/Attributes/'Has Access Values

Description
The prefix of the  attribute is a type. The result is a Boolean value which is True if the is an access type, or is a composite type with a component (at any nesting depth) that is an access type, and is False otherwise. The intended use of this attribute is in conjunction with generic definitions. If the attribute is applied to a generic private type, it indicates whether or not the corresponding actual type has access values.


text:
Ada Programming/Attributes/'Has Discriminants

Description
The prefix of the  attribute is a type. The result is a Boolean value which is True if the type has discriminants, and False otherwise. The intended use of this attribute is in conjunction with generic definitions. If the attribute is applied to a generic private type, it indicates whether or not the corresponding actual type has discriminants.


text:
Ada Programming/Attributes/'Img

Description
The  attribute differs from   in that, while both can be applied directly to an object,   cannot be applied to types.

Example usage of the attribute: which has the same meaning as the more verbose: where  is the (sub)type of the object.

Note that technically, in analogy to,   returns a parameterless function that returns the appropriate string when called. This means that  can be renamed as a function-returning-string, or used in an instantiation as a function parameter.

title: Ada Programming/Attributes/'Img


text:
Ada Programming/Attributes/'Integer Value

Description
For every integer type,   denotes a function with the following spec: The value returned is the integer value  , such that: where   is the type of. The effect is thus similar to first doing an unchecked conversion from the fixed-point type to its corresponding implementation type, and then converting the result to the target integer type. The difference is that there are full range checks, to ensure that the result is in range. This attribute is primarily intended for use in implementation of the standard input-output functions for fixed-point values.


text:
Ada Programming/Attributes/'Invalid Value

Description
For every scalar type S, S’Invalid_Value returns an undefined value of the type. If possible this value is an invalid representation for the type. The value returned is identical to the value used to initialize an otherwise uninitialized value of the type if pragma Initialize_Scalars is used, including the ability to modify the value with the binder -Sxx flag and relevant environment variables at run time.


text:
Ada Programming/Attributes/'Machine Size

Description
This attribute is identical to the  attribute. It is provided for compatibility with the DEC Ada 83 attribute of this name.


text:
Ada Programming/Attributes/'Maximum Alignment

Description
( is the only allowed prefix) provides the maximum useful alignment value for the target. This is a static value that can be used to specify the alignment for an object, guaranteeing that it is properly aligned in all cases.


text:
Ada Programming/Attributes/'Mechanism Code

Description
yields an integer code for the mechanism used for the result of function, and   yields the mechanism used for formal parameter number n (a static integer value, with 1 meaning the first parameter) of subprogram. The code returned is:

 * 1
 * by copy (value)

 * 2
 * by reference


text:
Ada Programming/Attributes/'Null Parameter

Description
A reference  denotes an imaginary object of type or subtype   allocated at machine address zero. The attribute is allowed only as the default expression of a formal parameter, or as an actual expression of a subprogram call. In either case, the subprogram must be imported.

The identity of the object is represented by the address zero in the argument list, independent of the passing mechanism (explicit or default).

This capability is needed to specify that a zero address should be passed for a record or other composite object passed by reference. There is no way of indicating this without the  attribute.


text:
Ada Programming/Attributes/'Object Size

Description
The size of an object is not necessarily the same as the size of the type of an object. This is because by default object sizes are increased to be a multiple of the alignment of the object. For example,  is 31, but by default objects of type   will have a size of 32 bits. Similarly, a record containing an integer and a character: will have a size of 40 (that is  will be 40). The alignment will be 4, because of the integer field, and so the default size of record objects for this type will be 64 (8 bytes).

If the alignment of the above record is specified to be 1, then the object size will be 40 (5 bytes). This is true by default, and also an object size of 40 can be explicitly specified in this case.

A consequence of this capability is that different object sizes can be given to subtypes that would otherwise be considered in Ada to be statically matching. But it makes no sense to consider such subtypes as statically matching. Consequently, GNAT adds a rule to the static matching rules that requires object sizes to match. Consider this example: In the absence of lines 5 and 6, types  and   statically match and hence the conversion on line 12 is legal. But since lines 5 and 6 cause the object sizes to differ, GNAT considers that types  and   are not statically matching, and line 12 generates the diagnostic shown above.

Similar additional checks are performed in other contexts requiring statically matching subtypes.

title: Ada Programming/Attributes/'Object Size


text:
Ada Programming/Attributes/'Passed By Reference

Description
for any subtype returns a value of type   value that is   if the type is normally passed by reference and   if the type is normally passed by copy in calls. For scalar types, the result is always  and is static. For non-scalar types, the result is nonstatic.


text:
Ada Programming/Attributes/'Pool Address

Description
for any object  returns the address of X within its storage pool. This is the same as, except that for an unconstrained array whose bounds are allocated just before the first component,   returns the address of those bounds, whereas   returns the address of the first component.

Here, we are interpreting ‘storage pool’ broadly to mean, which could be a user-defined storage pool, the global heap, on the stack, or in a static memory area. For an object created by,   is what is passed to   and returned from.


text:
Ada Programming/Attributes/'Range Length

Description
for any discrete type yields the number of values represented by the subtype (zero for a null range). The result is static for static subtypes. applied to the index subtype of a one dimensional array always gives the same result as  applied to the array itself.


text:
Ada Programming/Attributes/'Storage Unit

Description
( is the only allowed prefix) provides the same value as.


text:
Ada Programming/Attributes/'Stub Type

Description
The GNAT implementation of remote access-to-classwide types is organized as described in AARM section E.4 (20.t): a value of an RACW type (designating a remote object) is represented as a normal access value, pointing to a “stub” object which in turn contains the necessary information to contact the designated remote object. A call on any dispatching operation of such a stub object does the remote call, if necessary, using the information in the stub object to locate the target partition, etc.

For a prefix  that denotes a remote access-to-classwide type,   denotes the type of the corresponding stub objects.

By construction, the layout of  is identical to that of type   declared in the internal implementation-defined unit. Use of this attribute will create an implicit dependency on this unit.

title: Ada Programming/Attributes/'Stub Type


text:
Ada Programming/Attributes/'Target Name

Description
( is the only allowed prefix) provides a static string value that identifies the target for the current compilation. For GCC implementations, this is the standard gcc target name without the terminating slash (for example, GNAT 5.0 on windows yields “i586-pc-mingw32msv”).

title: Ada Programming/Attributes/'Target Name


text:
Ada Programming/Attributes/'Type Class

Description
for any type or subtype yields the value of the type class for the full type of. If is a generic formal type, the value is the value for the corresponding actual subtype. The value of this attribute is of type, which has the following definition: Protected types yield the value  , which thus applies to all concurrent types. This attribute is designed to be compatible with the DEC Ada 83 attribute of the same name.

title: Ada Programming/Attributes/'Type Class


text:
Ada Programming/Attributes/'Type Key

Description
The  attribute is applicable to a type or subtype and yields a value of type Standard.String containing encoded information about the type or subtype. This provides improved compatibility with other implementations that support this attribute.

title: Ada Programming/Attributes/'Type Key


text:
Ada Programming/Attributes/'Unconstrained Array

Description
The  attribute can be used with a prefix that denotes any type or subtype. It is a static attribute that yields  if the prefix designates an unconstrained array, and   otherwise. In a generic instance, the result is still static, and yields the result of applying this test to the generic actual.


text:
Ada Programming/Attributes/'Universal Literal String

Description
The prefix of  must be a named number. The static result is the string consisting of the characters of the number as defined in the original source. This allows the user program to access the actual text of named numbers without intermediate conversions and without the need to enclose the strings in quotes (which would preclude their use as numbers).

For example, the following program prints the first 50 digits of pi:


text:
Ada Programming/Attributes/'Unrestricted Access

Description
The  attribute is similar to   except that all accessibility and aliased view checks are omitted. This is a user-beware attribute.

For objects, it is similar to, for which it is a desirable replacement where the value desired is an access type. In other words, its effect is similar to first applying the  attribute and then doing an unchecked conversion to a desired access type.

For subprograms,  may be used where   would be illegal, to construct a value of a less-nested named access type that designates a more-nested subprogram. This value may be used in indirect calls, so long as the more-nested subprogram still exists; once the subprogram containing it has returned, such calls are erroneous. For example: When P1 is called from P2, the call via Global is OK, but if P1 were called after P2 returns, it would be an erroneous use of a dangling pointer.

For objects, it is possible to use  for any type. However, if the result is of an access-to-unconstrained array subtype, then the resulting pointer has the same scope as the context of the attribute, and must not be returned to some enclosing scope. For instance, if a function uses  to create an access-to-unconstrained-array and returns that value to the caller, the result will involve dangling pointers. In addition, it is only valid to create pointers to unconstrained arrays using this attribute if the pointer has the normal default ‘fat’ representation where a pointer has two components, one points to the array and one points to the bounds. If a size clause is used to force ‘thin’ representation for a pointer to unconstrained where there is only space for a single pointer, then the resulting pointer is not usable.

In the simple case where a direct use of Unrestricted_Access attempts to make a thin pointer for a non-aliased object, the compiler will reject the use as illegal, as shown in the following example: but other cases cannot be detected by the compiler, and are considered to be erroneous. Consider the following example: A normal unconstrained array value or a constrained array object marked as aliased has the bounds in memory just before the array, so a thin pointer can retrieve both the data and the bounds. But in this case, the non-aliased object  does not have the bounds before the string. If the size clause for type  were not present, then the pointer would be a fat pointer, where one component is a pointer to the bounds, and all would be well. But with the size clause present, the conversion from fat pointer to thin pointer in the call loses the bounds, and so this is erroneous, and the program likely raises a  exception.

In general, it is advisable to completely avoid mixing the use of thin pointers and the use of  where the designated type is an unconstrained array. The use of thin pointers should be restricted to cases of porting legacy code that implicitly assumes the size of pointers, and such code should not in any case be using this attribute.

Another erroneous situation arises if the attribute is applied to a constant. The resulting pointer can be used to access the constant, but the effect of trying to modify a constant in this manner is not well-defined. Consider this example: Here we attempt to modify the constant P from 4 to 3, but the compiler may or may not notice this attempt, and subsequent references to P may yield either the value 3 or the value 4 or the assignment may blow up if the compiler decides to put P in read-only memory. One particular case where  can be used in this way is to modify the value of an   parameter: In general this is a risky approach. It may appear to “work” but such uses of  are potentially non-portable, even from one version of GNAT to another, so are best avoided if possible.


text:
Ada Programming/Attributes/'VADS Size

Description
The  attribute is intended to make it easier to port legacy code which relies on the semantics of   as implemented by the VADS Ada 83 compiler. GNAT makes a best effort at duplicating the same semantic interpretation. In particular,  applied to a predefined or other primitive type with no Size clause yields the Object_Size (for example,   is 32 rather than 31 on typical machines). In addition  applied to an object gives the result that would be obtained by applying the attribute to the corresponding type.

title: Ada Programming/Attributes/'VADS Size


text:
Ada Programming/Attributes/'Value Size

Description
is the number of bits required to represent a value of the given subtype. It is the same as, but, unlike  , may be set for non-first subtypes.

title: Ada Programming/Attributes/'Value Size


text:
Ada Programming/Attributes/'Wchar T Size

Description
( is the only allowed prefix) provides the size in bits of the C   type primarily for constructing the definition of this type in package. The result is a static constant.


text:
Ada Programming/Attributes/'Word Size

Description
( is the only allowed prefix) provides the value. The result is a static constant.

title: Ada Programming/Attributes/'Word Size


text:
Character Encodings/Code Tables/EBCDIC/EBCDIC 1300

IBM code page 1300 (CCSID 1300) is an EBCDIC code page used in IBM mainframes. It is called Generic Bar Code/OCR-B.

Codepage layout
Characters are shown with their equivalent Unicode codes.

 * Bar code symbol, not in Unicode.
 * Zero with a slash.


text:
Character Encodings/Code Tables/EBCDIC/EBCDIC 1301

IBM code page 1301 (CCSID 1301) is an EBCDIC code page used in IBM mainframes. It is called Zip + 4 Postnet Bar Code.

 * Mail bar code symbol, not in Unicode.


text:
Character Encodings/Code Tables/EBCDIC/EBCDIC 1302

IBM code page 1302 (CCSID 1302) is an EBCDIC code page used in IBM mainframes. It is called Facing Identification Marks.

 * Facing identification mark, not in Unicode.


text:
Template:Ada/2022

This language feature has been introduced in Ada 2022. /Ada 2022 feature Ada:2022

title: Template:Ada/2022


text:
Category:Book:Ada Programming/Ada 2022 feature

|Ada programming language -> |Ada Programming-> Ada 2022-> Ada 2022 feature

Ada Programming modules containing references to an Ada 2022 feature.

Ada 2022


text: Category:Culantro recipes

title: Category:Culantro recipes


text:
Character Encodings/Code Tables/MS-DOS/Code page 58335

Code page 58335 is a variant of code page 991 intended for Kashubian while also retaining its Polish coverage.

Character set
The following table shows code page 58335. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437. Note that ù appears twice.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 991}}


text:
Character Encodings/Code Tables/MS-DOS/Code page 58152

Code page 58152 is a code page intended for Kazakh.

Character set
The following table shows code page 58152. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 808}}


text:
Character Encodings/Code Tables/MS-DOS/Code page 58210

Code page 58210 is a code page intended for Azerbaijani Cyrillic and Russian. Capital straight u and lowercase Shha are probably at code points 0xFB and 0xFE, though they are completely missing from the mapping table.

Character set
The following table shows code page 58210. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 866}}


text:
Character Encodings/Code Tables/MS-DOS/Code page 59234

Code page 59234 is a code page intended for Tatar Cyrillic and Turkmen Cyrillic.

Character set
The following table shows code page 59234. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 866}}


text:
Character Encodings/Code Tables/MS-DOS/Code page 60258

Code page 60258 is a code page intended for Russian, Bulgarian, and Azerbaijani Latin.

Character set
The following table shows code page 60258. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 866}}


text:
Character Encodings/Code Tables/MS-DOS/Code page 62306

Code page 62306 is a code page intended for Cyrillic Uzbek.

Character set
The following table shows code page 62306. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 866}}


text:
User talk:138.44.4.63

May 2024
MathXplore (discuss • contribs) 05:24, 27 May 2024 (UTC)

title: User talk:138.44.4.63


text:
Talk:IB/Group 3/History/Route 2/Causes, Practices, and Effects of Wars/The Results of World War I

history
evaluate the results of world war one 129.205.240.65 (discuss) 05:29, 27 May 2024 (UTC)


text:
Computer Graphics/Two Dimensions

Two dimensional graphics is graphics drawn on a plane surface. In computer graphics, graphics are drawn on a two dimensional computer display. However, other applications like Augmented Reality (AR) and Virtual Reality (VR) can produce spatial three dimensional graphics. Also, techniques like Holography can create three dimensional illusions of real objects- unrelated to computer graphics. Computer graphics need not be two dimensional, though it often is for computer users. The process of converting a higher dimensional computer graphics object into a two dimensional representation is called rasterization.

The Cartesian Coordinate System
Two dimensional graphics are represented by a cartesian coordinate system. Usually, the origin is at the top left corner of the screen, but the graphics programmer may use any other point as origin. For easier calculations, the center of the screen is often used. The Cartesian coordinate system uses a list of numbers to represent the position of a point. In two dimensions, the list has two numbers. These numbers describe how far the point is from the origin, in terms of horizontal and vertical distance.

The Polar Coordinate System
Although modern (rectangular) displays are not suited for polar coordinates, it can be useful for drawing curves. In this system, a given point lies a given distance from the origin at a given angle. Just like both horizontal and vertical distances can uniquely represent point location in Cartesian Coordinate system, both the distance of given point from the origin and the direction it is oriented towards from the origin uniquely represent point location in polar coordinates.

Transforming Coordinate Systems
Generally, the graphics objects are drawn with their own coordinate system different from the screen coordinates. Thus the representation of the object is separate from that displayed. For this reason, it is required to transform the graphics objects from the (logical) coordinate system they were made on into coordinate system that can be measured in real world.

Representing Two Dimensional Graphics Objects

Graphics Transformations

Colors and Textures

title: Computer Graphics/Two Dimensions


text:
Adventist Adventurer Awards and Answers/Introduction

The purpose of Adventurer Awards is to provide instructors with answers to facilitate their experience as teachers. The answers here are based in the requirements of the North American Division for the Adventurer Program

The awards are designed to be used in connection with the Adventurer curriculum. It is recommended that a variety of awards be offered to help each child have a well-rounded understanding of many interests.

Instructors should be creative and make the award meaningful to the Adventurer child. Remember to challenge the more advanced child without discouraging the lesser achiever.

The goal is to help each child experience achievement and to learn new activities and ideas in an interesting and fun way. Affirm each child, remembering that there is more than one right way. Encourage each child to do his/her best. We do not need to be perfect. God is not finished with us yet.


text:
Ada Programming/Attributes/'Extended Base

Description
For a type T returns the base type of T. This attribute is allowed only as the prefix of the name of another attribute. (This is the old Ada83 'BASE attribute.)


text:
Ada Programming/Attributes/'Extended Image

Description
Returns the image of type STRING associated with a specified item as defined for the PUT procedure in TEXT_IO generic package appropriate for type T (e.g., TEXT_IO.INTEGER_IO(T) if T is an integer type). T may denote an integer, enumeration, floating point or fixed point type name. Named parameter notation may not be used. The parameters are:

 * Item : T
 * the item for which you want the image. Required.

 * Width : Field := 0
 * the minimum number of characters to be in the string that is returned.

 * Base : Number_Base := 10
 * the base in which the image is to be displayed.

 * Based : Boolean := FALSE
 * if TRUE, return the string in based format (e.g., 10#99#).

 * Space_If_Positive : Boolean := FALSE
 * if TRUE, a positive integer will be preceded by a blank in the string returned.


text:
Ada Programming/Attributes/'Extended Value

Description
Returns the value of type T associated with Item as defined for the GET procedure in the TEXT_IO generic package appropriate for type T (e.g., TEXT_IO.INTEGER_IO(T) if T is an integer type). T may denote an integer, enumeration, floating point, or fixed point type.

 * Item
 * is the STRING for which you want the value.


text:
Ada Programming/Attributes/'Extended Width

Description
Returns the width for (sub)type T. T may be integer or enumeration type. All the parameters are optional. They are:

 * Base : Number_Base := 10
 * the base for which the width will be calculated.

 * Based : Boolean := FALSE
 * if TRUE, compute the width of the based format (e.g., 10#99#).

 * Space_If_Positive : BOOLEAN := FALSE
 * if TRUE, compute the width assuming that a positive integer will be preceded by a blank.


text:
Ada Programming/Attributes/'Extended Wide Image

Description
Returns the image of type WIDE_STRING associated with a specified item as defined for the PUT procedure in TEXT_IO generic package appropriate for type T (e.g., TEXT_IO.INTEGER_IO(T) if T is an integer type). T may denote an integer, enumeration, floating point or fixed point type name. Named parameter notation may not be used. The parameters are:

 * Item : T
 * the item for which you want the image. Required.

 * Width : Field := 0
 * the minimum number of characters to be in the string that is returned.

 * Base : Number_Base := 10
 * the base in which the image is to be displayed.

 * Based : Boolean := FALSE
 * if TRUE, return the string in based format (e.g., 10#99#).

 * Space_If_Positive : Boolean := FALSE
 * if TRUE, a positive integer will be preceded by a blank in the string returned.


text:
Ada Programming/Attributes/'Extended Wide Value

Description
Returns the value of type T associated with Item as defined for the GET procedure in the TEXT_IO generic package appropriate for type T (e.g., TEXT_IO.INTEGER_IO(T) if T is an integer type). T may denote an integer, enumeration, floating point, or fixed point type.

 * Item
 * is the WIDE_STRING for which you want the value.


text:
Ada Programming/Attributes/'Extended Wide Width

Description
Returns the width for (sub)type T. T may be integer or enumeration type. All the parameters are optional. They are:

 * Base : Number_Base := 10
 * the base for which the width will be calculated.

 * Based : Boolean := FALSE
 * if TRUE, compute the width of the based format (e.g., 10#99#).

 * Space_If_Positive : BOOLEAN := FALSE
 * if TRUE, compute the width assuming that a positive integer will be preceded by a blank.


text:
Ada Programming/Attributes/'Extended Digits

Description
Returns the number of digits using Base in the mantissa of model numbers in the floating point subtype T. The optional parameter is:

 * Base : Number_Base := 10
 * the base that the subtype is defined in


text:
Ada Programming/Attributes/'Extended Fore

Description
Returns the minimum number of characters required for the integer part of the representation of the fixed point subtype T. All parameters are optional. They are:

 * Base : Number_Base := 10
 * the base in which the digits will be represented.

 * Based : Boolean := FALSE
 * if TRUE, compute the width of the based format (e.g., 10#99.0#).


text:
Ada Programming/Attributes/'Extended Aft

Description
Returns the minimum number of characters required for the fractional part of the representation of the fixed point subtype T. All parameters are optional. They are:

 * Base : Number_Base := 10
 * the base in which the digits will be represented.

 * Based : Boolean := FALSE
 * if TRUE, compute the width of the based format (e.g.,10#99.0#).


text:
Ada Programming/Attributes/'Ref

Description
’REF denotes the effective address of the first of the storage units allocated to the object. ’REF is not supported for a package, task unit or entry. The two forms for this attribute are X’REF and SYSTEM.ADDRESS’REF(N). Only use X’REF in machine code procedures. Use SYSTEM.ADDRESS’REF(N) anywhere to convert an integer expression to an address.

X’REF
The attribute generates a reference to the entity to which it is applied. In X’REF, X must be either a constant, variable, procedure, function, or label. The attribute returns a value of the type MACHINE_CODE.OPERAND. Only use it to designate an operand in a code-statement. Precede the instruction generated by the code-statement in which the attribute occurs by additional instructions needed to facilitate the reference, such as loading a base register. If the declarative section of the procedure contains pragma IMPLICIT_CODE (OFF), a warning generates if additional code is required.

SYSTEM.ADDRESS’REF(N)
The effect of this attribute is similar to the effect of an unchecked conversion from integer to address. However, use SYSTEM.ADDRESS’REF(N) instead in the following listed circumstances. In these circumstances, N must be static. In SYSTEM.ADDRESS’REF(N), SYSTEM.ADDRESS must be type SYSTEM.ADDRESS. N must be an expression of type UNIVERSAL_INTEGER. The attribute returns a value of type SYSTEM.ADDRESS, which represents the address designated by N.

 * With any of the runtime configuration packages: Use of unchecked conversion in an address clause requires the generation of elaboration code, but the configuration packages are not elaborated.
 * In any instance where N is greater than INTEGER’LAST: Such values are required in address clauses that reference the upper portion of memory. To use unchecked conversion in these instances requires the expression be given as a negative integer.
 * To place an object at an address, use ’REF.

Example
In the following example, the integer_value converts to an address for use in the address representation clause. The form avoids UNCHECKED_CONVERSION and is useful for 32-bit unsigned addresses.

title: Ada Programming/Attributes/'Ref


text:
Ada Programming/Attributes/'Task ID

Description
For a non-passive task object or a value, X, X’TASK_ID yields the unique task ID associated with the task. The value of this attribute is of the type SYSTEM.TASK_ID. If the task objector value X denotes a passive task, the result is the passive task header record object associated with the passive task. The result type is then of type SYSTEM.PASSIVE_TASK_ID.

title: Ada Programming/Attributes/'Task ID


title: Template:Ada/2022/RM


text:
Vehicle Identification Numbers (VIN codes)/Alfa Romeo/VIN Codes

GVWR, Brake System, & Restraint Systems - Multi-Purpose Passenger Vehicles 2018-
GVWR=Gross Vehicle Weight Rating

Price Series, Drive Wheels, Drive Position, and Body Style
Passenger Cars

Multi-Purpose Passenger Vehicles

General Template for Alfa Romeo's VIN format (2008 - 2009 8C)
All 8C VINs start with the letters ZAR (Europe, Italy, Alfa Romeo).

4th digit - Model:
 * J -> Alfa Romeo 8C ('08-'09)

5th digit - Series:
 * A -> First Series

6th digit - Body Style:
 * 1 -> 2-d coupe (8C Competizione)
 * 2 -> 2-d convertible (8C Spider)

7th digit - Engine:
 * 8 -> 4.7L DOHC 32v VVT V8. Ferrari-based F136 YC.

8th digit - Restraint System:
 * 1 -> Manual Seat Belts and Driver and Passenger Front Airbags

9th digit - Check digit

10th digit - Model year:
 * 8: 2008, 9: 2009

11th digit - Plant of Manufacture:
 * 0 -> Maserati Modena plant, Modena, Italy

12-17 digit - Production Sequence Number

General Template for Alfa Romeo's VIN format (1991 - 1995)
All Alfa Romeo VINs start with the letters ZAR (Europe, Italy, Alfa Romeo).

4th digit - Line:
 * B -> Alfa Romeo Spider ('91-'94)
 * E -> Alfa Romeo 164 ('91-'95)

5th digit - Version:
 * A -> 164 ('91-'93)
 * B -> Spider ('91-'94)
 * D -> 164 ('94-'95)

6th digit - Transmission, Restraint System:
 * 3 -> Manual transmission, Manual seat belts and Driver-side airbag ('91-'95 164, '91-'94 Spider)
 * 4 -> Automatic transmission, Manual seat belts and Driver-side airbag ('91-'95 164, '91-'93 Spider)

7th digit - Engine Displacement:
 * 2 -> 2.0 liter (I4) ('91-'94 Spider)
 * 3 -> 3.0 liter (V6) ('91-'95 164)

8th digit - Trim Level:
 * A -> 164 (base model) ('91)
 * E -> 164 S ('91-'93)
 * L -> 164 L ('91-'93)
 * E -> 164 LS ('94-'95)
 * R -> 164 Quadrifoglio ('94-'95)
 * G -> Spider (base model) ('91-'94)
 * N -> Spider Veloce ('91-'94)

9th digit - Check digit

10th digit - Model year:
 * M: 1991, N: 1992, P: 1993, R: 1994, S: 1995

11th digit - Plant of Manufacture:
 * 6 -> Alfa Romeo Arese plant, Arese, Italy (164, '91 Spider)
 * 7 -> Alfa Romeo Arese plant, Arese, Italy ('92-'94 Spider)

12-17 digit - Production Sequence Number

General Template for Alfa Romeo's VIN format (1987 - 1990)
All Alfa Romeo VINs start with the letters ZAR (Europe, Italy, Alfa Romeo).

4th digit - Line:
 * B -> Alfa Romeo Spider ('87-'90)
 * D -> Alfa Romeo Milano ('87-'89)

5th digit - Transmission, Restraint System:
 * A -> 5-spd. manual, Manual seat belts ('87-'89 Milano, '87-'90 Spider)
 * B -> 3-spd. automatic, Manual seat belts ('88-'89 Milano)
 * C -> 5-spd. manual, Passive (motorized) seat belts ('87-'89 Spider)

6th, 7th, 8th digit - Trim Level:
 * 114 -> Milano Quadrifoglio Silver 2.5L man. trans. ('87)
 * 116 -> Milano Quadrifoglio Gold 2.5L man. trans. ('87-'89)
 * 124 -> Milano Quadrifoglio Verde 3.0L man. trans. ('87-'89)
 * 136 -> Milano Quadrifoglio Platinum 2.5L man. trans. ('87)
 * 140 -> Milano Quadrifoglio Gold 2.5L auto. trans. ('88-'89)
 * 142 -> Milano Quadrifoglio Platinum 2.5L auto. trans. ('88-'89)
 * 556 -> Spider Quadrifoglio 2.0L ('87-'89)
 * 558 -> Spider Veloce 2.0L ('87-'89)
 * 564 -> Graduate 2.0L ('87-'89)
 * 570 -> Spider Quadrifoglio 2.0L ('88)
 * 576 -> Spider Veloce 2.0L ('87-'88)
 * 12C -> Spider Veloce 2.0L ('90)
 * 12G -> Graduate 2.0L ('90)
 * 12T -> Spider Quadrifoglio 2.0L ('90)

9th digit - Check digit

10th digit - Model year:
 * H: 1987, J: 1988, K: 1989, L: 1990

11th digit - Plant of Manufacture:
 * 1 -> Alfa Romeo Arese plant, Arese, Italy (Milano, '87-'89 Spider)
 * 6 -> Alfa Romeo Arese plant, Arese, Italy ('89-'90 Spider)

12-17 digit - Production Sequence Number

General Template for Alfa Romeo's VIN format (1981 - 1986)
All Alfa Romeo VINs start with the letters ZAR (Europe, Italy, Alfa Romeo).

4th digit - Line:
 * A -> Alfa Romeo GTV6 ('81-'86)
 * B -> Alfa Romeo Spider ('81-'86)

5th digit - Transmission, Restraint System:
 * A -> 5-spd. manual, Manual seat belts

6th, 7th, 8th digit - Model:
 * 541 -> Spider Veloce ('81-'86), Spider Special Edition ('82), Graduate ('85-'86), Spider Quadrifoglio ('86)
 * 669 -> GTV6 ('81-'86)

9th digit - Check digit

10th digit - Model year:
 * B: 1981, C: 1982, D: 1983, E: 1984, F: 1985, G: 1986

11th digit - Plant of Manufacture:
 * 1 -> Alfa Romeo Arese plant, Arese, Italy

12-17 digit - Production Sequence Number

Alfa Romeo WMIs

 * ZAR - Alfa Romeo Passenger Car
 * ZAS - Alfa Romeo Alfasud & Sprint through 1989
 * ZAS - Alfa Romeo Multipurpose Passenger Vehicle 2018- (in N. America)


text:
Character Encodings/Code Tables/MS-DOS/Code page 59829

Code page 59829 is a code page intended for Georgian.

Character set
The following table shows code page 59829. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 437}}


text:
Business Strategy/Introduction

Business (or Strategic) management is the art, science, and craft of formulating, implementing and evaluating cross-functional decisions that will enable an organization to achieve its long-term objectives. It is the process of specifying the organization's mission, vision and objectives, developing policies and plans, often in terms of projects and programs, which are designed to achieve these objectives, and then allocating resources to implement the policies and plans, projects and programs. Strategic management seeks to coordinate and integrate the activities of the various functional areas of a business in order to achieve long-term organizational objectives. A balanced scorecard is often used to evaluate the overall performance of the business and its progress towards objectives.

Strategic management is the highest level of managerial activity. Strategies are typically planned, crafted or guided by the Chief Executive Officer, approved or authorized by the Board of directors, and then implemented under the supervision of the organization's top management team or senior executives. Strategic management provides overall direction to the enterprise and is closely related to the field of Organization Studies. In the field of business administration it is useful to talk about "strategic alignment" between the organization and its environment or "strategic consistency". According to Arieu (2007), "there is strategic consistency when the actions of an organization are consistent with the expectations of management, and these in turn are with the market and the context."

Before reading the rest, it is recommended that An Overview of Strategic Planning be read.

title: Business Strategy/Introduction


text:
Character Encodings/Code Tables/MS-DOS/Code page 60853

Code page 60853 is a code page intended for Georgian which includes capital letters, though it lacks the five obsolete letters, and shin with caron.

Character set
The following table shows code page 60853. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 437}}


text:
Character Encodings/Code Tables/Windows/Code page 58595

Code page 58595 is a variant of Windows-1251 which covers the Kazakh, Tatar (Cyrillc), Turkmen (Cyrillic), and Uzbek (Cyrillic) languages. It also covers Russian, Bulgarian, Belarusian, and Rusyn.

{{legend|#FFD|Differences from Windows-1251}}


text:
Character Encodings/Code Tables/Windows/Code page 58596

Code page 58596 is a variant of Windows-1252 which covers the Georgian language.

{{legend|#FFD|Differences from Windows-1252}}


text:
Character Encodings/Code Tables/HP

 * Code page 1056

title: Character Encodings/Code Tables/HP


text: Category:Book:Adventist Adventurer Awards and Answers


text: Category:Book:Ada Programming/Ada 2022

title: Category:Book:Ada Programming/Ada 2022


text:
Category:Pages with disabled graphs

__HIDDENCAT__

title: Category:Pages with disabled graphs


text:
User talk:2A02:C7C:4128:5800:15C0:E726:6E69:71F8

May 2024
MathXplore (discuss • contribs) 12:14, 28 May 2024 (UTC)


text:
World War II/Stalin and the Soviet Union

Stalin and his involvement in World War II, started in 1939. Hitler and Stalin agreed a secret treaty to divide Poland between the Soviet Union and Germany. Following the invasion, Britain (which had a treaty with Poland) declared war on Germany.


text:
Canadian Refugee Procedure/31.1 - Refugee Travel Document

IRPA Section 31.1
Section 31.1 of the Immigration and Refugee Protection Act reads: Refugee Travel Document

Designated foreign national 31.1 For the purposes of Article 28 of the Refugee Convention, a designated foreign national whose claim for refugee protection or application for protection is accepted is lawfully staying in Canada only if they become a permanent resident or are issued a temporary resident permit under section 24.

Designated foreign nationals will not have the ability to travel outside of Canada for at least five years after acceptance of their refugee claim
The Canadian Immigration Lawyers Association summarizes the effect of this section as follows: designated foreign nationals will not benefit from Article 28 of the Refugee Convention, which requires contracting states, such as Canada, to issue travel documents to refugees lawfully staying in their territory. Put in simpler terms, they say, designated foreign nationals will not have the ability to travel outside of Canada for at least five years after acceptance of their refugee claim. See more: Canadian Refugee Procedure/20.1-20.2 - Designated Foreign Nationals.

UNHCR takes the position that this provision is inconsistent with Canada's obligations under the Refugee Convention
In its May 2012 submission on this section, the United Nations High Commission on Refugees (UNHCR) took the position that the above provision runs contrary to Canada’s obligation under the 1951 Refugee Convention and the 1967 protocol:"The new section 31.1 is at variance with Article 28 of the 1951 Convention, which provides that “Contracting States shall issue to refugees lawfully staying in their territory travel documents for the purpose of travel outside their territory unless compelling reasons of national security or public order otherwise require....” Although the term “lawfully staying” has no universally consistent meaning, it is UNHCR’s view that “stay” means a permitted regularized stay of some duration – including either permanent or temporary residence, while “lawful” normally is to be assessed against prevailing national laws and regulations. A judgment as to lawfulness should nevertheless take into account all the prevailing circumstances, including the fact that the stay in question is known and not prohibited. Formally 15 recognized refugees whose status in the country has been permitted by the granting State should be considered to be “lawfully staying” in their host country, and consequently, be entitled to benefit from the right to Convention Travel Documents per Article 28 of the 1951 Convention, unless there are compelling reasons of national security or public order to deny a Convention Travel Document in the individual case."


text:
FormsABC unit in PascalABC.NET

FormsABC - is a PascalABC.NET unit intended for simple GUI application's creation.

Controls

 * 1) Button - a button
 * 2) CheckBox - a checkbox
 * 3) RadioButton - a radio button
 * 4) IntegerField - a single line text box intended to keep integer values
 * 5) RealField  - a single line text box intended to keep real values
 * 6) Field - a single line text box
 * 7) TextBox - a multi line text box
 * 8) TrackBar - a track bar
 * 9) TextLabel - a label
 * 10) ListBox - a list box
 * 11) ComboBox - a combo box
 * 12) MainMenu - a main menu

Examples
Create a new button with  text on it:

Examples
Create a new checkbox with  text on it:

title: FormsABC unit in PascalABC.NET


text:
Canadian Refugee Procedure/150.1 - Sharing of Information

IRPA Section 150.1
Section 150.1 of the Immigration and Refugee Protection Act reads: Sharing of Information

Regulations 150.1 (1) The regulations may provide for any matter relating to (a) the collection, retention, use, disclosure and disposal of information, including a Social Insurance Number, for the purposes of this Act or for the purposes of program legislation as defined in section 2 of the Canada Border Services Agency Act; (b) the disclosure of information for the purposes of national security, the defence of Canada or the conduct of international affairs, including the implementation of an agreement or arrangement entered into under section 5 or 5.1 of the Department of Citizenship and Immigration Act or section 13 of the Canada Border Services Agency Act; (c) the disclosure of information relating to the professional or ethical conduct of a person referred to in any of paragraphs 91(2)(a) to (c) in connection with a proceeding — other than a proceeding before a superior court — or application under this Act to a body that is responsible for governing or investigating that conduct or to a person who is responsible for investigating that conduct, for the purposes of ensuring that persons referred to in those paragraphs offer and provide professional and ethical representation and advice to persons in connection with such proceedings and applications; (d) the retention, use, disclosure and disposal by the Royal Canadian Mounted Police of biometric information and any related personal information that is collected under this Act and provided to it for the enforcement of any law of Canada or a province; and (e) the disclosure of information for the purposes of cooperation between the Government of Canada and the government of a province.

Conditions (2) Regulations made under subsection (1) may include conditions under which the collection, retention, use, disposal and disclosure may be made.

Section 150.1(1)(c) provides that the regulations may provide for an matter relating to the disclosure of information relating to the professional or ethical conduct of certain representatives
See: Canadian Refugee Procedure/IRPR s. 13.1 - Authorized disclosure.


text: Category:Curry leaf recipes

title: Category:Curry leaf recipes


text:
Character Encodings/Code Tables/MS-DOS/Code page 30000

Code page 30000 is a code page intended for the Sámi languages, Finnish Kalo, and the Finnic languages (Livonian, Finnish, Estonian, etc.). It also covers Latvian and its dialects.

Character set
The following table shows code page 30000. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 858}}


text:
Chess Opening Theory/1. e4/1...e6/2. d4/2...d5/3. Nc3/3...Bb4/6. f3

=Winckelmann-Reimer Gambit=


text:
Character Encodings/Code Tables/MS-DOS/Code page 30001

Code page 30001 is a code page intended for the Celtic languages and the Scots language.

Character set
The following table shows code page 30001. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 858}}


text:
Character Encodings/Code Tables/MS-DOS/Code page 30002

Code page 30002 is a code page intended for Tajik.

Character set
The following table shows code page 30002. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 808}}


text: User talk:OliwierB

title: User talk:OliwierB


text:
Character Encodings/Code Tables/MS-DOS/Code page 30003

Code page 30003 is a code page intended for Latin American languages.

Character set
The following table shows code page 30003. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 859}}


text:
User talk:172.242.243.243

May 2024
MathXplore (discuss • contribs) 02:27, 29 May 2024 (UTC)

title: User talk:172.242.243.243


text:
Character Encodings/Code Tables/MS-DOS/Code page 30004

Code page 30004 is a code page intended for Greenlandic and the North Germanic languages (including Old Norse).

Character set
The following table shows code page 30004. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 858}}


text:
User talk:210.55.76.21

May 2024
MathXplore (discuss • contribs) 03:05, 29 May 2024 (UTC)

title: User talk:210.55.76.21


text:
User talk:User88765676

--SHB2000 (discuss • contribs) 09:25, 29 May 2024 (UTC)

Blocked
You cannot edit indefinitely due to disruptive editing. You may appeal this action with a reasonable argument by adding the text below. --SHB2000 (discuss • contribs) 09:32, 29 May 2024 (UTC)
 * Your talk page access will be revoked if you abuse this page. --SHB2000 (discuss • contribs) 09:33, 29 May 2024 (UTC)

title: User talk:User88765676


text:
Talk:History of the National Hockey League

English language
um it is true that 'NATIONAL HOCKEY LEAGUE ' be gins with demise of it predecessor  league the NATIONAL  HOCKEY LEAGUE   ??🙂 um sorry  Hi first  I think   41.150.195.74 (discuss) 10:36, 29 May 2024 (UTC)

 * who are you ?Wikipedia Equality/TaraElla1 41.150.195.74 (discuss) 10:38, 29 May 2024 (UTC)


text:
User talk:136.158.41.154

May 2024
MathXplore (discuss • contribs) 14:47, 29 May 2024 (UTC)

title: User talk:136.158.41.154


text:
User talk:80.233.74.194

May 2024
MathXplore (discuss • contribs) 14:55, 29 May 2024 (UTC)

title: User talk:80.233.74.194


text:
Talk:Astrodynamics/The Earth

The Ecliptic Plane
Since the celestial equator is mentioned, I think that maybe the ecliptic plane and maybe even the galactic equator should be mentioned/written about, but then again, this article is in the "Introduction" section of the book and this book is about astrodynamics, not astronomy as a whole so I guess it is ok if it is not touched on. ALazyEditor (discuss • contribs) 15:40, 29 May 2024 (UTC)

title: Talk:Astrodynamics/The Earth


text:
Ada Programming/Attributes/'Atomic Always Lock Free

Description
The prefix of the  attribute is a type. The result indicates whether atomic operations are supported by the target for the given type.


text:
Ada Programming/Attributes/'Default Scalar Storage Order

Description
( is the only allowed prefix), provides the current value of the default scalar storage order (as specified using pragma , or equal to   if unspecified) as a   value. This is a static attribute.


text:
Ada Programming/Attributes/'Deref

Description
The attribute  where   is of type   yields the variable of type   that is located at the given address. It is similar to, where   is an unchecked conversion from address to a named access-to- type, except that it yields a variable, so it can be used on the left side of an assignment.

title: Ada Programming/Attributes/'Deref


text:
Ada Programming/Attributes/'Descriptor Size

Description
Nonstatic attribute  returns the size in bits of the descriptor allocated for a type. The result is non-zero only for unconstrained array types and the returned value is of type universal integer. In GNAT, an array descriptor contains bounds information and is located immediately before the first element of the array. The attribute takes into account any padding due to the alignment of the component type. In the example above, the descriptor contains two values of type  representing the low and high bound. But, since  has an alignment of 4, the size of the descriptor is   rounded up to the next multiple of 32, which yields a size of 32 bits, i.e. including 16 bits of padding.


text:
Ada Programming/Attributes/'Elab Subp Body

Description
This attribute can only be applied to a library level subprogram name and is only allowed in CodePeer mode. It returns the entity for the corresponding elaboration procedure for elaborating the body of the referenced subprogram unit. This is used in the main generated elaboration procedure by the binder in CodePeer mode only and is unrecognized otherwise.


text:
Ada Programming/Attributes/'Fast Math

Description
( is the only allowed prefix) yields a static Boolean value that is True if pragma   is active, and False otherwise.

title: Ada Programming/Attributes/'Fast Math


text:
Ada Programming/Attributes/'Finalization Size

Description
The prefix of attribute  must be an object or a non-class-wide type. This attribute returns the size of any hidden data reserved by the compiler to handle finalization-related actions. The type of the attribute is universal_integer.

yields a value of zero for a type with no controlled parts, an object whose type has no controlled parts, or an object of a class-wide type whose tag denotes a type with no controlled parts.

Note that only heap-allocated objects contain finalization data.


text:
Ada Programming/Attributes/'From Any

Description
This internal attribute is used for the generation of remote subprogram stubs in the context of the Distributed Systems Annex.

title: Ada Programming/Attributes/'From Any


text:
Ada Programming/Attributes/'Has Tagged Values

Description
The prefix of the  attribute is a type. The result is a Boolean value which is True if the type is a composite type (array or record) that is either a tagged type or has a subcomponent that is tagged, and is False otherwise. The intended use of this attribute is in conjunction with generic definitions. If the attribute is applied to a generic private type, it indicates whether or not the corresponding actual type has access values.


text:
Ada Programming/Attributes/'Initialized

Description
For the syntax and semantics of this attribute, see the SPARK 2014 Reference Manual, section 6.10.

title: Ada Programming/Attributes/'Initialized


text:
Ada Programming/Attributes/'Large

The  attribute is provided for compatibility with Ada 83. See the Ada 83 reference manual for an exact description of the semantics of this attribute.

title: Ada Programming/Attributes/'Large


text:
Ada Programming/Attributes/'Library Level

Description
, where P is an entity name, returns a Boolean value which is True if the entity is declared at the library level, and False otherwise. Note that within a generic instantiation, the name of the generic unit denotes the instance, which means that this attribute can be used to test if a generic is instantiated at the library level, as shown in this example:


text:
Ada Programming/Attributes/'Loop Entry

Description
The  attribute is used to refer to the value that an expression had upon entry to a given loop in much the same way that the   attribute in a subprogram postcondition can be used to refer to the value an expression had upon entry to the subprogram. The relevant loop is either identified by the given loop name, or it is the innermost enclosing loop when no loop name is given.

A  attribute can only occur within an ,  ,  ,   or   pragma. In addition, such a pragma must be one of the items in the sequence of statements of a loop body, or nested inside block statements that appear in the sequence of statements of a loop body. A common use of  is to compare the current value of objects with their initial value at loop entry, in a   pragma.

The effect of using  is the same as declaring a constant initialized with the initial value of   at loop entry. This copy is not performed if the loop is not entered, or if the corresponding pragmas are ignored or disabled.

title: Ada Programming/Attributes/'Loop Entry


text:
Ada Programming/Attributes/'Mantissa

Description
The  attribute is provided for compatibility with Ada 83. See the Ada 83 reference manual for an exact description of the semantics of this attribute.

title: Ada Programming/Attributes/'Mantissa


text:
Ada Programming/Attributes/'Max Integer Size

Description
( is the only allowed prefix) provides the size of the largest supported integer type for the target. The result is a static constant.


text:
Ada Programming/Attributes/'Restriction Set

Description
This attribute allows compile time testing of restrictions that are currently in effect. It is primarily intended for specializing code in the run-time based on restrictions that are active (e.g. don’t need to save fpt registers if restriction No_Floating_Point is known to be in effect), but can be used anywhere.

There are two forms: In the case of the first form, the only restriction names allowed are parameterless restrictions that are checked for consistency at bind time. For a complete list see the subtype.

The result returned is True if the restriction is known to be in effect, and False if the restriction is known not to be in effect. An important guarantee is that the value of a Restriction_Set attribute is known to be consistent throughout all the code of a partition.

This is trivially achieved if the entire partition is compiled with a consistent set of restriction pragmas. However, the compilation model does not require this. It is possible to compile one set of units with one set of pragmas, and another set of units with another set of pragmas. It is even possible to compile a spec with one set of pragmas, and then WITH the same spec with a different set of pragmas. Inconsistencies in the actual use of the restriction are checked at bind time.

In order to achieve the guarantee of consistency for the Restriction_Set pragma, we consider that a use of the pragma that yields False is equivalent to a violation of the restriction.

So for example if you write And the result is False, so that the else branch is executed, you can assume that this restriction is not set for any unit in the partition. This is checked by considering this use of the restriction pragma to be a violation of the restriction No_Floating_Point. This means that no other unit can attempt to set this restriction (if some unit does attempt to set it, the binder will refuse to bind the partition).

Technical note: The restriction name and the unit name are intepreted entirely syntactically, as in the corresponding Restrictions pragma, they are not analyzed semantically, so they do not have a type.


text:
Ada Programming/Attributes/'Safe Emax

Description
The  attribute is provided for compatibility with Ada 83. See the Ada 83 reference manual for an exact description of the semantics of this attribute.

title: Ada Programming/Attributes/'Safe Emax


text:
Ada Programming/Attributes/'Safe Large

Description
The  attribute is provided for compatibility with Ada 83. See the Ada 83 reference manual for an exact description of the semantics of this attribute.

title: Ada Programming/Attributes/'Safe Large


text:
Ada Programming/Attributes/'Safe Small

Description
The  attribute is provided for compatibility with Ada 83. See the Ada 83 reference manual for an exact description of the semantics of this attribute.

title: Ada Programming/Attributes/'Safe Small


text:
Ada Programming/Attributes/'Scalar Storage Order

Description
For every array or record type, the representation attribute   denotes the order in which storage elements that make up scalar components are ordered within S. The value given must be a static expression of type System.Bit_Order. The following is an example of the use of this feature: Other properties are as for the standard representation attribute  defined by Ada RM 13.5.3(4). The default is.

For a record type, if   is specified explicitly, it shall be equal to. Note: this means that if a  attribute definition clause is not confirming, then the type’s   shall be specified explicitly and set to the same value.

Derived types inherit an explicitly set scalar storage order from their parent types. This may be overridden for the derived type by giving an explicit scalar storage order for it. However, for a record extension, the derived type must have the same scalar storage order as the parent type.

A component of a record type that is itself a record or an array and that does not start and end on a byte boundary must have have the same scalar storage order as the record type. A component of a bit-packed array type that is itself a record or an array must have the same scalar storage order as the array type.

No component of a type that has an explicit  attribute definition may be aliased.

A confirming  attribute definition clause (i.e. with a value equal to  ) has no effect.

If the opposite storage order is specified, then whenever the value of a scalar component of an object of type  is read, the storage elements of the enclosing machine scalar are first reversed (before retrieving the component value, possibly applying some shift and mask operatings on the enclosing machine scalar), and the opposite operation is done for writes.

In that case, the restrictions set forth in 13.5.1(10.3/2) for scalar components are relaxed. Instead, the following rules apply:

 * the underlying storage elements are those at positions
 * the sequence of underlying storage elements shall have a size no greater than the largest machine scalar
 * the enclosing machine scalar is defined as the smallest machine scalar starting at a position no greater than  and covering storage elements at least up to
 * the position of the component is interpreted relative to that machine scalar.

If no scalar storage order is specified for a type (either directly, or by inheritance in the case of a derived type), then the default is normally the native ordering of the target, but this default can be overridden using pragma.

If a component of  is itself of a record or array type, the specfied   does not apply to that nested type: an explicit attribute definition clause must be provided for the component type as well if desired.

Representation changes that explicitly or implicitly toggle the scalar storage order are not supported and may result in erroneous execution of the program, except when performed by means of an instance of.

In particular, overlays are not supported and a warning is given for them:

In most cases, such representation changes ought to be replaced by an instantiation of a function or procedure provided by.

Note that the scalar storage order only affects the in-memory data representation. It has no effect on the representation used by stream attributes.

Note that debuggers may be unable to display the correct value of scalar components of a type for which the opposite storage order is specified.


text:
Ada Programming/Attributes/'Simple Storage Pool

Description
For every nonformal, nonderived access-to-object type, the representation attribute   may be specified via an attribute_definition_clause (or by specifying the equivalent aspect): The name given in an attribute_definition_clause for the   attribute shall denote a variable of a ‘simple storage pool type’ (see pragma ).

The use of this attribute is only allowed for a prefix denoting a type for which it has been specified. The type of the attribute is the type of the variable specified as the simple storage pool of the access type, and the attribute denotes that variable.

It is illegal to specify both  and   for the same access type.

If the  attribute has been specified for an access type, then applying the   attribute to the type is flagged with a warning and its evaluation raises the exception.

If the Simple_Storage_Pool attribute has been specified for an access type, then the evaluation of the attribute   returns the result of calling  , which is intended to indicate the number of storage elements reserved for the simple storage pool. If the Storage_Size function has not been defined for the simple storage pool type, then this attribute returns zero.

If an access type  has a specified simple storage pool of type , then the evaluation of an allocator for that access type calls the primitive   procedure for type  , passing   as the pool parameter. The detailed semantics of such allocators is the same as those defined for allocators in section 13.11 of the, with the term simple storage pool substituted for storage pool.

If an access type  has a specified simple storage pool of type , then a call to an instance of the   for that access type invokes the primitive   procedure for type  , passing   as the pool parameter. The detailed semantics of such unchecked deallocations is the same as defined in section 13.11.2 of the Ada Reference Manual, except that the term simple storage pool is substituted for storage pool.


text:
Ada Programming/Attributes/'Small Denominator

Description
for any fixed-point subtype yields the denominator in the representation of   as a rational number with coprime factors (i.e. as an irreducible fraction).


text:
Ada Programming/Attributes/'Small Numerator

Description
for any fixed-point subtype yields the numerator in the representation of   as a rational number with coprime factors (i.e. as an irreducible fraction).


text:
Ada Programming/Attributes/'System Allocator Alignment

Description
( is the only allowed prefix) provides the observable guaranteed to be honored by the system allocator (malloc). This is a static value that can be used in user storage pools based on malloc either to reject allocation with alignment too large or to enable a realignment circuitry if the alignment request is larger than this value.


text:
Ada Programming/Attributes/'To Any

Description
This internal attribute is used for the generation of remote subprogram stubs in the context of the Distributed Systems Annex.

title: Ada Programming/Attributes/'To Any


text:
Ada Programming/Attributes/'TypeCode

Description
This internal attribute is used for the generation of remote subprogram stubs in the context of the Distributed Systems Annex.

title: Ada Programming/Attributes/'TypeCode


text:
Ada Programming/Attributes/'Update

Description
The  attribute creates a copy of an array or record value with one or more modified components. The syntax is: where  is the name of an array or record object, the association list in parentheses does not contain an   choice and the box symbol   may not appear in any expression. The effect is to yield a copy of the array or record value which is unchanged apart from the components mentioned in the association list, which are changed to the indicated value. The original value of the array or record value is not affected. For example: yields a value for  of 1,10,20,20,5 with   begin unmodified. Similarly: yields a value for  of (A => 1, B => 20, C => 3), with   being unmodifed. Note that the value of the attribute reference is computed completely before it is used. This means that if you write: then the value of  is not modified if   raises an exception, unlike the effect of a series of direct assignments to elements of. In general this requires that two extra complete copies of the object are required, which should be kept in mind when considering efficiency.

The  attribute cannot be applied to prefixes of a limited type, and cannot reference discriminants in the case of a record type. The accessibility level of an Update attribute result object is defined as for an aggregate.

In the record case, no component can be mentioned more than once. In the array case, two overlapping ranges can appear in the association list, in which case the modifications are processed left to right.

Multi-dimensional arrays can be modified, as shown by this example: which changes element (1,2) to 20 and (3,4) to 30.

title: Ada Programming/Attributes/'Update


text:
Ada Programming/Attributes/'Valid Value

Description
The  attribute is defined for enumeration types other than those in package Standard. This attribute is a function that takes a String, and returns Boolean. returns True if and only if  would not raise Constraint_Error.

title: Ada Programming/Attributes/'Valid Value


text:
Ada Programming/Attributes/'Valid Scalars

Description
The  attribute is intended to make it easier to check the validity of scalar subcomponents of composite objects. The attribute is defined for any prefix  which denotes an object. Prefix  can be any type except for tagged private or   types. The value of the attribute is of type.

yields  if and only if the evaluation of   yields   for every scalar subcomponent   of , or if   has no scalar subcomponents. Attribute  is equivalent to attribute   for scalar types.

It is not specified in what order the subcomponents are checked, nor whether any more are checked after any one of them is determined to be invalid. If the prefix  is of a class-wide type   (where   is the associated specific type), or if the prefix   is of a specific tagged type , then only the subcomponents of   are checked; in other words, components of extensions of   are not checked even if.

The compiler will issue a warning if it can be determined at compile time that the prefix of the attribute has no scalar subcomponents.

Note:  can generate a lot of code, especially in the case of a large variant record. If the attribute is called in many places in the same program applied to objects of the same type, it can reduce program size to write a function with a single use of the attribute, and then call that function from multiple places.


text:
Chess Opening Theory/1. g4/1...e5/2. d3

1. g4 e5 2. d3
d3 aims to open up the queen side bishop to attack Black's kingside, as well as support a future e4 for control of the center as well. It is basically trying to do two things at once, being hyper-modern as well as classic. Due to this as well as a weak kingside due to the advanced g pawn, White is at a disadvantage, being a jack of all trades, but a master of none.

With good play however, White can establish a mimicry of the King's Indian Attack, with the g pawn able to disrupt the king side knight if it ever comes to f6, meaning Black would have to play h6 to secure it, losing a tempo. Some common moves of this caliber for White include Nf3, Bg2, or the eventual e5, as well as the unique move of g5 common in many games of this opening to prevent Black's knight from moving there.

The main continuation for Black is to play d5, opening up the bishop to attack the g4 pawn, leading to g5. There is also the developing move of Nc6, which defends the e5 pawn and controls d4 along with said pawn.

title: Chess Opening Theory/1. g4/1...e5/2. d3


text:
Ada Programming/Keywords/parallel

This keyword is used with parallel blocks and parallel loops to create a form of lightweight tasking to take advantage of multicore CPUs.

Wikibook

 * Ada Programming
 * Ada Programming/Keywords

Ada Quality and Style Guide

|Record Keywords:parallel

title: Ada Programming/Keywords/parallel


text: Category:Custard powder recipes

title: Category:Custard powder recipes


text:
Palliative Pharmacotherapy

Purpose
The purpose of this Wikibook is to serve as a reference to pharmacists who practice in palliative care in any capacity -- whether that's inpatient or outpatient; strictly pain management, hospice, or oncology symptom management. I am hoping you will find some useful information herein. All contributions are welcome including syntax, style, and content. This Wikibook was first created on May 29th, 2024 and so it is in its infancy.

Anticipated Content
As this is an open-source book, it is impossible to determine the ultimate trajectory of this book. However, the creation of this book was spawned from a massive (400+ page Word document) which held many notes related to palliative care pharmacotherapy. These notes were organized first into drug and drug class-specific information, then into disease state-specific information, then logistics, finally miscellaneous.

Contributing
If you are interested in directly contributing content, please see the local style manual.

If you would like to request or contribute material without having to learn the ins and outs of Wikibooks, then please ask on my talk page.

Table of Contents
This ToC is a work-in-progress, as is much of this book so far. Thank you for your patience as we build something great!

Disclaimer
Nothing in this textbook should be construed as medical advice. All content within this book is free for anyone to edit and this book is not monitored 24/7. While every effort is made to verify the accuracy of the information contained herein, it is possible that unscrupulous or uninformed persons could alter or add incorrect or misleading content. Information contained within this book is for information and educational purposes only. Clinicians should always use professional judgment. No one contributing information to this book shall be held liable for any incidents that happen as a result of using information within this book.

title: Palliative Pharmacotherapy


text:
Palliative Pharmacotherapy/Style Manual

Basics of Palliative Pharmacotherapy Style:

 * More organization is better: Use a deep structure as opposed to flat. This means there will be nested pages. For example, to learn about the buprenorphine buccal film, the reader will be directed to Drug Specific Information > Opioids > Specific Opioids > Buprenorphine > Buccal Film
 * Naming of titles and sections should use title case.
 * There are no arbitrary page length restrictions.
 * Eventually a template will be designed for condition-specific and drug-specific chapters. Condition-specific chapters will include background, presentation, pathophysiology, diagnosis, treatment, monitoring, prognosis, and pearls sections at a minimum. Drug-specific chapters will include background, mechanism of action, indications, formulations, dosing, contraindications / warnings / precautions, adverse effects & monitoring, and pearls at a minimum.
 * Each chapter should contain references if appropriate.
 * Links to outside content or websites is OK.
 * Navigation: Still undecided on the exact approach to this, however, ideally each page will have a miniature ToC at the bottom of each page so users can easily navigate through the book to any place without being restricted to navigating linearly.
 * Images: TBD
 * Categories: TBD
 * Citing sources: Please use AMA citation format. If you need help, ZoteroBib is a nice citation generator by Zotero, which is a reference manager.

title: Palliative Pharmacotherapy/Style Manual


text:
User:PalliativePharmacist/sandbox

testing toc template

title: User:PalliativePharmacist/sandbox


text:
Character Encodings/Code Tables/MS-DOS/Code page 30005

Code page 30005 is a code page intended for languages in Nigeria.

Character set
The following table shows code page 30005. Each character is shown with its equivalent Unicode code point. Only the second half of the table (128–255) is shown, the first half (0–127) being the same as code page 437.

{{legend|#EFF|Symbols and punctuation}} {{legend|#FFD|Differences from code page 859}}


text: Category:Dabeli masala recipes

title: Category:Dabeli masala recipes


text:
User:PalliativePharmacist

Hello!

I am a palliative care PharmD who simply wants to share my knowledge. I am still early in my career and new to palliative care, so I am equally excited to learn from others as I am to teach.

title: User:PalliativePharmacist


text:
User:Immanuelle/sandbox/Sumiyoshi Faith

The sumiyoshi faith is a related faith to the watatsumi faith. It is associated with the Tsumori clan

In the Sumiyoshi taisha jindaiki, Jingū's connection to the sea deity Sumiyoshi is emphasized. After Emperor Chūai's death, Jingū has "secret doings" with Sumiyoshi, symbolizing a clandestine affair. Sumiyoshi plays a prominent role in guiding her conquest, ensuring her safe passage across the sea and providing divine assistance. This narrative suggests that Sumiyoshi, rather than Emperor Chūai, might be the father of Emperor Ōjin, thus integrating Sumiyoshi into the imperial lineage. The text highlights Jingū's negotiations with the gods, culminating in her enshrinement alongside Sumiyoshi, which underscores the deity's importance in maritime traditions and the imperial polity.

The Sumiyoshi deities are a triad just like the Munakata goddesses and Watatsumi. However unlike Watatsumi, they are more related to safe navigation than to fishing or the depths. This makes them a distinctly more human deity, and may be responsible for the lack of attempts to reinterpret Sumiyoshi as was done with Watatsumi with Azumi-no-Isora and Utsushihikihanasaku.

The first known Sumiyoshi Shrine is Sumiyoshi-jinja in Fukuoka.

The Tsumori clan who rules Sumiyoshi-taisha claims ancestry from Amenohoakari, making them relatives of the Owari and Amabe clans

Empress Jingu asked them to make a shrine for the Sumiyoshi gods in Osaka, and so the Sumiyoshi-taisha was born

title: User:Immanuelle/sandbox/Sumiyoshi Faith


text:
User talk:2409:40F4:3F:FE3:8000:0:0:0

May 2024
MathXplore (discuss • contribs) 03:22, 30 May 2024 (UTC)

title: User talk:2409:40F4:3F:FE3:8000:0:0:0


text: Category:Book:Palliative Pharmacotherapy


text:
User:Cuiditheoir

User: Cuiditheoir

title: User:Cuiditheoir


text:
User:Immanuelle/sandbox/Sengen Faith

The Sengen Faith primarily worships Konohanasakuyahime and secondarily Oyamatsumi. Some Sengen shrines worship Iwnaga-hime but we will cover here in the next chapter

title: User:Immanuelle/sandbox/Sengen Faith