Teledyne USB Script Decode User Manual
PROTOCOL SOLUTIONS GROUP
SCOTT BLVD
3385
ANTA CLARA, CA 95054
S
CATC Scripting Language
Reference Manual
for
CATC
A Scripting Language for Voyager, Advisor T3, and
CATC USBTracer, USBMobile, and USBAdvisor
USB Analyzers
USB Protocol Analyzers
Manual Version 1.1
For all software versions
December 2010
CATC Scripting Language for USB LeCroy Corporation
Document Disclaimer
The information contained in this document has been carefully checked and is believed to be
reliable. However, no responsibility can be assumed for inaccuracies that may not have been
detected.
LeCroy reserves the right to revise the information presented in this document without notice or
penalty.
Trademarks and Servicemarks
LeCroy, CATC, Voyager, Advisor T3, USBTracer, USBMobile, and USBAdvisor are
trademarks of LeCroy.
All other trademarks are property of their respective companies.
Copyright
Copyright © 2002 and 2010, LeCroy Corporation. All Rights Reserved.
This document may be printed and reproduced without additional permission, but all copies
should contain this copyright notice.
ii
CATC Scripting Language for USB Table of Contents
TABLE OF CONTENTS
TableofContents.................................... iii
1 Introduction .........................................1
Features of CATC Scripting Language ..............................1
2 Values ..............................................3
Literals .......................................................3
Integers....................................................3
Strings ....................................................3
EscapeSequences.........................................4
Lists ......................................................4
RawBytes .................................................4
Null ......................................................4
Variables .....................................................5
GlobalVariables ............................................5
LocalVariables .............................................6
Constants .....................................................6
3 Expressions ..........................................7
select expression ..............................................7
4 Operators ...........................................9
Operations ....................................................9
OperatorPrecedenceandAssociativity ..............................9
5 Comments ..........................................17
6 Keywords ..........................................19
7 Statements..........................................21
ExpressionStatements..........................................21
ifStatements .................................................21
if-elseStatements..............................................21
whileStatements ..............................................22
forStatements ................................................22
returnStatements ..............................................23
Compound Statements ..........................................24
iii
CATC Scripting Language for USB Table of Contents
8 Preprocessing .......................................27
9 Context ............................................29
10Functions...........................................31
11Primitives ..........................................33
Call() .......................................................33
Format() .....................................................33
Format Conversion Characters ................................34
GetNBits() ...................................................35
NextNBits() ..................................................36
Resolve() ....................................................37
Trace() ......................................................37
12DecoderPrimitives...................................39
Abort() ......................................................39
AddCell() ....................................................39
AddDataCell() ................................................41
AddEvent()...................................................42
AddSeparator()................................................43
BeginCellBlock()..............................................43
Complete() ...................................................46
EndCellBlock() ...............................................47
GetBitOffset() ................................................47
PeekNBits() ..................................................48
Pending() ....................................................48
Reject()......................................................49
13Modules............................................51
Module Functions .............................................51
ProcessData()..............................................51
CollectData() ..............................................51
BuildCellList() .............................................51
Module Data .................................................52
ModuleType ...............................................52
OutputType ...............................................52
InputType .................................................52
LevelName ................................................52
DecoderDesc ..............................................52
Icon .....................................................53
iv
CATC Scripting Language for USB Table of Contents
14USBDecoders .......................................55
DecoderFiles .................................................55
ScriptDecodingMechanisms...............................55
ReservedVariableandConstantNames .........................56
UsbEndpDir ............................................57
UsbMaxPktSize .........................................57
UsbMaxXferSize ........................................57
UsbMaxXferDecodeSize ..................................57
UsbClassCode...........................................57
UsbSubClass............................................57
UsbProtocol ............................................57
UsbVendorId............................................58
UsbProductId ...........................................58
UsbEndpId .............................................58
UsbIgnoreSetupData ......................................58
UsbLsbToMsb ..........................................58
UsbReqStr..............................................59
UsbDescTooltipStr.......................................59
UsbDataDecodeStr.......................................59
UsbDecHdrType.........................................59
UsbDecHdrLen..........................................59
UsbDecExtraInfoBytePos..................................60
UsbScriptDecodeType....................................60
Reserved Parameter Strings (Used as values in the above string declara-
tions): .................................................60
Constants ....................................................60
ConstantsdefinedinDecoderTools2.inc.........................60
GlobalVariables ..............................................61
GlobalssetinDecoderTools2.inc ..............................61
CommonFunctions ............................................62
Functions found in DecoderTools2.inc ..........................62
RGB().................................................62
SaveFieldSettings().......................................62
RestoreFieldSettings() ....................................63
Find() .................................................63
ShowDataBlock()........................................64
AddDecSeparator().......................................64
Warning() ..............................................64
WarningForDlg() ........................................65
AddWarningTooltip().....................................65
ReservedCheck().........................................66
IncFieldOffset() .........................................66
PrepareFieldForDlg().....................................67
v
CATC Scripting Language for USB Table of Contents
PrepareZeroFieldForDlg() .................................67
PrepareFieldForDlgExt() ..................................68
AddCaptionToDlg()......................................68
AddStringToDlg()........................................69
AddDataBlockToDlg()....................................69
CheckBadDataLength() ...................................70
NextNBits_()............................................70
PeekNBits_()............................................70
GetNBits_().............................................71
GetRangeBits()..........................................71
GetBit()................................................71
AddCaptionCell()........................................72
AddPayLoadCell().......................................73
AddPayLoadCellMono() . . ................................73
AddPLCellMonoStr() .....................................74
AddPLCellMonoCap() ....................................75
AddPLCellMonoNoDlg() . . ................................76
AddSimplePLCell() ......................................77
AddSimpleCellMonoCap(). ................................78
AddBlockPLCell().......................................78
AddBlockPLCellMonoStr() ................................79
AddBlockPLCellMonoCap() ...............................80
ShowItem().............................................81
PLReservedCheck() ......................................82
UnsignedCompare()......................................82
CurrentFldInit()..........................................83
SetFieldOffsetLen() ......................................83
vi
CHAPTER 1
CATC Scripting Language for USB Introduction
CHAPTER 1: INTRODUCTION
CATC Scripting Language (CSL) was developed to create scripts that would allow
users to do file-based decoding with CATC USBTracer, USBMobile, and USBAdvisor analyzers. CSL is used to edit CATC Decode Scripting (CDS) files. CATC
analyzers are equipped with built-in decoders in addition to script-based decoders
that can be modified by the users or implemented as-is. Decoding scripts for
analyzers are distributed in the /scripts directory. These scripts are tools to
decode and display transactions. Users can also add entirely new, customized
decoders.
Included with the CATC USBTracer Protocol Analyzer are USB decoder scripts for
many of the USB classes, as described in the USB specification. They are located
in the USBTracer\Scripts directory and are identifiable by the .dec and .inc extensions. These scripts are tools to decode and display transactions. Users can also
add entirely new, customized decoders to fit their own, specific development needs.
USBTracer looks in the \Scripts directory and automatically loads all of the .dec
files that it finds. To prevent a particular decoder from being loaded, changed its
extension to something other than .dec or move it out of the \Scripts directory.
CSL is based on C language syntax, so anyone with a C programming background
will have no trouble learning CSL. The simple, yet powerful, structure of CSL also
enables less experienced users to easily acquire the basic knowledge needed to start
writing custom scripts.
Features of CATC Scripting Language
• Powerful -- provides a high-level API while simultaneously allowing
implementation of complex algorithms.
• Easy to learn and use -- has a simple but effective syntax.
• Self-contained -- needs no external tools to run scripts.
• Wide range of value types -- provides efficient and easy processing of data.
• Used to create built-in script-based decoders for analyzers.
• May be used to write custom decoders.
• General purpose -- is integrated in a number of CATC products.
1
CHAPTER 1
CATC Scripting Language for USB Introduction
2
CHAPTER 2
CATC Scripting Language for USB Values
CHAPTER 2: VALUES
There are five value types that may be manipulated by a script: integers, strings,
lists, raw bytes,andnull. CSL is not a strongly typed language. Value types need
not be pre-declared. Literals, variables and constants can take on any of the five
value types, and the types can be reassigned dynamically.
Literals
Literals are data that remain unchanged when the program is compiled. Literals are
a way of expressing hard-coded data in a script.
Integers
Integer literals represent numeric values with no fractions or decimal points. Hexadecimal, octal, decimal, and binary notation are supported:
Hexadecimal numbers must be preceded by 0x: 0x2A, 0x54, 0xFFFFFF01
Octal numbers must begin with 0: 0775, 017, 0400
Decimal numbers are written as usual: 24, 1256, 2
Binary numbers are denoted with 0b: 0b01101100, 0b01, 0b100000
Strings
String literals are used to represent text. A string consists of zero or more characters
and can include numbers, letters, spaces, and punctuation. An empty string ("")
contains no characters and evaluates to false in an expression, whereas a non-empty
string evaluates to true. Double quotes surround a string, and some standard
backslash (\) escape sequences are supported.
String Represented text
"Quote: \"This is a string
literal.\""
"256"
"abcd!$%&*" abcd!$%&*
"June 26, 2001" June 26, 2001
Quote: "This is a string
literal."
256
**Note that this does not represent the integer
256, but only the characters that make up the number.
"[ 1, 2, 3 ]" [ 1, 2, 3 ]
Table 2.1: Examples of String Literals
3
CHAPTER 2
CATC Scripting Language for USB Values
Escape Sequences
These are the available escape sequences in CSL:
Escape
Character
backslash \\ "This is a backslash: \\" This is a backslash: \
double quote \" "\"Quotes!\"" "Quotes!"
horizontal tab \t "Before tab\tAfter tab" Before tab After tab
newline \n "This is how\nto get a newline." This is how
single quote \' "\'Single quote\'" 'Single quote'
Sequence Example Output
to get a newline.
Table 2.2: Escape Sequences
Lists
A list can hold zero or more pieces of data. A list that contains zero pieces of data
is called an empty list. An empty list evaluates to false when used in an expression,
whereas a non-empty list evaluates to true. List literals are expressed using the
square bracket ([]) delimiters. List elements can be of any type, including lists.
[1, 2, 3, 4]
[]
["one", 2, "three", [4, [5, [6]]]]
Raw Bytes
Raw binary values are used primarily for efficient access to packet payloads. A
literal notation is supported using single quotes:
'00112233445566778899AABBCCDDEEFF'
This represents an array of 16 bytes with values starting at 00 and ranging up to
0xFF. The values can only be hexadecimal digits. Each digit represents a nybble
(four bits), and if there are not an even number of nybbles specified, an implicit zero
is added to the first byte. For example:
'FFF'
is interpreted as
'0FFF'
Null
Null indicates an absence of valid data. The keyword null represents a literal
null value and evaluates to false when used in expressions.
4
CHAPTER 2
CATC Scripting Language for USB Values
result = null;
Variables
Variables are used to store information, or data, that can be modified. A variable
can be thought of as a container that holds a value.
All variables have names. Variable names must contain only alphanumeric characters and the underscore ( _ ) character, and they cannot begin with a number. Some
possible variable names are
x
_NewValue
name_2
A variable is created when it is assigned a value. Variables can be of any value type,
and can change type with re-assignment. Values are assigned using the assignment
operator ( = ). The name of the variable goes on the left side of the operator, and the
value goes on the right:
x=[1,2,3]
New_value = x
name2 = "Smith"
If a variable is referenced before it is assigned a value, it evaluates to null.
There are two types of variables: global and local.
Global Variables
Global variables are defined outside of the scope of functions. Defining global
variables requires the use of the keyword set. Global variables are visible throughout a file (and all files that it includes).
set Global = 10;
If an assignment in a function has a global as a left-hand value, a variable will not
be created, but the global variable will be changed. For example
set Global = 10;
Function()
{
Global = "cat";
Local = 20;
}
5
CHAPTER 2
CATC Scripting Language for USB Values
will create a local variable called Local, which will only be visible within the
function Function. Additionally, it will change the value of Global to "cat",
which will be visible to all functions. This will also change its value type from an
integer to a string.
Local Variables
Local variables are not declared. Instead, they are created as needed. Local
variables are created either by being in a function's parameter list, or simply by
being assigned a value in a function body.
Function(Parameter)
{
Local = 20;
}
This function will create a local variable Parameter and a local variable Local,
which has an assigned value of 20.
Constants
A constant is similar to a variable, except that its value cannot be changed. Like
variables, constant names must contain only alphanumeric characters and the underscore ( _ ) character, and they cannot begin with a number.
Constants are declared similarly to global variables using the keyword const:
const CONSTANT = 20;
They can be assigned to any value type, but will generate an error if used in the lefthand side of an assignment statement later on. For instance,
const constant_2 = 3;
Function()
{
constant_2 = 5;
}
will generate an error.
Declaring a constant with the same name as a global, or a global with the same name
as a constant, will also generate an error. Like globals, constants can only be
declared in the file scope.
6
CHAPTER 3
CATC Scripting Language for USB Expressions
CHAPTER 3: EXPRESSIONS
An expression is a statement that calculates a value. The simplest type of expression
is assignment:
x=2
The expression x=2calculates 2 as the value of x.
All expressions contain operators, which are described in Chapter 4, Operators,on
page 9. The operators indicate how an expression should be evaluated in order to
arrive at its value. For example
x+2
saystoadd2tox to find the value of the expression. Another example is
x>2
which indicates that x is greater than 2. This is a Boolean expression, so it will
evaluate to either true or false. Therefore, if x=3, then x>2will evaluate to
true; if x=1,itwillreturnfalse.
True is denoted by a non-zero integer (any integer except 0), and false is a zero
integer (0). True and false are also supported for lists (an empty list is false, while
all others are true), and strings (an empty string is false, while all others are true),
and null is considered false. However, all Boolean operators will result in integer
values.
select expression
The select expression selects the value to which it evaluates based on Boolean
expressions. This is the format for a select expression:
select {
<expression1> : <statement1>
<expression2> : <statement2>
...
};
The expressions are evaluated in order, and the statement that is associated with the
first true expression is executed. That value is what the entire expression evaluates
to.
7
CHAPTER 3
CATC Scripting Language for USB Expressions
x=10
Value_of_x = select {
x<5:"Lessthan 5";
x>=5:"Greater than or equal to 5";
};
The above expression will evaluate to “Greater than or equal to 5” because the first
true expression is x>=5. Note that a semicolon is required at the end of a
select expression because it is not a compound statement and can be used in an
expression context.
There is also a keyword default, which in effect always evaluates to true. An
example of its use is
Astring = select {
A==1:"one";
A==2:"two";
A == 3: "three";
A>3:"overflow";
default : null;
};
If none of the first four expressions evaluates to true, then default will be evaluated, returning a value of null for the entire expression.
select expressions can also be used to conditionally execute statements, similar
to C switch statements:
select {
A==1:DoSomething();
A==2:DoSomethingElse();
default: DoNothing();
};
In this case the appropriate function is called depending on the value of A, but the
evaluated result of the select expression is ignored.
8
CHAPTER 4
CATC Scripting Language for USB Operators
CHAPTER 4: OPERATORS
An operator is a symbol that represents an action, such as addition or subtraction,
that can be performed on data. Operators are used to manipulate data. The data
being manipulated are called operands. Literals, function calls, constants, and
variables can all serve as operands. For example, in the operation
x+2
the variable x and the integer 2 are both operands, and + is the operator.
Operations
Operations can be performed on any combination of value types, but will result in
a null value if the operation is not defined. Defined operations are listed in the
Operand Types column of Table 4.2 on page 12. Any binary operation on a null and
a non-null value will result in the non-null value. For example, if
x = null
then
3*x
will return a value of 3.
A binary operation is an operation that contains an operand on each side of the
operator, as in the preceding examples. An operation with only one operand is
called a unary operation, and requires the use of a unary operator. An example of a
unary operation is
!1
which uses the logical negation operator. It returns a value of 0.
The unary operators are
sizeof(), head(), tail(), ~ and !.
Operator Precedence and Associativity
Operator rules of precedence and associativity determine in what order operands are
evaluated in expressions. Expressions with operators of higher precedence are
evaluated first. In the expression
4+9*5
the * operator has the highest precedence, so the multiplication is performed before
the addition. Therefore, the expression evaluates to 49.
9
CHAPTER 4
CATC Scripting Language for USB Operators
The associative operator () is used to group parts of the expression, forcing those
parts to be evaluated first. In this way, the rules of precedence can be overridden.
For example,
(4+9)*5
causes the addition to be performed before the multiplication, resulting in a value
of 65.
When operators of equal precedence occur in an expression, the operands are
evaluated according to the associativity of the operators. This means that if an operator's associativity is left to right, then the operations will be done starting from
the left side of the expression. So, the expression
4+9-6+5
would evaluate to 12. However, if the associative operator is used to group a part or
parts of the expression, those parts are evaluated first. Therefore,
(4+9)-(6+5)
has a value of 2.
In Table 4.1, Operator Precedence and Associativity, the operators are listed in
order of precedence, from highest to lowest. Operators on the same line have equal
precedence, and their associativity is shown in the second column.
Operator Symbol Associativity
++ --
[] ()
~ ! sizeof head tail
*/%
+-
<< >>
<><=>=
== !=
&
^
|
Right to left
Left to right
Right to left
Left to right
Left to right
Left to right
Left to right
Left to right
Left to right
Left to right
Left to right
&&
||
Table 4.1: Operator Precedence and Associativity
10
Left to right
Left to right
CHAPTER 4
CATC Scripting Language for USB Operators
Operator Symbol Associativity
=+=-=*=/=%=>>=<<=&=
^= |=
Table 4.1: Operator Precedence and Associativity (Continued)
Right to left
11
CHAPTER 4
CATC Scripting Language for USB Operators
Operator
Symbol
Description
Operand
Types
Result
Types
Examples
Index Operator
[] Index or
subscript
Raw Bytes Integer Raw = '001122'
Raw[1] = 0x11
List Any List = [0, 1, 2, 3, [4, 5]]
List[2] = 2
List[4] = [4, 5]
List[4][1] = 5
*Note: if an indexed Raw value is assigned to any
value that is not a byte ( > 255 or not an integer), the
variable will be promoted to a list before the
assignment is performed.
Associative Operator
() Associative Any Any (2+4)*3=18
2+(4*3)=14
Arithmetic Operators
* Multiplication Integer-integer Integer 3*1=3
/ Division Integer-integer Integer 3/1=3
% Modulus Integer-integer Integer 3%1=0
+ Addition Integer-integer Integer 2+2=4
String-string String "one " + "two" = "one two"
Raw byte-raw byte Raw '001122' + '334455' =
List-list List [1, 2] + [3, 4] = [1, 2, 3, 4]
Integer-list List 1 + [2, 3] = [1, 2, 3]
Integer-string String "number="+2="number = 2"
String-list List "one" + ["two"] = ["one", "two"]
- Subtraction Integer-integer Integer 3–1=2
'001122334455'
*Note: integer-string concatenation uses decimal
conversion.
Increment and Decrement Operators
++ Increment Integer Integer a =1
-- Decrement Integer Integer a =2
Table 4.2: Operators
12
++a =2
b =1
b++ = 1
*Note that the value of b after execution is 2.
--a =1
b =2
b--=2
*Note that the value of b after execution is 1.
CHAPTER 4
CATC Scripting Language for USB Operators
Operator
Symbol
Description
Operand
Types
Result
Types
Equality Operators
== Equal Integer-integer Integer 2==2
String-string Integer "three" == "three"
Raw byte-raw byte Integer '001122' == '001122'
List-list Integer [1, [2, 3]] == [1, [2, 3]]
!= Not equal Integer-integer Integer 2!=3
String-string Integer "three" != "four"
Raw byte-raw byte Integer '001122' != '334455'
List-list Integer [1, [2, 3]] != [1, [2, 4]]
Relational Operators
< Less than Integer-integer Integer 1<2
String-string Integer "abc" < "def"
> Greater than Integer-integer Integer 2>1
String-string Integer "xyz" > "abc"
<= Less than or
equal
>= Greater than or
equal
Integer-integer Integer 23 <= 27
String-string Integer "cat" <= "dog"
Integer-integer Integer 2>=1
String-string Integer "sun" >= "moon"
Examples
*Note: equality operations on values of different
types will evaluate to false.
*Note: equality operations on values of different
types will evaluate to false.
*Note: relational operations on string values are
evaluated according to character order in the ASCII
table.
Logical Operators
! Negation All combinations
of types
&& Logical AND All combinations
of types
|| Logical OR All combinations
of types
Table 4.2: Operators (Continued)
Integer !0 = 1 !"cat" = 0
!9=0 !""=1
Integer 1&&1=1 1&&!""=1
1&&0=0 1&&"cat" = 1
Integer 1||1=1 0||0=0
1||0=1 ""||!"cat" = 0
13
CHAPTER 4
CATC Scripting Language for USB Operators
Operator
Symbol
Description
Operand
Types
Result
Types
Examples
Bitwise Logical Operators
~ Bitwise
complement
& Bitwise AND Integer-integer Integer 0b11111110 & 0b01010101 =
^ Bitwise
exclusive OR
| Bitwise
inclusive OR
Integer-integer Integer ~0b11111110 = 0b00000001
0b01010100
Integer-integer Integer 0b11111110 ^ 0b01010101 =
0b10101011
Integer-integer Integer 0b11111110 | 0b01010101 =
0b11111111
Shift Operators
<< Left shift Integer-integer Integer 0b11111110 << 3 = 0b11110000
>> Right shift Integer-integer Integer 0b11111110 >> 1 = 0b01111111
Assignment Operators
= Assignment Any Any A=1
B=C=A
+= Addition
assignment
-= Subtraction
assignment
*= Multiplication
assignment
/= Division
assignment
%= Modulus
assignment
>>= Right shift
assignment
<<= Left shift
assignment
Integer-integer Integer x =1
x +=1=2
String-string String a = "one "
a += "two" = "one two"
Raw byte-raw byte Raw z = '001122'
z += '334455' = '001122334455'
List-list List x = [1, 2]
x += [3, 4] = [1, 2, 3, 4]
Integer-list List y =1
y += [2, 3] = [1, 2, 3]
Integer-string String a = "number = "
a += 2 = "number = 2"
*Note: integer-string concatenation uses decimal
conversion.
String-list List s = "one"
s + ["two"] = ["one", "two"]
Integer-integer Integer y =3
y –=1=2
Integer-integer Integer x =3
x *=1=3
Integer-integer Integer s =3
s /=1=3
Integer-integer Integer y =3
y %=1=0
Integer-integer Integer b = 0b11111110
b >>= 1 = 0b01111111
Integer-integer Integer a = 0b11111110
a <<= 3 = 0b11111110000
Table 4.2: Operators (Continued)
14
CHAPTER 4
CATC Scripting Language for USB Operators
Operator
Symbol
Description
Operand
Types
Result
Types
Examples
Assignment Operators (continued)
&= Bitwise AND
assignment
^= Bitwise
exclusive OR
assignment
|= Bitwise
inclusive OR
assignment
Integer-integer Integer a = 0b11111110
a &= 0b01010101 = 0b01010100
Integer-integer Integer e = 0b11111110
e ^= 0b01010101 = 0b10101011
Integer-integer Integer i = 0b11111110
i |= 0b01010101 = 0b11111111
List Operators
sizeof() Number of
elements
head() Head List Any head([1, 2, 3]) = 1
tail() Tail List List tail([1, 2, 3]) = [2, 3]
Any Integer sizeof([1, 2, 3]) = 3
sizeof('0011223344') = 5
sizeof("string") = 6
sizeof(12) = 1
sizeof([1, [2, 3]]) = 2
*Note: the last example demonstrates that the
sizeof() operator returns the shallow count of a
complex list.
*Note: the Head of a list is the first item in the list.
*Note: the Tail of a list includes everything except
the Head.
Table 4.2: Operators (Continued)
15
CHAPTER 4
CATC Scripting Language for USB Operators
16
CHAPTER 5
CATC Scripting Language for USB Comments
CHAPTER 5: COMMENTS
Comments may be inserted into scripts as a way of documenting what the script
does and how it does it. Comments are useful as a way to help others understand
how a particular script works. Additionally, comments can be used as an aid in
structuring the program.
Comments in CSL begin with a hash mark (#) and finish at the end of the line. The
end of the line is indicated by pressing the Return or Enter key. Anything contained
inside the comment delimiters is ignored by the compiler. Thus,
#x=2;
is not considered part of the program. CSL supports only end-of-line comments,
which means that comments can be used only at the end of a line or on their own
line. It's not possible to place a comment in the middle of a line.
Writing a multi-line comment requires surrounding each line with the comment delimiters
# otherwise the compiler would try to interpret
# anything outside of the delimiters
# as part of the code.
The most common use of comments is to explain the purpose of the code immediately following the comment. For example:
# Add a profile if we got a server channel
if(rfChannel != "Failure")
{
result = SDPAddProfileServiceRecord(rfChannel,
"ObjectPush");
Trace("SDPAddProfileServiceRecord returned ",
result, "\n");
}
17
CHAPTER 5
CATC Scripting Language for USB Comments
18
CHAPTER 6
CATC Scripting Language for USB Keywords
CHAPTER 6: KEYWORDS
Keywords are reserved words that have special meanings within the language. They
cannot be used as names for variables, constants or functions.
In addition to the operators, the following are keywords in CSL:
Keyword Usage
select select expression
set define a global variable
const define a constant
return return statement
while while statement
for for statement
if if statement
else if-else statement
default select expression
null null value
in input context
out output context
Table 6.1: Keywords
19
CHAPTER 6
CATC Scripting Language for USB Keywords
20
CHAPTER 7
CATC Scripting Language for USB Statements
CHAPTER 7: STATEMENTS
Statements are the building blocks of a program. A program is made up of list of
statements.
Seven kinds of statements are used in CSL: expression statements, if statements, ifelse statements, while statements, for statements, return statements, and compound
statements.
Expression Statements
An expression statement describes a value, variable, or function.
<expression>
Here are some examples of the different kinds of expression statements:
Value: x + 3;
Variable: x = 3;
Function: Trace(x+3);
The variable expression statement is also called an assignment statement, because
it assigns a value to a variable.
if Statements
An if statement follows the form
if <expression><statement>
For example,
if (3 && 3) Trace("True!");
will cause the program to evaluate whether the expression 3&&3is nonzero, or
True. It is, so the expression evaluates to True and the Trace statement will be
executed. On the other hand, the expression 3&&0is not nonzero, so it would
evaluate to False, and the statement wouldn't be executed.
if-else Statements
The form for an if-else statement is
if <expression><statement1>
else <statement2>
The following code
21
Loading...