Common Syntax Errors

There are a small set of SmartCAM macro errors that user's will likely run across; especially when updating older macros. The following lists these common macro syntax errors and gives some suggestions on how to resolve them.

Global Variable System

All simple data variables in SmartCAM are global variables. Once declared, they will exist and continue to be valid until they are either removed or the application is restarted. This means it is possible a variable declared as a specific type in one macro is trying to be redefined as a different type in a different macro (if both macros use the same variable name).

This is covered in the Fundamental : Variables Scope topic.

The Macro Variables dialog, available from Macro - Variables can also be used to check which variables are set, their data type, and current contents.

This only applies to simple data variables: INTEGER, DECIMAL, and STRING. Arrays are transitory constructions and only exist while the macro is running. When a macro ends, they are removed. Even so, it is possible that a previous macro has defined a simple data variable with the same name as the array variable in the current macro. This could cause problems or false syntax errors.

To reduce the chances of one macro inadvertently affecting another, it is suggested that all variable names be prefaced with a unique suffix. The suffix should related to the macro or custom Panel they are associated with. For example, the Path Length macro could have prefaced all variables with "PL_".

The suffix helps reduce the chance of the same exact variable name being used in multiple macros. It also helps keep variables grouped together in the Macro Variables dialog.

Keep in mind, the suffix uses some of the 12 available variable name characters. So, do not make the suffix too long.

Custom PCB Panels

Variables declared on a custom PCB panel are instantiated when the panel is displayed. They do not need to be redeclared in the macro file itself.

When using Macro - Execute - Check Macro to verify a macro that is launched by a custom panel, first navigate to the panel and display it. This will create the necessary variables and add them to the Global Variable System. Then, when the macro is checked, the correct variables will exist.

Common Macro Errors

3079: Malformed DATA statement

When declaring a new variable, the declaration statement in the macro file is incorrectly written. The DATA string is replaced with the actual data type: INTEGER, DECIMAL, or STRING.

Example: INTEGER:#A A

This example triggers the error because "#A A" is not a valid declaration or variable name.

3081: Attempted redefinition of the variable <variable name>

This is a variable scoping issue. The macro is attempting to redeclare an already established variable. For example:

INTEGER:#IVAR    // variable declared as INTEGER
DECIMAL:#IVAR    // attempting to redefine as DECIMAL

The variable was already instantiated as in INTEGER, it cannot then be redefined as a DECIMAL.

The macro compiler will also complain if the macro attempts to declare the same variable more than once, even if the data type is the same. Example:

INTEGER:#IVAR   // variable declared as INTEGER
INTEGER:#IVAR   // trying to redefine the variable

A variable only needs to be declared once. For these types of errors, check the macro file for multiple declarations of the same variable name. If they are of the same data type, simply remove the duplicate declarations; keeping the first declaration. If the redeclarations are for different data types, use new variable names for the redeclarations.

Using VAR_REMOVE[] will not resolve this issue. Example:

INTEGER:#IVAR          // variable declared as INTEGER
VAR_REMOVE[VN="IVAR"]  // removing the #IVAR variable
DECIMAL:#IVAR          // redeclaring as DECIMAL. This will not compile.

The declaration issue is being caught while the macro is being compiled, not while the macro is being run. Therefore, the VAR_REMOVE[] command will be checked for proper syntax, but is not actually executed. So #IVAR is still considered to be existing and of type INTEGER before and after the VAR_REMOVE[] command.

Using the same variable name for multiple data types is very poor idea and can lead to significant downstream confusion and hard to trace problems. The SmartCAM MCL compiler is keeping this bad programming technique from being used.

3082: IF statement missing ENDIF
3083: WHILE statement missing ENDW

These two issues are very closely related and so are grouped together. The IF conditional branching block and the WHILE conditional loop require a macro statement to close the end of the block. The end of block statement is missing.

Find the beginning of the IF or WHILE block on the line provided in the error. Then trace through the code until the end of the statement block is found. Add the missing ENDIF or ENDW statement.

3085: Label already defined <label name>

The macro command GOTO() jumps to a specific label in the macro. Each label must be unique, otherwise the macro engine will not know where to branch to.

This error is triggered when the same label name is used more than once. Example:

@LABEL1
  ... macro code
GOTO(LABEL1)
  ... macro code
@LABEL1

In this example, the label "LABEL1" is defined twice. Remove one of the two labels or rename one of them.

3086: Reference to undeclared label <label name>

Similar to error 3085, in this instance the GOTO() label is missing. Example:

GOTO(LABEL1)
... macro code

The branch location LABEL1 is not defined in the macro file, the GOTO() command has no place to branch to.

Find where in the code the GOTO should jump to and add the appropriate label. Otherwise, remove the unnecessary GOTO() command.

3087: Reference to undefined function <function>

The function being called is not a valid function name. Example:

#D=TOTLE()   // use TOTEL() to get the total # of elements

In this case, the macro function TOTEL() is misspelled. Refer to the Automation/Customization - MCL Reference section of Learning SmartCAM for a complete list of valid macro functions and commands.

3088: No function having the signature <function signature>

A function signature is a description of the data types, number, and order of function parameters and return value. The referenced macro function does not match this signature.

For example the function signature for the TYP() function is: INTEGER TYP(INTEGER). Which means the single parameter is an INTEGER and the return value is an INTEGER. Therefore the following will generate this error:

INTEGER:#RETVAL
STRING:#ELMT="1"
#RETVAL=TYP(#ELMT)

There is not a function signature for INTEGER TYP(STRING), which is what the example macro is using, so an error is displayed.

3097: The variable name <variable name> exceeds the maximum number of characters.

The given variable name is too long. Reduce the size to 12 or less characters. Make sure to update the variable name in all instances where it is used.

3099: Unreferenced label <label name>

A label is used as part of a unconditional branch and takes the form of "@LABEL_NAME". All labels must be referenced by a GOTO() command. Those that are not should be commented out or deleted.

3100: Use of a deprecated function signature <function signature>

A function signature is a description of the data types, number, and order of function parameters and return value.

A deprecated function signature is an older function signature that is being obsoleted. Many macro commands that now require a given parameter to be an INTEGER used to allow the parameter to be a NUMBER. Where a NUMBER was either a decimal or integer.

In most cases, this did not make sense. For example, what is element number 1.75?

Refer to the Automation/Customization - MCL Reference - Reference: Macro Commands and Reference: Macro Functions topics for a full list of macro command and functions. Update the macro parameters to match the current function signature.

3101: Reference to an undefined macro parameter <parameter>

As SmartCAM evolves, the parameters to existing macro commands may change and have changed. This error is shows a parameter that is no longer used by the associated macro command.

Generally, these can simply be deleted without incident.

It is a good idea to look up the macro command or function, in the Automation/Customization - MCL Reference - Reference: Macro Commands and Reference: Macro Functions topics, to see what the current set of parameters is and what each does.

3102: Unsupported mixed-type assignment to "variable"

The macro is attempting to assign the wrong type of data to a macro variable; for example assigning a string to an INTEGER or DECIMAL variable or a decimal to an INTEGER variable.

Another common cause is assigning text to a string without quoting the text. Example:

STRING:#SVAR
#SVAR=Testing One Two Three   // this will cause an error, the quotes are missing
#SVAR="Testing One Two Three" // this will work

Make sure strings are quoted and have both quotation marks - leading and trailing.