idl_parser ::=
        #ignore(C++)
        #continue
        [
                '#' #!ignore ->'\n'
            |
                // à ce niveau, toutes les déclarations sont
                // placées dans la racine
                declaration(this)
        ]*
        #empty
        ;

// la déclaration sera contenue sous le noeud 'parent' passé
// en paramètre
declaration(parent : node::=
        #readIdentifier:sDecl
        declaration<sDecl>(parent)
        ;

declaration<"struct">(parent : node::=
        #continue
        identifier:sName
        => insert parent.structures[sName].name = sName;
        '{'
        [attribute_declaration(parent.structures[sName])]*
        '}'
        ';'
        ;

declaration<"typedef">(parent : node::=
            "sequence"
            '<'
            => local theType;
            type_name(theType)
            '>'
            identifier:sAlias
            ';'
            // arrivé au point-virgule, on est sûr d'avoir atteint la
            // fin de la séquence ;
            // recopie du sous-graphe du type
            => setall parent.sequences[sAlias] = theType;
        |
            ->';'
        ;
declaration<"interface">(parent : node::=
        #continue
        identifier:sName
        => insert parent.interfaces[sName].name = sName;
        // gardons une référence sur l'interface, cela facilitera
        // l'écriture du reste de la règle de production
        => localref interface = parent.interfaces[sName];
        [
            ':' #continue
            identifier:interface.inheritance
        ]?

        '{'
        [member_declaration(interface)]*
        '}'
        ';'
        ;

member_declaration(parent : node::= attribute_declaration(parent) | method_declaration(parent);

attribute_declaration(parent : node::=
        // la variable 'bReadonly' doit être déclarée à l'extérieur des
        // crochets, si l'on désire que sa portée les dépasse, et qu'elle
        // soit visible à la fin de la règle (la dernière ligne)
        => local bReadonly;
        [#readIdentifier:"readonly":bReadonly]?
        => local theType;
        type_name(theType)
        identifier:sName
        ';'
        => insert parent.attributes[sName].name = sName;
        // recopie du sous-graphe du type
        => setall parent.attributes[sName].type = theType;
        => if bReadonly insert parent.attributes[sName].readonly = bReadonly;
        ;

method_declaration(parent : node::=
        => local returnType; // là encore, cette variable doit se déclarer à l'extérieur des crochets
        [type_name(returnType) | #readIdentifier:"void"]
        identifier:sName
        '('
        #continue
        => insert parent.methods[sName].name = sName;
        => localref method = parent.methods[sName];
        // recopie du sous-graphe du type
        => setall method.type = returnType;
        [
            parameter(method)
            [',' #continue parameter(method)]*
        ]?
        ')'
        ';'
        ;

parameter(parent : node::=
        // autre façon de construire le graphe de parsing :
        // on alimente tout d'abord un graphe local puis,
        // si la règle de production s'avère valide, on
        // le recopie dans le graphe de parsing
        => local param;
        #readIdentifier:{"in""inout""out"}:param.mode
        type_name(param.type)
        identifier:param.name
        // on recopie tout le graphe local
        => setall parent.parameters[param.name] = param;
        ;

type_name(theType : node::=
        #readIdentifier:sType
        [
                // est-ce un type de base parmi ceux que l'on veut bien reconnaître ?
                #check(sType in {"boolean""double""long""string"})
                => insert theType = sType;
            |
                // est-ce une interface ?
                #check(this.interfaces.findElement(sType))
                => insert theType = sType;
                => insert theType.is_interface = true;
            |
                // est-ce une structure ?
                #check(this.structures.findElement(sType))
                => insert theType = sType;
                => insert theType.is_structure = true;
            |
                // est-ce une séquence ?
                #check(this.sequences.findElement(sType))
                => {
                    // type faisant l'objet de la séquence, que l'on recopie
                    // dans la description de l'élément
                    setall theType.element = this.sequences[sType];
                    // ce type est une séquence
                    insert theType.is_sequence = true;
                }
        ]

        ;

identifier:value ::=
        #readIdentifier:identifier
        #check(!(identifier in {"abstract""any""attribute""boolean""case""char""component""const""consults",
                         "context""custom""default""double""emits""enum""eventtype""exception""factory",
                         "FALSE""finder""fixed""float""getraises""home""import""in""inout""interface",
                         "local""long""manages""module""multiple""native""Object""octet""oneway""out",
                         "primarykey""private""provides""public""publishes""raises""readonly""sequence",
                         "setraises""short""string""struct""supports""switch""TRUE""truncatable""typedef",
                         "typeid""typeprefix""union""unsigned""uses""ValueBase""valuetype""wchar""wstring"}))
        ;

Generated by CodeWorker v3.8.2 from CWscript2HTML.cwp.