Return to var.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb

Power 6/32 Unix version 1.2b

static char sccsid[] = "@(#)var.c	2.10";

#include "macdefs.h"
#include "cdb.h"

export int	vilvMax;
int	vilvMac;
pTYR vrgTyLv;	/* allocated at in InitSpc */

#ifdef BSD41
#define	SbCrock(x) ((int)x)
#else
#define	SbCrock(x)	x
#endif

#ifndef M68000
TYR	vrgTySpc[] = {	/* array of register special variables */
#ifndef VAX
#ifndef TAHOE
	{
		SbCrock("$cBad"),stSpc, false, 0, btInt, 0,0,0,0,0,0,(ulong)&vcBadMax	}
	,
#endif
#endif
	{
		SbCrock("$lang"),	stSpc, false, 0, btInt,0,0,0,0,0,0,(ulong)&vlc	}
	,
	{
		SbCrock("$signal"),stSpc, false, 0, btInt, 0,0,0,0,0,0, (ulong)&vsig	}
	,
	/* name,st,fConstant,unused,desc,value */
	{
		SbCrock("$r0"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u0	}
	,
	{
		SbCrock("$r1"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u1	}
	,
	{
		SbCrock("$r2"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u2	}
	,
	{
		SbCrock("$r3"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u3	}
	,
	{
		SbCrock("$r4"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u4	}
	,
	{
		SbCrock("$r5"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u5	}
	,
	{
		SbCrock("$r6"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u6	}
	,
	{
		SbCrock("$r7"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u7	}
	,
	{
		SbCrock("$r8"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u8	}
	,
	{
		SbCrock("$r9"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u9	}
	,
	{
		SbCrock("$r10"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u10	}
	,
	{
		SbCrock("$r11"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u11	}
	,
	{
		SbCrock("$r12"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u12	}
	,
#ifndef TAHOE
	{
		SbCrock("$r13"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u13	}
	,
#endif
#ifdef ONYX
	{
		SbCrock("$r14"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u14	}
	,
	{
		SbCrock("$r15"),	stReg, false, 0, btInt, 0,0,0,0,0,0, u15	}
	,
	{
		SbCrock("$fcw"),	stReg, false, 0, btInt, 0,0,0,0,0,0, ufcw	}
	,
	{
		SbCrock("$long"),	stReg, false, 0, btLong,0,0,0,0,0,0, u6	}
	,
	{
		SbCrock("$short"),	stReg, false, 0, btShort,0,0,0,0,0,0,u7	}
	,
	{
		SbCrock("$result"),stReg, false, 0, btInt, 0,0,0,0,0,0, u7	}
	,
#endif
	{
		SbCrock("$fp"),	stReg, false, 0, btInt, 0,0,0,0,0,0, ufp	}
	,
	{
		SbCrock("$sp"),	stReg, false, 0, btInt, 0,0,0,0,0,0, usp	}
	,
	{
		SbCrock("$pc"),	stReg, false, 0, btInt, 0,0,0,0,0,0, upc	}
	,
#ifdef BSD41
#ifndef TAHOE
	{
		SbCrock("$ap"),	stReg, false, 0, btInt, 0,0,0,0,0,0, uap	}
	,
#endif
	{
		SbCrock("$long"),	stReg, false, 0, btLong, 0,0,0,0,0,0,u0	}
	,
	{
		SbCrock("$short"),	stReg, false, 0, btShort,0,0,0,0,0,0,u0	}
	,
	{
		SbCrock("$result"),stReg, false, 0, btInt, 0,0,0,0,0,0, u0	}
	,
	/* following allows us to diddle certain internal variables */
#endif
};
#endif

#ifdef M68000
TYR	vrgTySpc[] = {	/* array of register special variables */
	/* the following allows us to diddle certain internal variables */
	{
		SbCrock("$lang"),	stSpc,false,  0, 0,0,0,0,0,0,btInt,(ulong)&vlc	}
	,
	{
		SbCrock("$cBad"),stSpc,false,0,0,0,0,0,0,0,btInt,(ulong)&vcBadMax	}
	,
	/* and now the registers */
	{
		SbCrock("$result"),stReg, false, 0, 0,0,0,0,0,0, btLong, ud0	}
	,
	{
		SbCrock("$long"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud0	}
	,
	{
		SbCrock("$short"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud0	}
	,
	{
		SbCrock("$a0"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ua0	}
	,
	{
		SbCrock("$a1"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ua1	}
	,
	{
		SbCrock("$a2"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ua2	}
	,
	{
		SbCrock("$a3"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ua3	}
	,
	{
		SbCrock("$a4"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ua4	}
	,
	{
		SbCrock("$a5"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ua5	}
	,
	{
		SbCrock("$a6"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ua6	}
	,
	{
		SbCrock("$a7"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ua7	}
	,
	{
		SbCrock("$d0"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud0	}
	,
	{
		SbCrock("$d1"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud1	}
	,
	{
		SbCrock("$d2"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud2	}
	,
	{
		SbCrock("$d3"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud3	}
	,
	{
		SbCrock("$d4"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud4	}
	,
	{
		SbCrock("$d5"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud5	}
	,
	{
		SbCrock("$d6"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud6	}
	,
	{
		SbCrock("$d7"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ud7	}
	,
	{
		SbCrock("$fp"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ufp	}
	,
	{
		SbCrock("$sp"),	stReg, false, 0, 0,0,0,0,0,0, btLong, usp	}
	,
	{
		SbCrock("$pc"),	stReg, false, 0, 0,0,0,0,0,0, btLong, upc	}
	,
	{
		SbCrock("$ps"),	stReg, false, 0, 0,0,0,0,0,0, btLong, ups	}
	,
};
#endif
int	vispcMac = sizeof(vrgTySpc) / cbTYR;


/* I N I T   S P C */

export void InitSpc()
{
	int		i;
	TYR		aty;

	vrgTyLv = (pTYR) malloc((vilvMax+1)*cbTYR);	/* KLUDGE!! */
	vcbTot += vilvMax * cbTYR;
	aty = *vtyLong;	/* they are all basically long */
	aty.td.st = stSpc;
	for (i=0; i< vilvMax; i++)
		CopyTy(vrgTyLv+i, &aty); /* init various fields in the specials */
#ifdef BSD41
	/* this crock is due to string space/pointer problem */
	for (i=0; i < vispcMac; i++)
		vrgTySpc[i].sbVar |= bitHigh;
#endif
} /* InitSpc */


/* F   A D R   F   S P E C I A L */

export FLAGT FAdrFSpecial(sbSpc, rgTy, padr)
char	*sbSpc;
TYR	rgTy[];
pADRT	padr;
{
	int	i;

	/* first check the predefined specials */
	for (i=0; i < vispcMac; i++) {
		if (FSbCmp(SbInCore(vrgTySpc[i].sbVar), sbSpc)) {
			CopyTy(rgTy, vrgTySpc+i);
			*padr = vrgTySpc[i].valTy;
			return(true);
		} /* if */
	} /* for */

	/* next check the user defined specials */
	for (i=0; i < vilvMac; i++) {
		if (FSbCmp(SbInCore(vrgTyLv[i].sbVar), sbSpc)) {
			CopyTy(rgTy, vrgTyLv+i);
			*padr = (ADRT) &(vrgTyLv[i].valTy);
			return(true);
		} /* if */
	} /* for */

	/* no luck = try to define a new special with this name */
	if (vilvMac >= vilvMax)
		UError("No room to define local - %s", sbSpc);
	i = vilvMac++;
#ifdef SYSIII
	strncpy(vrgTyLv[i].sbVar, sbSpc, cbVarMax);
#endif
#ifdef BSD41
	vrgTyLv[i].sbVar = (int) malloc(strlen(sbSpc)+2);
	strcpy(vrgTyLv[i].sbVar, sbSpc);
	vrgTyLv[i].sbVar |= bitHigh;
#endif

	CopyTy(rgTy, vrgTyLv+i);
	*padr = (ADRT) &(vrgTyLv[i].valTy);
	return(true);
} /* FAdrFSpecial */


/* A D R   F   L O C A L */

export ADRT AdrFLocal(ipd, cnt, sbVar, rgTy)
int	ipd, cnt;
char	*sbVar;
TYR	rgTy[];
{
	ADRT	fp, ap;
	ADRT	adr;

	FpApFIpd(&fp, &ap, ipd, cnt);
	if (fp == 0)
		return(adrNil);

	SetNext(vrgPd[ipd].isym+1);
	if (!FNextLocal(true, true, sbVar)) {
		return(adrNil);
	} /* if */

#ifdef SYSIII
	if ((vsymCur->type == N_ABS) AND (vsymCur->value == 1))
		UError("Compiler wart involving register parameters - sorry");
#endif
	adr = vsymCur->value;
	TyFLocal(rgTy, sbVar, visym);

#ifdef BSD41
	if (vsymCur->type == stParam)
		adr = ap + adr;
	else if (vsymCur->type == stLocal)
		adr = fp - abs(adr);
#endif
#ifdef SYSIII
	adr += fp;
#endif
	/* things of type stReg do NOT get modified - may want to do look up
	     * some day, but this is almost impossible on ONYX
	     */
	return(adr);
} /* AdrFLocal */


/* A D R   F   G L O B A L */

export ADRT AdrFGlobal(sbVar, rgTy)
char	*sbVar;
TYR	rgTy[];
{
	ADRT	adrRet;
	char	sbTemp[cbVarMax+3];

	adrRet = adrNil;
	/* first we check for `_foo' */
	sbTemp[0] = '_';
	strcpy((sbTemp+1), sbVar);
	sbTemp[cbVarMax] = chNull;
	SetNext(visymGlobal);
	if (FNextSym(N_DATA, N_BSS, 0, sbTemp, FProcCmp)) {
		adrRet = vsymCur->value;
	} 
	else {
		/* no luck, try just plain `foo' */
		sbVar[cbVarMax] = chNull;
		SetNext(visymGlobal);
		if (FNextSym(N_DATA, N_BSS, 0, sbVar, FProcCmp)) {
			adrRet = vsymCur->value;
		} /* if */
	} /* if */
	if (adrRet != adrNil)
		TyFGlobal(rgTy, sbVar);
	return(adrRet);
} /* AdrFGlobal */


/* A D R   F   L A B E L */

export ADRT AdrFLabel(sbVar)
char	*sbVar;
{
	char	sbTemp[cbVarMax+2];

	/* first we check for `_foo' */
	sbTemp[0] = '_';
	strcpy((sbTemp+1), sbVar);
	sbTemp[cbVarMax] = chNull;
	SetNext(visymGlobal);
	if (FNextSym(N_TEXT, 0, 0, sbTemp, FProcCmp)) {
		return(vsymCur->value);
	} 
	else {
		/* no luck, try just plain `foo' */
		sbVar[cbVarMax] = chNull;
		SetNext(visymGlobal);
		if (FNextSym(N_TEXT, 0, 0, sbVar, FProcCmp))
			return(vsymCur->value);
	} /* if */
	return(adrNil);
} /* AdrFLabel */


/* C B   F   L O C A L */

export int CbFLocal(isym)
long	isym;
{
#ifdef BSD41
	SYMR	rgSym[2];

	SetSym(isym);
	rgSym[0] = *vsymCur;
	SetSym(isym+1);	/* second one might not be in core */
	rgSym[1] = *vsymCur;
	return(CbFTy(rgSym));	/* sort of a hack, but it IS correct */
#endif
#ifdef SYSIII
	int		cb, val;
	long	isymSave;

	/* boy is this section MACHINE DEPENDENT !! */
	isymSave = isym;
	SetSym(isym);
	val = vsymCur->value;
	if (FOdd(val))
		cb = 1;	/* this assumes that only one byte entities have odd adresses */
	else if (val > 0) {
		/* it's a parameter */
		do {
			SetSym(++isym); /* we need to look at the next one */
		} 
		while (vsymCur->type == N_REG);
		if ((vsymCur->type != N_ABS) OR ((int) (vsymCur->value) < 0))
			/* this means we don't know size of last param. kludge! */
			cb = CBINT;
		else cb = vsymCur->value - val;
	} 
	else {
		/* it's a local */
		SetSym(isym-1); /* we need to look at the previous one */
		if ((vsymCur->type != N_ABS) OR ((int) (vsymCur->value) >= 0))
#ifdef REGULUS
			cb = 0 - val;
#else
		cb = -12 - val;
#endif
		else cb = vsymCur->value - val;
	} /* if */

	SetSym(isymSave);
	return(cb);
#endif
} /* CbFLocal */


/* F P   A P   F   I P D */

export void FpApFIpd(pfp, pap, ipd, cnt)
pADRT	pfp, pap;
int	ipd, cnt;
{
	int		depth, ipdX;
	ADRT	pc;
	FLAGT	fDontCare;

	if (fDontCare = (cnt == -1))
		cnt = 10000;

	depth = 0;
	*pfp = vfp;
	*pap = vap;
	pc = vpc;
	while (*pfp != 0) {
		ipdX = IpdFAdr(pc);
		if (ipdX == ipd) {
			if ((fDontCare) OR (cnt == depth))
				return;
		} /* if */
		if (cnt < depth)
			UError("Procedure '%s' is not at that stack depth",
			vrgPd[ipd].sbProc);
		depth++;
		NextFrame(pfp, pap, &pc);
	} /* for */
	return;
} /* FpApFIpd */


/* N E X T   F R A M E */

export void NextFrame(pfp, pap, ppc)
ADRT	*pfp, *pap, *ppc;
{
	/* we either give them the vbalues for the next frame
		 * OR we give them a new fp of 0
		 */
#ifdef ONYX
	*ppc = GetWord(*pfp+CBINT, spaceData);
	*pfp = GetWord(*pfp, spaceData);
	*pap = *pfp;	/* they are the same for most non-vax systems */
#endif
#ifdef M68000
#ifndef SUN
	*ppc = GetWord(*pfp+CBLONG, spaceData);
	*pfp = GetWord(*pfp, spaceData);
	*pap = *pfp;	/* they are the same for most non-vax systems */
#endif
#endif
#ifdef BSD41
#ifdef SUN
	*ppc = GetWord(*pfp+CBLONG, spaceData);
	*pfp = GetWord(*pfp, spaceData);
	*pap = *pfp;	/* they are the same for most non-vax systems */
#endif

#ifdef TAHOE
	*ppc = GetWord(*pfp-8, spaceData);
	*pap = GetWord(*pfp, spaceData);
	*pfp = GetWord(*pfp, spaceData) ;	/* force to even byte */
#endif

#ifdef VAX
	*ppc = GetWord(*pfp+16, spaceData);
	*pap = GetWord(*pfp+8, spaceData);
	*pfp = GetWord(*pfp+12, spaceData) & ~1;	/* force to even byte */
	if (*ppc > 0x70000000) {
		/* it looks like we have some error handler magic here */
		*ppc = GetWord(*pfp+64, spaceData) - 1; /* back up pc by 1 */
		*pap = GetWord(*pfp+8, spaceData);
		*pfp = GetWord(*pfp+12, spaceData) & ~1;	/* force to even byte */
	}
#endif
	if (*pfp & 0xf0000000 != 0x70000000)
		Panic("Non-kosher frame pointer");
	/* see if this is the 'start' frame */
	if (vrgFd[0].adrStart > *ppc) {
		*pfp = 0;
	} /* if */
	if ((vfPascal)
	    AND (*ppc > vadrMain)
	    AND (*ppc < vadrStart)) {
		*pfp = 0;	/* this is pascal's version of the start code */
	}
#endif
} /* NextFrame */


/* D I S P   F R A M E */

export void DispFrame(pc, ipd, fp, ap, cnt, fDoLocals, fDoVal)
ADRT	pc;
int	ipd, cnt;
ADRT	fp, ap;
FLAGT	fDoLocals, fDoVal;
{
	int		ifd, ln, slop, i;
	char	sbName[50];
	long	val, isymSave, isym, adrLong;
	TYR		rgTy[cTyMax];

	printf("%s(", vrgPd[ipd].sbProc);
	SetNext(vrgPd[ipd].isym+1);
	i = 0;
	while (FNextLocal(false, true, sbNil)) {
		isymSave = visym;
		val = vsymCur->value;
		TyFLocal(rgTy, SbInCore(vsymCur->sbSym+vcbVarHdr), visym);
		if (i++)
			printf(", ");
		if (fDoVal) {
#ifdef BSD41
			printf("%s=", SbInCore(rgTy[0].sbVar));
#else
			printf("%.8s=", SbInCore(rgTy[0].sbVar));
#endif
			adrLong = val + ap;
			DispVal(adrLong, rgTy, modeNil, false, true, false);
		} 
		else {
			/* they just want to know what the args are */
			PxTy(rgTy);
		} /* if */
		visym = isymSave;
	} /* while */
	printf(")");
	if (pc != adrNil) {
		isymSave = visym;
		isym = vrgPd[ipd].isym;
		IfdLnFAdr(pc, isym, &ifd, &ln, &slop);
		printf("    [%s:%d]", vrgFd[ifd].sbFile, ln);
		visym = isymSave;
	} /* if */
	if (fDoLocals) {
		SetNext(visym);
		vcNest++;	/* in case we have structure to indent */
		while (FNextLocal(true, false, sbNil)) {
			strcpy(sbName, SbInCore(vsymCur->sbSym+vcbVarHdr));
			isym = visym;
			adrLong = AdrFLocal(ipd, cnt, sbName, rgTy);
			printf("\n	");
			DispVal(adrLong, rgTy, modeNil, true, true, true);
			SetSym(isym);
		} /* while */
		vcNest--;
	} /* if */
	printf("\n");
} /* DispFrame */


/* D I S P   U N K N O W N */

export void DispUnknown(pc, fp, ap)
ADRT	pc, fp, ap;
{
	int		i;
#ifdef TAHOE
	int	real_no_args;
#endif

	LabelFAdr(pc);	/* sets vsymCur to nearest label */
	printf("%s", SbInCore(vsymCur->sbSym));
	if (vsymCur->value != pc)
		printf("+%s",SbFAdr(lengthen(pc-vsymCur->value), true));
	/* we print what LOOK like the first N parameters */
	printf("(");
#ifdef ONYX
	ap += 4;
#endif
#ifdef TAHOE
	real_no_args = ( (GetWord(fp-4, spaceData) & 0xffff) -4) /4;
#endif
#ifdef VAX
	ap += 4;
#endif
#ifdef M68000
	ap += 4;
#endif
#define cArgsMax 5

#ifdef TAHOE
	for (i=0; i<real_no_args; i++) {
#else
		for (i=0; i<cArgsMax; i++) {
#endif
			printf("%d%s", GetWord(ap, spaceData), (i<cArgsMax-1) ? ", " : "");
			ap += CBINT;
		}
		printf(")\n");
	} /* DispUnknown */


	/* S T A C K   T R A C E */

	export void StackTrace(cnt, fDoLocals)
		int	cnt;
	FLAGT	fDoLocals;
	{
		int 	ipd, i;
		ADRT	pc, fp, ap;

		fp = vfp;
		pc = vpc;
		ap = vap;
		for (i=0; ((i < cnt) AND (fp != 0)); i++) {
			ipd = IpdFAdr(pc);
			if (ipd == ipdNil) {
				printf("%2d ", i);
				DispUnknown(pc, fp, ap);
			} 
			else {
				printf("%2d ", i);
				DispFrame(pc, ipd, fp, ap, i, fDoLocals, true);
			} /* if */
			NextFrame(&fp, &ap, &pc);
		} /* for */
	} /* StackTrace */


	/* L I S T   R E G S */

	export void ListRegs(sbRegs)
		char	*sbRegs;
	{
		int		i;
		long	adr;
		TYR		ty;

		/* first check the predefined specials */
		for (i=0; i < vispcMac; i++) {
			if ((vrgTySpc[i].td.st != stReg)
			    OR (sbRegs != sbNil)
			    AND (!FHdrCmp(sbRegs, SbInCore(vrgTySpc[i].sbVar)))) 
				continue;	/* not interesting */
			ty = vrgTySpc[i];
			adr = vrgTySpc[i].valTy;
			DispVal(adr, &ty, modeNil, true, true, true);
			printf("\n");
		} /* for */
	} /* ListRegs */


	/* L I S T   S P E C I A L */

	export void ListSpecial(sbSpecial)
		char	*sbSpecial;
	{
		int		i;
		long	adr;
		TYR		ty;

		/* first check the predefined specials */
		for (i=0; i < vispcMac; i++) {
			if ((vrgTySpc[i].td.st == stReg)
			    OR (sbSpecial != sbNil)
			    AND (!FHdrCmp(sbSpecial, SbInCore(vrgTySpc[i].sbVar)))) 
				continue;	/* not interesting */
			ty = vrgTySpc[i];
			adr = vrgTySpc[i].valTy;
			DispVal(adr, &ty, modeNil, true, true, true);
			printf("\n");
		} /* for */

		/* next do user defined stuff */
		for (i=0; i<vilvMac ; i++) {
			if ((sbSpecial != sbNil)
			    AND (!FHdrCmp(sbSpecial, SbInCore(vrgTyLv[i].sbVar))))
				continue;	/* not interesting */
			adr = (long) &(vrgTyLv[i].valTy);
			DispVal(adr, vrgTyLv+i, modeNil, true, true, true);
			printf("\n");
		} /* for */
	} /* ListSpecial */


	/* L A B E L   F   A D R */

	export void LabelFAdr(adr)
		ADRT	adr;
	{
		long	isymNearest;
		ADRT	adrLabel, adrNearest;
		/* returns isym of nearest TEXT Label <= adr */

		adrNearest = 0;
		SetNext(visymGlobal);
		while (FNextSym(N_TEXT, 0, 0, sbNil, nil)) {
			if ((vsymCur->type & N_EXT) == 0)
				continue;
			adrLabel = vsymCur->value;
			if ( (adrLabel <= adr)
			    AND (adrLabel >= adrNearest) ) {
				isymNearest = visym;
				adrNearest = adrLabel;
			} /* if */
		} /* while */
		SetSym(isymNearest);
	} /* LabelFAdr */


	/* O P E N   S T A C K */

	export void OpenStack(cnt)
		int	cnt;
	{
		int		cntIn;
		ADRT	pc, fp, ap;

		cntIn = cnt;
		fp = vfp;
		ap = vap;
		pc = vpc;
		while (cnt-- AND fp)
			NextFrame(&fp, &ap, &pc);
		if (fp == 0)
			UError("Stack isn't that deep!");

#ifdef VAX
		if (cntIn != 0)
			pc -= 1;
#endif
		PrintPos(pc, fmtFile+fmtProc+fmtLn+fmtPrint);
	} /* OpenStack */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.