In order to mark statements that the program might wish to reference with GOTO or GOSUB commands, PBP uses line labels. Unlike many older BASICs, PBP doesn't allow line numbers and doesn't require that each line be labeled. Rather, any PBP line may start with a line label, which is simply an identifier followed by a colon (:).

	here:	Serout 0,N2400,["Hello, World!",13,10]
		Goto here

Variables are where temporary data is stored in a PICBASIC PRO™ program. They are created using the VAR keyword. Variables may be bits, bytes or words. Space for each variable is automatically allocated in the microcontroller=s RAM by PBP. The format for creating a variable is as follows:

	Label	VAR	Size{.Modifiers}

Label is any identifier, excluding keywords, as described above. Size is BIT, BYTE or WORD. Optional Modifiers add additional control over how the variable is created. Some examples of creating variable are:

	dog	var	byte
	cat	var	bit
	w0	var	word

There are no predefined user variables in PICBASIC PRO™. For compatibility sake, two files have been provided that create the standard variables used with the BASIC Stamps: Abs1defs.bas@ and Abs2defs.bas@. To use one of these files, add the line:

Include "bs1defs.bas"

Include "bs2defs.bas"

near the top of the PICBASIC PRO™gram. These files contain numerous VAR statements that create all of the BASIC Stamp variables and pin definitions.

VAR can also be used to create an alias (another name) for a variable. This is most useful for accessing the innards of a variable.

	fido	var	dog		' fido is another name for dog
	b0	var	w0.byte0	' b0 is the first byte of word w0
	b1	var	w0.byte1	' b1 is the second byte of word w0
	flea	var	dog.0		' flea is bit0 of dog

The variable modifiers may also be used as part of variables in a statement:

b = w0.byte0
OPTION_REG.7 = 0

Label VAR Size[Number of elements]

Label is any identifier, excluding keywords, as described above. Size is BIT, BYTE or WORD. Number of elements is how many array locations is desired. Some examples of creating arrays are:

The first array location is element 0. In the fish array defined above, the elements are numbered fish[0] to fish[7] yielding 8 elements in total.

Label CON Constant expression

SYMBOL provides yet another method for aliasing variables and constants. It is included for BS1 compatibility. SYMBOL cannot be used to create a variable. Use VAR to create a variable.

	SYMBOL lion = cat	' cat was previously created using VAR
	SYMBOL mouse = 1	' Same as mouse con 1

PBP allows numeric constants to be defined in the three bases: decimal, binary and hexadecimal. Binary values are defined using the prefix '%' and hexadecimal values using the prefix '$'. Decimal values are the default and require no prefix.

	100	' Decimal value 100
	%100	' Binary value for decimal 4
	$100	' Hexadecimal value for decimal 256

	"A"	' ASCII value for decimal 65
	"d"	' ASCII value for decimal 100

	Lcdout "Hello"	' Output String (Short for "H","e","l","l","o")

	PORTA = %01010101	' Write value to PORTA
	anyvar = PORTB & $0f	' Isolate lower 4 bits of PORTB and 
				place result in anyvar

	PORTB.1 = 1	' Set PORTB, bit 1 to a 1

To make it easier to remember what a pin is used for, it should be assigned a name using the VAR command. In this manner, the name may then be used in any operation:

led	var	PORTA.0	' Rename PORTA.0 as led
	High led		' Set led (PORTA.0) high

Pins may be referenced by number (0 - 15), name (e.g. Pin0, if one of the bsdefs.bas files are included or you have defined them yourself), or full bit name (e.g. PORTA.1). Any pin or bit of the microcontroller can be accessed using the latter method.

The pin names (i.e. Pin0) are not automatically included in your program. In most cases, you would define pin names as you see fit using the VAR command:

However, two definition files have been provided to enhance BASIC Stamp compatibility. The file Abs1defs.bas@ or Abs2defs.bas@ may be included in the PICBASIC PRO™ program to provide pin and bit names that match the BASIC Stamp names.

Include "bs1defs.bas"

Include "bs2defs.bas"

BS1DEFS.BAS defines Pins, B0-B13, W0-W6 and most of the other BS1 pin and variable names.

BS2DEFS.BAS defines Ins, Outs, B0-B25, W0-W12 and most of the other BS2 pin and variable names.

	TRISA = %00000000		' Or TRISA = 0

	TRISB = %11111111		' Or TRISB = 255

	TRISB = %11111111		' Or TRISB = 255

The BASIC Stamp variable names Dirs, Dirh, Dirl and Dir0-Dir15 are not defined and should not be used with the PICBASIC PRO™ Compiler. TRIS should be used instead, but has the opposite state of Dirs.

	Dir0 = 1	' Doesn’t set pin PORTB.0 to output

	TRISB.0 = 0	' Set pin PORTB.0 to output

A PBP comment starts with either the REM keyword, the single quote ('), or the semi-colon (;). All following characters on this line are ignored.

Unlike many BASICs, REM is a unique keyword and not an abbreviation for REMark. Thus, variables names may begin with REM (although REM itself is not valid).

In order to allow more compact programs and logical grouping of related commands, PBP supports the use of the colon (:) to separate statements placed on the same line. Thus, the following two examples are equivalent:

	W2 = W0
	W0 = W1
	W1 = W2

is the same as:

	W2 = W0 : W0 = W1 : W1 = W2

	Branch B0,[label0,label1,label2,_
	label3,label4]

Other BASIC source files may be added to a PBP program by using INCLUDE. You may have standardized subroutines, definitions or other files that you wish to keep separate. The Stamp and serial mode definition files are examples of this. These files may be included in programs where they are necessary, but kept out of programs where they are not needed.

The included file=s source code lines are inserted into the program exactly where the INCLUDE is placed.

INCLUDE "modedefs.bas"

Some elements, like the clock oscillator frequency and the LCD pin locations, are predefined in PBP. DEFINE allows a PBP program to change these definitions, if desired.

DEFINE may be used to change the predefined oscillator value, the DEBUG pins and baud rate and the LCD pin locations, among other things. 

These definitions must be in all upper case. If not, the compiler may not recognize them. No error message will be produced for DEFINEs the compiler does not recognize.

See the appropriate sections of the manual for specific information on these definitions. A complete list of DEFINEs is in Appendix B.

	DEFINE OSC 4			'Oscillator speed in
					 MHz: 3(3.58) 4 8 10
					 12 16 20 25 32 33 40

PBP performs 16x16 multiplication. The '*' operator returns the lower 16 bits of the 32-bit result. This is the typical multiplication found in most programming languages. The '**' operator returns the upper 16 bits of the 32-bit result. These two operators can be used in conjunction to perform 16x16 multiplication that produces 32-bit results.

	W1 = W0 * 1000	' Multiply value in W0 by 1000 and place the result in W1
	W2 = W0 ** 1000	' Multiply W0 by 1000 and place the high order 16 bits (which may be 0) in W2

The >*/= operator returns the middle 16 bits of the 32-bit result.

	W3 = W1 */ W0	' Multiply W1 by W0 and place the middle 16 bits in W3

PBP performs 16x16 division. The '/' operator returns the 16-bit result. The '//' operator returns the remainder. This is sometimes referred to as the modulus of the number.

	W1 = W0 / 1000	' Divide value in W0 by 1000 and place the result in W1
	W2 = W0 // 1000	' Divide value in W0 by 1000 and place the remainder in W2

The '<<' and '>>' operators shift a value left or right, respectively, 0 to 15 times. The newly shifted-in bits are set to 0.

	B0 = B0 << 3	' Shifts B0 left 3 places (same as multiply by 8)
	W1 = W0 >> 1	' Shifts W0 right 1 position and places result in W1 (same as divide by 2)

ABS returns the absolute value of a number. If a byte is greater than 127 (high bit set), ABS will return 256 - value. If a word is greater than 32767 (high bit set), ABS will return 65536 - value.

	B1 = ABS B0

COS returns the 8-bit cosine of a value. The result is in two=s complement form (i.e. -127 to 127). It uses a quarter-wave lookup table to find the result. Cosine starts with a value in binary radians, 0 to 255, as opposed to the usual 0 to 359 degrees.

	B1 = COS B0

DCD returns the decoded value of a bit number. It changes a bit number (0 - 15) into a binary number with only that bit set to 1. All other bits are set to 0.

	B0 = DCD 2		' Sets B0 to %00000100

DIG returns the value of a decimal digit. Simply tell it the digit number (0 - 4 with 0 being the rightmost digit) you would like the value of, and voila.

	B0 = 123		' Set B0 to 123
	B1 = B0 DIG 1	' Sets B1 to 2 (digit 1 of 123)

PBPs multiply (*) function operates as a 16-bit x 16-bit multiply yielding a 32-bit result. However, since the compiler only supports a maximum variable size of 16 bits, access to the result had to happen in 2 steps: c = b * a returns the lower 16 bits of the multiply while d = b ** a returns the upper 16 bits. There was no way to access the 32-bit result as a unit.

In many cases it is desirable to be able to divide the entire 32-bit result of the multiply by a 16-bit number for averaging or scaling. A new function has been added for this purpose: DIV32. DIV32 is actually limited to dividing a 31-bit unsigned integer (max 2147483647) by a 15-bit unsigned integer (max 32767). This should suffice in most circumstances.

As the compiler only allows a maximum variable size of 16 bits, DIV32 relies that a multiply was just performed and that the internal compiler variables still contain the 32-bit result of the multiply. No other operation may occur between the multiply and the DIV32 or the internal variables may be altered, destroying the 32-bit multiplication result.

This means, among other things, that ON INTERRUPT must be DISABLEd from before the multiply until after the DIV32. If ON INTERRUPT is not used, there is no need to add DISABLE to the program. Interrupts in assembler should have no effect on the internal variables so they may be used without regard to DIV32.

The following code fragment shows the operation of DIV32:

a 	Var 	Word
b 	Var 	Word
c 	Var 	Word
dummy 	Var 	Word

	b = 500
	c = 1000

	Disable 	' Necessary if On Interrupt used

	dummy = b * c 	' Could also use ** or */
	a = DIV32 100

	Enable 		' Necessary if On Interrupt used

This program assigns b the value 500 and c the value 1000. When multiplied together, the result would be 500000. This number exceeds the 16-bit word size of a variable (65535). So the dummy variable contains only the lower 16 bits of the result. In any case, it is not used by the DIV32 function. DIV32 uses variables internal to the compiler as the operands.

In this example, DIV32 divides the 32-bit result of the multiplication b * c by 100 and stores the result of this division, 5000, in the word-sized variable a.

MAX and MIN returns the maximum and minimum, respectively, of two numbers. It is usually used to limit numbers to a value.

	B1 = B0 MAX 100	' Set B1 to the larger of B0 and 100 (B1 will be between 100 & 255)
	B1 = B0 MIN 100	' Set B1 to the smaller of B0 and 100 (B1 can’t be bigger than 100)

NCD returns the priority encoded bit number (1 - 16) of a value. It is used to find the highest bit set in a value. It returns 0 if no bit is set.

	B0 = NCD %01001000	' Sets B0 to 7

REV reverses the order of the lowest bits in a value. The number of bits to be reversed is from 1 to 16.

	B0 = %10101100 REV 4	' Sets B0 to %10100011

SIN returns the 8-bit sine of a value. The result is in two=s complement form (i.e. -127 to 127). It uses a quarter-wave lookup table to find the result. Sine starts with a value in binary radians, 0 to 255, as opposed to the usual 0 to 359 degrees.

	B1 = SIN B0

SQR returns the square root of a value. Since PICBASIC PRO™ only works with integers, the result will always be an 8-bit integer no larger than the actual result.

	B0 = SQR W1	' Sets B0 to square root of W1

	B0 = B0 & %00000001	' Isolate bit 0 of B0
	B0 = B0 | %00000001	' Set bit 0 of B0
	B0 = B0 ^ %00000001	' Reverse state of bit 0 of B0

Comparison operators are used in IF..THEN statements to compare one expression with another. These comparisons are unsigned. They cannot be used to check if a number is less than 0.

Logical operators differ from bitwise operations. They yield a true/false result from their operation. Values of 0 are treated as false. Any other value is treated as true. They are mostly used in conjunction with the comparison operators in an IF..THEN statement. The operators supported are: