BNF for CoCo3.jj

NON-TERMINALS

/*

	Components are stateful entities that are responsible
	for computations.

*/
// (file suffix *.cm)

/*
 connectors are responsible for data transfer
 between components.
*/

/*	Defines data types of dataTypedata that is
	transmitted between components

	dataType specification --> spec of the structure of
  dataTypes that are transferred between components
 */

/*
 *
 * Data types in coco are more or less the equivalent of C++ structs (in contrast to C++ structs)
 * data types can not declare methods and only support single inheritance
 * Data types can be inherited from another data type. The only restriction is, that this base
 * data type must also be a user defined data type. Thus it is not possible to inherit directly
 * from coco base types (like int or float)
 *
 */

/*
	Describes all component instances that are to be composed within a composite component

 */

/*
	Describes roles for component instances that are to be composed within a composite component
	Roles can only appear in an abstract component. When a component inherits from an abstract component,
	all roles must be assigned a certain instance. The type of this instance must be a subtype of
	the type declared for this role.
 */

/*
  *	ports are in, out or inout ports, they have a data type
  * and the are either optional (may be unbound in the final system)
  * or mandatory (must be bound, this is default)
  */

/*
 * A port can currently only be a data port. However, this might be loosened in the future
 * The grammar also allows for invocation or handler ports. In contrast to data ports,
 * handler/invocation ports have a formal parameter list.
 */

/*
 * formal parameters of a handler (or, if existing in the model) invocation port
 */

/*
 * Coco provides a set of primitive base types. This set basically resembles more or less
 * the base types known from Java or C++.
 * Maybe one has to change the grammar here since there is actually a difference between
 * the actual base (primitive) type and its usage as an array type. The same applies for user
 * types. Atleast the name should be changed (to something like TypeReference) to reflect
 * the real meaning of this construct. (TG)
 */

/*
 	properties of a component have a type (int, float, string, or enum)
 	and may have an initial value. Mandatory properties (the default)
 	must be bound at least in the final system. Optional properties may
 	not be bound. The distinction between abstract and 'normal' properties
 	is artificial (it makes it easier to deal with those two kinds of properties
 	differently afterwards. Abstract properties can only appear within an abstract
 	component or within a property set definition while normal properties can
 	appear within components, ports, connectors
 */

/** Stabilizies the parser by skipping to the specified token.
   * The token itself is removed from the stream.
   * THIS IS NOT A GRAMMAR PRODUCTION
   * Side-effects: increases the numErros variable by one.
   *  @param kind the token to look for
   *  @param e the originally catched exception describing the actual parse problem
   */

/** Stabilizies the parser by skipping to one of the specified tokens.
   * When an appropriate token is found it is pushed back onto the stream.
   * before the method returns. If no token is found the method simply
   * re-throws the original exception.
   * THIS IS NOT A GRAMMAR PRODUCTION
   * Side-effects: increases the numErros variable by one.
   *  @param kind[] the array of tokens to look for
   *  @param e the originally catched exception describing the actual parse problem
   */