Overview

The Cecilia IDL Language is a way to define interfaces in Cecilia, because the C programming language does not support natively the interface construct.

This IDL is strongly typed. In fact interface descriptions are used by the compilation tool-chain to make type based analysis to verify the compatibility of interconnected component interfaces, and to generate communication adaptors for component pairs that can not be naturally bound (JNI, RPC, etc.).

Basic Example

Cecilia IDL supports four types of constructs:

• Interface defines the signature of a component interface. An interface contains a set of methods. Each method must have a distinct name. Optionally, an interface can extends another interface (multiple inheritance is not allowed). Finally, an interface may define constants;
• Record defines a structured type. It contains a set of fields. Each field has a type and a name. Records are used to define component attributes and can also be used as method parameter or return types.
• Enum (since Cecilia 1.2) defines an enumerated type. It contains a set of members. Each field has a name and optionally a value. Enums can be used as interfaces method parameter types and also as method return types.
• Union (since Cecilia 2.0) defines a union type. It contains a set of fields. Each field has a type and a name. Unions can be used as method parameter or return types.

Each construct definition must be done in a separate file. The extension used for these files is .idl. The file name must correspond to the construct name which is defined in the file, and each IDL definition belongs to a package. The package name must correspond to the path in the file system.

An IDL definition can reference a type which is defined in another IDL definition. To this end, two kinds of identifiers may be used, a simple identifier or a qualified identifier. A qualified identifier corresponds to <package>.<interface> giving the absolute description of the IDL definition. An identifier corresponds only to <interface>, and may be considered as a relative path. An single identifier can be used to reference an IDL type which is defined in the same package. Otherwise, one may import the qualified identifier to use then an identifier in the IDL definition. Note that the imported identifiers overload the identifiers found in the same package.

The following IDL definition specifies an interface, called Printer, in the package video.api, which provides two distinct methods, one providing a print operation for a character, and the other for a string.

// file = video/api/Printer.idl
package video.api;

public interface Printer {
    void printChar(char c);
    void printString(string s);
}

The following IDL definition defines a record called ServiceAttributes in the package attributes which has two integer fields respectively called cols and rows.

// file = service/ServiceAttributes.idl
package attributes;

record ServiceAttributes {
    int cols;
    int rows;
}

The following IDL definition defines a DayOfTheWeek enumerated type in the package days, which has 7 members, named after the days of the week.

// file = days/DayOfTheWeek.idl
package days;

enum DayOfTheWeek {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

The following IDL definition defines a Handle union type in the package system, which has an integer field and a pointer field.

// file = system/Handle.idl
package system;

enum Handle {
    uint32_t handle;
    any ptr;
}

Cecilia IDL Grammar Specification

QualifiedIdentifier ::=  (Identifier ( "." Identifier)* )

Declaration ::= Package (Import)* (InterfaceDeclaration | RecordDeclaration | EnumDeclaration | UnionDeclaration)
Package     ::= "package" QualifiedIdentifier;
Import      ::= "import " QualifiedIdentifier;  

Type           ::= PrimitiveType | ComplexType
ComplexType   ::= QualifiedIdentifier | "any"
PrimitiveType  ::= (
 "boolean"                     |
 "char"                        |
 "byte"                        |
 "short"                       |
 "int"                         |
 "long"                        |
 "unsigned byte"               |
 "unsigned short"              |
 "unsigned int"                |
 "unsigned long"               |
 "float"                       |
 "double"                      |
 "(u?)int(8|16|32|64)_t"       |
 "(u?)int_least(8|16|32|64)_t" |
 "(u?)int_fast(8|16|32|64)_t"  |
 "(u?)intptr_t"                |
 "(u?)intmax_t"                |
 "size_t"                      |
 "ptrdiff_t"                   |
 "wchar_t"                     |
 "string"  ) 

InterfaceDeclaration  ::=  "public"? "interface" Identifier "{"
    ( 
    MethodDeclaration  |
    FieldDeclaration   |
    ";" 
    )*   
"}" 

MethodDeclaration  ::=  ResultType Identifier FormalParameters ";"
ResultType         ::=  Type | "void"
FormalParameters   ::=  
    "("
      FormalParameter 
      ( "," FormalParameter )*
      ( "," "..." )? 
    ")" 
FormalParameter    ::=  ("in" | "out" | "in out")? Type Identifier              

FieldDeclaration  ::=  PrimitiveType Identifier "=" Expression ("," Identifier "=" Expression)* ";"                     

RecordDeclaration      ::=  "record" Identifier "{
    (BasicFieldDeclaration)* 
"}"
BasicFieldDeclaration  ::=  Type Identifier ("," Identifier)* ";"

EnumDeclaration      ::=  "enum" Identifier "{
    (EnumMemberDeclaration)
    ( "," EnumMemberDeclaration )*
"}"
EnumMemberDeclaration  ::=  Identifier (":" Expression)?

UnionDeclaration      ::=  "union" Identifier "{
    (BasicFieldDeclaration)* 
"}"
BasicFieldDeclaration  ::=  Type Identifier ("," Identifier)* ";"