cv.c

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

align_base =  - 4;
align_len = 0;

search_ptr_align = align_ptr = Mod.align_data;
search_ptr_align->reclen = sizeof(SEARCHSYM);
search_ptr_align->reclen = ((search_ptr_align->reclen + 3)And ~3) - 2;
search_ptr_align->rectyp = S_SSEARCH;
align_len += search_ptr_align->reclen + 2;

align_base += align_len;

While symlen GreaterThan 0 BeginWhile memcpy(align_copy, symptr, (*(bit_16_ptr)
    symptr) + 2);
Using *(bit_16_ptr)(symptr + 2)BeginCase When S_UDT: 
{
    UDTSYM *p = align_copy;
    NEWTYPE(p->typind);
}

//-------------------------------------------------------------------------

memcpy(global_copy, align_copy, (*(bit_16*)align_copy) + 2);
copy_to_global = True;
break;
When S_BLOCK32: 
{
    BLOCKSYM32 *p = align_copy;
    p->pParent += align_base;
    p->pEnd += align_base;
    GlobalAddress(mod, &p->off, &p->seg);
    If copy_to_global IsTrue Then memcpy(global_copy, symptr, (*(bit_16_ptr)
        symptr) + 2);
    p = global_copy;
    GlobalAddress(mod, &p->off, &p->seg);
    p->pParent += global_len - align_len + global_base;
    p->pEnd += global_len - align_len + global_base;
    EndIf
}

//-------------------------------------------------------------------------

blocklevel++;
break;
When S_REGISTER: 
{
    REGSYM *p = align_copy;
    NEWTYPE(p->typind);
    memcpy(global_copy, align_copy, (*(bit_16*)align_copy) + 2);
}

//-------------------------------------------------------------------------

break;
When S_BPREL32: 
{
    BPRELSYM32 *p = align_copy;
    NEWTYPE(p->typind);
    memcpy(global_copy, align_copy, (*(bit_16*)align_copy) + 2);
}

//-------------------------------------------------------------------------

break;
When S_LDATA32: If blocklevel IsZero Then copy_to_global = False;
EndIf;
{
    DATASYM32 *p = align_copy;
    NEWTYPE(p->typind);
    GlobalAddress(mod, &p->off, &p->seg);
    If copy_to_global IsTrue Then memcpy(global_copy, align_copy, (*(bit_16_ptr)
        symptr) + 2);
    EndIf
}

//-------------------------------------------------------------------------

break;
When S_GDATA32: copy_to_global = True;
{
    DATASYM32 *p = align_copy;
    NEWTYPE(p->typind);
    GlobalAddress(mod, &p->off, &p->seg);
    memcpy(global_copy, align_copy, (*(bit_16_ptr)symptr) + 2);
}

//-------------------------------------------------------------------------

break;
When S_END: blocklevel--;
memcpy(global_copy, symptr, (*(bit_16_ptr)symptr) + 2);
break;
When S_ENDARG: memcpy(global_copy, symptr, (*(bit_16_ptr)symptr) + 2);
break;
When S_LPROC32: copy_to_global = False;
If nextptr_align IsNotNull Then*nextptr_align = align_len;
*nextptr_align = Null;
EndIf
{
    PROCSYM32 *p = align_copy;
    NEWTYPE(p->typind);
    GlobalAddress(mod, &p->off, &p->seg);
    p->pEnd += align_base;
    p->pNext = 0;
    nextptr_align = align_ptr + align_len + ((byte_ptr) &p->pNext - (byte_ptr)p)
        ;
    If search_ptr_align IsNotNull Then search_ptr_align->startsym = align_len;
    search_ptr_align->seg = p->seg;
    search_ptr_align = NULL;
    EndIf
}

//-------------------------------------------------------------------------

blocklevel++;
break;
When S_GPROC32: copy_to_global = True;
If nextptr_align IsNotNull Then*nextptr_align = align_len;
nextptr_align = Null;
EndIf If nextptr_global IsNotNull Then*nextptr_global = global_len;
nextptr_global = Null;
EndIf
{
    PROCSYM32 *p = align_copy;
    NEWTYPE(p->typind);
    GlobalAddress(mod, &p->off, &p->seg);
    p->pEnd += align_base;
    p->pNext = 0;
    nextptr_align = align_ptr + align_len + ((byte_ptr) &p->pNext - (byte_ptr)p)
        ;
    If search_ptr_align IsNotNull Then search_ptr_align->startsym = align_len;
    search_ptr_align->seg = p->seg;
    search_ptr_align = NULL;
    EndIf memcpy(global_copy, symptr, (*(bit_16_ptr)symptr) + 2);
    p = global_copy;
    NEWTYPE(p->typind);
    GlobalAddress(mod, &p->off, &p->seg);
    p->pEnd += global_len - align_len + global_base;
    p->pNext = 0;
    nextptr_global = global_ptr + global_len + ((byte_ptr) &p->pNext - 
        (byte_ptr)p);
    If search_ptr_global IsNotNull Then search_ptr_global->startsym =
        global_len;
    search_ptr_global->seg = p->seg;
    search_ptr_global = NULL;
    EndIf
}

//-------------------------------------------------------------------------

blocklevel++;
break;
When S_RETURN: memcpy(global_copy, align_copy, (*(bit_16_ptr)symptr) + 2);
break;
When S_COMPILE: copy_to_global = False;
break;
When S_OBJNAME: copy_to_global = False;
break;
Otherwise: printf("CV - unknown symbol record\n");
EndCase length = (*(bit_16*)symptr) + 2;
If copy_to_global IsTrue Then If global_len + length > global_max Then
    global_max += 65536;
oldptr_global = global_ptr;
global_ptr = (byte_ptr)reallocate_memory(global_ptr, global_max);
If nextptr_global IsNotNull Then nextptr_global = (bit_32_ptr)((bit_32)
    nextptr_global + (bit_32)global_ptr - (bit_32)oldptr_global);
EndIf If search_ptr_global IsNotNull Then search_ptr_global = (bit_32_ptr)(
    (bit_32)search_ptr_global + (bit_32)global_ptr - (bit_32)oldptr_global);
EndIf EndIf memcpy(global_ptr + global_len, global_copy, length);
global_len += length;
EndIf memcpy(align_ptr + align_len, align_copy, length);
align_len += length;
symptr += length;
symlen -= length;
EndWhile EndIf Mod.align_len = align_len;
EndFor*globallen = global_len;
*globals = global_ptr;
EndCode 
#undef Mod
#undef Pub
#undef Lseg
#undef Lab

void create_codeview_data(byte_ptr *data_ptr, bit_32_ptr data_len)
    BeginDeclarations bit_32 i, j;
byte_ptr globals;
bit_32 global_len;
byte_ptr linnum_ptr;
module_ptr mod;
#define Mod                                   (*mod)
byte_ptr types;
bit_32 type_len;
byte_ptr types_offsets;
bit_32 types_offsets_len;
byte_ptr tables_ptr;
bit_32 tables_size;
byte_ptr dir_ptr;
bit_32 dir_size;
byte_ptr data;
EndDeclarations BeginCode cv_globaltypes_data(&types, &type_len, &types_offsets,
    &types_offsets_len);
cv_globalsyms_data(&globals, &global_len);
tables_size = sizeof(OMFSignature) + 32;
if (global_len)
    tables_size += global_len + sizeof(OMFSymHash);
if (type_len)
    tables_size += type_len + sizeof(OMFGlobalTypes) - sizeof(bit_32) +
        types_offsets_len;

dir_size = sizeof(OMFDirHeader);
if (type_len)
    dir_size += sizeof(OMFDirEntry);
if (global_len)
    dir_size += sizeof(OMFDirEntry);

For i = 0;
i < n_modules;
i++BeginFor mod = modules[i];
If Mod.debsymseg IsNotNull Or Mod.publics.first IsNotNull Then dir_size +=
    sizeof(OMFDirEntry); /* module entry */
tables_size += sizeof(OMFModule) - sizeof(OMFSegDesc);
If Mod.cseg AndIf Mod.cseg->length Then tables_size += sizeof(OMFSegDesc);
EndIf If Mod.dseg AndIf Mod.dseg->length Then tables_size += sizeof(OMFSegDesc);
EndIf If Mod.bseg AndIf Mod.bseg->length Then tables_size += sizeof(OMFSegDesc);
EndIf tables_size += strlen(Mod.name);
tables_size = (tables_size + 3) &~3;
If Mod.align_len IsNotZero Then dir_size += sizeof(OMFDirEntry); /* align entry
    */
tables_size += Mod.align_len;
EndIf If Mod.linnum_len IsNotZero Then dir_size += sizeof(OMFDirEntry); /*
    linnum entry */
tables_size += Mod.linnum_len + sizeof(bit_32);
tables_size = (tables_size + 3) &~3;
EndIf EndIf EndFor 

data = (byte_ptr)allocate_memory(dir_size + tables_size);

tables_ptr = data + 32;
dir_ptr = data + tables_size;

{
    OMFSignature *p = tables_ptr;
    p->Signature[0] = 'L';
    p->Signature[1] = 'S';
    p->Signature[2] = '1';
    p->Signature[3] = '1';
    p->filepos = tables_size - 32;
    tables_ptr += sizeof(OMFSignature);
}

//-------------------------------------------------------------------------

{
    OMFDirHeader *p = dir_ptr;
    p->cbDirHeader = sizeof(OMFDirHeader);
    p->cbDirEntry = sizeof(OMFDirEntry);
    p->cDir = (dir_size - sizeof(OMFDirHeader)) / sizeof(OMFDirEntry);
    p->lfoNextDir = 0;
    p->flags = 0;
    dir_ptr += sizeof(OMFDirHeader);
}

//-------------------------------------------------------------------------

For i = 0;
i < n_modules;
i++BeginFor OMFModule *m = tables_ptr;
OMFSegDesc *p;

mod = modules[i];
If Mod.debsymseg IsNotNull Or Mod.publics.first IsNotNull Then m->ovlNumber = 0;
m->iLib = 0;
m->cSeg = 0;
m->Style[0] = 'C';
m->Style[1] = 'V';
p = &m->SegInfo;
If Mod.cseg IsNotZero AndIf Mod.cseg->length IsNotZero Then p->Seg = 1;
p->pad = 0;
p->Off = 0;
p->cbSeg = Mod.cseg->length;
GlobalAddress(mod, &p->Off, &p->Seg);
m->cSeg++;
p++;
EndIf If Mod.dseg IsNotZero AndIf Mod.dseg->length IsNotZero Then p->Seg = 2;
p->pad = 0;
p->Off = 0;
p->cbSeg = Mod.dseg->length;
GlobalAddress(mod, &p->Off, &p->Seg);
m->cSeg++;
p++;
EndIf If Mod.bseg IsNotZero AndIf Mod.bseg->length IsNotZero Then p->Seg = 3;
p->pad = 0;
p->Off = 0;
p->cbSeg = Mod.bseg->length;
GlobalAddress(mod, &p->Off, &p->Seg);
m->cSeg++;
p++;
EndIf*(byte_ptr)p = strlen(Mod.name);
memcpy(((byte_ptr)p) + 1, Mod.name, *(byte_ptr)p);
(byte_ptr)p += 1+*(byte_ptr)p;
If(((byte_ptr)p - tables_ptr)And 3)IsNotZero Then(byte_ptr)p += 4-(((byte_ptr)p
    - tables_ptr)And 3);
EndIf 

{
    OMFDirEntry *q = dir_ptr;
    q->SubSection = sstModule;
    q->iMod = i + 1;
    q->lfo = tables_ptr - data - 32;
    q->cb = (byte_ptr)p - (byte_ptr)tables_ptr;
    dir_ptr += sizeof(OMFDirEntry);
}

//-------------------------------------------------------------------------

tables_ptr = (byte_ptr)p;
EndIf EndFor For i = 0;
i < n_modules;
i++BeginFor mod = modules[i];
If Mod.debsymseg IsNotNull Or Mod.publics.first IsNotNull Then If Mod.align_len
    IsNotZero Then memcpy(tables_ptr, Mod.align_data, Mod.align_len);
{
    OMFDirEntry *p = dir_ptr;
    p->SubSection = sstAlignSym;
    p->iMod = i + 1;
    p->lfo = tables_ptr - data - 32;
    p->cb = Mod.align_len;
    dir_ptr += sizeof(OMFDirEntry);
}

//-------------------------------------------------------------------------

tables_ptr += Mod.align_len;
EndIf If Mod.linnum_len Then linnum_ptr = tables_ptr + sizeof(bit_16);

*((bit_16_ptr)linnum_ptr)++ = Mod.linnum_len / 6;
For j = 0;
j < Mod.linnum_len;
j += 6 BeginFor(*(bit_16_ptr)tables_ptr) = 1;
*(bit_32*)linnum_ptr = *(bit_32_ptr)(Mod.linnum_data + j + sizeof(bit_16));
GlobalAddress(mod, linnum_ptr, tables_ptr);
linnum_ptr += sizeof(bit_32);
EndFor For j = 0;
j < Mod.linnum_len;
j += 6 BeginFor*((bit_16_ptr)linnum_ptr)++ = *(bit_16_ptr)(Mod.linnum_data + j);
EndFor
{
    OMFDirEntry *p = dir_ptr;
    p->SubSection = sstSrcModule;
    p->iMod = i + 1;
    p->lfo = tables_ptr - data - 32;
    p->cb = (byte_ptr)linnum_ptr - (byte_ptr)tables_ptr;
    dir_ptr += sizeof(OMFDirEntry);
}

//-------------------------------------------------------------------------

tables_ptr = linnum_ptr;
If(tables_ptr - data)And 3 Then tables_ptr += 4-((tables_ptr - data)And 3);
EndIf EndIf EndIf EndFor
{
    OMFSymHash *p = tables_ptr;
    p->symhash = OMFHASH_NONE;
    p->addrhash = OMFHASH_NONE;
    p->cbSymbol = global_len;
    p->cbHSym = 0;
    p->cbHAddr = 0;
    memcpy(tables_ptr + sizeof(OMFSymHash), globals, global_len);
    {
        OMFDirEntry *p = dir_ptr;
        p->SubSection = sstGlobalSym;
        p->iMod = 0xffff;
        p->lfo = tables_ptr - data - 32;
        p->cb = global_len + sizeof(OMFSymHash);
        dir_ptr += sizeof(OMFDirEntry);
    }
    tables_ptr += global_len + sizeof(OMFSymHash);
}

//-------------------------------------------------------------------------

If type_len GreaterThan 0 Then OMFGlobalTypes *p = tables_ptr;
p->flags.sig = 0xa4; /* wasn't specified */
p->cTypes = types_offsets_len / sizeof(bit_32);
memcpy(p->typeOffset, types_offsets, types_offsets_len);
memcpy((byte_ptr)p->typeOffset + types_offsets_len, types, type_len);
{
    OMFDirEntry *p = dir_ptr;
    p->SubSection = sstGlobalTypes;
    p->iMod = 0xffff;
    p->lfo = tables_ptr - data - 32;
    p->cb = sizeof(OMFGlobalTypes) - sizeof(bit_32) + types_offsets_len +
        type_len;
    dir_ptr += sizeof(OMFDirEntry);
    tables_ptr += p->cb;
}

//-------------------------------------------------------------------------

EndIf If tables_ptr - data IsNotEqualTo tables_size Then printf(
    "CV - module data mismatch");
EndIf If dir_ptr - data IsNotEqualTo tables_size + dir_size Then printf(
    "CV - dir entry mismatch");
EndIf*data_ptr = data;
*data_len = tables_size + dir_size;
EndCode 
#undef Mod