Format Language

The formatting language uses syntax much like other programming languages. While it uses a similar syntax, the formatting language is not an actual programming language or script, like the MCL macro language. It is designed, solely to format output based on SmartCAM JOS Data Tags and related Section Numbers.

The formatting language includes the following basic concepts and rules.

Comments

Two forward slash characters, "//", are used to mark comments. The // marks the start of the comment and SmartCAM ignores everything from the marker to the end of the line. Comments are not displayed in the output.

Example:

// This entire line is a comment
format("%-0.3f dia.", tl_dia);  // The format is valid, but the half of the line is a comment

End Of Statement Marker

End all, but two, format statements with a semicolon. The two format statements not ended with a semicolon are the #include and procedure blocks.

Including Files

Use an include statement, "#include", to incorporate other format files into the current format file. The include statement must appear in the file before any references to items defined in the included file. Including files is only available in report formats.

Using include files makes it easier to group related information together and have smaller individual include files, for subsequent editing. As an example, SmartCAM reports are organized so that there is a main format file. This format file only initialized the output and then includes all the other files required for the report. The other files include formatting for Job, Step, and Tool reports; each in their own file. And include files that are used to help format the final output.

Example:

// MILLING HTML Report Format File (main)
//
// Include file with common mapping procedures
#include "cmn_proc_htm.inc" 

// Include file with global HTML report Header and Footer procedures
#include "glob_hdrftr_htm.inc" 

// Include file containing the MILLING JOB INFO report procedures 
#include "mjobinf_htm.inc"

// Include file containing the MILLING STEP report procedures
#include "mstepinf_htm.inc" 

// Include file containing the MILLING TOOL report procedures
#include "mtoolinf_htm.inc"

Map Numbers to Text

The formatting language is designed to extract data from Data Tags and send to output in a formatted fashion. However, some data tags may not track data in a way that is easy to read or understand. As an example, the tl_mat data tag tracks the tool material; such as Brass, Copper, and Molybdenum. However, it does not contain the name of the material, include it tracks an integer index value into a list. So, it stores 0 instead of the readable name Brass.

There is a special function named map(), which allows you to map the integer index and get the human-readable name. The map() function has two parameters; the variable containing the integer value and the list of items to extract from. It returns a string value that can be output.

Example, returning material type based on tl_mat integer value:

map(tl_mat, [0 = "Brass", 1 = "Zinc Coated", 2 = "Molybdenum", 3 = "Copper", 4 = "Special"])

To output the string returned from map():

format("%s", map(tl_mat, [0 = "Brass", 1 = "Zinc Coated", 2 = "Molybdenum", 3 = "Copper", 4 = "Special"]));

Procedures - Custom

Procedures are blocks of related commands. Procedures can be user defined, to handle specific tasks. For example, the following is a user defined procedure that is used to map the Speed Mode data tag from an integer ID to a human-readable string.

//  Procedure to map unspmode data tag to a text string
procedure speed_mode
{
   format("%s",
      map(unspmode, [1 = "SFM", 2 = "RPM", 11 = "m/min", 12 = "RPM"]));
}

Notice the command in the procedure, between the two starting and ending markers ({}) ends with a semicolon. However, the procedure and opening and closing braces does not.

The procedure block defines what the procedure is. To use the procedure, you must call it. The following shows the speed_mode procedure being used.

call(speed_mode);

Procedures - Section Number

Another type of procedure, used in Report format files, is based on Section Numbers. This procedure uses a specific procedure name. The name consists of "section_" followed by the Section Number. As an example:

//  Milling Operations (all)
procedure section_1030100
{
   // Add commands needed for the Step information
}

When SmartCAM needs to display the information for Milling Operations, it uses the Section Number and finds this procedure and then uses it to format the information.

For customizing the data shown in the Planner, there is a variation on this type of procedure. It still includes the Section Number, and it also includes a short description of the type of information it contains. For example, a procedure for a Face Mill Tool would be named:

procedure tool_2010103

While a generic procedure for all steps would be:

procedure step_5020000

Variables

Declare all variables before you reference them. The declaration must include the variable data type ( integer, float, or string) and the variable name. When using variables to access Job Operation Setup Data Tags, you must also declare those variables.

Variable must be declared before being used.

When using Data Tag variables, they should only be used in the appropriate context. For example, you should not declare and use variables for tool data, in the context of a job report. The variables, being out of context, would not make sense and would be unusable.

When declaring variables in order to access Data Tags, use the extern command, to tell SmartCAM the variable is coming from outside the report itself; in this case, from the Data Tag.

Example:

extern string jof_file, tl_desc;
extern integer tl_num;

Notice the external variable declaration provides the type of data stored in the variable; in this case string and integer. If you have several variables of the same type to declare, you can combine them into a single line using a comma to separate them. And the end of the declaration is marked by a semicolon (the end of statement marker).