Post-Processor Language¶

Post-Processor Language Files¶

The file that contains all of the post-processor language to define how machine independent NC programs are to be converted to G-Code files for a single machine/control combination is often incorrectly referred to as a "Post". It is the logic embedded in such a file, together with the Vericut Post-Processor program that performs the processing task, but we have no intention of fighting the nomenclature.

A "post" file must contain all the language needed for a machine/control combination. It cannot make reference to other language files, even for subroutines that are common to many machine/control combinations. Each subroutine needed must be present in the single file that will be accessed by the Vericut post-processor. The default file extension for a "post" file is ".VcPost".

A VcPost file is typically encoded with ASCII. The language does not require the use of any non-ASCII characters, but if a user needs to generate comments in the output G-Code, or in the post-processor's log, with accented vowels or Eastern languages, a VcPost file can be encoded with UTF-8 or Unicode. Any suitable text editor can be used to create and maintain VcPost files. A word-processor can be used if you take great care to avoid saving the files with any formatting information. The text editor embedded in Vericut is a viable solution.

It is strongly recommended that you follow good programming practices in terms of indenting blocks of logic to make the code more legible. Recognizing that we haven't yet explained any of the language's syntax, the following snippet may make it clear what is meant by indenting.

Sub GOTO

  If (G = 0) Then

    If (Z < Z.Previous) Then

      Out "<N><G><X><Y>"

      Out "<N><G><Z>"

    Else

      Out "<N><G><Z>"

      Out "<N><G><X><Y>"

    End If

  Else

    Out "<N><G><X><Y><Z><F>"

  End If

End Sub

Statements, Continuations, and Comments¶

Statements

Elements of the post-processor language are organized in statements to create a VcPost. Very often a statement and a line of the file are the same thing. Using a piece of the same code snippet from the previous page to illustrate this, still without any explanation of the contents of the statements, ...

If (Z < Z.Previous) Then

  Out "<N><G><X><Y>"

  Out "<N><G><Z>"

Else

  Out "<N><G><Z>"

  Out "<N><G><X><Y>"

End If

... has seven statements. Many programming languages use a particular character to denote the end of a statement, such as the semi-colon in C and Java. This is not the case in BASIC, or in our post-processor language. The end of a statement is the end of the line, unless the rightmost pair of characters indicates a continuation.

Continuations

The continuation characters are a space followed by an underscore, " _". It is easy to think of the underscore alone as being the continuation character, but an underscore can be used at the end of a variable name, such as "Radius_". We are not recommending this because it would make the code more difficult to read. But if a name like this appeared at the end of a line, the post-processor would treat the next line as the first of another statement. An underscore which is intended to signify a continuation of the current line's statement should be separated from the rest of the characters by at least one space. For example;

Radius = squareRoot((X.Current - X.Previous) ^ 2 _

  + (Y.Current - Y.Previous) ^ 2)

Trying to split a function name or variable name between two lines of a statement is a bad idea. It makes the code hard to read, and won't work. We haven't covered the topic of string constants yet, but they consist of any characters between double-quotation marks. "Any" includes the underscore character, so a single string constant cannot span two lines of a statement. It is necessary to split the string into two or more, and concatenate them as follows;

Sentence = "The quick brown fox jumps" _

  & " over the lazy dog."

Strictly it is not necessary to use continuation characters at all. There is no practical limit on the length of a line of code. But it makes sense to restrict lines to the width that can be displayed by your text editor without having to scroll horizontally.

Comments

A comment can be appended to any line of code, simply by adding a single-quotation mark and any characters for the comment.

Radius = 0.5 * Diameter 'This is a comment

It is also possible for a line to contain nothing but a comment, and this may well be the better style to adopt for legibility.

' This line is just a comment

Radius = 0.5 * Diameter

A line with the continuation characters can also end with a comment, but this really gets ugly because it makes it more difficult to see the continuations.

Sentence = "The quick" _ 'This sentence

  & " brown fox" _ 'contains all

  & " jumps over" _ 'the letters of

  & " the lazy dog." 'the alphabet

It would be much better to give the comment its own line.

' This sentence contains all the letters of the alphabet

Sentence = "The quick brown fox jumps over the lazy dog."

While you can append comments to continued lines, it is not possible, nor necessary, to split extensive comments into continuation lines. Since a comment can contain any characters, a space and underscore on the right end will not cause the next line to be treated as a continuation. If you need a multi-line comment, just use several individual comment lines.

' Check for RAPID and perform horizontal or vertical

'       moves, or vice versa, to "square" the motion.

No other syntax to denote a comment is supported. In particular the "Rem" style that appears in some flavors of BASIC cannot be used.

Variables¶

There are just three types of variables in the post-processor language; numeric values, text strings and an object analogous to a control's register that has both numeric and text properties. We will refer to these three variable types as simply numbers, strings and registers. There is no Boolean variable type. All Variables defined in the post-processor are "global".

Variable names can be any combination of letters of the alphabet, numerals and the underscore character, but must begin with a letter. There is no practical limit to their length, so you can make them very descriptive. Names are case insensitive, so "radius", "Radius" and "RADIUS" are synonymous and are processed as identical. This relaxed attitude also applies to reserved words in the language such as "If", "Then" and "Else", and also to subroutine and function names. There are two schools of thought when it comes to compound names. One uses uppercase for the first letter of each word, such as "CircleRadius", while the other separates the words with an underscore, such as "circle_radius". We suggest that you pick a style and stick with it. Having both in the same VcPost file would be an invitation to bugs, since "CircleRadius" and "circle_radius" are not synonymous.

Unlike BASIC, the post-processor language has no declaration statements, such as "Dim". We will leave the topic of registers for a while, but if the following statements are the first to be executed that refer to "Radius" and "Tool", then their types will be number and string respectively.

Radius = 0.125

Tool = "Drill"

Once a variable has been defined, its type cannot be altered. So the following statement

Tool = 5

would generate an error if it followed the prior lines.

This may not mean much yet, but also unlike BASIC, all variables are global in scope. If you define a variable in one segment of your VcPost file, it is accessible from all others, without the need to pass it as an argument between subroutines.

Variable names must be unique across all variable types, so you cannot have a number and a string both called "Turret". There are reserved variable names which you must avoid using for anything but their intended purpose.

Numbers

A number variable retains a 64bit precision numeric value. 64bit precision is good for about 15 significant decimal digits. There is no distinction between fixed point values, sometimes called integers, and floating point values, sometimes called floats or doubles. Numeric constants can use integer, decimal or scientific notation. Thus the following are all valid; 2, +3, -4, 1.625, -3.75, 1.E6, 2.25e-3, -4.125E+3. Note that embedded spaces in a numeric constant are a bad idea. Use of a thousands separator, as in "1,000,000" would not produce the desired result.

If you want to format a number variable for output, it should instead be defined as a register. There are numerous functions for performing mathematical operations on number variables.

Strings

A string variable retains a sequence of characters. There is no practical limit on the number of characters. A string constant is a sequence of characters enclosed by double-quotation marks.

Sample = "This is a sample string constant."

If a string constant needs to contain a double-quotation mark, then two such marks should be used. For example;

Exclaim = """Hey!"", he said, ""Get off!"""

There are many functions for manipulating string variables.

Mixing

Number and string variable types cannot be mixed in arithmetic, string concatenation or logical expressions. Thus if "Radius1" and "Radius2" are defined by;

Radius1 = 3.5

Radius2 = "1.25"

then any of the following statements will generate an error;

Sum = Radius1 + Radius2

Range = Radius1 & " to " & Radius2

If (Radius1 > Radius2) Then

Registers¶

A register is analogous to a control or machine register. It contains current and previous floating point numeric values. It also carries information on how its current value is to be formatted in a G-Code file and in the post-processor log. The numeric values are limited to lie in a range, either dictated by the number of digits in the formatting, or specified by tighter constraints. A scale can be applied to the current value prior to formatting.

Syntactically a register is treated like an Object in Visual Basic. It has several properties but no methods. Samples of the properties and syntax used to access them are;

X.Prefix = "X"

MyRegister.Suffix = “] “

X.Format = "s3.3sm"

X.Minimum = -499.999

X.Maximum = 500

If (X.Scale < 0) Then

DeltaX = X.Current - X.Previous

Message = "Set vernier to " & X.Output

A new variable is defined as a register as soon as the variable name is encountered with a trailing period. Many registers are predefined and have reserved names, such as X, Y, and Z for the first 3 machine axes.

To shorten code and perhaps make it more comprehensible, a register variable name can appear without a trailing period. If it appears in an arithmetic expression, an unqualified register name implies its. Current property, thus the following lines of code have the same effect;

Diameter = 2.0 + Z

Diameter = 2.0 + Z.Current

If an unqualified register name appears where a string is expected, such as in concatenation, it is formatted. Output property is assumed. So the following lines of code have the same effect;

Message = "Raise to " & Z & " now."

Message = "Raise to " & Z.Output & " now."

There is one function of note for use with registers;

Zap R

This function will reset the previous value of register R to an undefined state. This is useful for a modal register when it is necessary to force output of the current value even when it may not have changed, perhaps after a tool change.

Properties

Arrays¶

Variables of all three types; numeric values, text strings and registers, can be grouped into arrays. While it is possible to mix the types of variables in a single array, it would be much more common to have, for example, an array of numeric values or an array of text strings. The same rules that apply to variable names also apply to array names. They can be any combination of letters of the alphabet, numerals and the underscore character, but must begin with a letter.

Unlike BASIC, the post-processor language has no syntax for declaring arrays. The following statements assign values, numeric or textual, to array members.

  Tool(1) = "Drill"

  Tool(2) = "CounterSink"

  Tool(3) = "Tap"

  Depth(1) = 3.0

  Depth(2) = 0.125

  Depth(3) = 2.5

Once an array member has been defined, its type cannot be altered. So

Tool(2) = 5

would generate an error if it followed the prior lines.

Just like variables, array members are global in scope. Once an array member has been assigned a value, it can be used in subsequent statements in the same way that a variable can. So if "ToolNo" has been defined and contains a suitable numeric value, then the following would be a valid statement,

Z = Z - Depth(ToolNo)

Note that the array index or subscript, "ToolNo" in this case, will always be rounded to the nearest integer value.

If you wish to have an array of registers, then to reference one of the member's properties, the syntax would be "Reg_Name(Array_Index).Property", for example;

G(2).Prefix = " G"

It is also possible to define and use arrays with multiple subscripts, but the syntax differs from BASIC's. Instead of using comma-separated subscripts within a single set of parentheses, the post-processor language requires that each subscript be in its own parentheses. For example;

Matrix(0)(0) = 1

Matrix(0)(1) = 0

Matrix(1)(0) = 0

Matrix(1)(1) = 1

Reserved Variable Names¶

Reserved Variable Names, listed by the application for which they are used, are described in the following sections:

Vericut

Vericut Inspection Probe Cycle Programming

Vericut Composite Probing

Vericut Drilling and Fastening

Vericut¶

The following variables are reserved for use in Vericut post-processors. These post-processor Variable names must declared in the .vcpost file. Use the command

getString("keyword")

to make all variables attached to the "keyword" accessible in the post.

All of these post-processor Variables are automatically updated by Vericut at the end of each block before executing post-processor subroutines.

3D Cutter Compensation information:

Key Word: 3DCDCInfo

Circle information:

Key Word: CircleInfo

Drilling Cycle information: (information comes from the control configuration)

Key Word: CycleInfo

Dynamic Offset information: (from Info> Machine Offsets…)

Key Word: MachineOffsetInfo

Mirror information:

Key Word: MirrorInfo

Project and Setup Information:

Key Word: ProjectInfo

Rotation Plane Matrix information: (from Info> Machine Offsets…)

Key Word: RPMatrixInfo

Refer to the above Rotation Plane Matix table.

Status Window information:

Key Word: StatusInfo

Each of the following variables corresponds to a feature that can be displayed in the Vericut Status window. All values available in Status window are updated in the post-processor when Run Post while simulating, in the Post Setup window is toggled on (checked).

Working Plane Matrix information: (from Info> Machine Offsets…)

Key Word: WPMatrixInfo

| I | J | K | D
---|---|---|---|---
X | I1 | J1 | K1 | D1
Y | I2 | J2 | K2 | D2
Z | I3 | J3 | K3 | D3

Refer to the above Working Plane Matix table.

Vericut Inspection Probe Cycle Programming¶

Numbers

NurbsOrder | Order of current NURBS.
NurbsWeight | Weight for current NURBS control point.
PathX | Current X coordinate transformed by NC program matrix.
PathY | Current Y coordinate transformed by NC program matrix.
PathZ | Current Z coordinate transformed by NC program matrix.
PathI | Current I coordinate transformed by NC program matrix.
PathJ | Current J coordinate transformed by NC program matrix.
PathK | Current K coordinate transformed by NC program matrix.
PathCenterX | Current X coordinate of arc center, transformed by NC program matrix.
PathCenterY | Current Y coordinate of arc center, transformed by NC program matrix.
PathCenterZ | Current Z coordinate of arc center, transformed by NC program matrix.
PathCenterI | Current I coordinate of arc axis, transformed by NC program matrix.
PathCenterJ | Current J coordinate of arc axis, transformed by NC program matrix.
PathCenterK | Current K coordinate of arc axis, transformed by NC program matrix.
RawX | Current raw X coordinate from APT source.
RawY | Current raw Y coordinate from APT source.
RawZ | Current raw Z coordinate from APT source.
RawI | Current raw I coordinate from APT source.
RawJ | Current raw J coordinate from APT source.
RawK | Current raw K coordinate from APT source.
RawCenterX | Current raw X coordinate of arc center, from APT source.
RawCenterY | Current raw Y coordinate of arc center, from APT source.
RawCenterZ | Current raw Z coordinate of arc center, from APT source.
RawCenterI | Current raw I coordinate of arc axis, from APT source.
RawCenterJ | Current raw J coordinate of arc axis, from APT source.
RawCenterK | Current raw K coordinate of arc axis, from APT source.

Strings

Registers

Language Keywords

(Language Keywords cannot be used as variable names.)

• And
• Case
• Debug
• Do
• Else
• ElseIf

• End

• Exit

• For
• If
• Log
• Loop
• mod

• Next

• Not

• Or
• Out
• Select
• Show
• Step

• Sub

• Then

• To
• Until
• Wend
• While
• Xor
• Zap
• zapFrom

Vericut Composite Probing¶

📝 NOTE: The following Reserved Variable Names tables apply to both Vericut Composites Programming and to Vericut Composites Probing.

Numbers

Strings

Registers

Language Keywords

(Language Keywords cannot be used as variable names.)

• And
• Case
• Debug
• Do
• Else
• ElseIf

• End

• Exit

• For
• If
• Log
• Loop
• mod

• Next

• Not

• Or
• Out
• Select
• Show
• Step

• Sub

• Then

• To
• Until
• Wend
• While
• Xor
• Zap
• zapFrom

Vericut Drilling and Fastening¶

Subroutines are defined in the post by VDAF (Reserved Subroutines variables are defined before subroutine is called)

Modals

Modals are called once at the start of post-processing

DefineRetractPoint

Called after Modals subroutine. Loop through all Way Points, invoked once fore each Way Point.

NewSequence

Called after DefineRetractPoint. Loop through all sequences, invoked once at the beginning of each sequence. All properties associated with the location are set before these subroutines are triggered.

StartCycleProcessing

Start a new location.

GoToApproachParent

Loop through all parent approach way points for each location for a given sequence. This sub is triggered before GoToApproach sub.

GoToApproach

Called at each location of a given sequence.

GoToLocation

Called at each location of a given sequence.

UserMachineCycles

Called at each location of a given sequence if locations' cycle name is defined, after the GoToLocation subroutines. A subroutine with the cycle name is triggered. Optional cycle parameters are set before this sub is triggered. If combined cycles are defined, will loop through all subcycles.

GoToRetract

GoToRetractParent

EndCycleProcessing

End of a location.

Terminate

Called once at the end

Functions¶

There is no provision for user-written functions in the post-processor language. You can however write subroutines which are not named to match APT major words, and use them anywhere.

Math Functions

String Manipulation

(positions are base 1)

Register Related

Array Related

📝 NOTE: These functions differ from the equivalents in standard BASIC because their first arguments are a text string containing the name of the array, not the array itself.

Cache Related

(indices are base 0)

📝 NOTE: This group of functions is applicable only to Vericut Composites Simulation

getNthAddCut(number) | Loads a set of variables detailing the n'th add or cut point in the cache. The list of variables is the same as that for a call to the GoTo subroutine, with the exception of the Cached flag, and the distances to the next add (ToNextAdd), the next cut (ToNextCut), the last cut (ToLastCut) and the end of the run-out (ToRunOut). A number variable, ACCount, provides the count of the points in the cache.

Add/Cut Related

(indices are base 0)

📝 NOTE: This group of functions is applicable only to Vericut Composites Simulation

Input Related

📝 NOTE: This group of functions is applicable only to Vericut

zapFrom | Sets a flag so that the next FROM or GOTO point will become the new HOME position.
Typically used during a tool change or tool axis adjustment.

Output Related

Vericut

Vericut Composites Programming

Show string | Sends a string to the product’s status area.

Subroutines¶

As the post-processor reads each statement from the input NC program, it attempts to invoke a subroutine, or "Sub", from the VcPost file. For example, when the post-processor encounters a RAPID statement, it will try to call the RAPID subroutine. For a subroutine with the name RAPID, the syntax of the start and end of such a subroutine is;

Sub RAPID

....

....

End Sub

Note that a subroutine has no arguments. Because all variables are global in scope, there is no need to pass them as arguments between subroutines. The code between the "Sub" and "End Sub" statements will be executed each time the RAPID subroutine is called.

If at some point within a subroutine you wish to bypass the remaining code, you can use an "Exit" statement.

Sub PPRINT

  ....

  ....

    If (display = 0) Then

      Exit Sub

    End If

  ....

  ....

End Sub

It is not necessary to write a subroutine for every statement that the post-processor may encounter. If there is no subroutine for a particular statement, the post-processor does nothing, and does not generate an error message.

Do not be surprised to see code statements in a VcPost file that are not in any subroutine. While such lines can appear anywhere in the file, it is good practice to put them up front. They get executed by the post-processor before any statements are read from the input NC program. Typically they are used to establish the output format of registers and specify initial values. For example;

X.Prefix = "X"

X.Format = "s3.4sm"

Y.Prefix = "Y"

Y.Format = "s3.4sm"

Machine = "Horizontal Lathe"

Author = "I. B. Nutz"

MyRegister.Suffix = “] “

Before & After

📝 NOTE: The following table is only applicable to Vericut Inspection Probe Cycle Probing.

Depending on a statement's major word, the post-processor may perform some activities before invoking the appropriate subroutine, and it may perform more afterwards.

Using a GOTO statement as an example, the post-processor will first convert the statement's X, Y and Z coordinates, and I, J and K if present, to machine axis positions, load these into the reserved machine axis registers, X, Y, Z and others, then invoke the GOTO subroutine. Finally it will set the current value of the G register to 1. Performing this last activity after the subroutine call allows the G register to be tested within the subroutine to check for RAPID motion.

The following table details the "before and after" activities for each major word, in alphabetic order. If a major word is not in this list, there are no associated before or after activities, but a subroutine will still be invoked if one is supplied.

Calls

It is not normally necessary for a subroutine named for a major word to invoke one named for another major word. But you can do so.

You can also write a subroutine which is not associated with a major word, which will never be invoked directly by the post-processor. To call such a subroutine, you simply place its name in a statement on its own. There are no arguments because all variables are global in scope. For example you could write a subroutine to calculate rotate the current X and Y machine axis locations through an angle.

Sub RotateXY

  ca = cos(Angle)

  sa = sin(Angle)

  XRotated = X * ca - Y * sa

  YRotated = Y * ca + X * sa

End Sub

Then to use this subroutine you would need to set up the "Angle" variable, invoke the Sub and access the results.

Angle = 5

RotateXY

NewX = XRotated

NewY = YRotated

Assignment and Operators¶

Assignment

Assignment of a value to a variable is achieved using the equal sign, "=". The variable's name goes on the left of the equal sign, and an expression that generates the required value goes on the right. This is true for numbers, strings and register properties.

Diameter = R.Current * 2

Message = "Load tool " & T.Current

F.Prefix = " F"

MyRegister.Suffix = “] “

If the variable or register on the left of the equal sign does not already exist, it will be created by the assignment statement. If it does exist, its value or the value of its property, will be adjusted.

Arithmetic Operators

Order of precedence is from top to bottom.

mod | Modulus.

The remainder after dividing the first number by the second. | 7 mod 3 | 1
+ | Addition.

Adds two numbers. | 2 + 2 | 4
- | Subtraction.

Subtracts second number from first. | 5 - 3 | 2

String Operators

Logical Operators

Order of precedence is from top to bottom.

Not | Changes true to false, or false to true. | Not (Z > 0)

And | True if both expressions are true. | (X > 2) And (X <10)

Or | True if either or both expressions are true. | (X = 5) Or (X = 6)

Xor | True if one expression is true but not both. | (X = 5) Xor (Y = 5)

Note that the "Like", "Is", "Eqv" and "Imp" operators available in some flavors of BASIC, are not supported by the post-processor language.

Branching¶

There are two types of logic branching available in the post-processor language, the "If ... Then ... Else" technique and the "Select ... Case"" method.

If ... Then ... Else

Using "[" and "]" to bracket optional elements, the syntax is;

If condition Then

  statements

[ElseIf condition Then

  statements]

[ElseIf condition Then

  statements]

[Else

  statements]

End If

Note that a statement never appears on the same line following "Then", in an "If" or "ElseIf". This is possible in BASIC but we have chosen not to support it, to encourage more easily maintainable code. An "If" branch can be as simple as;

If (Offset < 0) Then

  Offset = -Offset

End If

The parentheses around the condition are not strictly necessary but help improve legibility. Stepping up in complexity, an "If" can represent an either/or condition;

If (word = "Off") Then

  M.Current = 11

Else

  M.Current = 10

End If

Or it can cover any number of options;

If (word = "Off") Then

  display = 0

ElseIf (word = "On" ) Then

  display = 1

Else

  Out "<N>(" & Comment & ")"

End If

Select ... Case

Using "[" and "]" to bracket optional elements, the syntax is;

Select Case expression

Case condition[,condition][,condition]

  statements

[Case condition[,condition][,condition]

  statements]

[Case condition[,condition][,condition]

  statements]

[Case Else

  statements]

End Select

The expression can be a number, string or register property. Each condition should involve the same variable type, with numeric register properties treated as numbers, and text register properties treated as strings. There is a wide choice of condition syntax as defined in the following table, in which variable denotes an expression that evaluates to a number or string.

Note that the operator "Is", available in some flavors of BASIC, is not supported by the post-processor language. Nor are compound conditions that would require use of the logical operators "Not", "And", "Or" or "Xor". At most one block of statements will be executed during a pass through the "Select" construct, regardless of the value of the expression and the conditions. If the expression matches more than one of the conditions, only the statements following the first such condition will be executed.

Following is an example of the use of "Select ... Case" which parallels the last example for the "If ... Then ... Else" technique.

Select Case word

Case "Off"

  display = 0

Case "On"

  display = 1

Case Else

  Out "<N>(" & Comment & ")"

End Select

And here is an example that uses a number variable and illustrates more of the possible conditions.

Select Case ShankDiameter

Case < 0.25

  Chuck = "A"

Case 0.25 To 1

  Chuck = "B"

Case 1 To 2.5

  Chuck = "C"

Case > 2.5

  Chuck = "D"

End Select

Looping¶

There are three types of looping available in the post-processor language, "For ... Next", "Do ... Loop", and "While ... Wend".

For ... Next

Using "[" and "]" to bracket optional elements, the syntax is;

For counter = start To end [Step step]

  statements

  [Exit For

  statements]

  [Exit For

  statements]

Next [counter]

The counter must be a number, or a register if its current value is to be used. The elements start, end and step, if present, must all be expressions that evaluate to a number. The value of the count and components of any of the expressions can be altered within the loop, but this tends to make debugging much more difficult. If step is missing, a value of -1 is assumed if start is greater than end, otherwise +1 is used.

For a positive or zero step, the contents of the loop are executed provided counter is less than or equal to end, and the counter gets increased by step. For a negative step, the contents of the loop are executed provided counter is greater than or equal to end, and the counter gets decreased by step. It is possible for the content of the loop to never be executed, as would be the case with the following example.

For Count = 1 To 5 Step -2

  ...

Next

Do ... Loop

Using "[" and "]" to bracket optional elements, and "|" to indicate a choice of keywords, the syntax is;

Do [While|Untilcondition]

  statements

[Exit Do

  statements]

  [Exit Do

    statements]

Loop [While|Untilcondition]

It would be very unusual to have While or Until conditions at both ends of the same loop. With a While in the Do statement, the content of the loop will be executed if the condition is true. With an Until in the Do statement, a false condition is required for the loop content to be processed. A While in the Loopstatement needs a true condition for control to return to the Do, and an Until would require a false condition.

You can write a "Do ... Loop" with no conditions at either end, but you had better have an "Exit Do" somewhere within it, or you could wait a while for the post-processor to finish.

While ... Wend

The syntax is;

While condition

  statements

Wend

There is no "Exit" statement for a "While ... Wend" so it is vital that condition is changed within the loop, and that it becomes false at some point.