x= 74 --> 0x4a --> 0100 1010
y=135 --> 0x87 --> 1000 0111

We can see if our calculations were right with SPEC:

323.SPEC> x= 0x4a
324.SPEC> y= 0x87
325.SPEC> p x | y , x & y, x ^ y, ~x, ~y
207 2 205 -75 -136

Everything seems to be OK except the last two results which are not what is written in the table. Why does the SPEC output for ~x read -75 and the number in our table is 181. The reason is that we made a wrong assumption when calculating ~x. We wrote the number down with only 8 bits and not 32 bits as stored in SPEC. SPEC will negate all the other bits in the number, too. Therefore we end up with the binary number 11111111111111111111111110110101. This number is interpreted as a negative number from SPEC and this leads to -75. (A number with all bits set to 1 is interpreted as -1). To arrive at the same result as in the table we have to mask off all the higher order bits. We can use the and-operator to do that.

338.SPEC> p ~x & 0xff
181
339.SPEC> p ~y & 0xff
120

Be careful to distinguish well between the bitwise and/or operators and the logical and/or operators from the last section. So results 1&2 in 0 but 1&&2 in 1.

The last two remaining operators >> and << are used to shift the bits in a number to the left (<<) or to the right (>>).

00010001 << 2 == 01000100
00010001 >> 2 == 00000100

You see that the bits in the number get shifted to the left or to the right. You remark that bits can fall off the edge and dissapear when they get shifted "outside" the number. The operation << 2 corresponds to a multiplication with 4 and the operation >> 2 to a division by 4.

Compound Assignments *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=, ++, --

SPEC can combine the assignment with one operation from the previous sections. The idea of such an compound assignment is to carry it out on the number itself. It can be understood by taking "a op= b" as equal to "a = a op b". So will the expression x *= 2 double the value in x for example. The expression variable++ or variable-- will add or substract one from the variable.

340.SPEC> x = 5
341.SPEC> x *= 2
342.SPEC> p x
10
343.SPEC> x -= 6
344.SPEC> p x
4
345.SPEC> x *= 3
346.SPEC> p x
12
347.SPEC> x++
348.SPEC> p x
13

The expression variable++ needs some more explanation as it can be written as variable++ or ++variable. The result will be in both cases that the variable is raised by one. The difference is the value which is returned by this expression. In the case of variable++ the value returned by the expression is the contents of variable and in the case ++variable the resulting value is variable+1. Another way of saying this is that in the case of ++variable the variable is raised before usage and in the case of variable++ it is raised after usage. An example will make that clear:

349.SPEC> x =10
350.SPEC> p x++
10
351.SPEC> p x
11
352.SPEC> x = 10
353.SPEC> p ++x
11
354.SPEC> p x
11

You saw that the effect on the variable was in both cases the same, it went from 10 to 11. In one case x++ was calculated to be 10 and in the other case ++x was calculated to be 11.

The same applies of course to the -- operator.

Conditional Expressions

The conditional expression is a simple way to make an expression depend on an extra condition. The syntax is:

expression1 ? expression2 : expression 3

The value of this construction is either expression2 or expression3 depending on expression1. If expression1 is not equal 0 (TRUE) then the value of the whole expression is expression2 else it is expression3. To get the maximum of two numbers you could write for example:

maximum = (x > y) ? x : y

SPEC special dereference operator

SPEC has a special dereference operator to access variables which name is only known when executing the program. @name_variable corresponds to the variable which name is stored in the variable name_variable. If the variable x contains the string "myvar", @x represents the variable myvar. This is a small example to illustrate that.

365.SPEC> y = 134
366.SPEC> x = "y"
367.SPEC> p @x
134
368.SPEC> @x = 200
369.SPEC> p y
200

The main usage of this feature is related to arrays. Let's suppose you would like to write a general background substraction function which will calculate the background of a spectrum and substract the calculated background from the spectrum. The name of the array which contains the spectrum should be stored in the global variable PLOT_ARRAY. The reason that the name of the array is stored in a global variable is that you would like to write different functions like plot, fit and so on which can be called by the user from SPECs command level. You have two choices now:

1. You can either copy the contents of the array to temporary array and work all the time with the same temporary array. This will cost time and storage space.
2. You can store the name of the array in a global variable and use the @PLOT_ARRAY construction to refer to the array.

If the current data is stored in the array SCAN_DATA, you could assign PLOT_ARRAY to "SCAN_DATA" with the following SPEC command:

PLOT_ARRAY = "SCAN_DATA"

When you would like to get the fist element of the second column of the SCAN_DATA array, you can write now:

first_y = @PLOT_ARRAY[0][1]

Precedence of SPEC operators

The following table lists the SPEC operators in the order of precedence. Everybody knows that multiplication takes precedence over addition. For example 3 * 4 + 1 has to be evaluated as (3 * 4) + 1. In the same way the more complicated operators can also be classified in the order of precedence. If you have doubts simply use parenthesis () to group expressions.

Exercises

1. Write a one-line macro function to return the minimum of two numbers.
2. Is the following expression testing if x is in between 2 and 4 or do you need some extra parenthesis: if (x >= 2 && x <= 4)
3. What is the result of the following expressions:

   1 << 3
   2 >> 2
   1 & 3
   1 & 2
   1 && 2

4. Write one line to set bit number 2 in the variable x, one line to clear bit number 2 in the variable x and one line to check if bit number 2 is set in the variable x.
5. Write an expression to test if the variable y can be divided by 5.

Flow control

Statements and Blocks

The end of the line or a semicolon makes a statement from a expression. If you are familiar with the C language you know that every statement ends in a semicolon there. In its general idea to make programming as simple as possible, this requirement had been released in SPEC. You already noticed this in previous chapters. Some example of a statement are:

y = 34 or
print Hello or
z = 45 ;

You see that a statement can be ended with a semicolon. This is useful to put multiple statements in one line. Like in

x[0]=0; x[1] = 2; x[2] = 4

If you want to continue a single statement over more than one line, you will have to escape the (invisible) end of line character by typing a backslash \ at the end of the line to be continued. Be careful that there is no other character (like a tab or a blank) after the backslash \. For example:

print "The numbers you asked are for are given her:", number1, \
number2, number3, number4

You can group multiple statements to a block with the use of curly brackets ({}). Such a block is equivalent to a single statement. This is used for example for conditional execution of the following statements:

if (x == 4) {
  print "x is 4, this is not allowed"
  exit
}

Without the use of the curly brackets the exit statement would be executed all the time. With curly brackets it is only executed when x is equal to 4.

Another way to group multiple statements to one statement is to separate the individual statements with a comma (,). The syntax is:

statement , statement , statement

The difference between separating statements with , or ; is shown in the following example:

422.SPEC> if (0)
423.more> x = "One Statement" , y = "Another one"
424.more>
424.SPEC> p x,y
0 0
425.SPEC> if (0)
426.more> x = "One Statement" ; y = "Another one"
427.SPEC> p x,y
0 Another one

The if (0) in the example will make sure that the following statement is not executed. As you can see, SPEC accepts the comma separated list as one statement (which is not executed in the example), but the semicolon separated list as two statements.

Sometimes the comma operator does not work correctly. This is when the statement before accepts , as possible input values. Like in:

428.SPEC> print "Hello" , print "World"
print "Hello" , print "World"
^
Syntax error on "print".

when the print commands interprets the comma.

The if-statement

The syntax for the conditional execution in SPEC is

if (expression)
statement1
else
statement2

Statement1 is executed if the expression is not equal 0 (TRUE) else the statement2 is executed. The else part is optional. The following is an example of a simple if statement.

if (n >= 0)
sign = 1
else
sign = -1

There is a two problem with the if statement which comes from the fact that the else statement is optional. If there are multiple if statements with some else missing it is not easy to see to which if statement an else belongs. This is easy to see in the following example:

if (n >= 0)
if (n == 0)
sign = 0
else
sign = 1

The problem is now to know to which if statement (the (n >=0) or the (n==0)) the else belongs to. SPEC solves this conflict by always using the if statement which is closest to the else and does not have another else statement yet. In our example the else statement belongs to therefore to the (n == 0) if statement as indicated by the indentation. (for help human readers). You can always use curly brackets if you have any doubts. In our example you could also have been written:

if (n >= 0) {
if (n == 0)
  sign = 0
else
  sign = 1
}

to make it really clear to which if statement the else statement belongs. An application of the else rule mentioned above is often used to formulate multiple if-else chains. For example:

if (x <= 0) {
  print "No error"
} else if (x == 1) {
  print "Could not open input file"
} else if (x ==2) {
  print "Could not open output file"
} else {
  print "Unknown error"
}

The following problem is less important. Look at the following example of typing

372.SPEC> if (x = 2)
373.more> p "x is two"
374.more>
x is two

The line you have to look to see the problem is 374. You see that SPEC did not write "x is two" immediatly to the screen, but waited for you to type the next line. (line 374 which is empty). The reason for this behaviour is that SPEC does not know if an else statement will follow.

The for loop

The standard loop to execute a statement multiple times is constructed with the for statement in the following way:

for (expression1; expression2; expression3)
statement

The statement will be executed as long as expression2 is TRUE (!= 0). Before the statement is executed for the first time expression1 is executed. expression3 is executed every time after the statement is executed. The standard way to execute a statement n times in SPEC is done with the following statement:

for (i = 0; i < n; i++)
statement

You see that before anything else is done i is set to 0 with the first expression. After that i is tested if it is smaller than n. If n is greater than 0, the statement is executed for the first time. After the execution of the statement, i is incremented to be 1. Then i is tested again to be smaller than n. If n is greater than 1, the statement is executed for the second time. In total the statement will be executed n times. At the end of the nth execution, i will be incremented to be n and fail the test. Therefore execution will continue with the next statement in the program.

The expressions do not all have to be present. For example, if the first expression is missing, there will be no initialisation. The following two statements do the same thing as the last example above:

i=0
for (;i<n;) {
  statement
  i++
}

In this way, an endless loop can be written as:

for (;;)
statement

The while loop

Another way to construct loops in SPEC is with the help of the while statement. Its syntax is:

while (expression)
statement

If the expression is different from 0 (TRUE), the statement is executed. The statement is executed as long as the expression is TRUE. The above for loop could be written also in the following way:

i=0
while (i <n) {
  statement
  i++
}

The for and while loops are the same as the ones defined in C. Contrary to C, the SPEC language does not include the do-while nor the switch statement.

The break statement

The break statement is used to leave a loop before its regular end. When SPEC encounters a break statement it leaves the innermost loop. In the following example, the break statement is used to leave the for loop if there is an error.

for (i = 0; i < 1000; i++) {
  measure_pressure
  if (PRESSURE_ERROR != 0 ) {
    print "Error measuring pressure"
    break
  }
}
print "Continue with other important tasks"

The macro measure_pressure is supposed to measure a value and store it. In case of an error it could set the global variable PRESSURE_ERROR. The break statement inside the if, would leave the loop and continue with the print statement "Continue with other important tasks".

The continue statement

The continue statement is similar to the break statement in the sense that it also is used inside loop constructions. As soon as a continue statement is reached the current loop iteration is stopped and the next one is started. You can imagine that the continue statement jumps back to the beginning of the loop and starts the next iteration.

for (i=0; i< 1000; i++) {
  if (data[i] < 0)
    continue;
  treat_data
}

In the above example, the macro treat_data will only be called for positive elements of the array data. If a negative array element is found, the continue statement is called. Therefore the next iteration is started. The counter i is raised.

Exercises

1. Write a macro to print the first 10 non negative elements of the array "items".
2. Write a macro to sort the 100 elements of the array "numbers".
3. What will be the output of the following macros on the screen:

   def loop_1 '{
   for (i=0; i<10; i+= 2) {
   print i
   }
   }'

   def loop_2 '{
   local x
   x = 34
   while (x == 0) {
   x = 43
   print "X is now", x
   }
   }'

   def loop_3 '{
   local i j
   for (i = 0; i< 3; i++)
   for (j = 0; j < 3; j++) {
   if (j == i)
   continue
   print j
   }
   }'

4. And in these more complicated cases:
   

   def loop_4 '{
   local x
   x = 3
   if (x < 2)
   if (x < 1)
   print "Your value x is too small"
   else
   print "X is OK"
   }'

   def loop_5 '{
   local i
   for (i = 0; i < 5; i ++) ;
   print i
   }'

Input/Output Facilities

The print and printf commands - write output to the screen

We already used the print command in our macros. It syntax is

print string_expression1, string_expression2, ...

The print command will write all these string_expressions to the sceen separated by one blank character. After printing it will automatically start a new line. (The possiblity to separate the string expressions with spaces and not with commas has nothing to do with the print command, but is a general SPEC feature. Strings can be concatenated by separating them with blanks. More about this feature in the section about string handling)

If you need more precise formating you can use the printf function. (the "f" stands for formated). The general syntax of this function is:

printf (format_string, argument1, argument2, ....)

The format_string describes in which format to write the parameters on the screen. There are many different possible formats and ways how to describe them. In the following we only give a short introduction to the usage of the printf function. Look in a good C reference guide to know about all the possibilities.

The general format consists of an abritary string. In this string there are special argument format descriptors embedded which start with a percentage sign (%) to distinguish them from ordinary text. This is an example how to print the contens of the variable x on the screen:

565.SPEC> printf ("The variable x is %d now\n", x)
The variable x is 0 now

In general, the argument format descriptor has the following format

Examples of valid formats are :

%15f, %20.20s, 0x%x, %.10s, %04d, %10.3e, %-7.3f

The meaning of the letter indicating the type is shown in the following table:

The most important usages are normally:

• %d to output a number without a decimal point
• %f to output a number with fixed number of decimal places
• %g if you are not sure about the magnitude of a floating point number
• %s to output a string

To put a literal percentage sign in the format string you have to double the percentage sign (%%). You could write for example:

printf("I work at %d %% for the moment\n", 100)

The following character combinations have a special meaning in a string constant. They are not only valid for the printf function, but in general for all the string constants.

The following examples cover the most used formats.

1.SPEC> str = "Hello world" ; i = 20; x = 234.56789; y = -1

6.SPEC> printf("This is my string %20.10s\n",str)
This is my string Hello worl
7.SPEC> printf("This is my string %-20.10s\n",str)
This is my string Hello worl
8.SPEC> printf("This is my string %-20.20s\n",str)
This is my string Hello world
9.SPEC> printf("Now i = %d and x = %f\n",i,x )
Now i = 20 and x = 234.567890
10.SPEC> printf("Now i = %04d and x = %10.2f\n",i,x )
Now i = 0020 and x = 234.57
11.SPEC> printf("Now i = %-1d and x = %10.2e\n",i,x )
Now i = 20 and x = 2.35e+02
13.SPEC> printf("Now i = 0x%x and x = %10.4g\n",i,x )
Now i = 0x14 and x = 234.6

More to come