Language Reference/Directives - Revision history

SergeMukhin: add #stringinclude

2020-02-18T17:09:53Z

add #stringinclude

← Older revision		Revision as of 19:09, 18 February 2020
Line 3:		Line 3:
	Each compiler directive starts from the <vp>#</vp> character. The following directives are supported:		Each compiler directive starts from the <vp>#</vp> character. The following directives are supported:

	* <vp>#include</vp>, <vp>#bininclude </vp> - file inclusion.		* <vp>#include</vp>, <vp>#bininclude </vp>, <vp>#stringinclude </vp> - file inclusion.
	* <vp>#if</vp>, <vp>#then</vp>, <vp>#else</vp>, <vp>#elseif</vp>, <vp>#endif</vp> - conditional statements.		* <vp>#if</vp>, <vp>#then</vp>, <vp>#else</vp>, <vp>#elseif</vp>, <vp>#endif</vp> - conditional statements.
	* <vp>#export</vp>, <vp>#externally</vp> - exporting and importing classes.		* <vp>#export</vp>, <vp>#externally</vp> - exporting and importing classes.

Thomas Linder Puls: #options "/profile"

2019-02-26T15:06:20Z

#options "/profile"

← Older revision		Revision as of 17:06, 26 February 2019
Line 228:		Line 228:
	"/GOAL"		"/GOAL"
	"/MAXErrors"		"/MAXErrors"
	"/MAXWarnings"</vip>		"/MAXWarnings"
			"/profile"</vip>

	Otherwise the compiler generates the error message for invalid option.		Otherwise the compiler generates the error message for invalid option.

Thomas Linder Puls: Text File Inclusion

2019-02-21T15:12:24Z

Text File Inclusion

← Older revision		Revision as of 17:12, 21 February 2019
Line 34:		Line 34:

	If the compiler does not find the specified file a compiling time error is generated.		If the compiler does not find the specified file a compiling time error is generated.

			=== Text File Inclusion ===

			The <vp>#stringinclude</vp> compiler directive is used to include (during compilation) the contents of a file (specified by the {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} string) as a ::{{lang2\|Built-in_entities\|string\|string}} constant into your program source code. It has the following syntax:

			<vipbnf><Pp_dir_bininclude> :
			#stringinclude( <String_literal> )</vipbnf>

			This directive can be used in any places where {{lang2\|Built-in_entities\|string\|string}} constants are allowed. The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive. If the file has a byte-order-mark it will be treated accordingly, if the file does not have byte order mark and does not appear to be in utf-16 it will be read with the current codepage (it is recommended to use files with byte-order-mark utf-8 or utf-16).
			{{Example\|A typical usage is like this:
			<vip>
			constants
			myText : string = #stringinclude("text.txt").
			% String constant from contents of the file "text.txt".
			</vip>
			}}

	=== Binary File Inclusion ===		=== Binary File Inclusion ===

	The <vp>#bininclude</vp> compiler directive is used to include (during compilation) the contents of a file (specified by the {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} string) as a ::{{lang2\|Built-in_entities\|binary\|binary}} ~~type~~ constant into your program source code. It has the following syntax:		The <vp>#bininclude</vp> compiler directive is used to include (during compilation) the contents of a file (specified by the {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} string) as a ::{{lang2\|Built-in_entities\|binary\|binary}} constant into your program source code. It has the following syntax:

	<vipbnf><Pp_dir_bininclude> :		<vipbnf><Pp_dir_bininclude> :
	#bininclude ( <String_literal> )</vipbnf>		#bininclude( <String_literal> )</vipbnf>

	This directive can be used in any places where {{lang2\|Built-in_entities\|binary\|binary}} constants are allowed. The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive.		This directive can be used in any places where {{lang2\|Built-in_entities\|binary\|binary}} constants are allowed. The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive.

	~~The~~ typical usage is like this:		{{Example\|A typical usage is like this:
			<vip>
	<vip>constants		constants
	myBin : binary = #bininclude("Bin.bin").		myBin : binary = #bininclude("Bin.bin").
	% ~~Creates value of binary~~ constant from "Bin.bin" ~~file~~</vip>		% Binary constant from contents of the file "Bin.bin".
	~~When creating a binary constant the compiler adds the EOS symbol immediately after this constant, which makes safe the directive usages like this:~~		</vip>
			}}

	~~<vip>constants~~		When creating a binary constant the compiler adds the EOS symbol immediately after this constant.
	~~text : string = uncheckedConvert(string, #bininclude("text.txt")).~~
	~~% Here text~~.~~txt is a text file, which is normally not text zero terminated</vip>~~

	=== Exporting and Importing Classes ===		=== Exporting and Importing Classes ===

Thomas Linder Puls: link

2012-10-26T10:13:21Z

link

← Older revision		Revision as of 12:13, 26 October 2012
Line 220:		Line 220:
	=== Conditional Compilation ===		=== Conditional Compilation ===

	The conditional programming constructions are part of the Visual Prolog language. Only other compiler directives, {{~~lang2~~\|~~Compilation_Units\|Compilation_Units_and_Items~~\|Compilation Units}}, and {{~~lang2\|Program_Sections~~\|~~Program_Sections~~\|~~program sections~~}} (including empty) can be conditional. The following syntax is used:		The conditional programming constructions are part of the Visual Prolog language. Only other compiler directives, {{lang\|Compilation Units\|Compilation Units}}, and {{lang\|Program Sections\|Program Sections}} (including empty) can be conditional. The following syntax is used:

	<vipbnf><ConditionalItem> :		<vipbnf><ConditionalItem> :

Thomas Linder Puls: link

2012-10-26T10:11:23Z

link

← Older revision		Revision as of 12:11, 26 October 2012
Line 102:		Line 102:
	An <vp>#externally</vp> compiler directive is counterpart to an <vp>#export</vp> compiler directive. An <vp>#externally</vp> compiler directive can be used instead of (and concurrently with) an <vp>IMPORTS</vp> directive in definition files. An <vp>#externally</vp> compiler directive enumerates classes, which are declared in a module but implemented in other modules. Therefore, the compiler will not produce errors when it detects such classes. The referenced classes can be implemented (and exported) in DLLs, which can be linked to the module at runtime.		An <vp>#externally</vp> compiler directive is counterpart to an <vp>#export</vp> compiler directive. An <vp>#externally</vp> compiler directive can be used instead of (and concurrently with) an <vp>IMPORTS</vp> directive in definition files. An <vp>#externally</vp> compiler directive enumerates classes, which are declared in a module but implemented in other modules. Therefore, the compiler will not produce errors when it detects such classes. The referenced classes can be implemented (and exported) in DLLs, which can be linked to the module at runtime.

	The <vp>#export</vp> and <vp>#externally</vp> compiler directives can be used as <vpbnf><Condition></vpbnf> boolean expressions in {{lang2\|Directives\|~~Compiler_Directives~~\|Conditional ~~Directives~~}}.		The <vp>#export</vp> and <vp>#externally</vp> compiler directives can be used as <vpbnf><Condition></vpbnf> boolean expressions in {{lang2\|Directives\|Conditional Compilation\|Conditional Compilation}}.

	For example, like this:		For example, like this:

Thomas Linder Puls: /* Source File Inclusion */ color

2012-10-25T10:03:32Z

Source File Inclusion: color

← Older revision		Revision as of 12:03, 25 October 2012
Line 18:		Line 18:
	#include <String_literal></vipbnf>		#include <String_literal></vipbnf>

	The {{lang2\|Lexical_Elements\|String_Literals\|~~string_literal~~}} should specify an existing filename.		The {{lang2\|Lexical_Elements\|String_Literals\|<vpbnf><String_literal></vpbnf>}} should specify an existing filename.

	<~~vipbnf~~>#include "pfc\\exception\\exception.ph" % Includes pfc\exception\exception.ph file</~~vipbnf~~>		<vip>#include "pfc\\exception\\exception.ph" % Includes pfc\exception\exception.ph file</vip>

	<~~vipbnf~~>#include @"pfc\vpi\vpimessage\vpimessage.ph" % Includes pfc\vpi\vpimessage\vpimessage.ph</~~vipbnf~~>		<vip>#include @"pfc\vpi\vpimessage\vpimessage.ph" % Includes pfc\vpi\vpimessage\vpimessage.ph</vip>

	This compiler directive uses "include the first file occurrence only" semantics. That is, if a compilation unit contains several include directives for the same file, it will be included only one time with the first include directive.		This compiler directive uses "include the first file occurrence only" semantics. That is, if a compilation unit contains several include directives for the same file, it will be included only one time with the first include directive.

Alexander Doronin: /* Binary File Inclusion */

2012-06-09T09:06:08Z

Binary File Inclusion

← Older revision		Revision as of 11:06, 9 June 2012
Line 48:		Line 48:
	<vip>constants		<vip>constants
	myBin : binary = #bininclude("Bin.bin").		myBin : binary = #bininclude("Bin.bin").
	% Creates value of binary constant from "Bin.bin" file		% Creates value of binary constant from "Bin.bin" file</vip>
	When creating a binary constant the compiler adds the EOS symbol immediately after this constant, which makes safe the directive usages like this:		When creating a binary constant the compiler adds the EOS symbol immediately after this constant, which makes safe the directive usages like this:

Thomas Linder Puls: /* Binary File Inclusion */ formatting

2012-06-09T08:26:00Z

Binary File Inclusion: formatting

← Older revision		Revision as of 10:26, 9 June 2012
Line 42:		Line 42:
	#bininclude ( <String_literal> )</vipbnf>		#bininclude ( <String_literal> )</vipbnf>

	This directive can be used in any places where ::{{lang2\|Built-in_entities\|binary\|binary}} constants are allowed. The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive.		This directive can be used in any places where {{lang2\|Built-in_entities\|binary\|binary}} constants are allowed. The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive.

	~~When creating a binary constant the compiler adds the EOS symbol immediately after this constant, which makes safe the directive usages~~ like this:		The typical usage is like this:

	<vip>constants		<vip>constants
	~~text~~ : ~~::string~~ = ~~uncheckedConvert(string,~~ #bininclude ("~~text~~.~~txt~~")). % ~~Here text~~.~~txt is~~ a ~~text file~~, which		myBin : binary = #bininclude("Bin.bin").
	~~% is normally not text zero terminated</vip>~~		% Creates value of binary constant from "Bin.bin" file
			When creating a binary constant the compiler adds the EOS symbol immediately after this constant, which makes safe the directive usages like this:
	~~The typical usage is~~ like this:

	<vip>constants		<vip>constants
	~~myBin~~ : ~~::binary~~ = #bininclude ("~~Bin~~.~~bin~~"). ~~% Creates value of binary~~		text : string = uncheckedConvert(string, #bininclude("text.txt")).
	% ~~constant from "Bin~~.~~bin"~~ file		% Here text.txt is a text file, which is normally not text zero terminated</vip>
	~~myBin2 = #bininclude ("Bin2.bin"). % Short format of a binary~~
	~~% constant initialization~~</vip>

	=== Exporting and Importing Classes ===		=== Exporting and Importing Classes ===

Alexander Doronin: /* Binary File Inclusion */

2012-06-09T06:58:42Z

Binary File Inclusion

← Older revision		Revision as of 08:58, 9 June 2012
Line 43:		Line 43:

	This directive can be used in any places where ::{{lang2\|Built-in_entities\|binary\|binary}} constants are allowed. The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive.		This directive can be used in any places where ::{{lang2\|Built-in_entities\|binary\|binary}} constants are allowed. The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive.

			When creating a binary constant the compiler adds the EOS symbol immediately after this constant, which makes safe the directive usages like this:

			<vip>constants
			text : ::string = uncheckedConvert(string, #bininclude ("text.txt")). % Here text.txt is a text file, which
			% is normally not text zero terminated</vip>

	The typical usage is like this:		The typical usage is like this:
Line 51:		Line 57:
	myBin2 = #bininclude ("Bin2.bin"). % Short format of a binary		myBin2 = #bininclude ("Bin2.bin"). % Short format of a binary
	% constant initialization</vip>		% constant initialization</vip>

	In this example. Parsing the first constant <vp>myBin</vp> declaration, the compiler meets the <vp>#bininclude ("Bin.bin")</vp> directive. It checks whether the '''"Bin.bin"''' file exists in the directory where the source file containing this <vp>#bininclude ("Bin.bin")</vp> directive is placed or whether the '''"Bin.bin"''' file exists in one of directories specified in the '''Include Directories''' list box in the '''Project Settings''' dialog (in directories defined by the <vp>/Include</vp> command line option). If the compiler finds the '''"Bin.bin"''' file, then it reads it. From the file contents the compiler forms correct data of the ::{{lang2\|Built-in_entities\|binary\|binary}} domain and place it as the <vp>myBin</vp> constant value. For example, if the '''"Bin.bin"''' file contains only one <vp>A</vp> character, then the <vp>myBin</vp> constant obtains the following value:

	~~<vip>myBin = $[0x41] % Here 0x41 is the hexadecimal ASCII value of 'A'</vip>~~

	=== Exporting and Importing Classes ===		=== Exporting and Importing Classes ===

Alexander Doronin: /* Binary File Inclusion */

2012-06-09T06:08:04Z

Binary File Inclusion

← Older revision		Revision as of 08:08, 9 June 2012
Line 42:		Line 42:
	#bininclude ( <String_literal> )</vipbnf>		#bininclude ( <String_literal> )</vipbnf>

	~~The <vp>#bininclude</vp> compiler~~ directive ~~instructs the compiler to insert the contents of the specified file as the value of a~~ ::{{lang2\|Built-in_entities\|binary\|binary}} ~~constant~~. ~~This~~ directive ~~can be used~~ in ~~any places where ::~~{{lang2\|~~Built-in_entities~~\|~~binary~~\|~~binary~~}} ~~constants are allowed~~.		This directive can be used in any places where ::{{lang2\|Built-in_entities\|binary\|binary}} constants are allowed. The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive.

	The typical usage is like this:		The typical usage is like this:
Line 55:		Line 55:

	<vip>myBin = $[0x41] % Here 0x41 is the hexadecimal ASCII value of 'A'</vip>		<vip>myBin = $[0x41] % Here 0x41 is the hexadecimal ASCII value of 'A'</vip>

	The {{lang2\|Lexical_Elements\|String_Literals\|string_literal}} should specify an existing filename. The syntax is the same as in the <vp>#include</vp> compiler directive described in the previous paragraph {{lang2\|Directives\|Source_File_Inclusion\|Source File Inclusions}}. The compiler tries to find the specified file in the same way as for <vp>#include</vp> compiler directive.

	=== Exporting and Importing Classes ===		=== Exporting and Importing Classes ===