5 - Editors in CoDeSys 
CoDeSys V2.3 
5-3 
Add variables to watch list 
If one or several variables or elements are selected in one of the POU editors, these can be inserted 
in a new or existing watch list via appropriate commands in the context menu. For details see 6.8.2. 
Creating Watchlists, Recipes. 
5.2 Declaration Editor 
5.2.1 Working in the Declaration Editor 
The declaration editor is used to declare variables of POUs and global variables, for data type 
declarations, and in the Watch- and Recipe Manager. It gives access to the usual Windows functions, 
and even those of the IntelliMouse can be used if the corresponding driver is installed. 
In Overwrite mode, 'OV' is shown in black on the status bar; switching between Overwrite and Insert 
modes can be accomplished with the <Ins> key. 
The declaration of variables is supported by syntax coloring. 
The most important commands are found in the context menu (right mouse button or <Ctrl>+<F10>). 
Hint:  
Regard the possibility of using pragmas to affect the properties of a variable concerning the 
compilation resp. precompilation process (see chapter 5.2.3). 
Declaration Part 
All variables to be used only in this POU are declared in the declaration part of the POU. These can 
include: input variables, output variables, input/output variables, local variables, remanent variables 
and constants. The declaration syntax is based on the IEC61131-3 standard.  
For a recommendation on the use of identifiers please see Appendix J: . 
Regard the possibility of using templates for objects of type 'Global Variables', 'Data types', 'Function', 
'Function Block' or 'Program' , see Chapter 4.3, 'File' New from template'. 
An example of a correct declaration of variables in CoDeSys-Editor: 
Input Variable 
Between the key words VAR_INPUT and END_VAR, all variables are declared that serve as input 
variables for a POU. That means that at the call position, the value of the variables can be given along 
with a call. 
Example: 
Pdf mail merge - Merge, append PDF files in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Provide C# Demo Codes for Merging and Appending PDF Document
acrobat split pdf into multiple files; reader combine pdf pages
Pdf mail merge - VB.NET PDF File Merge Library: Merge, append PDF files in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
VB.NET Guide and Sample Codes to Merge PDF Documents in .NET Project
scan multiple pages into one pdf; c# merge pdf pages
Declaration Editor 
5-4 
CoDeSys V2.3 
VAR_INPUT 
iIn1:INT (* 1. Inputvariable*) 
END_VAR 
Output Variable 
Between the key words VAR_OUTPUT and END_VAR, all variables are declared that serve as output 
variables of a POU. That means that these values are carried back to the POU making the call. There 
they can be answered and used further. 
Example: 
VAR_OUTPUT 
iOut1:INT; (* 1. Outputvariable*) 
END_VAR 
Input and Output Variables 
Between the key words VAR_IN_OUT and END_VAR, all variables are declared that serve as input 
and output variables for a POU. 
Attention:  With this variable, the value of the transferred variable is changed ("transferred as a pointer", Call-by-
Reference). That means that the input value for such variables cannot be a constant. For this reason, 
even the VAR_IN_OUT variables of a function block can not be read or written directly from outside 
via <functionblockinstance><in/outputvariable>.  
Example: 
VAR_IN_OUT 
iInOut1:INT; (* 1. Inputoutputvariable *) 
END_VAR 
Local Variables 
Between the keywords VAR and END_VAR, all of the local variables of a POU are declared. These 
have no external connection; in other words, they can not be written from the outside. 
Example: 
VAR 
iLoc1:INT; (* 1. Local Variable*) 
END_VAR 
Remanent variables 
Remanent variables can retain their value throughout the usual program run period. These include 
Retain variables and Persistent variables. 
Example: 
VAR RETAIN 
iRem1:INT; (* 1. Retain variable*) 
END_VAR 
Retain variables are identified by the keyword RETAIN. These variables maintain their value even 
after an uncontrolled shutdown of the controller as well as after a normal switch off and on of the 
controller (resp. at the command 'Online' 'Reset', see Chapter 4.6). When the program is run again, 
the stored values will be processed further. A concrete example would be an piece-counter in a 
production line, that recommences counting after a power failure.    
All other variables are newly initialized, either with their initialized values or with the standard 
initializations. 
Contrary to Persistent variables Retain Variables are reinitialized at a new download of the 
program.  
Persistent variables are identified by the keyword PERSISTENT. Unlike Retain variables, these 
variables retain their value only after a re-Download, but not after an 'Online' 'Reset', 'Online' 
C# Word - MailMerge Processing in C#.NET
Mail Merge Processing. |. Home ›› XDoc.Word ›› C# Word: Process Mail Merge. IDocument doc = document0.GetDocument().Clone(); // Execute mail merge.
add pdf together one file; c# merge pdf files
C# Word - Merge Word Documents in C#.NET
C# Word - Merge Word Documents in C#.NET. Provide C# Demo Codes for Merging and Appending Word Document. Combine and Merge Multiple Word Files into One Using C#.
add pdf files together reader; pdf mail merge
5 - Editors in CoDeSys 
CoDeSys V2.3 
5-5 
'Reset (original)' or 'Online' 'Reset (cold)' (see Chapter 4.6 each), because they are not saved in 
the "retain area". If also persistent variables should maintain their values after a uncontrolled 
shutdown of the controller, then they have to be declared additionally as VAR RETAIN variables. A 
concrete example of "persistent Retain-Variables" would be a operations timer that recommences 
timing after a power failure. 
Attention:  
- If a local variable in a program is declared as VAR RETAIN, then exactly that variable will be saved  
in the retain area (like a global retain variable)  
- If a local variable in a function block is declared as VAR RETAIN, then the complete instance of  
the function block will be saved in the retain area (all data of the POU), whereby only the declared  
retain variable will be handled as a retain. 
- If a local variable in a function is declared as VAR RETAIN, then this will be without any effect. The  
variable will not be saved in the retain area! If a local variable is declared as PERSISTENT in a 
function, then this will be without any effect also! 
x = value will be retained    - = value gets reinitialized 
after Online command 
VAR 
VAR RETAIN 
VAR PERSISTENT 
VAR RETAIN PERSISTENT 
VAR PERSISTENT RETAIN 
Reset 
Reset (Kalt) 
Reset (Ursprung) 
Download 
Online Change 
Constants, Typed Literals 
Constants are identified by the key word CONSTANT. They can be declared locally or globally. 
Syntax: 
VAR CONSTANT 
<Identifier>:<Type> := <initialization>;  
END_VAR 
Example: 
VAR CONSTANT 
c_iCon1:INT:=12; (* 1. Constant*) 
END_VAR 
See Appendix B: Operands in CoDeSys, for a listing of possible constants. See there also regarding 
the possibility of using typed constants (Typed Literals). 
External variables 
Global variables which are to be imported into the POU are designated with the keyword EXTERNAL. 
They also appear in the Watch window of the declaration part in Online mode. 
If the VAR_EXTERNAL declaration does not match the global declaration in every respect, the 
following error message appears: "Declaration of '<var>' does not match global declaration!" 
If the global variable does not exist, the following error message appears: "Unknown global variable: 
'<var>'!" 
Example: 
VAR EXTERNAL 
iVarExt1:INT:=12; (* 1st external variable *) 
END_VAR 
How to C#: Overview of Using XDoc.Word
Tell C# users how to: create a new Word file and load Word from pdf; merge, append, and split Word files; insert, delete, move, rotate, copy and paste Word
reader create pdf multiple files; pdf mail merge plug in
How to C#: Convert PDF, Excel, PPT to Word
Images. Convert Word to ODT. Convert PDF to Word. Convert ODT to Word. Document Delete Word Pages. Page: Move Word Page Position. Page: Extract Word Pages. Mail
append pdf; c# pdf merge
Declaration Editor 
5-6 
CoDeSys V2.3 
Keywords 
Keywords are to be written in uppercase letters in all editors. Keywords may not be used as variables. 
Examples for keywords: VAR, VAR_CONSTANT, IF, NOT, INT. 
Variables declaration 
A variables declaration has the following syntax: 
<Identifier> {AT <Address>}:<Type> {:=<initialization>};  
The parts in the braces {} are optional.  
Regarding the identifier, that is the name of a variable, it should be noted that it may not contain 
spaces or umlaut characters, it may not be declared in duplicate and may not be identical to any 
keyword. Upper/lowercase writing of variables is ignored, in other words VAR1, Var1 and var1 are not 
different variables. Underlines in identifiers are meaningful, e.g. A_BCD and AB_CD are interpreted 
as different identifiers. Multiple consecutive underlines at the beginning of an identifier or within a 
identifier are not allowed. The length of the identifier, as well as the meaningful part of it, is unlimited. 
All declarations of variables and data type elements can include initialization. They are brought about 
by the ":=" operator. For variables of elementary types, these initializations are constants. The default-
initialization is 0 for all declarations. 
Example: 
iVar1:INT:=12; (* Integer variable with initial value of 12*) 
If you wish to link a variable directly to a definite address, then you must declare the variable with the 
keyword AT
For faster input of the declarations, use the shortcut mode.  
In function blocks you can also specify variables with incomplete address statements. In order for 
such a variable to be used in a local instance, there must be an entry for it in the variable 
configuration. 
Pay attention to the possibilities of an automatic declaration resp. of using pragmas to affect the 
properties of variables concerning the compilation process. 
AT Declaration 
If you wish to link a variable directly to a definite address, then you must declare the variable with the 
keyword AT. The advantage of such a procedure is that you can assign a meaningful name to an 
address, and that any necessary changes of an incoming or outgoing signal will only have to be made 
in one place (e.g., in the declaration).  
Notice that variables requiring an input cannot be accessed by writing.  
Examples: 
xCounterHeat7 AT %QX0.0: BOOL; 
wLightcabinetimpulse AT %IW2: WORD; 
xDownload AT %MX2.2: BOOL; 
Note:  
If boolean variables are assigned to a Byte, Word or DWORD address, they occupy one byte with 
TRUE or FALSE, not just the first bit after the offset! 
'Insert' 'Declaration keywords'  
You can use this command to open a list of all the keywords that can be used in the declaration part 
of a POU. After a keyword has been chosen and the choice has been confirmed, the word will be 
inserted at the present cursor position.  
You also receive the list, when you open the Input Assistant (<F2>) and choose the Declarations 
category. 
C# Word - Convert Word to PDF in C#.NET
Word: Convert Word to PDF. C# Word - Convert Word to PDF in C#.NET. Online C# Tutorial for Converting Word to PDF (.pdf) Document. Word to PDF Conversion Overview
acrobat reader merge pdf files; pdf merge documents
C# PDF Convert to Word SDK: Convert PDF to Word library in C#.net
Password protected PDF file can be printed to Word for mail merge. C# source code is available for copying and using in .NET Class.
merge pdf online; pdf merger
5 - Editors in CoDeSys 
CoDeSys V2.3 
5-7 
'Insert' 'Type'  
With this command you will receive a selection of the possible types for a declaration of variables. You 
also receive the list when you access the Input Assistant (<F2>). 
The types are divided into the following categories: 
Standard types  BOOL, BYTE, etc. 
Defined types  Structures, enumeration types, etc. 
Standard function blocks for instance declarations 
Defined function blocks for instance declarations 
CoDeSys supports all standard types of IEC1131-3: 
Syntax Coloring 
In all editors you receive visual support in the implementation and declaration of variables. Errors are 
avoided, or discovered more quickly, because the text is displayed in color.  
A comment left unclosed, thus annotating instructions, will be noticed immediately; keywords will not 
be accidentally misspelled, etc. 
The following color highlighting will be used: 
Blue 
Keywords 
Green Comments in the text editors 
Pink 
Special constants (e.g. TRUE/FALSE, T#3s, %IX0.0) 
Red 
Input error (for example, invalid time constant, keyword, written in lower case,...) 
Black 
Variables, constants, assignment operators, ...  
Shortcut Mode 
The declaration editor for CoDeSys allows you to use the shortcut mode. This mode is activated when 
you end a line with <Ctrl><Enter> 
The following shortcuts are supported: 
All identifiers up to the last identifier of a line will become declaration variable identifiers  
The type of declaration is determined by the last identifier of the line. In this context, the following will 
apply: 
B or BOOL 
gives the result BOOL 
I or INT 
gives the result INT 
R or REAL 
gives the result REAL 
S or string  
gives the result STRING 
If no type has been established through these rules, then the type is BOOL and the last identifier will 
not be used as a type (Example 1.). 
Every constant, depending on the type of declaration, will turn into an initialization or a string 
(Examples 2. and 3.). 
An address (as in %MD12) is extended around the ATATDeclaration>Proc... attribute(Example 4.). 
A text after a semicolon (;) becomes a comment (Example 4.). 
All other characters in the line are ignored (e.g., the exclamation point in Example 5.). 
Examples: 
XDoc.Word for .NET, Advanced .NET Word Processing Features
mail-merge in OpenXML file, Microsoft access database and field; More about Word Mail-Merge ▶. Extract raw image or clipped and scaled image from PDF file.
reader merge pdf; combine pdf files
C# Word - Process Word Document in C#
Word document processing implementations using C# demo codes, such as add or delete Word document page, change Word document pages order, merge or split Word
c# merge pdf files into one; acrobat combine pdf files
Declaration Editor 
5-8 
CoDeSys V2.3 
Shortcut 
Declaration 
A: BOOL; 
A B I 2 
A, B: INT := 2; 
ST S 2; A string 
ST:STRING(2); (* A string *) 
X %MD12 R 5 Real Number 
X AT %MD12: REAL := 5.0;(* Real Number *) 
B ! 
B: BOOL; 
Autodeclaration 
If the Autodeclaration option has been chosen in the Editor category of the Options dialog box , then a 
dialog box will appear in all editors after the input of a variable that has not yet been declared. With 
the help of this dialog box, the variable can now be declared.  
Dialog Box for Declaration of Variables 
With the help of the Class combo box , select whether you are dealing with a local variable (VAR), 
input variable (VAR_INPUT), output variable (VAR_OUTPUT), input/output variable (VAR_INOUT), or 
a global variable (VAR_GLOBAL).  
With the CONSTANTRETAIN, PERSISTENT options, you can define whether you are dealing with a 
constant or a retain variable  
The variable name you entered in the editor has been entered in the Name field, BOOL has been 
placed in the Type field. The 
button opens the Input Assistant dialog which allows you to select 
from all possible data types. 
Declaration of Arrays:
If ARRAY is chosen as the variable type, the dialog for entering array boundaries appears.  
Dialog for determining array boundaries during automatic declaration 
.
For each of the three possible dimensions (Dim.), array boundaries can be entered under Start 
and End by clicking with the mouse on the corresponding field to open an editing space. The array 
data type is entered in the Type field. In doing this, the 
button can be used to call up an input 
assistant dialog. 
Upon leaving the array boundaries dialog via the OK button, variable declarations in IEC format 
are set up based on the entries in the Type field in the dialog. Example: ARRAY [1..5, 1..3] OF INT 
VB.NET Image: Barcode Reader SDK, Read Intelligent Mail from Image
VB.NET Demo Code to Decode Intelligent Mail on PDF Page. With the help of well developed image barcode reading API methods and following demo code in VB program
batch merge pdf; merge pdf
How to C#: Quick to Start Using XDoc.Word
To meet your requirement, on this quick to start page, we will tell how to create a C# console application, merge two Word files, and save into a new Word file
pdf merge files; break pdf file into multiple files
5 - Editors in CoDeSys 
CoDeSys V2.3 
5-9 
In the field Initial value, you may enter the initial value of the variable being declared. If this is an 
array or a valid structure, you can open a special initialization dialog via the 
button or open the 
input assistant dialog for other variable types.  
In the initialization dialog for an array you are presented a list of array elements; a mouse click on 
the space following „:="opens an editing field for entering the initial value of an element.  
In the initialization dialog for a structure, individual components are displayed in a tree structure. 
The type and default initial value appear in brackets after the variable name; each is followed by 
„:=". A mouse click on the field following „:=" opens an editing field in which you can enter the 
desired initial value. If the component is an array, then the display of individual fields in the array 
can be expanded by a mouse click on the plus sign before the array name and the fields can be 
edited with initial values. 
After leaving the initialization dialog with OK, the initialization of the array or the structure appears 
in the field Initial value of the declaration dialog in IEC format. 
Example: x:=5,field:=2,3,struct2:=(a:=2,b:=3)  
In the Address field, you can bind the variable being declared to an IEC address (AT declaration).  
If applicable, enter a Comment. The comment can be formatted with line breaks by using the key 
combination <Ctrl> + <Enter>. 
By pressing OK, the declaration dialog is closed and the variable is entered in the corresponding 
declaration editor in accordance to the IEC syntax. 
Note:  
The dialog box for variable declaration you also get by the command 'Edit' 'Declare Variable'. If the 
cursor is resting on a variable in Online mode, the Autodeclare window can be opened with 
<Shift><F2> with the current variable-related settings displayed. 
Line Numbers in the Declaration Editor 
In offline mode, a simple click on a special line number will mark the entire text line. 
In the online mode, a single click on a specific line number will open up or close the variable in this 
line, in case a structural variable is involved. 
Declarations as tables  
If the Declarations as tables option is activated in the Project Options (category ‘Editor’) or – if you 
already are working in the declaration editor – in the context menu, the declaration editor will look like 
a table. As in a card-index box, you can select the register cards of the respective variable types and 
edit the variables. 
For each variable you are given the following entry fields. 
Name: 
Input the identifier of the variable. 
Address: If necessary, input the address of the variable (AT declaration) 
Type: 
Input the type of the variable. (Input the function block when instantiating a function 
block) 
Initial: 
Enter a possible initialization of the variable (corresponding to the ":= " assignment 
operator). 
Comment: Enter a comment here.  
Both of the display types of the declaration editor can be changed without causing any problems. In 
online mode there are no different display types. 
Insert new declaration:
In order to edit a new variable, select the 'Insert' 'New Declaration' command (see below). 
Sorting the declarations:
Declaration Editor 
5-10 
CoDeSys V2.3 
In order to sort the table entries, set the cursor to the line number bar at the left border of the editor 
window and choose one of the following commands in the context menu:  
Sort by name: All lines are sorted alphabetically according to the identifier names in column ‘Name’. 
Sort by address: All lines are sorted alphabetically according to the address entries in column 
‘Address’. 
Sort by type: All lines are sorted alphabetically according to the type names in column ’Type’. 
Original order: The lines are displayed in the order in which they had been entered originally. 
Declaration Editor as a Table 
'Insert' 'New Declaration'  
With this command you bring a new variable into the declaration table of the declaration editor. If the 
present cursor position is located in an field of the table, then the new variable will be pasted in the 
preceding line; otherwise, the new variable is pasted at the end of the table. Moreover, you can paste 
a new declaration at the end of the table by using the right arrow key or the tab key in the last field of 
the table. 
You will receive a variable that has "Name" located in the Name field, and "Bool" located in the Type 
field, as its default setting. You should change these values to the desired values. Name and type are 
all that is necessary for a complete declaration of variables.  
5.2.2 Declaration Editors in Online Mode 
In online mode, the declaration editor changes into a monitor window. In each line there is a variable 
followed by the equal sign (=) and the value of the variable. If the variable at this point is undefined, 
three question marks (???) will appear. For function blocks, values are displayed only for open 
instances (command: 'Project' 'Open instance').  
In front of every multi-element variable there is a plus sign. By pressing <Enter> or after 
doubleclicking on such a variable, the variable is opened up. In the example, the traffic signal 
structure would be opened up. 
When a variable is open, all of its components are listed after it. A minus sign appears in front of the 
variable. If you double-click again or press <Enter>, the variable will be closed, and the plus sign will 
reappear. 
Pressing <Enter> or double-clicking on a single-element variable will open the dialog box to write a 
variable. Here it is possible to change the present value of the variable. In the case of Boolean 
variables, no dialog box appears; these variables are toggled. 
5 - Editors in CoDeSys 
CoDeSys V2.3 
5-11 
The new value is displayed after the variable, in pointed brackets and in turquoise color, and remains 
unchanged. If the 'Online' 'Write values' command is given, then all variables are placed in the 
selected list and are once again displayed in black. 
If the 'Online' 'Force values' command is given, then all variables will be set to the selected values, 
until the 'Release force' command is given. In this event, the color of the force value changes to red 
5.2.3 Pragma instructions in the Declaration Editor 
The pragma instruction is used to affect the properties of a variable concerning the compilation resp. 
precompilation process. It can be used in with supplementary text in a program line of the declaration 
editor or in its own line. 
The pragma instruction is enclosed in curly brackets, upper- and lower-case are ignored: { <Instruction 
text> } 
If the compiler cannot meaningfully interpret the instruction text, the entire pragma is handled as a 
comment and read over. A warning is issued: „Ignore compiler directive ‚<Instruction text>’!" 
Depending on the type and contents of pragma, the pragma either operates on the line in which it is 
located or on all subsequent lines until it is ended by an appropriate pragma, or the same pragma is 
executed with different parameters, or the end of the file is reached. By file we mean here: declaration 
part, implementation portion, global variable list, type declaration. 
The opening bracket may immediately follow a variable name. Opening and closing brackets must be 
located on the same line.  
The following pragmas are currently available in CoDeSys:
 Pragma {flag …} for Initialization,  Monitoring, Creation of symbols 
 Pragma {bitaccess ...} for the Bitaccess 
 Pragma {link} for Linking a POU or DUT 
 Pragmas {parameter ..}, {template...}, {instance...} for creating for Parameter Manager entries 
 Pragma {library ...} for controlling the display of library declaration parts 
Pragma instructions for Initialization, Monitoring, Creation of symbols, Bitaccess, Linking 
Pragma {flag [<flags>] [off|on]}  
<flags> can be a combination of the following flags: 
noinit: 
The variable will not be initialized. 
nowatch: 
The variable can not be monitored 
noread: 
The variable is exported to the symbol file without read permission 
nowrite: 
The variable is exported to the symbol file without write permission 
noread, nowrite: 
The variable will not get exported to the symbol file 
With the „on" modifier, the pragma operates on all subsequent variable declarations until it is 
ended by the pragma {flag off}, or until overwritten by another {flag <flags> on} pragma. 
Without the „on" or „off" modifier, the pragma operates only on the current variable declaration 
(that is the declaration that is closed by the next semicolon). 
Examples for use of pragma {flag}:  
Initialization and monitoring of variables:
The variable a will not be initialized and will not be monitored. The variable b will not be 
initialized: 
Declaration Editor 
5-12 
CoDeSys V2.3 
VAR 
a : INT {flag noinit, nowatch}; 
b : INT {flag noinit }; 
END_VAR 
VAR 
{flag noinit, nowatch on} 
a : INT; 
{flag noinit on} 
b : INT; 
{flag off} 
END_VAR 
Neither variable will be initialized: 
{flag noinit on} 
VAR 
a : INT; 
b : INT; 
END_VAR 
{flag off} 
VAR 
{flag noinit on} 
a : INT;  
b : INT; 
{flag off} 
END_VAR 
Getting variables to the symbol file:
The flags „noread" and „nowrite" are used, in a POU that has read and/or write permission, to provide 
selected variables with restricted access rights. The default for the variable is the same as the setting for 
the POU in which the variable is declared. If a variable has neither read nor write permission, it will not 
be exported into the symbol file. 
Examples:  
If the POU has read and write permission, then with the following pragmas variable a can only be 
exported with write permission, while variable b can not be exported at all: 
VAR 
a : INT {flag noread}; 
b : INT {flag noread, nowrite}; 
END_VAR 
VAR 
{ flag noread on} 
a : INT; 
{ flag noread, nowrite on} 
b : INT; 
{flag off} 
END_VAR 
Neither variable a nor b will be exported to the symbol file: 
{ flag noread, nowrite on } 
VAR 
a : INT;  
b : INT; 
END_VAR 
{flag off} 
VAR 
{ flag noread, nowrite on} 
a : INT;  
b : INT; 
{flag off} 
END_VAR 
The pragma operates additively on all subsequent variable declarations.
Example: (all POUs in use will be exported with read and write permission) 
a : afb; 
Documents you may be interested
Documents you may be interested