/* SCMEDFDI (SCM) -- Convert EDIF SCM Data */
/* SCMEDFDI (SCM) -- EDIF SCM-Daten konvertieren */
/*
// Copyright (c) 1999-2012 Oliver Bartels F+E, Muenchen
// Author: Roman Ludwig
// Changes History:
//	rl (120427) RELEASED FOR BAE V7.8.
//	rl (101220) ENHANCEMENT:
//		Added instance name backannotation entries support.
//	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 (070109) ENHANCEMENT:
//		Added automatic loglib run option.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (050906) RELEASED FOR BAE V6.6.
//	rl (050331) ENHANCEMENT:
//		Added pin type attribute support.
//		Added symbol attribute list placement support.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (040119) ENHANCEMENT:
//		Applied new full pin connectivity mode to created plans.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (021014) ENHANCEMENT:
//		Added additional orthogonal segment to pin/pin overlap
//		position to establish connection in case of transit segment.
//		Fixed problems with scale factor.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (010625) RELEASED FOR BAE V5.0.
//	rl (010529) ENHANCEMENT:
//		Added optional parameter settings from bae.ini file.
//	rl (000830) RELEASED FOR BAE V4.6.
//	rl (000419) ENHANCEMENT:
//		Introduced pin rotation support.
//	rl (991112) RELEASED FOR BAE V4.4.
//	rl (990429) ORIGINAL CODING.
//
// DESCRIPTION
//
// The scmedfdi User Language program converts a EDIF data file
// to BAE SCM format. Logical library definitions are generated automatically.
*/

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

// Disable undo state request
#pragma ULCALLERNOUNDO

// Messages
string UPRPEXIT		= M_UPRPEXIT();
string REPLOGHD0	= M("BAE SCM EDIF Konvertierung",
			    "BAE SCM EDIF Conversion");
string REPLOGHD1	= M("Fehlerreport:","Error report:");
string REPLIBCONV	= M("Konvertieren Library Datei...",
			    "Converting library file...");
string REPDONE		= M("Es wurden keine Fehler festgestellt.",
			    "Operation completed.");
string UPRLIBFILE	= M("Library-Eingabedatei ? ","Library Input File ? ");
string UPROVRWRITE	= M("Zieldatei '%s' ersetzen ?",
			    "Replace destination file '%s' ?");
string ERRTMPWRITE	= M("Fehler beim Schreiben der Temporaerdatei '%s'!",
			    "Error writing temporary file '%s'!");
string ERRLIBOPEN	= M("Library-Eingabedatei '%s' kann nicht geoeffnet werden!",
			    "Couldn't open library file '%s'!");
string ERRLOGCREA	= M("Logische Bibliothek '%s' kann nicht erzeugt werden!",
			    "Couldn't create logical library file '%s'!");
string ERRMAPCREA	= M("Mappingdatei '%s' kann nicht erzeugt werden!",
			    "Couldn't create logical library file '%s'!");
string ERRPLCPOLY	= M("Fehler bei der Polygonerzeugung (%s %s: %.1fmm,%.1fmm)!",
			    "Error generating polygon (%s %s: %.1fmm,%.1fmm)!");
string ERRPLCTEXT	= M("Fehler bei der Textplatzierung (%s %s: '%s')!",
			    "Error placing text (%s %s: '%s')!");
string ERRPLCPIN	= M("Fehler bei der Pinplatzierung (%s %s: '%s')!",
			    "Error placing pin (%s %s: '%s')!");
string ERRPLCCON	= M("Fehler bei der Verbindungsplatzierung (%s %s: %.1fmm,%.1fmm)!",
			    "Error placing connection (%s %s: %.1fmm,%.1fmm)!");
string ERRPLCSYM	= M("Fehler bei der Symbolplatzierung (%s %s: %s, %s)!",
			    "Error placing symbol (%s %s: %s, %s)!");
string ERRRENSYM	= M("Fehler bei der Symbolumbenennung (%s %s: %s, %s)!",
			    "Error renaming symbol (%s %s: %s, %s)!");
string ERRPLCLAB	= M("Fehler bei der Labelplatzierung (%s %s: %s, %s)!",
			    "Error placing label (%s %s: %s, %s)!");
string ERRPLCPORT	= M("Fehler bei der Portplatzierung (%s %s: %s, %s)!",
			    "Error placing port (%s %s: %s, %s)!");
string ERRPLCTAP	= M("Plan '%s' Bustap '%s' (%.1fmm,%.1fmm) konnte nicht platziert werden!",
			    "Sheet '%s' Bustap '%s' (%.1mm,%.1mm) could not be placed!");
string ERRSETATTR	= M("Fehler bei der Attributzuweisung (%s %s: %s, %s, %s)!",
			    "Error assigning attributes (%s %s: %s, %s, %s)!");
string ERRBTAPREC	= M("Plan '%s' Bustap '%s' zu viele Unterbusse (Busschleife?)!",
			    "Sheet '%s' bustap '%s' too many sub busses (bus loop?)!");
string ERRBTAPLNAME	= M("Plan '%s' Namenskombination Bus '%s'/Bustap '%s' %d Zeichen zu lang!",
			    "Sheet '%s' name combination bus '%s'/bus tap '%s' %d chars too long!");
string ERRCPMARK	= M("Marker '%s' nicht in Bibliothek '%s'!",
			    "Marker '%s' not defined in library '%s'!");
string ERRCPLABEL	= M("Label '%s' nicht in Bibliothek '%s'!",
			    "Label '%s' not defined in library '%s'!");

// INI file parameter name definitions
#define PAR_SEDFIFEXT	"SEDFIFEXT_SCM"	// Library input file name extension
#define PAR_SMAPEXT	"SYMMAPEXT_SCM"	// Symbol mapping file ext.
#define PAR_EDFDEFFEXT	"EDFDEFFEXT_SCM"// Logical library file name extension
#define PAR_EDFPOWMODE	"EDFPOWMODE_SCM"// Power pin process mode
#define PAR_EDFPOWEXT	"EDFPOWEXT_SCM"	// Power symbol name extension
#define PAR_EDFVALATT	"EDFVALATT_SCM"	// Value attribute name
#define PAR_EDFTMPFLAG	"EDFTMPFLAG_SCM"// Temporary file conversion flag
#define PAR_EDFTMPFILE	"EDFTMPFILE_SCM"// Library temporary file name
#define PAR_EDFNAMEPAT	"EDFNAMEPAT_SCM"// Symbol name pattern
#define PAR_EDFRENAME	"EDFRENAME_SCM"	// Name/rename mode
#define PAR_EDFSYMOFF	"EDFSYMOFF_SCM"	// Symbol boundary offset
#define PAR_EDFNAMESIZ	"EDFNAMESIZ_SCM"// Name text size
#define PAR_EDFVALSIZ	"EDFVALSIZ_SCM" // Value text size
#define PAR_EDFPNAMSIZ	"EDFPNAMSIZ_SCM"// Pin name text size
#define PAR_EDFPNUMSIZ	"EDFPNUMSIZ_SCM"// Pin number text size
#define PAR_EDFCOMMSIZ	"EDFCOMMSIZ_SCM"// Commentary text size
#define PAR_EDFALOFF	"EDFALOFF_SCM"	// Alias placement offset
#define PAR_EDFDOTDRAW	"EDFDOTDRAW_SCM"// Dot draw flag
#define PAR_EDFDOTRAD	"EDFDOTRAD_SCM"	// Dot radius
#define PAR_EDFZERORAD	"EDFZERORAD_SCM"// Zero circle radius
#define PAR_EDFATTRL	"EDFATTRL_SCM"	// Attribute list
#define PAR_EDFLENFAC	"EDFLENFAC_SCM"	// Length correction factor
#define PAR_EDFPINTMODE	"EDFPINTMODE_SCM"// Pin text mode
#define PAR_EDFPINTCLASS	"EDFPINTCLASS_SCM"// Pin text class
#define PAR_EDFLOGLIB	"EDFLOGLIB_SCM"	// Automatic loglib run flag
#define PAR_SYMLIB	"SYMGRPLIB_SCM"	// Symbol library
#define PAR_SYMGRP	"SYMGRPNAME_SCM"// Symbol group
#define PAR_EDFSRENAME	"EDFSRENAME_SCM"// Symbol rename mode

// Global definitions
string LIBEXT = bae_inistrval(PAR_SEDFIFEXT,".edf")
					/* Library input file name ext. */;
string LOGEXT = bae_inistrval(PAR_EDFDEFFEXT,".def")
					/* Logical library file name ext. */;
string MAPEXT = bae_inistrval(PAR_SMAPEXT,".map")
					/* Mapping file name ext. */;
string SYMGRP = bae_inistrval(PAR_SYMGRP,"")
					/* Symbol group name */;
string SYMLIB = bae_inistrval(PAR_SYMLIB,"")
					/* Symbol group library file */;
int POWMODE = bae_iniintval(PAR_EDFPOWMODE,2)
					/* Power pin process mode */;
string POWEXT = bae_inistrval(PAR_EDFPOWEXT,"_pow")
					/* Power symbol name ext. */;
string VALATTR = bae_inistrval(PAR_EDFVALATT,"$val")
					/* Value attribute name */;
int TMPFLAG = bae_iniintval(PAR_EDFTMPFLAG,1)
					/* Temporary file conversion flag */;
int PINTMODE = bae_iniintval(PAR_EDFPINTMODE,2)
					/* Pin text mode */;
int PINTCLASS = bae_iniintval(PAR_EDFPINTCLASS,1)
					/* Pin text class */;
string TMPFILE = bae_inistrval(PAR_EDFTMPFILE,"edflib.pxx")
					/* Library temporary file name */;
string NAMEPAT = bae_inistrval(PAR_EDFNAMEPAT,"????")
					/* Symbol name pattern */;
int RENAMEMODE = bae_iniintval(PAR_EDFRENAME,0)
					/* Name/rename mode */;
int SYMRENAME = bae_iniintval(PAR_EDFSRENAME,0)
					/* Name/rename mode */;
double SYMOFF = bae_inidblval(PAR_EDFSYMOFF,0.001)
					/* Symbol boundary offset */;
double NAMESIZ = bae_inidblval(PAR_EDFNAMESIZ,0.002)
					/* Name text size */;
double VALSIZ = bae_inidblval(PAR_EDFVALSIZ,0.002)
					/* Value text size */;
double PNAMSIZ = bae_inidblval(PAR_EDFPNAMSIZ,0.002)
					/* Pin name text size */;
double PNUMSIZ = bae_inidblval(PAR_EDFPNUMSIZ,0.002)
					/* Pin number text size */;
double COMMSIZ = bae_inidblval(PAR_EDFCOMMSIZ,0.001)
					/* Commentary text size */;
double ALIASOFF = bae_inidblval(PAR_EDFALOFF,0.00075)
					/* Alias placement offset */;
int DOTDRAW = bae_iniintval(PAR_EDFDOTDRAW,0)
					/* No dot draw */;
double DOTRAD = bae_inidblval(PAR_EDFDOTRAD,0.0005)
					/* Dot circle radius */;
double ZEROCRAD = bae_inidblval(PAR_EDFZERORAD,0.0005)
					/* Zero circle radius */;
double LENFAC = bae_inidblval(PAR_EDFLENFAC,20.0)
					/* Length correction factor */;
int AUTOLOGLIB = bae_iniintval(PAR_EDFLOGLIB,1)
					/* Automatic loglib run */;
struct attrdes {			// Attribute descriptor
	string attname			/* Attribute name */;
	string attprop			/* Attribute property name */;
	int attdisp			/* Attribute display flag */;
	int attmode			/* Attribute display process mode */;
	}				/* Attribute list */;
struct attrdes defattrl[]	= {	// Default attribute list
	{ "$id"		, "part_number"		,"",0 },
	{ "$plname"	, "pcb_footprint"	,"",0 }
	};
struct attrdes attrl[]			/* Attribute list */;
int attrn				/* Attribute count */;

#define SMALLVAL	0.000000001	// Small compare value
#define SDVAL		0.00005		// Small distance value
double PI		= cvtangle(180.0,1,2)
					/* (Constant) PI value */;
#define CHRWTOH		32.0/48.0	// Char. width to height factor
#define PINMAC		"p"		// Pin macro
#define VALPROP		"value"		// Value property name
#define TEMPINAME	"instbatemp%d"	// Temporary instance backannotated name
#define DELPREFIX	"atbb-ed02-a-reserve_"	// Deletion prefix

// Data input buffers
int deffh				/* Logical definition file handle */;
int mapfh				/* Mapping definition file handle */;
string ddbfname				/* Database output file name */;
string ddbfsname			/* Short database file name */;
int symfh				/* Symbol name log file handle */;
int strfh				/* Symbol name transl. file handle */;

// Scanner variables
string cursymname[]			/* Current symbol name */;
int cursymn=0				/* Current symbol name count */;
string curplname			/* Current part library name */;
string curdesignator			/* Current designator name */;
string curportname			/* Current port name */;
string curportoname			/* Current port original name */;
string curpropname			/* Current property name */;
string curcellref = ""			/* Current cell reference */;
string curstrval			/* Current string value */;
string curstrdisp			/* Current string display */;
int curstrdispflag = 0			/* Current string display flag */;
string curdispgrp			/* Current display group name  */;
int curcellcode = 0			/* Current cell type */;
int curclass				/* Current element class */;
double curlx, curly			/* Current plan lower boundary */;
double curux, curuy			/* Current plan upper boundary */;
double curx, cury			/* Current coordinates */;
double curorgx, curorgy			/* Current origin coordinates */;
double curdotx, curdoty			/* Current dot coordinates */;
double curhotx, curhoty			/* Current hot spot coordinates */;
double curconlx, curconly		/* Cur. connect location coords. */;
double curtransx, curtransy		/* Cur. transformation coordinates */;
int curtransori				/* Cur. transformation orientation */;
int curori				/* Current orientation */;
int curnameass				/* Current name assignment */;
int curarray = 0			/* Current array flag */;
int curdisplay = 0			/* Current display flag */;
int curmember = 0			/* Current member flag */;
int curmembnum = (-1)			/* Current member number */;
int curnet = 0				/* Current net flag */;
int currename = 0			/* Current rename flag */;
int netpolyoff = 0			/* Current net polygon index offset */;
int curripsym = 0			/* Current array flag */;
int curtitledisp			/* Current title block display flag */;
double cursize				/* Current size */;
string curid				/* Current identifier */;
int curcell = 0				/* Current cell state */;
string curpageblock			/* Current page block name */;
int curpage = 0				/* Current page state */;
int curpagesym = 0			/* Current page symbol state */;
int curpagedone = 0			/* Current page done state */;
int curport = 0				/* Current port state */;
int curportimp = 0			/* Cur. port implementation state */;
int curportiref = (-1)			/* Cur. port imp. inst. index */;
int curportinst = 0			/* Cur. port instance state */;
int curportlist = 0			/* Cur. port list state */;
int curinstance = 0			/* Current instance state */;
int curdes = 0				/* Current designator state */;
int curprop = 0				/* Current property state */;
int cursymbol = 0			/* Current symbol state */;
int cursymboldone = 0			/* Current symbol done state */;
int curview = 0				/* Current view state */;
int curviewtype = 0			/* Current view type */;
string curviewname = ""			/* Current view name */;
int curvaldisp = 0			/* Current value display flag */;
double curvalx, curvaly			/* Current value position */;
double curvalang			/* Current value angle */;
int curvaljustify = 8			/* Current value justify mode */;
double curpinnamex, curpinnamey		/* Current pin name position */;
int curpinnamejustify			/* Current pin name justify */;
int curpinnameori			/* Current pin name orientation */;
int curpinnamedisp = 0			/* Current pin name display flag */;
double curpinnumx, curpinnumy		/* Current pin number position */;
int curpinnumori			/* Current pin number orientation */;
int curpinnumjustify			/* Current pin number justify */;
int curpinnumdisp = 0			/* Current pin number display flag */;
double curnamex, curnamey		/* Current name position */;
double curnameang			/* Current name angle */;
int curnamejustify = 8			/* Current name justify mode */;
int curnamedisp = 0			/* Current name display flag */;
int curvisible = 1			/* Current visible state */;
int curjustify = 0			/* Current justify mode */;
int curbool = 0				/* Current boolean value */;
double curflt				/* Current float value */;
double curexp				/* Current float value */;
double curint				/* Current integer value */;
double lenconv = 1.0			/* Length conv. factor (default m) */;
double curscale = 1.0			/* Current scale factor */;
double curxscale = 1.0			/* Current X scale factor */;
double cursheetscale = 1.0		/* Current sheet scale factor */;
int curunit = (-1)			/* Current unit */;
string textid		= creatextid()	/* Get multiline text base ID */;
int mtextcnt		= 0		/* Multiline text count */;

struct pointdes {			// Polygon point descriptor
	double x, y			/* Point coordinates */;
	int t				/* Point typ */;
	};
struct polydesc {			// Polygon descriptor
	struct pointdes pl[]		/* Polygon point list */;
	int ptyp			/* Polygon type */;
	int netidx			/* Polygon net index */;
	int pn				/* Polygon point count */;
	} curpolyl[]			/* Current polygon list */;
int curpolyn				/* Current pin count */;
struct pointdes curpointl[]		/* Point list */;

struct boxdes {				// Box descriptor
	double lx,ly			/* Box lower corner */;
	double ux,uy			/* Box upper corner */;
	};

struct pindesc {			// Pin descriptor
	string name			/* Pin name */;
	string oname			/* Pin old name */;
	string rname			/* Pin rename name */;
	string ptyp			/* Pin type */;
	int sflag			/* Pin symbol flag */;
	int portimp			/* Pin port implementation flag */;
	double x, y			/* Pin coordinates */;
	double ang			/* Pin angle */;
	double namex, namey		/* Pin name coordinates */;
	double nameang			/* Pin name angle */;
	int namejustify			/* Pin name justify */;
	int namedisp			/* Pin name display */;
	double numx, numy		/* Pin number coordinates */;
	double numang			/* Pin number angle */;
	int numjustify			/* Pin number justify */;
	int numdisp			/* Pin number display */;
	string pxl[]			/* Pin xlat name list */;
	int pxn				/* Pin xlat count */;
	} curpinl[]			/* Current pin list */;
int curpinn				/* Current pin count */;

struct instdesc {			// Instance descriptor
	string name			/* Instance name */;
	string macro			/* Instance macro */;
	string value			/* Instance value */;
	string attrnl[]			/* Instance attribute name list */;
	string attrvl[]			/* Instance attribute value list */;
	int attrn			/* Instance attribute count */;
	int ori				/* Instance orientation */;
	int typ				/* Instance type */;
	double x, y			/* Instance coordinates */;
	double cx, cy			/* Instance connection coordinates */;
	double namex, namey		/* Instance name coordinates */;
	double nameang			/* Instance name angle */;
	int namejustify			/* Instance name justify */;
	int namedisp			/* Instance name display */;
	double valx, valy		/* Instance value coordinates */;
	double valang			/* Instance value angle */;
	int valjustify			/* Instance value justify */;
	int valdisp			/* Instance value display */;
	} curinstl[]			/* Current instance list */;
int curinstn				/* Current instance count */;

struct instbadesc {			// Instance backannotation descriptor
	string instname			/* Internal instance name */;
	string planname			/* Instance plan name */;
	string plcname			/* Placed instance name */;
	string backname			/* Backannotated instance name */;
	string plname			/* Backannotated part lib. name */;
	} instbal[]			/* Instance backannotation list */;
int instbabase	= 0			/* Instance backanno. base index */;
string curinstbaname			/* Instance backannotation name */;
int instbaproc	= 0			/* Instance backannotate command */;
int instban	= 0			/* Instance backannotation count */;
int instback	= 0			/* Instance backannotation flag */;
string inirpname			/* $rpname initial value */;

struct textdesc {			// Text descriptor
	double x, y			/* Text coordinates */;
	double size			/* Text size */;
	double angle			/* Text angle */;
	string str			/* Text string */;
	} curtextl[]			/* Current text list */;
int curtextn				/* Current text count */;

struct symdesc {			// Symbol descriptor
	double x, y			/* Symbol hot spot coordinates */;
	string name			/* Symbol name */;
	int typ				/* Symbol type */;
	int mainp			/* Symbol main part flag */;
	int pagesym			/* Symbol block flag */;
	} syml[]			/* Current symbol list */;
int inssymidx				/* Symbol insert index */;
int symn = 0				/* Current symbol count */;

struct aliasdesc {			// Alias descriptor
	double x, y			/* Alias coordinates */;
	int ori				/* Alias orientation */;
	string name			/* Net name */;
	} curaliasl[]			/* Current alias list */;
int curaliasn				/* Current alias count */;
int fnalias				/* First net alias index */;

string strvalstk[]			/* Current string value stack */;
string namestk[]			/* Current name stack */;
string renamestk[]			/* Current rename stack */;
int namestkn = 0			/* Current name stack count */;
int pointstk[]				/* Current point index stack */;
int pointstkn = 0			/* Current point index stack count */;
struct boxdes boxstk[]			/* Current box stack */;
int boxstkn = 0				/* Current box stack count */;
string netnamel[]			/* Net name list */;
int netnamen = 0			/* Net name count */;

string dellabell[] = {			// Label delete list
	"vcc5"
	};
int dellabeln = arylength(dellabell)	/* Label delete count */;

struct topcelldesc {			// Top level cell descriptor
	double xl, yl			/* Cell lower boundary */;
	double xu, yu			/* Cell upper boundary */;
	struct pindesc pl[]		/* Pin list */;
	int pn				/* Pin count */;
	string name			/* Top level name */;
	} tcelll[]			/* Top cell level list */;
int tcelln = 0				/* Top level cell count */;

#define NTYP_MAC	0		// Symbol macro  name type
#define NTYP_NAME	1		// Symbol name type
#define NTYP_GRP	2		// Display group name type
#define NTYP_KEY	3		// Keyword name type
#define NTYP_ANNOT	4		// Annotation name type
struct renamedesc {			// Rename definition descriptor
	string oname			/* Original name */;
	string rname			/* Rename name */;
	int typ				/* Namespace type */;
	} renamel[]			/* Rename definition list */;
int renamen = 0				/* Rename definition count */;
int curnametype[] = { NTYP_KEY }	/* Current namespace type stack */;
int curnametypen = 0			/* Current namespace type stack cnt. */;

STRINGS msgl				/* Message list */;
int msgn = 0				/* Message count */;
string oldlibfname			/* Old library file name */;

// Main program
void main()
{
	string libfname			/* Library file name */;
	string logfname			/* Logical library file name */;
	string mapfname			/* Mapping file name */;
	string bakfname			/* Backup file name */;
	string tmpname			/* Temporary instance name */;
	string ename			/* Element name */;
	string msg			/* Message buffer */;
	STRINGS hl			/* Popup menu header list */;
	int hn				/* Popup menu header count */;
	int chgflag			/* Plan changed flag */;
	int i				/* Loop control variable */;
	// Get the attribute list
	for (attrn=0;attrn<1000;attrn++) {
		if ((attrl[attrn].attname=bae_inistrval(
		 bae_inifieldvarname(PAR_EDFATTRL,attrn,0),""))=="") {
			// Check if list defined at all
			if (attrn==0) {
				// Use default attribute list
				attrl=defattrl;
				attrn=arylength(attrl);
				}
			break;
			}
		attrl[attrn].attprop=bae_inistrval(
		 bae_inifieldvarname(PAR_EDFATTRL,attrn,1),"");
		attrl[attrn].attdisp=0;
		attrl[attrn].attmode=bae_iniintval(
		 bae_inifieldvarname(PAR_EDFATTRL,attrn,2),0);
		}
	// Select the library input file
	if (bae_askfilename(libfname,LIBEXT,UPRLIBFILE) || libfname=="")
		error_abort();
	// Get the output file names
	ddbfname=convstring(libfname,0)+DDBEXT;
	ddbfsname=convstring(libfname,2);
	logfname=convstring(libfname,0)+LOGEXT;
	mapfname=convstring(libfname,0)+MAPEXT;
	oldlibfname=scm_libfname();
	// Get the symbol library name
	if (SYMLIB=="")
		SYMLIB=scm_deflibname();
	// Check if file already exists
	fseterrmode(0);
	if ((deffh=fopen(ddbfname,0))!=(-1)) {
		fclose(deffh);
		sprintf(msg,UPROVRWRITE,ddbfname);
		if (!verify(msg,0))
			error_abort();
		bakfname=convstring(libfname,0)+".bak";
		if ((deffh=fopen(bakfname,0))!=(-1)) {
			fclose(deffh);
			remove(bakfname);
			}
		rename(ddbfname,bakfname);
		}
	// Copy markers
	if (ddbcopyelem(oldlibfname,ddbfname,DDBCLSMRK,PINMAC,1)!=0) {
		sprintf(msg,ERRCPMARK,PINMAC,oldlibfname);
		error(msg);
		}
	if (ddbcopyelem(oldlibfname,ddbfname,DDBCLSMRK,"pin",1)!=0) {
		sprintf(msg,ERRCPMARK,"pin",oldlibfname);
		error(msg);
		}
	if (ddbcopyelem(oldlibfname,ddbfname,DDBCLSMRK,"terminal",1)!=0) {
		sprintf(msg,ERRCPMARK,"terminal",oldlibfname);
		error(msg);
		}
	if (ddbcopyelem(oldlibfname,ddbfname,DDBCLSMRK,"junction",1)!=0) {
		sprintf(msg,ERRCPMARK,"junction",oldlibfname);
		error(msg);
		}
	if (ddbcopyelem(oldlibfname,ddbfname,DDBCLSLAB,"standard",1)!=0) {
		sprintf(msg,ERRCPLABEL,"standard",oldlibfname);
		error(msg);
		}
	if (ddbcopyelem(oldlibfname,ddbfname,DDBCLSLAB,"port",1)!=0) {
		sprintf(msg,ERRCPLABEL,"port",oldlibfname);
		error(msg);
		}
	if (ddbcopyelem(oldlibfname,ddbfname,DDBCLSLAB,"bustap",1)!=0) {
		sprintf(msg,ERRCPLABEL,"bustap",oldlibfname);
		error(msg);
		}
	// Create logical library file
	if ((deffh=fopen(logfname,1))==(-1))
		errormsg(ERRLOGCREA,logfname);
	if (SYMRENAME) {
		symfh=fopen(convstring(libfname,0)+"_sym.txt",1);
		strfh=fopen(convstring(libfname,0)+"_rename.txt",0);
		}
	else {
		symfh=strfh=(-1);
		}
	// Start the logical library file
	fprintf(deffh,"loglib\n");
	// Create mapping file
	if ((mapfh=fopen(mapfname,1))==(-1))
		errormsg(ERRMAPCREA,mapfname);
	// Save current state for undo
	bae_callmenu(MNU_BAESAVESTATE);
	// Process the library file
	parsefile(libfname);
	// Check if backannotated part names
	if (instback) {
		// First rename to temporary names
		ename="";
		while (scanddbenames(ddbfname,DDBCLSCM,ename)==1) {
		        // Load the plan if not already in memory
			if (ddbfname!=bae_planfname() ||
			 ename!=bae_planename()) {
				if (ddbfname==bae_planfname())
					bae_setintpar(22,1);
				loadddbelem(ddbfname,ename,DDBCLSCM);
				}
			chgflag=bae_plannotsaved();
			for (i=0;i<instban;i++) {
				if (ename!=instbal[i].planname ||
				 instbal[i].backname=="")
					continue;
				sprintf(tmpname,TEMPINAME,i);
				symrename(instbal[i].plcname,tmpname);
				chgflag=1;
				}
			if (chgflag) {
				// Save the element
				bae_setintpar(22,1);
				call(MNU_SCMSAVELEM);
				bae_setintpar(22,0);
				}
			}
		// Rename temporary to real names
		ename="";
		while (scanddbenames(ddbfname,DDBCLSCM,ename)==1) {
		        // Load the plan if not already in memory
			if (ddbfname!=bae_planfname() ||
			 ename!=bae_planename()) {
				if (ddbfname==bae_planfname())
					bae_setintpar(22,1);
				loadddbelem(ddbfname,ename,DDBCLSCM);
				}
			chgflag=bae_plannotsaved();
			for (i=0;i<instban;i++) {
				if (ename!=instbal[i].planname ||
				 instbal[i].backname=="")
					continue;
				sprintf(tmpname,TEMPINAME,i);
				symrename(tmpname,instbal[i].backname);
				if (instbal[i].plname!="")
					if (scm_setpartattrib(
					 instbal[i].backname,"$plname",
					 instbal[i].plname,1)) {
						sprintf(msgl[msgn],ERRSETATTR,
						 ddbclassname(
						  bae_planddbclass()),
						  bae_planename(),
						 instbal[i].backname,"$plname",
						 instbal[i].plname);
						msgn++;
						}
				chgflag=1;
				}
			if (chgflag) {
				// Save the element
				bae_setintpar(22,1);
				call(MNU_SCMSAVELEM);
				bae_setintpar(22,0);
				}
			}
		}
	// Terminate the logical library file
	fprintf(deffh,"\nend.\n");
	// Close the files
	fclose(deffh);
	fclose(mapfh);
	// Perform the loglib command
	if (AUTOLOGLIB)
		system("\""+bae_progdir()+"loglib\" \""+
		 logfname+"\" \""+ddbfname+"\"");
	if (msgn) {
		// Display conversion log header
		sprintf(hl[0],REPLOGHD0);
		sprintf(hl[2],REPLOGHD1);
		hn=4;
		// Display log with popup menu
		bae_setintpar(16,3091);
		popupmenu(0,"",hl,hn,msgl,msgn,
		 UINPOPABORT,0,-1,-1,hn+msgn+2,100,0,"");
		}
	else {
		// Done
		bae_prtdialog(REPDONE);
		}
}

/*________________________________________________________________*/
// SQL database access routines

void boundset(double lx,double ly,double ux,double uy)
/*
// Set the element boundary
// Parameters :
//	double lx,ly		: Lower element boundary
//	double ux,uy		: Upper element boundary
*/
{
	// Set lower plan boundary
	bae_clriactqueue();
	bae_storemouseiact(1,0.0,0.0,1,RMB);
	bae_storemenuiact(1,3,LMB);
	bae_storetextiact(1,ftoa(cvtlength(lx-SYMOFF,0,2),3));
	bae_storetextiact(1,ftoa(cvtlength(ly-SYMOFF,0,2),3));
	call(MNU_SCMPARLBND);
	// Set upper plan boundary
	bae_storemouseiact(1,0.0,0.0,1,RMB);
	bae_storemenuiact(1,3,LMB);
	bae_storetextiact(1,ftoa(cvtlength(ux+SYMOFF,0,2),3));
	bae_storetextiact(1,ftoa(cvtlength(uy+SYMOFF,0,2),3));
	call(MNU_SCMPARUBND);
}

/*_________________________________________________________________*/
// Scanner/parser functions
#bnf {	// EDIF BNF input syntax definition
	ediffile : "(" "edif" edifFileNameDef  edifVersion edifLevel
		keywordMap edifcommands ")" EOF
		;
	edifcommands : edifcommands edifcommand
		| edifcommand
		;
	edifcommand : status
		| external
		| library
		| design
		;
	acLoad : "(" "acload" minomaxvaldisp ")"
		;
	after : "(" "after" miNoMaxValue aftercommands ")"
		;
	aftercommands : aftercommands aftercommand
		| aftercommand
		|
		;
	aftercommand : logicAssign
		| follow
		| maintain
		| comment
		| userData
		;
	annotate : "(" "annotate" (p_annot) annotatespec (p_annotend) ")"
		;
	annotatespec : stringValue
		| stringDisplay
		;
	apply : "(" "apply" cycle applycommands ")"
		;
	applycommands : applycommands applycommand
		| applycommand
		|
		;
	applycommand : logicInput
		| logicOutput
		| comment
		| userData
		;
	arc : "(" "arc" pointValue pointValue
		  pointValue (p_arc) ")"
		;
	array : "(" "array" (p_array) nameDef integerValue
		  integervaluelist ")"
		;
	arrayMacro : "(" "arraymacro" plug ")"
		;
	arrayRelatedInfo : "(" "arrayrelatedinfo" arrayrelatedspec comudlist ")"
		;
	arrayrelatedspec : arrayMacro
		| arraySite
		| baseArray
		;
	arraySite : "(" "arraysite" socket ")"
		;
	atLeast : "(" "atleast" numberValue ")"
		;
	atMost : "(" "atmost" numberValue ")"
		;
	author : "(" "author" stringToken ")"
		;
	baseArray : "(" "basearray" ")"
		;
	becomes : "(" "becomes" becomesspec ")"
		;
	becomesspec : logicNameRef
		| logicList
		| logicOneOf
		;
	between : "(" "between" betweenspeca betweenspecb ")"
		;
	betweenspeca : atLeast
		| greaterThan
		;
	betweenspecb : atMost
		| lessThan
		;
	boolean : "(" "boolean" booleancommands ")"
		;
	booleancommands : booleancommands booleancommand
		| booleancommand
		|
		;
	booleancommand : booleanValue
		| booleanDisplay
		| boolean
		;
	booleanDisplay : "(" "booleandisplay" booleanValue displaylist ")"
		;
	booleanMap : "(" "booleanmap" booleanValue ")"
		;
	booleanValue : false
		| true
		;
	borderPattern : "(" "borderpattern" integerValue integerValue
		  boolean ")"
		;
	borderWidth : "(" "borderwidth" integerValue ")"
		;
	boundingBox : "(" "boundingbox" rectangle (p_boundingbox) ")"
		;
	cell : "(" "cell" (p_incstk(6)) cellNameDef (p_cellname) cellType
		 cellcommands (p_cellend) ")"
		;
	cellcommands : cellcommands cellcommand
		| cellcommand
		|
		;
	cellcommand : status
		| view
		| viewMap
		| property
		| comment
		| userData
		;
	cellNameDef : nameDef
		;
	cellNameRef : nameRef
		;
	cellRef : "(" "cellref" (p_incstk(2)) cellNameRef (p_cellref)
		  optlibraryRef (p_decstk(2)) ")"
		;
	optcellref :  cellRef
		|
		;
	cellType : "(" "celltype" celltypespec ")"
		;
	celltypespec : "generic" (p_cellcode(0))
		| "tie" (p_cellcode(1))
		| "ripper" (p_cellcode(2))
		;
	change : "(" "change" changespec transbeclist ")"
		;
	changespec : portNameRef
		| portRef
		| portList
		;
	circle : "(" "circle" (p_incstk(1)) pointValue pointValue
		  propertylist (p_circle) ")"
		;
	color : "(" "color" scaledInteger scaledInteger scaledInteger ")"
		;
	comment : "(" "comment" stringlist ")"
		;
	commentlist : commentlist comment
		| comment
		|
		;
	comud : comment
		| userData
		;
	comudlist : comudlist comud
		| comud
		|
		;
	commentGraphics : "(" "commentgraphics" (p_incstk(4))
		  commentgrcommands (p_decstk(4)) ")"
		;
	commentgrcommands : commentgrcommands commentgrcommand
		| commentgrcommand
		|
		;
	commentgrcommand : annotate
		| figure
		| instance
		| boundingBox
		| property
		| comment
		| userData
		;
	compound : "(" "compound" (p_incstk(2))
		  logicnamereflist (p_decstk(2)) ")"
		;
	connectLocation : "(" "connectlocation" figurelist (p_connectloc) ")"
		;
	contents : "(" "contents" (p_incstk(4))
		  contentscommands (p_decstk(4)) ")"
		;
	contentscommands : contentscommands contentscommand
		| contentscommand
		|
		;
	contentscommand : instance
		| offPageConnector
		| figure
		| section
		| net
		| netBundle
		| page
		| commentGraphics
		| portImplementation
		| timing
		| simulate
		| when
		| follow
		| logicPort
		| boundingBox
		| comment
		| userData
		;
	cornerType : "(" "cornertype" cornertypespec ")"
		;
	cornertypespec : "extend"
		| "round"
		| "truncate"
		;
	criticality : "(" "criticality" criticalityspec ")"
		;
	criticalityspec : integerValue
		| integerDisplay
		;
	currentMap : "(" "currentmap" miNoMaxValue ")"
		;
	curve : "(" "curve" arcpointvallist ")"
		;
	cycle : "(" "cycle" integerValue optduration ")"
		;
	dataOrigin : "(" "dataorigin" stringToken optversion ")"
		;
	dcFaninLoad : "(" "dcfaninload" numvaldisp ")"
		;
	dcFanoutLoad : "(" "dcfanoutload" numvaldisp ")"
		;
	dcMaxFanin : "(" "dcmaxfanin" numvaldisp ")"
		;
	dcMaxFanout : "(" "dcmaxfanout" numvaldisp ")"
		;
	delay : "(" "delay" minomaxvaldisp ")"
		;
	delta : "(" "delta" (p_incstk(1)) pointvaluelist (p_decstk(1)) ")"
		;
	derivation : "(" "derivation" derivationspec ")"
		;
	derivationspec : "calculated"
		| "measured"
		| "required"
		;
	design : "(" "design" (p_incstk(2)) designNameDef cellRef
		  designcommands (p_decstk(2)) ")"
		;
	designcommands : designcommands designcommand
		| designcommand
		|
		;
	designcommand : status
		| property
		| comment
		| userData
		;
	designator : "(" "designator" (p_designator)
		 stringvaldisp (p_designatorend) ")"
		;
	designNameDef : nameDef
		;
	difference : "(" "difference" figgrefoplist ")"
		;
	direction : "(" "direction" directionspec ")"
		;
	directionspec : "inout" (p_pintyp)
		| "input" (p_pintyp)
		| "output" (p_pintyp)
		;
	display : "(" "display" (p_display) dispgroup
		  displaycommands (p_displayend) ")"
		;
	displaycommands : displaycommands displaycommand
		| displaycommand
		|
		;
	displaycommand : justify
		| orientation
		| origin
		;
	displaylist : displaylist display
		| display
		|
		;
	dispgroup : figureGroupNameRef (p_dispgroup)
		| figureGroupOverride (p_dispgroup)
		;
	dominates : "(" "dominates" (p_incstk(2))
		  logicnamereflist (p_decstk(2)) ")"
		;
	dot : "(" "dot" (p_incstk(1)) pointValue propertylist (p_dot) ")"
		;
	duration : "(" "duration" numberValue ")"
		;
	optduration : duration
		|
		;
	e : "(" "e" integerToken (p_expnumber(0))
		  integerToken (p_expnumber(1)) ")"
		;
	edifFileNameDef : nameDef
		;
	edifLevel : "(" "ediflevel" integerToken ")"
		;
	edifVersion : "(" "edifversion" integerToken integerToken
		  integerToken ")"
		;
	enclosureDistance : "(" "enclosuredistance" (p_incstk(2)) ruleNameDef
		  figureGroupObject figureGroupObject enclosuredistancespc
		  comudlist (p_decstk(2)) ")"
		;
	enclosuredistancespc : range
		| singleValueSet
		;
	endType : "(" "endtype" endtypespec ")"
		;
	endtypespec : "extend"
		| "round"
		| "truncate"
		;
	entry : "(" "entry" entryspeca entryspecb entryspecc ")"
		;
	entryspeca : match
		| change
		| steady
		;
	entryspecb : logicRef
		| portRef
		| noChange
		| table
		;
	entryspecc : atMost
		| lessThan
		|
		;
	event : "(" "event" eventspec transbeclist ")"
		;
	eventlist :  eventlist event
		| event
		|
		;
	eventspec : portRef
		| portList
		| portGroup
		| netRef
		| netGroup
		| transition
		| becomes
		;
	exactly : "(" "exactly" numberValue ")"
		;
	external : "(" "external" (p_incstk(2)) libraryNameDef edifLevel
		  technology externalcommands (p_decstk(2)) ")"
		;
	externalcommands : externalcommands externalcommand
		| externalcommand
		|
		;
	externalcommand : status
		| cell
		| comment
		| userData
		;
	fabricate : "(" "fabricate" (p_incstk(2)) layerNameDef
		  figureGroupNameRef (p_decstk(2)) ")"
		;
	false : "(" "false" (p_false) ")"
		;
	figure : "(" "figure" dispgroup figurecommands ")"
		;
	figurecommands : figurecommands figurecommand
		| figurecommand
		|
		;
	figurecommand : circle
		| dot
		| openShape
		| path
		| polygon
		| rectangle
		| shape
		| comment
		| userData
		;
	figurelist : figurelist figure
		| figure
		|
		;
	figureArea : "(" "figurearea" (p_incstk(2)) ruleNameDef
		  figureGroupObject rangesingval comudlist (p_decstk(2)) ")"
		;
	figureGroup : "(" "figuregroup" (p_incstk(2)) figureGroupNameDef
		  figuregroupcommands (p_decstk(2)) ")"
		;
	figuregroupcommands : figuregroupcommands figuregroupcommand
		| figuregroupcommand
		|
		;
	figuregroupcommand : cornerType
		| endType
		| pathWidth
		| borderWidth
		| color
		| fillPattern
		| borderPattern
		| textHeight
		| visible
		| includeFigureGroup
		| property
		| comment
		| userData
		;
	figureGroupNameDef : nameDef
		;
	figureGroupNameRef : nameDef
		;
	figureGroupObject : "(" "figuregroupobject" (p_incstk(2))
		  figuregroupobjectspc (p_decstk(2)) ")"
		;
	figuregroupobjectspc : figureGroupNameRef
		| figureGroupRef
		| figureOp
		;
	figureGroupOverride : "(" "figuregroupoverride"
		  figureGroupNameRef (p_incstk(2))
		  figuregovrcommands (p_decstk(2)) ")"
		;
	figuregovrcommands : figuregovrcommands figuregovrcommand
		| figuregovrcommand
		|
		;
	figuregovrcommand : cornerType
		| endType
		| pathWidth
		| borderWidth
		| color
		| fillPattern
		| borderPattern
		| textHeight
		| visible
		| property
		| comment
		| userData
		;
	figureGroupRef : "(" "figuregroupref" (p_incstk(2)) figureGroupNameRef
		  optlibraryref (p_decstk(2)) ")"
		;
	figureOp : difference
		| intersection
		| inverse
		| oversize
		| union
		;
	figgrefoplist : figgrefoplist figgrefop
		| figgrefop
		;
	figgrefop : figureGroupRef
		| figureOp
		;
	figurePerimeter : "(" "figureperimeter" (p_incstk(2)) ruleNameDef
		  figureGroupObject rangesingval comudlist (p_decstk(2)) ")"
		;
	figureWidth : "(" "figurewidth" (p_incstk(2)) ruleNameDef
		  figureGroupObject rangesingval comudlist (p_decstk(2)) ")"
		;
	fillPattern : "(" "fillpattern" integerValue integerValue boolean ")"
		;
	follow : "(" "follow" (p_incstk(2)) portnref followspec
		  optdelloaddelay (p_decstk(2)) ")"
		;
	followspec : portRef
		| table
		;
	forbiddenEvent : "(" "forbiddenevent" timeIntervall eventlist ")"
		;
	form : "(" keywordNameRef datalist ")"
		;
	globalPortRef : "(" (p_incstk(2)) "globalportref"
		  portNameRef (p_decstk(2)) ")"
		;
	greaterThan : "(" "greaterthan" numberValue ")"
		;
	gridMap : "(" "gridmap" numberValue numberValue ")"
		;
	ignore : "(" "ignore" ")"
		;
	includeFigureGroup : "(" "includefiguregroup" figgrefop ")"
		;
	initial : "(" "initial" ")"
		;
	instance : "(" "instance" (p_instancestart) instanceNameDef (p_instance)
		  viewlistcommand instancecommands (p_instanceend) ")"
		;
	instancecommands : instancecommands instancecommand
		| instancecommand
		|
		;
	instancecommand : transform
		| parameterAssign
		| portInstance
		| designator
		| timing
		| property
		| comment
		| userData
		;
	instanceBackAnnotate : "(" "instancebackannotate" (p_instbackanno)
		 instanceRef instancebaspeccmds (p_instbackannoend) ")"
		;
	instancebaspeccmds : instancebaspeccmds instancebaspec
		| instancebaspec
		|
		;
	instancebaspec : designator
		| timing
		| property
		| comment
		;
	instanceGroup : "(" "instancegroup" instancereflist ")"
		;
	instanceMap : "(" "instancemap" instancemapcommands ")"
		;
	instancemapcommands : instancemapcommands instancemapcommand
		| instancemapcommand
		|
		;
	instancemapcommand : instanceRef
		| instanceGroup
		| comment
		| userData
		;
	instanceNameDef : nameDef
		| array
		;
	instanceNameRef : nameDef
		| member
		;
	instanceRef : "(" "instanceref" (p_incstk(2)) instanceNameRef
		  instancerefspec (p_instancerefend) ")"
		;
	instancerefspec : instanceRef
		| viewRef
		|
		;
	instancereflist : instancereflist instanceRef
		| instanceRef
		|
		;
	integer : "(" "integer" integercommands ")"
		;
	integercommands : integercommands integercommand
		| integercommand
		|
		;
	integercommand : integerValue
		| integerDisplay
		| integer
		;
	integerDisplay : "(" "integerdisplay" integerValue displaylist ")"
		;
	integerValue : integerToken
		;
	integervaluelist : integervaluelist integerValue
		| integerValue
		|
		;
	interface : "(" "interface" interfacecommands ")"
		;
	interfacecommands : interfacecommands interfacecommand
		| interfacecommand
		|
		;
	interfacecommand : port
		| portBundle
		| symbol
		| protectionFrame
		| arrayRelatedInfo
		| parameter
		| joined
		| mustJoin
		| weakJoined
		| permutable
		| timing
		| simulate
		| designator
		| property
		| comment
		| userData
		;
	interFigureGroupSpac : "(" "interfiguregroupspac" (p_incstk(2))
		  ruleNameDef figureGroupObject figureGroupObject
		  rangesingval comudlist (p_decstk(2)) ")"
		;
	intersection : "(" "intersection" figgrefoplist ")"
		;
	intraFigureGroupSpac : "(" "intrafiguregroupspac" (p_incstk(2))
		  ruleNameDef figureGroupObject rangesingval
		  comudlist (p_decstk(2)) ")"
		;
	inverse : "(" "inverse" figgrefop ")"
		;
	isolated : "(" "isolated" ")"
		;
	joined : "(" "joined" joinedcommands ")"
		;
	joinedcommands : joinedcommands joinedcommand
		| joinedcommand
		|
		;
	joinedcommand : portRef
		| portList
		| globalPortRef
		;
	justify : "(" "justify" justifyspec ")"
		;
	justifyspec : "upperleft" (p_justify(0))
		| "uppercenter" (p_justify(1))
		| "upperright" (p_justify(2))
		| "centerleft" (p_justify(4))
		| "centercenter" (p_justify(5))
		| "centerright" (p_justify(6))
		| "lowerleft" (p_justify(8))
		| "lowercenter" (p_justify(9))
		| "lowerright" (p_justify(10))
		;
	keywordDisplay : "(" "keyworddisplay" (p_incstk(2))
		  keywordNameRef (p_keydispname)
		  displaylist (p_keydispend) ")"
		;
	keywordLevel : "(" "keywordlevel" integerToken ")"
		;
	keywordMap : "(" "keywordmap" keywordLevel commentlist ")"
		;
	keywordNameRef : identifier (p_namedef(0))
		;
	layerNameDef : nameRef
		;
	lessThan : "(" "lessthan" numberValue ")"
		;
	library	: "(" "library" (p_incstk(2)) libraryNameDef edifLevel
		  technology librarycommands (p_decstk(2)) ")"
		;
	librarycommands : librarycommands librarycommand
		| librarycommand
		|
		;
	librarycommand : status
		| cell
		| comment
		| userData
		;
	libraryNameDef : nameDef
		;
	libraryNameRef : nameRef
		;
	optlibraryRef : libraryRef
		|
		;
	libraryRef : "(" "libraryref" (p_incstk(2))
		  libraryNameRef (p_decstk(2)) ")"
		;
	optlibraryref : libraryRef
		|
		;
	listOfNets : "(" "listofnets" netlist ")"
		;
	listOfPorts : "(" "listofports" listofportscommands ")"
		;
	listofportscommands : listofportscommands listofportscommand
		| listofportscommand
		|
		;
	listofportscommand : port
		| portBundle
		;
	loadDelay : "(" "loaddelay" minomaxvaldisp minomaxvaldisp ")"
		;
	delloaddelay : delay
		| loadDelay
		;
	optdelloaddelay : delloaddelay
		|
		;
	logicAssign : "(" "logicassign" portnref logicassignspec
		  optdelloaddelay ")"
		;
	logicassignspec : portRef
		| logicRef
		| table
		;
	logicInput : "(" "logicinput" (p_incstk(2)) logicinputspec
		  logicWaveform (p_decstk(2)) ")"
		;
	logicinputspec : portNameRef
		| portRef
		| portList
		;
	logicList : "(" "logiclist" (p_incstk(2))
		  logiclistcommands (p_decstk(2)) ")"
		;
	logiclistcommands : logiclistcommands logiclistcommand
		| logiclistcommand
		|
		;
	logiclistcommand : logicNameRef
		| logicOneOf
		| ignore
		;
	logicMapInput : "(" "logicmapinput" logicreflist ")"
		;
	logicMapOutput : "(" "logicoutput" logicreflist ")"
		;
	logicNameDef : nameDef
		;
	logicNameRef : nameDef
		;
	logicnamereflist : logicnamereflist logicNameRef
		| logicNameRef
		|
		;
	logicOneOf : "(" "logiconeof" logiconeofcommands ")"
		;
	logiconeofcommands : logiconeofcommands logiconeofcommand
		| logiconeofcommand
		|
		;
	logiconeofcommand : logicNameRef
		| logicList
		;
	logicOutput : "(" "logicoutput" logicoutputspec logicWaveform ")"
		;
	logicoutputspec : portNameRef
		| portRef
		| portList
		;
	logicPort : "(" "logicport" logicportcommands ")"
		;
	logicportcommands : logicportcommands logicportcommand
		| logicportcommand
		|
		;
	logicportcommand : property
		| comment
		| userData
		;
	logicRef : "(" "logicref" (p_incstk(2)) logicNameRef
		  optlibraryref (p_decstk(2)) ")"
		;
	logicreflist : logicreflist logicRef
		| logicRef
		|
		;
	logicValue : "(" "logicvalue" (p_incstk(2)) logicNameDef
		  logicvaluecommands (p_decstk(2)) ")"
		;
	logicvaluecommands : logicvaluecommands logicvaluecommand
		| logicvaluecommand
		|
		;
	logicvaluecommand : voltageMap
		| currentMap
		| booleanMap
		| compound
		| weak
		| strong
		| dominates
		| logicMapOutput
		| logicMapInput
		| isolated
		| resolves
		| property
		| comment
		| userData
		;
	logicWaveform : "(" "logicwaveform" logicwfcommands ")"
		;
	logicwfcommands : logicwfcommands logicwfcommand
		| logicwfcommand
		|
		;
	logicwfcommand : logicNameRef
		| logicList
		| logicOneOf
		| ignore
		;
	maintain : "(" "maintain" portnref optdelloaddelay ")"
		;
	match : "(" "match" matchspeca matchspecb ")"
		;
	matchspeca : portNameRef
		| portRef
		| portList
		;
	matchspecb : logicNameRef
		| logicList
		| logicOneOf
		;
	member : "(" "member" (p_incstk(2)) nameRef (p_member)
		 integerValue (p_membnum) integervaluelist (p_decstk(2)) ")"
		;
	miNoMax : "(" "minomax" minomaxspec ")"
		;
	minomaxspec : miNoMaxValue
		| miNoMaxDisplay
		| miNoMax
		;
	miNoMaxDisplay : "(" "minomaxdisplay" miNoMaxValue displaylist ")"
		;
	miNoMaxValue : "(" "minomaxvalue" minomaxvaluespec ")"
		;
	minomaxvaluespec : numberValue
		| mnm
		;
	minomaxvaldisp : miNoMaxValue
		| miNoMaxDisplay
		;
	mnm : "(" "mnm" mnmspec mnmspec mnmspec ")"
		;
	mnmspec : numberValue
		| undefined
		| unconstrained
		;
	multipleValueSet : "(" "multiplevalueset" rangevectorlist ")"
		;
	mustJoin : "(" "mustjoin" mustjoincommands ")"
		;
	mustjoincommands : mustjoincommands mustjoincommand
		| mustjoincommand
		|
		;
	mustjoincommand : portRef
		| portList
		| weakJoined
		| joined
		;
	name : "(" "name" identifier (p_name) displaylist (p_nameend) ")"
		;
	nameDef : identifier (p_namedef(0))
		| name
		| rename
		;
	nameRef : identifier (p_namedef(0))
		| name
		;
	net : "(" "net" (p_net) netNameDef (p_netname) joined
		  netcommands (p_netend) ")"
		;
	netcommands : netcommands netcommand
		| netcommand
		|
		;
	netcommand : criticality
		| netDelay
		| figure
		| net
		| instance
		| commentGraphics
		| property
		| comment
		| userData
		;
	netlist : netlist net
		| net
		|
		;
	netBackAnnotate : "(" "netbackannotate" netRef netbacommands ")"
		;
	netbacommands : netbacommands netbacommand
		| netbacommand
		|
		;
	netbacommand : netDelay
		| criticality
		| property
		| comment
		;
	netBundle : "(" "netbundle" (p_incstk(2)) netNameDef listOfNets
		  netbundlecommands (p_decstk(2)) ")"
		;
	netbundlecommands : netbundlecommands netbundlecommand
		| netbundlecommand
		|
		;
	netbundlecommand : figure
		| commentGraphics
		| property
		| comment
		| userData
		;
	netDelay : "(" "netdelay" derivation delay transbeclist ")"
		;
	netGroup : "(" "netgroup" netgroupcommands ")"
		;
	netgroupcommands : netgroupcommands netgroupcommand
		| netgroupcommand
		|
		;
	netgroupcommand : netNameRef
		| netRef
		;
	netMap : "(" "netmap" netmapcommands ")"
		;
	netmapcommands : netmapcommands netmapcommand
		| netmapcommand
		|
		;
	netmapcommand : netRef
		| netGroup
		| comment
		| userData
		;
	netNameDef : nameDef
		| array
		;
	netNameRef : nameRef
		| member
		;
	netRef : "(" "netref" (p_incstk(2)) netNameRef
		  netrefspec (p_decstk(2)) ")"
		;
	netrefspec : netRef
		| instanceRef
		| viewRef
		|
		;
	noChange : "(" "nochange" ")"
		;
	nonPermutable : "(" "nonpermutable" nonpermutablespec ")"
		;
	nonpermutablespec : portRef
		| permutable
		;
	notAllowed : "(" "notallowed" (p_incstk(2)) ruleNameDef
		  figureGroupObject comudlist (p_decstk(2)) ")"
		;
	notchSpacing : "(" "notchspacing" (p_incstk(2)) ruleNameDef
		  figureGroupObject rangesingval comudlist (p_decstk(2)) ")"
		;
	number : "(" "number" numbercommands ")"
		;
	numbercommands : numbercommands numbercommand
		| numbercommand
		|
		;
	numbercommand : numberValue
		| numberDisplay
		| number
		;
	numberDefinition : "(" "numberdefinition" numdefcommands ")"
		;
	numdefcommands : numdefcommands numdefcommand
		| numdefcommand
		|
		;
	numdefcommand : scale
		| gridMap
		| comment
		;
	numberDisplay : "(" "numberdisplay" numberValue displaylist ")"
		;
	numberValue : scaledInteger
		;
	numvaldisp : numberValue
		| numberDisplay
		;
	offPageConnector : "(" "offpageconnector" (p_incstk(2)) portNameDef
		  offpageconcommands (p_decstk(2)) ")"
		;
	offpageconcommands : offpageconcommands offpageconcommand
		| offpageconcommand
		|
		;
	offpageconcommand : unused
		| property
		| comment
		| userData
		;
	offsetEvent : "(" "offsetevent" event numberValue ")"
		;
	openShape : "(" "openshape" (p_incstk(1)) curve
		  propertylist (p_polygon(0)) ")"
		;
	orientation : "(" "orientation" orispec ")"
		;
	orispec : "r0" (p_ori(0))
		| "r90" (p_ori(1))
		| "r180" (p_ori(2))
		| "r270" (p_ori(3))
		| "mx" (p_ori(4))
		| "my" (p_ori(6))
		| "myr90" (p_ori(7))
		| "mxr90" (p_ori(5))
		;
	origin : "(" "origin" (p_incstk(1)) pointValue (p_origin) ")"
		;
	overhangDistance : "(" "overhangdistance" (p_incstk(2)) ruleNameDef
		  figureGroupObject figureGroupObject rangesingval
		  comudlist (p_decstk(2)) ")"
		;
	overlapDistance : "(" "overlapdistance" (p_incstk(2)) ruleNameDef
		  figureGroupObject figureGroupObject rangesingval
		  comudlist (p_decstk(2)) ")"
		;
	oversize : "(" "oversize" integerValue figgrefop cornerType ")"
		;
	owner : "(" "owner" stringToken ")"
		;
	page : "(" "page" (p_pagestart) instanceNameDef (p_page)
		  pagecommands (p_pageend) ")"
		;
	pagecommands : pagecommands pagecommand
		| pagecommand
		|
		;
	pagecommand : instance
		| net
		| netBundle
		| commentGraphics
		| portImplementation
		| pageSize
		| boundingBox
		| comment
		| userData
		;
	pageSize : "(" "pagesize" rectangle (p_boundingbox) ")"
		;
	parameter : "(" "parameter" (p_incstk(2)) valueNameDef typedValue
		  optunit (p_decstk(2)) ")"
		;
	parameterAssign : "(" "parameterassign" (p_incstk(2)) valueNameDef
		  typedValue (p_decstk(2)) ")"
		;
	parameterDisplay : "(" "parameterdisplay" (p_incstk(2)) valueNameRef
		  displaylist (p_decstk(2)) ")"
		;
	path : "(" "path" (p_incstk(1)) pointList
		  propertylist (p_polygon(0)) ")"
		;
	pathDelay : "(" "pathdelay" delay eventlist ")"
		;
	pathWidth : "(" "pathwidth" integerValue ")"
		;
	permutable : "(" "permutable" permutablespec ")"
		;
	permutablespec : portRef
		| permutable
		| nonPermutable
		;
	physicalDesignRule : "(" "physicaldesignrule"
		  physicaldrcommands ")"
		;
	physicaldrcommands : physicaldrcommands physicaldrcommand
		| physicaldrcommand
		|
		;
	physicaldrcommand : figureWidth
		| figureArea
		| rectangleSize
		| figurePerimeter
		| overlapDistance
		| overhangDistance
		| enclosureDistance
		| interFigureGroupSpac
		| intraFigureGroupSpac
		| notchSpacing
		| notAllowed
		| figureGroup
		| comment
		| userData
		;
	plug : "(" "plug" socketsetlist ")"
		;
	point : "(" "point" (p_incstk(1)) pointcommands (p_decstk(1)) ")"
		;
	pointcommands : pointcommands  pointcommand
		| pointcommand
		|
		;
	pointcommand : pointValue
		| pointDisplay
		| point
		;
	pointDisplay : "(" "pointdisplay" (p_incstk(1)) pointValue
		  displaylist (p_decstk(1)) ")"
		;
	pointList : "(" "pointlist" pointvaluelist ")"
		;
	pointValue : pt (p_pointvalue)
		;
	pointvaluelist : pointvaluelist pointValue
		| pointValue
		|
		;
	arcpointval : arc
		| pointValue
		;
	arcpointvallist : arcpointvallist arcpointval
		| arcpointval
		|
		;
	polygon : "(" "polygon" (p_incstk(1)) pointList
		  optproperty (p_polygon(1)) ")"
		;
	port : "(" "port" (p_portstart) portNameDef (p_pinname)
		  portcommands (p_portend) ")"
		;
	portcommands : portcommands  portcommand
		| portcommand
		|
		;
	portcommand : direction
		| unused
		| designator
		| dcFaninLoad
		| dcFanoutLoad
		| dcMaxFanin
		| dcMaxFanout
		| acLoad
		| portDelay
		| property
		| comment
		| userData
		;
	portBackAnnotate : "(" "portbackannotate" (p_incstk(2)) portRef
		  portbacommands (p_decstk(2)) ")"
		;
	portbacommands : portbacommands portbacommand
		| portbacommand
		|
		;
	portbacommand : designator
		| dcFaninLoad
		| dcFanoutLoad
		| dcMaxFanin
		| dcMaxFanout
		| acLoad
		| portDelay
		| property
		| comment
		;
	portBundle : "(" "portbundle" (p_incstk(2)) portNameDef listOfPorts
		  portbundlecommands (p_decstk(2)) ")"
		;
	portbundlecommands : portbundlecommands portbundlecommand
		| portbundlecommand
		|
		;
	portbundlecommand : property
		| comment
		| userData
		;
	portDelay : "(" "portdelay" derivation delloaddelay transbeclist ")"
		;
	portGroup : "(" "portgroup" (p_incstk(2))
		  portnreflist (p_decstk(2)) ")"
		;
	portImplementation : "(" "portimplementation" (p_portimp)
		  portnref portimpcommands (p_portimpend) ")"
		;
	portimpcommands : portimpcommands portimpcommand
		| portimpcommand
		|
		;
	portimpcommand : connectLocation
		| figure
		| instance
		| commentGraphics
		| propertyDisplay
		| keywordDisplay
		| property
		| comment
		| userData
		;
	portInstance : "(" "portinstance" (p_portinst) portnref
		  portinstancecommands (p_portinstend) ")"
		;
	portinstancecommands : portinstancecommands portinstancecommand
		| portinstancecommand
		|
		;
	portinstancecommand : unused
		| designator
		| dcFaninLoad
		| dcFanoutLoad
		| dcMaxFanin
		| dcMaxFanout
		| acLoad
		| portDelay
		| property
		| comment
		| userData
		;
	portList : "(" "portlist" (p_portlist)
		  portnreflist (p_portlistend) ")"
		;
	portListAlias : "(" "portlistalias" (p_incstk(2)) portNameDef
		  portList (p_decstk(2)) ")"
		;
	portMap : "(" "portmap" portmapcommands ")"
		;
	portmapcommands : portmapcommands portmapcommand
		| portmapcommand
		|
		;
	portmapcommand : portRef
		| portGroup
		| comment
		| userData
		;
	portNameDef : nameDef
		| array
		;
	portNameRef : nameRef
		| member
		;
	portnref : portNameRef
		| portRef
		;
	portnreflist : portnreflist portnref
		| portnref
		|
		;
	portRef : "(" "portref" (p_incstk(2)) portNameRef
		  portrefspec (p_decstk(2)) ")"
		;
	portrefspec : portRef
		| instanceRef
		| viewRef
		|
		;
	programm : "(" "program" stringToken optversion ")"
		;
	property : "(" "property" (p_incstk(2)) propertyNameDef (p_propname)
		  typedValue (p_propval)
		  propcommands (p_decstk(2)) ")"
		;
	propcommands : propcommands  propcommand
		| propcommand
		|
		;
	propcommand : owner
		| unit
		| property
		| comment
		;
	propertylist : propertylist property
		| property
		|
		;
	optproperty : property
		|
		;
	propertyDisplay : "(" "propertydisplay" (p_incstk(2))
		  propertyNameRef (p_propdispname)
		  displaylist (p_propdispend) ")"
		;
	propertyNameDef : nameDef
		;
	propertyNameRef : nameRef
		;
	protectionFrame : "(" "protectionframe" (p_incstk(4))
		  protectionfrcommands (p_decstk(4)) ")"
		;
	protectionfrcommands : protectionfrcommands protectionfrcommand
		| protectionfrcommand
		|
		;
	protectionfrcommand : portImplementation
		| figure
		| instance
		| commentGraphics
		| boundingBox
		| propertyDisplay
		| keywordDisplay
		| parameterDisplay
		| property
		| comment
		| userData
		;
	pt : "(" "pt" coord (p_xcoord) coord (p_ycoord) ")"
		;
	range :  atLeast
		| atMost
		| between
		| exactly
		| greaterThan
		| lessThan
		;
	rangelist : rangelist range
		| range
		|
		;
	rangeVector : "(" "rangevector" rangesingvallist ")"
		;
	rangevectorlist : rangevectorlist rangeVector
		| rangeVector
		|
		;
	rangesingval : range
		| singleValueSet
		;
	rangesingvallist : rangesingvallist rangesingval
		| rangesingval
		|
		;
	rectangle : "(" "rectangle" (p_incstk(1)) pointValue pointValue
		  propertylist (p_rect) ")"
		;
	rectangleSize : "(" "rectanglesize" (p_incstk(2)) ruleNameDef
		  figureGroupObject rectanglesizespec
		  comudlist (p_decstk(2)) ")"
		;
	rectanglesizespec : rangeVector
		| multipleValueSet
		;
	rename : "(" "rename" renamespeca (p_rename(1))
		  renamespecb (p_rename(0)) ")"
		;
	renamespeca : identifier (p_namedef(0))
		| name
		;
	renamespecb : stringValue (p_namedef(4))
		| stringDisplay
		;
	resolves : "(" "resolves" (p_incstk(2))
		  logicnamereflist (p_decstk(2)) ")"
		;
	ruleNameDef : nameDef
		;
	scale : "(" "scale" numberValue (p_scale(1))
		  numberValue (p_scale(0)) unit ")" (p_scale(2))
		;
	scaledInteger : integerToken
		| e
		;
	scaleX : "(" "scalex" integerValue (p_scalex(0))
		 integerValue (p_scalex(1)) ")"
		;
	scaleY : "(" "scaley" integerValue integerValue ")"
		;
	section : "(" "section" stringValue sectioncommands ")"
		;
	sectioncommands : sectioncommands sectioncommand
		| sectioncommand
		|
		;
	sectioncommand : stringValue
		| section
		| instance
		;
	shape : "(" "shape" (p_incstk(1)) curve
		  propertylist (p_polygon(1)) ")"
		;
	simulate : "(" "simulate" (p_incstk(2)) simulateNameDef
		  simulatecommands (p_decstk(2)) ")"
		;
	simulatecommands : simulatecommands simulatecommand
		| simulatecommand
		|
		;
	simulatecommand : portListAlias
		| waveValue
		| apply
		| comment
		| userData
		;
	simulateNameDef : nameDef
		;
	simulationInfo : "(" "simulationinfo" siminfocommands ")"
		;
	siminfocommands : siminfocommands siminfocommand
		| siminfocommand
		|
		;
	siminfocommand : logicValue
		| comment
		| userData
		;
	singleValueSet : "(" "singlevalueset" rangelist ")"
		;
	site : "(" "site" viewRef opttransform ")"
		;
	sitelist : sitelist site
		| site
		|
		;
	socket : "(" "socket" optsymmetry ")"
		;
	socketSet : "(" "socketset" symmetry sitelist ")"
		;
	socketsetlist : socketsetlist socketSet
		| socketSet
		|
		;
	status : "(" "status" statuscommands ")"
		;
	statuscommands : statuscommands statuscommand
		| statuscommand
		|
		;
	statuscommand : written
		| comment
		| userData
		;
	steady : "(" "steady" steadyspec duration opttransbec ")"
		;
	steadyspec : portNameRef
		| portRef
		| portList
		|
		;
	stringx : "(" "string" stringcommands ")"
		;
	stringcommands : stringcommands stringcommand
		| stringcommand
		|
		;
	stringcommand : stringValue
		| stringDisplay
		| stringx
		;
	stringDisplay : "(" "stringdisplay" stringValue (p_strdisp)
		  displaylist ")" (p_strdispend)
		;
	stringValue : DQSTR (p_strval)
		;
	stringvaldisp : stringValue
		| stringDisplay
		;
	strong : "(" "strong" (p_incstk(2)) logicNameRef (p_decstk(2)) ")"
		;
	symbol : "(" "symbol" (p_symbol) symbolcommands (p_symbolend) ")"
		;
	symbolcommands : symbolcommands symbolcommand
		| symbolcommand
		|
		;
	symbolcommand : portImplementation
		| figure
		| annotate
		| instance
		| commentGraphics
		| pageSize
		| boundingBox
		| propertyDisplay
		| keywordDisplay
		| parameterDisplay
		| property
		| comment
		| userData
		;
	symmetry : "(" "symmetry" transform ")"
		;
	optsymmetry : symmetry
		|
		;
	table : "(" "table" tablecommands ")"
		;
	tablecommands : tablecommands tablecommand
		| tablecommand
		|
		;
	tablecommand : entry
		| tableDefault
		;
	tableDefault : "(" "tabledefault" tabledefaultspec optdelloaddelay ")"
		;
	tabledefaultspec : logicRef
		| portRef
		| noChange
		| table
		;
	technology : "(" "technology" numberDefinition techcommands ")"
		;
	techcommands : techcommands techcommand
		| techcommand
		|
		;
	techcommand : figureGroup
		| fabricate
		| simulationInfo
		| physicalDesignRule
		| comment
		| userData
		;
	textHeight : "(" "textheight" coord (p_size) ")"
		;
	timeIntervall : "(" "timeintervall" timeintervallspeca
		  timeintervallspecb ")"
		;
	timeintervallspeca : event
		| offsetEvent
		;
	timeintervallspecb : event
		| offsetEvent
		| duration
		;
	timeStamp : "(" "timestamp" integerToken integerToken integerToken
		  integerToken integerToken integerToken ")"
		;
	timing : "(" "timing" derivation timingcommands ")"
		;
	timingcommands : timingcommands timingcommand
		| timingcommand
		|
		;
	timingcommand : pathDelay
		| forbiddenEvent
		| comment
		| userData
		;
	transform : "(" "transform" (p_transini) transformcommands
		 (p_transform) ")"
		;
	transformcommands : transformcommands transformcommand
		| transformcommand
		|
		;
	transformcommand : scaleX
		| scaleY
		| delta
		| orientation
		| origin
		;
	opttransform :  transform
		|
		;
	transition : "(" "transition" transitionspec
		  transitionspec ")"
		;
	transitionspec : logicNameRef
		| logicList
		| logicOneOf
		;
	transbec : transition
		| becomes
		;
	transbeclist : transbeclist transbec
		| transbec
		|
		;
	opttransbec : transbec
		|
		;
	trigger : "(" "trigger" triggercommands ")"
		;
	triggercommands : triggercommands triggercommand
		| triggercommand
		|
		;
	triggercommand : change
		| steady
		| initial
		;
	true : "(" "true" (p_true) ")"
		;
	typedValue : boolean
		| integer
		| miNoMax
		| number
		| point
		| stringx
		;
	unconstrained : "(" "unconstrained" ")"
		;
	undefined : "(" "undefined" ")"
		;
	union : "(" "union" figgrefoplist ")"
		;
	unit : "(" "unit" unitspec ")"
		;
	unitspec : "angle" (p_unit(0))
		| "capacitance" (p_unit(1))
		| "conductance" (p_unit(2))
		| "charge" (p_unit(3))
		| "current" (p_unit(4))
		| "distance" (p_unit(5))
		| "energy" (p_unit(6))
		| "flux" (p_unit(7))
		| "frequency" (p_unit(8))
		| "inductance" (p_unit(9))
		| "mass" (p_unit(10))
		| "power" (p_unit(11))
		| "resistance" (p_unit(12))
		| "temperature" (p_unit(13))
		| "time" (p_unit(14))
		| "voltage" (p_unit(15))
		;
	optunit : unit
		|
		;
	unused : "(" "unused" ")"
		;
	userData : "(" "userdata" identifier datalist ")"
		;
	valueNameDef : nameDef
		| array
		;
	valueNameRef : nameRef
		| member
		;
	version : "(" "version" stringToken ")"
		;
	optversion : version
		|
		;
	view : "(" "view" (p_incstk(2)) viewNameDef (p_view) viewType interface
		  viewcommands (p_decstk(2)) ")"
		;
	viewcommands : viewcommands viewcommand
		| viewcommand
		|
		;
	viewcommand : status
		| contents
		| comment
		| property
		| userData
		;
	viewList : "(" "viewlist" viewlistcommands ")"
		;
	viewlistcommands : viewlistcommands viewlistcommand
		| viewlistcommand
		|
		;
	viewlistcommand : viewRef
		| viewList
		;
	viewMap : "(" "viewmap" viewmapcommands ")"
		;
	viewmapcommands : viewmapcommands viewmapcommand
		| viewmapcommand
		|
		;
	viewmapcommand : portMap
		| portBackAnnotate
		| instanceMap
		| instanceBackAnnotate
		| netMap
		| netBackAnnotate
		| comment
		| userData
		;
	viewNameDef : nameDef
		;
	viewNameRef : nameRef
		;
	viewRef : "(" "viewref" (p_incstk(2)) viewNameRef
		  optcellref (p_decstk(2)) ")"
		;
	viewType : "(" "viewtype" viewtypespec ")"
		;
	viewtypespec : "behavior" (p_viewtype(2))
		| "document" (p_viewtype(3))
		| "graphic" (p_viewtype(1))
		| "logicmodel" (p_viewtype(4))
		| "masklayout" (p_viewtype(5))
		| "netlist" (p_viewtype(6))
		| "pcblayout" (p_viewtype(7))
		| "schematic" (p_viewtype(0))
		| "stranger" (p_viewtype(8))
		| "symbolic" (p_viewtype(9))
		;
	visible : "(" "visible" booleanValue (p_visible) ")"
		;
	voltageMap : "(" "voltagemap" miNoMaxValue ")"
		;
	waveValue : "(" "wavevalue" (p_incstk(2)) logicNameDef numberValue
		  logicWaveform (p_decstk(2)) ")"
		;
	weak : "(" "weak" (p_incstk(2)) logicNameRef (p_decstk(2)) ")"
		;
	weakJoined : "(" "weakjoined" weakjoinedcommands ")"
		;
	weakjoinedcommands : weakjoinedcommands weakjoinedcommand
		| weakjoinedcommand
		|
		;
	weakjoinedcommand : portRef
		| portList
		| joined
		;
	when : "(" "when" trigger whencommands ")"
		;
	whencommands : whencommands whencommand
		| whencommand
		|
		;
	whencommand : after
		| follow
		| logicAssign
		| maintain
		| comment
		| userData
		;
	written : "(" "written" timeStamp writecommands ")"
		;
	writecommands : writecommands writecommand
		| writecommand
		|
		;
	writecommand : author
		| programm
		| dataOrigin
		| property
		| comment
		| userData
		;
	datalist : datalist dataitem
		| dataitem
		|
		;
	dataitem :  integerToken
		| integer
		| stringToken
		| identifier
		| form
		;
	identifier : IDENT (p_ident)
		| terminal
		| "&" NUMBER (p_ident)
		| "&" IDENT (p_ident)
		| "&" DQSTR (p_ident)
		;
	coord : integerValue (p_fltcoord)
		;
	stringToken : DQSTR
		;
	stringlist : stringlist stringToken
		| stringToken
		|
		;
	integerToken : NUMBER (p_signed(0))
		| "+" NUMBER (p_signed(0))
		| "-" NUMBER (p_signed(1))
		;
	terminal : "capacitance" (p_ident)
		| "celltype" (p_ident)
		| "centercenter" (p_ident)
		| "centerleft" (p_ident)
		| "centerright" (p_ident)
		| "color" (p_ident)
		| "comment" (p_ident)
		| "conductance" (p_ident)
		| "current" (p_ident)
		| "designator" (p_ident)
		| "display" (p_ident)
		| "distance" (p_ident)
		| "delay" (p_ident)
		| "dot" (p_ident)
		| "e" (p_ident)
		| "energy" (p_ident)
		| "event" (p_ident)
		| "false" (p_ident)
		| "figuregroupoverride" (p_ident)
		| "frequency" (p_ident)
		| "graphic" (p_ident)
		| "inductance" (p_ident)
		| "input" (p_ident)
		| "instance" (p_ident)
		| "interface" (p_ident)
		| "justify" (p_ident)
		| "lowercenter" (p_ident)
		| "lowerleft" (p_ident)
		| "lowerright" (p_ident)
		| "name" (p_ident)
		| "net" (p_ident)
		| "netgroup" (p_ident)
		| "number" (p_ident)
		| "offpageconnector" (p_ident)
		| "orientation" (p_ident)
		| "origin" (p_ident)
		| "output" (p_ident)
		| "owner" (p_ident)
		| "page" (p_ident)
		| "port" (p_ident)
		| "power" (p_ident)
		| "program" (p_ident)
		| "property" (p_ident)
		| "pt" (p_ident)
		| "r0" (p_ident)
		| "r180" (p_ident)
		| "r90" (p_ident)
		| "r270" (p_ident)
		| "resistance" (p_ident)
		| "ripper" (p_ident)
		| "schematic" (p_ident)
		| "status" (p_ident)
		| "string" (p_ident)
		| "stringdisplay" (p_ident)
		| "temperature" (p_ident)
		| "trigger" (p_ident)
		| "textheight" (p_ident)
		| "timing" (p_ident)
		| "true" (p_ident)
		| "uppercenter" (p_ident)
		| "upperleft" (p_ident)
		| "upperright" (p_ident)
		| "value" (p_ident)
		| "visible" (p_ident)
		| "voltage" (p_ident)
/*"angle" (p_ident)
		| "behavior" (p_ident)
		| "calculated" (p_ident)
		| "charge" (p_ident)
		| "document" (p_ident)
		| "extend" (p_ident)
		| "flux" (p_ident)
		| "generic" (p_ident)
		| "logicmodel" (p_ident)
		| "masklayout" (p_ident)
		| "mass" (p_ident)
		| "measured" (p_ident)
		| "mx" (p_ident)
		| "mxr90" (p_ident)
		| "my" (p_ident)
		| "myr90" (p_ident)
		| "netlist" (p_ident)
		| "pcblayout" (p_ident)
		| "ripper" (p_ident)
		| "round" (p_ident)
		| "required" (p_ident)
		| "round" (p_ident)
		| "stranger" (p_ident)
		| "symbolic" (p_ident)
		| "tie" (p_ident)
		| "time" (p_ident)
		| "truncate" (p_ident)
*/
		;
}	// BNF syntax definition end
/*_________________________________________________________________*/

void parsefile(fn)
// Parse an input file
string fn			/* File name */;
{
	// Parser error messages
	STRINGS ERRS	= {
		"",
		M("(synparsefile) Keine BNF-Definition verfuegbar!",
		  "(synparsefile) No BNF definition available!"),
		M("(synparsefile) Parser ist bereits aktiv!",
		  "(synparsefile) Parser already active!"),
		M("(synparsefile) Fehler beim Oeffnen der Datei '%s'!",
		  "(synparsefile) Error opening file '%s'!"),
		M("(synparsefile) Zu viele offene Dateien!",
		  "(synparsefile) Too many open files!"),
		M("[%s/%d] Fataler Lese-/Schreibfehler!",
		  "[%s/%d] Fatal read/write error!"),
		M("[%s/%d] Scan Item '%s' zu lang!",
		  "[%s/%d] Scan item '%s' too long!"),
		M("[%s/%d] Syntaxfehler bei '%s' (unerwartetes Symbol)!",
		  "[%s/%d] Syntax error at '%s' (unexpected symbol)!"),
		M("[%s/%d] Dateiende erreicht!",
		  "[%s/%d] Unexpected end of file!"),
		M("[%s/%d] Stackueberlauf (BNF zu komplex)!",
		  "[%s/%d] Stack overflow (BNF too complex)!"),
		M("[%s/%d] Stackunterlauf (BNF fehlerhaft)!",
		  "[%s/%d] Stack underflow (BNF erroneous)!"),
		M("[%s/%d] Fehler von Parser Aktion/Funktion!",
		  "[%s/%d] Error from parse action function!"),
		M("(synparsefile) Unbekannter Fehlercode %d!",
		  "(synparsefile) Unknown error code %d!")
		};
	int status			/* Parser status */;
	int tmpfh			/* Temporary file name handle */;
	int libfh			/* Library file name handle */;
	int c				/* Character buffer */;
	int qtoggle			/* Quotation mark toggle */;
	int nmode			/* Number name mode */;
	int qcnt			/* Quotation contents count */;
	string parsefn			/* Parse file name */;
	string msg			/* Error message */;
	if (TMPFLAG) {
		// Set the file error mode
		fseterrmode(0);
		// Open the library file
		if ((libfh=fopen(fn,0))==(-1))
			errormsg(ERRLIBOPEN,fn);
		// Create temporary library file
		if ((tmpfh=fopen(TMPFILE,1))==(-1))
			errormsg(ERRTMPWRITE,TMPFILE);
		// Copy library file with conversion
		bae_prtdialog(REPLIBCONV);
		qtoggle=qcnt=nmode=0;
		while ((c=fgetc(libfh))!=(-1)) {
			// Check if linefeed character
			if (c==0x0a || c==0x0d) {
				if (qtoggle==0 && nmode) {
					if (fputc('"',tmpfh)) {
						// File write error
						fclose(libfh);
						fclose(tmpfh);
						remove(TMPFILE);
						errormsg(ERRTMPWRITE,TMPFILE);
						}
					nmode=0;
					}
				if (qtoggle==0 && nmode==0)
					if (fputc(' ',tmpfh)) {
						// File write error
						fclose(libfh);
						fclose(tmpfh);
						remove(TMPFILE);
						errormsg(ERRTMPWRITE,TMPFILE);
						}
				continue;
				}
			if (c=='"') {
				qtoggle=1-qtoggle;
				qcnt=0;
				}
			if (nmode && !(isalnum(c) || c=='_')) {
				if (fputc('"',tmpfh)) {
					// File write error
					fclose(libfh);
					fclose(tmpfh);
					remove(TMPFILE);
					errormsg(ERRTMPWRITE,TMPFILE);
					}
				nmode=0;
				}
			// Write the current character to the output file
			if ((!qtoggle || qcnt<100) &&
			 (fputc(c,tmpfh) || (c==')' && fputc('\n',tmpfh)))) {
				// File write error
				fclose(libfh);
				fclose(tmpfh);
				remove(TMPFILE);
				errormsg(ERRTMPWRITE,TMPFILE);
				}
			qcnt++;
			if (!qtoggle && c=='&') {
				nmode=1;
				if (fputc('"',tmpfh)) {
					// File write error
					fclose(libfh);
					fclose(tmpfh);
					remove(TMPFILE);
					errormsg(ERRTMPWRITE,TMPFILE);
					}
				}
			if (qtoggle && c=='\\') {
				if (fputc(c,tmpfh)) {
					// File write error
					fclose(libfh);
					fclose(tmpfh);
					remove(TMPFILE);
					errormsg(ERRTMPWRITE,TMPFILE);
					}
				}
			}
		// Close files
		fclose(libfh);
		fclose(tmpfh);
		// Reset the file error mode
		fseterrmode(1);
		// Set the parse file name
		parsefn=TMPFILE;
		}
	else {
		// Set the parse file name
		parsefn=fn;
		}
	pointstk[0]=0;
	pointstkn=1;
	// Init. lists
	curpinn=0;
	curpinl[curpinn].pxn=0;
	curpinl[curpinn].ptyp="";
	curpolyn=0;
	curpolyl[curpolyn].pn=0;
	curpolyl[curpolyn].ptyp=0;
	curtextn=0;
	curinstn=0;
	instbabase=instban;
	curaliasn=0;
	curview=0;
	// Parse the input file and evaluate the parser status
	synscanigncase(1);
	synscaneoln(0);
	if ((status=synparsefile(parsefn))==0) {
		synscanigncase(0);
		if (TMPFLAG==1)
			remove(TMPFILE);
		// No error
		return;
		}
	synscanigncase(0);
	if (status>=arylength(ERRS))
		sprintf(msg,ERRS[arylength(ERRS)-1],status);
	else
		sprintf(msg,ERRS[status],
		 fn,synscanline(),synscanstring());
	// Print the error message
	error(msg);
}

// Parser action routines

int p_annot()
// Receive a annotate command
// Returns : zero if done or (-1) on error
{
	curorgx=0.0;
	curorgy=0.0;
	curjustify=0;
	curori=0;
	cursize=NAMESIZ;
	incnamespace(NTYP_ANNOT);
	// Return without errors
	return(0);
}

int p_annotend()
// Receive an annotate end
// Returns : zero if done or (-1) on error
{
	double ang			/* Text angle */;
	if (curview!=1) {
		decnamespace();
		return(0);
		}
	ang=curori*0.5*PI;
	textadjust(curstrdisp,curjustify,0,curorgx,curorgy,ang,cursize,
	 curtextl[curtextn].x,curtextl[curtextn].y,curtextl[curtextn].angle,0);
	curtextl[curtextn].str=textstrconv(curstrdisp);
	curtextl[curtextn].size=cursize;
	curtextn++;
	curjustify=0;
	decnamespace();
	// Return without errors
	return(0);
}

int p_arc()
// Receive an arc
// Returns : zero if done or (-1) on error
{
	double x1,y1			/* First arc point */;
	double x2,y2			/* Second arc point */;
	double xp,yp			/* Sekant vector */;
	double xm,ym			/* Center point coordinates */;
	double xs,ys			/* Sekant middle point coordinates */;
	double xa,ya			/* Center vector components */;
	double r			/* Radius */;
	double lp			/* Sekant length */;
	double ap			/* Sekant arc point distance */;
	int ptyp			/* Point typ */;
	int sidx			/* Polygon point list start index */;
	// Check if symbol skip
	if (curview!=1 || pointstkn<1 ||
	 (pointstk[pointstkn]-pointstk[pointstkn-1])<3)
		return(0);
	sidx=pointstk[pointstkn]-3;
	// Last point is third arc point
	x1=curpointl[sidx].x;
	y1=curpointl[sidx].y;
	xa=curpointl[sidx+1].x;
	ya=curpointl[sidx+1].y;
	x2=curpointl[sidx+2].x;
	y2=curpointl[sidx+2].y;
	// Get sekant middle to arc point vector and length
	xs=0.5*(x1+x2)-xa;
	ys=0.5*(y1+y2)-ya;
	ap=sqrt(xs*xs+ys*ys);
	// Get sekant vector and length
	xp=x2-x1;
	yp=y2-y1;
	lp=sqrt(xp*xp+yp*yp);
	// Very small arc angle, don't create arc (line interpolation)
	if (lp<=SMALLVAL)
		return(0);
	// Calculate arc radius
	r=0.5*lp/cos(0.5*PI-2.0*atan(2.0*ap/lp));
	// Normalize sekant vector
	xp/=lp;
	yp/=lp;
	// Create left or right arc according to sekant/arcpoint orientation
	if ((yp*xs-xp*ys)>=0.0) {
		xm=xa+r*yp;
		ym=ya-r*xp;
		ptyp=2;
		}
	else {
		xm=xa-r*yp;
		ym=ya+r*xp;
		ptyp=1;
		}
	// Store the arc center point
	curpointl[sidx+1].x=xm;
	curpointl[sidx+1].y=ym;
	curpointl[sidx+1].t=ptyp;
	// Return without errors
	return(0);
}

int p_array()
// Receive an array flag
// Returns : zero if done or (-1) on error
{
	curarray=1;
	// Return without errors
	return(0);
}

int p_boundingbox()
// Receive a bounding box
// Returns : zero if done or (-1) on error
{
	double lx,ly		/* Lower box boundary */;
	double ux,uy		/* Upper box boundary */;
	double t		/* Temp. buffer */;
	if (curview!=1)
		return(0);
	// Dismiss stored polygon
	curpolyn--;
	curpolyl[curpolyn].pn=0;
	curpolyl[curpolyn].ptyp=0;
	// Get the box boundaries
	lx=curpolyl[curpolyn].pl[2].x;
	ly=curpolyl[curpolyn].pl[0].y;
	ux=curpolyl[curpolyn].pl[0].x;
	uy=curpolyl[curpolyn].pl[2].y;
	if (lx>ux) {
		t=lx;
		lx=ux;
		ux=t;
		}
	if (ly>uy) {
		t=ly;
		ly=uy;
		uy=t;
		}
	boxstk[boxstkn].lx=lx;
	boxstk[boxstkn].ly=ly;
	boxstk[boxstkn].ux=ux;
	boxstk[boxstkn].uy=uy;
	// Return without errors
	return(0);
}

int p_cellcode(int code)
// Receive a cell type code
// Returns : zero if done or (-1) on error
{
	curcellcode=code;
	// Return without errors
	return(0);
}

int p_cellend()
// Receive a symbol end
// Returns : zero if done or (-1) on error
{
	index C_FIGURE nfig		/* New figure list element */;
	string macname			/* Macro name */;
	string oldmacname		/* Old label macro name */;
	string pinname			/* Pin name */;
	string cmpname			/* Pin compare name */;
	string pinmac			/* Pin macro name */;
	string pintyp			/* Pin type name */;
	string partname			/* Part name */;
	string etapname			/* Error bustap name */;
	string ebusname			/* Error bus name */;
	string namepat	= ""		/* Name pattern */;
	int autoname			/* Automatic name generation flag */;
	int errcode			/* Error code */;
	int firstpin			/* First pin flag */;
	int mainp			/* Mainpart definition flag */;
	int pown			/* Power pin count */;
	int pn				/* Pin count */;
	int sidx			/* Symbol index */;
	int skipdef			/* Symbol definition skip flag */;
	int extsymb			/* Extended symbol definitions flag */;
	int pagesym			/* Page symbol flag */;
	int pinnum			/* Pin number */;
	int res				/* Symbol place result */;
	int symidx			/* Symbol name index */;
	double xoff, yoff		/* Symbol offset */;
	double ix, iy			/* Current instance coordinates */;
	double bx, by			/* Text base vector */;
	double x,y			/* Bus entry coordinates */;
	double ang			/* Current angle */;
	double angsin, angcos		/* Current angle trig. values */;
	double s			/* Scale factor */;
	int mirr			/* Current mirror flag */;
	int mode			/* Current text mode */;
	int start			/* Text string start */;
	STRINGS rl			/* Rule list */;
	int textcol	= 0		/* Text column */;
	int len				/* Current string length */;
	char c				/* Character buffer */;
	int i, j, k			/* Loop control variable */;
	// Check if cell type override by view name/name
	if (curcellcode==0 && curviewtype==1)
		curcellcode=3;
	if (curdesignator!="") {
		namepat=curdesignator;
		res=strlen(namepat)-1;
		if (namepat[res]=='?')
			namepat[res]='*';
		else
			namepat+=NAMEPAT;
		}
	// Evaluate the cell code
	skipdef= curcellcode==1 ? 1 : 0 ;
	// Search undeclared power pins
	pown=mainp=0;
	for (i=0;i<curpinn;i++) {
		// Check if power multipin
		if (POWMODE==1 && curpinl[i].pxn>0 &&
		 curpinl[i].pxl[0]==curpinl[i].pxl[1])
			// Set pin type
			curpinl[i].ptyp="sup";
		if (curpinl[i].ptyp=="sup") {
			pown++;
			continue;
			}
		pn=0;
		for (j=1;j<curpinl[i].pxn;j++)
			if (curpinl[i].pxl[j]=="0" || curpinl[i].pxl[j]=="" ||
			 curpinl[i].pxl[0]==curpinl[i].pxl[j])
				pn++;
		// Check if undeclared pins found
		if (pn>0) {
			// Set pin type to extended power
			curpinl[i].ptyp="xsup";
			mainp=1;
			}
		}
	// Get the extended symbol definition flag
	extsymb=
	 (curcellcode==2 || curcellcode==3 || curcellcode==4) ? 0 : 1 ;
	// Get the symbol class
	curclass= curpage ? DDBCLSCM :
	 ((curpinn==1 && pown==1) || extsymb==0 ? DDBCLSLAB : DDBCLSSYM);
	s= curpage ? cursheetscale : 1.0 ;
	// Check if the element is already defined
	if (curpage) {
		symidx=1;
		partname=cursymname[0];
		while (existddbelem(ddbfname,DDBCLSCM,partname)==1) {
			symidx++;
			partname=cursymname[0]+"_"+itoa(symidx);
			}
		cursymname[0]=partname;
		}
	else {
		skipdef|= (curpagedone ||
		 existddbelem(ddbfname,curclass,cursymname[0])==1) ? 1 : 0;
		}
	if (curclass==DDBCLSLAB)
		for (i=0;i<dellabeln;i++)
			if (cursymname[0]==dellabell[i]) {
				skipdef|=1;
				break;
				}
	// Check if symbol skip
	if (skipdef) {
		// Clear the symbol name field
		cursymn=0;
		curcell=0;
		curpage=0;
		curpinn=0;
		curpinl[curpinn].pxn=0;
		curpinl[curpinn].ptyp="";
		curpolyn=0;
		curpolyl[curpolyn].pn=0;
		curinstn=0;
		instbabase=instban;
		curtextn=0;
		curaliasn=0;
		return(p_decstk(6));
		}
	switch (curclass) {
		case DDBCLSLAB :
		break;
		case DDBCLSSYM :
		// Search origin pin
		curhotx=curhoty=0.0;
		if (curpinn) {
			firstpin=1;
			for (i=0;i<curpinn;i++) {
				// Don't process extended power pins
				if (curpinl[i].ptyp=="xsup")
					continue;
				// Check if leftmost uppermost pin
				if (firstpin || curhotx>curpinl[i].x ||
				 (curhotx==curpinl[i].x &&
				  curhoty<curpinl[i].y)) {
					// Set origin
					curhotx=curpinl[i].x;
					curhoty=curpinl[i].y;
					firstpin=0;
					}
				}
			}
		break;
		default :
		curhotx=curhoty=0.0;
		}
	if ((symidx=findsymbol(cursymname[0]))<0) {
		// Update the symbol list
		for (i=symn;i>inssymidx;i--)
			syml[i]=syml[i-1];
		// Insert symbol
		syml[inssymidx].name=cursymname[0];
		syml[inssymidx].x=curhotx;
		syml[inssymidx].y=curhoty;
		syml[inssymidx].mainp=mainp;
		syml[inssymidx].typ=curcellcode;
		syml[inssymidx].pagesym=curpagesym;
		symn++;
		symidx=inssymidx;
		}
	// Check if special main part definition required
	if (mainp && curclass==DDBCLSSYM && !curpage) {
		// Create schematic symbol element
		bae_clriactqueue();
		bae_storemenuiact(1,1,LMB);
		bae_storetextiact(1,ddbfname);
		bae_storetextiact(1,cursymname[0]+POWEXT);
		if (bae_plannotsaved())
			bae_storetextiact(1,M_UINYES());
		bae_storetextiact(1,"m");
		bae_storetextiact(1,"1");
		bae_storetextiact(1,"1");
		bae_setintpar(22,1);
		call(MNU_SCMCREELEM);
		bae_setintpar(22,0);
		// Set the plan boundaries
		boundset(curlx,curly,curux,curuy);
		if (SYMGRP!="") {
			bae_clriactqueue();
			bae_storetextiact(1,SYMLIB);
			bae_storetextiact(1,SYMGRP);
			bae_storemouseiact(1,0.0,0.0,0,LMB);
			bae_setintpar(22,1);
			call(MNU_SCMLOADGRP);
			bae_setintpar(22,0);
			call(MNU_SCMGRPRESE);
			}
		// Perform the create element call
		bae_setintpar(22,1);
		call(MNU_BAEZOOMALL);
		bae_setintpar(22,0);
		// Place the symbol pins
		for (i=0;i<curpinn;i++) {
			// Only place extended power pins
			if (curpinl[i].ptyp!="xsup")
				continue;
			// Place the pin
			if (scm_storepart(curpinl[i].name,PINMAC,
			 curpinl[i].x,curpinl[i].y,curpinl[i].ang,0)!=0) {
				sprintf(msgl[msgn],ERRPLCPIN,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),curpinl[i].name);
				msgn++;
				continue;
				}
			if (PINTMODE==3)
				continue;
			if (curpinl[i].namedisp && cap_lastfigelem(nfig)==0) {
			    textadjust(curpinl[i].name,
			     curpinl[i].namejustify,0,
			     curpinl[i].namex,curpinl[i].namey,
			     curpinl[i].nameang,PNAMSIZ,x,y,ang,0);
			    if (PINTMODE==5) {
				scm_attachtextpos(nfig,"$$",
				 curpinl[i].x,curpinl[i].y,0.0,0.0,0);
				cmpname=curpinl[i].name;
				strupper(cmpname);
				if (scm_storetext(
				 cmpname,x,y,ang,PNAMSIZ,0,mode)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),cmpname);
					msgn++;
					}
				else if (cap_lastfigelem(nfig)==0) {
					// Assign the text class
					// predicate rule
					rsc_assfigintpred(nfig,
					 RS_TXTCLASS,PINTCLASS,0,"");
					}
				}
			    else {
				scm_attachtextpos(
				 nfig,"$$",x,y,ang,PNAMSIZ,0);
				}
			    }
			else if (curpinl[i].numdisp &&
			 cap_lastfigelem(nfig)==0) {
			    if (PINTMODE==4) {
				for (j=0;j<curtextn;j++) {
					cmpname=curtextl[j].str;
					strlower(cmpname);
					if (cmpname==curpinl[i].name) {
						curtextl[j].str="";
						scm_attachtextpos(nfig,"$$",
						 curtextl[j].x,curtextl[j].y,
						 curtextl[j].angle,
						 curtextl[j].size,0);
						break;
						}
					}
				}
			    else if (PINTMODE==1) {
				textadjust(curpinl[i].name,
				 curpinl[i].numjustify,0,
				 curpinl[i].numx,curpinl[i].numy,
				 curpinl[i].numang,PNUMSIZ,x,y,ang,0);
				scm_attachtextpos(nfig,"$$",x,y,ang,PNUMSIZ,0);
				}
			    else if (PINTMODE==2) {
				scm_attachtextpos(nfig,"$$",
				 curpinl[i].x,curpinl[i].y,0.0,0.0,0);
				}
			    }
			if (curpinl[i].numdisp && cap_lastfigelem(nfig)==0) {
				textadjust(curpinl[i].pxn>0 ?
				 curpinl[i].pxl[0] : curpinl[i].name,
				 curpinl[i].numjustify,0,
				 curpinl[i].numx,curpinl[i].numy,
				 curpinl[i].numang,PNUMSIZ,x,y,ang,0);
				scm_attachtextpos(nfig,"$",x,y,ang,PNUMSIZ,0);
				}
			else if (PINTMODE!=5 && curpinl[i].namedisp &&
			 cap_lastfigelem(nfig)==0) {
			    if (PINTMODE==1) {
				textadjust(curpinl[i].pxn>0 ?
				 curpinl[i].pxl[0] : curpinl[i].name,
				 curpinl[i].namejustify,0,
				 curpinl[i].namex,curpinl[i].namey,
				 curpinl[i].nameang,PNUMSIZ,x,y,ang,0);
				scm_attachtextpos(nfig,"$",x,y,ang,PNUMSIZ,0);
				}
			    else if (PINTMODE==2) {
				scm_attachtextpos(nfig,"$",
				 curpinl[i].x,curpinl[i].y,0.0,0.0,0);
				}
			    }
			}
		if (scm_storetext("$rpname",
		 0.0,-2*(NAMESIZ+COMMSIZ),0.0,COMMSIZ,0,1)) {
			sprintf(msgl[msgn],ERRPLCTEXT,
			 ddbclassname(bae_planddbclass()),
			 bae_planename(),"$rpname");
			msgn++;
			}
		// Set the symbol origin
		bae_clriactqueue();
		bae_storemouseiact(1,curhotx,curhoty,2,LMB);
		call(MNU_SCMPARORIG);
		// Set the symbol name pattern
		if (namepat!="") {
			bae_clriactqueue();
			bae_storetextiact(1,namepat);
			call(MNU_SCMPNAMPAT);
			}
		// Zoom overview
		bae_setintpar(22,1);
		call(MNU_BAEZOOMALL);
		bae_setintpar(22,0);
		// Save the symbol
		bae_setintpar(22,1);
		call(MNU_SCMSAVELEM);
		bae_setintpar(22,0);
		// Save identical symbols to other names
		for (i=1;i<cursymn;i++) {
			bae_clriactqueue();
			bae_storetextiact(1,"");
			bae_storetextiact(1,cursymname[i]+POWEXT);
			call(202);
			}
		}
	// Create schematic symbol element
	bae_clriactqueue();
	bae_storemenuiact(1,curpage ? 0 : (curclass==DDBCLSSYM ? 1 : 2),LMB);
	bae_storetextiact(1,ddbfname);
	bae_storetextiact(1,cursymname[0]);
	if (bae_plannotsaved())
		bae_storetextiact(1,M_UINYES());
	if (curpage)
		bae_storemenuiact(1,14,LMB);
	else
		bae_storetextiact(1,"m");
	bae_storetextiact(1,"1");
	bae_storetextiact(1,"1");
	bae_setintpar(22,1);
	call(MNU_SCMCREELEM);
	bae_setintpar(22,0);
	if (curpage) {
		// Assign the connectivity mode predicate rule
		rsc_assplanintpred(1,RS_CONMODE,1,0,"");
		if (cursymboldone) {
			// Set block data
			bae_clriactqueue();
			bae_storemenuiact(1,2,LMB);
			bae_storetextiact(1,curpageblock);
			call(801);
			}
		}
	// Set the plan boundaries
	boundset(curlx*s,curly*s,curux*s,curuy*s);
	if (!curpage && curclass==DDBCLSSYM && SYMGRP!="") {
		bae_clriactqueue();
		bae_storetextiact(1,SYMLIB);
		bae_storetextiact(1,SYMGRP);
		bae_storemouseiact(1,0.0,0.0,2,LMB);
		bae_setintpar(22,1);
		call(MNU_SCMLOADGRP);
		bae_setintpar(22,0);
		call(MNU_SCMGRPRESE);
		}
	bae_setintpar(22,1);
	call(MNU_BAEZOOMALL);
	bae_setintpar(22,0);
	// Output all bus polygons
	for (i=0;i<curpolyn;i++) {
		if (curpolyl[i].ptyp!=(-2))
			continue;
		// Get the polygon point count
		pn=curpolyl[i].pn;
		bae_clearpoints();
		for (j=0;j<pn;j++)
			bae_storepoint(curpolyl[i].pl[j].x*s,
			 curpolyl[i].pl[j].y*s,j==0 ? 1 : curpolyl[i].pl[j].t);
		if (scm_storecon()) {
			if (pn==2) {
				bae_clearpoints();
				bae_storepoint(curpolyl[i].pl[0].x*s,
				 curpolyl[i].pl[0].y*s,1);
				bae_storepoint(curpolyl[i].pl[0].x*s,
				 curpolyl[i].pl[pn-1].y*s,0);
				bae_storepoint(curpolyl[i].pl[pn-1].x*s,
				 curpolyl[i].pl[pn-1].y*s,0);
				if (scm_storecon()==0) {
					scm_setintpar(4,0);
					continue;
					}
				}
			if (scm_storepoly(5)) {
				sprintf(msgl[msgn],ERRPLCCON,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),
				 cvtlength(curpolyl[i].pl[0].x*s,0,2),
				 cvtlength(curpolyl[i].pl[0].y*s,0,2));
				msgn++;
				}
			}
		else {
			scm_setintpar(4,0);
			}
		}
	// Check if symbol defintion
	if (!curpage) {
	    if (curclass==DDBCLSSYM) {
		// Place the symbol pins
		for (i=0;i<curpinn;i++) {
			// Don't place power pins
			if (curpinl[i].ptyp=="sup" ||
			 curpinl[i].ptyp=="xsup" ||
			 !curpinl[i].portimp)
				continue;
			// Place the pin
			pinmac=
			 curpinl[i].namedisp==0 && curpinl[i].numdisp==0 ?
			  (curpinl[0].pxn>1 ? "pin" : "terminal") : PINMAC;
			pinnum=0;
			do {
				pinnum++;
				if (pinnum==1)
					pinname=curpinl[i].name;
				else
					sprintf(pinname,"%s_%d",
					 curpinl[i].name,pinnum);
				}
			 while ((res=scm_storepart(pinname,pinmac,
			  curpinl[i].x,curpinl[i].y,curpinl[i].ang,0))==(-5));
			if (res!=0) {
				sprintf(msgl[msgn],ERRPLCPIN,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),curpinl[i].name);
				msgn++;
				}
			if (PINTMODE==3)
				continue;
			if (curpinl[i].namedisp && cap_lastfigelem(nfig)==0) {
			    textadjust(curpinl[i].name,
			     curpinl[i].namejustify,0,
			     curpinl[i].namex,curpinl[i].namey,
			     curpinl[i].nameang,PNAMSIZ,x,y,ang,0);
			    if (PINTMODE==5) {
				scm_attachtextpos(nfig,"$$",
				 curpinl[i].x,curpinl[i].y,0.0,0.0,0);
				cmpname=curpinl[i].name;
				strupper(cmpname);
				if (scm_storetext(
				 cmpname,x,y,ang,PNAMSIZ,0,mode)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),cmpname);
					msgn++;
					}
				else if (cap_lastfigelem(nfig)==0)
					// Assign the text class
					// predicate rule
					rsc_assfigintpred(nfig,
					 RS_TXTCLASS,PINTCLASS,0,"");
					}
			    else {
				scm_attachtextpos(
				 nfig,"$$",x,y,ang,PNAMSIZ,0);
				}
			    }
			else if (curpinl[i].numdisp &&
			 cap_lastfigelem(nfig)==0) {
			    if (PINTMODE==4) {
				for (j=0;j<curtextn;j++) {
					cmpname=curtextl[j].str;
					strlower(cmpname);
					if (cmpname==curpinl[i].name) {
						curtextl[j].str="";
						scm_attachtextpos(nfig,"$$",
						 curtextl[j].x,curtextl[j].y,
						 curtextl[j].angle,
						 curtextl[j].size,0);
						break;
						}
					}
				}
			    else if (PINTMODE==1) {
				textadjust(curpinl[i].name,
				 curpinl[i].numjustify,0,
				 curpinl[i].numx,curpinl[i].numy,
				 curpinl[i].numang,PNUMSIZ,x,y,ang,0);
				scm_attachtextpos(nfig,"$$",x,y,ang,PNUMSIZ,0);
				}
			    else if (PINTMODE==2) {
				scm_attachtextpos(nfig,"$$",0.0,0.0,0.0,0.0,0);
				}
			    }
			if (curpinl[i].numdisp &&
			 cap_nrefsearch(pinname,nfig)==0) {
				textadjust(curpinl[i].pxn>0 ?
				 curpinl[i].pxl[0] : curpinl[i].name,
				 curpinl[i].numjustify,1,
				 curpinl[i].numx,curpinl[i].numy,
				 curpinl[i].numang,PNUMSIZ,x,y,ang,0);
				scm_attachtextpos(nfig,"$",x,y,ang,PNUMSIZ,0);
				}
			else if (PINTMODE!=5 && curpinl[i].namedisp &&
			 cap_nrefsearch(pinname,nfig)==0) {
			    if (PINTMODE==1) {
				textadjust(curpinl[i].pxn>0 ?
				 curpinl[i].pxl[0] : curpinl[i].name,
				 curpinl[i].namejustify,0,
				 curpinl[i].namex,curpinl[i].namey,
				 curpinl[i].nameang,PNUMSIZ,x,y,ang,0);
				scm_attachtextpos(nfig,"$",x,y,ang,PNUMSIZ,0);
				}
			    else if (PINTMODE==2) {
				scm_attachtextpos(nfig,"$",0.0,0.0,0.0,0.0,0);
				}
			    }
			}
		// Check if symbol with attributes
		if (extsymb && (curpinn || (cursymname[0]!="gnd"
		 && cursymname[0]!="masse_allg" && cursymname[0]!="schirm"))) {
			// Store the attribute texts
			cury=curly;
			if (curnamedisp) {
				textadjust("$",curnamejustify,1,curnamex,
				 curnamey,curnameang,NAMESIZ,x,y,ang,mode);
				if (scm_storetext(
				 "$",x,y,ang,NAMESIZ,0,mode)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),"$");
					msgn++;
					}
				}
			else {
				cury-=NAMESIZ;
				if (scm_storetext(
				 "$",0.0,cury,0.0,NAMESIZ,0,0)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),"$");
					msgn++;
					}
				}
			cury-=COMMSIZ;
			if (curvaldisp) {
				textadjust(VALATTR,curvaljustify,1,curvalx,
				 curvaly,curvalang,VALSIZ,x,y,ang,mode);
				if (scm_storetext(
				 VALATTR,x,y,ang,VALSIZ,0,mode)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),VALATTR);
					msgn++;
					}
				}
			else {
				if (scm_storetext(
				 VALATTR,0.0,cury,0.0,VALSIZ,0,1)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),VALATTR);
					msgn++;
					}
				cury-=COMMSIZ;
				}
			// Check if multiple gates part
			if (curpinl[0].pxn>1) {
				if (scm_storetext("$rpname",
				 0.0,cury,0.0,COMMSIZ,0,1)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),"$rpname");
					msgn++;
					}
				cury-=COMMSIZ;
				}
			for (i=0;i<attrn;i++) {
				if (scm_storetext(attrl[i].attname,0.0,
				 cury,0.0,COMMSIZ,0,1)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),attrl[i].attname);
					msgn++;
					}
				cury-=COMMSIZ;
				}
			}
		// Write all symbol instance loglib entries
		for (sidx=0;sidx<cursymn;sidx++) {
			// Check if part with extended power supply
			if (mainp) {
				fprintf(deffh,
				 "\npart \"%s\" : subpart \"%s\" {\n",
				 cursymname[sidx]+POWEXT,cursymname[sidx]);
				// Write the pin definitions
				firstpin=1;
				for (i=0;i<curpinn;i++) {
					if (curpinl[i].ptyp!="xsup")
						continue;
					if (!firstpin) {
						fprintf(deffh,",");
						if (i%8==0)
							fprintf(deffh,"\n\t ");
						}
					else {
						fprintf(deffh,"\tpin (");
						firstpin=0;
						}
					fprintf(deffh,"\"%s\"",
					 curpinl[i].name);
					}
				// Check if pin definition end required
				if (!firstpin)
					fprintf(deffh,");\n");
				fprintf(deffh,"\txlat ( ");
				// Write the logical pins
				firstpin=1;
				for (i=0;i<curpinn;i++) {
					if (curpinl[i].ptyp!="xsup")
						continue;
					if (!firstpin) {
						fprintf(deffh,",");
						if (i%8==0)
							fprintf(deffh,"\n\t  ");
						}
					else {
						firstpin=0;
						}
					fprintf(deffh,
					 "\"%s\"",curpinl[i].name);
					}
				fprintf(deffh,")\n\t to (");
				// Write the physical pins
				firstpin=1;
				for (i=0;i<curpinn;i++) {
					if (curpinl[i].ptyp!="xsup")
						continue;
					if (!firstpin) {
						fprintf(deffh,",");
						if (i%8==0)
							fprintf(deffh,"\n\t  ");
						}
					else {
						firstpin=0;
						}
					fprintf(deffh,
					 "\"%s\"",curpinl[i].pxl[0]);
					}
				fprintf(deffh,");\n");
				// Write the pin type attributes
				for (i=0;i<curpinn;i++) {
					if (curpinl[i].ptyp!="xsup")
						continue;
					fprintf(deffh,"\tnewattr \"$pintype\"");
					fprintf(deffh," = \"sup\" to");
					fprintf(deffh," (\"%s\");\n",
					 curpinl[i].pxl[0]);
					}
				fprintf(deffh,"\t}\n");
				fprintf(mapfh,"%s;%s;1;%s\n",cursymname[sidx],
				 cursymname[sidx]+POWEXT,ddbfsname);
				}
			// Start the symbol logical library entry
			if (curpagesym)
				fprintf(deffh,"\npart \"%s\" : virtual {\n",
				 cursymname[sidx]);
			else if (curpinn)
				fprintf(deffh,
				 "\npart \"%s\" : %sdefault \"%s\" {\n",
				 cursymname[sidx],mainp ? "mainpart " : "",
				 cursymname[sidx]);
			// Write the pin definitions
			firstpin=1;
			for (i=0;i<curpinn;i++) {
				if (curpinl[i].ptyp=="sup" ||
				 curpinl[i].ptyp=="xsup")
					continue;
				if (!firstpin) {
					fprintf(deffh,",");
					if (i%8==0)
						fprintf(deffh,"\n\t ");
					}
				else {
					fprintf(deffh,"\tpin (");
					firstpin=0;
					}
				fprintf(deffh,"\"%s\"",curpinl[i].name);
				}
			// Check if pin definition end required
			if (!firstpin)
				fprintf(deffh,");\n");
			// Write the xlat command
			if (curpinn && curpinl[0].pxn>0 && !curpagesym) {
				fprintf(deffh,"\txlat ( ");
				// Write the logical pins
				firstpin=1;
				for (i=0;i<curpinn;i++) {
					if (curpinl[i].ptyp=="sup"
					 || curpinl[i].ptyp=="xsup")
						continue;
					if (!firstpin) {
						fprintf(deffh,",");
						if (i%8==0)
							fprintf(deffh,"\n\t ");
						}
					else {
						firstpin=0;
						}
					fprintf(deffh,
					 "\"%s\"",curpinl[i].name);
					}
				fprintf(deffh,")\n");
				// Loop for all gates
				for (j=0;j<curpinl[0].pxn;j++) {
					fprintf(deffh,"\t %s (",
					 j==0 ? "to" : "or");
					// Write the physical pins
					firstpin=1;
					for (i=0;i<curpinn;i++) {
						if (curpinl[i].ptyp=="sup"
						 || curpinl[i].ptyp=="xsup")
							continue;
						if (!firstpin) {
							fprintf(deffh,",");
							if (i%8==0)
								fprintf(deffh,
								 "\n\t ");
							}
						else {
							firstpin=0;
							}
						fprintf(deffh,
						 "\"%s\"",curpinl[i].pxl[j]);
						}
					fprintf(deffh,")%s\n",
					 j==curpinl[0].pxn-1 ? ";" : "");
					}
				if (curpinl[0].pxn>1)
					fprintf(mapfh,"%s;%s;%d;%s\n",
					 cursymname[sidx],cursymname[sidx],
					 curpinl[0].pxn,ddbfsname);
				}
			else if (mainp && !curpagesym) {
				fprintf(mapfh,"%s;%s;1;%s\n",cursymname[sidx],
				 cursymname[sidx],ddbfsname);
				}
			// Write the pin type attributes
			if (!curpagesym)
			    for (i=0;i<curpinn;i++) {
				pintyp=curpinl[i].ptyp;
				// Check if pin type defined
				if (pintyp=="" || pintyp=="xsup")
					continue;
				if (pintyp=="sup") {
					fprintf(deffh,"\tnet \"%s\" :",
					 curpinl[i].name);
					fprintf(deffh," (\"%s\");\n",
					 curpinl[i].pxl[0]);
					fprintf(deffh,"\tnewattr \"$pintype\"");
					fprintf(deffh," = \"sup\" to");
					fprintf(deffh," (\"%s\");\n",
					 curpinl[i].pxl[0]);
					}
				else {
					fprintf(deffh,"\tnewattr \"$pintype\"");
					fprintf(deffh," = \"%s\" to (",pintyp);
					for (j=0;j<curpinl[i].pxn;j++)
						fprintf(deffh,"%s\"%s\"",j==0
						 ? "" : ",",curpinl[i].pxl[j]);
					fprintf(deffh,");\n");
					}
				}
			if (curpagesym)
				fprintf(deffh,"\tcall \"%s\";\n\t}\n",
				 cursymname[sidx]);
			else if (curpinn)
				fprintf(deffh,"\t}\n");
			else if (cursymname[sidx]!="gnd"
			 && cursymname[sidx]!="masse_allg"
			 && cursymname[sidx]!="schirm")
				fprintf(deffh,"\npart \"%s\" : virtual;\n",
				 cursymname[sidx]);
			}
		}
	    else {
		// Check if ripper label
		if (curcellcode==2 && curpinn==2) {
			// Ensure bustap origin at proper bus position
			if (curpinl[0].name=="bundle" ||
			 curpinl[0].name=="bus") {
				// Adjust origin/placement offset
				curhotx=curpinl[0].x-syml[symidx].x;
				curhoty=curpinl[0].y-syml[symidx].y;
				syml[symidx].x=curhotx;
				syml[symidx].y=curhoty;
				}
			else if (curpinl[1].name=="bundle" ||
			 curpinl[1].name=="bus") {
				// Adjust origin/placement offset
				curhotx=curpinl[1].x-syml[symidx].x;
				curhoty=curpinl[1].y-syml[symidx].y;
				syml[symidx].x=curhotx;
				syml[symidx].y=curhoty;
				}
			// Place the pin, avoid bus recursion
			if (curpinl[0].x!=curpinl[1].x ||
			 curpinl[0].y!=curpinl[1].y) {
				if (curpinl[1].name=="bundle" ||
				 curpinl[1].name=="bus") {
					if (scm_storepart("pin","pin",
					 curpinl[0].x,curpinl[0].y,
					 curpinl[0].ang,0)!=0) {
						sprintf(msgl[msgn],ERRPLCPIN,
						 ddbclassname(
						  bae_planddbclass()),
						 bae_planename(),"pin");
						msgn++;
						}
					}
				else {
					if (scm_storepart("pin","pin",
					 curpinl[1].x,curpinl[1].y,
					 curpinl[1].ang,0)!=0) {
						sprintf(msgl[msgn],ERRPLCPIN,
						 ddbclassname(
						  bae_planddbclass()),
						 bae_planename(),"pin");
						msgn++;
						}
					}
				}
			if (scm_storetext("$",curpinl[1].x,
			 curpinl[1].y,curpinl[1].ang,NAMESIZ,0,0)) {
				sprintf(msgl[msgn],ERRPLCTEXT,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),"$");
				msgn++;
				}
			}
		else {
			// Place the pin
			if (scm_storepart("pin","pin",
			 curpinn==1 ? curpinl[0].x : curhotx,
			 curpinn==1 ? curpinl[0].y : curhoty,0.0,0)!=0) {
				sprintf(msgl[msgn],ERRPLCPIN,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),"pin");
				msgn++;
				}
			else if (cap_lastfigelem(nfig)==0)
				rsc_assfigintpred(
				 nfig,RS_PINMOVE,1,0,"scm_pin_move");
			if (scm_storetext("$",
			 curpinn==1 ? curpinl[0].x : curhotx,
			 curpinn==1 ? curpinl[0].y : curhoty,0.0,NAMESIZ,0,0)) {
				sprintf(msgl[msgn],ERRPLCTEXT,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),"$");
				msgn++;
				}
			}
		}
	    }
	else {
	    // Set own file as library to avoid label macro mismatch
	    bae_clriactqueue();
	    bae_storetextiact(1,ddbfname);
	    bae_callmenu(MNU_SCMPARSLIB);
	    // Store the top level cell data
	    tcelll[tcelln].xl=curlx;
	    tcelll[tcelln].yl=curly;
	    tcelll[tcelln].xu=curux;
	    tcelll[tcelln].yu=curuy;
	    tcelll[tcelln].name=cursymname[0];
	    tcelll[tcelln].pl=curpinl;
	    tcelll[tcelln].pn=curpinn;
	    tcelln++;
	    // Place the references
	    for (i=0;i<curinstn;i++) {
		macname=curinstl[i].macro;
		ix=curinstl[i].x;
		iy=curinstl[i].y;
		// Check if top level cell reference
		if (curinstl[i].typ==1) {
			// Search the top level cell definition
			for (j=0;j<tcelln;j++)
				if (tcelll[j].name==macname)
					break;
			if (j>=tcelln)
				continue;
			// Place the port labels
			for (k=0;k<tcelll[j].pn;k++) {
				if (tcelll[j].pl[k].sflag==0)
					continue;
				if (scm_storelabel(tcelll[j].pl[k].name,1,
				 (ix+tcelll[j].pl[k].x)*s,
				 (iy+tcelll[j].pl[k].y)*s,0.0,0)) {
					sprintf(msgl[msgn],ERRPLCLAB,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),
					 tcelll[j].pl[k].name,macname);
					msgn++;
					}
				scm_setintpar(4,0);
				}
			bae_clearpoints();
			bae_storepoint(
			 (ix+tcelll[j].xl)*s,(iy+tcelll[j].yl)*s,0);
			bae_storepoint(
			 (ix+tcelll[j].xu)*s,(iy+tcelll[j].yl)*s,0);
			bae_storepoint(
			 (ix+tcelll[j].xu)*s,(iy+tcelll[j].yu)*s,0);
			bae_storepoint(
			 (ix+tcelll[j].xl)*s,(iy+tcelll[j].yu)*s,0);
			bae_storepoint(
			 (ix+tcelll[j].xl)*s,(iy+tcelll[j].yl)*s,0);
			if (scm_storepoly(0)) {
				sprintf(msgl[msgn],ERRPLCPOLY,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),
				 cvtlength((ix+tcelll[j].xl)*s,0,2),
				 cvtlength((iy+tcelll[j].yl)*s,0,2));
				msgn++;
				}
			macname=gcrename(macname,macname,NTYP_MAC);
			if (scm_storetext(macname,(ix+tcelll[j].xl)*s,
			 (iy+tcelll[j].yu)*s,0.0,NAMESIZ,0,0)) {
				sprintf(msgl[msgn],ERRPLCTEXT,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),macname);
				msgn++;
				}
			continue;
			}
		// Get symbol macro info
		if ((symidx=findsymbol(curinstl[i].macro))<0)
			continue;
		xoff=syml[symidx].x;
		yoff=(curinstl[i].ori&4) ? -syml[symidx].y : syml[symidx].y;
		ang=0.5*PI*(curinstl[i].ori&3);
		angsin=sin(ang); angcos=cos(ang);
		mirr=(curinstl[i].ori&4)>>2;
		ix=curinstl[i].x*s+angcos*xoff-angsin*yoff;
		iy=curinstl[i].y*s+angsin*xoff+angcos*yoff;
		if (syml[symidx].typ==2) {
			oldmacname=baepar_strval(SCMPAR_BUSTAPMACRO);
			bae_storetextiact(1,curinstl[i].macro);
			bae_callmenu(810);
			scm_setintpar(39,1);
			if (scm_storelabel(curinstl[i].name,2,
			 ix,iy,ang,mirr)) {
				sprintf(msgl[msgn],ERRPLCTAP,bae_planename(),
				 curinstl[i].name,
				 cvtlength(ix,0,2),cvtlength(iy,0,2));
				msgn++;
				}
			scm_setintpar(39,0);
			scm_setintpar(4,0);
			bae_clriactqueue();
			bae_storetextiact(1,oldmacname);
			bae_callmenu(810);
			continue;
			}
		if (syml[symidx].typ==3 || (syml[symidx].typ==4 &&
		 strmatch(curinstl[i].macro,"port*")==0)) {
			oldmacname=baepar_strval(SCMPAR_LABELMACRO);
			bae_storetextiact(1,curinstl[i].macro);
			bae_callmenu(809);
			if (scm_storelabel(curinstl[i].name,0,
			 ix,iy,ang,mirr)) {
				sprintf(msgl[msgn],ERRPLCLAB,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),
				 curinstl[i].name,curinstl[i].macro);
				msgn++;
				}
			else if (curinstl[i].cx!=(-1.0) &&
			 cap_lastfigelem(nfig)==0) {
				bae_postprocess();
				scm_attachtextpos(nfig,"#",curinstl[i].cx*s,
				 curinstl[i].cy*s,ang,1.0,mirr);
				bae_postprocess();
				}
			scm_setintpar(4,0);
			bae_clriactqueue();
			bae_storetextiact(1,oldmacname);
			bae_callmenu(809);
			continue;
			}
		else if (syml[symidx].typ==4) {
			oldmacname=baepar_strval(SCMPAR_PORTMACRO);
			bae_storetextiact(1,curinstl[i].macro);
			bae_callmenu(811);
			if (scm_storelabel(curinstl[i].name,1,
			 ix,iy,ang,mirr)) {
				sprintf(msgl[msgn],ERRPLCPORT,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),
				 curinstl[i].name,curinstl[i].macro);
				msgn++;
				}
			else if (curinstl[i].cx!=(-1.0) &&
			 cap_lastfigelem(nfig)==0) {
				bae_postprocess();
				scm_attachtextpos(nfig,"#",curinstl[i].cx*s,
				 curinstl[i].cy*s,ang,1.0,mirr);
				bae_postprocess();
				}
			scm_setintpar(4,0);
			bae_clriactqueue();
			bae_storetextiact(1,oldmacname);
			bae_callmenu(811);
			continue;
			}

		partname=curinstl[i].name;
		if (partname[strlen(partname)-1]=='?') {
			autoname=1;
			partname[strlen(partname)-1]='\0';
			curinstl[i].name=partname;
			partname=partname+"1";
			}
		else {
			autoname=0;
			}
		if (syml[symidx].mainp)
			scm_storepart(partname+POWEXT,
			 curinstl[i].macro+POWEXT,ix,iy,ang,mirr);
		pagesym=syml[symidx].pagesym;
		symidx=0;
		if (SYMRENAME && symfh!=(-1))
			fprintf(symfh,"%s;",partname);
		if (strfh!=(-1)) {
			if (fgets(cmpname,100,strfh)!=0) {
				fclose(strfh);
				strfh=(-1);
				}
			else {
				for (j=0;(c=cmpname[j])!='\0';j++)
					if (c==';')
						break;
				if (c!=';' ||
				 strextract(cmpname,0,j-1)!=partname) {
					fclose(strfh);
					strfh=(-1);
					}
				else {
					partname=strextract(
					 cmpname,j+1,strlen(cmpname));
					if (partname[strlen(partname)-1]==0x0a)
						partname[strlen(partname)-1]=
						 '\0';
					if (partname[strlen(partname)-1]==0x0d)
						partname[strlen(partname)-1]=
						 '\0';
					curinstl[i].name=partname;
					}
				}
			}
		switch (errcode=
		 scm_storepart(partname,curinstl[i].macro,ix,iy,ang,mirr)) {
			case 0 :
			break;
			case -5 :
			symidx=2;
			if (autoname)
				partname=curinstl[i].name+itoa(symidx);
			else
				partname=curinstl[i].name+"_"+itoa(symidx);
			while ((res=scm_storepart(partname,curinstl[i].macro,
			 ix,iy,ang,mirr))==(-5)) {
				symidx++;
				if (autoname)
					partname=
					 curinstl[i].name+itoa(symidx);
				else
					partname=
					 curinstl[i].name+"_"+itoa(symidx);
				}
			autoname=1;
			if (res==0)
				break;
			default :
			sprintf(msgl[msgn],ERRPLCSYM,
			 ddbclassname(bae_planddbclass()),bae_planename(),
			 curinstl[i].name,curinstl[i].macro);
			msgn++;
			}
		if (SYMRENAME)
			fprintf(symfh,"%s\n",partname);
		instbal[instbabase+i].planname=bae_planename();
		instbal[instbabase+i].plcname=partname;
		if (curinstl[i].namedisp && cap_nrefsearch(partname,nfig)==0) {
			textadjust(partname,curinstl[i].namejustify,0,
			 curinstl[i].namex*s,curinstl[i].namey*s,
			 curinstl[i].nameang,NAMESIZ,x,y,ang,0);
			scm_attachtextpos(nfig,"$",x,y,ang,NAMESIZ,0);
			}
		if (curinstl[i].valdisp && cap_nrefsearch(partname,nfig)==0) {
			textadjust(curinstl[i].value,curinstl[i].valjustify,0,
			 curinstl[i].valx*s,curinstl[i].valy*s,
			 curinstl[i].valang,VALSIZ,x,y,ang,0);
			scm_attachtextpos(nfig,VALATTR,x,y,ang,VALSIZ,0);
			}
		// Set part value attribute
		if (!pagesym)
		    if (scm_setpartattrib(partname,VALATTR,
		     curinstl[i].value,1) && curinstl[i].value!="") {
			sprintf(msgl[msgn],ERRSETATTR,
			 ddbclassname(bae_planddbclass()),bae_planename(),
			 partname,VALATTR,curinstl[i].value);
			msgn++;
			}
		for (j=0;j<curinstl[i].attrn;j++)
			if (scm_setpartattrib(partname,curinstl[i].attrnl[j],
			  curinstl[i].attrvl[j],0) &&
			 curinstl[i].attrvl[j]!="") {
				sprintf(msgl[msgn],ERRSETATTR,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),partname,
				 curinstl[i].attrnl[j],curinstl[i].attrvl[j]);
				msgn++;
				}
		// Try to set requested part name attribute. Ignore failure
		if (!pagesym && !autoname) {
			cmpname=curinstl[i].name;
			if ((len=strlen(cmpname))>1 &&
			 isalpha(cmpname[len-1]) && isdigit(cmpname[len-2]))
				cmpname[len-1]='\0';
			scm_setpartattrib(
			 partname,"$rpname",cmpname,2);
			}
		}
	    // Place the aliases
	    for (i=0;i<curaliasn;i++) {
		ang=0.5*PI*(curaliasl[i].ori&3);
		angsin=sin(ang); angcos=cos(ang);
		if (scm_storelabel(curaliasl[i].name,0,curaliasl[i].x*s-
		 angsin*ALIASOFF,curaliasl[i].y*s+angcos*ALIASOFF,ang,0)) {
			sprintf(msgl[msgn],ERRPLCLAB,
			 ddbclassname(bae_planddbclass()),
			 bae_planename(),curaliasl[i].name,"alias");
			msgn++;
			}
		}
	    // Restore old library
	    bae_clriactqueue();
	    bae_storetextiact(1,oldlibfname);
	    bae_callmenu(MNU_SCMPARSLIB);
	    }
	// Output all non-bus polygons
	for (i=0;i<curpolyn;i++) {
		if (curpolyl[i].ptyp==(-2))
			continue;
		// Get the polygon point count
		if ((pn=curpolyl[i].pn)<2)
			continue;
		bae_clearpoints();
		for (j=0;j<pn;j++)
			bae_storepoint(curpolyl[i].pl[j].x*s,
			 curpolyl[i].pl[j].y*s,curpolyl[i].pl[j].t);
		if (curpolyl[i].ptyp<0) {
			if (scm_storecon()) {
				if (pn==2) {
					bae_clearpoints();
					bae_storepoint(curpolyl[i].pl[0].x*s,
					 curpolyl[i].pl[0].y*s,0);
					bae_storepoint(curpolyl[i].pl[0].x*s,
					 curpolyl[i].pl[pn-1].y*s,0);
					bae_storepoint(curpolyl[i].pl[pn-1].x*s,
					 curpolyl[i].pl[pn-1].y*s,0);
					if (scm_storecon()==0) {
						scm_setintpar(4,0);
						continue;
						}
					}
				if (scm_storepoly(5)) {
					sprintf(msgl[msgn],ERRPLCCON,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),
					 cvtlength(curpolyl[i].pl[0].x*s,0,2),
					 cvtlength(curpolyl[i].pl[0].y*s,0,2));
					msgn++;
					}
				}
			else {
				scm_setintpar(4,0);
				}
			}
		else {
		    if (scm_storepoly(curpolyl[i].ptyp)) {
			if (curpolyl[i].ptyp!=0) {
				bae_clearpoints();
				for (j=0;j<pn;j++)
					bae_storepoint(
					 curpolyl[i].pl[j].x*s,
					 curpolyl[i].pl[j].y*s,
					 curpolyl[i].pl[j].t);
				if (scm_storepoly(0)) {
					sprintf(msgl[msgn],ERRPLCPOLY,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),
					 cvtlength(curpolyl[i].pl[0].x*s,0,2),
					 cvtlength(curpolyl[i].pl[0].y*s,0,2));
					msgn++;
					}
				}
			else {
				sprintf(msgl[msgn],ERRPLCPOLY,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),
				 cvtlength(curpolyl[i].pl[0].x*s,0,2),
				 cvtlength(curpolyl[i].pl[0].y*s,0,2));
				msgn++;
				}
			}
		    }
		}
	// Place the alias label wire segments
	if (curpage) {
		for (i=0;i<curaliasn;i++) {
			ang=0.5*PI*(curaliasl[i].ori&3);
			angsin=sin(ang);
			angcos=cos(ang);
			if (curhotx!=0.0)
				ang+=PI;
			bae_clearpoints();
			bae_storepoint(curaliasl[i].x*s-angsin*ALIASOFF,
			 curaliasl[i].y+angcos*ALIASOFF,0);
			bae_storepoint(curaliasl[i].x*s,curaliasl[i].y,0);
			scm_storecon();
			scm_setintpar(4,0);
			}
		}
	// Output all texts
	for (i=0;i<curtextn;i++) {
		if ((len=strlen(curtextl[i].str))==0)
			continue;
		x=curtextl[i].x;
		y=curtextl[i].y;
		ang=curtextl[i].angle;
		if (len<MAXTEXTLEN) {
			// Place the text
			if (scm_storetext(curtextl[i].str,
			 x*s,y*s,ang,curtextl[i].size*s,0,0)) {
				sprintf(msgl[msgn],ERRPLCTEXT,
				 ddbclassname(bae_planddbclass()),
				 bae_planename(),curtextl[i].str);
				msgn++;
				}
			}
		else {
			bx=cos(ang)*curtextl[i].size;
			by=sin(ang)*curtextl[i].size;
			// Build the multiline text rules
			sprintf(rl[0],":%s:%s='%s_%d';",
			 RS_SCMSUBJ,RS_MTEXTID,textid,mtextcnt);
			mtextcnt++;
			sprintf(rl[2],":%s:%s=%d;",RS_SCMSUBJ,RS_MTEXTROW,0);
			sprintf(rl[3],":%s:%s=%.2f;",RS_SCMSUBJ,RS_MTEXTLS,1.0);
			for (sidx=start;sidx<len;sidx+=MAXKEYLEN) {
				sprintf(rl[1],":%s:%s=%d;",
				 RS_SCMSUBJ,RS_MTEXTCOL,textcol);
				// Store the current text
				if (scm_storetext(
				 strextract(curtextl[i].str,sidx,
				 sidx+MAXKEYLEN-1),
				 x+(sidx-start)*bx/1.5,y+(sidx-start)*by/1.5,
				 ang,curtextl[i].size,0,0)) {
					sprintf(msgl[msgn],ERRPLCTEXT,
					 ddbclassname(bae_planddbclass()),
					 bae_planename(),curtextl[i].str);
					msgn++;
					}
				else if (cap_lastfigelem(nfig)==0) {
					// Attach rules
					if (cap_rulefigatt(nfig,rl))
						rsc_error(0);
					}
				textcol++;
				}
			}
		}
	// Set the symbol origin
	bae_setintpar(0,1);
	bae_clriactqueue();
	bae_storemouseiact(1,curhotx,curhoty,2,LMB);
	call(MNU_SCMPARORIG);
	// Set the symbol name pattern
	if (namepat!="" && !curpage) {
		bae_clriactqueue();
		bae_storetextiact(1,namepat);
		call(MNU_SCMPNAMPAT);
		}
	// Zoom overview
	bae_setintpar(22,1);
	call(MNU_BAEZOOMALL);
	bae_setintpar(22,0);
	// Save the symbol
	bae_setintpar(22,1);
	call(MNU_SCMSAVELEM);
	bae_setintpar(22,0);
	if (curclass==DDBCLSCM) {
		scm_getstrpar(8,etapname);
		scm_getstrpar(9,ebusname);
		/* Check if bus tap problem encountered */
		if (etapname[0]!='\0') {
			if (ebusname[0]!='\0')
				/* Name combination too long */
				sprintf(msgl[msgn],ERRBTAPLNAME,bae_planename(),
				 ebusname,etapname,strlen(ebusname)+
				 strlen(etapname)+1-MAXKEYLEN);
			else
				sprintf(msgl[msgn],ERRBTAPREC,
				 bae_planename(),etapname);
			msgn++;
			}
		}
	// Save identical symbols to other names
	if (!curpage)
		for (i=1;i<cursymn;i++) {
			bae_clriactqueue();
			bae_storetextiact(1,"");
			bae_storetextiact(1,cursymname[i]);
			bae_setintpar(22,1);
			call(202);
			bae_setintpar(22,0);
			}
	// Abort program on request
	if (kbhit()) {
		getchr();
		if (verify(UPRPEXIT,0))
			error_abort();
		}
	// Clear the symbol name field
	cursymn=0;
	curcell=0;
	curpage=0;
	curpinn=0;
	curpinl[0].pxn=0;
	curpinl[0].ptyp="";
	curpolyn=0;
	curpolyl[0].pn=0;
	curtextn=0;
	curinstn=0;
	instbabase=instban;
	curaliasn=0;
	cursheetscale=1.0;
	// Return without errors
	return(p_decstk(6));
}

int p_cellname()
// Receive a cell name
// Returns : zero if done or (-1) on error
{
	// Get the symbol name
	cursymname[cursymn]=
	 gcrename(namestk[namestkn],renamestk[namestkn],NTYP_MAC);
	// Adjust the symbol count
	cursymn++;
	// Set default designator name
	curdesignator="";
	curcell=1;
	curpage=curpagedone=0;
	curpageblock="";
	cursymboldone=0;
	curview=0;
	curcellcode=0;
	curtitledisp=0;
	curhotx=curhoty=0.0;
	curvaldisp=0;
	curnamedisp=0;
	netnamen=0;
	curinstn=0;
	instbabase=instban;
	curtextn=0;
	curpinn=0;
	curpinl[0].pxn=0;
	curpinl[0].ptyp="";
	curpolyn=0;
	curpolyl[0].pn=0;
	curlx=curly=curux=curuy=0.0;
	cursheetscale=1.0;
	// Return without errors
	return(0);
}

int p_cellref()
// Receive a cell reference name
// Returns : zero if done or (-1) on error
{
	// Get the symbol name
	curcellref=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_MAC);
	// Return without errors
	return(0);
}

int p_circle()
// Receive a circle
// Returns : zero if done or (-1) on error
{
	double cx, cy			/* Center coordinates */;
	int sidx			/* Polygon point list start index */;
	// Check if symbol skip
	sidx=pointstk[pointstkn-1];
	if (curview!=1 || (pointstk[pointstkn]-sidx)!=2 ||
	 (curpage && cursymbol))
		return(p_decstk(1));
	// Check circle size
	if (curpointl[sidx].x==curpointl[sidx+1].x &&
	 curpointl[sidx].y==curpointl[sidx+1].y) {
		if (ZEROCRAD==0.0)
			return(p_decstk(1));
		cx=curpointl[sidx].x;
		cy=curpointl[sidx].y;
		storepoint(cx-ZEROCRAD,cy,0);
		storepoint(cx,cy,1);
		storepoint(cx+ZEROCRAD,cy,0);
		storepoint(cx,cy,1);
		storepoint(cx-ZEROCRAD,cy,0);
		}
	else {
		// Store the circle polygon
		cx=0.5*(curpointl[sidx].x+curpointl[sidx+1].x);
		cy=0.5*(curpointl[sidx].y+curpointl[sidx+1].y);
		storepoint(curpointl[sidx].x,curpointl[sidx].y,0);
		storepoint(cx,cy,1);
		storepoint(curpointl[sidx+1].x,curpointl[sidx+1].y,0);
		storepoint(cx,cy,1);
		storepoint(curpointl[sidx].x,curpointl[sidx].y,0);
		}
	termpoly(0);
	// Return without errors
	return(p_decstk(1));
}

int p_connectloc()
// Receive a connection location
// Returns : zero if done or (-1) on error
{
	curconlx=curdotx;
	curconly=curdoty;
	if (curportiref>=0) {
		curinstl[curportiref].cx=curconlx;
		curinstl[curportiref].cy=curconly;
		}
	// Return without errors
	return(0);
}

int p_decstk(int stkfield)
// Receive a stack pointer decrement
// Returns : zero if done or (-1) on error
{
	if (stkfield&1)
		pointstkn--;
	if (stkfield&2) {
		namestkn--;
		curstrval=strvalstk[namestkn];
		}
	if (stkfield&4)
		boxstkn--;
	// Return without errors
	return(0);
}

int p_designator()
// Receive a designator
// Returns : zero if done or (-1) on error
{
	curdes=1;
	incnamespace(NTYP_NAME);
	// Return without errors
	return(0);
}

int p_designatorend()
// Receive a designator end
// Returns : zero if done or (-1) on error
{
	int len				/* String length */;
	int i,j				/* Loop variables */;
	curdes=0;
	if (curview!=1 ||
	 (curport==0 && curinstance==0 && curcell==0 && instbaproc==0)) {
		decnamespace();
		return(0);
		}
	// Store the physical pin names
	if (curport) {
		strlower(curstrval);
		len=strlen(curstrval);
		if (len==0)
			curpinl[curpinn].pxl[curpinl[curpinn].pxn++]=
			 curpinl[curpinn].name;
		for (i=0;i<len;i++) {
			if (curstrval[i]==' ')
				continue;
			for (j=i;j<len && curstrval[j]!=' ';j++)
				;
			curpinl[curpinn].pxl[curpinl[curpinn].pxn++]=
			 strextract(curstrval,i,j-1);
			i=j;
			}
		}
	else if (curinstance && !curnameass) {
		if (curstrval!="") {
			curinstl[curinstn].name=
			 gcrename(curstrval,curstrval,NTYP_NAME);
			curnameass=1;
			}
		}
	else if (curcell) {
		strlower(curstrval);
		curdesignator=curstrval;
		}
	else if (instbaproc) {
		curdesignator=gcrename(curstrval,curstrval,NTYP_NAME);
		}
	decnamespace();
	// Return without errors
	return(0);
}

int p_dispgroup()
// Receive a display group name
// Returns : zero if done or (-1) on error
{
	// Get the display group name
	curdispgrp=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_GRP);
	// Return without errors
	return(0);
}

int p_display()
// Receive a display start
// Returns : zero if done or (-1) on error
{
	// Set the display flag
	curdisplay=1;
	curaliasl[curaliasn].name= curstrdispflag ?
	 gcrename(curstrdisp,curstrdisp,NTYP_NAME) :
	 gcrename(namestk[namestkn],renamestk[namestkn],NTYP_NAME);
	curori=0;
	curjustify=0;
	// Return without errors
	return(p_incstk(2));
}

int p_displayend()
// Receive a display end
// Returns : zero if done or (-1) on error
{
	// Check if instance name display
	if (curinstance && !curportinst) {
		if (curdes) {
			curinstl[curinstn].namedisp=1;
			curinstl[curinstn].namex=curorgx;
			curinstl[curinstn].namey=curorgy;
			curinstl[curinstn].nameang=curori*0.5*PI;
			curinstl[curinstn].namejustify=curjustify;
			}
		if (curprop && curpropname==VALPROP) {
			curvaldisp=1;
			curvalx=curorgx;
			curvaly=curorgy;
			curvalang=curori*0.5*PI;
			curvaljustify=curjustify;
			}
		}
	// Reset the display flag
	curdisplay=0;
	// Return without errors
	return(p_decstk(2));
}

int p_dot()
// Receive a dot
// Returns : zero if done or (-1) on error
{
	int sidx			/* Polygon point list start index */;
	// Check if symbol skip
	sidx=pointstk[pointstkn-1];
	if (curview!=1 || (pointstk[pointstkn]-sidx)!=1)
		return(p_decstk(1));
	if (DOTDRAW) {
		// Store the circle polygon
		storepoint(curpointl[sidx].x+DOTRAD,curpointl[sidx].y,0);
		storepoint(curpointl[sidx].x,curpointl[sidx].y,1);
		storepoint(curpointl[sidx].x-DOTRAD,curpointl[sidx].y,0);
		storepoint(curpointl[sidx].x,curpointl[sidx].y,1);
		termpoly(1);
		}
	curdotx=curpointl[sidx].x;
	curdoty=curpointl[sidx].y;
	// Return without errors
	return(p_decstk(1));
}

int p_expnumber(expflag)
// Receive a exponent based value
// Returns : zero if done or (-1) on error
int expflag			/* Negative number flag */;
{
	if (expflag) {
		curflt=curexp;
		if (curint>0) {
			while (curint>0) {
				curflt*=10.0;
				curint--;
				}
			}
		else {
			while (curint<0) {
				curflt*=0.1;
				curint++;
				}
			}
		}
	else {
		curexp=curflt;
		}
	// Return without errors
	return(0);
}

int p_false()
// Receive a false value
// Returns : zero if done or (-1) on error
{
	curbool=0;
	// Return without errors
	return(0);
}

int p_fltcoord()
// Receive a coordinate value
// Returns : zero if done or (-1) on error
{
	// Convert the value to internal units
	curflt*=lenconv;
	// Return without errors
	return(0);
}

int p_ident()
// Receive an identifier
// Returns : zero if done or (-1) on error
{
	// Store the current string
	curid=synscanstring();
	// Return without errors
	return(0);
}

int p_incstk(int stkfield)
// Receive a stack pointer increment
// Returns : zero if done or (-1) on error
{
	if (stkfield&1) {
		pointstk[pointstkn+1]=pointstk[pointstkn];
		pointstkn++;
		}
	if (stkfield&2) {
		strvalstk[namestkn]=curstrval;
		namestkn++;
		}
	if (stkfield&4) {
		boxstkn++;
		boxstk[boxstkn].lx=boxstk[boxstkn].ly=0.0;
		boxstk[boxstkn].ux=boxstk[boxstkn].uy=0.0;
		}
	// Return without errors
	return(0);
}

int p_instancestart()
// Receive an instance start
// Returns : zero if done or (-1) on error
{
	incnamespace(NTYP_NAME);
	return(p_incstk(2));
}

int p_instance()
// Receive an instance
// Returns : zero if done or (-1) on error
{
	curtransx=curtransy=0.0;
	curtransori=0;
	curxscale=1.0;
	curori=0;
	curjustify=0;
	curinstance=1;
	curnameass=0;
	curvaldisp=0;
	curcellref="";
	curinstl[curinstn].namex=curinstl[curinstn].namey=0.0;
	curinstl[curinstn].cx=curinstl[curinstn].cy=(-1.0);
	curinstl[curinstn].namejustify=8;
	curinstl[curinstn].namedisp=0;
	if (curportimp) {
		curinstl[curinstn].name=curportname;
		curportiref=curinstn;
		if (curpinnamedisp) {
			curinstl[curinstn].namex=curpinnamex;
			curinstl[curinstn].namey=curpinnamey;
			curinstl[curinstn].nameang=curpinnameori*0.5*PI;
			curinstl[curinstn].namejustify=curpinnamejustify;
			curinstl[curinstn].namedisp=1;
			}
		}
	else {
		curinstl[curinstn].name=
		 gcrename(namestk[namestkn],renamestk[namestkn],NTYP_NAME);
		}
	curinstl[curinstn].value="";
	curinstl[curinstn].attrn=0;
	curinstl[curinstn].valdisp=0;
	instbal[instban].instname=curinstl[curinstn].name;
	instbal[instban].planname="";
	instbal[instban].plcname="";
	instbal[instban].backname="";
	instbal[instban].plname="";
	// Return without errors
	return(0);
}

int p_instanceend()
// Receive an instance end
// Returns : zero if done or (-1) on error
{
	string macro			/* Macro name */;
	int symidx			/* Symbol index */;
	// Reset instance process status
	curinstance=0;
	// Check if first view
	if (curview!=1) {
		decnamespace();
		return(p_decstk(2));
		}
	macro=gcrename(curcellref,curcellref,NTYP_MAC);
	// Get symbol macro info
	if ((symidx=findsymbol(macro))<0) {
		decnamespace();
		return(p_decstk(2));
		}
	switch (syml[symidx].typ) {
		// Tie
		case 1 :
		decnamespace();
		// Ignore tie symbol
		return(p_decstk(2));
		// Ripper
		case 2 :
		break;
		// Global symbol
		case 3 :
		break;
		// Port symbol
		case 4 :
		break;
		// Title block symbol
		case 5 :
		// Check if title block symbol
		if (curtitledisp==0) {
			decnamespace();
			// Ignore title block symbol
			return(p_decstk(2));
			}
		break;
		// Generic
		case 0 :
		// Unknown
		default :
		}
	// Store the instance
	curinstl[curinstn].x=curtransx;
	curinstl[curinstn].y=curtransy;
	curinstl[curinstn].cx=(-1.0);
	curinstl[curinstn].cy=(-1.0);
	curinstl[curinstn].ori=curtransori;
	curinstl[curinstn].macro=macro;
	curinstl[curinstn].typ=(curpage &&
	 ddbcheck(ddbfname,DDBCLSSYM,curinstl[curinstn].macro)==(-1) &&
	 ddbcheck(ddbfname,DDBCLSCM,curinstl[curinstn].macro)==0) ? 1 : 0 ;
	curinstn++;
	instban++;
	// Transfer cell scale to sheet scale
	if (cursheetscale==1.0)
		cursheetscale=1.0/curxscale;
	curxscale=1.0;
	decnamespace();
	// Return without errors
	return(p_decstk(2));
}

int p_instancerefend()
// Receive a instance reference end
// Returns : zero if done or (-1) on error
{
	string instname			/* Instance name */;
	int symidx			/* Symbol name index */;
	int i				/* Loop control variable */;
	if (curnet && !curportlist) {
		instname=
		 gcrename(namestk[namestkn],renamestk[namestkn],NTYP_NAME);
		for (i=0;i<curinstn;i++)
			if (curinstl[i].name==instname &&
			 (symidx=findsymbol(curinstl[i].macro))>=0 &&
			 syml[symidx].typ==2) {
				if (curmembnum>=0)
					// Use member index as ripper name
					curinstl[i].name=itoa(curmembnum);
				else
					// Use net name as ripper instance name
					curinstl[i].name=netnamel[netnamen-1];
				curripsym=1;
				}
		curmembnum=(-1);
		}
	else if (instbaproc) {
		curinstbaname=
		 gcrename(namestk[namestkn],renamestk[namestkn],NTYP_NAME);
		}
	return(p_decstk(2));
}

int p_justify(int typ)
// Receive a justify specification
// Returns : zero if done or (-1) on error
{
	// Store the justify specification
	curjustify=typ;
	// Return without errors
	return(0);
}

int p_keydispend()
// Receive a keyword display end
// Returns : zero if done or (-1) on error
{
	if (curview!=1)
		return(p_decstk(2));
	if (curnamedisp) {
		if (curport || curportimp) {
			if (curdispgrp=="pinnumber") {
				curpinnumx=curorgx;
				curpinnumy=curorgy;
				curpinnumori=curori;
				curpinnumjustify=curjustify;
				curpinnumdisp=1;
				}
			else if (curdispgrp=="pinname") {
				curpinnamex=curorgx;
				curpinnamey=curorgy;
				curpinnameori=curori;
				curpinnamejustify=curjustify;
				curpinnamedisp=1;
				}
			}
		else if (curcell) {
			curnamex=curorgx;
			curnamey=curorgy;
			curnameang=curori*0.5*PI;
			curnamejustify=curjustify;
			}
		}
	return(p_decstk(2));
}

int p_nameend()
// Receive a name end
// Returns : zero if done or (-1) on error
{
	if (curview!=1)
		return(0);
	if (curport || curportimp) {
		if (curdispgrp=="pinnumber") {
			curpinnumx=curorgx;
			curpinnumy=curorgy;
			curpinnumori=curori;
			curpinnumjustify=curjustify;
			curpinnumdisp=1;
			}
		else if (curdispgrp=="pinname" || curdispgrp=="port") {
			curpinnamex=curorgx;
			curpinnamey=curorgy;
			curpinnameori=curori;
			curpinnamejustify=curjustify;
			curpinnamedisp=1;
			}
		}
	return(0);
}

int p_keydispname()
// Receive a keyword display name
// Returns : zero if done or (-1) on error
{
	string name			/* Property name */;
	if (curview!=1)
		return(0);
	// Get the keyword name
	name=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_KEY);
	if (name=="designator")
		curnamedisp=1;
	curjustify=8;
	curorgx=curorgy=0.0;
	// Return without errors
	return(0);
}

int p_member()
// Receive a member command
// Returns : zero if done or (-1) on error
{
	curmember=1;
	// Return without errors
	return(0);
}

int p_membnum()
// Receive a member number
// Returns : zero if done or (-1) on error
{
	curmembnum=curint;
	// Return without errors
	return(0);
}

int p_name()
// Receive a name
// Returns : zero if done or (-1) on error
{
	namestk[namestkn]=renamestk[namestkn]=curid;
	curdispgrp="";
	curori=0;
	curjustify=8;
	if (curportimp && curview==1 && curportname=="")
		portpinname();
	// Return without errors
	return(0);
}

void portpinname()
// Receive a port pin name
{
	int i				/* Loop control variable */;
	// Get the port pin name
	curportname=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_NAME);
	curportoname=namestk[namestkn];
	for (i=0;i<curpinn;i++)
		if (curpinl[i].oname==curportoname &&
		 curpinl[i].rname==curportname) {
			curconlx=curpinl[i].x;
			curconly=curpinl[i].y;
			curori=curpinl[i].ang*2.0/PI;
			curpinnamex=curpinl[i].namex;
			curpinnamey=curpinl[i].namey;
			curpinnameori=curpinl[i].nameang*2.0/PI;
			curpinnamejustify=curpinl[i].namejustify;
			curpinnamedisp=curpinl[i].namedisp;
			curpinnumx=curpinl[i].numx;
			curpinnumy=curpinl[i].numy;
			curpinnumori=curpinl[i].numang*2.0/PI;
			curpinnumjustify=curpinl[i].numjustify;
			curpinnumdisp=curpinl[i].numdisp;
			break;
			}
}

int p_namedef(int typ)
// Receive a name
// Returns : zero if done or (-1) on error
{
	switch (typ) {
		case 0 :
		renamestk[namestkn]=namestk[namestkn]=curid;
		if (curportimp && curview==1 && curportname=="")
			portpinname();
		return(0);
		case 2 :
		renamestk[namestkn]=curstrdisp;
		gcrename(namestk[namestkn],
		 renamestk[namestkn],curnametype[curnametypen]);
		return(0);
		case 4 :
		renamestk[namestkn]=curstrval;
		gcrename(namestk[namestkn],
		 renamestk[namestkn],curnametype[curnametypen]);
		return(0);
		default :
		namestk[namestkn]=synscanstring();
		}
	renamestk[namestkn]=namestk[namestkn];
	// Return without errors
	return(0);
}

int p_instbackanno()
// Receive an instance backannotate command
// Returns : zero if done or (-1) on error
{
	instbaproc=1;
	curdesignator=curinstbaname=curplname="";
	return(p_incstk(2));
}

int p_instbackannoend()
// Receive an instance backannotate end command
// Returns : zero if done or (-1) on error
{
	int i			/* Loop control variable */;
	if (curdesignator!="" && curinstbaname!="") {
		for (i=0;i<instban;i++)
			if (curinstbaname==instbal[i].instname) {
				if (curdesignator!=instbal[i].plcname) {
					instbal[i].backname=curdesignator;
					instbal[i].plname=curplname;
					instback=1;
					}
				break;
				}
		}
	instbaproc=0;
	return(p_decstk(2));
}

int p_net()
// Receive a net command
// Returns : zero if done or (-1) on error
{
	curarray=0;
	curmember=0;
	curmembnum=(-1);
	curripsym=0;
	curnet=1;
	fnalias=curaliasn;
	netpolyoff=curpolyn;
	incnamespace(NTYP_NAME);
	return(p_incstk(2));
}

int p_netname()
// Receive a net name command
// Returns : zero if done or (-1) on error
{
	int i				/* Loop control variable */;
	netnamel[netnamen]=
	 gcrename(namestk[namestkn],renamestk[namestkn],NTYP_NAME);
	for (i=fnalias;i<curaliasn;i++)
		curaliasl[i].name=netnamel[netnamen];
	netnamen++;
	// Return without errors
	return(0);
}

int p_netend()
// Receive a net end
// Returns : zero if done or (-1) on error
{
	int i				/* Loop control variable */;
	if (curarray || (curripsym && !curmember))
		for (i=netpolyoff;i<curpolyn;i++)
			if (curpolyl[i].ptyp==(-1))
				curpolyl[i].ptyp=(-2);
	curripsym=0;
	curnet=0;
	netnamel[netnamen]="";
	curmember=0;
	decnamespace();
	return(p_decstk(2));
}

int p_ori(int ori)
// Receive an orientation
// Returns : zero if done or (-1) on error
{
	curori=ori;
	// Return without errors
	return(0);
}

int p_origin()
// Receive an origin
// Returns : zero if done or (-1) on error
{
	int sidx			/* Polygon point list start index */;
	// Check if symbol skip
	sidx=pointstk[pointstkn-1];
	if (curview!=1 || (pointstk[pointstkn]-sidx)!=1)
		return(p_decstk(1));
	// Store the coordinates
	curorgx=curpointl[sidx].x;
	curorgy=curpointl[sidx].y;
	if (curdisplay && curdispgrp=="alias") {
		curaliasl[curaliasn].x=curorgx;
		curaliasl[curaliasn].y=curorgy;
		curaliasl[curaliasn].ori=curori;
		curaliasn++;
		}
	// Return without errors
	return(p_decstk(1));
}

int p_pagestart()
// Receive a page start
// Returns : zero if done or (-1) on error
{
	incnamespace(NTYP_NAME);
	return(p_incstk(6));
}

int p_page()
// Receive a page command
// Returns : zero if done or (-1) on error
{
	string pagename			/* Page name */;
	int pagenlen			/* Page name length */;
	int viewbak			/* View backup */;
	int cellcodebak			/* Cell code backup */;
	string pageblockbak		/* Page block backup */;
	int symdonebak			/* Symbol done flag backup */;
	// Store the page symbol
	if (cursymboldone) {
		curpagesym=1;
		if (p_cellend())
			return(-1);
		curpagesym=0;
		p_incstk(6);
		}
	// Get the page name
	pagename=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_NAME);
	pagenlen=strlen(pagename);
	viewbak=curview;
	cellcodebak=curcellcode;
	symdonebak=cursymboldone;
	// Strip schematic extension
	if (pagenlen>4 &&
	 pagename[pagenlen-4]=='.' && pagename[pagenlen-3]=='s' &&
	 pagename[pagenlen-2]=='c' && pagename[pagenlen-1]=='h')
		pagename[pagenlen-4]='\0';
	if (curpageblock=="")
		curpageblock=cursymname[0];
	renamestk[namestkn]=namestk[namestkn]=curpageblock+"_"+pagename;
	pageblockbak=curpageblock;
	// Store the page cell
	if (p_cellname())
		return(-1);
	curview=viewbak;
	curcellcode=cellcodebak;
	curpageblock=pageblockbak;
	cursymboldone=symdonebak;
	renamestk[namestkn]=namestk[namestkn]=pagename;
	curpage=1;
	// Return without errors
	return(0);
}

int p_pageend()
// Receive a page end command
// Returns : zero if done or (-1) on error
{
	double olx,oly			/* Old lower boundary */;
	double oux,ouy			/* Old upper boundary */;
	if (curpage) {
		// Get the page size
		olx=curlx; oly=curly;
		oux=curux; ouy=curuy;
		curlx=boxstk[boxstkn].lx; curly=boxstk[boxstkn].ly;
		curux=boxstk[boxstkn].ux; curuy=boxstk[boxstkn].uy;
		// Store the last page
		if (p_cellend()) {
			decnamespace();
			return(-1);
			}
		p_incstk(6);
		curlx=olx; curly=oly;
		curux=oux; curuy=ouy;
		curpage=0;
		curpagedone=1;
		}
	decnamespace();
	// Return without errors
	return(p_decstk(6));
}

int p_portstart()
// Receive a port start
// Returns : zero if done or (-1) on error
{
	incnamespace(NTYP_NAME);
	return(p_incstk(2));
}

int p_pinname()
// Receive a pin name
// Returns : zero if done or (-1) on error
{
	string name			/* Pin name */;
	int pcnt			/* Double pin count */;
	int i				/* Loop control variable */;
	if (curview!=1)
		return(0);
	curport=1;
	// Store the pin data
	curpinl[curpinn].x=curpinl[curpinn].y=0.0;
	curpinl[curpinn].ang=0.0;
	curpinl[curpinn].namex=curpinl[curpinn].namey=0.0;
	curpinl[curpinn].namejustify=8;
	curpinl[curpinn].namedisp=0;
	curpinl[curpinn].numx=curpinl[curpinn].numy=0.0;
	curpinl[curpinn].numjustify=8;
	curpinl[curpinn].numdisp=0;
	curpinnumx=curpinnumy=0.0;
	curpinnumori=0;
	curpinnumjustify=8;
	curpinnumdisp=0;
	curpinnamex=curpinnamey=0.0;
	curpinnameori=0;
	curpinnamejustify=8;
	curpinnamedisp=0;
	name=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_NAME);
	for (i=pcnt=0;i<curpinn;i++)
		if (curpinl[i].rname==name)
			pcnt++;
	curpinl[curpinn].name=name+(pcnt==0 ? "" : ("_"+itoa(pcnt-1)));
	curpinl[curpinn].rname=name;
	curpinl[curpinn].oname=namestk[namestkn];
	curpinl[curpinn].pxn=0;
	curpinl[curpinn].ptyp="";
	curconlx=curconly=0.0;
	curori=0;
	// Return without errors
	return(0);
}

int p_pintyp()
// Receive a pin type
// Returns : zero if done or (-1) on error
{
	string ptyp			/* Pin type */;
	// Get the pin type
	ptyp=synscanstring();
	strlower(ptyp);
	// Transform pin type
	switch (ptyp) {
		case "input" :
		ptyp="in";
		break;
		case "output" :
		ptyp="out";
		break;
		case "inout" :
		ptyp="bidi";
		break;
		default :
		;
		}
	curpinl[curpinn].ptyp=ptyp;
	// Return without errors
	return(0);
}

int p_pointvalue()
// Receive a point value list entry
// Returns : zero if done or (-1) on error
{
	if (curview!=1)
		return(0);
	curpointl[pointstk[pointstkn]].x=curx;
	curpointl[pointstk[pointstkn]].y=cury;
	curpointl[pointstk[pointstkn]].t=0;
	pointstk[pointstkn]++;
	// Return without errors
	return(0);
}

int p_polygon(int typ)
// Receive a polygon end
// Returns : zero if done or (-1) on error
{
	string rname		/* Ripper symbol name */;
	int pidx		/* Polygon point list index */;
	int eidx		/* Polygon point list end index */;
	if (curview!=1 || (curpage && cursymbol))
		return(p_decstk(1));
	eidx=pointstk[pointstkn];
	pidx=pointstk[pointstkn-1];
	if (curcellcode!=2 &&
	 (curdispgrp=="wire" || curdispgrp=="net_fgp") && eidx==(pidx+2) &&
	 fabs(fabs(curpointl[pidx].x-curpointl[pidx+1].x)-
	  fabs(curpointl[pidx].y-curpointl[pidx+1].y))<=SDVAL) {
		sprintf(rname,"xrip_%d",curinstn);
		curinstl[curinstn].name=rname;
		curinstl[curinstn].value="";
		curinstl[curinstn].x=curpointl[pidx+1].x;
		curinstl[curinstn].y=curpointl[pidx+1].y;
		curinstl[curinstn].ori=0;
		curinstl[curinstn].typ=0;
		if (curpointl[pidx].x>curpointl[pidx+1].x) {
			if (curpointl[pidx].y>curpointl[pidx+1].y)
				curinstl[curinstn].macro="xrip0b1y1";
			else
				curinstl[curinstn].macro="xrip0b1m1";
			}
		else {
			if (curpointl[pidx].y>curpointl[pidx+1].y)
				curinstl[curinstn].macro="xrip0bm1y1";
			else
				curinstl[curinstn].macro="xrip0bm1m1";
			}
		curinstn++;
		}
	else {
		for (;pidx<eidx;pidx++)
			// Store the coordinates
			storepoint(curpointl[pidx].x,curpointl[pidx].y,
			 curpointl[pidx].t);
		if (typ==0 && curcellcode!=2) {
			if (curdispgrp=="wire" || curdispgrp=="net_fgp")
				termpoly(-1);
			else if (curdispgrp=="bus" || curdispgrp=="bus_fgp")
				termpoly(-2);
			else
				termpoly(typ);
			}
		else {
			termpoly(typ);
			}
		}
	// Return without errors
	return(p_decstk(1));
}

int p_portend()
// Receive a port end
// Returns : zero if done or (-1) on error
{
	curport=0;
	if (curview!=1) {
		decnamespace();
		return(p_decstk(2));
		}
	curpinl[curpinn].x=curconlx;
	curpinl[curpinn].y=curconly;
	curpinl[curpinn].ang=curori*0.5*PI;
	curpinl[curpinn].namex=curpinnamex;
	curpinl[curpinn].namey=curpinnamey;
	curpinl[curpinn].nameang=curpinnameori*0.5*PI;
	curpinl[curpinn].namejustify=curpinnamejustify;
	curpinl[curpinn].namedisp=curpinnamedisp;
	curpinl[curpinn].numx=curpinnumx;
	curpinl[curpinn].numy=curpinnumy;
	curpinl[curpinn].numang=curpinnumori*0.5*PI;
	curpinl[curpinn].numjustify=curpinnumjustify;
	curpinl[curpinn].numdisp=curpinnumdisp;
	curpinl[curpinn].sflag=cursymbol;
	curpinl[curpinn].portimp=0;
	curpinn++;
	curpinl[curpinn].pxn=0;
	curpinl[curpinn].ptyp="";
	curconlx=curconly=0.0;
	curori=0;
	decnamespace();
	// Return without errors
	return(p_decstk(2));
}

int p_portimp()
// Receive a port implementation start
// Returns : zero if done or (-1) on error
{
	curportimp=1;
	curportiref=(-1);
	curportname=curportoname="";
	curcellref="";
	curvisible=1;
	curconlx=curconly=0.0;
	curpinnumx=curpinnumy=0.0;
	curpinnumori=0;
	curpinnumjustify=8;
	curpinnumdisp=0;
	curpinnamex=curpinnamey=0.0;
	curpinnameori=0;
	curpinnamejustify=8;
	curpinnamedisp=0;
	curori=0;
	incnamespace(NTYP_NAME);
	// Return without errors
	return(p_incstk(2));
}

int p_portimpend()
// Receive a port implementation end
// Returns : zero if done or (-1) on error
{
	int pcnt			/* Double pin count */;
	int i				/* Loop control variable */;
	if (curview!=1) {
		curconlx=curconly=0.0;
		curori=0;
		curportimp=0;
		curportiref=(-1);
		decnamespace();
		return(p_decstk(2));
		}
	for (i=0;i<curpinn;i++)
		if (curpinl[i].oname==curportoname &&
		 curpinl[i].rname==curportname)
			break;
	if (i>=curpinn) {
		if (curvisible) {
			for (i=pcnt=0;i<curpinn;i++)
				if (curpinl[i].rname==curportname)
					pcnt++;
			// Store the pin data
			curpinl[curpinn].x=curconlx;
			curpinl[curpinn].y=curconly;
			curpinl[curpinn].ang=curori*0.5*PI;
			curpinl[curpinn].name=
			 curportname+(pcnt==0 ? "" : ("_"+itoa(pcnt-1)));
			curpinl[curpinn].rname=curportname;
			curpinl[curpinn].oname=curportoname;
			curpinl[curpinn].pxn=0;
			curpinl[curpinn].ptyp="";
			curpinl[curpinn].sflag=cursymbol;
			curpinl[curpinn].portimp=1;
			curpinl[curpinn].namex=curpinnamex;
			curpinl[curpinn].namey=curpinnamey;
			curpinl[curpinn].nameang=curpinnameori*0.5*PI;
			curpinl[curpinn].namejustify=curpinnamejustify;
			curpinl[curpinn].namedisp=curpinnamedisp;
			curpinl[curpinn].numx=curpinnumx;
			curpinl[curpinn].numy=curpinnumy;
			curpinl[curpinn].numang=curpinnumori*0.5*PI;
			curpinl[curpinn].numjustify=curpinnumjustify;
			curpinl[curpinn].numdisp=curpinnumdisp;
			curpinn++;
			curpinl[curpinn].pxn=0;
			curpinl[curpinn].ptyp="";
			}
		}
	else {
		if (cursymbol) {
			curpinl[i].x=curconlx;
			curpinl[i].y=curconly;
			curpinl[i].namex=curpinnamex;
			curpinl[i].namey=curpinnamey;
			curpinl[i].nameang=curpinnameori*0.5*PI;
			curpinl[i].namejustify=curpinnamejustify;
			curpinl[i].namedisp=curpinnamedisp;
			curpinl[i].numx=curpinnumx;
			curpinl[i].numy=curpinnumy;
			curpinl[i].numang=curpinnumori*0.5*PI;
			curpinl[i].numjustify=curpinnumjustify;
			curpinl[i].numdisp=curpinnumdisp;
			curpinl[i].ang=curori*0.5*PI;
			}
		curpinl[i].sflag|=cursymbol;
		curpinl[i].portimp=1;
		}
	curconlx=curconly=0.0;
	curori=0;
	curportimp=0;
	curportiref=(-1);
	decnamespace();
	// Return without errors
	return(p_decstk(2));
}

int p_portinst()
// Receive a port instance start
// Returns : zero if done or (-1) on error
{
	curportinst=1;
	incnamespace(NTYP_NAME);
	// Return without errors
	return(p_incstk(2));
}

int p_portinstend()
// Receive a port instance end
// Returns : zero if done or (-1) on error
{
	curportinst=0;
	decnamespace();
	// Return without errors
	return(p_decstk(2));
}

int p_portlist()
// Receive a port list start
// Returns : zero if done or (-1) on error
{
	curportlist=1;
	// Return without errors
	return(p_incstk(2));
}

int p_portlistend()
// Receive a port list end
// Returns : zero if done or (-1) on error
{
	curportlist=0;
	// Return without errors
	return(p_decstk(2));
}

int p_propdispend()
// Receive a property display end
// Returns : zero if done or (-1) on error
{
	if (curview!=1)
		return(p_decstk(2));
	if (curvaldisp) {
		curvalx=curorgx;
		curvaly=curorgy;
		curvalang=curori*0.5*PI;
		curvaljustify=curjustify;
		}
	return(p_decstk(2));
}

int p_propdispname()
// Receive a property display name
// Returns : zero if done or (-1) on error
{
	string name			/* Property name */;
	if (curview!=1)
		return(0);
	// Get the property name
	name=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_KEY);
	if (name==VALPROP)
		curvaldisp=1;
	curorgx=curorgy=0.0;
	curjustify=8;
	curori=0;
	// Return without errors
	return(0);
}

int p_propname()
// Receive a property name
// Returns : zero if done or (-1) on error
{
	// Get the property name
	curpropname=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_KEY);
	curprop=1;
	if (!curcell) {
		curvalx=curvaly=0.0;
		curvaljustify=8;
		curvaldisp=0;
		}
	// Return without errors
	return(0);
}

int p_propval()
// Receive a property value
// Returns : zero if done or (-1) on error
{
	int i				/* Loop control variable */;
	curprop=0;
	switch (curpropname) {
		case "celltype" :
		case "orcadviewtype" :
		strlower(curstrval);
		switch (curstrval) {
			case "global_symbol" :
			curcellcode=3;
			break;
			case "off_page_symbol" :
			case "pageport" :
			case "port_symbol" :
			curcellcode=4;
			break;
			case "titleblock_symbol" :
			case "pagetemplate" :
			curcellcode=5;
			break;
			case "symbolport" :
/* XXX
			curcellcode=4;
*/
			break;
			default :
			;
			}
		}
	if (curview!=1)
		return(0);
	switch (curpropname) {
		case "edifhotspot" :
		extractptxy(curstrval,curhotx,curhoty);
		break;
		case "hotspot" :
		// Store the coordinates
		curhotx=curx;
		curhoty=cury;
		break;
		case "titleblock_displayed" :
		curtitledisp= curstrval=="0" ? 0 : 1 ;
		break;
		case "orcadportorigin" :
		extractptxy(curstrval,curconlx,curconly);
		break;
		case VALPROP :
		if (curinstance) {
			if (curinstl[curinstn].value=="")
				curinstl[curinstn].value=
				 valstrconv(curstrval);
			else
				curinstl[curinstn].value=
				 valstrconv(curstrval+","+
				 curinstl[curinstn].value);
			if (curvaldisp) {
				curinstl[curinstn].valdisp=1;
				curinstl[curinstn].valx=curvalx;
				curinstl[curinstn].valy=curvaly;
				curinstl[curinstn].valang=curvalang;
				curinstl[curinstn].valjustify=curvaljustify;
				}
			}
		break;
		case "1st part field" :
		case "2st part field" :
		case "3st part field" :
		case "4st part field" :
		case "5st part field" :
		case "6st part field" :
		case "7st part field" :
		case "8st part field" :
		if (curinstance) {
			if (curinstl[curinstn].value=="")
				curinstl[curinstn].value=
				 valstrconv(curstrval);
			else
				curinstl[curinstn].value=
				 curinstl[curinstn].value+","+
				 valstrconv(curstrval);
			}
		break;
		case "fplist" :
		if (instbaproc && curstrval!="")
			curplname="["+convspaces(valstrconv(curstrval))+"]";
		break;
		default :
		if (curinstance) {
		    for (i=0;i<attrn;i++)
			if (attrl[i].attprop==curpropname) {
				curinstl[curinstn].attrnl[
				 curinstl[curinstn].attrn]=attrl[i].attname;
				curinstl[curinstn].attrvl[
				  curinstl[curinstn].attrn]=
				 valstrconv(curstrval);
				if (attrl[i].attname=="$plname")
					curinstl[curinstn].attrvl[
					  curinstl[curinstn].attrn]=
					 convspaces(curinstl[curinstn].attrvl[
					  curinstl[curinstn].attrn]);
				curinstl[curinstn].attrn++;
				break;
				}
		    }
		if (instbaproc && curstrval!="") {
		    for (i=0;i<attrn;i++)
			if (attrl[i].attprop==curpropname &&
			 attrl[i].attname=="$plname")
				curplname=convspaces(valstrconv(curstrval));
			}
		}
	// Return without errors
	return(0);
}

int p_rect()
// Receive a rectangle end
// Returns : zero if done or (-1) on error
{
	int sidx			/* Polygon point list start index */;
	// Check if symbol skip
	sidx=pointstk[pointstkn-1];
	if (curview!=1 || (pointstk[pointstkn]-sidx)!=2 ||
	 (curpage && cursymbol))
		return(p_decstk(1));
	// Store the coordinates
	storepoint(curpointl[sidx].x,curpointl[sidx].y,0);
	storepoint(curpointl[sidx+1].x,curpointl[sidx].y,0);
	storepoint(curpointl[sidx+1].x,curpointl[sidx+1].y,0);
	storepoint(curpointl[sidx].x,curpointl[sidx+1].y,0);
	storepoint(curpointl[sidx].x,curpointl[sidx].y,0);
	termpoly(0);
	// Return without errors
	return(p_decstk(1));
}

int p_rename(status)
// Receive a rename status
// Returns : zero if done or (-1) on error
int status			/* Rename status */;
{
	// Store the rename status
	currename=status;
	// Return without errors
	return(0);
}

int p_scale(basemode)
// Receive a scale value
// Returns : zero if done or (-1) on error
int basemode			/* Base mode */;
{
	switch (basemode) {
		case 0 :
		curscale=curflt/curscale;
		break;
		case 1 :
		curscale=curflt*25.4;
		break;
		case 2 :
		if (curunit==5)
			lenconv=curscale*LENFAC;
		break;
		default :
		;
		}
	// Return without errors
	return(0);
}

int p_scalex(fracmode)
// Receive a X scale value
// Returns : zero if done or (-1) on error
int fracmode			/* Fraction mode */;
{
	switch (fracmode) {
		case 0 :
		curxscale=curflt;
		break;
		case 1 :
		curxscale/=curflt;
		break;
		default :
		;
		}
	// Return without errors
	return(0);
}

int p_signed(negflag)
// Receive a signed value
// Returns : zero if done or (-1) on error
int negflag			/* Negative number flag */;
{
	// Get the current float value
	curflt=atof(synscanstring());
	curint=atoi(synscanstring());
	// Set negative on request
	if (negflag) {
		curflt*=(-1);
		curint*=(-1);
		}
	// Return without errors
	return(0);
}

int p_strdisp()
// Receive a string value
// Returns : zero if done or (-1) on error
{
	curstrdisp=curstrval;
	curori=0;
	curstrdispflag=1;
	if (currename)
		return(p_namedef(2));
	// Return without errors
	return(0);
}

int p_strdispend()
// Receive a string value
// Returns : zero if done or (-1) on error
{
	if (curprop && curcell && curpropname==VALPROP) {
		curvaldisp=1;
		curvalx=curorgx;
		curvaly=curorgy;
		curvalang=curori*0.5*PI;
		curvaljustify=curjustify;
		}
	curstrdisp=curstrval;
	curori=0;
	curstrdispflag=0;
	if (currename)
		return(p_namedef(2));
	// Return without errors
	return(0);
}

int p_strval()
// Receive a string value
// Returns : zero if done or (-1) on error
{
	curstrval=synscanstring();
	// Return without errors
	return(0);
}

int p_symbol()
// Receive a symbol command
// Returns : zero if done or (-1) on error
{
	if (curview!=1)
		return(p_incstk(4));
	cursymbol=1;
	// Return without errors
	return(p_incstk(4));
}

int p_symbolend()
// Receive a symbol command end
// Returns : zero if done or (-1) on error
{
	if (curview!=1)
		return(p_decstk(4));
	curlx=boxstk[boxstkn].lx;
	curly=boxstk[boxstkn].ly;
	curux=boxstk[boxstkn].ux;
	curuy=boxstk[boxstkn].uy;
	cursymbol=0;
	cursymboldone=1;
	// Return without errors
	return(p_decstk(4));
}

int p_transini()
// Receive a transform initialization
// Returns : zero if done or (-1) on error
{
	// Store the coordinates
	curorgx=0.0;
	curorgy=0.0;
	curori=0;
	// Return without errors
	return(0);
}

int p_transform()
// Receive a transform coordinate pair
// Returns : zero if done or (-1) on error
{
	// Store the coordinates
	curtransx=curorgx;
	curtransy=curorgy;
	curtransori=curori;
	// Return without errors
	return(0);
}

int p_true()
// Receive a true value
// Returns : zero if done or (-1) on error
{
	curbool=1;
	// Return without errors
	return(0);
}

int p_unit(unitclass)
// Receive a unit class
// Returns : zero if done or (-1) on error
int unitclass			/* Unit class */;
{
	// Store the unit class
	curunit=unitclass;
	// Return without errors
	return(0);
}


int p_view()
// Receive a view
// Returns : zero if done or (-1) on error
{
	curviewname=gcrename(namestk[namestkn],renamestk[namestkn],NTYP_KEY);
	curviewtype=0;
	if (curview!=0 || curviewname!="convert")
		curview++;
	// Return without errors
	return(0);
}

int p_viewtype(viewtype)
// Receive a view type
// Returns : zero if done or (-1) on error
int viewtype			/* View type */;
{
	// Store the view type
	curviewtype=viewtype;
	// Return without errors
	return(0);
}

int p_visible()
// Receive a visible value
// Returns : zero if done or (-1) on error
{
	curvisible=curbool;
	// Return without errors
	return(0);
}

int p_size()
// Receive a size value
// Returns : zero if done or (-1) on error
{
	// Store size
	cursize=curflt;
	// Return without errors
	return(0);
}

int p_xcoord()
// Receive a x coordinate value
// Returns : zero if done or (-1) on error
{
	// Store x coordinate
	curx=curflt;
	// Return without errors
	return(0);
}

int p_ycoord()
// Receive a y coordinate value
// Returns : zero if done or (-1) on error
{
	// Store y coordinate
	cury=curflt;
	// Return without errors
	return(0);
}

void storepoint(x,y,t)
// Store a polygon point to the current polygon
double x, y		/* Polygon point coordinates */;
int t			/* Polygon point type */;
{
	int pn			/* Polygon point count */;
	// Get the point list index
	pn=curpolyl[curpolyn].pn;
	// Check for double point definitions
	if (pn>0 && curpolyl[curpolyn].pl[pn-1].x==x &&
	 curpolyl[curpolyn].pl[pn-1].y==y &&
	 curpolyl[curpolyn].pl[pn-1].t==t)
		// Ignore double point
		return;
	// Store the point data
	curpolyl[curpolyn].pl[pn].x=x;
	curpolyl[curpolyn].pl[pn].y=y;
	curpolyl[curpolyn].pl[pn].t=t;
	// Adjust the point count
	curpolyl[curpolyn].pn=pn+1;
}

void termpoly(int typ)
// Terminate a polygon defintion
{
	// Check if degenerated polygon
	if (curpolyl[curpolyn].pn<=1) {
		// Clear this polygon
		curpolyl[curpolyn].pn=0;
		curpolyl[curpolyn].ptyp=0;
		return;
		}
	curpolyl[curpolyn].ptyp=typ;
	curpolyl[curpolyn].netidx=netnamen-1;
	// Increment polygon count
	curpolyn++;
	// Init. next polygon
	curpolyl[curpolyn].pn=0;
	curpolyl[curpolyn].ptyp=0;
	curpolyl[curpolyn].netidx=(-1);
}

void extractptxy(string valstr,double x,double y)
// Terminate a polygon defintion
{
	int len				/* String length */;
	int cidx			/* Coordinate sep. index */;
	len=strlen(valstr);
	if (strextract(valstr,0,3)!="(pt " || valstr[len-1]!=')') {
		x=0.0;
		y=0.0;
		return;
		}
	// Get first coordinate end position
	cidx=strscannext(valstr," ",5,1)-1;
	x=atof(strextract(valstr,4,cidx))*lenconv;
	y=atof(strextract(valstr,cidx+1,len-2))*lenconv;
}

string gcrename(string oname,string rname,int ntyp)
/*
// Get or create a rename entry
// Return value :
//	original name
// Parameters :
//	string oname		: Orginal name
//	string rname		: Rename name
//	string ntyp		: Namespace type
*/
{
	int slb		= 0		/* Search lower boundary */;
	int sub		= renamen-1	/* Search upper boundary */;
	int sidx			/* Search index */;
	int compres			/* Compare result */;
	string cmpname			/* Compare name */;
	// Get the compare names
	cmpname=oname;
	strlower(cmpname);
	strlower(rname);
	// Loop until search area empty
	while (slb<=sub) {
		// Get the search index
		sidx=(slb+sub)>>1;
		// Get the comparison result
		if (ntyp==renamel[sidx].typ) {
			if ((compres=strcmp(cmpname,renamel[sidx].oname))==0) {
				if (currename)
					renamel[sidx].rname=rname;
				return(convspaces(RENAMEMODE ?
				 renamel[sidx].rname : renamel[sidx].oname));
				}
			}
		else {
			compres= ntyp<renamel[sidx].typ ? (-1) : 1 ;
			}
		if (compres<0)
			sub=sidx-1;
		else
			slb=sidx+1;
		}
	// Update the rename list
	for (sidx=renamen;sidx>slb;sidx--)
		renamel[sidx]=renamel[sidx-1];
	// Insert rename
	renamel[slb].rname=rname;
	renamel[slb].oname=cmpname;
	renamel[slb].typ=ntyp;
	renamen++;
	// Return name
	return(convspaces(RENAMEMODE ? rname : cmpname));
}

int findsymbol(string name)
/*
// Find a symbol macro entry
// Return value :
//	symbol list index or (-1) on not found
// Parameters :
//	string name		: Symbol name
*/
{
	int slb		= 0		/* Search lower boundary */;
	int sub		= symn-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;
		// Get the comparison result
		if ((compres=strcmp(name,syml[sidx].name))==0)
			return(sidx);
		if (compres<0)
			sub=sidx-1;
		else
			slb=sidx+1;
		}
	inssymidx=slb;
	// Symbol not found
	return(-1);
}

string valstrconv(string vstr)
/*
// Convert a value string
// Return value :
//	converted value string
*/
{
	string result			/* Result string */;
	int sidx			/* Search index */;
	int len				/* String length */;
	// Loop for all characters
	result="";
	len=strlen(vstr);
	for (sidx=0;sidx<len;sidx++)
		if (sidx>len-4 || vstr[sidx]!='%' ||
		 vstr[sidx+1]!='3' || vstr[sidx+2]!='7' || vstr[sidx+3]!='%') {
			sprintf(result,"%s%c",result,vstr[sidx]);
			}
		else {
			result+="%";
			sidx+=3;
			}
	// Return value
	return(result);
}

string textstrconv(string tstr)
/*
// Convert a text string
// Return value :
//	converted text string
*/
{
	string result			/* Result string */;
	int sidx			/* Search index */;
	int len				/* String length */;
	int code			/* ASCII code buffer */;
	char c				/* Character buffer */;
	// Loop for all characters
	result="";
	len=strlen(tstr);
	for (sidx=0;sidx<len;sidx++)
		if ((c=tstr[sidx])=='%' && isdigit(tstr[sidx+1])) {
			code=atoi(strextract(tstr,sidx+1,len));
			if (code==0x0a || code==0x0d)
				code=32;
			else if (code<128 && code!=37 && code!=34)
				code+=128;
			sprintf(result,"%s%c",result,code);
			// Skip escape sequence
			sidx++;
			while (sidx<len && tstr[sidx]!='%')
				sidx++;

			}
		else {
			sprintf(result,"%s%c",result,c);
			if (c=='%' && tstr[sidx+1]=='%')
				sidx++;
			}
	// Return value
	return(result);
}

void textadjust(string str,int justify,int centmode,double x,double y,
 double rot,double size,double xnew,double ynew,double rotnew,double modenew)
/*
// Adjust a text position according to alignment
// Parameters :
//	string str			: Text string
//	int justify			: Text justify mode
//	int centmode			: Text centered process mode
//	double x, y			: Text coordinates
//	double rot			: Text rotation
//	double size			: Text size
//	double xnew,ynew		: Text new coordinates return
//	double rotnew			: Text new rotation
//	int modenew			: Text new mode
*/
{
	double xoff, yoff		/* Text offset */;
	double angsin, angcos		/* Current angle trig. values */;
	double len			/* Text length */;
	xoff=yoff=0.0;
	rotnew=rot;
	angsin=sin(rotnew);
	angcos=cos(rotnew);
	len=strlen(str)*size*CHRWTOH;
	modenew=0;
	switch (justify) {
		// Upper left
		case 0 :
		yoff=-size;
		break;
		// Upper center
		case 1 :
		if (centmode)
			modenew=0x20;
		else
			xoff=-0.5*len;
		yoff=-size;
		break;
		// Upper right
		case 2 :
		rotnew+=PI;
		break;
		// Center left
		case 4 :
		yoff=-0.5*size;
		break;
		// Center center
		case 5 :
		if (centmode)
			modenew=0x20;
		else
			xoff=-0.5*len;
		yoff=-0.5*size;
		break;
		// Center right
		case 6 :
		rotnew+=PI;
		yoff=0.5*size;
		break;
		// Lower left
		case 8 :
		break;
		// Lower center
		case 9 :
		if (centmode)
			modenew=0x20;
		else
			xoff=-0.5*len;
		break;
		// Lower right
		case 10 :
		rotnew+=PI;
		yoff=size;
		break;
		default :
		}
	xnew=x+angcos*xoff-angsin*yoff;
	ynew=y+angsin*xoff+angcos*yoff;
}

void incnamespace(int nametyp)
// Receive a namespace stack increment
{
	curnametypen++;
	curnametype[curnametypen]=nametyp;
}

void decnamespace()
// Receive a namespace stack decrement
{
	if (curnametypen>0)
		curnametypen--;
}

string convspaces(string cstr)
/*
// Convert all spaces in string to underscores
// Return value :
//	converted string
*/
{
	string result			/* Result string */;
	int sidx			/* Source string index */;
	int didx			/* Destination string index */;
	int pairs			/* Character pair count */;
	int len				/* Name length */;
	int backslash = 0		/* Backslash found flag */;
	char c				/* Character buffer */;
	int i				/* Loop control variable */;
	// Loop for all characters
	for (sidx=didx=0;(c=cstr[sidx])!='\0';sidx++)
		switch (c) {
			case ' ' :
			case '?' :
			case '*':
			case '\'':
			result[didx]='_';
			didx++;
			break;
			case '�':
			result[didx]='�';
			didx++;
			break;
			case '�':
			result[didx]='�';
			didx++;
			break;
			case '�':
			result[didx]='�';
			didx++;
			break;
			// Convert backslash escape character
			case '\\' :
			if (didx>0) {
				if (cstr[sidx+1]=='\\') {
					result[didx+1]=result[didx-1];
					result[didx-1]='\\';
					result[didx]='/';
					didx+=2;
					sidx++;
					backslash++;
					break;
					}
				}
			default :
			result[didx]=c;
			didx++;
			}
	result[didx]='\0';
	if (backslash*3==strlen(result)) {
		for (i=0;i<backslash;i++)
			result[i]=result[3*i+2];
		result[backslash]='\0';
		}
	else {
		backslash=0;
		}
	if (strlen(result)>MAXKEYLEN) {
		for (sidx=0;(c=result[sidx])!='\0';sidx++)
			if (c==':')
				break;
		if (c!='\0') {
			didx=sidx+1;
			for (sidx=0;(c=result[sidx])!='\0';sidx++)
				if (c=='/' || c=='\\')
					didx=sidx;
			result=strextract(result,didx+1,strlen(result));
			}
		}
	if (strcmp(DELPREFIX,strextract(result,0,strlen(DELPREFIX)-1))==0)
		result=strextract(result,strlen(DELPREFIX),strlen(result));
	if (strlen(result)>MAXKEYLEN)
		result[MAXKEYLEN]='\0';
	// Return value
	return(backslash ? "/"+result : result);
}

static void symrename(string oldname,string newname)
/*
// Rename a symbol keeping the attributes
// Returns : 1 if rename successful else zero
// Parameters :
//	string oldname		: Old symbol name
//	string newname		: New symbol name
*/
{
	index C_FIGURE fig		/* Figure list index */;
	index C_FIGURE nfig		/* New figure list index */;
	index C_FIGURE tfig		/* Tag figure list index */;
	index C_FIGURE ofig		/* Old symbol figure list index */;
	index C_NREF nref		/* Named reference index */;
	index C_ATTRIBUTE attr		/* Attribute index */;
	index C_REFTEXT rmod		/* Ref. text modifier index */;
	index C_MACRO macro		/* Macro index */;
	string macname			/* New macro name */;
	double ang			/* Symbol angle */;
	double x, y			/* Symbol coords. */;
	double tang			/* Text angle */;
	double btx, bty			/* Back transf. text coords. */;
	double asin, acos		/* Angle sin, cos values */;
	int mirr			/* Symbol mirror mode */;
	int tmirr			/* Text mirror mode */;
	string attrname			/* Attribute name */;
	string attrval			/* Attribute value */;
	int attidx	= 0		/* Attribute index */;
	int lastidx	= 0		/* Last attribute index */;
	STRINGS rl			/* Rule list */;
	int i				/* Loop control variable */;
	if (cap_nrefsearch(oldname,fig)!=0) {
		sprintf(msgl[msgn],ERRRENSYM,
		 ddbclassname(bae_planddbclass()),bae_planename(),
		 oldname,newname);
		msgn++;
		// Symbol rename failed
		return;
		}
	macname=fig.NREF.MACRO.NAME;
	// Store new part
	if (scm_storepart(newname,macname,fig.X,fig.Y,fig.ANGLE,fig.MIRROR)) {
		sprintf(msgl[msgn],ERRPLCSYM,
		 ddbclassname(bae_planddbclass()),bae_planename(),
		 newname,macname);
		msgn++;
		// Symbol rename failed
		return;
		}
	// Copy the attributes
	nref=fig.NREF;
	forall (attr of nref) {
		attrname=attr.NAME;
		if (scm_chkattrname(attrname)!=0)
			continue;
		if (attrname=="$rpname" || attrname=="$rbname" ||
		 attrname=="$vgrp") {
			inirpname="";
			if (cap_scanfelem(fig,0.0,0.0,0.0,1,
			 rpmacfunc,NULL,NULL,rptextfunc)!=0)
				error_scan();
			}
		lastidx++;
		}
	forall (attr of nref) {
		attrname=attr.NAME;
		if (scm_chkattrname(attrname)!=0)
			continue;
		attrval= ((attrname=="$rpname" || attrname=="$rbname" ||
		 attrname=="$vgrp") && inirpname=="$") ? newname : attr.VALUE;
		attidx++;
		if (scm_setpartattrib(newname,attrname,attrval,
		 4|(attidx==1 ? 1 : 0)|(attidx==lastidx ? 2 : 0))) {
			sprintf(msgl[msgn],ERRSETATTR,
			 ddbclassname(bae_planddbclass()),bae_planename(),
			 newname,attrname,attrval);
			msgn++;
			}
		}
	// Transfer rules
	if (fig.RULEOBJID>=0 && cap_nrefsearch("",nfig)==0)
		// Get rules
		if (rsc_getfigrules(fig,rl)>0)
			// Attach rules
			if (cap_rulefigatt(nfig,rl))
				rsc_error(-1);
	// Get symbol data
	x=fig.X; y=fig.Y;
	ang=fig.ANGLE;
	mirr=fig.MIRROR;
	macro=nref.MACRO;
	// Transfer name moves
	forall (rmod of nref)
		if (cap_nrefsearch("",nfig)==0) {
			// Transform rel. to abs. position
			asin=sin(mirr ? -ang : ang);
			acos=cos(mirr ? -ang : ang);
			btx=acos*(rmod.X-macro.MNX)-asin*(rmod.Y-macro.MNY);
			bty=asin*(rmod.X-macro.MNX)+acos*(rmod.Y-macro.MNY);
			bty= mirr ? (-bty) : bty ;
			tmirr=(rmod.MIRROR!=0)!=(mirr!=0) ? 1 : 0 ;
			tang=rmod.ANGLE;
			tang+=tmirr ? -ang : ang ;
			// Store the text position
			scm_attachtextpos(nfig,rmod.STR,
			 x+btx,y+bty,tang,rmod.SIZE,tmirr);
			}
	// Delete old part
	if (scm_delelem(fig)) {
		sprintf(msgl[msgn],ERRRENSYM,
		 ddbclassname(bae_planddbclass()),bae_planename(),
		 oldname,newname);
		msgn++;
		}
	// Cleanup part list entry
	ddbdelelem(bae_planfname(),-DDBCLSPLST,oldname);
}

static int rpmacfunc(index C_MACRO macro,index C_POOL pool,int macinws,
 string refname,index C_LEVEL level,index C_LEVEL buslevel)
/*
// $rpname attribute scan 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 macro
	if (macro.CLASS==DDBCLSSYM)
		// Continue symbol macro scan
		return(1);
	// Abort scan for pins
	return(0);
}

static int rptextfunc(index C_TEXT textp,double tx,double ty,double tangle,
 int mirrflag,double tsize,string tstr,int textinws,int macclass,int varattr)
/*
// $rpname attribute scan text function
// 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=="$rpname" || textp.STR=="$rbname" || textp.STR=="$vgrp")
		// Query the current active default value
		if (cap_rulequery(RS_OCPOOL,textp,RS_SCMSUBJ,RS_INIVAL,
		 "?s",inirpname)<1)
			inirpname="";
	// Return without errors
	return(0);
}

string creatextid()
/*
// Generate new text ID
// Return value :
//	Text ID
*/
{
	string textid			/* Text id */;
	int year,month,day		/* Date */;
	int hour,min,sec		/* Time */;
	// Get date and time
	get_date(day,month,year);
	get_time(hour,min,sec);
	// Build the text ID
	sprintf(textid,"%04d%02d%02d%02d%02d%02d",
	 year+1900,month+1,day,hour,min,sec);
	// Return the text ID
	return(textid);
}

// User Language program end