/* DEF2CSV (SCM) -- Create Symbol Selection Database from .def Files  */
/* DEF2CSV (SCM) -- Aus logischen Definitionen Symboldatenbank erzeugen */
/*
// Copyright (c) 2005-2012 Oliver Bartels F+E, Muenchen
// Author: Roman Ludwig
// Changes History:
//	rl (120427) RELEASED FOR BAE V7.8.
//	rl (101019) RELEASED FOR BAE V7.6.
//	rl (091020) RELEASED FOR BAE V7.4.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (080625) ENHANCEMENT:
//		Added $gp gate mapping options.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (060613) ENHANCEMENT:
//		Added optional alternate part list split option.
//	rl (051015) ORIGINAL CODING.
//
// DESCRIPTION
//
// The def2csv User Language program scans the logical definition files
// in a selectable folder and creates .csv and .map files suitable to create
// a symbol selection database with the symattdb and symmapdb User Language
// programs. The library name for a symbol is derived from the definition
// file name, so def2csv is only suitable for definition files with the same
// base name as the symbol library for the therein defined symbols.
*/

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

// Enforce SCM caller type
#pragma ULCALLERSCM

// Disable undo state request
#pragma ULCALLERNOUNDO

// Messages
string UPRABORT		= M_UPRABORT();
string UPRPEXIT		= M_UPRPEXIT();
string REPDONE		= M("Es wurden keine Fehler festgestellt.",
			    "Operation completed without errors.");
string REPHEADSKIP	= M("Ungueltige ignorierte Eintraege:",
			    "Invalid Entries ignored:");
string REPREADINP	= M("Lesen Eingabe-Datei (%s/%s)...",
			    "Reading Input file (%s/%s)...");
string WRNNOLIBSYM	= M("Symbol zu Definition '%s' nicht in Bibliothek '%s'!",
			    "Symbol for Definition '%s' not in library '%s'!");
string UPRSDIR		= M("Definitionsverzeichnis ? ",
			    "Definition File Directory ? ");
string UPRSELMODE	= M("Gatterbearbeitungsmodus selektieren!",
			    "Select Gate Process Mode!");
string UPRMODE1		= M("&Kein $gp","&No $gp");
string UPRMODE2		= M("$gp fuer &Einzelpingatter",
			    "$gp for &single pin gates");
string UPRMODE3		= M("$gp fuer alle &Gatter","$gp for all &gates");
string UPRMODE4		= M("$gp wenn &Attributtext","$gp if &attribute text");

// INI file parameter name definitions
#define PAR_SYMMAPPATH	"SYMMAPPATH_SCM"// Symbol mapping default directory
#define PAR_SMAPEXT	"SYMMAPEXT_SCM"	// Symbol mapping file ext.
#define PAR_MAPLIB	"MAPLIB_SCM"	// Mapping library name
#define PAR_SSELEXT	"SSELEXT_SCM"	// Input file extension
#define PAR_CSVSYMTAB	"CSVSYMTAB_SCM"	// Symbol table column list
#define PAR_CSVSPLITPL	"CSVSPLITPL_SCM"// $plname split mode
#define PAR_CSVMAINP	"CSVMAINP_SCM"	// mainpart output mode
#define PAR_SYMIDBASE	"SYMIDBASE_SCM"	// Symbol ID base

// Database structure definitions
string DEFSTARTDIR	= bae_inistrval(PAR_SYMMAPPATH,"")
					/* Default mapping root path */;
string MAPEXT		= bae_inistrval(PAR_SMAPEXT,".map")
					/* Mapping output file name ext. */;
string MAPLIB		= bae_inistrval(PAR_MAPLIB,"mehrfach")
					/* Mapping library name */;
string CSVEXT		= bae_inistrval(PAR_SSELEXT,".csv")
					/* Definition output file name ext. */;
int SPLITPL		= bae_iniintval(PAR_CSVSPLITPL,0)
					/* $plname split mode */;
int MAINONLY		= bae_iniintval(PAR_CSVMAINP,0)
					/* mainpart output only */;
int SYMID		= bae_iniintval(PAR_SYMIDBASE,1)
					/* Symbol ID base */;
struct tabdesc {			// Symbol table column descriptor
	string name			/* Column name */;
	string src			/* Primary data source */;
	string src2			/* Secondary data source */;
	};
struct tabdesc deftabl[]	= {	// Default table column list
	{ M("Symbol","Symbol"), "SYMBOL", "" },
	{ M("Kommentar","Comment"),M("$commentge","$comment"),M("$comment","")},
	{ M("Gehaeuse","Package"), "FOOTPRINT", "" },
	{ M("Hersteller","Manufacturer"), "$manufacturer", "" },
	{ M("Bibliothek","Library"), "LIBRARY", "" }
	};
struct tabdesc tabl[]			/* Table column list */;
int tabn				/* Table column list element count */;

int procmode				/* Process mode */;
string deffname				/* Definition file name string */;
string libfname				/* Library file name string */;
string libname				/* Library name string */;
int mainflag				/* Main part flag */;
int subflag				/* Sub part flag */;
string attrnl[]				/* Part attribute name list */;
string attrvl[]				/* Part attribute value list */;
int attrn				/* Part attribute count */;
string curcomment			/* Current comment */;
string curpcomment			/* Current part comment */;
string curpname				/* Current part name */;
string curplname			/* Current physical library name */;
string curstr				/* Current string */;
string curname				/* Current name */;
string curpiece				/* Current name piece */;
string currngstart			/* Current name range start */;
string currngend			/* Current name range end */;
int currngstep				/* Current name range step */;
int curpinstate	= (-1)			/* Current pin process status */;
string gpl[]				/* $gp gate pin name list */;
int gatecnt				/* Current gate count */;
int pincnt				/* Current pin count */;
int pinidx				/* Current pin index */;
int xlatidx				/* Current xlat index */;
int gpfound				/* $gp text found flag */;
int mfh					/* Mapping file handle */;
int cfh					/* Selection data file handle */;
STRINGS hl				/* Report list */;
int hn		= 0			/* Report count */;
STRINGS msgl				/* Message list */;
int msgn	= 0			/* Message count */;

// Main program
void main()
{
	string fname			/* File name */;
	string startdir			/* Start directory */;
	int len				/* String length */;
	// Get the attribute list
	for (tabn=0;tabn<1000;tabn++) {
		if ((tabl[tabn].name=bae_inistrval(
		 bae_inifieldvarname(PAR_CSVSYMTAB,tabn,0),""))=="") {
			// Check if list defined at all
			if (tabn==0) {
				// Use default attribute list
				tabl=deftabl;
				tabn=arylength(tabl);
				}
			break;
			}
		tabl[tabn].src=
		 bae_inistrval(bae_inifieldvarname(PAR_CSVSYMTAB,tabn,1),"");
		tabl[tabn].src2=
		 bae_inistrval(bae_inifieldvarname(PAR_CSVSYMTAB,tabn,2),"");
		}
	// Select source directory
	if (DEFSTARTDIR!="") {
		startdir=DEFSTARTDIR;
		}
	else {
		// Select source directory
		startdir=UINPOPABORT;
		if (bae_askdirname(startdir,getcwd(),UPRSDIR)!=0 ||
		 startdir==UINPOPABORT)
			error_abort();
		}
	len=strlen(startdir)-1;
	if (startdir[len]=='/' || startdir[len]=='\\')
		startdir[len]='\0';
	// Select process mode
	bae_promptdialog(UPRSELMODE);
	if ((procmode=bae_askmenu(5,UPRMODE1,UPRMODE2,
	 UPRMODE3,UPRMODE4,UPRABORT))<0 || procmode>3)
		error_abort();
	// Scan the directory
	fname="";
	while (scandirfnames(startdir,".def",fname)==1)
		procfile(startdir+bae_swversion(4)+fname);
	// Test if any errors occurred
	if (msgn) {
		// Error(s) occurred
		hl[hn++]=REPHEADSKIP;
		hl[hn++]="";
		// Display messages with popup menu
		bae_setintpar(16,3070);
		popupmenu(0,"",hl,hn,msgl,msgn,
		 UINPOPABORT,0,-1,-1,hn+msgn+2,100,0,"");
		// Abort
		return;
		}
	bae_prtdialog(REPDONE);
}

void procfile(string fname)
/*
// Scan file for mapping definitions
// Parameter :
//	string fname		: Scan file name
*/
{
	int i				/* Loop control variable */;
	deffname=fname;
	libname=convstring(fname,2);
	libfname=convstring(fname,0)+DDBEXT;
	// Create mapping file
	mfh=bae_fopen(convstring(fname,0)+MAPEXT,1);
	// Create selection data file
	cfh=bae_fopen(convstring(fname,0)+CSVEXT,1);
	for (i=0;i<tabn;i++) {
		fprintf(cfh,"%s%s",tabl[i].name,i==(tabn-1) ? "\n" : ";");
		if (tabl[i].src=="ID" && tabl[i].src2=="")
			tabl[i].src2="ID%05d";
		}
	// Parse the loglib file
	synscaneoln(0);
	synsetintpar(1,1);
	synparsefile(fname,p_comment);
	// Close the files
	fclose(mfh);
	fclose(cfh);
}



// Logical library file syntax

#bnf {	// Loglib file
	loglib	: "loglib" libdefs "end" "."
		;
	libdefs	: libdefs libdef
		|
		;
	libdef	: "delete" "part" ident ";"
		| "part" ident (p_pname) ":"
		  optclassspec partdef (p_partstore)
		;
	// Part functions syntax
	optclassspec
		: "class" ident
		|
		;
	partdef	: mainflag defflag plnames partblk
		| "subpart" (p_subpart) ident (p_plname) partblk
		| "virtual" virtblk
		| "logical" virtblk
		;
	mainflag
		: "mainpart" (p_mainflag)
		|
		;
	defflag	: "default"
		|
		;
	plnames : plnames "," ident (p_plname)
		| ident (p_plname)
		;
	partblk	: "{" partcmds "}"
		| ";"
		;
	partcmds
		: partcmds partcmd
		| partcmd
		;
	partcmd	: "bus" pinlist ";"
		| "net" netcmd ":" pinlist ";"
		| "pin" pinlist ";"
		| "swap" swapcmd swapblk ";"
		| "xlat" (p_xlat) pinlist "to" (p_clearpin(0))
		 xlats ";" (p_endxlat)
		| "xlat" (p_xlat) "(" xlatpinass ")" ";" (p_endxlat)
		| "netattr" "priority" DQSTR ":" pinlist ";"
		| "netattr" "mindist" DQSTR ":" pinlist ";"
		| "netattr" "powwidth" DQSTR ":" pinlist ";"
		| "netattr" "routwidth" DQSTR ":" pinlist ";"
		| "netattr" idstr DQSTR ":" pinlist ";"
		| "newattr" DQSTR (p_attrname) "=" DQSTR (p_attrval)
		 topinlist ";"
		| "comment" "=" DQSTR ";"
		;
	virtblk	: "{" virtcmds "}"
		| ";"
		;
	virtcmds
		: virtcmds virtcmd
		| virtcmd
		;
	virtcmd	: "bus" pinlist ";"
		| "net" netcmd ":" pinlist ";"
		| "pin" pinlist ";"
		| "netattr" "priority" DQSTR ":" pinlist ";"
		| "netattr" "mindist" DQSTR ":" pinlist ";"
		| "netattr" "powwidth" DQSTR ":" pinlist ";"
		| "netattr" "routwidth" DQSTR ":" pinlist ";"
		| "netattr" idstr DQSTR ":" pinlist ";"
		| "newattr" DQSTR (p_attrname) "=" DQSTR (p_attrval)
		 topinlist ";"
		| "call" ident ";"
		| "architecture" "{" synthprog "}"
		| "comment" "=" DQSTR ";"
		;
	topinlist
		: "to" pinlist (p_pinattr)
		|
		;
	netcmd	: ident
		| "internal"
		;
	swapcmd	: "internal"
		|
		;
	swapblk	: "(" groups ")"
		| "(" gates ")"
		;
	groups	: groups "," "[" gates "]"
		| "[" gates "]"
		;
	gates	: gates "," gate
		| gate
		;
	gate	: "(" gateblk ")"
		| pin
		;
	gateblk	: gateblk "," gatepin
		| gatepin
		;
	gatepin	: pinlist
		| pin
		;
	xlats	: xlats "or" pinlist (p_endpin)
		| pinlist (p_endpin)
		;
	xlatpinass : xlatpinass "," xlpindef
		| xlpindef
		;
	xlpindef : "(" pin "," (p_clearpin(1)) xlpins ")" (p_endpin)
		;
	xlpins	: xlpins "," pin
		| pin
		;
	synthprog
		: synthprog sprogcmd
		| sprogcmd
		;
	sprogcmd
		: "part" ident "(" preqpinlist ")" ";"
		;
	preqpinlist
		: preqpinlist "," preqpinass
		| preqpinass
		;
	preqpinass
		: pin ":" preqdest
		;
	preqdest
		: pin
		| "net" ident
		| "net" "&" ident
		| "&" ident
		;
	pinlist	: "(" pins ")"
		;
	pins	: pins "," pin
		| pin
		;
	pin	: identpt (p_pin)
		| identpt (p_rangestart) "-" identpt(p_rangeend)
		 optstep (p_pinrangeend)
		;
	optstep	: ":" NUMBER (p_rangestep)
		|
		;
	// Identifier expression
	ident	: IDENT (p_ident)
		| NUMBER (p_ident)
		| SQSTR (p_ident)
		| DQSTR (p_ident)
		;
	identpt	: identpt idpiece (p_namepcnext)
		| idpiece (p_namepcfirst)
		| identptslash (p_namepcfirst) idpiece (p_namepcnext)
		;
	identptslash : '/' (p_namepcslash)
		;
	idpiece	: IDENT (p_namepiece)
		| NUMBER (p_namepiece)
		| SQSTR (p_namepiece)
		| DQSTR (p_namepiece)
		| '.' (p_namepcpoint)
		;
	idstr : IDENT
		| DQSTR
		;
}	// BNF end

// Parser action routines

int p_partstore()
/*
// Handle the part store request
// Return value :
//	zero if done, or nonzero on error
*/
{
	string slibname			/* Symbol library name */;
	string altprefix		/* Alternate part name prefix */;
	string altphext			/* Alternate part name extension */;
	int dstidx1			/* Destination string 1st index */;
	int dstidx2			/* Destination string 2nd index */;
	int dstid			/* Destination string ID */;
	char c				/* Scan character */;
	int i				/* Loop control variable */;
	// Store the part
	strlower(curpname);
	if (existddbelem(libfname,DDBCLSSYM,curpname)!=1) {
		// Ignore definition without symbol
		sprintf(msgl[msgn],WRNNOLIBSYM,curpname,libfname);
		msgn++;
		}
	if (gatecnt==0)
		gatecnt=1;
	strlower(curplname);
	if (curplname[0]=='[')
		curplname+="]";
	if (subflag) {
		if (!MAINONLY) {
			if (gatecnt>1 &&
			 (procmode==2 || (procmode==1 && pincnt==1) ||
			 (procmode==3 && symgpchk(libfname,curpname)))) {
				for (i=0;i<gatecnt;i++)
					fprintf(mfh,"%s;%s;%d;%s;;$gp %s\n",
					 curplname,curpname,1,libname,gpl[i]);
				}
			else {
				fprintf(mfh,"%s;%s;%d;%s\n",
				 curplname,curpname,gatecnt,libname);
				}
			}
		}
	else {
		if (gatecnt>1 || mainflag) {
			if (procmode==2 || (procmode==1 && pincnt==1) ||
			 (procmode==3 && symgpchk(libfname,curpname))) {
				for (i=0;i<gatecnt;i++)
					fprintf(mfh,"%s;%s;%d;%s;;$gp %s\n",
					 curpname,curpname,1,libname,gpl[i]);
				}
			else {
				fprintf(mfh,"%s;%s;%d;%s\n",
				 curpname,curpname,gatecnt,libname);
				}
			slibname= MAINONLY ? libname : MAPLIB;
			}
		else {
			slibname=libname;
			}
		if (SPLITPL && curplname[0]=='[') {
			// Scan alternate physical part name list
			for (i=1,dstidx1=0,dstidx2=0,dstid=0;
			 (c=curplname[i])!='\0';i++)
			    switch (c) {
				case ']' :
				case ',' :
				// Check name scan state
				if (dstid==0) {
					if (dstidx1!=0) {
						// Store pure prefix name
						altprefix[dstidx1]='\0';
						dstidx1=0;
						// Store the new alternate name
						outentry(
						 slibname,altprefix,1);
						}
					}
				else {
					/* Build name combination */
					altphext[dstidx2]='\0';
					dstidx2=0;
					/* Store the new alternate name */
					outentry(
					 slibname,altprefix+altphext,1);
					if (c==']') {
						dstid=0;
						dstidx1=0;
						}
					}
				break;
				case '[' :
				if (dstid==0) {
					altprefix[dstidx1]='\0';
					dstid=1;
					dstidx2=0;
					break;
					}
				default :
				if (dstid==0) {
					if (dstidx1<MAXKEYLEN)
						altprefix[dstidx1++]=c;
					}
				else {
					if (dstidx2<MAXKEYLEN)
						altphext[dstidx2++]=c;
					}
				}
			}
		else {
			outentry(slibname,curplname,0);
		    }
		}
	curpcomment="";
	attrn=0;
	curpinstate=(-1);
	// Return without errors
	return(0);
}

int p_mainflag()
/*
// Receive a mainpart flag
// Return value :
//	zero if done, or nonzero on error
*/
{
	mainflag=1;
	// Return without errors
	return(0);
}

int p_subpart()
/*
// Receive a subpart definition
// Return value : zero if done, or nonzero on error
*/
{
	subflag=1;
	// Return without errors
	return(0);
}

int p_xlat()
/*
// Receive a pin list clear command
// Return value :
//	zero if done, or nonzero on error
*/
{
	gatecnt=0;
	pinidx=0;
	xlatidx=0;
	// Return without errors
	return(0);
}

int p_clearpin(int xlatalt)
/*
// Receive a pin list clear command
// Return value :
//	zero if done, or nonzero on error
*/
{
	if (!xlatalt)
		gatecnt=0;
	pinidx=0;
	curpinstate=xlatalt;
	// Return without errors
	return(0);
}

int p_endpin()
/*
// Receive a pin list end command
// Return value :
//	zero if done, or nonzero on error
*/
{
	if (curpinstate!=0) {
		curpinstate=(-1);
		}
	else if (xlatidx==0) {
		pincnt=pinidx;
		}
	pinidx=0;
	xlatidx++;
	// Return without errors
	return(0);
}

int p_endxlat()
/*
// Receive a xlat end command
// Return value :
//	zero if done, or nonzero on error
*/
{
	if (curpinstate==1)
		pincnt=xlatidx;
	curpinstate=(-1);
	pinidx=0;
	xlatidx=0;
	// Return without errors
	return(0);
}

int p_pin()
/*
// Receive a pin command
// Return value :
//	zero if done, or nonzero on error
*/
{
	switch (curpinstate) {
		case 0 :
		if (pinidx==0) {
			gpl[gatecnt]=curname;
			gatecnt++;
			}
		break;
		case 1 :
		if (xlatidx==0) {
			gpl[gatecnt]=curname;
			gatecnt++;
			}
		break;
		}
	pinidx++;
	// Return without errors
	return(0);
}

int p_comment(string comment)
/*
// Receive a comment
// Return value :
//	zero if done, or nonzero on error
// Parameter :
//	string comment		: Comment string
*/
{
	int sidx, eidx			/* Comment text range */;
	for (sidx=0;comment[sidx]!='\0';sidx++)
		if (comment[sidx]!=' ' && comment[sidx]!='\t')
			break;
	for (eidx=strlen(comment)-1;eidx>=sidx;eidx--)
		if (comment[eidx]!=' ' && comment[eidx]!='\t')
			break;
	curcomment=curpcomment=strextract(comment,sidx,eidx);
	// Return without errors
	return(0);
}

int p_attrname()
/*
// Receive an attribute name
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Store the current attribute name
	attrnl[attrn]=synscanstring();
	// Return without errors
	return(0);
}

int p_attrval()
/*
// Receive an attribute value
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Store the current attribute value
	attrvl[attrn]=synscanstring();
	attrn++;
	// Return without errors
	return(0);
}

int p_pinattr()
/*
// Receive a pin attribute list end
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Dismiss pin attributes
	attrn--;
	// Return without errors
	return(0);
}

int p_pname()
/*
// Receive a part name
// Return value :
//	zero if done, or nonzero on error
*/
{
	string msg			/* Message buffer */;
	// Store the part name
	curpname=curstr;
	gatecnt=0;
	mainflag=subflag=0;
	curplname="";
	sprintf(msg,REPREADINP,deffname,curpname);
	bae_prtdialog(msg);
	curpinstate=(-1);
	// Return without errors
	return(0);
}

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

int p_namepiece()
/*
// Receive a name piece
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Abort program on request
	if (kbhit()) {
		getchr();
		if (verify(UPRPEXIT,0))
			error_abort();
		}
	// Store the current scan string
	curpiece=synscanstring();
	// Return without errors
	return(0);
}

int p_namepcpoint()
/*
// Receive a dot name piece
// Return value :
//	zero if done, or nonzero on error
*/
{
	curpiece=".";
	// Return without errors
	return(0);
}

int p_namepcslash()
/*
// Receive a slash name piece
// Return value :
//	zero if done, or nonzero on error
*/
{
	curpiece="/";
	// Return without errors
	return(0);
}

int p_namepcfirst()
/*
// Receive a first name piece
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Abort program on request
	if (kbhit()) {
		getchr();
		if (verify(UPRPEXIT,0))
			error_abort();
		}
	curname=curpiece;
	// Return without errors
	return(0);
}

int p_namepcnext()
/*
// Receive next name piece
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Abort program on request
	if (kbhit()) {
		getchr();
		if (verify(UPRPEXIT,0))
			error_abort();
		}
	curname=curname+curpiece;
	// Return without errors
	return(0);
}

int p_rangestart()
/*
// Receive a name range start
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Store the current scan string
	currngstart=synscanstring();
	currngstep=1;
	// Return without errors
	return(0);
}

int p_rangeend()
/*
// Receive a name range end
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Store the current scan string
	currngend=synscanstring();
	// Return without errors
	return(0);
}

int p_rangestep()
/*
// Receive a name range step
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Store the current scan string
	currngstep=atoi(synscanstring());
	// Return without errors
	return(0);
}

int p_pinrangeend()
/*
// Receive a name range definition end
// Return value :
//	zero if done, or nonzero on error
*/
{
	// Return without errors
	return(0);
}

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

void outentry(string slibname,string plname,int plattr)
/*
// Handle the part store request
// Parameters :
//	string slibname		: Symbol library name
//	string plname		: Physical library name
//	int plattr		: Physical library name attribut ext. flag
*/
{
	string entry			/* Table entry */;
	string src			/* Table entry source */;
	int i, j			/* Loop control variables */;
	for (i=0;i<tabn;i++) {
		switch (src=tabl[i].src) {
			case "SYMBOL" :
			entry=curpname;
			break;
			case "FOOTPRINT" :
			entry=plname;
			break;
			case "LIBRARY" :
			entry=slibname;
			break;
			case "COMMENT" :
			entry=curcomment;
			break;
			case "PCOMMENT" :
			entry=curpcomment;
			break;
			case "ID" :
			sprintf(entry,tabl[i].src2,SYMID);
			break;
			default :
			if (src[0]!='$') {
				entry=src;
				break;
				}
			entry="";
			for (j=0;j<attrn;j++)
				if (src==attrnl[j]) {
					entry=attrvl[j];
					break;
					}
			if (plattr) {
				src+=":"+plname;
				for (j=0;j<attrn;j++)
					if (src==attrnl[j]) {
						entry=attrvl[j];
						break;
						}
				}
			if (entry=="" && (src=tabl[i].src2)!="") {
				if (src[0]!='$') {
					entry=src;
					break;
					}
				for (j=0;j<attrn;j++)
					if (src==attrnl[j]) {
						entry=attrvl[j];
						break;
						}
				if (plattr) {
					src+=":"+plname;
					for (j=0;j<attrn;j++)
						if (src==attrnl[j]) {
							entry=attrvl[j];
							break;
							}
					}
				}
			}
		fprintf(cfh,"%s%s",entry,i==(tabn-1) ? "\n" : ";");
		}
	SYMID++;
}

int symgpchk(string libfname,string symname)
/*
// Display a library symbol in a popup window
// Return value :
//	1 if $gp text found else 0
// Parameters :
//	string libfname		: Library file name
//	string symname		: Symbol name
*/
{
	index C_POOL pool		/* Pool element index */;
	// Load the symbol macro
	if (cap_macload(pool,libfname,symname,DDBCLSSYM))
		return(0);
	// Scan for $gp text
	gpfound=0;
	cap_scanpool(pool,0.0,0.0,0.0,1,macfunc,NULL,NULL,textfunc);
	// Release macro
	cap_macrelease(pool);
	return(gpfound);
}

int macfunc(index C_MACRO macro,index C_POOL pool,int macinws,
 string refname,index C_LEVEL level,index C_LEVEL buslevel)
/*
// $gp 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);
}

int textfunc(index C_TEXT textp,double tx,double ty,double tangle,
 int mirrflag,double tsize,string tstr,int textinws,int macclass,int varattr)
/*
// Vectorize a text data block
// Return value :
//	zero if done or (-1) on error
//	index C_TEXT textp	: Text index
//	double tx		: Text X coordinate
//	double ty		: Text Y coordinate
//	double tangle		: Text rotation 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
*/
{
	// Check if $gp text
	if (tstr=="$gp")
		gpfound=1;
	// Return without errors
	return(0);
}

// User Language program end