/* LAYERUSE (LAY) -- Layout Library Layer Usage Report */
/* LAYERUSE (LAY) -- Layoutbibliothek Lagenbelegungsreport */
/*
// Copyright (c) 1994-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 (081014) RELEASED FOR BAE V7.2.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (050906) RELEASED FOR BAE V6.6.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (010625) RELEASED FOR BAE V5.0.
//	rl (010526) ENHANCEMENT:
//		Added trace counts to summary output.
//		Suppressed output of zero element entries.
//	rl (010402) ENHANCEMENT:
//		Added optional parameter settings from bae.ini file.
//	rl (000509) RELEASED FOR BAE V4.6.
//	rl (990625) RELEASED FOR BAE V4.4.
//	rl (980910) RELEASED FOR BAE V4.2.
//	mb (980712) ENHANCEMENT:
//		Dynamic multi-language support introduced.
//	rl (970929) RELEASED FOR BAE V4.0.
//	mb (960919) RELEASED FOR BAE V3.4.
//	mb (95) RELEASED FOR BAE V3.2.
//	mb (94) RELEASED FOR BAE V3.0.
//	mb (94) ORIGINAL CODING.
//
// DESCRIPTION
//
// layeruse is a layout library management utility program for
// analyzing layer assignments of selectable DDB file layout
// elements. The layer assignment statistics are listed to an
// ASCII report file.
*/

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

// Disable undo state request
#pragma ULCALLERNOUNDO

// Messages
string ITMUNDEF		= M("*** UNDEFINIERT ***","*** UNDEFINED ***");
string REPDONE		= M("Lagenbelegungsreport ausgegeben auf Datei '",
			    "Layer Usage Report written to File '");
string REPANALYZE	= M("Analyse %s '%s'...","Analyzing %s '%s'...");
string UPRREPCUR	= M("Lagenbelegungsreport aktuelles Element ? ",
			    "Current Element Layer Usage Report ? ");
string UPRLAYLIB	= M("Layout Library Datei ? ",
			    "Layout Library File ? ");
string ERRNOLIB		= M("Bibliothek enthaelt keine Layout-Elemente!",
			    "Library contains no layout elements!");
string ERRLOAD		= M("Fehler beim Laden des Elementes '%s'!",
			    "Error loading element '%s'!");
string FMTLUSHD		= M("\n\nLAGENBELEGUNG IN LAYOUT-BIBLIOTHEK '%s':\n\n",
			    "\n\nLAYER USAGE IN LAYOUT LIBRARY '%s':\n\n");
string FMTTOTLAY	= M("Anzahl analysierter Layouts.............: %5d\n",
			    "Analyzed Layouts Count.................: %5d\n");
string FMTTOTPRT	= M("Anzahl analysierter Bauteile............: %5d\n",
			    "Analyzed Parts Count...................: %5d\n");
string FMTTOTSTK	= M("Anzahl analysierter Padstacks...........: %5d\n",
			    "Analyzed Padstacks Count...............: %5d\n");
string FMTTOTPAD	= M("Anzahl analysierter Pads................: %5d\n",
			    "Analyzed Pads Count....................: %5d\n");
string FMTLAYHD		= M("\nLAGE %d (%s) :\n","\nLAYER %d (%s) :\n");
string FMTREFLAY	= M("  Layouts mit Objekten auf Lage.........: %5d\n",
			    "  Number of Layouts using Layer........: %5d\n");
string FMTREFPRT	= M("  Bauteile mit Objekten auf Lage........: %5d\n",
			    "  Number of Parts using Layer..........: %5d\n");
string FMTREFSTK	= M("  Padstacks mit Objekten auf Lage.......: %5d\n",
			    "  Number of Padstacks using Layer......: %5d\n");
string FMTREFPAD	= M("  Pads mit Objekten auf Layer...........: %5d\n",
			    "  Number of Pads using Layer...........: %5d\n");
string FMTPADCNT	= M("  Anzahl Pads platziert auf Lage........: %5d\n",
			    "  Number of Pads placed on Layer.......: %5d\n");
string FMTTEXTCNT	= M("  Anzahl Texte platziert auf Lage.......: %5d\n",
			    "  Number of Texts placed on Layer......: %5d\n");
string FMTPOLYCNT	= M("  Anzahl Polygone platziert auf Lage....: %5d\n",
			    "  Number of Polygons placed on Layer...: %5d\n");
string FMTTRCCNT	= M("  Anzahl Leiterbahnen platziert auf Lage: %5d\n",
			    "  Number of Traces placed on Layer.....: %5d\n");
string FMTSUMPAD	= M("\nAnzahl Pads insgesamt platziert.........: %5d\n",
			    "\nTotal Number of Pads placed............: %5d\n");
string FMTSUMTEXT	= M("Anzahl Texte insgesamt platziert........: %5d\n",
			    "Total Number of Texts placed...........: %5d\n");
string FMTSUMPOLY	= M("Anzahl Polygone insgesamt platziert.....: %5d\n",
			    "Total Number of Polygons placed........: %5d\n");
string FMTSUMTRC	= M("Anzahl Leiterbahnen insgesamt platziert.: %5d\n",
			    "Total Number of Traces placed..........: %5d\n");
string FMTLAYER		= M("\tLAGE = %d (%s) ;\n","\tLAYER = %d (%s) ;\n");
#define FMTTOPIC	"         '%s'\n"
#define FMTELEMHD	"%s '%s':\n"
#define FMTUREF		"    %s '%s':"
#define FMTTEXT		"    TEXT '%s':"
#define FMTPOLY		"    %s :"

// INI file parameter name definitions
#define PAR_LUSFEXT	"LAYUSEFEXT_LAY"// Layer usage output file name ext.

// Global definitions
#define ITMLAYOUT	"LAYOUT"
#define ITMPART		"PART"
#define ITMSTACK	"STACK"
#define ITMPAD		"PAD"
#define POLYTYP1	"POLY COPPPAS"	// Polygon type passive copper
#define POLYTYP2	"POLY KEEPOUT"	// Polygon type keep out area
#define POLYTYP3	"POLY BRDOUT"	// Polygon type board outline
#define POLYTYP4	"POLY COPPACT"	// Polygon type active copper
#define POLYTYP5	"POLY DOCLINE"	// Polygon type documentary line
#define POLYTYP6	"POLY DOCAREA"	// Polygon type documentary area
#define POLYTYP7	"POLY COPPFIL"	// Polygon type copper fill area
#define POLYTYP8	"POLY HTCHCOP"	// Polygon type hatched copper area
#define POLYTYP9	"POLY SPPAREA"	// Polygon type split power plane area
string OUTEXT = bae_inistrval(PAR_LUSFEXT,".lus")
					/* Output file name extension */;

// Macro list
STRINGS macros				/* Macro name list */;
int mclasses[]				/* Macro plan class list */;
int macron		= 0		/* Macro count */;

// Layer descriptors
struct {				// Layer descriptor
	int laynum			/* Layer number */;
	int textcnt			/* Texts on this layer count */;
	int polycnt			/* Polygons on this layer count */;
	int trccnt			/* Traces on this layer count */;
	int padcnt			/* Pads on this layer count */;
	int layrefcnt			/* Part reference count */;
	int prtrefcnt			/* Part reference count */;
	int stkrefcnt			/* Stack reference count */;
	int padrefcnt			/* Pad reference count */;
	int refflag			/* Reference flag */;
	int topiclidx			/* Layer topic list index */;
	} layers[]			/* Layer list */;
int layern		= 0		/* Layer count */;

struct {				// Topic list descriptor
	int padn			/* Pad count */;
	STRINGS padl			/* Pad name list */;
	int txtn			/* Text count */;
	STRINGS txtl			/* Text list */;
	} topiclists[]			/* Topic list table */;
int topiclistn		= 0		/* Topic list count */;

// Global variables
int totlaycnt		= 0		/* Total layout count */;
int totprtcnt		= 0		/* Total part count */;
int totstkcnt		= 0		/* Total padstack count */;
int totpadcnt		= 0		/* Total pad count */;

// Main program
void main()
{
	string jobfname			/* Job file name */;
	string jobename			/* Job element name */;
	int jobclass			/* Job class */;
	string libfile			/* Library file */;
	string ofname			/* Output file name */;
	int ofh				/* Output file handle */;
	int i				/* Loop control variable */;
	// Save current element with verification on request
	verifysave();
	// Get the plan class and file and element name
	jobclass=bae_planddbclass();
	jobfname=bae_planfname();
	jobename=bae_planename();
	// Select the layout library file
	if (jobclass!=DDBCLUNDEF && verify(UPRREPCUR,0))
		// Set the library file designator to current element
		libfile="";
	else if (bae_askddbfname(libfile,1,UPRLAYLIB))
		// Abort
		error_abort();
	// Build the macro list
	buildmaclist(libfile);
	// Abort if library is empty
	if (macron==0)
		error(ERRNOLIB);
	// Restore the library file name
	if (libfile=="")
		libfile=jobfname;
	// Build the output file name
	ofname=convstring(libfile,0)+OUTEXT;
	// Open the output file
	ofh=bae_fopen(ofname,1);
	// Print the layer usage header
	fprintf(ofh,FMTLUSHD,libfile);
	// Loop thru the macro list
	for (i=0;i<macron;i++) {
		// Load the macro
		bae_setintpar(22,1);
		if (bae_loadelem(libfile,macros[i],mclasses[i])==(-1))
			errormsg(ERRLOAD,macros[i]);
		// Dump the loaded element
		dumpelem(ofh);
		}
	// Print the layer usage summary
	layusesummary(ofh,libfile);
	// Close the output file
	fclose(ofh);
	// Re-load the initial element
	if (jobclass!=DDBCLUNDEF && (jobclass!=bae_planddbclass() ||
	 jobfname!=bae_planfname() || jobename!=bae_planename())) {
		bae_setintpar(22,2);
		loadddbelem(jobfname,jobename,jobclass);
		}
	// Done
	bae_prtdialog(REPDONE+ofname+"'.");
}

void buildmaclist(string libfile)
/*
// Build macro list
// Parameters :
//	string libfile		: Library file
*/
{
	index L_MACRO mac		/* Macro index */;
	string ename			/* Current element name */;
	// Test if library file is undefined
	if (libfile=="") {
		// Build the pad list
		forall (mac where mac.CLASS==DDBCLLPAD) {
			macros[macron]=mac.NAME;
			mclasses[macron++]=DDBCLLPAD;
			totpadcnt++;
			}
		// Build the stacks list
		forall (mac where mac.CLASS==DDBCLLSTK) {
			macros[macron]=mac.NAME;
			mclasses[macron++]=DDBCLLSTK;
			totstkcnt++;
			}
		// Build the parts list
		forall (mac where mac.CLASS==DDBCLLPRT) {
			macros[macron]=mac.NAME;
			mclasses[macron++]=DDBCLLPRT;
			totprtcnt++;
			}
		// Test the current element class
		if (bae_planddbclass()==DDBCLUNDEF)
			return;
		// Evaluate the current element class
		switch (bae_planddbclass()) {
			case DDBCLLAY  : totlaycnt=1; break;
			case DDBCLLPRT : totprtcnt=1; break;
			case DDBCLLSTK : totstkcnt=1; break;
			case DDBCLLPAD : totpadcnt=1; break;
			}
		// Store the current element to the macro list
		macros[macron]=bae_planename();
		mclasses[macron++]=bae_planddbclass();
		// Done
		return;
		}
	// Build the pad list
	ename="";
	while (scanddbenames(libfile,DDBCLLPAD,ename)==1) {
		macros[macron]=ename;
		mclasses[macron++]=DDBCLLPAD;
		totpadcnt++;
		}
	// Set the total pad count
	totpadcnt=macron;
	// Build the stacks list
	ename="";
	while (scanddbenames(libfile,DDBCLLSTK,ename)==1) {
		macros[macron]=ename;
		mclasses[macron++]=DDBCLLSTK;
		totstkcnt++;
		}
	// Build the parts list
	ename="";
	while (scanddbenames(libfile,DDBCLLPRT,ename)==1) {
		macros[macron]=ename;
		mclasses[macron++]=DDBCLLPRT;
		totprtcnt++;
		}
	// Build the layouts list
	ename="";
	while (scanddbenames(libfile,DDBCLLAY,ename)==1) {
		macros[macron]=ename;
		mclasses[macron++]=DDBCLLAY;
		totlaycnt++;
		}
}

// Output routines

void layusesummary(int fh,string libfile)
/*
// Print the layer usage summary
// Parameters :
//	int fh			: Output file handle
//	string libfile		: Library file name
*/
{
	int tlidx			/* Topic list index */;
	int padn,txtn			/* Topic list entry counts */;
	int sumpad	= 0		/* Pad sum */;
	int sumtext	= 0		/* Text sum */;
	int sumpoly	= 0		/* Polygon sum */;
	int sumtrc	= 0		/* Trace sum */;
	int i,j				/* Loop control variables */;
	// Print the layer usage header
	fprintf(fh,FMTLUSHD,libfile);
	fprintf(fh,FMTTOTLAY,totlaycnt);
	fprintf(fh,FMTTOTPRT,totprtcnt);
	fprintf(fh,FMTTOTSTK,totstkcnt);
	fprintf(fh,FMTTOTPAD,totpadcnt);
	// Loop thru all layers
	for (i=0;i<layern;i++) {
		// Get the topic list index and entry counts
		tlidx=layers[i].topiclidx;
		padn=topiclists[tlidx].padn;
		txtn=topiclists[tlidx].txtn;
		// Print the layer usage statistics
		fprintf(fh,FMTLAYHD,
		 layers[i].laynum,layername(layers[i].laynum));
		if (layers[i].layrefcnt)
			fprintf(fh,FMTREFLAY,layers[i].layrefcnt);
		if (layers[i].prtrefcnt)
			fprintf(fh,FMTREFPRT,layers[i].prtrefcnt);
		if (layers[i].stkrefcnt)
			fprintf(fh,FMTREFSTK,layers[i].stkrefcnt);
		if (layers[i].padrefcnt)
			fprintf(fh,FMTREFPAD,layers[i].padrefcnt);
		if (layers[i].padcnt)
			fprintf(fh,FMTPADCNT,layers[i].padcnt);
		for (j=0;j<padn;j++)
			fprintf(fh,FMTTOPIC,topiclists[tlidx].padl[j]);
		if (layers[i].textcnt)
			fprintf(fh,FMTTEXTCNT,layers[i].textcnt);
		for (j=0;j<txtn;j++)
			fprintf(fh,FMTTOPIC,topiclists[tlidx].txtl[j]);
		if (layers[i].polycnt)
			fprintf(fh,FMTPOLYCNT,layers[i].polycnt);
		if (layers[i].trccnt)
			fprintf(fh,FMTTRCCNT,layers[i].trccnt);
		// Update the sums
		sumpad+=layers[i].padcnt;
		sumtext+=layers[i].textcnt;
		sumpoly+=layers[i].polycnt;
		sumtrc+=layers[i].trccnt;
		}
	// Print the sums
	fprintf(fh,FMTSUMPAD,sumpad);
	fprintf(fh,FMTSUMTEXT,sumtext);
	fprintf(fh,FMTSUMPOLY,sumpoly);
	fprintf(fh,FMTSUMTRC,sumtrc);
}

void dumpelem(int fh)
/*
// Dumps the currently loaded element
// Parameters :
//	int fh			: Output file handle
*/
{
	string msg			/* Message string */;
	int i				/* Loop control variable */;
	// Print protocol message
	sprintf(msg,REPANALYZE,classname(),bae_planename());
	bae_prtdialog(msg);
	// Print the class name and the element name
	fprintf(fh,FMTELEMHD,classname(),bae_planename());
	// Print the text list
	textlist(fh);
	// Print the unnamed reference list
	if (bae_planddbclass()==DDBCLLSTK)
		ureflist(fh);
	// Print the polygon list
	polylist(fh);
	// Update the trace list
	trclist();
	// Update the layer reference counts
	switch (bae_planddbclass()) {
		case DDBCLLAY :
		for (i=0;i<layern;i++) {
			if (layers[i].refflag)
				layers[i].layrefcnt++;
			layers[i].refflag=0;
			}
		break;
		case DDBCLLPRT :
		for (i=0;i<layern;i++) {
			if (layers[i].refflag)
				layers[i].prtrefcnt++;
			layers[i].refflag=0;
			}
		break;
		case DDBCLLSTK :
		for (i=0;i<layern;i++) {
			if (layers[i].refflag)
				layers[i].stkrefcnt++;
			layers[i].refflag=0;
			}
		break;
		case DDBCLLPAD :
		for (i=0;i<layern;i++) {
			if (layers[i].refflag)
				layers[i].padrefcnt++;
			layers[i].refflag=0;
			}
		break;
		}
}

void ureflist(int fh)
/*
// Unnamed reference list function
// Parameters :
//	int fh			: Output file handle
*/
{
	index L_UREF u			/* Unnamed reference index */;
	int layidx			/* Layer list index */;
	// Loop thru the unnamed reference list
	forall (u) {
		// Print the info
		fprintf(fh,FMTUREF,macclassname(u.MACRO.CLASS),u.MACRO.NAME);
		fprintf(fh,FMTLAYER,u.LAYOFF,layername(u.LAYOFF));
		layidx=gclayer(u.LAYOFF);
		layers[layidx].padcnt++;
		layers[layidx].refflag=1;
		storepadtopic(layers[layidx].topiclidx,u.MACRO.NAME);
		}
}

void textlist(int fh)
/*
// Text list function
// Parameters :
//	int fh			: Output file handle
*/
{
	index L_TEXT t			/* Text index */;
	int layidx			/* Layer list index */;
	// Loop thru the text list
	forall (t) {
		// Print the info
		fprintf(fh,FMTTEXT,t.STR);
		fprintf(fh,FMTLAYER,t.LAYER,layername(t.LAYER));
		layidx=gclayer(t.LAYER);
		layers[layidx].textcnt++;
		layers[layidx].refflag=1;
		storetexttopic(layers[layidx].topiclidx,t.STR);
		}
}

void polylist(int fh)
/*
// Polygon list function
// Parameters :
//	int fh			: Output file handle
*/
{
	index L_POLY p			/* Polygon index */;
	int layidx			/* Layer list index */;
	// Loop thru the polygon list
	forall (p) {
		// Print the info
		fprintf(fh,FMTPOLY,polytype(p.TYP));
		fprintf(fh,FMTLAYER,p.LAYER,layername(p.LAYER));
		layidx=gclayer(p.LAYER);
		layers[layidx].polycnt++;
		layers[layidx].refflag=1;
		}
}

void trclist()
/*
// Trace list function
*/
{
	index L_LINE t			/* Trace index */;
	int layidx			/* Layer list index */;
	// Loop thru the trace list
	forall (t) {
		layidx=gclayer(t.LAYER);
		layers[layidx].trccnt++;
		layers[layidx].refflag=1;
		}
}

// Layer list routines

int gclayer(int layer)
/*
// Get or create a layer entry for a given layer number
// Return value :
//	layer list index
// Parameters :
//	int layer		: Layer number
*/
{
	int slb		= 0		/* Search lower boundary */;
	int sub		= layern-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;
		// Compare entries; test if layer found
		if ((compres=layer-layers[sidx].laynum)==0)
			// Layer found
			return(sidx);
		// Update the search area
		if (compres<0)
			sub=sidx-1;
		else
			slb=sidx+1;
		}
	// Insert the new entry to the layer list
	layern++;
	for (sidx=layern-2;sidx>=slb;sidx--)
		layers[sidx+1]=layers[sidx];
	layers[slb].laynum=layer;
	layers[slb].textcnt=0;
	layers[slb].polycnt=0;
	layers[slb].trccnt=0;
	layers[slb].padcnt=0;
	layers[slb].layrefcnt=0;
	layers[slb].prtrefcnt=0;
	layers[slb].stkrefcnt=0;
	layers[slb].padrefcnt=0;
	layers[slb].refflag=0;
	layers[slb].topiclidx=topiclistn;
	topiclists[topiclistn].txtn=0;
	topiclists[topiclistn].padn=0;
	topiclistn++;
	// Return the layer list index
	return(slb);
}

void storepadtopic(int tlidx,string padname)
/*
// Store a pad name to a layer topic list
// Parameters :
//	int tlidx		: Topic list index
//	string padname		: Padname
*/
{
	int slb				/* Search lower boundary */;
	int sub				/* Search upper boundary */;
	int sidx			/* Search index */;
	int compres			/* Compare result */;
	// Init. the search area variables
	slb=0;
	sub=topiclists[tlidx].padn-1;
	// Loop until search area empty
	while (slb<=sub) {
		// Get the search index
		sidx=(slb+sub)>>1;
		// Compare entries
		compres=strcmp(padname,topiclists[tlidx].padl[sidx]);
		// Test if pad found
		if (compres==0)
			// Pad already stored
			return;
		// Update the search area
		if (compres<0)
			sub=sidx-1;
		else
			slb=sidx+1;
		}
	// Insert the new entry to the topic table pad list
	topiclists[tlidx].padn++;
	for (sidx=topiclists[tlidx].padn-2;sidx>=slb;sidx--)
		topiclists[tlidx].padl[sidx+1]=
		 topiclists[tlidx].padl[sidx];
	topiclists[tlidx].padl[slb]=padname;
}

void storetexttopic(int tlidx,string textstr)
/*
// Store a text string to a layer topic list
// Parameters :
//	int tlidx		: Topic list index
//	string textstr		: Text string
*/
{
	int slb				/* Search lower boundary */;
	int sub				/* Search upper boundary */;
	int sidx			/* Search index */;
	int compres			/* Compare result */;
	// Init. the search area variables
	slb=0;
	sub=topiclists[tlidx].txtn-1;
	// Loop until search area empty
	while (slb<=sub) {
		// Get the search index
		sidx=(slb+sub)>>1;
		// Compare entries
		compres=strcmp(textstr,topiclists[tlidx].txtl[sidx]);
		// Test if text found
		if (compres==0)
			// Text already stored
			return;
		// Update the search area
		if (compres<0)
			sub=sidx-1;
		else
			slb=sidx+1;
		}
	// Insert the new entry to the topic table text list
	topiclists[tlidx].txtn++;
	for (sidx=topiclists[tlidx].txtn-2;sidx>=slb;sidx--)
		topiclists[tlidx].txtl[sidx+1]=
		 topiclists[tlidx].txtl[sidx];
	topiclists[tlidx].txtl[slb]=textstr;
}

// Data conversion routines

string classname()
/*
// Return value :
//	class name of the currently loaded element
*/
{
	// Get the plan class
	switch (bae_planddbclass()) {
		case DDBCLLAY  : return(ITMLAYOUT);
		case DDBCLLPRT : return(ITMPART);
		case DDBCLLSTK : return(ITMSTACK);
		case DDBCLLPAD : return(ITMPAD);
		}
	// Return the undefined class name
	return(ITMUNDEF);
}

string macclassname(int c)
/*
// Return value :
//	class name for the given macro class code
// Parameters :
//	int c			: Macro class code
*/
{
	// Get the plan class
	switch (c) {
		case DDBCLLAY  : return(ITMLAYOUT);
		case DDBCLLPRT : return(ITMPART);
		case DDBCLLSTK : return(ITMSTACK);
		case DDBCLLPAD : return(ITMPAD);
		}
	// Return the undefined class name
	return(ITMUNDEF);
}

string polytype(int code)
/*
// Convert polygon type code to item string
// Return value :
//	polygon type denote string
// Parameters :
//	int code		: Polygon type code
*/
{
	// Evaluate the code
	switch (code) {
		case L_POLYCOPPASS : return(POLYTYP1);
		case L_POLYKEEPOUT : return(POLYTYP2);
		case L_POLYBRDOUT  : return(POLYTYP3);
		case L_POLYCOPACT  : return(POLYTYP4);
		case L_POLYDOCLINE : return(POLYTYP5);
		case L_POLYDOCAREA : return(POLYTYP6);
		case L_POLYCOPFILL : return(POLYTYP7);
		case L_POLYHTCHCOP : return(POLYTYP8);
		case L_POLYSPPAREA : return(POLYTYP9);
		}
	// Undefined
	return(ITMUNDEF);
}

// User Language program end