The syntax of ooxref input file is as follows:
Keyword: value
or
Keyword: text-description (value)
or 
Keyword: text-description {type (value)}
where the text-description is optional 
The value in parenthesis is required
The braces "{" and "}" are required
The parenthesis "(" and ")" are required
The square brackets are not required, but indicate that the contained text 
is optional


Class: class-name
End-class: [class-name]
Parent: parent-name 
Friend: friend-name 
Constructor: constructor-name 
End-constructor: [constructor-name]
Method: method-name
end-method: [method-name]

Struct: struct-name
End-struct: [struct-name]

Typedef: type name

Ctype: file-name
End-ctype: [file-name]
Function: function-name
End-function: [function-name]

Input: [data description] {type (data-name)}
Output: [data description] {type (data-name)}
Private: [data description] {type (data-name)}
Protected: [data description] {type (data-name)}
Public: [data description] {type (data-name)}
Contains: class-name
Access: [data description] {type (data-name)}
Associate: [data description] {type (data-name)}
Description:
End-description:
Notes:
End-notes:
Comment:
End-comment:
Requirement: requirement satisfied

It should be obvious that each keyword is terminated by a colon (:)

Layout of file

Class: class-name
      This is a major category. It identifies a class type, and within
      it several sub-categoris are identified. Although the order for
      each sub-category key is not critical, it is recomended that the
      keys be grouped together.

  Parent: parent-name
    Parent does not have an end-parent delimiter. Only one parent
           may be identified on each Parent line. If a class has
           multiple parents, then each parent must have be
           identified by a Parent key.

    Public: [description] {type (data-name)}
      Public does not have an end delimiter. Only one 
           datum may be identified for each.

    Protected: [description] {type (data-name)}
      Protected does not have an end delimiter. Only one 
           datum may be identified for each.

    Private: [description] {type (data-name)}
      Private does not have an end delimiter. Only one 
           datum may be identified for each.

    Friend: class-name
      Friend does not have an end delimiter. Only one 
           datum may be identified for each.

    Contains: class-name
      Contains does not have an end delimiter. Only one 
           datum may be identified for each.

    Requirment: requirement satisfied
      Requirement does not have an end delimiter. Only one requirment
           is identified per key and should reference a requirement
           document and paragraph number.

    Description:
      A description of the purpose of the class goes within the description
      delimiters.
    End-description:

    Constructor: constructor-name
      Constructor requires an End-constructor delimiter. More than one
           Constructor is allowed for each class. The first should be
           the name of the class. If more than one constructor is
           identified for a class, the constructors after the first 
           should be identified by appending a dash n (-n) where n 
           goes from 2 through the number of constructors associated
           with the class. Constructor has the same fields as Method.

    End-constructor:
      End-constructor delimiter is required for each constructor

    Method: method-name
      Method requires an End-method delimiter. More than one method
           may be identified for each class. In fact, if a class only
           has one method identified, it should be examined closely.

       Input: [data description] {type (data-name)}
           Input does not have an end delimiter. Only one input parameter
              is identified on each input line

       Output: [data description] {type (data-name)}
           Output does not have an end delimiter. Only one output parameter
              is identified on each output line

       Requirment: requirement satisfied
         Requirement does not have an end delimiter. Only one requirment
              is identified per key and should reference a requirement
              document and paragraph number.

    End-method:
      End-method delimiter is required for each method

End-class:
      End-class delimiter is required for each class. 


Struct: struct-name
      This is a major category for non-object oriented applications 
      that may be in object-oriented applications as well. It is
      equivalent to a Class that has no methods, and the data contained
      is public.

    Contains: class-name
      Contains does not have an end delimiter. Only one 
           datum may be identified for each.

End-struct:


Ctype: ctype-name
      This is a major category for non-object oriented applications.
      Ctype is usually the name of the file that will contain one or 
      more functions. Within a Ctype block, Function, Public, and
      Private data may be identified.

    Public: [description] {type (data-name)}
      Public does not have an end delimiter. Only one 
           datum may be identified for each. Public data
           in non-object oriented data refers to data that
           is global, and is referenced in the 'C' language
           by using the extern key word.

    Private: [description] {type (data-name)}
      Private does not have an end delimiter. Only one 
           datum may be identified for each. Private data
           in non-object oriented data refers to data that
           is available to only those functions that are in
           the same file as the data declaration and follow
           the declaration.

    Function: function-name
      Function requires an End-function delimiter. More than one function
           may be identified for each class. In fact, if a class only
           has one function identified, it should be examined closely.

    End-function:
      End-function delimiter is required for each function

End-ctype:

Description, Note, and Comment may be contained within any major category
block. These categories will be used when the data if formatted for 
documents. Note identifies design notes to me (like hidden text except
it is visible in the raw text file). Note(s) will only appear in a
public document if the print-notes switch is turned on. Usually a Note
identifies a change I made to the design because I found a flaw in the
design and do not want to repeat the flaw at later time (those why didn't
I do this types). Comments are explanations for questions that might
come up during a design review. I want the comments in the raw file,
and I will put a switch in the document generator so that my copy
will use the print-comment switch when I print it.

so the format for these sub-categories is:

Description:
  Text description goes here

End-description:
  This delimits the description

Note:
  Text notes go here

End-note:

Comment:
  comment goes here

End-comment

Input and Output may be within Function, Method or Constructor sub-categories.
These categories identify the parameters passed to or by the target. 

Input: [data description] {type (data-name)}
  This sub-category identifies an input parameter. Only one parameter may
  be on a line, and a parameter with its description may not exceed one 
  line in the raw document.

Output: [data description] {type (data-name)}
  This sub-category identifies an output parameter. Only one parameter may
  be on a line, and a parameter with its description may not exceed one 
  line in the raw document. Usually there will only be one output parameter.

Contains may be within Class, Function, Method, or Constructor. 

Contains: class-name
  This sub-category is usually used to identify Class instantiations 
  within a method, but it may be a struct as well. Only one instantiation
  may be on a line, the description may not exceed one line.