Definition of the TargetPath

<target path> = [("//" | "\\") <server name or address> ("/" | "\")] {<target name> ("/" | "\")}
              | "."       //current process
              | ".."      //parent of current process
              | "..."     //current INCO server

The "normal" case:

char TargetPath[] = "MyTarget";

Accessing a target connected to a remote computer:

char TargetPath[] = "\\\\RemotePcName\\MyTarget";

char TargetPath[] = "//RemotePcName/MyTarget";

Accessing a slave (XAxis) of a target connected to a remote computer:

char TargetPath[] = "\\\\RemotePcName\\MyTarget\\XAxis";

char TargetPath[] = "//RemotePcName/MyTarget/XAxis";

Definition of the ItemPath

<inco path> = <inco item path>
            | <inco item path> "!" <property name>
            | <inco item path> ":" <bit number>
            | <inco item path> "[" <array index> "]"

<inco item path> = <inco item name> {"." <inco item name>}

<inco item name> = <nonempty sequence of alphanumeric ASCII characters, spaces, underscores (_), hyphen-minuses (-), and backslash-escaped periods (\.)>

Periods in INCO item names are only allowed if they are preceded by a backslash. Backslashes are only allowed if they are followed by a period. Unescaped periods are always considered as path separators, and non-period-escaping backslashes as target separators.

The path to the timer variable of the target:

char ItemPath[] = "Target.Prop.Timer";

Definition of the CallProcedure(Ex) syntax

<callprocedure> = <inco item path> {whitespace} "(" [<value> {"," <value>}] ")"

<value> = {whitespace} <trimmed value> {whitespace}

<trimmed value> = <number> { {whitespace} ("+"|"-") {whitespace} <number> }
                | <string literal> { {whitespace} <string literal> }

<number> = ("0x"|"0X") <hexadecimal integer> ":" ("l"|"f"|"d"|"L"|"F"|"D")
         | <decimal integer> [":" ("l"|"L")]
         | <decimal real number> [":" ("f"|"d"|"F"|"D")]

<string literal> = """ <string contents with " and \ escaped as \" and \\, optionally LF as \n> """

Decimal numbers without a type suffix are accepted and interpreted as float values for backwards compatibility, but should be avoided in new applications.

Multiple adjacent string literals are concatenated into one string.

Joining multiple numbers with "+" or "-" computes the respective sum or difference. The type of the result is determined as follows: If any summand is a double, the result is a double. Else, if any summand is a float, the result is a float. Else, if any summand is a signed integer, the result is a signed integer. Else (i.e. if all summands are unsigned integers), the result is an unsigned integer.

A function that takes no arguments:

char CallProcedure[] = "Target.Cmd.Reset()";

A function taking one uint32 argument (decimal and hex notation):

char CallProcedure[] = "Target.MyFunction(12345:l)";

char CallProcedure[] = "Target.MyFunction(0xabcd:l)";

A function taking a negative number:

char CallProcedure[] = "Target.MyFunction(-1234:l)";

A function taking one a string argument:

char CallProcedure[] = "Target.MyStringFunction(\"The string argument value\")";

A function taking one double argument:

char CallProcedure[] = "Target.MyFunction(1.23456789:d)";

A function taking one float argument:

char CallProcedure[] = "Target.MyFunction(1.2345:f)";