C++ (Cpp) class_module_name Examples

Example #1

File: class.c Project: 0xDEC0DE8/mcsema

OBJECT * make_class_module( LIST * xname, LIST * bases, FRAME * frame )
{
    OBJECT     * name = class_module_name( list_front( xname ) );
    OBJECT   * * pp;
    module_t   * class_module = 0;
    module_t   * outer_module = frame->module;
    int found;
    LISTITER iter, end;

    if ( !classes )
        classes = hashinit( sizeof( OBJECT * ), "classes" );

    pp = (OBJECT * *)hash_insert( classes, list_front( xname ), &found );
    if ( !found )
    {
        *pp = object_copy( list_front( xname ) );
    }
    else
    {
        printf( "Class %s already defined\n", object_str( list_front( xname ) ) );
        abort();
    }
    check_defined( bases );

    class_module = bindmodule( name );

    var_set( class_module, constant_name, xname, VAR_SET );
    var_set( class_module, constant_bases, bases, VAR_SET );

    iter = list_begin( bases ), end = list_end( bases );
    for ( ; iter != end; iter = list_next( iter ) )
        import_base_rules( class_module, list_item( iter ) );

    return name;
}

Example #2

File: class.c Project: TuZZiX/ROS_IDE_inc

OBJECT * make_class_module( LIST * xname, LIST * bases, FRAME * frame )
{
    OBJECT     * name = class_module_name( list_front( xname ) );
    OBJECT   * * pp;
    module_t   * class_module = 0;
    module_t   * outer_module = frame->module;
    int found;

    if ( !classes )
        classes = hashinit( sizeof( OBJECT * ), "classes" );

    pp = (OBJECT * *)hash_insert( classes, list_front( xname ), &found );
    if ( !found )
    {
        *pp = object_copy( list_front( xname ) );
    }
    else
    {
        out_printf( "Class %s already defined\n", object_str( list_front( xname ) )
            );
        abort();
    }
    check_defined( bases );

    class_module = bindmodule( name );

    {
        /*
            Initialize variables that Boost.Build inserts in every object.
            We want to avoid creating the object's hash if it isn't needed.
         */
        int num = class_module->num_fixed_variables;
        module_add_fixed_var( class_module, constant_name, &num );
        module_add_fixed_var( class_module, constant_class, &num );
        module_set_fixed_variables( class_module, num );
    }

    var_set( class_module, constant_name, xname, VAR_SET );
    var_set( class_module, constant_bases, bases, VAR_SET );

    {
        LISTITER iter = list_begin( bases );
        LISTITER const end = list_end( bases );
        for ( ; iter != end; iter = list_next( iter ) )
            import_base_rules( class_module, list_item( iter ) );
    }

    return name;
}

Example #3

File: class.c Project: romanzenka/myrimatch

static void import_base_rules( module_t * class_, OBJECT * base )
{
    OBJECT * module_name = class_module_name( base );
    module_t * base_module = bindmodule( module_name );
    LIST * imported;
    struct import_base_data d;
    d.base_name = base;
    d.base_module = base_module;
    d.class_module = class_;
    object_free( module_name );

    if ( base_module->rules )
        hashenumerate( base_module->rules, import_base_rule, &d );

    imported = imported_modules( base_module );
    import_module( imported, class_ );
    list_free( imported );
}

Example #4

File: class.c Project: romanzenka/myrimatch

OBJECT * make_class_module( LIST * xname, LIST * bases, FRAME * frame )
{
    OBJECT     * name = class_module_name( xname->value );
    OBJECT   * * pp = &xname->value;
    module_t   * class_module = 0;
    module_t   * outer_module = frame->module;
    OBJECT     * name_ = object_new( "__name__" );
    OBJECT     * bases_ = object_new( "__bases__" );

    if ( !classes )
        classes = hashinit( sizeof( OBJECT * ), "classes" );

    if ( hashenter( classes, (HASHDATA * *)&pp ) )
    {
        *pp = object_copy( xname->value );
    }
    else
    {
        printf( "Class %s already defined\n", object_str( xname->value ) );
        abort();
    }
    check_defined( bases );

    class_module = bindmodule( name );

    exit_module( outer_module );
    enter_module( class_module );

    var_set( name_, xname, VAR_SET );
    var_set( bases_, bases, VAR_SET );

    exit_module( class_module );
    enter_module( outer_module );

    for ( ; bases; bases = bases->next )
        import_base_rules( class_module, bases->value );

    object_free( bases_ );
    object_free( name_ );

    return name;
}

Example #5

File: class.c Project: 4ukuta/core

        ( r->module->class_module == d->base_module ) ) )
        ir1->module = ir2->module = d->class_module;

    string_free( qualified_name );
}


/*
 * For each exported rule 'n', declared in class module for base, imports that
 * rule in 'class' as 'n' and as 'base.n'. Imported rules are localized and
 * marked as exported.
 */

static void import_base_rules( module_t * class, char * base )
{
    module_t * base_module = bindmodule( class_module_name( base ) );
    struct import_base_data d;
    d.base_name = base;
    d.base_module = base_module;
    d.class_module = class;

    if ( base_module->rules )
        hashenumerate( base_module->rules, import_base_rule, &d );

    import_module( imported_modules( base_module ), class );
}


char * make_class_module( LIST * xname, LIST * bases, FRAME * frame )
{
    char       * name = class_module_name( xname->string );