/* LISTDDB (STD) -- List DDB File Elements */
/* LISTDDB (STD) -- DDB-Datei-Elemente auflisten */
/*
// Copyright (c) 1993-2012 Oliver Bartels F+E, Muenchen
// Author: Manfred Baumeister
// Changes History:
//	rl (120427) RELEASED FOR BAE V7.8.
//	rl (101019) RELEASED FOR BAE V7.6.
//	rl (091021) RELEASED FOR BAE V7.4.
//	rl (091016) ENHANCEMENT:
//		Added packager parameter display to output.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (070625) ENHANCEMENT:
//		Added SQL table name output.
//	rl (070110) ENHANCEMENT:
//		Added element reference list output options.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (060330) ENHANCEMENT:
//		Added automatic file output option.
//	rl (050906) RELEASED FOR BAE V6.6.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (020620) RELEASED FOR BAE V5.4.
//	rl (010625) RELEASED FOR BAE V5.0.
//	rl (010503) ENHANCEMENT:
//		Added optional parameter settings from bae.ini file.
//	rl (000509) RELEASED FOR BAE V4.6.
//	rl (990625) RELEASED FOR BAE V4.4.
//	mb (981008) RELEASED FOR BAE V4.2.
//	mb (981008) ENHANCEMENT:
//		Included DDB class code display to DDB class headers.
//	rl (980901) ENHANCEMENT:
//		Introduced class DDBCLLDRC.
//	rl (980821) ENHANCEMENT:
//		Introduced class DDBCLCCHG.
//	mb (980710) ENHANCEMENT:
//		Dynamic multi-language support introduced.
//	rl (970929) RELEASED FOR BAE V4.0.
//	mb (970603) ENHANCEMENT:
//		Introduced DDB elements reference listings.
//	mb (960919) RELEASED FOR BAE V3.4.
//	mb (960731) ENHANCEMENT:
//		Introduced DDB class 402 (Parameter Setup Data).
//	mb (960722) CHANGE:
//		Introduced Compiler directive for DDB class header
//		output on request only.
//	mb (960318) ENHACNEMENT:
//		Introduced DDB classes 1201 (User Language Library)
//		and 1400 (Design Rule)
//	mb (951012) IMPROVEMENT:
//		Performing BAE_Demo_check(2) before starting output.
//	mb (951012) CHANGE:
//		Skipped fileout() option/function (which was obsolete
//		due to (Dump) option in popup menu display).
//	mb (950915) CHANGE:
//		Introduced Compiler directive for type-sorted
//		DDB class output.
//	mb (950915) IMPROVEMENT:
//		screenout() function changed in order to support popup
//		menu listing (select mode 0) with (Back)/(Dump) buttons.
//		Key hit abort feature integrated to screenout().
//	mb (95) RELEASED FOR BAE V3.2.
//	mb (94) RELEASED FOR BAE V3.0.
//	mb (93) RELEASED FOR BAE V2.6.
//	mb (93) ORIGINAL CODING:
//		Retrieved from DDBCONT.
//
// DESCRIPTION
//
// The listddb User Language program produces a list of the
// database elements of a selectable DDB and displays this
// list in a popup menu with file output option.
*/

// Includes
#include "mnu.ulh"			// User Language menu utilities
#include "sql.ulh"			// User Language SQL utilities

// Disable undo state request
#pragma ULCALLERNOUNDO

// INI file parameter name definitions
#define PAR_SORTCLASSES	"SORTCLASSES_STD"	// Activate DDB class sort
#define PAR_HEADOUTORO	"HEADOUTORO_STD"	// Class header on request only
#define PAR_LSTEXT	"LISTDDBEXT_STD"	// Listing file name extension

// Messages
string UPRABORT		= M_UPRABORT();
string UPRFEXIT		= M_UPRFEXIT();
string UPRDDBFILE	= M("DDB-Datei Name ? ","DDB File Name ? ");
string UPRLSTMODE	= M("Listingmodus auswaehlen!",
			    "Select Element List Mode!");
string UPRLSTELEM	= M("&Standard","&Standard");
string UPRLSTEREF	= M("%&Referenzen auf Element",
			    "%&References to Element");
string UPRLSTAREF	= M("Referenzen&uebersicht","Reference &Overview");
#define UPRCLSSYM	"&Symbol"
#define UPRCLSLAB	"&Label"
#define UPRCLSMRK	"&Marker"
string UPRCLLPRT	= M("&Bauteil","&Part");
#define UPRCLLSTK	"Pad&stack"
#define UPRCLLPAD	"Pa&d"
string UPRCLICELL	= M("Chip Standard-&Zelle","Chip Standard &Cell");
#define UPRCLIPIN	"Chip &Pin"
string UPRSELCLASS	= M("Elementklasse selektieren!",
			    "Select Element Class!");
string REPLSTINC	= M("-- Auflistung abgebrochen/unvollstaendig! --",
			    "-- Listing aborted/incomplete! --");
string REPLSTFILE	= M("Listing ausgegeben nach '%s'.",
			    "Listing output to '%s'.");
string FMTLSTHD		= M("Inhalt Datenbank %s :",
			    "Contents Database %s :");
string FMTCLHD		= M("Datenbank Klasse %d : %s :",
			    "Database Class %d : %s :");
string FMTPLIBENTRY	= M("  :- Packagerbibliothek      : %s",
			    "  :- Packager Library       : %s");
string FMTPCONENTRY	= M("  :- Packager Layoutnetzliste: %s",
			    "  :- Packager Layout Netlist: %s");
string FMTSQLHD		= M("SQL Datenbank Tabellen :",
			    "SQL Database Tables :");
string FMTELSTHD	= M("Referenzen in Datenbank %s :",
			    "Database References %s :");
string FMTELHD		= M("%s %s verwendet in:","%s %s used by:");
string ERRDDBACC	= M("Zugriff auf DDB-Datei '%s' fehlgeschlagen!",
			    "Error accessing DDB file '%s'!");
#define FMTENTRY	"> %s (%02d.%02d.%04d / %02d:%02d:%02d) %d Bytes"
string FMTSQLENTRY	= M("> %s (%d Tabelleneintraege)",
			    "> %s (%d Table entries)");
#define FMTSQLFIELD	"  :- %s %s"
#define FMTREFENTRY	"  :- %-10s : '%s'"
#define FMTEREFENTRY	"  %s %s"
#define FMTCLEND	"---"

// DDB class descriptors
static int sclasses[]	= {		// Sorted DDB class code list
	DDBCLSCM   ,DDBCLSSYM  ,	// SCM elements data
	DDBCLSMRK  ,DDBCLSLAB  ,
	DDBCLSPLST ,DDBCLLCON  ,	// SCM netlist data
	DDBCLLLIB  ,DDBCLPCON  ,
	DDBCLCPRT  ,DDBCLPPINF ,	// Loglib/netlist data
	DDBCLPPAR  ,			// Packager parameter data
	DDBCLBASS  ,			// Backannotation data
	DDBCLCCHG  ,			// Backannotation request
	DDBCLLAY   ,DDBCLLPRT  ,	// PCB elements data
	DDBCLLSTK  ,DDBCLLPAD  ,
	DDBCLLPATH ,DDBCLLECN  ,	// PCB connection list data
	DDBCLLAR   ,DDBCLAPAR  ,	// PCB autorouter data
	DDBCLASET  ,DDBCLABAT  ,
	DDBCLLDRC  ,			// PCB DRC parameter data
	DDBCLILAY  ,DDBCLICELL ,	// IC elements data
	DDBCLIPIN  ,
	DDBCLIPATH ,DDBCLIECN  ,	// IC connection list/rout data
	DDBCLIAR   ,
	DDBCLPARSET,			// Parameter data
	DDBCLFONT  ,DDBCLBSETUP,	// BAE system data
	DDBCLMSG   ,
	DDBCLSCOL  ,DDBCLLCOL  ,	// BAE color tables
	DDBCLICOL  ,
	DDBCLXWIN  ,DDBCLWIN   ,	// BAE window positions
	DDBCLGTAB  ,DDBCLGDS   ,	// CAM / GDS data
	DDBCLUL    ,DDBCLULLIB ,	// User Language
	DDBCLRULE  ,DDBCLRULL  ,	// BAE Design Rules
	DDBCLRULS  ,
	DDBCLSQLTS ,DDBCLSQLFT ,	// SQL
	DDBCLUNDEF			// Sentinel
	};
static int uclasses[]	= {		// Unsorted DDB class code list
	DDBCLLAY   ,DDBCLLPRT  ,DDBCLLSTK  ,DDBCLLPAD  ,
	DDBCLLPATH ,DDBCLLECN  ,DDBCLLDRC  ,DDBCLPCON  ,
	DDBCLBASS  ,DDBCLCCHG  ,DDBCLCPRT  ,DDBCLLAR   ,
	DDBCLAPAR  ,DDBCLASET  ,DDBCLABAT  ,DDBCLFONT  ,
	DDBCLBSETUP,DDBCLPARSET,DDBCLGTAB  ,DDBCLLCOL  ,
	DDBCLSCOL  ,DDBCLICOL  ,DDBCLXWIN  ,DDBCLWIN   ,
	DDBCLGDS   ,DDBCLMSG   ,DDBCLSCM   ,DDBCLSSYM  ,
	DDBCLSMRK  ,DDBCLSLAB  ,DDBCLSPLST ,DDBCLLLIB  ,
	DDBCLLCON  ,DDBCLPPINF ,DDBCLPPAR  ,DDBCLILAY  ,
	DDBCLICELL ,DDBCLIPIN  ,DDBCLIPATH ,DDBCLIECN  ,
	DDBCLIAR   ,DDBCLUL    ,DDBCLULLIB ,DDBCLRULE  ,
	DDBCLRULL  ,DDBCLRULS  ,DDBCLSQLTS ,DDBCLSQLFT ,
	DDBCLUNDEF			// Sentinel
	};
static int classes[]			/* Classes code list */;

// Globals
int SORTCLASSES = bae_iniintval(PAR_SORTCLASSES,1)
					/* Activate DDB class sort */;
int HEADOUTORO = bae_iniintval(PAR_HEADOUTORO,1)
					/* Class header on request only */;
string LSTEXT = bae_inistrval(PAR_LSTEXT,"")
					/* Listing file name extension */;
static string fname = bae_planfname()	/* DDB file name */;
static int headout			/* Header output flag */;
static int abort	= 0		/* Abort flag */;
static int curclass			/* Current class code */;
static int sqlten			/* Current SQL table entry count */;
static int sqlmaxidx			/* Cur. SQL max. table entry index */;
static int dispclass			/* Current display class code */;
static int scanelclass			/* Current scan element class code */;
static string scanelname		/* Current scan element name */;
static STRINGS entryl			/* Entry list */;
static int entryn			/* Entry count */;

// Main program
void main()
{
	int lstmode			/* Listing mode */;
	// Ask user for listing mode
	bae_promptdialog(UPRLSTMODE);
	if ((lstmode=bae_askmenu(4,
	 UPRLSTELEM,UPRLSTEREF,UPRLSTAREF,UPRABORT))<0 || lstmode>2)
		error_abort();
	// Perform list DDB output to screen
	switch (lstmode) {
		// Single element reference list
		case 1 :
		listelemref();
		break;
		// Summarized element reference list
		case 2 :
		listsumref();
		break;
		// Standard list
		case 0 :
		default :
		listddb();
		}
}

string selectddbfile(string prompt,int ddbclass)
/*
// Perform a DDB file selection via popup menu
// Return value :
//	name of selected DDB file or empty string on abort
// Parameters :
//	string prompt		: Prompt string
//	int ddbclass		: DDB class (-1 = any DDB file)
*/
{
	STRINGS extl	= {bae_swversion(3)}	/* Extension list */;
	string fname			/* File name buffer */;
	// Perform the file name selection
	fname=askfile(prompt,extl,ddbclass);
	// Append DDB file extension if no extension
	catextadv(fname,DDBEXT,0);
	// Return the file name
	return(fname);
}

void listddb()
/*
// Perform list DDB output to screen
*/
{
	STRINGS tabl			/* Table name list */;
	int tabn	= 0		/* Table count */;
	sql_fields fieldl		/* Table field name list */;
	string lstfname			/* Listing file name */;
	string cmd			/* SQL command buffer */;
	int fh				/* File handle */;
	int classoff			/* DDB Class offset */;
	int i, j			/* Loop control variables */;
	// Select the DDB file name
	if ((fname=selectddbfile(UPRDDBFILE,DDBCLUNDEF))=="")
		error_abort();
	// Abort on DDB file access failure
	if (ddbcheck(fname,DDBCLUNDEF,""))
		errormsg(ERRDDBACC,fname);
	// Select class list
	classes= SORTCLASSES ? sclasses : uclasses ;
	// Define the popup header
	sprintf(entryl[0],FMTLSTHD,fname);
	entryn=1;
	// Print scan message
	message(M_REPSCANDDB(),fname);
	// Loop thru all classes
	for (i=0;(curclass=classes[i])!=DDBCLUNDEF && !abort;i++) {
	    for (classoff=0;classoff<=DDBCLINFOS;classoff+=DDBCLINFOS) {
		curclass+=classoff;
		// Init the header output flag
		headout=!HEADOUTORO;
		// Report the class code
		if (headout)  {
			entryl[entryn]="";
			sprintf(entryl[entryn+1],
			 FMTCLHD,curclass,ddbclassname(curclass));
			entryn+=2;
			}
		// Scan the element names
		ddbclassscan(fname,curclass,scanfunc);
		// Store class delimiter
		if (headout && !abort)
			entryl[entryn++]=FMTCLEND;
		}
	    }
	// Store listing aborted message if abort flag set
	if (abort) {
		entryl[entryn++]=REPLSTINC;
		}
	else {
		// Get SQL table names
		if ((tabn=sql_gettabs(fname,tabl))>0) {
			entryl[entryn]="";
			entryl[entryn+1]=FMTSQLHD;
			entryn+=2;
			for (i=0;i<tabn;i++) {
				// Get table entry info
				sqlten=0;
				sprintf(cmd,"select from %s;",tabl[i]);
				sqlcmd(fname,cmd,entrycntfunc);
				sprintf(entryl[entryn],FMTSQLENTRY,
				 tabl[i],sqlten);
				entryn++;
				sqlmaxidx=sql_getfields(fname,tabl[i],fieldl);
				for (j=0;j<sqlmaxidx;j++) {
					sprintf(entryl[entryn],FMTSQLFIELD,
					 fieldl[j].fname,
					 sql_dtyp2str(fieldl[j].fdtyp));
					entryn++;
					}
				}
			}
		}
	if (LSTEXT=="") {
		// Show DDB listing with popup menu
		bae_setintpar(16,5023);
		mnu_poptext(entryl,0,0,-1,0,0);
		}
	else {
		// Get listing file name
		lstfname=convstring(fname,0)+LSTEXT;
		// Write listing file
		fh=fopen(lstfname,1);
		for (i=0;i<entryn;i++)
			fprintf(fh,"%s\n",entryl[i]);
		fclose(fh);
		message(REPLSTFILE,lstfname);
		}
}

void listelemref()
/*
// Perform single DDB element reference list output to screen
*/
{
	string elemname			/* Element name */;
	int ddbcl	= DDBCLUNDEF	/* Plan DDB class */;
	// Test the current UL interpeter type
	bae_promptdialog(UPRSELCLASS);
	switch (uliptype()) {
		// Schematic Editor
		case ULIPSCM :
		// Select the SCM plan DDB class
		switch (bae_askmenu(4,UPRCLSSYM,UPRCLSLAB,UPRCLSMRK,UPRABORT)) {
			/* Symbol */ case 0 : ddbcl=DDBCLSSYM; break;
			/* Label */  case 1 : ddbcl=DDBCLSLAB; break;
			/* Marker */ case 2 : ddbcl=DDBCLSMRK; break;
			}
		break;
		// Layout Editor or CAM Processor
		case ULIPGED :
		case ULIPCAM :
		case ULIPAR :
		// Select the layout plan DDB class
		switch (bae_askmenu(4,UPRCLLPRT,UPRCLLSTK,UPRCLLPAD,UPRABORT)) {
			/* Part */   case 0 : ddbcl=DDBCLLPRT; break;
			/* Stack */  case 1 : ddbcl=DDBCLLSTK; break;
			/* Pad */    case 2 : ddbcl=DDBCLLPAD; break;
			}
		break;
		// Chip Editor
		case ULIPCED :
		// Select the IC design plan DDB class
		switch (bae_askmenu(3,UPRCLICELL,UPRCLIPIN,UPRABORT)) {
			/* IC Cell */   case 0 : ddbcl=DDBCLICELL; break;
			/* IC Pin */    case 1 : ddbcl=DDBCLIPIN;  break;
			}
		break;
		// CAM View
		case ULIPCV :
		break;
		}
	// Check the element class
	if (ddbcl==DDBCLUNDEF)
		// Abort
		error_abort();
	// Select DDB file name
	if (bae_askddbfname(fname,1,UPRDDBFILE))
		// Abort
		error_abort();
	// Select DDB element name
	if (bae_askddbename(elemname,fname,ddbcl,"")!=0)
		error_abort();
	// Define the popup header
	sprintf(entryl[0],FMTELSTHD,fname);
	entryl[1]="";
	sprintf(entryl[2],FMTELHD,ddbclassname(ddbcl),elemname);
	entryn=3;
	if (listrefs(ddbcl,elemname)==0)
		entryl[entryn++]=REPLSTINC;
	// Show DDB listing with popup menu
	bae_setintpar(16,5023);
	mnu_poptext(entryl,0,0,-1,0,0);
}

void listsumref()
/*
// Perform DDB element summarized reference list output to screen
*/
{
	string lstfname			/* Listing file name */;
	int fh				/* File handle */;
	int i				/* Loop control variable */;
	// Select DDB file name
	if (bae_askddbfname(fname,1,UPRDDBFILE))
		// Abort
		error_abort();
	// Define the popup header
	sprintf(entryl[0],FMTELSTHD,fname);
	entryn=1;
	// Print scan message
	message(M_REPSCANDDB(),fname);
	if (scanclrefs(DDBCLSSYM)==0 || scanclrefs(DDBCLSLAB)==0 ||
	 scanclrefs(DDBCLSMRK)==0 || scanclrefs(DDBCLLPRT)==0 ||
	 scanclrefs(DDBCLLSTK)==0 || scanclrefs(DDBCLLPAD)==0 ||
	 scanclrefs(DDBCLICELL)==0 || scanclrefs(DDBCLIPIN)==0)
		entryl[entryn++]=REPLSTINC;
	if (LSTEXT=="") {
		// Show DDB listing with popup menu
		bae_setintpar(16,5023);
		mnu_poptext(entryl,0,0,-1,0,0);
		}
	else {
		// Get listing file name
		lstfname=convstring(fname,0)+LSTEXT;
		// Write listing file
		fh=fopen(lstfname,1);
		for (i=0;i<entryn;i++)
			fprintf(fh,"%s\n",entryl[i]);
		fclose(fh);
		message(REPLSTFILE,lstfname);
		}
}

int scanclrefs(int ddbcl)
/*
// Scan class element for reference display
// Return value :
//	1 for scan continue, 0 for scan stop
// Parameter :
//	int ddbcl		: Scan class
*/
{
	string ename = ""		/* Scan element name */;
	while (scanddbenames(fname,ddbcl,ename)==1) {
		entryl[entryn]="";
		entryn++;
		sprintf(entryl[entryn],FMTELHD,ddbclassname(ddbcl),ename);
		entryn++;
		if (listrefs(ddbcl,ename)==0) {
			// Flush scan cache
			scanddbenames(fname,0,"");
			return(0);
			}
		}
	return(1);
}

int listrefs(int ddbcl,string ename)
/*
// List references to given element
// Return value :
//	1 for scan continue, 0 for scan stop
// Parameters :
//	int ddbcl		: Element class
//	string ename		: Element name
*/
{
	switch (ddbcl) {
		case DDBCLSSYM :
		case DDBCLSLAB :
		listclrefs(DDBCLSCM,DDBCLSCM,ddbcl,ename);
		break;
		case DDBCLSMRK :
		if (listclrefs(DDBCLSCM,DDBCLSCM,ddbcl,ename)==0)
			return(0);
		if (listclrefs(DDBCLSSYM,DDBCLSSYM,ddbcl,ename)==0)
			return(0);
		listclrefs(DDBCLSLAB,DDBCLSLAB,ddbcl,ename);
		break;
		case DDBCLLPRT :
		listclrefs(DDBCLLAY,DDBCLLAY,ddbcl,ename);
		break;
		case DDBCLLSTK :
		if (listclrefs(DDBCLLPATH,DDBCLLAY,ddbcl,ename)==0)
			return(0);
		listclrefs(DDBCLLPRT,DDBCLLPRT,ddbcl,ename);
		break;
		case DDBCLLPAD :
		listclrefs(DDBCLLSTK,DDBCLLSTK,ddbcl,ename);
		break;
		case DDBCLICELL :
		if (listclrefs(DDBCLILAY,DDBCLILAY,ddbcl,ename)==0)
			return(0);
		listclrefs(DDBCLICELL,DDBCLICELL,ddbcl,ename);
		break;
		case DDBCLIPIN :
		if (listclrefs(DDBCLIPATH,DDBCLILAY,ddbcl,ename)==0)
			return(0);
		listclrefs(DDBCLICELL,DDBCLICELL,ddbcl,ename);
		break;
		default :
		;
		}
	return(1);
}

int listclrefs(int ddbcl,int dispcl,int elcl,string ename)
/*
// List class references to given element
// Return value :
//	1 for scan continue, 0 for scan stop
// Parameters :
//	int ddbcl		: Scan class
//	int dispcl		: Display class
//	int elcl		: Element class
//	string ename		: Element name
*/
{
	// Store scan data
	curclass=ddbcl;
	dispclass=dispcl;
	scanelclass=elcl;
	scanelname=ename;
	// Scan the reference element names
	ddbclassscan(fname,curclass,refscanfunc);
	// Stop scan on request
	return(abort ? 0 : 1);
}

int scanfunc(string ename)
/*
// DDB element scan function
// Return value :
//	1 for scan continue, 0 for scan stop, or (-1) on error
// Parameters :
//	string ename		: Element name
*/
{
	int sec,min,hour,day,mon,year	/* Update time designators */;
	int size			/* Record size */;
	int refcnt			/* Reference entry count */;
	int refidx			/* Reference entry index */;
	int refclass			/* Reference entry class */;
	string refname			/* Reference entry name */;
	string libname			/* Packager library name */;
	string conname			/* Packager connection list name */;
	// Test on abort request
	if (kbhit()) {
		getchr();
		if (verify(UPRFEXIT,0)) {
			// Set abort flag and stop scan
			abort=1;
			// Stop scan
			return(0);
			}
		}
	// Check header output flag
	if (!headout) {
		// Report the class code
		entryl[entryn++]="";
		sprintf(entryl[entryn],FMTCLHD,
		 curclass,ddbclassname(curclass));
		entryn++;
		// Set the header output flag
		headout=1;
		}
	// Get the update time
	ddbupdtime(fname,curclass,ename,sec,min,hour,day,mon,year);
	ddbupdtime(fname,curclass,"*"+ename,size,0,0,0,0,0);
	// Store the entry to the menu
	sprintf(entryl[entryn],FMTENTRY,ename,day,mon,year,hour,min,sec,size);
	entryn++;
	if (curclass==DDBCLPPAR) {
		if (bae_getpackdata(fname,libname,conname)==0) {
			if (libname!="") {
				// Store the ref. entry to menu
				sprintf(entryl[entryn],FMTPLIBENTRY,libname);
				entryn++;
				}
			if (conname!="") {
				// Store the ref. entry to menu
				sprintf(entryl[entryn],FMTPCONENTRY,conname);
				entryn++;
				}
			}
		}
	// Get the DDB element reference count
	refcnt=ddbelemrefcount(fname,curclass,ename);
	// List the DDB element references
	for (refidx=0;refidx<refcnt;refidx++) {
		// Get the reference entry
		if (ddbelemrefentry(
		 fname,curclass,ename,refidx,refclass,refname)==0) {
			// Store the ref. entry to menu
			sprintf(entryl[entryn],FMTREFENTRY,
			 ddbclassname(refclass),refname);
			entryn++;
			}
		// Test on abort request
		if (kbhit()) {
			getchr();
			if (verify(UPRFEXIT,0)) {
				// Set abort flag
				abort=1;
				break;
				}
			}
		}
	// Stop scan on request
	return(abort ? 0 : 1);
}

int refscanfunc(string ename)
/*
// DDB element scan function
// Return value :
//	1 for scan continue, 0 for scan stop, or (-1) on error
// Parameters :
//	string ename		: Element name
*/
{
	int refcnt			/* Reference entry count */;
	int refidx			/* Reference entry index */;
	int refclass			/* Reference entry class */;
	string refname			/* Reference entry name */;
	// Get the DDB element reference count
	refcnt=ddbelemrefcount(fname,curclass,ename);
	// List the DDB element references
	for (refidx=0;refidx<refcnt;refidx++) {
		// Get the reference entry
		if (ddbelemrefentry(
		  fname,curclass,ename,refidx,refclass,refname)==0 &&
		 refclass==scanelclass && refname==scanelname) {
			// Store the ref. entry to menu
			sprintf(entryl[entryn],FMTEREFENTRY,
			 ddbclassname(dispclass),ename);
			entryn++;
			}
		// Test on abort request
		if (kbhit()) {
			getchr();
			if (verify(UPRFEXIT,0)) {
				// Set abort flag
				abort=1;
				break;
				}
			}
		}
	// Stop scan on request
	return(abort ? 0 : 1);
}

// SQL data callback functions

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

// User Language program end