Program Organization

Lexical Elements

• White Space, Newlines, and Continuation Lines
• Comments
• Identifiers
• Keywords

White Space, Newlines, and Continuation Lines

The main purpose of white space characters is to format source files so that they are more readable. The compiler ignores white space characters, except when they are used to separate tokens or when they appear within string literals.

The newline character is not treated as white space in preprocessor directives. A newline character is used to terminate preprocessor directives. See Overview of the Preprocessor for more information.

The line continuation character in C is the backslash (\). Use the continuation character at the end of the line when splitting a quoted string or preprocessor directive across one or more lines of source code.

Spreading Source Code Across Multiple Lines

HP C allows comments to appear anywhere in the source file except within identifiers or string literals. The C language does not support nested comments.

In the following example, a comment follows an assignment statement:

average = total / number_of_components; /* Find mean value. */

/*
    This is a
    multi-line comment.
 */

• Letters (ISO Latin-1 decimal values 65-90 and 97-122)
• Digits
• Dollar sign ($) (HP C extension)
• Underscore (_)

Identifiers cannot conflict with reserved Keywords .

Legal Identifiers

Illegal Identifiers

Length of Identifiers

The ANSI/ISO standard requires compilers to support names of up to 32 characters for local variables and 6 characters for global variables.

To improve portability, it is a good idea to make your local variable names unique within the first 32 characters, and global variable names unique within the first 6 characters.

Case Sensitivity in Identifiers

kilograms
KILOGRAMS
Kilograms

Strings are also case-sensitive. The system recognizes the following two strings as distinct:

"THE RAIN IN SPAIN"
"the rain in spain"

Keywords

• auto
• break
• case
• char
• const
• continue
• default
• do
• double
• else
• enum
• extended
• extern
• float
• float80
• for
• goto
• if
• int
• long
• long double
• register
• return
• short
• signed
• sizeof
• static
• struct
• switch
• __thread
• typedef
• union
• unsigned
• void
• volatile
• while

auto

break

case

switch (getchar())
{
   case "r":
   case "R":
      moveright();
      break;
      ...
}

char

A char type has a minimum value of -128 and a maximum value of 127.

The numeric range for unsigned char is 1 byte, with a minimum value of 0 and a maximum value of 255.

const

/* declare factor as a constant float */
const float factor = 2.54;

continue

default

switch (grade){
   case "A":
      printf("Excellent\n");
      break;
   default:
      printf("Invalid grade\n");
      break;
}

do

• Min:
  • Least positive normal: 2.2251e-308
  • Least positive denormal: 4.9407e-324
• Max: 1.7976e+308

Other floating-point types are float, float80, extended and long double.

else

enum

The approximate range in decimal for extended is:

• Min:
  • Least positive normal: 3.3622e-4932
  • Least positive denormal: 3.6452e-4951
• Max: 1.1897e4932

Other floating-point types are float, float80, double and long double.

float

The approximate range in decimal for float is:

• Min:
  • Least normalized: 1.1755E-38
  • Least denormalized: 1.4013E-45
• Max: 3.4028E+38

Other floating-point types are extended, float80, double and long double.

float80

The range for float80 is:

• Min: Least normalized: Least denormalized:
• Max:

for

if

int

The range for int is -2,147,483,648 through 2,147,483,647.

The range for unsigned int is 0 through 4,294,967,295.

long

The long long 64-bit data type is supported as an extension to the language when you use the -Ae compile-line option.

The range for long long is -9,223,372,036,854,775,808 through +9,223,372,036,854,775,807.

long double

The approximate range in decimal for long double is:

• Min:
  • Least positive normal: 3.3622e-4932
  • Least positive denormal: 6.4752e-4966
• Max: 1.1897e4932

Other floating-point types are extended, float, float80, and double.

register

return

short

The range for short is -32,768 through 32,767.

The range for unsigned short is 0 through 65,535.

signed

• char
• int
• enum
• long
• long long
• short

static

__thread

This keyword is implemented as an HP-specific type qualifier, with the same syntax as const and volatile, but not the same semantics. Syntax examples:

__thread int var;
int __thread var;

Only one declaration, for example,

__thread int x;

extern __thread int x;

Note that use of the __thread keyword in a shared library will prevent that shared library from being dynamically loaded (that is, loaded via an explicit call to shl_load()).

typedef

• char
• int
• enum
• long
• long long
• short

• to indicate that a function does not return a value
• to declare a function that takes no arguments
• to allow you to create generic pointers.

void func(int a, int b)
{
      . . .    
}

extern void func(int, int);

• Typedef Declarations
• Abstract Global Types
• Improving Portability
• Simplifying Complex Declarations
• Using typedefs for Arrays
• Name Spaces
• Structure, Union, and Enum Names
• Macro Names

In general, a variable declaration has the following format:

[storage_class_specifier] [data_type] variable_name
    [=initial_value];

• storage_class_specifier is an optional keyword.
• data_type is one of the data types described in Data Types and Declarations
• variable_name is a legal identifier.
• initial_value is an optional initializer for the variable.

int   age;                 /* integer variable "age" */
int length, width;         /* abbreviated declaration of two
                              variables*/
float ph;                  /* floating-point variable "ph" */
char  a_letter;            /* character variable "a_letter" */
int   values[10];         /* array of 10 integers named values */
enum  days {mon, wed, fri}; /* enumerated variable "days" */

A typedef declaration may appear anywhere a variable declaration may appear and obeys the same scoping rules as a normal declaration. Once declared, a typedef name may be used anywhere that the type is allowed (such as in a declaration, cast operation, or sizeof operation). You can write typedef names in all uppercase so that they are not confused with variable names.

You may not include an initializer with a typedef.

The statement:

typedef long int FOUR_BYTE_INT;

long int j;
FOUR_BYTE_INT j;

typedef struct {
    char  month[4];
    int   day;
    int   year;
} BIRTHDAY;
 
typedef char A_LINE[80]; /* A_LINE is an array of
                          * 80 characters */

Improving Portability

#if SMALL_COMPUTER
    typedef int SHORTINT;
    typedef long LONGINT;

#elif
    BIG_COMPUTER
    typedef short SHORTINT;
    typedef int LONGINT;

#endif

Simplifying Complex Declarations

typedef float *PTRF, ARRAYF[], FUNCF();

PTRF x[5];  /* a 5-element array of pointers to floats */
FUNCF z;    /* A function returning a float */

Using typedefs for Arrays

typedef char STR[80];      
STR   string, *ptr;         
                           
                           
                            
main()                      
{                           
   ptr = string;            
   printf("ptr = %d\n", ptr);
   ptr++;                     
   printf("ptr = %d\n", ptr);  
}                            
                            
*** Run-Time Results ***     
                             
ptr = 3997696                
ptr = 3997776                

typedef char STR[80];      
STR   string;             
char  *ptr;                
                            
                            
main()                      
{                            
   ptr = string;
   printf("ptr = %d\n", ptr);
   ptr++;
   printf("ptr = %d\n", ptr);
}                            
                           
*** Run-Time Results ***     
                            
ptr = 3997696               
ptr = 3997697               

• Structure, Union, and Enumeration Tags are tag names that immediately follow these type specifiers: struct, union, and enum. These types are described in Structure and Union Specifiers .
• Member Names are names of members of a structure or union.
• Goto Labels are names that mark the target of a goto statement.
• Function, Variable and All Other Names are any names that are not members of the preceding three classes.

The following example uses the same name, overuse, in four different ways:

int main(void)
{
    int overuse;       /* normal identifier */
    struct overuse {   /* tag name */
        float overuse; /* member name */
        char *p;
    } x;
    goto overuse;
overuse: overuse = 3;  /* label name */
}

struct A {
    int x;
    float y;
};
struct B {
    int x;
    float y;
};

#define square(arg)  arg * arg


int main(void)
{
  ...
square:
   ...
}

• Integer Constants
• Floating-Point Constants
• Character Constants
• String Constants

Integer Constants

• decimal - one or more digits from 0-9. The constant must not start with a 0.
• octal - one or more digits from 0-7. The constant must begin with 0.
• hexadecimal - one or more hexadecimal digits from 0-9, a-f, or A-F. The constant must begin with 0x or 0X. An integer constant is a simple number like 12. It is not an integer variable (like x or y) or an integer expression.

  The data type assigned to an integer constant is the first in which it will fit from the list on the right for the constant declaration on the left:
  

  Table 1: 

  Constant	Assigned Data Type
  decimal (no suffix)	int, long int, unsigned long int
  octal or hex (no suffix)	int, unsigned int, long, unsigned long
  letter u or U suffix	unsigned int, unsigned long int
  letter l or L suffix	long, unsigned long
  both letters u or U and	unsigned long l or L suffix:
  letters ll or LL suffix:	long long, unsigned long long
  both letters u or U and ll or LL suffix:	unsigned long long

Integer constants may not contain any punctuation such as commas or periods.

Examples of Integer Constants

Floating-Point Constants

The number may be followed by an f or F, to signify that it is of type float, or by an l or L, to signify that it is of type long double. If the number does not have a suffix, it is of type double even if it can be accurately represented in four bytes.

If the magnitude of a floating-point constant is too great or too small to be represented in a double, the C compiler will substitute a value that can be represented. This substitute value is not always predictable.

You may precede a floating-point constant with the unary plus or minus operator to make its value positive or negative.

Scientific Notation

The letter e or E, standing for exponent, is used to separate the two parts.

The floating-point constant 3e2, for instance, is interpreted as 3*(10²), or 300. Likewise, the value -2.5e-4 is interpreted as -2.5/(10⁴), or -0.00025.

Examples of Floating-Point Constants

Character Constants

The value of a character constant is the integer ISO Latin-1 value of the character. For example, the value of the constant x is 120.

Escape Sequences

The escape sequences for octal and hexadecimal numbers are commonly used to represent characters. For example, if ISO Latin-1 representations are being used, the letter a may be written as \141 or \x61 and Z as \132 or \x5A. This syntax is most frequently used to represent the null character as \0. This is exactly equivalent to the numeric constant zero (0). When you use the octal format, you do not need to include the zero prefix as you would for a normal octal constant.

Multi-Character Constants

For example, the following assignments are legal:

{
   char    x;              /* 1-byte integer */
   unsigned short int si;  /* 2-byte integer */
   unsigned long int li;   /* 4-byte integer */
 
/* the following two assignments are portable: */
   x  =  "j";      /* 1-byte character constant */
   li = L"j";      /* 4-byte wide char constant */
 
/* the following two assignments are not portable,
   and are not recommended: */
   si = "ef";     /* 2-character constant */
   li = "abcd";   /* 4-character constant */
}

String Constants

"A short string"

Like a character constant, a string constant can begin with the letter L to indicate that it is a string constant in an extended character set.

To span a string constant over more than one line, use the backslash character (\), also called the continuation character. The following, for instance, is legal:

    strcpy(string,"This is a very long string that requires more \
than one line");

The compiler concatenates adjacent string constants. Therefore, you can also span a string constant over one line as shown:

strcpy(string, "This is a very long string that requires more "
               "than one line");

The type of a string is array of char, and strings obey the same conversion rules as other arrays. Except when a string appears as the operand of sizeof or as an initializer, it is converted to a pointer to the first element of the string. Note also that the null string,

""

Structuring a C Program

• Preprocessor directives
• Variables
• Functions

Example

The following shows how a program can be organized:

/* preprocessor directives */

#include <stdio.h>
#define WEIGHTING_FACTOR 0.6
/* global typedef declaration */
typedef float THIRTY_TWO_BIT_REAL;
/* global variable declaration */
THIRTY_TWO_BIT_REAL correction_factor = 1.15;
/* prototype */
float average (float arg1, THIRTY_TWO_BIT_REAL arg2)
/* start of function body */
{
   /* local variable declaration */
    float mean;
   /* assignment statement */
    mean = (arg1 * WEIGHTING_FACTOR) +
           (arg2 * (1.0 - WEIGHTING_FACTOR));
/* return statement */
     return (mean * correction_factor);
/* end of function body */
}

int main(void)
/* start of function body */
{
/* local variable declarations */ 
    float value1, value2, result;
/* statements */
    printf("Enter two values -- ");
    scanf("%f%f", &value1, &value2);
    result = average(value1, value2);
/* continuation line */
    printf("The weighted average using a correction \
factor of %4.2f is %5.2f\n", correction_factor, result);
/* end of function body */
}