swap.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

	for(i = 0 ; i < count ; i++){
	    sextr = ((psEXTR)pext)[i];
	    sextr.asym.iss   = swap_word(sextr.asym.iss);
	    sextr.asym.value = swap_word(sextr.asym.value);

	    if (destsex == hostsex) {
		pext[i] = *(pEXTR)&sextr;
		sextr.asym.u.word  = swap_word(sextr.asym.u.word);

		pext[i].asym.st       = sextr.asym.u.fields.st;
		pext[i].asym.sc       = sextr.asym.u.fields.sc;
		pext[i].asym.reserved   = sextr.asym.u.fields.reserved;
		pext[i].asym.index    = sextr.asym.u.fields.index;

		sextr.u.word  = swap_word(sextr.u.word);
		pext[i].ifd   = sextr.u.fields.ifd;
		pext[i].reserved   = sextr.u.fields.reserved;
		pext[i].jmptbl   = sextr.u.fields.jmptbl;
		pext[i].cobol_main = sextr.u.fields.cobol_main;
	    } else {

		sextr.asym.u.fields.st = pext[i].asym.st;
		sextr.asym.u.fields.sc = pext[i].asym.sc;
		sextr.asym.u.fields.reserved = pext[i].asym.reserved;
		sextr.asym.u.fields.index = pext[i].asym.index;

		sextr.asym.u.word  = swap_word(sextr.asym.u.word);

		sextr.u.fields.ifd = pext[i].ifd;
		sextr.u.fields.reserved = pext[i].reserved;
		sextr.u.fields.cobol_main = pext[i].cobol_main;
		sextr.u.fields.jmptbl = pext[i].jmptbl;

		sextr.u.word  = swap_word(sextr.u.word);
		pext[i] = *(pEXTR)&sextr;
	    } /* if */
	}
}

/*
 * Convert count procedure table entries pointed to by ppd to the other byte
 * sex.
 */
void
swap_pd(ppd, count, destsex)
register pPDR ppd;
register long count;
long destsex;
{
    register long i;

	for(i = 0 ; i < count ; i++){
	    ppd[i].adr         = swap_word(ppd[i].adr);
	    ppd[i].isym        = swap_word(ppd[i].isym);
	    ppd[i].iline       = swap_word(ppd[i].iline);
	    ppd[i].regmask     = swap_word(ppd[i].regmask);
	    ppd[i].regoffset   = swap_word(ppd[i].regoffset);
	    ppd[i].iopt        = swap_word(ppd[i].iopt);
	    ppd[i].fregmask    = swap_word(ppd[i].fregmask);
	    ppd[i].fregoffset  = swap_word(ppd[i].fregoffset);
	    ppd[i].frameoffset = swap_word(ppd[i].frameoffset);
	    ppd[i].framereg    = swap_half(ppd[i].framereg);
	    ppd[i].pcreg       = swap_half(ppd[i].pcreg);
	    ppd[i].lnLow       = swap_word(ppd[i].lnLow);
	    ppd[i].lnHigh      = swap_word(ppd[i].lnHigh);
	    ppd[i].cbLineOffset = swap_word(ppd[i].cbLineOffset);
	}
}

/*
 * Convert count dense number entries entries pointed to by pdn to the
 * other byte sex.
 */
void
swap_dn(pdn, count, destsex)
register pDNR pdn;
register long count;
long destsex;
{
    register long i;

	for(i = 0 ; i < count ; i++) {
	    pdn[i].rfd            = swap_word(pdn[i].rfd);
	    pdn[i].index            = swap_word(pdn[i].index);
	}
}

/*
 * Convert count runtime procedure table entries pointed to by prpd to the
 * other byte sex.
 */
void
swap_rpd(prpd, count, destsex)
register pRPDR prpd;
register long count;
long destsex;
{
    register long i;

	for(i = 0 ; i < count ; i++){
	    prpd[i].adr            = swap_word(prpd[i].adr);
	    prpd[i].regmask        = swap_word(prpd[i].regmask);
	    prpd[i].regoffset      = swap_word(prpd[i].regoffset);
	    prpd[i].fregmask       = swap_word(prpd[i].fregmask);
	    prpd[i].fregoffset     = swap_word(prpd[i].fregoffset);
	    prpd[i].frameoffset    = swap_word(prpd[i].frameoffset);
	    prpd[i].framereg       = swap_word(prpd[i].framereg);
		/* pointers must be castable to long and back */
	    prpd[i].exception_info = (struct exception_info *)swap_word((long)prpd[i].exception_info);
	}
}

typedef struct {
    union {
	struct {
	    unsigned index : 20;
	    unsigned rfd : 12;
	} fields;
	unsigned long word;
    } u;
} sRNDXR, *psRNDXR;

/*
 * Convert count optimization table entries pointed to by popt to the other byte
 * sex.
 */
void
swap_opt(popt, count, destsex)
register pOPTR popt;
register long count;
long destsex;
{
    register long i;
    register long hostsex = gethostsex();

    typedef struct {
	union {
	    struct {
		unsigned ot: 8;
		unsigned value: 24;
	    } fields;
	    unsigned long word;
	} u;
	sRNDXR	rndx;
	unsigned long	offset;
    } sOPTR, *psOPTR;

    sOPTR soptr;

	for(i = 0 ; i < count ; i++){
	    soptr = ((psOPTR)popt)[i];
	    soptr.offset    = swap_word(soptr.offset);

	    if (destsex == hostsex) {
		popt[i] = *(pOPTR)&soptr;
		soptr.u.word      = swap_word(soptr.u.word);
		soptr.rndx.u.word = swap_word(soptr.rndx.u.word);

		popt[i].ot    = soptr.u.fields.ot;
		popt[i].value = soptr.u.fields.value;
		popt[i].rndx.index = soptr.rndx.u.fields.index;
		popt[i].rndx.rfd   = soptr.rndx.u.fields.rfd;
	    } else {
		soptr.u.fields.ot = popt[i].ot;
		soptr.u.fields.value = popt[i].value;
		soptr.rndx.u.fields.index = popt[i].rndx.index;
		soptr.rndx.u.fields.rfd = popt[i].rndx.rfd;

		soptr.u.word      = swap_word(soptr.u.word);
		soptr.rndx.u.word = swap_word(soptr.rndx.u.word);
		popt[i] = *(pOPTR)&soptr;
	    } /* if */
	}
}

/*
 * Convert count auxiliary table entries pointed to by paux of type to the other
 * byte sex.
 */
void
swap_aux(paux, type, destsex)
register pAUXU paux;
long type;
long destsex;
{
    typedef struct {
	union {
	    struct {
		unsigned tq3 : 4;
		unsigned tq2 : 4;
		unsigned tq1 : 4;
		unsigned tq0 : 4;
		unsigned tq5 : 4;
		unsigned tq4 : 4;
		unsigned bt  : 6;
		unsigned continued : 1;
		unsigned fBitfield : 1;
	    } fields;
	    unsigned long word;
	} u;
    } sTIR, *psTIR;
    sTIR stir;
    register long hostsex = gethostsex();

    sRNDXR srndxr;

    if (destsex != hostsex) {
	fprintf (stderr, "swap of auxs not supported when destsex != hostsex\n");
	return;
    } /* if */

	switch(type){
	case ST_AUX_TIR:
	    stir = *((psTIR)paux);
	    stir.u.word = swap_word(stir.u.word);

	    paux->ti.tq3 = stir.u.fields.tq3;
	    paux->ti.tq2 = stir.u.fields.tq2;
	    paux->ti.tq1 = stir.u.fields.tq1;
	    paux->ti.tq0 = stir.u.fields.tq0;
	    paux->ti.tq5 = stir.u.fields.tq5;
	    paux->ti.tq4 = stir.u.fields.tq4;
	    paux->ti.bt = stir.u.fields.bt;
	    paux->ti.continued = stir.u.fields.continued;
	    paux->ti.fBitfield = stir.u.fields.fBitfield;
	    break;

	case ST_AUX_RNDXR:
	    srndxr = *((psRNDXR)paux);
	    srndxr.u.word = swap_word(srndxr.u.word);

	    paux->rndx.index = srndxr.u.fields.index;
	    paux->rndx.rfd   = srndxr.u.fields.rfd;
	    break;

	case ST_AUX_DNLOW:
	case ST_AUX_DNMAC:
	case ST_AUX_ISYM:
	case ST_AUX_ISS:
	case ST_AUX_WIDTH:
	default:
	    paux->width = swap_word(paux->width);
	    break;
	}
}

/*
 * Convert count relocation entries pointed to by preloc to the other byte sex.
 */
void
swap_reloc(preloc, count, destsex)
register struct reloc *preloc;
register long count;
long destsex;
{
    register long i;
    register long hostsex = gethostsex();

    typedef struct {
	long	r_vaddr;
	union {
	    struct {
		unsigned r_extern:1;
		unsigned r_type:4;
		unsigned r_reserved:3;
		unsigned r_symndx:24;
	    } fields;
	    unsigned long word;
	} u;
    } sRELOC, *psRELOC;

    sRELOC sreloc;

	for(i = 0 ; i < count ; i++){
	    sreloc = ((psRELOC)preloc)[i];
	    sreloc.r_vaddr = swap_word(sreloc.r_vaddr);

	    if (destsex == hostsex) {
		preloc[i] = *(RELOC *)&sreloc;
		sreloc.u.word     = swap_word(sreloc.u.word);

		preloc[i].r_extern   = sreloc.u.fields.r_extern;
		preloc[i].r_type     = sreloc.u.fields.r_type;
		preloc[i].r_reserved = sreloc.u.fields.r_reserved;
		preloc[i].r_symndx   = sreloc.u.fields.r_symndx;
	    } else {
		sreloc.u.fields.r_extern = preloc[i].r_extern;
		sreloc.u.fields.r_type = preloc[i].r_type;
		sreloc.u.fields.r_reserved = preloc[i].r_reserved;
		sreloc.u.fields.r_symndx = preloc[i].r_symndx;

		sreloc.u.word     = swap_word(sreloc.u.word);
		preloc[i] = *(RELOC *)&sreloc;
	    } /* if */
	}
}

/*
 * Convert count ranlib structures pointed to by pranlib to the other byte sex.
 */
void
swap_ranlib(pranlib, count, destsex)
register struct ranlib *pranlib;
register long count;
long destsex;
{
    register long i;

	for(i = 0 ; i < count ; i++){
	    pranlib[i].ran_un.ran_strx = swap_word(pranlib[i].ran_un.ran_strx);
	    pranlib[i].ran_off	       = swap_word(pranlib[i].ran_off);
	}
}

/*
 * Convert count gph structures pointed to by pgph to the other byte sex.
 */
void
swap_gpt(pgpt, count, destsex)
register GPTAB *pgpt;
register long count;
long destsex;
{
    long i;

	for(i = 0 ; i < count ; i++){
	    pgpt[i].entry.g_value = swap_word(pgpt[i].entry.g_value);
	    pgpt[i].entry.bytes   = swap_word(pgpt[i].entry.bytes);
	}
}