C++ (Cpp) DbgMustAlloc Examples

Example #1

File: dbgscan.c Project: Ukusbobra/open-watcom-v2

static void SetRadixSpec( char *str, unsigned len, unsigned radix, bool clear )
{

    rad_str   *pref;
    rad_str  **owner;

    owner = &RadStrs;
    pref = RadStrs;
    while( pref != NULL ) {
        if( pref->radstr[0] == len
         && memicmp( &pref->radstr[1], str, pref->radstr[0] ) == 0 ) break;
        if( pref->radstr[0] < len ) break;
        owner = &pref->next;
        pref = pref->next;
    }
    if( pref == NULL || pref->radstr[0] != len ) {
        if( clear ) return;
        pref = DbgMustAlloc( sizeof( rad_str ) + len );
        memcpy( &pref->radstr[1], str, len );
        pref->radstr[0] = len;
        pref->next = *owner;
        *owner = pref;
    } else if( clear ) {
        *owner = pref->next;
        _Free( pref );
        return;
    }
    pref->radval = radix;
}

Example #2

File: dbgutil.c Project: Azarien/open-watcom-v2

cmd_list *AllocCmdList( const char *start, size_t len )
{
    cmd_list *cmds;

    cmds = DbgMustAlloc( sizeof( cmd_list ) + len );
    cmds->use = 1;
    cmds->buff[len] = NULLCHAR;
    memcpy( cmds->buff, start, len );
    return( cmds );
}

Example #3

void InsertRing( char_ring **owner, char *start, unsigned len )
{
    char_ring *path;

    if( len != 0 ) {
        path = DbgMustAlloc( sizeof( char_ring ) + len );
        memcpy( path->name, start, len );
        path->name[ len ] = NULLCHAR;
        path->next = NULL;
        *owner = path;
        owner = &path->next;
    }
}

Example #4

File: dbgset.c Project: NoSuchProcess/open-watcom-v2

void NewLang( const char *lang )
{
    char       *new_lang;
    unsigned    len;

    if( lang == NULL )
        return;
    len = strlen( lang );
    new_lang = DbgMustAlloc( len + 1 );
    memcpy( new_lang, lang, len );
    new_lang[len] = NULLCHAR;
    strlwr( new_lang );
    if( ( len != strlen( Language ) ) || memcmp( new_lang, Language, len ) != 0 ) {
        if( LangLoad( new_lang, len ) ) {
            _Free( Language );
            Language = new_lang;
            return;
        }
        LangLoad( Language, strlen( Language ) );
        Error( ERR_NONE, LIT_ENG( ERR_NO_LANG ) );
    }
    _Free( new_lang );
}

Example #5

static void DoCallSet( void )
{
    mad_string          ctype;
    int                 parm;
    int                 i;
    const char          *start;
    struct {
        union {
            const char  *arg;
            char        *start;
        } u;
        unsigned        len;
    }                   new_parms[MAX_PARMS];
    location_list       ll;
    dig_type_info       ti;

    if( CurrToken == T_DIV ) {
        Scan();
        ctype = ScanCall();
        if( ctype == MAD_MSTR_NIL ) {
            Error( ERR_LOC, LIT_ENG( ERR_BAD_CALL_TYPE ) );
        }
    } else {
        ctype = DefCallType;
    }
    if( CurrToken == T_LEFT_PAREN ) {
        parm = 0;
        Scan();
        if( CurrToken != T_RIGHT_PAREN ) {
            for( ;; ) {
                if( parm >= MAX_PARMS )
                    Error( ERR_LOC, LIT_ENG( ERR_TOO_MANY_PARMS ) );
                new_parms[parm].u.arg = ScanPos();
                GetLocation( &ll, &ti );
                new_parms[parm].len = ScanPos() - new_parms[parm].u.arg;
                ++parm;
                if( CurrToken != T_COMMA )
                    break;
                Scan();
            }
        }
        Recog( T_RIGHT_PAREN );
    } else {
        parm = -1;
    }
    start = ScanPos();
    if( CurrToken == T_DIV ) {
        Scan();
    } else if( ScanEOC() ) {
        start = NULL;
    } else {
        /* syntax check */
        ChkPrintList();
    }
    ReqEOC();
    if( start != NULL ) {
        char *new_return;

        i = ScanPos() - start;
        new_return = DbgMustAlloc( i + 1 );
        memcpy( new_return, start, i );
        new_return[i] = NULLCHAR;
        _Free( DefReturn );
        DefReturn = new_return;
    }
    if( parm >= 0 ) {
        for( i = 0; i < parm; ++i ) {
            char    *new_arg;

            _Alloc( new_arg, new_parms[i].len + 1 );
            if( new_arg == NULL ) {
                parm = i;
                for( i = 0; i < parm; ++i ) {
                    _Free( new_parms[i].u.start );
                }
                parm = 0;
                Error( ERR_NONE, LIT_ENG( ERR_NO_MEMORY_FOR_EXPR ) );
                break;
            } else {
                memcpy( new_arg, new_parms[i].u.arg, new_parms[i].len );
                new_arg[new_parms[i].len] = NULLCHAR;
                new_parms[i].u.start = new_arg;
            }
        }
        FreeParms();
        for( i = 0; i < parm; ++i ) {
            DefParms[i] = new_parms[i].u.start;
        }
    }
    DefCallType = ctype;
}