/* LOGLEDIT (SCM) -- Loglib Editor Functions */
/* LOGLEDIT (SCM) -- Loglib-Editor-Funktionen */
/*
// Copyright (c) 2000-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 (100113) ENHANCEMENT:
//		Adjusted line wrap to at least edit box width.
//	rl (091021) RELEASED FOR BAE V7.4.
//	rl (081205) ENHANCEMENT:
//		Added manual launch button.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (070601) ENHANCEMENT:
//		Added alternate part macro edit box.
//		Improved virtual symbol handling.
//	rl (070112) BUGFIX:
//		Fixed problem with graphic edit plan reload.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (051031) ENHANCEMENT:
//		Added automatic xlat for single pin symbols.
//	rl (050906) RELEASED FOR BAE V6.6.
//	rl (050530) ENHANCEMENT:
//		Added table pin assignment.
//	rl (050527) ENHANCEMENT:
//		Added graphical pin assignment.
//	rl (050218) ENHANCEMENT:
//		Added automatic newattr commands insertion.
//	rl (041216) ENHANCEMENT:
//		Added automatic default statement for symbols with $plname.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (040216) ENHANCEMENT:
//		Added layout part macro selection for new definitions.
//		Added layout part pin list comment for new definitions.
//		Added layout part macro load in HighEnd.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (030226) ENHANCEMENT:
//		Added $rlext support for picked references.
//		Fixed problem with uppercase $rlname definition.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (020206) BUGFIX:
//		Fixed problem with empty $rlname definition.
//	rl (010928) ENHANCEMENT:
//		Added $rlname query for picked references.
//	rl (010625) RELEASED FOR BAE V5.0.
//	rl (010423) BUGFIX:
//		Fixed problem with library file name extension.
//	rl (010409) ENHANCEMENT:
//		Added optional parameter settings from bae.ini file.
//	rl (000713) RELEASED FOR BAE V4.6.
//	rl (000504) ORIGINAL CODING.
//
// DESCRIPTION
//
// The logledit User Language program provides the ability to
// edit and compile loglib data.
// If the currently loaded element is a schematic symbol the
// loglib definition for this symbol will be created/edited.
// If the currently loaded element is a schematic plan the
// user can select a symbol on the plan.
// For other element classes the element must be specified/selected in
// a selection list box.
*/

// Includes
#include "pop.ulh"			// User Language popup utilities
#include "baeparam.ulh"			// User Language BAE param. access
#include "scm.ulh"			// User Language SCM utilities
#include "sql.ulh"			// User Language SQL utilities

// Disable undo state request
#pragma ULCALLERNOUNDO

// Messages
string UPRABORT		= M_UPRABORT();
string REPDONE		= M("Es wurden keine Fehler festgestellt.",
			    "Operation completed without errors.");
string UPRPICKSYM	= M("Symbol selektieren!","Select Symbol");
string UPRDEST		= M("Zieldatei selektieren!",
			    "Select destination file!");
string UPRDEFLIB	= M("&Defaultbibliothek","&Default library");
string UPRJOB		= M("&Jobdatei","&Job file");
string UPROTHER		= M("&Andere Datei","&Other file");
string UPREDIT		= M("!Neue Loglib-Definition",
			    "!New Loglib Definition");
string UPRDEDIT		= M("Loglib-Definition zu Symbol '%s'",
			    "Loglib Definition of Symbol '%s'");
string UPRDEDITD		= M("Loglib-Definition '%s' zu Symbol '%s'",
			    "Loglib Definition '%s' of Symbol '%s'");
string UPRDFILE		= M("!Zieldateiname ? ","!Destination File Name ? ");
string UPRLFILE		= M("Quelldateiname ? ","Source File Name ? ");
string UPRMACLIST	= M("Gehaeuse","Macro(s)");
string UPRDOCU		= M("Doku","Help");
string UPRSAMPLE	= M("Beispiele :","Examples :");
string UPRPINASS	= M("Pinzuordnungen :","Pin Assignments :");
string UPRPINASSN	= M("Pinzuordnungen '%s'","Pin Assignments '%s'");
string UPRPINASSS	= M(":",":");
string UPRNEXTDIAL	= M("&>","&>");
string UPRPREVDIAL	= M("&<","&<");
string UPRIMPASS	= M("&Import","&Import");
string UPRTABASS	= M("&Tabelle","&Table");
string UPRGRLASS	= M("Grafisch mit &Linien","Graphically with &Lines");
string UPRGRTASS	= M("Grafisch mit &Texten","Graphically with &Texts");
string UPRASSFILE	= M("Pinzuordnungsdatei ? ","Pin Assignment File ? ");
string UPROFILE		= M("Definition '%s' in anderer Datei suchen ?",
			    "Search definition '%s' in other file ?");
string UPRNFILE		= M("Definition '%s' nicht gefunden! In anderer Datei suchen ?",
			    "Definition '%s' not found. Search in other file ?");
string UPRNPFILE	= M("Layoutbauteil '%s' nicht gefunden! (Anderes) Bauteil suchen ?",
			    "Layout part '%s' not found. Search (other) part ?");
string UPRECONT		= M("Fehler bei der Kompilierung!",
			    "Error compiling definition!");
string UPRWCONT		= M("Warnung(en) bei der Kompilierung!",
			    "Warning(s) compiling definition!");
string UPRPRTPROJ	= M("Bauteilmakros in Projektdatei :",
			    "Part Macros in Project File :");
string UPRPRTDB		= M("Bauteilmakros in Bibliothek '%s' :",
			    "Library Part Macros '%s' :");
string UPRPATTERN	= M("Muster anwenden :","Apply Pattern :");
string UPRPATTERNA	= M("Alle","All");
string UPRPATTDOC	= M("z.B. *16 oder dil*","e.g. *16 or dil*");
string UPRLIST		= M("Liste","List");
string UPRVIRTUAL	= M("virtual","virtual");
string UPRNEWPRT	= M("Layoutbauteilmakro in '%s' ?",
			    "Layout Part Macro in '%s' ?");
string UPRDNEWPRT	= M("Layoutbauteilmakro :","Layout Part Macro :");
string UPRDNEWPRTL	= M("Layoutbauteilmakro(s) :","Layout Part Macro(s) :");
string UPRNEWPRTD	= M("Layoutbauteilmakro zu Symbol '%s' Definition '%s'",
			    "Layout Part Macro of Symbol '%s' Definition '%s'");
string UPRGATECNT	= M("Anzahl Gatter ? ","Gate Count ? ");
string UPRTXTLEFT	= M("Zum Speichern hier links klicken",
			    "Left click here to finish");
string UPRATXTLEFT	= M("Zum Abbrechen hier links klicken",
			    "Left click here to abort");
string UPRTXTRIGHT	= M("Zum Speichern hier rechts klicken",
			    "Right click here to finish");
string UPRATXTRIGHT	= M("Zum Abbrechen hier rechts klicken",
			    "Right click here to abort");
string UPRLPINCNT	= M("Layoutbauteil '%s' hat zu wenig Pins fuer Zuordnung. Abbrechen?",
			    "Layout part '%s' has not enough pins for assignment. Abort?");
string REPSPPARTF	= M("part r : s0805              - Bauteil mit fester Bauformzuordnung",
			    "part r : s0805              - Part with fixed part macro assignment");
string REPSPPARTD	= M("part r : default s0805      - Bauteil mit $plname-aenderbarer Bauformzuordnung",
			    "part r : default s0805      - Part with $plname changeable part macro assignment");
string REPSPPARTA	= M("part r : s0805,s1206        - Bauteil mit Alternativbauformliste",
			    "part r : s0805,s1206        - Part with alternate part macro list");
string REPSPPARTM	= M("part op : mainpart so8      - mainpart-Definition",
			    "part op : mainpart so8      - mainpart definition");
string REPSPPARTS	= M("part op_supply : subpart op - subpart-Definition",
			    "part op_supply : subpart op - subpart definition");
string REPSPPARTV	= M("part header : virtual       - virtual-Definition",
			    "part header : virtual       - virtual definition");
string REPSPPARTC	= M("part d : class diode s0805  - Bauteil mit Klassenangabe",
			    "part d : class diode s0805  - Part with class specification");
string REPSPPARTMC	= M("part lm324 : class op mainpart so8 - mainpart mit Klassenangabe",
			    "part lm324 : class op mainpart so8 - mainpart with class specification");
string REPSPPINS	= M("pin(a,b,y);                 - Symbolpinauflistung",
			    "pin(a,b,y);                 - Symbol pin list");
string REPSPBUSSES	= M("bus(data);                  - Buspinauflistung",
			    "bus(data);                  - Bus pin list");
string REPSPXLATG	= M("xlat (a,b,y) to (1,2,3) or (4,5,6);        - Symbolpinzuordnung gatterweise",
			    "xlat (a,b,y) to (1,2,3) or (4,5,6);        - Symbol pin assignment");
string REPSPXLATP	= M("xlat ((a,1,4),(b,2,5),(y,3,6));            - Symbolpinzuordnung pinweise",
			    "xlat ((a,1,4),(b,2,5),(y,3,6));            - Symbol pin assignment");
string REPSPXLATB	= M("xlat (data.d0,data.d1,data.d2) to (7,8,9); - Buspinzuordnung",
			    "xlat (data.d0,data.d1,data.d2) to (7,8,9); - Bus pin assignment");
string REPSPPARTATT	= M("newattr \"$manufacturer\" = \"Bartels\"; - Bauteilattributzuweisung",
			    "newattr \"$manufacturer\" = \"Bartels\"; - Part attribute assignment");
string REPSPPARTUATT	= M("newattr \"$val\" = \"!unique!\"; - Nur Symbole mit gleichem Wert zusammenpacken",
			    "newattr \"$val\" = \"!unique!\"; - Package only same value symbols to one part");
string REPSPPINATT	= M("newattr \"$pintype\" = \"out\" to (3,6); - Attributzuweisung an "+"Layoutbauteilpins",
			    "newattr \"$pintype\" = \"out\" to (3,6); - Layout part pin attribute assignment");
string REPSPPINTYP	= M("         Pintypen: \"in\",\"out\",\"bidi\",\"anl\",\"sup\"",
			    "         Pin types: \"in\",\"out\",\"bidi\",\"anl\",\"sup\"");
string REPSPNETASS	= M("net \"gnd\" : (10);       - Layoutbauteilpin Festnetzzuweisung",
			    "net \"gnd\" : (10);       - Layout part pin net assignment");
string REPSPNETAASS	= M("net \"$gnd\" : (10);      - Layoutbauteilpin Attributnetzzuweisung",
			    "net \"$gnd\" : (10);      - Layout part pin attribute net assignment");
string REPSPNETINT	= M("net internal : (10,11); - Layoutbauteilpins verbinden",
			    "net internal : (10,11); - Connect layout part pins");
string REPSPSWAPG	= M("swap ((1,2,3),(4,5,6);      - Gattertausch = swap (((1),(2),(3)),((4),(5),(6)))",
			    "swap ((1,2,3),(4,5,6);      - Gate swap = swap(((1),(2),(3)),((4),(5),(6)))");
string REPSPSWAPP	= M("swap (((1,2)));             - Pintausch",
			    "swap (((1,2)));             - Pin swap");
string REPSPSWAPGP	= M("swap (((1,2),3),((4,5),6)); - Pin-/Gattertausch",
			    "swap (((1,2),3),((4,5),6)); - Pin/gate swap/");
string REPSPSWAPPI	= M("swap internal (((1,2)));    - Auf Bauteil beschraenkter swap",
			    "swap internal (((1,2)));    - Part restricted swap");
string REPSPNETATTD	= M("netattr mindist \"$val\" : (x);   - Netzmindestabstand aus Attribut ableiten",
			    "netattr mindist \"$val\" : (x);   - Derive net min. distance from attribute");
string REPSPNETATTDF	= M("netattr mindist \"0.5\" : (x);    - Netzmindestabstand fest vorgeben",
			    "netattr mindist \"0.5\" : (x);    - Set net min. distance to given value");
string REPSPNETATTP	= M("netattr priority \"$val\" : (x);  - Netzprioritaet aus Attribut ableiten",
			    "netattr priority \"$val\" : (x);  - Derive net priority from attribute");
string REPSPNETATTPF	= M("netattr priority \"5\" : (x);     - Netzprioritaet fest vorgeben",
			    "netattr priority \"5\" : (x);     - Set net priority to given value");
string REPSPNETATTW	= M("netattr routwidth \"$val\" : (x); - Netzroutingbreite aus Attribut ableiten",
			    "netattr routwidth \"$val\" : (x); - Derive net route width from attribute");
string REPSPNETATTWF	= M("netattr routwidth \"0.5\" : (x);  - Netzroutingbreite fest vorgeben",
			    "netattr routwidth \"0.5\" : (x);  - Set net route width to given value");
string REPSPNETATTV	= M("netattr powwidth \"$val\" : (x);  - Netzversorgungsbreite aus Attribut ableiten",
			    "netattr powwidth \"$val\" : (x);  - Derive net power route width from attribute");
string REPSPNETATTVF	= M("netattr powwidth \"0.5\" : (x);   - Netzversorgungsbreite fest vorgeben",
			    "netattr powwidth \"0.5\" : (x);   - Set net power route width to given value");
string REPSPNETATTA	= M("netattr \"$nettype\" \"$nettype\" : (x); - Beliebiges Netzattribut setzen",
			    "netattr \"$nettype\" \"$nettype\" : (x); - Set net attribute");
string REPSPNETATTF	= M("netattr \"$nettype\" \"a\" : (x);   - Beliebiges Netzattribut fest vorgeben",
			    "netattr \"$nettype\" \"a\" : (x);   - Set net attribute to given value");
string REPSPBLOCK	= M("call blockname;           - Referenz auf hierarchische Schaltplanbloecke",
			    "call blockname;           - Reference to hierarchical SCM block");
string REPSPCOMM	= M("comment = \"DSP 32 Bit\";   - Definitionskommentar",
			    "comment = \"DSP 32 Bit\";   - Definition comment");
string ERRMACLOAD	= M("Fehler beim Laden von Symbol '%s' aus '%s'!",
			    "Error loading symbol '%s' in '%s'!");
string ERRDELLSCM	= M("Altes Element '%s'/'%s' ist schreibgeschuetzt!",
			    "Old element '%s'/'%s' is write-protected!");
string ERRPINNASS	= M("Pin '%s'/'%s' hat keine Zuweisung!",
			    "Pin '%s'/'%s' isn't assigned!");
string ERRTEMPELEM	= M("Temporaerelement '%s'/'%s' konnte nicht angelegt werden!",
			    "Couldn't create temporary element '%s'/'%s'!");
string ERRNODEF		= M("Definition '%s' in Bibliothek '%s' nicht gefunden!",
			    "Logical definition '%s' not found in library '%s'!");
string ERRNOPICK	= M("Kein Pickelement gefunden!",
			    "No pick element found!");
string FMTGATENAME	= M("g%d","g%d");

// INI file parameter name definitions
#define PAR_LINELEN	"LLCOLS_SCM"	// Logical library edit columns
#define PAR_MAXEDIT	"LLMAXLEN_SCM"	// Max. logical library edit length
#define PAR_LLJOB	"LLJOBEDIT_SCM"	// Logical library job edit only
#define PAR_LLPINTS	"LLPINTS_SCM"	// Pin text size
#define PAR_NEWATTRL	"NEWATTRL_SCM"	// newattr list
#define PAR_ASSFEXT	"PINASSFEXT_SCM"// Pin assignment file name extension
#define PAR_PINDCNT	"LLPINDCNT_SCM"	// Pin edit dialog items count
#define PAR_PINWIDTH	"LLPINDW_SCM"	// Pin edit dialog item width
#define PAR_DISPPLNAME	"DISPPLNAME_SCM"// $plname part display flag

// User Language program names
#define UL_HISTORY	"history"	// ULP: File History Call

// Global variable definitions
int LINELEN	= bae_iniintval(PAR_LINELEN,40);
					// Logical library edit columns
int MAXEDIT	= bae_iniintval(PAR_MAXEDIT,60000);
					// Max. logical library edit length
int JOBDEST	= bae_iniintval(PAR_LLJOB,0);
					// Logical library job dest. flag
double PINTSIZE	= bae_inidblval(PAR_LLPINTS,0.002);
					// Pin text size
string ASSEXT = bae_inistrval(PAR_ASSFEXT,".csv")
					/* Pin assignments file name ext. */;
int PINDCNT = bae_iniintval(PAR_PINDCNT,12)
					/* Max. pin list length */;
double PINDWIDTH = bae_inidblval(PAR_PINWIDTH,5.0)
					/* Pin edit field width */;
double BUTXSTEP	= bae_swconfig(3)==2 ? 2.0 : 0.0
					/* Menu action button x spacing */;
#define RS_LLEDIT	"logledit"	// Logical library edit flag pred.
#define RS_LLCACOLOR	"logledit_color"// Log. lib. contact area color pred.
#define RS_LLPICKM	"logledit_pickm"// Log. lib. pick mode pred.
#define EBOXHEIGHT	16.0		// Edit box height
#define HBOXHEIGHT	3.0		// Help box height
#define SYMSPACE	0.010		// Symbol Placement spacing
#define LOGLFNAME	"logledit.ddb"	// Logical library edit DDB file name
string loglfname = scmlibdir()+LOGLFNAME;
string HLPDOC	= M("bm7_11_de.htm","bm7_11_en.htm")/* Help document name */;
#define HLPDIR		"baedoc"	// Help documents directory name

// SQL command definitions
#define L_CREATE	"create table lledit_data (plan string,library string);"
#define L_DELETE	"delete from lledit_data where plan=%s;"
#define L_INSERT	"insert into lledit_data values(%s,%s);"
#define L_SELECT	"select library from lledit_data where plan=%s;"
string sqlcommand			/* SQL command string */;

struct nattrdes {			// Attribute descriptor
	string attname			/* Attribute name */;
	string attval			/* Attribute default value */;
	}				/* Attribute list */;
struct nattrdes defnattrl[]	= {	// Default newattr list
	{ "$comment"      , "" },
	{ "$commentde"    , "" },
	{ "$manufacturer" , "" },
	{ "$type"         , "$LLNAME" }
	};
struct nattrdes nattrl[]		/* newattr list */;
int nattrn				/* newattr count */;
string logldef				/* Definition string */;
string defhead				/* Definition head part */;
string defbody				/* Definition body */;
string curstr				/* Current scan string */;
string curplname = ""			/* Current part macro name */;
int curplnflag = 0			/* Current part name attribute flag */;
int gpflag = 0				/* gpname attribute flag */;
int pinscan = 0				/* Pin command scan flag */;
int pincnt = 0				/* Pin count */;
struct pindes {				// Pin placement descriptor
	double x, y			/* Pin position */;
	double r			/* Pin rotation angle */;
	string name			/* Pin name */;
	int proc			/* Pin processed flag */;
	} lpinl[],spinl[]		/* Pin lists */;
int lpinn = 0				/* Layout pin count */;
int spinn = 0				/* Schematic pin count */;
double symw, symh			/* Symbol size */;
double symxoff, symyoff			/* Symbol origin offset */;
double symlx, symly			/* Symbol lower boundary */;
struct xlatdes {			// xlat descriptor
	string pl[]			/* Part pin list */;
	string name			/* Pin name */;
	} xlatl[]			/* xlat pin list */;
int xlatn = 0				/* xlat pin count */;
int gaten = 0				/* Gate count */;
STRINGS pinl				/* Pin list */;
int pinn = 0				/* Pin count */;
STRINGS macl				/* Current part macro list */;
int macn = 0				/* Current part macro count */;
int macidx = (-1)			/* Makro field dialog box item idx. */;
string jobfname = bae_planfname()	/* Project file name */;
int ddbclass = bae_planddbclass()	/* Schematic plan DDB class */;
string defloglname			/* Default logical lib. file name */;

// Main program
void main()
{
	index C_FIGURE fig		/* Figure list index */;
	index C_NREF nref		/* Named reference index */;
	string deflname			/* Definition library file name */;
	string defename			/* Definition element name */;
	string rlname			/* Requested logical library name */;
	double x, y			/* Pick position */;
	int pickmode			/* Element pick mode */;
	int boxccnt			/* Edit box character count */;
	int col				/* Color buffer */;
	/* Get default logical library name */
	defloglname=strgetvarfilename(scm_defloglname());
	catext(defloglname,DDBEXT);
	// Get the newattr list
	for (nattrn=0;nattrn<1000;nattrn++) {
		if ((nattrl[nattrn].attname=bae_inistrval(
		 bae_inifieldvarname(PAR_NEWATTRL,nattrn,0),""))=="") {
			// Check if list defined at all
			if (nattrn==0) {
				// Use default newattr list
				nattrl=defnattrl;
				nattrn=arylength(nattrl);
				}
			break;
			}
		nattrl[nattrn].attval=bae_inistrval(
		 bae_inifieldvarname(PAR_NEWATTRL,nattrn,1),"");
		}
	// Calculate the edit box character count
	if (LINELEN<0) {
		LINELEN=-LINELEN;
		}
	else {
		boxccnt=floor((90.0-DIAL_LEFTMARG-DIAL_RIGHTEMARG-
		 2.0*bae_dialgettextlen(PA_FNTFIX," "))/
		 (bae_dialgettextlen(PA_FNTFIX,"  ")-
		  bae_dialgettextlen(PA_FNTFIX," ")));
		if (boxccnt>LINELEN)
			LINELEN=boxccnt;
		}
	// Check if special logical library edit plan
	if (cap_rulequery(RS_OCPLAN,0,RS_SCMSUBJ,RS_LLEDIT,"?d",col)>0 &&
	 col>0 && (deflname=getdstlibname())!="" &&
	 con_getlogpart(deflname,bae_planename(),LINELEN,logldef)==0) {
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		// Restore contact area color
		if (cap_rulequery(
		 RS_OCPLAN,0,RS_SCMSUBJ,RS_LLCACOLOR,"?d",col)>0)
			bae_setcolor(7,col);
		else
			bae_setcolor(7,0);
		if (cap_rulequery(
		 RS_OCPLAN,0,RS_SCMSUBJ,RS_LLPICKM,"?d",pickmode)<1)
			scm_getintpar(5,pickmode);
		defename=bae_planename();
		// Get the mouse position
		bae_wsmouse(x,y,0);
		bae_clriactqueue();
		bae_storemouseiact(1,x,y,0,LMB);
		if (scm_pickelem(fig,C_FIGTEXT)!=0 ||
		 (fig.NAME!=UPRATXTLEFT && fig.NAME!=UPRATXTRIGHT)) {
			// Strip xlat command from definition
			stripxlat();
			// Scan pin assignments
			forall (fig where fig.TYP==C_FIGNREF) {
				// Buffer symbol name for scan error messages
				curstr=fig.NAME;
				// Check if first gate
				if (gaten==0) {
					// Document schematic pins
					logldef+="   xlat(";
					if (cap_scanfelem(fig,0.0,0.0,0.0,1,
					 macfunc,NULL,NULL,NULL)!=0)
						error_scan();
					logldef=logldef+") to\n     (";
					}
				else {
					logldef=logldef+") or\n     (";
					}
				// Document layout part pins
				pincnt=0;
				if (cap_scanfelem(fig,0.0,0.0,0.0,1,
				 pmacfunc,NULL,NULL,NULL)!=0)
					error_scan();
				gaten++;
				}
			logldef+=");\n    }";
			// Compile new definition
			switch (con_compileloglib(deflname,NULL,logldef)) {
				case (-1) :
				bae_msgbox(2,UPRECONT,"");
				exit(0);
				case (-2) :
				bae_msgbox(1,UPRWCONT,"");
				default :
				screenredraw();
				}
			}
		// Save logical library edit element
		call(MNU_SCMSAVELEM);
		scm_setintpar(5,pickmode);
		// Reload previous plan
		bae_clriactqueue();
		bae_storetextiact(1,"c");
		ulsystem(UL_HISTORY,0);
		// Edit definition
		logledit(deflname,defename,defename,fig,1);
		}
	// Check if symbol edit
	else if (ddbclass==DDBCLSSYM || ddbclass==DDBCLSLAB) {
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		// Edit/create definition for current symbol
		logledit(jobfname,bae_planename(),bae_planename(),fig,0);
		}
	else if (ddbclass==DDBCLSCM) {
		// Pick symbol
		bae_promptdialog(UPRPICKSYM);
		if (scm_pickelem(fig,C_FIGNREF)!=0)
			// No pick element found
			error(ERRNOPICK);
		// Get named reference index
		nref=fig.NREF;
		// Get the requested library part name
		if (nref.MACRO.TAGSYM) {
			// Use default logical library name for tag symbol
			rlname=nref.MACRO.NAME;
			}
		else {
		    if (cap_getpartattrib(nref.NAME,"$rlname",rlname)!=0 ||
		     rlname[0]=='\0')
			// Get the requested library part name extension
			if (cap_getpartattrib(nref.NAME,"$rlext",rlname)!=0 ||
			 rlname[0]=='\0') {
				// Assume default logical library name
				rlname=nref.MACRO.NAME;
				}
			else {
				/* Check extended symbol macro name length */
				if ((strlen(nref.MACRO.NAME)+
				 strlen(rlname)+1)<=MAXKEYLEN)
					/* Add requested extension */
					rlname=nref.MACRO.NAME+"_"+rlname;
				else
					// Assume default logical library name
					rlname=nref.MACRO.NAME;
				}
		    }
		// Convert name to lower case
		strlower(rlname);
		// Save current state for undo
		bae_callmenu(MNU_BAESAVESTATE);
		// Edit/create definition
		logledit(jobfname,rlname,nref.MACRO.NAME,fig,0);
		}
	else {
		// Select the source DDB file
		deflname=defloglname;
		if (bae_askddbfname(deflname,1,""))
			// Abort
			error_abort();
		// Select the element name
		if (bae_askddbename(defename,deflname,DDBCLLLIB,""))
			// Abort
			error_abort();
		// Edit/create definition
		logledit(deflname,defename,defename,fig,0);
		}
}

void logledit(
 string fname,string ename,string symname,index C_FIGURE fig,int autodest)
/*
// Edit/create loglib definition
// Parameters :
//	string fname		: File name
//	string ename		: Element name
//	string symname		: Symbol macro name
//	index C_FIGURE fig	: Symbol figure list element
//	int autodest		: Automatically set destination
*/
{
	index C_FIGURE nfig		/* Named ref. figure list index */;
	string docdname			/* Document directoy name */;
	string deflname			/* Definition library file name */;
	string libname			/* Library file name */;
	string xlatbuf			/* xlat command buffer */;
	string msg			/* Message string */;
	string helpstr			/* Help display string */;
	int busflag			/* Bus pin flag */;
	int newfile	= 1		/* New source file flag */;
	int res				/* Result buffer */;
	double cx, cy			/* Current dialog coord. values */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	int edtidx			/* Edit field dialog box item idx. */;
	int repflag	= 1		/* Input repeat flag */;
	int i				/* Loop control variable */;
	// Get default library name
	libname=defloglname;
	// Try to load definition from job file
	if (con_getlogpart(fname,ename,LINELEN,logldef)==0) {
		// Log. part definition found
		deflname=fname;
		newfile=0;
		}
	// Try to load definition from library file
	else if (con_getlogpart(libname,ename,LINELEN,logldef)==0) {
		// Log. part definition found
		deflname=libname;
		newfile=0;
		}
	else {
		// Check if other file requested
		sprintf(msg,UPROFILE,ename);
		while (bae_msgboxverify(msg,"")) {
			// Select the source DDB file
			if (bae_askddbfname(deflname,0,UPRLFILE))
				break;
			// Try to load definition from source file
			if (con_getlogpart(deflname,ename,
			 LINELEN,logldef)==0) {
				// Log. part definition found
				newfile=0;
				break;
				}
			sprintf(msg,UPRNFILE,ename);
			}
		// Check if template creation
		if (newfile) {
		    if (ddbclass==DDBCLSLAB ||
		     (ddbclass==DDBCLSCM && fig.NREF.MACRO.CLASS==DDBCLSLAB)) {
			// Create label definition template
			sprintf(logldef,
			 "part \"%s\" : virtual\n{\n    pin(\"#\");\n}",
			 ename);
			}
		    else {
			// Get the layout part macro name
			getlaypartname(symname,ename,fig);
			sprintf(logldef,"part \"%s\" : ",ename);
			// Create symbol definition template
			if (macl[0]=="virtual") {
				logldef+="virtual";
				}
			else {
				if (curplnflag)
					logldef+="default ";
				logldef+="\""+macl[0]+"\"";
				for (i=1;i<macn;i++)
					logldef+=","+"\""+macl[i]+"\"";
				}
			logldef+="\n{\n";
			pincnt=0;
			if (ddbclass==DDBCLSCM) {
				pinscan=1;
				if (cap_scanfelem(fig,0.0,0.0,0.0,1,
				 macfunc,NULL,NULL,gptextfunc)!=0)
					error_scan();
				if (pincnt!=0)
					logldef=logldef+");\n";
				pinscan=0;
				}
			else if (ddbclass==DDBCLSSYM) {
				forall (nfig where nfig.TYP==C_FIGNREF) {
					spinl[spinn].name=nfig.NAME;
					spinn++;
					// Query the bus status
					if (cap_rulequery(RS_OCFIG,nfig,
					 RS_SCMSUBJ,RS_AUTOBUS,"?d",
					 busflag)>=1 && busflag)
						continue;
					pincnt++;
					if (pincnt!=1)
						logldef=logldef+",";
					else
						logldef=logldef+"    pin(";
					if (pincnt%10==0)
						logldef=logldef+"\n    ";
					logldef=logldef+"\""+nfig.NAME+"\"";
					}
				if (pincnt!=0)
					logldef=logldef+");\n";
				pincnt=0;
				forall (nfig where nfig.TYP==C_FIGNREF) {
					// Query the bus status
					if (cap_rulequery(RS_OCFIG,nfig,
					 RS_SCMSUBJ,RS_AUTOBUS,"?d",
					 busflag)<1 || !busflag)
						continue;
					pincnt++;
					if (pincnt!=1)
						logldef=logldef+",";
					else
						logldef=logldef+"    bus(";
					if (pincnt%10==0)
						logldef=logldef+"\n    ";
					logldef=logldef+"\""+nfig.NAME+"\"";
					}
				if (pincnt!=0)
					logldef=logldef+");\n";
				forall (nfig where nfig.TYP==C_FIGTEXT &&
				 nfig.NAME=="$gp")
					gpflag=1;
				}
			if (lpinn>0) {
				if (lpinn<spinn) {
					sprintf(msg,UPRLPINCNT,macl[0]);
					if (bae_msgboxverify(msg,""))
						error_abort();
					}
				if (spinn==1 && gpflag) {
					logldef=logldef+
					 "    xlat(\""+spinl[0].name+"\")";
					for (pincnt=0;pincnt<lpinn;pincnt++)
						logldef+=
						 ((pincnt==0) ? " to" : " or")+
						 "\n        (\""+
						 lpinl[pincnt].name+"\")";
					logldef+=";\n";
					}
				else {
					logldef=logldef+
					 "    /* Layout pins:\n       ";
					for (pincnt=1;pincnt<=lpinn;pincnt++) {
						if (pincnt!=1)
							logldef=logldef+",";
						if (pincnt%10==0)
							logldef=logldef+
							 "\n       ";
						logldef=logldef+"\""+
						 lpinl[pincnt-1].name+"\"";
						}
					logldef=logldef+"\n    */\n";
					}
				}
			for (i=0;i<nattrn;i++) {
				logldef=logldef+
				 "    newattr \""+nattrl[i].attname+"\" = \"";
				switch (nattrl[i].attval) {
					case "$llname" :
					logldef=logldef+ename;
					break;
					case "$LLNAME" :
					strupper(ename);
					logldef=logldef+ename;
					strlower(ename);
					break;
					default :
					logldef=logldef+nattrl[i].attval;
					}
				logldef=logldef+"\";\n";
				}
			logldef=logldef+"    }";
			deflname=fname;
			}
		    }
		}
	// Query the destination
	if (autodest) {
		deflname=fname;
		}
	else if (fname!=libname) {
		// Check if job is fix destination
		if (JOBDEST) {
			deflname=fname;
			}
		else {
			bae_promptdialog(UPRDEST);
			switch (bae_askmenu(4,
			 UPRDEFLIB,UPRJOB,UPROTHER,UPRABORT)) {
				case 0 :
				deflname=defloglname;
				break;
				case 1 :
				deflname=fname;
				break;
				case 2 :
				// Select the destination DDB file
				if (bae_askddbfname(deflname,0,UPRDFILE))
					// Abort
					error_abort();
				break;
				default :
				error_abort();
				}
			}
		}
	else {
		deflname=libname;
		}
	// Add ddb-file name extension
	catext(deflname,DDBEXT);
	if (bae_swconfig(0)==BAE_HighEnd && !newfile &&
	 bae_iniintval(PAR_DISPPLNAME,0)) {
		synparsestring(logldef);
		if (curplname!="") {
			// Search layout part macro file
			libname=jobfname;
			if (existddbelem(libname,DDBCLLPRT,curplname)!=1) {
				libname=defloglname;
				if (existddbelem(
				 libname,DDBCLLPRT,curplname)!=1)
					libname="";
				}
			if (libname!="") {
				// Build the load part macro request message
				sprintf(msg,"%d %s\"%s",MSGID_LLPRTMAC,
				 libname,curplname);
				// Send the load part macro request message
				bae_sendmsg(msg,0);
				}
			}
		}
	// Edit and compile loglib definition
	do {
	    // Check if dialog box support
	    if (bae_dialclr()) {
		// Get the new definition
		if ((logldef=bae_readedittext(
		 UPREDIT,logldef,MAXEDIT))=="" || logldef==UINPOPABORT)
			error_abort();
		}
	    else {
		// Build the help string
		helpstr=REPSPPARTF+"\n"+REPSPPARTD+"\n"+REPSPPARTA+"\n"+
		 REPSPPARTM+"\n"+REPSPPARTS+"\n"+REPSPPARTV+"\n"+REPSPPARTC+
		 "\n"+REPSPPARTMC+"\n"+REPSPPINS+"\n"+REPSPBUSSES+"\n"+
		 REPSPXLATG+"\n"+REPSPXLATP+"\n"+REPSPXLATB+"\n"+REPSPPARTATT+
		 "\n"+REPSPPARTUATT+"\n"+REPSPPINATT+"\n"+REPSPPINTYP+"\n"+
		 REPSPNETASS+"\n"+REPSPNETAASS+"\n"+REPSPNETINT+"\n"+REPSPSWAPG+
		 "\n"+REPSPSWAPP+"\n"+REPSPSWAPGP+"\n"+REPSPSWAPPI+"\n"+
		 REPSPNETATTD+"\n"+REPSPNETATTDF+"\n"+REPSPNETATTP+"\n"+
		 REPSPNETATTPF+"\n"+REPSPNETATTW+"\n"+REPSPNETATTWF+"\n"+
		 REPSPNETATTV+"\n"+REPSPNETATTVF+"\n"+REPSPNETATTA+"\n"+
		 REPSPNETATTF+"\n"+REPSPBLOCK+"\n"+REPSPCOMM;
		baseheight=DIAL_TOPMARG+HBOXHEIGHT+DIAL_BUTVSTEP+
		 DIAL_SEPVSTEP+0.4;
		do {
			// Build the dialog box
			bae_dialclr();
			dial_getboxsizemin(3000,dialwidth,dialheight,
			 DIAL_LEFTMARG+90.0+DIAL_RIGHTSMARG,
			 baseheight+EBOXHEIGHT,
			 DIAL_LEFTMARG+85.0+DIAL_RIGHTSMARG,baseheight+1.0);
			cy=DIAL_TOPMARG;
			// Store edit control
			edtidx=bae_dialadvcontrol(
			 PA_STR|PA_HBRDREL|PA_VBRDREL|PA_FNTFIX|PA_TAB,
			 0,0,0,0.0,0.0,0.0,logldef,MAXEDIT,DIAL_LEFTMARG,cy,
			 DIAL_RIGHTSMARG,DIAL_BOTEMARG+HBOXHEIGHT+DIAL_SEPVSTEP,
			 "");
			cy+=dialheight-baseheight;
			// Store OK button
			bae_dialaddcontrol(PA_OK,
			 0,0,0,0.0,0.0,0.0,"",0,DIAL_LEFTMARG,cy,0.0,"");
			// Store abort button
			bae_dialaddcontrol(PA_ABORT,
			 0,0,0,0.0,0.0,0.0,"",0,DIAL_LEFTMARG+5.0,cy,0.0,"");
			// Store macro list edit button
			bae_dialaddcontrol(PA_ACT,0,5,0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG+15.0,cy,0.0,UPRMACLIST);
			// Store pin assignment buttons
			cx=DIAL_LEFTMARG+30.0;
			bae_dialaddcontrol(PA_LAB,0,0,0,0.0,0.0,0.0,"",0,
			 cx,cy,0.0,UPRPINASS);
			cx+=bae_dialgettextlen(0,UPRPINASS)+BUTXSTEP;
			bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",0,
			 cx,cy,0.0,UPRIMPASS);
			cx+=bae_dialgettextlen(0,UPRIMPASS)+BUTXSTEP;
			bae_dialaddcontrol(PA_ACT,0,4,0,0.0,0.0,0.0,"",0,
			 cx,cy,0.0,UPRTABASS);
			cx+=bae_dialgettextlen(0,UPRTABASS)+BUTXSTEP;
			bae_dialaddcontrol(PA_ACT,0,2,0,0.0,0.0,0.0,"",0,
			 cx,cy,0.0,UPRGRLASS);
			cx+=bae_dialgettextlen(0,UPRGRLASS)+BUTXSTEP;
			bae_dialaddcontrol(PA_ACT,0,3,0,0.0,0.0,0.0,"",0,
			 cx,cy,0.0,UPRGRTASS);
			cy+=DIAL_BUTVSTEP;
			dial_hsep(cy);
			dial_label(0.0,cy,UPRSAMPLE);
			// Store documentation button
			bae_dialaddcontrol(PA_ACT,0,6,0,0.0,0.0,0.0,"",0,
			 DIAL_LEFTMARG,cy+2.0*DIAL_TXTVSTEP,0.0,UPRDOCU);
			bae_dialadvcontrol(
			 PA_STR|PA_FNTFIX|PA_NOEDIT|PA_HBRDREL,0,0,0,0.0,0.0,
			 0.0,helpstr,2*strlen(helpstr),DIAL_LEFTMARG+7.0,cy,
			 DIAL_RIGHTSMARG,HBOXHEIGHT,"");
			cy+=HBOXHEIGHT;
			// Display dialog box
			if (symname!=ename)
				sprintf(msg,UPRDEDITD,ename,symname);
			else
				sprintf(msg,UPRDEDIT,ename);
			bae_setintpar(16,3000);
			switch (res=bae_dialaskparams(
			 "!"+msg,0,dialwidth,cy+0.4)) {
				// Done
				case 0 :
				bae_dialgetdata(edtidx,0,0.0,logldef);
				repflag=0;
				break;
				// Import pin assignment
				case 1 :
				bae_dialgetdata(edtidx,0,0.0,logldef);
				// Remove part close brace
				i=strlen(logldef)-1;
				while (i>0 && logldef[i]!='}')
					i--;
				if (i>=0 && logldef[i]=='}') {
					while (i>0 && (logldef[i-1]==' ' ||
					 logldef[i-1]=='\t'))
						i--;
					logldef[i]='\0';
					}
				logldef+=pinassread()+"    }";
				break;
				// Graphical pin assignment
				case 2 :
				case 3 :
				// Table pin assignment
				case 4 :
				bae_dialgetdata(edtidx,0,0.0,logldef);
				verifysave();
				curplname="";
				gaten=pinn=xlatn=0;
				// Compile new definition
				switch (con_compileloglib(
				 deflname,NULL,logldef)) {
					case (-1) :
					bae_msgbox(2,UPRECONT,"");
					continue;
					case (-2) :
					bae_msgbox(1,UPRWCONT,"");
					default :
					screenredraw();
					}
				synparsestring(logldef);
				if (res==4) {
					// Strip xlat command from definition
					if ((xlatbuf=pinasstable(
					 ename,symname,curplname))!="") {
						stripxlat();
						logldef+=xlatbuf+"    }";
						}
					}
				else {
					pinassedit(deflname,ename,symname,
					 curplname,res==3 ? 1 : 0);
					}
				break;
				// Edit macro list
				case 5 :
				// Compile new definition(s)
				switch (con_compileloglib(
				 deflname,NULL,logldef)) {
					case (-1) :
					bae_msgbox(2,UPRECONT,"");
					continue;
					case (-2) :
					bae_msgbox(1,UPRWCONT,"");
					default :
					screenredraw();
					}
				headedit(deflname,symname,ename);
				break;
				// Display manual
				case 6 :
				// Build the directory path name
				docdname=bae_progdir();
				for (i=strlen(docdname)-2;i>=0;i--)
					if (docdname[i]==':' ||
					 docdname[i]=='/' ||
					 docdname[i]=='\\') {
						docdname[i+1]='\0';
						break;
						}
				// Call the online help launcher
				launch("$extappl:.htm: \""+
				 docdname+HLPDIR+'\\'+HLPDOC+"\"");
				break;
				// Resize
				case (-2) :
				bae_dialgetdata(edtidx,0,0.0,logldef);
				break;
				default :
				error_abort();
				}
			}
		 while (repflag);
		}
	    // Compile new definition
	    switch (con_compileloglib(deflname,NULL,logldef)) {
		case (-1) :
		bae_msgbox(2,UPRECONT,"");
		repflag=1;
		continue;
		case (-2) :
		bae_msgbox(1,UPRWCONT,"");
		default :
		screenredraw();
		}
	    break;
	    } while (1);
	bae_prtdialog(REPDONE);
}

int macfunc(index C_MACRO macro,index C_POOL pool,int macinws,
 string refname,index C_LEVEL level,index C_LEVEL buslevel)
/*
// Pin list macro function
// Return value :
//	0 if out of workspace, 1 if inside, 2 if unknown, or (-1) on error
// Parameters :
//	index C_MACRO macro	: Macro index
//	index C_POOL pool	: Macro pool index
//	int macinws		: Macro in workspace flag
//	string refname		: Macro reference name
//	index C_LEVEL level	: Macro level
//	index C_LEVEL buslevel	: Macro bus level
*/
{
	// Check if symbol pin
	if (macro.CLASS==DDBCLSMRK && refname!="") {
		pincnt++;
		if (pincnt!=1)
			logldef=logldef+",";
		else if (pinscan)
			logldef=logldef+"    pin(";
		if (pincnt%10==0)
			logldef=logldef+"\n    ";
		logldef=logldef+"\""+refname+"\"";
		spinl[spinn].name=refname;
		spinn++;
		}
	// Continue scan
	return(1);
}

int pmacfunc(index C_MACRO macro,index C_POOL pool,int macinws,
 string refname,index C_LEVEL level,index C_LEVEL buslevel)
/*
// Pin destination list macro function
// Return value :
//	0 if out of workspace, 1 if inside, 2 if unknown, or (-1) on error
// Parameters :
//	index C_MACRO macro	: Macro index
//	index C_POOL pool	: Macro pool index
//	int macinws		: Macro in workspace flag
//	string refname		: Macro reference name
//	index C_LEVEL level	: Macro level
//	index C_LEVEL buslevel	: Macro bus level
*/
{
	index C_FIGURE fig		/* Figure list index */;
	index C_POLY poly		/* Polygon index */;
	index C_POINT p			/* Polygon point index */;
	string msg			/* Message string */;
	double x, y			/* Macro coordinates */;
	double sx, sy			/* Line start coordinates */;
	double ex, ey			/* Line end coordinates */;
	int pn	= 0			/* Point count */;
	int oldpickmode			/* Old element pick mode */;
	// Check if symbol pin
	if (macro.CLASS==DDBCLSMRK && refname!="") {
		// Check if line end at pin position
		cap_maccoords(x,y,0.0,0);
		scm_getintpar(5,oldpickmode);
		scm_setintpar(5,0);
		bae_clriactqueue();
		bae_storemouseiact(1,x,y,0,LMB);
		if (scm_pickelem(fig,C_FIGPOLYC)==0) {
			// Scan polygon end points
			poly=fig.POLY;
			forall (p of poly) {
				if (pn==0) {
					sx=p.X; sy=p.Y;
					}
				else {
					ex=p.X; ey=p.Y;
					}
				pn++;
				}
			// Get the pick destination position
			if (dist(sx,sy,x,y)<dist(ex,ey,x,y)) {
				x=ex; y=ey;
				}
			else {
				x=sx; y=sy;
				}
			}
		// Pick layout pin name text
		bae_clriactqueue();
		bae_storemouseiact(1,x,y,0,LMB);
		if (scm_pickelem(fig,C_FIGTEXT)==0) {
			pincnt++;
			if (pincnt!=1)
				logldef=logldef+",";
			if (pincnt%10==0)
				logldef=logldef+"\n    ";
			logldef=logldef+"\""+fig.NAME+"\"";
			scm_setintpar(5,oldpickmode);
			return(1);
			}
		else {
			scm_setintpar(5,oldpickmode);
			sprintf(msg,ERRPINNASS,curstr,refname);
			bae_msgbox(2,msg,"");
			exit(0);
			}
		}
	// Continue scan
	return(1);
}

void getlaypartname(string symname,string ename,index C_FIGURE fig)
/*
// Get layout part macro name
// Parameter :
//	string symname		: Symbol macro name
//	string ename		: Element name
//	index C_FIGURE fig	: Symbol figure list index
*/
{
	index C_FIGURE tfig		/* Figure list index */;
	string newpart	= ""		/* New part macro name */;
	if (ddbclass==DDBCLSSYM) {
		forall (tfig where tfig.TYP==C_FIGTEXT &&
		 tfig.NAME=="$plname") {
			curplnflag=1;
			// Query the current active default value
			if (cap_rulequery(RS_OCFIG,tfig,RS_SCMSUBJ,RS_INIVAL,
			 "?s",newpart)>0 && newpart!="") {
				macl[0]=newpart;
				macn=1;
				// Get the layout part pin list
				getlaypartpins(newpart);
				return;
				}
			}
		}
	else if (ddbclass==DDBCLSCM) {
		curplname="";
		cap_scanfelem(fig,0.0,0.0,0.0,1,NULL,NULL,NULL,pltextfunc);
		if (curplname!="") {
			macl[0]=curplname;
			macn=1;
			// Get the layout part pin list
			getlaypartpins(curplname);
			return;
			}
		}
	// Check if dialog box support
	if (bae_dialclr()) {
		// Select new part macro
		if (bae_askddbename(newpart,jobfname,DDBCLLPRT,
		 msgstring(UPRNEWPRT,convstring(jobfname,1))))
			error_abort();
		macl[0]=newpart;
		macn=1;
		// Get the layout part pin list
		getlaypartpins(newpart);
		}
	else {
		// Edit new layout part macro list
		macn=0;
		if (editlaypartlist(symname,ename) || macn==0)
			return;
		// Get the layout part pin list
		getlaypartpins(macl[0]);
		}
}

void getlaypartpins(string partname)
/*
// Get layout part pin list
// Parameter :
//	string partname		: Part macro name
*/
{
	string msg			/* Message string */;
	string pinname	= ""		/* Pin name name */;
	string fn			/* File name buffer */;
	int pinidx = 0			/* Pin index */;
	double pinx, piny		/* Pin position */;
	double pinr			/* Pin rotation */;
	int i				/* Loop control variable */;
	// Init. the pin list
	lpinn=0;
	// Check if virtual symbol
	if (partname=="virtual")
		return;
	// Get the library file name
	fn=jobfname;
	if (existddbelem(fn,DDBCLLPRT,partname)!=1)
		fn=defloglname;
	// Check if part exists
	if (existddbelem(fn,DDBCLLPRT,partname)!=1) {
		sprintf(msg,UPRNPFILE,partname);
		if (bae_msgboxverify(msg,"")) {
			if (bae_askddbfname(fn,1,""))
				// Abort
				error_abort();
			// Select the element name
			if (bae_askddbename(partname,fn,DDBCLLPRT,""))
				// Abort
				error_abort();
			}
		}
	// Scan the layout part pin list
	while (
	 ddbgetlaypartpin(fn,partname,pinidx,pinname,"",pinx,piny,pinr,0)==0) {
		for (i=lpinn;i>0;i--)
			if (numstrcmp(pinname,lpinl[i-1].name)<0)
				lpinl[i]=lpinl[i-1];
			else
				break;
		lpinl[i].x=pinx;
		lpinl[i].y=piny;
		lpinl[i].r=pinr;
		lpinl[i].name=pinname;
		lpinl[i].proc=0;
		lpinn++;
		pinidx++;
		}
	if (bae_swconfig(0)==BAE_HighEnd && bae_iniintval(PAR_DISPPLNAME,0)) {
		// Build the load part macro request message
		sprintf(msg,"%d %s\"%s",MSGID_LLPRTMAC,fn,partname);
		// Send the load part macro request message
		bae_sendmsg(msg,0);
		}
}

void getsymbolpins(string symname)
/*
// Get symbol pin list
// Parameter :
//	string symname		: Symbol macro name
*/
{
	index C_POOL pool		/* Symbol macro pool index */;
	double gridx, gridy		/* Input grid */;
	double gd			/* Grid distance value */;
	string msg			/* Message string */;
	string fn			/* File name buffer */;
	// Get the library file name
	fn=jobfname;
	if (existddbelem(fn,DDBCLSSYM,symname)!=1) {
		fn=scm_libfname();
		catext(fn,DDBEXT);
		}
	// Copy the symbol macro to edit file
	ddbcopyelem(fn,loglfname,DDBCLSSYM,symname,1);
	// Load the symbol macro
	if (cap_macload(pool,fn,symname,DDBCLSSYM)!=0) {
		sprintf(msg,ERRMACLOAD,fn,symname);
		error(msg);
		}
	// Scan the symbol pins
	spinn=0;
	if (cap_scanpool(pool,0.0,0.0,0.0,1,pinposfunc,NULL,NULL,NULL)!=0) {
		// Release the macro element
		cap_macrelease(pool);
		error_scan();
		}
	// Store the macro size
	symlx=pool.MACRO.MLX;
	symly=pool.MACRO.MLY;
	symxoff=pool.MACRO.MNX;
	symyoff=pool.MACRO.MNY;
	if (bae_getgridlock()) {
		bae_getinpgrid(gridx,gridy);
		// Shift lower boundary to ensure symbol origin grid snap
		gd=symxoff-symlx;
		symlx-= gridx!=0.0 ? (gridx*ceil(gd/gridx)-gd) : 0.0;
		gd=symyoff-symly;
		symly-= gridy!=0.0 ? (gridy*ceil(gd/gridy)-gd) : 0.0;
		}
	symw=mmceil(pool.MACRO.MUX-symlx);
	symh=mmceil(pool.MACRO.MUY-symly);
	// Release the macro element
	cap_macrelease(pool);
}

int pinposfunc(index C_MACRO macro,index C_POOL pool,int macinws,
 string refname,index C_LEVEL level,index C_LEVEL buslevel)
/*
// Pin position scan function
// Return value :
//	0 if out of workspace, 1 if inside, 2 if unknown, or (-1) on error
// Parameters :
//	index C_MACRO macro	: Macro index
//	index C_POOL pool	: Macro pool index
//	int macinws		: Macro in workspace flag
//	string refname		: Macro reference name
//	index C_LEVEL level	: Macro level
//	index C_LEVEL buslevel	: Macro bus level
*/
{
	// Check if symbol macro itself
	if (refname=="")
		return(1);
	// Store the pin position
	cap_maccoords(spinl[spinn].x,spinl[spinn].y,spinl[spinn].r,0);
	spinl[spinn].name=refname;
	spinn++;
	return(0);
}

int gptextfunc(index C_TEXT textp,double tx,double ty,double tangle,
 int mirrflag,double tsize,string tstr,int textinws,int macclass,int varattr)
/*
// Get the text characteristics
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	index C_TEXT textp	: Text index
//	double tx		: Text X coordinate
//	double ty		: Text Y coordinate
//	double tangle		: Text angle
//	int mirrflag		: Text mirror flag
//	double tsize		: Text size
//	string tstr		: Text string
//	int textinws		: Text in workspace flag
//	int macclass		: Text macro class
//	int varattr		: Text variant attribute flag
*/
{
	if (textp.STR=="$gp")
		gpflag=1;
	// Return without errors
	return(0);
}

int pltextfunc(index C_TEXT textp,double tx,double ty,double tangle,
 int mirrflag,double tsize,string tstr,int textinws,int macclass,int varattr)
/*
// Get the text characteristics
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	index C_TEXT textp	: Text index
//	double tx		: Text X coordinate
//	double ty		: Text Y coordinate
//	double tangle		: Text angle
//	int mirrflag		: Text mirror flag
//	double tsize		: Text size
//	string tstr		: Text string
//	int textinws		: Text in workspace flag
//	int macclass		: Text macro class
//	int varattr		: Text variant attribute flag
*/
{
	if (textp.STR=="$plname") {
		curplnflag=1;
		// Query the current active default value
		if (cap_rulequery(RS_OCPOOL,textp,RS_SCMSUBJ,RS_INIVAL,
		 "?s",curplname)>0 && curplname!="")
			return(-1);
		curplname="";
		}
	// Return without errors
	return(0);
}

/*________________________________________________________________*/
// Logical library file syntax

#bnf {	// Loglib entry
	libdef	: "part" ident ":" optclassspec partdef
		;
	// Part functions syntax
	optclassspec
		: "class" ident
		|
		;
	partdef	: mainflag defflag plnames partblk
		| "subpart" ident partblk
		| "virtual" virtblk
		| "logical" virtblk
		;
	mainflag
		: "mainpart"
		|
		;
	defflag	: "default"
		|
		;
	plnames : plnames "," ident
		| ident (p_plname)
		;
	partblk	: "{" partcmds "}"
		| ";"
		;
	partcmds
		: partcmds partcmd
		| partcmd
		;
	partcmd	: "bus" pinlist ";"
		| "net" netcmd ":" pinlist ";"
		| "pin" pinlist ";"
		| "swap" swapcmd swapblk ";"
		| "xlat" (p_xlat) pinlist (p_xlatpins) "to" xlats ";"
		| "xlat" (p_xlat) "(" xlatpinass ")" ";"
		| "netattr" "priority" DQSTR ":" pinlist ";"
		| "netattr" "mindist" DQSTR ":" pinlist ";"
		| "netattr" "powwidth" DQSTR ":" pinlist ";"
		| "netattr" "routwidth" DQSTR ":" pinlist ";"
		| "netattr" idstr DQSTR ":" pinlist ";"
		| "newattr" DQSTR "=" DQSTR topinlist ";"
		| "comment" "=" DQSTR ";"
		;
	virtblk	: "{" virtcmds "}"
		| ";"
		;
	virtcmds
		: virtcmds virtcmd
		| virtcmd
		;
	virtcmd	: "bus" pinlist ";"
		| "net" netcmd ":" pinlist ";"
		| "pin" pinlist ";"
		| "netattr" "priority" DQSTR ":" pinlist ";"
		| "netattr" "mindist" DQSTR ":" pinlist ";"
		| "netattr" "powwidth" DQSTR ":" pinlist ";"
		| "netattr" "routwidth" DQSTR ":" pinlist ";"
		| "netattr" idstr DQSTR ":" pinlist ";"
		| "newattr" DQSTR "=" DQSTR topinlist ";"
		| "call" ident ";"
		| "architecture" "{" synthprog "}"
		| "comment" "=" DQSTR ";"
		;
	topinlist
		: "to" pinlist
		|
		;
	netcmd	: ident
		| "internal"
		;
	swapcmd	: "internal"
		|
		;
	swapblk	: "(" groups ")"
		| "(" gates ")"
		;
	groups	: groups "," "[" gates "]"
		| "[" gates "]"
		;
	gates	: gates "," gate
		| gate
		;
	gate	: "(" gateblk ")"
		| pin
		;
	gateblk	: gateblk "," gatepin
		| gatepin
		;
	gatepin	: pinlist
		| pin
		;
	xlats	: xlats "or" pinlist (p_xlatppins)
		| pinlist (p_xlatppins)
		;
	xlatpinass : xlatpinass "," xlpindef
		| xlpindef
		;
	xlpindef : "(" pin "," xlpins ")"
		;
	xlpins	: xlpins "," pin
		| pin
		;
	synthprog
		: synthprog sprogcmd
		| sprogcmd
		;
	sprogcmd
		: "part" ident "(" preqpinlist ")" ";"
		;
	preqpinlist
		: preqpinlist "," preqpinass
		| preqpinass
		;
	preqpinass
		: pin ":" preqdest
		;
	preqdest
		: pin
		| "net" ident
		| "net" "&" ident
		| "&" ident
		;
	pinlist	: "(" (p_clrid) pins ")"
		;
	pins	: pins "," pin
		| pin
		;
	pin	: identpt (p_addpin)
		| identpt (p_addpin) "-" identpt (p_addpin) optstep
		;
	optstep	: ":" NUMBER
		|
		;
	// Identifier expression
	ident	: IDENT (p_ident)
		| NUMBER (p_ident)
		| SQSTR (p_ident)
		| DQSTR (p_ident)
		;
	identpt	: identpt idpiece
		| '/' (p_idpiece) idpiece
		| idpiece
		;
	idpiece	: IDENT (p_idpiece)
		| NUMBER (p_idpiece)
		| SQSTR (p_idpiece)
		| DQSTR (p_idpiece)
		| '.' (p_idpiece)
		;
	idstr : IDENT
		| DQSTR
		;
}	// BNF end

/*________________________________________________________________*/
// Parser action routines

int p_plname()
/*
// Receive a physical library name
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Store the physical library name
	curplname=curstr;
	return(0);
}

int p_xlat()
/*
// Receive a xlat command start
// Return value :
//	zero if done, or nonzero on error
*/
{
	pinn=0;
	// Return without errors
	return(0);
}

int p_xlatpins()
/*
// Receive a xlat pin list
// Return value :
//	zero if done, or nonzero on error
*/
{
	int i			/* Loop control variable */;
	for (i=0;i<pinn;i++)
		xlatl[i].name=pinl[i];
	xlatn=pinn;
	pinn=0;
	// Return without errors
	return(0);
}

int p_xlatppins()
/*
// Receive a xlat physical pin list
// Return value :
//	zero if done, or nonzero on error
*/
{
	int i			/* Loop control variable */;
	for (i=0;i<pinn;i++)
		xlatl[i].pl[gaten]=pinl[i];
	gaten++;
	pinn=0;
	// Return without errors
	return(0);
}

int p_addpin()
/*
// Receive a pin name
// Return value :
//	zero if done, or nonzero on error
*/
{
	pinl[pinn]=curstr;
	pinn++;
	curstr="";
	// Return without errors
	return(0);
}

int p_ident()
/*
// Receive an identifier
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Store the current scan string
	curstr=synscanstring();
	// Return without errors
	return(0);
}

int p_clrid()
/*
// Receive an identifier clear request
// Return value :
//	zero if done, or nonzero on error
*/
{
	curstr="";
	// Return without errors
	return(0);
}

int p_idpiece()
/*
// Receive an identifier piece
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Add to current scan string
	curstr+=synscanstring();
	// Return without errors
	return(0);
}

void pinassedit(
 string deflname,string ename,string symname,string plname,int mode)
/*
// Edit pin assignments
// Parameters :
//	string deflname		: Destination library name
//	string ename		: Element name
//	string symname		: Symbol name
//	string plname		: Layout part name
//	int mode		: Draw mode
*/
{
	index C_FIGURE lastfig		/* Last figure list index */;
	string msg			/* Message string */;
	string predname			/* Predicate name buffer */;
	string name			/* Name buffer */;
	double pscale			/* Pin scale factor */;
	double d			/* Current pin distance */;
	double mindist			/* Minimum found pin distance */;
	double plx, ply			/* Pins lower boundary */;
	double pux, puy			/* Pins upper boundary */;
	double pxoff, pyoff		/* Pin placement offset */;
	double sx, sy			/* Symbol pin position */;
	double tx, ty			/* Text position */;
	double tang			/* Text placement angle */;
	int maxtlen	= 2		/* Max. text length */;
	int msmmode			/* Menu/mouse mode */;
	int pickmode			/* Element pick mode */;
	int nidx			/* Neighbour index */;
	int i, j, k			/* Loop control variables */;
	// Check if gates defined
	if (gaten==0) {
		// Query gate count
		gaten=1;
		if (askint(gaten,UPRGATECNT,3) || gaten<=0)
			error_abort();
		}
	// Delete any previous logical library edit plan reminiscants
	if (ddbcheck(loglfname,DDBCLSCM,ename)==0) {
		if (ddbdelelem(loglfname,DDBCLSCM,ename)!=0) {
			sprintf(msg,ERRDELLSCM,loglfname,ename);
			error(msg);
			}
		}
	for (i=0;i<gaten;i++) {
		sprintf(name,FMTGATENAME,i+1);
		ddbdelelem(loglfname,-DDBCLSPLST,name);
		}
	// Get the symbol pin list
	getsymbolpins(symname);
	// Get the layout part pin list
	getlaypartpins(plname);
	if (lpinn<(spinn*gaten)) {
		sprintf(msg,UPRLPINCNT,plname);
		if (bae_msgboxverify(msg,""))
			error_abort();
		}
	// Create the edit symbol element
	bae_clriactqueue();
	bae_storemenuiact(1,0,LMB);
	bae_storetextiact(1,loglfname);
	bae_storetextiact(1,ename);
	if (bae_plannotsaved())
		bae_storetextiact(1,M_UINYES());
	bae_storemenuiact(1,14,LMB);
	bae_storetextiact(1,"1");
	bae_storetextiact(1,"1");
	bae_setintpar(22,1);
	call(MNU_SCMCREELEM);
	bae_setintpar(22,0);
	if (bae_planfname()!=loglfname || bae_planename()!=ename) {
		sprintf(msg,ERRTEMPELEM,loglfname,ename);
		bae_msgbox(2,msg,"");
		exit(0);
		}
	// Store destination library to database file
	sqlinit(loglfname,1);
	sqlcmd(loglfname,L_CREATE,NULL);
	sprintf(sqlcommand,L_DELETE,sql_quotestr(ename));
	sqlcmd(loglfname,sqlcommand,NULL);
	sprintf(sqlcommand,L_INSERT,sql_quotestr(ename),sql_quotestr(deflname));
	sqlcmd(loglfname,sqlcommand,NULL);
	// Assign special predicates
	rsc_assplanintpred(0,RS_LLEDIT,1,0,"");
	rsc_assplanintpred(0,RS_LLCACOLOR,bae_getcolor(7),0,"");
	scm_getintpar(5,pickmode);
	rsc_assplanintpred(0,RS_LLPICKM,pickmode,0,"");
	scm_setintpar(5,0);
	bae_setcolor(7,mode ? 0 : bae_getcolor(2));
	bae_setanglelock(0);
	sprintf(predname,RS_FCTSEQ,0);
	symw+=SYMSPACE;
	for (i=0;i<gaten;i++) {
		sprintf(name,FMTGATENAME,i+1);
		scm_storepart(name,symname,
		 i*symw+symxoff-symlx,symyoff-symly,0.0,0);
		if (cap_lastfigelem(lastfig)==0)
			rsc_assfigstrpred(
			 lastfig,predname,"#500:ml:m:mr:sl0","","");
		if (i!=0) {
			bae_clearpoints();
			bae_storepoint(i*symw-0.5*SYMSPACE,0.0,0);
			bae_storepoint(i*symw-0.5*SYMSPACE,symh,0);
			scm_storepoly(5);
			}
		}
	plx=pux=lpinl[0].x;
	ply=puy=lpinl[0].y;
	for (i=1;i<lpinn;i++) {
		if (lpinl[i].x<plx)
			plx=lpinl[i].x;
		else if (lpinl[i].x>pux)
			pux=lpinl[i].x;
		if (lpinl[i].y<ply)
			ply=lpinl[i].y;
		else if (lpinl[i].y>puy)
			puy=lpinl[i].y;
		d=dist(lpinl[i].x,lpinl[i].y,lpinl[i-1].x,lpinl[i-1].y);
		if (i==1 || (d<mindist && d!=0.0))
			mindist=d;
		if (strlen(lpinl[i].name)>maxtlen)
			maxtlen=strlen(lpinl[i].name);
		}
	bae_getintpar(3,msmmode);
	scm_storetext((msmmode&2) ? UPRTXTRIGHT : UPRTXTLEFT,
	 0.5*(gaten*symw-SYMSPACE),symh+3.0*PINTSIZE,
	 0.0,PINTSIZE,0,TEXTHCENT|TEXTFRM1);
	if (cap_lastfigelem(lastfig)==0)
		rsc_assfigstrpred(lastfig,predname,"logledit","","");
	scm_storetext((msmmode&2) ? UPRATXTRIGHT : UPRATXTLEFT,
	 0.5*(gaten*symw-SYMSPACE),symh+PINTSIZE,
	 0.0,PINTSIZE,0,TEXTHCENT|TEXTFRM1);
	if (cap_lastfigelem(lastfig)==0)
		rsc_assfigstrpred(lastfig,predname,"logledit","","");
	pscale=0.75*PINTSIZE*maxtlen/(lpinn<=1 ? 1.0 : mindist);
	pxoff=pscale*(-plx-0.5*(pux-plx))+0.5*(gaten*symw-SYMSPACE);
	pyoff=-pscale*puy-SYMSPACE;
	for (i=0;i<xlatn;i++) {
		name=xlatl[i].name;
		// Search symbol pin
		for (j=0;j<spinn;j++)
			if (spinl[j].name==name) {
				sx=spinl[j].x;
				sy=spinl[j].y;
				break;
				}
		if (j>=spinn)
			continue;
		for (j=0;j<gaten;j++) {
		    name=xlatl[i].pl[j];
		    for (k=0;k<lpinn;k++)
			if (lpinl[k].name==name) {
				lpinl[k].proc=1;
				tx=j*symw+sx+symxoff-symlx;
				ty=sy+symyoff-symly;
				if (mode) {
					// Draw assignment text on pin
					scm_storetext(name,tx,ty,0.0,PINTSIZE,
					 0,TEXTHCENT|TEXTVCENT|TEXTFRM1);
					if (cap_lastfigelem(lastfig)==0)
						rsc_assfigstrpred(lastfig,
						 predname,"#601:ml","","");
					}
				else {
					// Draw assignment line to pin
					bae_clearpoints();
					bae_storepoint(tx,ty,0);
					bae_storepoint(
					 pxoff+pscale*lpinl[k].x,
					 pyoff+pscale*lpinl[k].y,0);
					scm_storepoly(0);
					if (cap_lastfigelem(lastfig)==0)
						rsc_assfigstrpred(lastfig,
						 predname,"#508:ml:m:mr:sl0",
						 "","");
					}
				break;
				}
		    }
		}
	for (i=0;i<lpinn;i++) {
		if (lpinn==1) {
			nidx=i;
			}
		else if (i==0) {
			nidx=1;
			}
		else if (i==(lpinn-1)) {
			nidx=i-1;
			}
		else {
			nidx=
			 dist(lpinl[i].x,lpinl[i].y,lpinl[i-1].x,lpinl[i-1].y)<
			 dist(lpinl[i].x,lpinl[i].y,lpinl[i+1].x,lpinl[i+1].y)
			 ? (i-1) : (i+1) ;
			}
		// Check orientation
		if (fabs(lpinl[i].x-lpinl[nidx].x)<
		 fabs(lpinl[i].y-lpinl[nidx].y)) {
			tx=pxoff+pscale*lpinl[i].x;
			ty=pyoff+pscale*lpinl[i].y;
			tang=0.0;
			}
		else {
			tx=pxoff+pscale*lpinl[i].x,
			ty=pyoff+pscale*lpinl[i].y;
			tang=cvtangle(90.0,1,0);
			}
		if (mode) {
			scm_storetext(lpinl[i].name,tx,ty,tang,
			 PINTSIZE,0,TEXTCOMM|TEXTHCENT|TEXTVCENT|TEXTFRM1);
			if (cap_lastfigelem(lastfig)==0)
				rsc_assfigintpred(lastfig,RS_PICKDIS,1,0,"");
			if (cap_lastfigelem(lastfig)==0)
				rsc_assfigintpred(lastfig,RS_GLUED,1,0,"");
			if (!lpinl[i].proc) {
				scm_storetext(lpinl[i].name,tx,ty,tang,
				 PINTSIZE,0,TEXTHCENT|TEXTVCENT|TEXTFRM1);
				if (cap_lastfigelem(lastfig)==0)
					rsc_assfigstrpred(lastfig,predname,
					 "#601:ml","","");
				}
			}
		else {
			scm_storetext(lpinl[i].name,tx,ty,tang,
			 PINTSIZE,0,TEXTHCENT|TEXTVCENT|TEXTFRM1);
			if (cap_lastfigelem(lastfig)==0)
				rsc_assfigintpred(lastfig,RS_PICKDIS,1,0,"");
			if (cap_lastfigelem(lastfig)==0)
				rsc_assfigintpred(lastfig,RS_GLUED,1,0,"");
			}
		}
	// Store part macro text
	scm_storetext(plname,0.5*(gaten*symw-SYMSPACE),
	 -pscale*(puy-ply)-SYMSPACE-2.0*PINTSIZE,0.0,PINTSIZE,0,TEXTHCENT);
	if (cap_lastfigelem(lastfig)==0)
		rsc_assfigintpred(lastfig,RS_GLUED,1,0,"");
	// Shrink plan
	baewsshrink(1);
	exit(0);
}

string pinassread()
/*
// Read pin assignments list file
// Return value :
//	Pin assignment string
*/
{
	string infname			/* Input file name */;
	int ifh				/* Input file handle */;
	string buf			/* Result buffer */;
	string readbuf			/* Input buffer */;
	string logname			/* Pin logical name */;
	struct pintdes {		// Pin translation descriptor
		string name		/* Pin name */;
		string typ		/* Pin type */;
		string pl[]		/* Pin layout name list */;
		} pl[]			/* Pin list */;
	int pn	= 0			/* Pin name count */;
	int pln				/* Pin layout name count */;
	int ls				/* Layout pin start index */;
	STRINGS strl			/* String list */;
	int strn			/* String count */;
	int netflag			/* Net name definition flag */;
	int eofflag	= 0		/* End of file flag */;
	int i, j			/* Loop control variables */;
	// Get the pin assignment list file name
	if (bae_askfilename(infname,ASSEXT,UPRASSFILE) || infname=="")
		return("");
	// Open attribute list file
	ifh=bae_fopen(infname,0);
	// Loop for all lines
	while (!eofflag) {
		if (fgets(readbuf,1024,ifh)==0) {
			// Split line into comma-separated strings
			strn=splitstring(readbuf,strl,",");
			while (strn>0 && strl[strn-1]=="")
				strn--;
			netflag= isupper(strl[0][0]) ? 1 : 0 ;
			ls=(netflag || isdigit(strl[1][0])) ? 1 : 2 ;
			}
		else {
			eofflag=1;
			}
		// Flush pending gate pins
		if ((eofflag || strn<2 || (strn-ls)!=pln) && pn>0) {
			buf+="    xlat";
			for (i=0;i<pn;i++)
				buf+=(i==0 ? "(\"" : ",\"")+pl[i].name+"\"";
			for (i=0;i<pln;i++) {
				buf+=(i==0 ? ")\n     to " : ")\n     or ");
				for (j=0;j<pn;j++)
					buf+=(j==0 ?
					 "(\"" : ",\"")+pl[j].pl[i]+"\"";
				}
			buf+=");\n";
			for (i=0;i<pn;i++)
				if (pl[i].typ!="") {
					buf+="    newattr \"$pintype\" = \""+
					 pl[i].typ+"\" to ";
					for (j=0;j<pln;j++)
						buf+=(j==0 ? "(\"" : ",\"")+
						 pl[i].pl[j]+"\"";
					buf+=");\n";
					}
			pln=0;
			pn=0;
			}
		if (strn<2 || eofflag)
			// Ignore empty input line
			continue;
		// Get the logical pin name
		logname=strl[0];
		strlower(logname);
		// Check if net name definition
		if (netflag) {
			buf+="    net \""+logname+"\" : ";
			for (i=1;i<strn;i++) {
				strlower(strl[i]);
				buf+=(i==1 ? "(\"" : ",\"")+strl[i]+"\"";
				}
			buf+=");\n";
			}
		else {
			// Store pin
			pl[pn].name=logname;
			pl[pn].typ= ls==1 ? "" : strl[1];
			strlower(pl[pn].typ);
			for (i=ls;i<strn;i++) {
				strlower(strl[i]);
				pl[pn].pl[i-ls]=strl[i];
				}
			pln=strn-ls;
			pn++;
			}
		}
	// Close the file
	fclose(ifh);
	return(buf);
}

string pinasstable(string ename,string symname,string plname)
/*
// Perform pin assignments with table dialog box
// Parameters :
//	string ename		: Element name
//	string symname		: Symbol name
//	string plname		: Layout part name
// Return value :
//	Pin assignment string
*/
{
	string buf			/* Result buffer */;
	string lpinlist = ""		/* Layout pin list string */;
	string msg			/* Message buffer */;
	double cy			/* Current y value */;
	double curlen			/* Current symbol pin length */;
	double maxlen	= 0.0		/* Max. symbol pin length */;
	int lpidxl[][]			/* Layout pin index lists */;
	int mlsidx	= 0		/* Menu attr. list start idx. */;
	int menuidx			/* Menu item index */;
	int repflag	= 1		/* Repeat flag */;
	double lpinrows			/* Layout pin list estimates rows */;
	int i, j			/* Loop control variables */;
	// Check for dialog support
	if (bae_dialclr())
		return("");
	// Check if gates defined
	if (gaten==0) {
		// Query gate count
		gaten=1;
		if (askint(gaten,UPRGATECNT,3) || gaten<=0)
			error_abort();
		// Get the symbol pin list
		getsymbolpins(symname);
		xlatn=spinn;
		for (i=0;i<xlatn;i++) {
			xlatl[i].name=spinl[i].name;
			for (j=0;j<gaten;j++)
				xlatl[i].pl[j]="";
			}
		}
	// Get schematic pin field length
	for (i=0;i<xlatn;i++)
		if ((curlen=bae_dialgettextlen(0,xlatl[i].name))>maxlen)
			maxlen=curlen;
	// Get the layout part pin list
	getlaypartpins(plname);
	for (i=0;i<lpinn;i++)
		lpinlist+=lpinl[i].name+"\n";
	maxlen+=2.0;
	do {
		bae_dialclr();
		cy=DIAL_TOPMARG;
		// Create the dialog box controls
		// Build the attribute table menu
		for (menuidx=0;menuidx<PINDCNT &&
		 (menuidx+mlsidx)<xlatn;menuidx++) {
			// Store symbol pin name
			dial_label(0.0,cy,xlatl[menuidx+mlsidx].name);
			dial_label(maxlen-1.0,cy,UPRPINASSS);
			for (i=0;i<gaten;i++)
				// Store edit field
				lpidxl[menuidx][i]=bae_dialaddcontrol(
				 PA_STR|PA_CHKNAME,0,0,0,0.0,0.0,0.0,
				 xlatl[menuidx+mlsidx].pl[i],MAXKEYLEN,
				 DIAL_LEFTMARG+maxlen+i*(PINDWIDTH+1.0),cy,
				 PINDWIDTH,"");
			cy+=DIAL_CTRVSTEP;
			}
		if ((curlen=(maxlen+gaten*(PINDWIDTH+1.0)-1.0))<25.0)
			curlen=25.0;
		lpinrows=0.5*(lpinn-2.0*(DIAL_BUTVSTEP+2.0*DIAL_SEPVSTEP)+1);
		if (menuidx<PINDCNT && menuidx<lpinrows)
			cy+=DIAL_CTRVSTEP*
			 ((lpinrows<PINDCNT ? lpinrows : PINDCNT)-menuidx);
		// Store the OK and abort button
		bae_dialaddcontrol(PA_HSEP,0,0,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy,curlen+1.0,"");
		cy+=DIAL_SEPVSTEP;
		dial_okabort(cy);
		bae_dialaddcontrol(PA_ACT|(mlsidx>0 ? 0 : PA_GRAYED),0,1,0,0.0,
		 0.0,0.0,"",0,DIAL_LEFTMARG+15.0,cy-1.6,0.0,UPRPREVDIAL);
		bae_dialaddcontrol(PA_ACT|((mlsidx+PINDCNT)<xlatn ? 0 :
		 PA_GRAYED),0,2,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG+17.0,cy-1.6,0.0,UPRNEXTDIAL);
		sprintf(msg,UPRPINASSN,ename);
		bae_dialadvcontrol(PA_VSEP,0,0,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG+curlen+1.0,DIAL_TOPMARG,0.0,cy-DIAL_SEPVSTEP,"");
		bae_dialadvcontrol(PA_STR|PA_NOEDIT,0,0,0,0.0,0.0,0.0,lpinlist,
		 2*strlen(lpinlist),DIAL_LEFTMARG+curlen+2.0,DIAL_TOPMARG,
		 10.0,cy-DIAL_SEPVSTEP-DIAL_TXTVSTEP,"");
		bae_dialaddcontrol(PA_LAB,0,0,0,0.0,0.0,0.0,"",0,DIAL_LEFTMARG+
		 curlen+2.0,cy-DIAL_TXTVSTEP-DIAL_SEPVSTEP,0.0,plname);
		// Call the dialog function
		bae_setintpar(16,3006);
		switch (bae_dialaskparams(msg,0,
		 DIAL_LEFTMARG+curlen+12.0+DIAL_RIGHTSMARG,cy)) {
			// Done
			case 0 :
			repflag=0;
			break;
			// Previous pin list
			case 1 :
			// Fetch current xlat fields
			for (menuidx=0;menuidx<PINDCNT &&
			 (menuidx+mlsidx)<xlatn;menuidx++)
				for (i=0;i<gaten;i++)
					bae_dialgetdata(lpidxl[menuidx][i],
					 0,0.0,xlatl[menuidx+mlsidx].pl[i]);
			mlsidx-=PINDCNT;
			break;
			// Next pin list
			case 2 :
			// Fetch current xlat fields
			for (menuidx=0;menuidx<PINDCNT &&
			 (menuidx+mlsidx)<xlatn;menuidx++)
				for (i=0;i<gaten;i++)
					bae_dialgetdata(lpidxl[menuidx][i],
					 0,0.0,xlatl[menuidx+mlsidx].pl[i]);
			mlsidx+=PINDCNT;
			break;
			// Fail/abort
			case (-1) :
			default :
			error_abort();
			}
	    }
	 // Stop if no further repeat requests
	 while (repflag);
	// Fetch current xlat fields
	for (menuidx=0;menuidx<PINDCNT && (menuidx+mlsidx)<xlatn;menuidx++)
		for (i=0;i<gaten;i++)
			bae_dialgetdata(lpidxl[menuidx][i],
			 0,0.0,xlatl[menuidx+mlsidx].pl[i]);
	// Document schematic pins
	buf="   xlat(";
	pincnt=0;
	for (i=0;i<xlatn;i++) {
		pincnt++;
		if (pincnt!=1)
			buf=buf+",";
		if (pincnt%10==0)
			buf=buf+"\n    ";
		buf=buf+"\""+xlatl[i].name+"\"";
		}
	for (i=0;i<gaten;i++) {
		buf=buf+(i==0 ? ") to\n     (" : ") or\n     (");
		// Document layout part pins
		pincnt=0;
		for (j=0;j<xlatn;j++) {
			pincnt++;
			if (pincnt!=1)
				buf=buf+",";
			if (pincnt%10==0)
				buf=buf+"\n    ";
			buf=buf+"\""+xlatl[j].pl[i]+"\"";
			}
		}
	buf+=");\n";
	return(buf);
}

void headedit(string libname,string symname,string altname)
/*
// Edit layout macro list of given symbol definition
// Parameters :
//	string libname		: Library file name
//	string symname		: Base symbol name
//	string altname		: Alternate definition name
*/
{
	string msg			/* Message string */;
	string newqpart	= ""		/* New quoted part macro name */;
	int i				/* Loop control variable */;
	// Try to load definition from library file
	if (con_getlogpart(libname,altname,LINELEN,logldef)!=0) {
		sprintf(msg,ERRNODEF,altname,libname);
		bae_msgbox(2,msg,"");
		return;
		}
	splitdef(logldef);
	if (editlaypartlist(symname,altname) || macn==0)
		return;
	// Build new definition
	logldef="part \""+altname+"\""+defhead;
	newqpart="\""+macl[0]+"\"";
	for (i=1;i<macn;i++)
		newqpart+=",\""+macl[i]+"\"";
	logldef+=newqpart+" "+defbody;
	// Compile new definition
	switch (con_compileloglib(libname,NULL,logldef)) {
		case (-1) :
		bae_msgbox(2,UPRECONT,"");
		return;
		case (-2) :
		bae_msgbox(1,UPRWCONT,"");
		break;
		default :
		screenredraw();
		}
}

int editlaypartlist(string symname,string altname)
/*
// Edit current layout part macro name list
// Return value :
//	0 done or (-1) on abort
// Parameter :
//	string symname		: Symbol macro name
//	string altname		: Alternate definition name
*/
{
	string msg			/* Message string */;
	string newpart	= ""		/* New part macro name */;
	double pcol			/* Parameter column */;
	double cy			/* Dialog box current y coordinate */;
	double dialwidth		/* Dialog box width */;
	double dialheight		/* Dialog box height */;
	double baseheight		/* Dialog box base height */;
	string pattern = ""		/* Pattern string */;
	int patidx = (-1)		/* Pattern dialog box item idx. */;
	int lstidx = (-1)		/* List flag dialog box item idx. */;
	int repflag	= 1		/* Repeat flag */;
	int listflag	= macn>1 ? 1 : 0/* Macro list flag */;
	STRINGS omacl			/* Old part macro list */;
	int omacn = 0			/* Old part macro count */;
	int i				/* Loop control variable */;
	// Buffer old macro list
	omacl=macl;
	omacn=macn;
	// Build the part name list string
	if (macn>0) {
		newpart=macl[0];
		for (i=1;i<macn;i++)
			newpart+=","+macl[i];
		}
	baseheight=DIAL_TOPMARG+3.0*DIAL_CTRVSTEP+3.0*DIAL_SEPVSTEP+
	 DIAL_BUTVSTEP+0.2;
	do {
		bae_dialclr();
		dial_getboxsizemin(3001,dialwidth,dialheight,
		 DIAL_LEFTMARG+74.0+DIAL_RIGHTSMARG,baseheight+10.0,
		 DIAL_LEFTMARG+60.0,baseheight+2.0);
		pcol=dialwidth/3.0;
		// Build the dialog box
		cy=DIAL_TOPMARG;
		// Store layout part macro edit controls
		dial_label(0.0,cy,listflag ? UPRDNEWPRT : UPRDNEWPRTL);
		macidx=bae_dialaddcontrol(PA_STR|PA_HBRDREL,0,0,0,0.0,0.0,0.0,
		 newpart,1000,DIAL_LEFTMARG+pcol,cy,DIAL_RIGHTEMARG+5.0,"");
		lstidx=bae_dialaddcontrol(PA_TOGGLE,0,3,listflag,0.0,0.0,0.0,
		 "",0,dialwidth-DIAL_RIGHTSMARG-5.0,cy,0.0,UPRLIST);
		cy+=DIAL_CTRVSTEP;
		dial_hsep(cy);
		bae_dialaddcontrol(PA_ACT,0,1,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy,0.0,UPRPATTERN);
		patidx=bae_dialaddcontrol(PA_STR|PA_CHKNPAT,0,0,0,
		 0.0,0.0,0.0,pattern,MAXKEYLEN,DIAL_LEFTMARG+pcol,cy,20.0,"");
		dial_label(pcol+21.0,cy,UPRPATTDOC);
		bae_dialaddcontrol(PA_ACT,0,4,0,0.0,0.0,0.0,"",0,
		 dialwidth-DIAL_RIGHTSMARG-6.0,cy,5.0,UPRPATTERNA);
		cy+=DIAL_CTRVSTEP;
		dial_label(0.0,cy,UPRPRTPROJ);
		bae_dialadvcontrol(PA_VSEP|PA_VBRDREL,0,0,0,0.0,
		 0.0,0.0,"",0,DIAL_LEFTMARG+pcol-1.5,cy,0.0,DIAL_BOTSMARG,"");
		sprintf(msg,UPRPRTDB,convstring(defloglname,2));
		dial_label(pcol,cy,msg);
		cy+=DIAL_CTRVSTEP;
		// Store project part list box
		bae_dialadvcontrol(
		 PA_LB|PA_OKSEL|(listflag ? PA_MCALLBACK : 0)|PA_HSCROLL,
		 (listflag ? patidx : macidx),0,(-1),0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG,cy,pcol-3.0,dialheight-baseheight,"");
		// Store list box entries
		newpart="";
		while (scanddbenames(jobfname,DDBCLLPRT,newpart)==1)
			// Add the part name
			if (pattern=="" || strmatch(newpart,pattern))
				bae_dialaddcontrol(PA_LBE,0,0,0,0.0,0.0,0.0,
				 "",0,0.0,0.0,0.0,newpart);
		// Store library part list box
		bae_dialadvcontrol(PA_LB|PA_MULCOL|PA_HSCROLL|PA_HBRDREL|
		 PA_OKSEL|(listflag ? PA_MCALLBACK : 0),
		 (listflag ? patidx : macidx),0,(-1),0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG+pcol,cy,
		 DIAL_RIGHTSMARG,dialheight-baseheight,"");
		// Store list box entries
		newpart="";
		while (scanddbenames(defloglname,DDBCLLPRT,newpart)==1)
			// Add the part name
			if (pattern=="" || strmatch(newpart,pattern))
				bae_dialaddcontrol(PA_LBE,0,0,0,0.0,0.0,0.0,
				 "",0,0.0,0.0,0.0,newpart);
		cy+=dialheight-baseheight+0.2;
		dial_hsep(cy);
		// Store OK button
		dial_okabort(cy);
		bae_dialaddcontrol(PA_ACT,0,2,0,0.0,0.0,0.0,"",0,
		 DIAL_LEFTMARG+pcol,cy-DIAL_BUTVSTEP-DIAL_SEPVSTEP,
		 0.0,UPRVIRTUAL);
		// Display dialog box
		sprintf(msg,UPRNEWPRTD,symname,altname);
		bae_setintpar(16,3001);
		switch (bae_dialaskcall("!"+msg,0,dialwidth,cy,macactcb)) {
			// Done
			case 0 :
			bae_dialgetdata(macidx,0,0.0,newpart);
			bae_dialgetdata(lstidx,listflag,0.0,"");
			repflag=0;
			if (newpart=="")
				break;
			buildmaclist(newpart);
			break;
			// Apply pattern
			case 1 :
			bae_dialgetdata(macidx,0,0.0,newpart);
			bae_dialgetdata(lstidx,listflag,0.0,"");
			bae_dialgetdata(patidx,0,0.0,pattern);
			break;
			// Virtual
			case 2 :
			repflag=0;
			macl[0]="virtual";
			macn=1;
			break;
			// List flag change
			case 3 :
			bae_dialgetdata(macidx,0,0.0,newpart);
			bae_dialgetdata(lstidx,listflag,0.0,"");
			bae_dialgetdata(patidx,0,0.0,pattern);
			break;
			// Reset pattern
			case 4 :
			bae_dialgetdata(macidx,0,0.0,newpart);
			bae_dialgetdata(lstidx,listflag,0.0,"");
			pattern="";
			break;
			// Resize
			case (-2) :
			bae_dialgetdata(macidx,0,0.0,newpart);
			bae_dialgetdata(lstidx,listflag,0.0,"");
			bae_dialgetdata(patidx,0,0.0,pattern);
			break;
			default :
			// Restore old macro list
			macl=omacl;
			macn=omacn;
			return(-1);
			}
		}
	 // Stop if no further repeat requests
	 while (repflag);
	// Return without errors
	return(0);
}

static int macactcb(int reason,int boxidx,int itemidx,int itemid,string itemstr)
/*
// Macro list activation callback
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	int reason		: Callback reason
//	int boxidx		: Dialog box index
//	int itemidx		: Dialog box item index
//	int itemid		: Dialog list box item id
//	string itemstr		: Dialog list box item string
*/
{
	string newpart	= ""		/* New part macro name */;
	int i				/* Loop control variable */;
	if (itemid<0)
		return(0);
	if (macidx>=0) {
		// Get current macro list string
		bae_dialgetdata(macidx,0,0.0,newpart);
		if (newpart=="virtual")
			macn=0;
		else
			// Extract macro name list
			buildmaclist(newpart);
		// Search selected macro item
		for (i=0;i<macn;i++)
			if (macl[i]==itemstr)
				break;
		// Check if macro found
		if (i>=macn) {
			// Add macro to list
			macl[macn]=itemstr;
			macn++;
			}
		else {
			// Delete macro from list
			for (;i<(macn-1);i++)
				macl[i]=macl[i+1];
			macn--;
			}
		// Build the part name list string
		newpart= macn==0 ? "" : macl[0];
		for (i=1;i<macn;i++)
			newpart+=","+macl[i];
		bae_dialsetdata(macidx,PA_STR,0,0.0,newpart);
		}
	return(0);
}

int splitstring(string s,STRINGS ssl,string DELCHARS)
/*
// Split string
// Return value :
//	number of substrings
// Parameters :
//	string s		: Input string
//	STRINGS ssl		: Substring list
//	string DELCHARS		: Delimiter characters
*/
{
	int ssn		= 0		/* Substring count */;
	int sl		= strlen(s)	/* String length */;
	int pos1	= 1		/* String position buffer 1 */;
	int pos2			/* String position buffer 2 */;
	// Repetively scan string
	while ((pos2=strscannext(s,DELCHARS,pos1,1))<sl) {
		// Extract next substring if one found
		ssl[ssn++]=
		 pos2>pos1 ? strtrim(strextract(s,pos1-1,pos2-2)) : "";
		// Update the scan start position
		pos1=pos2+1;
		}
	// Extract last substring if last char not delimiter
	if (pos1<pos2)
		ssl[ssn++]=strtrim(strextract(s,pos1-1,pos2-1));
	// Return the substring count
	return(ssn);
}

string strltrim(string s)
/*
// Left trim string (skip leading white spaces)
// Return value :
//	string without leading white spaces
// Parameters :
//	string s		: Input string
*/
{
	// Extract and return substring
	return(strextract(s,strscannext(s," \t\n",1,0)-1,strlen(s)));
}

string strrtrim(string s)
/*
// Right trim string (skip trailing white spaces)
// Return value :
//	string without trailing white spaces
// Parameters :
//	string s		: Input string
*/
{
	int i		= strlen(s)	/* Loop control variable */;
	// Scan string backward for non-space
	while ((--i)>=0 && isspace(s[i]))
		;
	// Extract and return substring
	return(i<0 ? "" : strextract(s,0,i));
}

string strtrim(string s)
/*
// Trim string (skip leading and trailing white spaces)
// Return value :
//	string without leading and trailing white spaces
// Parameters :
//	string s		: Input string
*/
{
	// Extract and return substring
	return(strrtrim(strltrim(s)));
}

double mmceil(double val)
/*
// Round meter input value up to next mm
// Return value :
//	rounded value in meters
// Parameters :
//	double val		: Input value
*/
{
	// Calculate result and return it
	return(ceil(val*1000.0)/1000.0);
}

string scmlibdir()
/*
// Get SCM library directory path
// Return value: SCM library directory path name
*/
{
	string s			/* String buffer */;
	// Get the default SCM library name
	if ((s=strgetvarfilename(scm_deflibname()))=="")
		// Return current directory name
		return("");
	// Extract and return directory path name
	return(strextract(s,0,strscanprior(s,"\\/",strlen(s)-1,1)));
}

void stripxlat()
/*
// Strip xlat command from logical definition
*/
{
	string loglbuf			/* Definition buffer */;
	int sqtoggle	= 0		/* Single quotation toggle */;
	int dqtoggle	= 0		/* Double quotation toggle */;
	int dst				/* String destination index */;
	char c				/* Character buffer */;
	int i				/* Loop control variable */;
	// Remove part close brace
	i=strlen(logldef)-1;
	while (i>0 && logldef[i]!='}')
		i--;
	if (i>=0 && logldef[i]=='}') {
		while (i>0 && (logldef[i-1]==' ' ||
		 logldef[i-1]=='\t'))
			i--;
		logldef[i]='\0';
		}
	// Remove xlat commands
	loglbuf=logldef;
	for (i=dst=0;(c=loglbuf[i])!='\0';i++) {
		if (c=='\'' && !dqtoggle)
			sqtoggle=!sqtoggle;
		else if (c=='"' && !sqtoggle)
			dqtoggle=!dqtoggle;
		// Check if xlat start
		if (c=='x' && !sqtoggle && !dqtoggle &&
		 strextract(loglbuf,i,i+3)=="xlat") {
			// Skip xlat command
			while ((c=loglbuf[i])!='\0' && c!=';')
				i++;
			if (c==';' && (loglbuf[i+1]==13 || loglbuf[i+1]==10)) {
				while (dst>0 && logldef[dst-1]==' ')
					dst--;
				i++;
				}
			}
		else {
			logldef[dst]=c;
			dst++;
			}
		}
	// Terminate definition
	logldef[dst]='\0';
}

void splitdef(string defstr)
/*
// Split logical definition
// Parameter :
//	string defstr		: Definition string
*/
{
	char c				/* Character buffer */;
	int bodystart = strlen(defstr)-1	/* Definition body start */;
	int headstart			/* Header string start */;
	int headend			/* Header string end */;
	int macstart			/* Macro string start */;
	int macend			/* Macro string end */;
	int i				/* Loop control variable */;
	// Search part body open brace
	for (i=0;(c=defstr[i])!='\0';i++)
		if (c=='{') {
			bodystart=i;
			break;
			}
	// Skip blanks
	i=bodystart-1;
	while (i>0 && ((c=defstr[i])==' ' || c=='\t' || c==13 || c==10))
		i--;
	// Scan part macro string
	macstart=macend=i;
	while (i>0) {
		if ((c=defstr[i])==' ' && (i==0 || ((c=defstr[i-1])!=' ' &&
		 c!='\t' && c!=13 && c!=10 && c!=','))) {
			macstart=i+1;
			break;
			}
		i--;
		}
	buildmaclist(strextract(defstr,macstart,macend));
	headend=i;
	headstart=5;
	while ((c=defstr[headstart])!='\0') {
		if (c==' ')
			break;
		headstart++;
		}
	// Get the definition split parts
	defbody=strextract(defstr,bodystart,strlen(defstr)-1);
	defhead=strextract(defstr,headstart,headend);
}

void buildmaclist(string macstr)
/*
// Get macro list from macro list string
// Parameter :
//	string macstr		: Macro list string
*/
{
	char c				/* Character buffer */;
	int macstart			/* Macro string start */;
	int macend			/* Macro string end */;
	int i				/* Loop control variable */;
	// Scan part macros
	macn=0;
	i=0;
	while ((c=macstr[i])!='\0') {
		// Skip blanks/seperators
		while ((c=macstr[i])==' ' ||
		 c==',' || c=='\t' || c==13 || c==10)
			i++;
		if (c=='"')
			i++;
		macstart=i;
		while ((c=macstr[i])!='\0' &&
		 c!=' ' && c!=',' && c!='\t' && c!=13 && c!=10)
			i++;
		macend=i-1;
		if (macend>0 && macstr[macend]=='"')
			macend--;
		macl[macn]=strextract(macstr,macstart,macend);
		macn++;
		}
}

string getdstlibname()
/*
// Get destination library
// Return value: Destination library file name
*/
{
	// Query the destination library name
	curstr="";
	sprintf(sqlcommand,L_SELECT,sql_quotestr(bae_planename()));
	sqlcmd(bae_planfname(),sqlcommand,datafunc);
	return(curstr);
}

int datafunc(string dstr,int dint,double ddbl,
 int dval,int dtype,string dtable,string dfield,int didx)
/*
// Data query callback function
// Return value :
//	zero if done or (-1) on data error
// Parameters :
//	string dstr		: String/Date data
//	int dint		: Integer/Boolean data
//	double ddbl		: Float data
//	int dval		: Data valid flag
//	int dtype		: Data type
//	string dtable		: Data table name
//	string dfield		: Data field name
//	int didx		: Data output field index
*/
{
	curstr=dstr;
	// Return without errors
	return(0);
}

// User Language program end