[Skip Navigation] [CSUSB] / [CNS] / [Comp Sci Dept] / [R J Botting] / [Samples] / c.syntax
[Index] [Contents] [Source Text] [About] [Notation] [Copyright] [Comment/Contact] [Search ]
Fri Sep 28 16:10:30 PDT 2007

Contents


    Syntax of The C Programming Language

      Cross-Refferences

    1. ASCII::= See http://www.csci.csusb.edu/dick/samples/comp.text.ASCII.html

      Used_in The definition of C++ [ c++.syntax.html ]

      Used_in The definition of Java [ java.syntax.html ]

      Notation

      This uses my XBNF Extended BNF Notation where "|" indicates "or", "(...)" indicates priority. For more information see [ intro_ebnf.html ]

      The following abbreviations are also used:


      1. O(_)::= 0 or 1 occurrences,
      2. N(_)::= 1 or more occurrence
      3. L(_)::= a comma separated list
      4. #(_)::= 0 or more occurrences.

      5. S(E,Op)::=serial_operator_expression(E, Op)
      6. serial_operator_expression(E,Op)::= E #(Op E).
         		S(E,Op) = E Op E Op E Op ... E

      It also uses the following shorthand

      Lexemes

      1. identifier::=nondigit #(nondigit | digit),

      2. nondigit::="_" | "a" | "A" | "b" | "B" | "c" | "C" | "d" | "D" | "e" | "E" | "f" | "F" | "g" | "G" | "h" | "H" | "i" | "I" | "j" | "J" | "k" | "K" | "l" | "L" | "m" | "M" | "n" | "N" | "o" | "O" | "p" | "P" | "q" | "Q" | "r" | "R" | "s" | "S" | "t" | "T" | "u" | "U" | "v" | "V" | "w" | "W" | "x" | "X" | "y" | "Y" | "z" | "Z",

      3. digit::="0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9",

      4. punctuator::="[" | "]" | "(" | ")" | "{" | "}" | "*" | "," | ":" | "=" | ";" | "..." | "#",

      5. operator::="[" | "]" | "(" | ")" | "." | "->" | "++" | "--" | "&" | "*" | "+" | "-" | "~" | "!" | "sizeof" | "/" | "%" | "<<" | ">>" | "<" | ">" | "<=" | ">=" | "==" | "!=" | "^" | "|" | "&&" | "||" | "?" | ":" | "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "||=" | "," | "#" | "##",

      6. infix::= "->" | "&" | "*" | "+" | "-" | "/" | "%" | "<<" | ">>" | "<" | ">" | "<=" | ">=" | "==" | "!=" | "^" | "|" | "&&" | "||" | "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "||=" | "," ,

      7. prefix::= "++" | "--" | "&" | "*" | "+" | "-" | "~" | "!" | "sizeof" ,

      8. postfix::= "++" | "--",

      9. integer_suffix::=#(unsigned_suffix) | #(long_suffix),

      10. unsigned_suffix::="u" | "U",

      11. long_suffix::="l" | "L",

      12. sign::="+" | "-",

      13. octal_constant::="0" #(octal_digit),

      14. octal_digit::="0" | "1" | "2" | "3" | "4" | "5" | "6" | "7",

      15. hex_constant::=("0x" | "0X") (hex_digit),

      16. hex_digit::="0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "a" | "b" | "c" | "d" | "e" | "f" | "A" | "B" | "C" | "D" | "E" | "F",

      17. decimal_constant::=non_zero_digit #(digit),

      18. non_zero_digit::="1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9",

      19. integer_constant::=(decimal_constant | octal_constant | hex_constant) | integer_suffix,

      20. float_suffix::="f" | "l" | "F" | "L",

      21. fraction::=#digit "." digit #digit,

      22. exponent_part::=("e" | "E") sign #(digit),

      23. float_constant::=fraction (exponent_part|) (float_suffix|)|(decimal_constant (exponent_part|) float_suffix,

      24. enumeration_constant::=identifier,

      25. char_constant::=char~(double_quote|eoln|backslash)| escape_sequence,

      26. escape_sequence::=backslash (char | "0" #octal_digit |"0x"#hexadecimal_digit),

      27. character_constant::="'" char_constant"'" ,

        constant :=::=float_constant | integer_constant | enumeration_constant | character_constant,

      28. string__char::=char~(double_quote|eoln|backslash)| escape_sequence,

      29. string_literal::=double_quote #(string_char) double_quote,

      . . . . . . . . . ( end of section Lexemes) <<Contents | End>>

      Expressions

        Expressions are made up by applying operators to primary_expressions.

      1. primary_expression::= variable | constant | string_literal | "(" expression ")",

      2. variable::= identifier & declared and in scope of declaration.
      3. argument_list::=List(assignment_expression),

        Operators

        SymbolSee
        "("... ")"primary_expression cast_expression function_call
        "."part of a structure
        "-"additive_expression unary_expression
        "->"part of a pointed at structure
        "--"unary_expression postfix_expression
        "-="assignment_expression
        "&"AND_expression bitwise Boolean
        "&="assignment_expression
        "&"address_of unary_expression
        "&&"logical_AND_expression
        "*"multiplicative_expression contents of pointer unary_expression
        "*="assignment_expression
        "+" additive_expression unary_expression
        "++"unary_expression postfix_expression
        "+="assignment_expression
        "~"bitwise negation prefix
        "!"logical negation prefix
        "!="equality_expression
        "sizeof"unary_expression
        "/"multiplicative_expression divide
        "/="assignment_expression
        "%"multiplicative_expression mod
        "%="assignment_expression
        "<"relational_expression
        "<<"shift_expression left
        "<<="assignment_expression
        "<="relational_expression
        ">"relational_expression
        ">>"shift_expression right
        ">="relational_expression
        ">>="assignment_expression
        "=="equality_expression
        "="assignment_expression
        "^"XOR_expression exclusive-or bitwise
        "^="assignment_expression
        "|"OR_expression bitwise or
        "||"logical_OR_expression
        "||="assignment_expression
        ..."?"... ":"...conditional_expression
        ","expression (discard previous value)

        Arithmetic

      4. post_fix::="++" | "--",

      5. post_fix_expression::=(primary_expression) #(post_fix),

      6. unary_operator::="&" | "*" | "+" | "-" | "!" | "-",

      7. pre_fix::="++" | "--" | "sizeof",

      8. unary_expression::=#(pre-fix) post_fix_expression | unary_operator cast_expression | "sizeof" "(" type_name")",

      9. cast_expression::=#(type_name) unary_expression. This implies that casts are done after doing post-fix operations..

      10. multiplicative_expression::=S(cast_expression, multiplicative_operator). [ serial_operator_expression ]

        The rule above means that 'casts' are done before multiplication and division, and that multiplication and division are done from left to right.

      11. multiplicative_operator::="*" | "%" | "/",

      12. additive_expression::=S(multiplicative_expression, additive_operator). This means that addition and subtraction occurs after multiplication and from left to right.

      13. additive_operator::="+" | "-",

        Shifts

      14. shift_expression::=S(additive_expression, shift_operator),

      15. shift_operator::=">>" | "<<", "<<" is left shift of bits (multiply by 2), and ">>" is the reverse and divides by 2.

        Relations

      16. relational_expression::= S(shift_expression, relational_operator),

      17. relational_operator::="<" | ">" | "<=" | ">=",

      18. equality_expression::=S(relational_expression, equality_operator),

      19. equality_operator::="==" | "!=",

        Bitwise Expressions

        These use the lowest level machine code operations that manipulate the bits in words. They are very fast and powerful. They are mostly used in system programming: drivers, operating systems, compilers, interpreters, shells, ... . They are also a very fast and tight coding for subsets of small sets: one bit per element has 1 for membership and 0 for nonmembership. For example if a class can meet on any collection of the 5 working days in a week (Monday=1, ..., Friday=5) then
         		FRWTM
         		10101 = MWF

        DecimalBinary (last 4 bits/ 1 byte)
        00000
        10001
        20010
        30011
        40100
        50101
        60110
        70111
        81000

      20. AND_expression::=S(equality_expression, and_operator),

      21. and_operator::="&", This operator takes each bit in the value of its arguments in turn to calculate the bit in the answer. A bit is 1 if and only if both arguments have bits in that place that are 1.
        DecimalBinary
        3 0011
        5 0101
        3&50001

      22. XOR_expression::=S(AND_expression, XOR_operator),

      23. XOR_operator::="^", XOR is short for eXclusive-OR. The n'th bit in the value is 1 precisly when the n'th bits in the two arguments are different.
        DecimalBinary
        3 0011
        5 0101
        3^50110

      24. OR_expression::=S(XOR_expression, OR_operator),

      25. OR_operator::="|", This operator takes each bit in the value of its arguments in turn to calculate the bit in the answer. The n'th bit is 1 if either n'th bits is 1.
        DecimalBinary
        3 0011
        5 0101
        3|50111

        Logical Expressions

        In C, logical false is reresented by any zero value and true by any nonzero value. Here is a list of operators
        1. and::="&&".
        2. or::="||",
        3. not::="!",

      26. logical_AND_expression::=S(OR_expression, logical_AND_operator),

      27. logical_AND_operator::=and, A&&B is true precisely when both A and B evaluate to be true. If A evaluates to false, B is not evaluated.

      28. logical_OR_expression::=S(logical_AND_expression, logical_OR_operator),

      29. logical_OR_operator::=or, A||B is true if A evaluates to be true, or when A is false and B evaluates to be true. If both evaluate to false (zero) then A||B is false.

        Conditional Expressions

      30. conditional_expression::=logical_OR_expression | logical_OR_expression "?" expression ":" conditional_expression,

        Assignment Statements

      31. assignment_expression::=S(unary_expression, assignment_operator),

      32. assignment_operator::="=" | "*=" | "/=" | "%=" | "+=" | "<<=" | ">>=" | "&=" | "^=" | "|=",

      33. expression::=List(assignment_expression ),

      34. constant_expression::=conditional_expression,

      . . . . . . . . . ( end of section Expressions) <<Contents | End>>

      Declarations

      1. declaration::=declaration_specifier | declarator_list,

      2. declarator_list::=List(declarator_initialized),

      3. declaration_specifier::=(storage_class | type_specifier | type_qualifier),

      4. storage_class::="typedef" | "extern" | "static" | "auto" | "register",

        Types

      5. type_specifier::="void" | "char" | "short" | "int" | "long" | "float" | "double" | "signed" | "unsigned" | struct_union_specifier | enumeration_specifier | typedef_name,

      6. type-qualifier::="const" | "volatile",

      7. typedef_name::=identifier,

        Initialization

      8. initializer::=assignment_expression | initializer_list,

      9. initializer_list::=List(initializer),

      10. declarator_initialized::=declarator ("=" initializer),

        Structs and Unions

      11. structure_declarator::=declarator | declarator ":" constant_expression,

      12. structure_declarator_list::=List(structure_declarator),

      13. structure_declaration::=(type_specifier | type_qualifier) structure_declarator_list ";" ,

      14. struct_union_specifier::=struct_union identifier | struct_union identifier "{"structure_declarator_list "}",

      15. struct_union::=( "struct" | "union" ),

        Enums

      16. enumeration_value::=enumeration_constant ("=" constant_expression|)

      17. enumeration_list::=List(enumeration_value ),

      18. enumeration_specifier::=enumeration_identifier | "enum" identifier "{"enumeration_list"}",

        Functions

      19. function_definition::=declaration_specifier declarator | declaration_list | compound_statement,
      20. parameter_declaration::=#declaration_specifier declarator | abstract_declarator,

      21. parameter_list::=List(parameter_declaration) (",..."|),

        Main Function

        A complete C program has to have a function with name 'main'. This is the function called by the operating system. It must return an int value indicating whether the prograam executed correctly or if there was an error. In UNIX, the main program returns 0 to indicate no errors. Their are several valid forms:
      22. int main()
      23. int main(argc, argv)
      24. int main(argc, argv, envp) The parameters are set up by the operating system when the program starts. The traditional arg stands for argument.

        Pointers

      25. pointer::=#( "*" | #type_qualifier),

      26. declarator::=pointer | direct_declarator,

        Functions and Arrays

      27. post_declarator::="["constant_expression"]" | "("parameter_list")" | "("identifier_list")"

      28. direct_declarator::=identifier | "("declarator")" | direct_declarator post_declarator,

      29. abstract_declarator::=pointer | pointer direct_abstract_declarator,

      30. direct_abstract_declarator::= "(" abstract_declarator ")" | O( direct_abstract_declarator) O("[" O(constant_expression) "]" | "(" O(parameter_list) ")" ),

      . . . . . . . . . ( end of section Declarations) <<Contents | End>>

      Statements

      1. statement::=labeled_statement | compound_statement | expression_statement | selection_statement | iteration_statement | jump_statement

        Branch

      2. jump_statement::="goto" identifier";" | "continue" ";" | "break;" | "return" expression ";",

        Structured

      3. loop::=iteration_statement.
      4. iteration_statement::="while" "("expression")" statement | "do" statement "while" "("expression")" ";" | for_statement.

      5. for_statement::="for" "("expression ";" expression ";" expression")" statement,

      6. selection_statement::=if_statement | "switch" "("expression")" statement,
      7. if_statement::="if ("expression")" statement | "if" "("expression")" statement "else" statement.

      8. expression_statement::= expression ";",

      9. labeled_statement::=identifier ":" statement | "case" constant_expression ":" statement | "default" ":" statement,

        Compound

      10. compound_statement::=block | "{" #statement "}",

      11. block::="{" declaration #declaration #statement "}",

      . . . . . . . . . ( end of section Statements) <<Contents | End>>

      Pre-Processor Commands

      1. preprocess_token::=identifier | constant | string_literal | operator | punctuator | each Non-white space not one of the previous,

      2. header_char::=any character except new_line | and | >,

      3. header_name::=#(header_char),

      4. new_line::=new_line character,

      5. Left_paren::=left parenthesis with no white space before it,

      6. control_line::="#include" (#(preprocess_token | header_name) new_line | "#define" identifier #(preprocess_token) new_line | "#define" identifier left_paren identifier_list #(preprocess_token) new_line, | "#undef" identifier new_line | "#line" preprocess_token new_line | "#error" preprocess_token new_line | "#pragma" preprocess_token new_line | "#"new_line,

      7. endif_line::="#endif" new_line,

      8. elif_group::="#elif" constant_expression new_line pp_group,

      9. else_group::="#else" new_line pp_group,

      10. if_group::=("#if" constant_expression | "#ifdef" identifier | "#ifndef" identifier) new_line pp_group,

      11. if_part::=if_group #(elif_group) else_group endif_line,

      12. pp_part::=#preprocess_token new_line | if_part | control_line,

      13. pp_group::=#(pp_part),

      . . . . . . . . . ( end of section Pre-Processor Commands) <<Contents | End>>

    . . . . . . . . . ( end of section Syntax of The C Programming Language) <<Contents | End>>

End