C++ (Cpp) copyCodeLen Beispiele

Beispiel #1

void AsmSysPCHReadCode( AUX_INFO *info )
/**************************************/
{
    byte *p;
    byte *s;
    byte_seq *code;
    unsigned fixup;
    SYMBOL sym;
    byte_seq_len seq_size;
    byte_seq_len code_length;

    seq_size = PCHReadUInt();
    if( seq_size == 0 ) {
        info->code = NULL;
        return;
    }
    code = CMemAlloc( seq_size );
    info->code = code;
    PCHRead( code, seq_size );
    if(( code->length & DO_FLOATING_FIXUPS ) == 0 ) {
        /* code has no relocs */
        return;
    }
    code_length = code->length & MAX_BYTE_SEQ_LEN;
    p = code->data;
    s = code->data + code_length;
    while( p != s ) {
        if( p[0] == FLOATING_FIXUP_BYTE ) {
            fixup = p[1];
            p += 2;
            if( fixup != FLOATING_FIXUP_BYTE ) {
                switch( fixup ) {
                case FIX_SYM_OFFSET:
                case FIX_SYM_SEGMENT:
                case FIX_SYM_RELOFF:
                    sym = SymbolMapIndex( *((SYMBOL*)p) );
                    copyCodeLen( p, &sym, sizeof( sym ) );
                    p += sizeof( SYMBOL ) + sizeof( unsigned long );
                    break;
                default:
                    break;
                }
            }
        } else {
            ++p;
        }
    }
}

Beispiel #2

Datei: cpragx86.c Projekt: jossk/open-watcom-v2

void AsmSysPCHWriteCode( AUX_INFO *info )
/***************************************/
{
    BYTE_SEQ_SYM sym;
    byte_seq_len code_length;
    byte_seq_len seq_size;
    unsigned fixup;
    byte_seq *code;
    byte *d;
    byte *s;
    byte *c;
    byte *p;
    byte *tmp_buff;
#ifndef NDEBUG
    byte buff[8];
#else
    byte buff[1024];
#endif

    seq_size = 0;
    code = info->code;
    if( code == NULL ) {
        /* no code */
        PCHWriteUInt( seq_size );
        return;
    }
    code_length = code->length;
    seq_size = offsetof( byte_seq, data ) + code_length;
    PCHWriteUInt( seq_size );
    if( !code->relocs ) {
        /* code has no relocs */
        PCHWrite( code, seq_size );
        return;
    }
    /* code has relocs */
    tmp_buff = buff;
    if( seq_size > sizeof( buff ) ) {
        tmp_buff = CMemAlloc( seq_size );
    }
    c = code->data;
    s = code->data + code_length;
    d = copyCodeLen( tmp_buff, code, offsetof( byte_seq, data ) );
    for( p = c; p != s; ) {
        if( p[0] == FLOATING_FIXUP_BYTE ) {
            fixup = p[1];
            *d++ = *p++;
            *d++ = *p++;
            if( fixup != FLOATING_FIXUP_BYTE ) {
                switch( fixup ) {
                case FIX_SYM_OFFSET:
                case FIX_SYM_SEGMENT:
                case FIX_SYM_RELOFF:
                    sym = SymbolGetIndex( *((BYTE_SEQ_SYM *)p) );
                    d = copyCodeLen( d, &sym, sizeof( sym ) );
                    p += sizeof( BYTE_SEQ_SYM );
                    d = copyCodeLen( d, p, sizeof( BYTE_SEQ_OFF ) );
                    p += sizeof( BYTE_SEQ_OFF );
                    break;
                default:
                    break;
                }
            }
        } else {
            *d++ = *p++;
        }
    }
    PCHWrite( tmp_buff, seq_size );
    if( tmp_buff != buff ) {
        CMemFree( tmp_buff );
    }
}