/* ICDPCR (ICD) -- IC Design Report */
/* ICDPCR (ICD) -- IC-Design-Report */
/* -- INTENDED FOR KEY-CALL USE -- */
/*
// Copyright (c) 2001-2012 Oliver Bartels F+E, Muenchen
// Author: Roman Ludwig
// Changes History:
//	rl (120427) RELEASED FOR BAE V7.8.
//	rl (101019) RELEASED FOR BAE V7.6.
//	rl (091021) RELEASED FOR BAE V7.4.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (050906) RELEASED FOR BAE V6.6.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (010806) ORIGINAL CODING. DERIVED FROM LAYPCR.ULC.
//
// DESCRIPTION
//
// The icdpcr User Language program provides detailed information
// about the currently loaded IC Design element such as
// DDB file name, element name, element origin coordinates,
// element boundary coordinates, element size, DRC checking
// parameter settings, reference listing (cells on IC layout,
// pins/cells on cell). The report output is displayed in a
// popup menu with file output option.
*/

// Includes
#include "pop.ulh"			// User Language popup utilities
#include "icd.ulh"			// User Language IC Design utilities

// Disable undo state request
#pragma ULCALLERNOUNDO

// Messages
string REPSCNPRT	= M("Scannen Makros (Abbruch mit Tastendruck)...",
			    "Scanning macros (hit any key to abort)...");
string REPHEADER	= M("%s Report :","%s Report :");
string REPFILE		= M("Dateiname ...............: '%s'",
			    "File Name ...............: '%s'");
string REPELEM		= M("Elementname .............: '%s'",
			    "Element Name ............: '%s'");
string REPSAVE		= M("Plan gesichert ..........: %s",
			    "Element saved ...........: %s");
string REPORIG		= M("Nullpunkt ...............: %8.3f,%8.3f %s",
			    "Origin ..................: %8.3f,%8.3f %s");
string REPUBND		= M("Obere Grenze ............: %8.3f,%8.3f %s",
			    "Upper Boundary ..........: %8.3f,%8.3f %s");
string REPLBND		= M("Untere Grenze ...........: %8.3f,%8.3f %s",
			    "Lower Boundary ..........: %8.3f,%8.3f %s");
string REPSIZE		= M("Plan Groesse ............: %8.3f,%8.3f %s",
			    "Element Size ............: %8.3f,%8.3f %s");
string REPPRTCNT	= M("Makroanzahl .............: %d",
			    "Macro Count..............: %d");
string REPPINCNT	= M("Pin/Makroanzahl .........: %d",
			    "Pin/Macro count .........: %d");
string REPECNLAY	= M("Connectivity-Lagen ......:",
			    "Connectivity Layers .....:");
string REPLAYEN		= M(" Lage %2d : %s"," Layer %2d : %s");
string UPRPARTLA	= M("Makroliste Alle","Macro List All");
string UPRPARTLP	= M("Makroliste Platziert","Macro List Placed");
string UPRPARTLU	= M("Makroliste Unplatziert","Macro List Unplaced");
string UPRPARTLC	= M("Makroliste Konstruktive",
			    "Macro List Constructive");
string ITMHDPRT		= M("Makro","Macro");
string ITMHDPIN		= M("Pin","Pin");
string ITMHDMAC		= M("Makro","Macro");
string ITMHDPLC         = M("Platzierung","Placement");
string ITMPLCUM		= M("ungespiegelt","not mirrored");
string ITMPLCMI		= M("gespiegelt","mirrored");
string ITMUNPLC		= M("-unplatziert-","-unplaced-");
string ITMINVPLC	= M("-falsches Makro-","-wrong macro-");
string ITMHDMIR		= M("Spiegelung","Mirror");
string ITMYES		= M("ja","yes");
string ITMNO		= M("nein","no");
string ITMON		= M("ein","on");
string ITMOFF		= M("aus","off");
string ITMCELL		= M("- Makro -","- Macro -");

// General item and format strings
#define ITMULINE	"========================================"
#define ITMELLIPS	"..."
#define FMTHEADUL	"%.*s"
#define FMTPRTH1	"%*s %-*s %-*s"
#define FMTPRTH2	"%.*s %.*s %.*s"
#define FMTPLCH1	"%*s %-*s %8s %8s Rotation %s %s"
#define FMTPINH1	"%*s %-*s %8s %8s Rotation %s"
#define FMTPINH2	"%.*s %.*s ======== ======== ======== %-.*s"
#define FMTPLC		"%*s %-*s %8.3f %8.3f %8.3f %s"
#define FMTPIND		"%*s %-*s %8.3f %8.3f %8.3f %*s %8.3f"

// Destination unit designators
string UNIT		= bae_getcoorddisp() ? "[mil]" : "[um]";
					// Unit designator
double ITOB		= baecvtl(1.0)
					/* Scale factor int. to BAE disp. */;

// Globals
double nx		= bae_planwsnx()/* Plan origin X coordinate */;
double ny		= bae_planwsny()/* Plan origin Y coordinate */;
double ux		= bae_planwsux()/* Plan upper X coordinate */;
double uy		= bae_planwsuy()/* Plan upper Y coordinate */;
double lx		= bae_planwslx()/* Plan lower X coordinate */;
double ly		= bae_planwsly()/* Plan lower Y coordinate */;
STRINGS headl				/* Header list */;
int headn		= 0		/* Header count */;
STRINGS entryl				/* Entry list */;
int entryn		= 0		/* Entry count */;

// Main program
void main()
{
	int mc		= 0		/* Requested popup column count */;
	int i				/* Loop variable */;
	// Print the plan characteristics
	sprintf(headl[0],REPHEADER,ddbclassname(bae_planddbclass()));
	sprintf(headl[1],FMTHEADUL,strlen(headl[0]),ITMULINE);
	sprintf(headl[2],REPFILE,bae_planfname());
	sprintf(headl[3],REPELEM,bae_planename());
	sprintf(headl[4],REPSAVE,bae_plannotsaved()?ITMNO:ITMYES);
	sprintf(headl[5],REPORIG,ITOB*nx,ITOB*ny,UNIT);
	sprintf(headl[6],REPUBND,ITOB*ux,ITOB*uy,UNIT);
	sprintf(headl[7],REPLBND,ITOB*lx,ITOB*ly,UNIT);
	sprintf(headl[8],REPSIZE,ITOB*(ux-lx),ITOB*(uy-ly),UNIT);
	headn=9;
	// Evaluate the plan class
	switch (bae_planddbclass()) {
		// Layout
		case DDBCLILAY :
		// Print the checking parameters
		layerparams();
		// Print the layout part list
		partlist();
		break;
		// Part
		case DDBCLICELL :
		// Print the checking parameters
		layerparams();
		// Print the part pin list
		pinlist();
		break;
		}
	// Get the maximum line length
	for (i=headn-1;i>=0;i--)
		mc=maxint(mc,strlen(headl[i])+1);
	for (i=entryn-1;i>=0;i--)
		mc=maxint(mc,strlen(entryl[i])+1);
	// Activate the report popup menu
	bae_setintpar(16,3011);
	popupmenu(0,"",headl,headn,entryl,entryn,
	 "",0,0,1,headn+entryn+2,mc,0,"");
}

// Data retrieval routines

void layerparams()
/*
// Append the layer specific parameters at list
*/
{
	int layer			/* Layer number */;
	// Store the connectivity layers header
	sprintf(headl[headn],REPECNLAY);
	headn++;
	// Loop for all signal layers
	for (layer=0;layer<STDLAYMAX;layer++)
		if (icd_ecnlaymode(layer)) {
			sprintf(headl[headn],REPLAYEN,
			 layer,icd_stdlayname(layer));
			headn++;
			}
}

void partlist()
/*
// Print the part list
*/
{
	index I_CPART cpart		/* Con. part index */;
	index I_NREF nref		/* Named reference index */;
	index I_MACRO mac		/* Macro index */;
	string uinput			/* User input string */;
	STRINGS plnam			/* Part name list */;
	STRINGS plmac			/* Part macro list */;
	STRINGS plplc			/* Part placement list */;
	int pn		= 0		/* Part count */;
	int lnam,lmac,lplc		/* Output field lengths */;
	int mc		= 0		/* Requested popup column count */;
	int abort	= 0		/* Abort flag */;
	int listp			/* List placed parts flag */;
	int listc			/* List constructive parts flag */;
	string entrystr			/* Entry string buffer */;
	int i				/* Loop control variable */;
	// Count the placed parts
	forall (nref)
		pn++;
	// Count the unplaced parts
	forall (cpart where (cpart.USED&CPART_PLC)==0)
		pn++;
	// Complete the header
	sprintf(headl[headn],REPPRTCNT,pn);
	headn++;
	// Insert part list output request entry
	headn++;
	entryl[entryn++]=UPRPARTLA;
	entryl[entryn++]=UPRPARTLP;
	entryl[entryn++]=UPRPARTLU;
	entryl[entryn++]=UPRPARTLC;
	// Get maximum line length
	// Get the maximum line length
	for (i=headn-1;i>=0;i--)
		mc=maxint(mc,strlen(headl[i])+1);
	for (i=entryn-1;i>=0;i--)
		mc=maxint(mc,strlen(entryl[i])+1);
	// Activate the popup menu; get part list request
	bae_setintpar(16,3012);
	if ((uinput=popupmenu(5,"",headl,headn,entryl,entryn,UINPOPABORT,
	 0,0,1,headn+entryn+2,mc,0,""))=="" || uinput==UINPOPABORT)
		// Abort request
		error_abort();
	// "Allocate" the part list
	plnam[pn]="";
	plmac[pn]="";
	plplc[pn]="";
	// Re-init the part count
	pn=0;
	// Init the output field lengths
	lnam=strlen(ITMHDPRT);
	lmac=strlen(ITMHDMAC);
	forall (mac where mac.CLASS==DDBCLICELL)
		lmac=maxint(lmac,strlen(mac.NAME));
	lplc=strlen(ITMINVPLC);
	// Print part scan message
	bae_prtdialog(REPSCNPRT);
	// Test if unplaced connection parts list requested
	if (uinput==UPRPARTLA || uinput==UPRPARTLU) {
		// Get the unplaced connection list parts
		forall (cpart where (cpart.USED&CPART_PLC)==0) {
			// Abort on request
			if (kbhit()) {
				getchr();
				abort=1;
				break;
				}
			// Store the part info
			plnam[pn]=cpart.NAME;
			plmac[pn]=cpart.PLNAME;
			plplc[pn]=ITMUNPLC;
			pn++;
			// Update the output field lengths
			lnam=maxint(lnam,strlen(cpart.NAME));
			lmac=maxint(lmac,strlen(cpart.PLNAME));
			}
		}
	// Get the parts list request flags
	listp=uinput==UPRPARTLA || uinput==UPRPARTLP;
	listc=uinput==UPRPARTLA || uinput==UPRPARTLC;
	// Test if constructive parts list requested
	if (!abort && (listc || listp)) {
		// Loop thru the placed part list
		forall (nref) {
			// Abort on request
			if (kbhit()) {
				getchr();
				abort=1;
				break;
				}
			// Test if connection list part
			if (icd_findconpart(nref.NAME,cpart)) {
				// Constructive part
				if (!listc)
					continue;
				// Store the part info
				plnam[pn]=nref.NAME;
				plmac[pn]=nref.MACRO.NAME;
				plplc[pn]=nref.MIRROR ? ITMPLCMI : ITMPLCUM;
				pn++;
				// Update output field lengths
				lnam=maxint(lnam,strlen(nref.NAME));
				}
			else {
				// Placed con. part
				if (!listp)
					continue;
				// Store the part info
				plnam[pn]=cpart.NAME;
				plmac[pn]=cpart.PLNAME;
				plplc[pn]=(nref.MACRO.NAME!=cpart.PLNAME) ?
				 ITMINVPLC :
				 (nref.MIRROR ? ITMPLCMI : ITMPLCUM);
				pn++;
				// Update the output field lengths
				lnam=maxint(lnam,strlen(cpart.NAME));
				lmac=maxint(lmac,strlen(cpart.PLNAME));
				}
			}
		}
	// Complete the header
	sprintf(headl[headn],FMTPRTH1,
	 lnam,ITMHDPRT,lmac,ITMHDMAC,lplc,ITMHDPLC);
	sprintf(headl[headn+1],FMTPRTH2,
	 lnam,ITMULINE,lmac,ITMULINE,lplc,ITMULINE);
	headn+=2;
	// Build the part entry list
	entryl[pn]="";
	entryn=0;
	for (i=0;i<pn;i++) {
		// Build the entry string
		sprintf(entrystr,FMTPRTH1,
		 lnam,plnam[i],lmac,plmac[i],lplc,plplc[i]);
		// Store the entry string
		newentry(entrystr);
		}
	// Test if part listing aborted
	if (abort) {
		// Add ellipsis to indicate abort
		sprintf(entryl[entryn],FMTPRTH1,
		 lnam,ITMELLIPS,lmac,ITMELLIPS,lplc,ITMELLIPS);
		entryn++;
		}
}

void pinlist()
/*
// Print the pin list of the currently loaded part
*/
{
	index I_FIGURE f		/* Figure list index */;
	index I_NREF n			/* Named reference index */;
	index I_UREF u			/* Unnamed reference index */;
	int lnam,lmac,lmir		/* Output field lengths */;
	int pincount	= 0		/* Pincount */;
	string entrystr			/* Entry string buffer */;
	// Init the output field lengths
	lnam=strlen(ITMHDPIN);
	lmac=strlen(ITMHDMAC);
	lmir=strlen(ITMHDMIR);
	// Get the maximum output field lengths and the pin count
	forall (n) {
		pincount++;
		lnam=maxint(lnam,strlen(n.NAME));
		lmac=maxint(lmac,strlen(n.MACRO.NAME));
		}
	forall (u) {
		lnam=maxint(lnam,strlen(ITMCELL));
		lmac=maxint(lmac,strlen(u.MACRO.NAME));
		}
	// Complete the header
	sprintf(headl[headn],REPPINCNT,pincount);
	sprintf(headl[headn+2],FMTPINH1,
	 lnam,ITMHDPIN,lmac,ITMHDMAC,"X "+UNIT,"Y "+UNIT,ITMHDMIR);
	sprintf(headl[headn+3],FMTPINH2,
	 lnam,ITMULINE,lmac,ITMULINE,lmir,ITMULINE);
	headn+=4;
	// Init the entry list
	entryl[pincount]="";
	entryn=0;
	// Store the pins
	forall (f where f.TYP==I_FIGNREF) {
		// Get the named reference index
		n=f.NREF;
		// Build the entry string
		sprintf(entrystr,FMTPLC,lnam,n.NAME,lmac,n.MACRO.NAME,
		 ITOB*(n.X-nx),ITOB*(n.Y-ny),
		 cvtangle(n.ANGLE,0,1),n.MIRROR ? ITMON : ITMOFF);
		// Store the entry string
		newentry(entrystr);
		}
	// Store the cells
	forall (f where f.TYP==I_FIGUREF) {
		// Get the named reference index
		u=f.UREF;
		// Build the entry string
		sprintf(entrystr,FMTPLC,lnam,ITMCELL,lmac,u.MACRO.NAME,
		 ITOB*(u.X-nx),ITOB*(u.Y-ny),
		 cvtangle(u.ANGLE,0,1),u.MIRROR ? ITMON : ITMOFF);
		// Store the entry string
		newentry(entrystr);
		}
}

// Entry list routines

void newentry(string entrystr)
/*
// Store a new entry string to the entry list
// Parameters :
//	string entrystr		: Entry string
*/
{
	int slb		= 0		/* Search lower boundary */;
	int sub		= entryn-1	/* Search upper boundary */;
	int sidx			/* Search index */;
	int compres			/* Compare result */;
	// Loop until search area empty
	while (slb<=sub) {
		// Get the search index
		sidx=(slb+sub)>>1;
		// Test if entry found; update the search area
		if ((compres=numstrcmp(entrystr,entryl[sidx]))<0)
			sub=sidx-1;
		else
			slb=sidx+1;
		}
	// Insert new entry string to sorted entry list
	for (sidx=entryn;sidx>slb;sidx--)
		entryl[sidx]=entryl[sidx-1];
	entryl[slb]=entrystr;
	entryn++;
}

// User Language program end