/* LMACREAD (GED) -- Text Based Macro Definition Import */
/* LMACREAD (GED) -- Textdatei mit Makrodefinitionen einlesen */
/*
// Copyright (c) 2006-2012 Oliver Bartels F+E, Muenchen
// Author: Roman Ludwig
// Changes History:
//	rl (120427) RELEASED FOR BAE V7.8.
//	rl (120123) BUGFIX:
//		Fixed problem with constant data initialization.
//	rl (110706) ENHANCEMENT:
//		Added vertical text center option.
//	rl (110609) ENHANCEMENT:
//		Added element comment support.
//		Added numstr number string formatter.
//	rl (101019) RELEASED FOR BAE V7.6.
//	rl (100503) ENHANCEMENT:
//		Added conditional operator support.
//		Added value list selection option to macro templates.
//	rl (100316) ENHANCEMENT:
//		Added interactive padstack creation support.
//	rl (091021) RELEASED FOR BAE V7.4.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (061122) ENHANCEMENT:
//		Allowed PADDEF command in PADSTACK definition.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (060728) ORIGINAL CODING.
//
// DESCRIPTION
//
// The lmacread User Language program provides generic insertion data
// output. The output format is specified in an external script file.
// The lmacread User Language program reads pad and padstack definitions
// from a selectable ASCII file and automatically creates the therein
// defined pads and padstacks.
*/

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

// Disable undo state request
#pragma ULCALLERNOUNDO

// Messages
string UPRABORT		= M_UPRABORT();
string UPRINPFILE	= M("Makrobeschreibungsdatei ? ",
			    "Macro Description File ? ");
string UPRSELTYPE	= M("Padstack Template ? ","Padstack Template ? ");
string UPRDUNIT		= M("Einheiten :","Units :");
string UPRDUNITMM	= M("&mm","&mm");
string UPRDUNITMIL	= M("mi&l","mi&l");
string UPRPROCMODE	= M("Bearbeitungsmodus waehlen!",
			    "Select Process Mode!");
string UPRPROC1		= M("&Konvertierlauf","&Conversion Run");
string UPRPROC2		= M("&Editierlauf","&Edit Run");
string REPADD		= M("Hinzugefuegt von: ","Added by:");
string REPDBLSTK	= M("Padstack '%s' bereits vorhanden!",
			    "Padstack '%s' already exists!");
string REPDONE		= M("Es wurden keine Fehler festgestellt.",
			    "Program run successfully done.");
string REPSTKCNT	= M("%d Padstackdefinitionen hinzugefuegt.",
			    "%d padstack definitions added.");
string ERRPARREF	= M("%s Zeile %d: Parameter/Konstante '%s' nicht definiert!",
			    "%s line %d: Parameter/constant '%s' not declared!");
string ERRPLCPOLY	= M("Zeile %d: Fehler bei der Polygonerzeugung!",
			    "Line %d: Error generating polygon!");
string ERRPLCPAD	= M("Zeile %d: Fehler bei der Padplatzierung ('%s')!",
			    "Line %d: Error placing pad ('%s')!");
string ERRPLCTEXT	= M("Zeile %d: Fehler bei der Textplatzierung ('%s')!",
			    "Line %d: Error placing text ('%s')!");
string ERRPLCDRILL	= M("Zeile %d: Fehler bei der Bohrungserzeugung!",
			    "Line %d: Error generating drill!");
string ERRSHAPEREF	= M("%s Zeile %d: Shape '%s' nicht definiert!",
			    "%s line %d: Shape '%s' not defined!");
string ERRTYPEREF	= M("%s Zeile %d: Padstacktyp '%s' nicht definiert!",
			    "%s line %d: Padstack Type '%s' not defined!");
string ERRUNTYPE	= M("%s Zeile %d: Padstacktyp '%s' ohne Namenzuweisung!",
			    "%s line %d: Padstack Type '%s' without name assignment!");
string ERRCONSTDUP	= M("%s Zeile %d: Konstante '%s' doppelt definiert!",
			    "%s line %d: Double defined constant '%s'!");
string ERRNOTEMP	= M("'%s': Keine Padstacktemplates gefunden!",
			    "'%s': No padstack templates found!");
string ERRTYPENAME	= M("Padstacktemplate '%s' nicht gefunden!",
			    "Padstack template '%s' not found!");
string ERRBAKFILE	= M("Fehler beim Anlegen der Backup-Datei '%s'!",
			    "Error creating backup file '%s'!");
string ERRNOWIN		= M("Nur in Windowsumgebungen verfuegbar!",
			    "Windows Environment needed!");
// Parser error messages
STRINGS PARSEERRS	= {
		"",
		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!")
		};

// INI file parameter name definitions
#define PAR_MACDFEXT	"MACDFEXT_GED"	// Macro definition file name ext.
#define PAR_MACDLIB	"MACDFILE_GED"	// Macro definition file

// File transfer definitions
string MACDEXT = bae_inistrval(PAR_MACDFEXT,".mac");
					// Macro definition file ext.
STRINGS extlist		= {		// Insertion spec. file extensions
	MACDEXT
	};
#define MAXLINELEN	1024		// Maximum input line length

// Term evaluation definitions
#define CMD_CONST	0		// Put constant onto stack
#define CMD_PARAM	1		// Put parameter reference onto stack
#define CMD_NEG		2		// Negate stack top
#define CMD_ADD		3		// Add stack top
#define CMD_SUB		4		// Subtract stack top
#define CMD_MUL		5		// Multiply stack top
#define CMD_DIV		6		// Divide stack top
#define CMD_STR		7		// String pattern stack top
#define CMD_NUMSTR	8		// String number stack top
#define CMD_EQU		9		// Compare equality stack top
#define CMD_NEQU	10		// Compare non equality stack top
#define CMD_LT		11		// Compare less than stack top
#define CMD_LE		12		// Compare less or equal stack top
#define CMD_GT		13		// Compare greater than stack top
#define CMD_GE		14		// Compare greater or equal stack top
#define CMD_COND	15		// Condition command stack top

// Rule types
#define RUL_NAME	0		// Rule name
#define RUL_INT		1		// Rule integer value predicate
#define RUL_DBL		2		// Rule double value predicate
#define RUL_STR		3		// Rule string value predicate

// Reference parameter type definitions
#define PARAM_DIM	0		// Dimension parameter
#define PARAM_STR	1		// String parameter
#define PARAM_DIML	2		// Dimension list parameter
#define PARAM_STRL	3		// String list parameter

struct datades {			// Data descriptor
	int cmd				/* Data code */;
	int ival			/* Data integer value */;
	double dval			/* Data double value */;
	string sval			/* Data string value */;
	string name			/* Data name string */;
	};
struct datades nilval = { 0,0,0.0,"","" }
					/* Nil value */;

struct datades curterm[]		/* Current term command list */;
int curtermn	= 0			/* Current term command count */;

struct refparam {			// Reference parameter
	string name			/* Reference parameter name */;
	int typ				/* Reference parameter type */;
	double dval			/* Data double value */;
	double dvall[]			/* Data double value list */;
	int dvaln			/* Data double value count */;
	string sval			/* Data string value */;
	string svall[]			/* Data string value list */;
	int svaln			/* Data string value count */;
	int pidx			/* Data parameter index */;
	int idx				/* Reference parameter dialog item */;
	};
struct refdes {				// Type reference descriptor
	struct refparam pl[]		/* Reference parameter list */;
	int pn				/* Reference paramater count */;
	int typel[]			/* Type reference list */;
	int typen			/* Type reference count */;
	string el[]			/* Type reference new entry list */;
	int en				/* Type reference new entry count */;
	int line			/* Type reference line */;
	string name			/* Type reference name */;
	} trefl[]			/* Type reference list */;
int trefn	= 0			/* Type reference count */;

struct termlist {			// Term list descriptor
	struct datades term[]		/* Term command list */;
	int termn			/* Term command count */;
	};

struct ruledes {
	struct datades term[]		/* Rule term list */;
	int termn			/* Rule term items */;
	int typ				/* Rule type */;
	string predname			/* Optional rule predicate name */;
	};

struct point {				// Point definition
	struct datades xl[]		/* Point x coordinate term list */;
	int xn				/* Point x coordinate term items */;
	struct datades yl[]		/* Point y coordinate term list */;
	int yn				/* Point y coordinate term items */;
	int typ				/* Point type */;
	} curpointl[]			/* Current point list */;
int curpointn	= 0			/* Current point count */;

struct shapedef {			// Shape definition
	string name			/* Shape name */;
	struct point pl[]		/* Point list */;
	int pn				/* Point count */;
	struct termlist vl[]		/* Shape variable command list */;
	int vn				/* Shape variable command count */;
	} shapel[]			/* Shape list */;
int shapen	= 0			/* Shape count */;

struct datades constl[]			/* Constant value list */;
int constn	= 0			/* Constant count */;

struct termlist curvarl[]		/* Current variable list */;
int curvarn	= 0			/* Current variable count */;

struct termlist curparrefl[]		/* Current parameter ref. list */;
int curparrefn	= 0			/* Current parameter ref. count */;

struct paddes {				// Pad descriptor
	struct datades name[]		/* Pad name commands */;
	int namen			/* Pad name command count */;
	int layerl[]			/* Pad layer list */;
	int layern			/* Pad layer count */;
	struct point pl[]		/* Point list */;
	int pn				/* Point count */;
	struct datades ang[]		/* Pad angle term list */;
	int angn			/* Pad angle term count */;
	int mirr			/* Pad mirror mode */;
	struct ruledes rules[]		/* Pad rule count */;
	int rulen			/* Pad rule count */;
	} curpad			/* Current pad */;

struct polydes {			// Polygon descriptor
	int polytyp			/* Polygon type */;
	int polyclose			/* Polygon close flag */;
	int mvis			/* Polygon mirror visibility */;
	int layerl[]			/* Polygon layer list */;
	int layern			/* Polygon layer count */;
	struct point pl[]		/* Point list */;
	int pn				/* Point count */;
	struct termlist sl[]		/* Polygon shape param. cmd. list */;
	int sn				/* Polygon shape param. cmd. count */;
	struct termlist vl[]		/* Polygon variable command list */;
	int vn				/* Polygon variable command count */;
	struct ruledes rules[]		/* Polygon rule count */;
	int rulen			/* Polygon rule count */;
	} curpoly			/* Current polygon */;

struct textdes {			// Text descriptor
	string text			/* Text string */;
	int layerl[]			/* Text layer list */;
	int layern			/* Text layer count */;
	struct point pl[]		/* Point list */;
	int pn				/* Point count */;
	struct datades ang[]		/* Text angle term list */;
	int angn			/* Text angle term count */;
	struct datades size[]		/* Text size term list */;
	int sizen			/* Text size term count */;
	int mirr			/* Text mirror and mode */;
	struct ruledes rules[]		/* Text rule count */;
	int rulen			/* Text rule count */;
	} curtext			/* Current text */;

struct drilldes {			// Drill descriptor
	struct point pl[]		/* Point list */;
	int pn				/* Point count */;
	struct datades size[]		/* Drill size term list */;
	int sizen			/* Drill size term count */;
	int class			/* Drill class */;
	struct ruledes rules[]		/* Drill rule count */;
	int rulen			/* Drill rule count */;
	} curdrill			/* Current drill */;

struct paddefdes {			// Pad definition descriptor
	struct datades name[]		/* Pad name commands */;
	int namen			/* Pad name command count */;
	struct datades comm[]		/* Pad comment commands */;
	int commn			/* Pad comment command count */;
	struct polydes poly		/* Pad polygon */;
	} curpaddef			/* Current pad definition */;

struct pstktypedef {			// Padstack type definition
	string name			/* Type name */;
	int typename			/* Padstack name variable index */;
	int typecomm			/* Padstack comment variable index */;
	struct point pl[]		/* Point list */;
	int pn				/* Point count */;
	struct textdes tl[]		/* Padstack text list */;
	int tn				/* Padstack text count */;
	struct drilldes dl[]		/* Padstack drill list */;
	int dn				/* Padstack drill count */;
	struct paddes padl[]		/* Padstack pad list */;
	int padn			/* Padstack pad count */;
	struct paddefdes pdl[]		/* Padstack pad definition list */;
	int pdn				/* Padstack pad definition count */;
	struct polydes polyl[]		/* Padstack pad list */;
	int polyn			/* Padstack pad count */;
	struct termlist vl[]		/* Type variable command list */;
	int vn				/* Type variable command count */;
	} typel[]			/* Type list */;
int typen	= 0			/* Type count */;

struct datades curparaml[]		/* Current parameter list */;
int curparamn	= 0			/* Current parameter count */;
int parambasevl[] = { 0 }		/* Parameter base var. index list */;
int parambasepl[] = { 0 }		/* Par. base par. name index list */;
int parambasel[] = { 0 }		/* Parameter base index list */;
int parambasen	= 1			/* Parameter base index count */;
int curlayerl[]				/* Current layer list */;
int curlayern	= 0			/* Current layer count */;

// Globals
#define SMALLVAL	0.000001	// Small distance value
string curdfname			/* Current defintion file name */;
string ddbfname				/* Output library file name */;
string msg				/* Message buffer */;
string curname				/* Current name */;
string curshapename			/* Current shape name */;
int curtypel[]				/* Current type reference list */;
int curtypen	= 0			/* Current type reference count */;
string curpstkname			/* Current padstack name */;
string curpstkcomm			/* Current padstack comment */;
string paramnames[]			/* Parameter name list */;
int paramnamen	= 0			/* Parameter count */;
struct ruledes currules[]		/* Current rule name list */;
int currulen	= 0			/* Current rule count */;
string curpred				/* Current predicate name */;
int curconstref				/* Current constant reference index */;
double curval				/* Current value */;
double curconv				/* Current conversion factor */;
struct datades curpadname[]		/* Current pad name term list */;
int curpadnamen				/* Current pad name term count */;
struct datades curpadcomm[]		/* Current pad comment term list */;
int curpadcommn				/* Current pad comment term count */;
struct datades cursize[]		/* Current size term list */;
int cursizen				/* Current size term count */;
struct datades curang[]			/* Current angle term list */;
int curangn				/* Current angle term count */;
int curmirr				/* Current mirror mode */;
int curmode				/* Current text mode */;
int curclass				/* Current drill class */;
int curmclass	= 0			/* Current drill class mirror flag */;
int curpolytyp				/* Current polygon type */;
int curpolymvis				/* Current polygon mirror visibility */;
int curplcmode	= 1			/* Current placement mode */;
int curprocmode = 0			/* Current process mode */;

// Main program
void main()
{
	string macdfname		/* Macro defintion file name */;
	string trefname			/* Type reference name */;
	int trefidx			/* Type reference index */;
	int typeidx			/* Type index */;
	int typerep	 = 1		/* Type loop repeat flag */;
	int pstkrep			/* Padstack loop repeat flag */;
	int paramrep			/* Parameter report flag */;
	int paramidx			/* Parameter index */;
	string paramstr			/* Parameter string */;
	double pcol			/* Parameter column */;
	double elen			/* Edit field length */;
	double cy	= DIAL_TOPMARG	/* Current y value */;
	double len			/* Text length */;
	int cunits			/* Coordinate display units */;
	int en		= 0		/* New entry count */;
	int sfh				/* Source file handle */;
	int dfh				/* Destination file handle */;
	string sbuf			/* String buffer */;
	string bakfname			/* Backup file name */;
	string hostname			/* Host name */;
	string username			/* User name */;
	int sec,min,hour		/* Time values */;
	int day,month,year		/* Date values */;
	int weekday,yearday		/* Day values */;
	int curline			/* Current replacement line */;
	int nextline			/* Next replacement line */;
	int oldparamn			/* Old parameter count */;
	string indent			/* Line indent string */;
	char c				/* Character buffer */;
	int i, j			/* Loop control variables */;
	// Select the element mode
	bae_promptdialog(UPRPROCMODE);
	if ((curprocmode=bae_askmenu(3,UPRPROC1,UPRPROC2,UPRABORT))<0 ||
	 curprocmode>1)
		// Abort
		error_abort();
	if ((macdfname=bae_inistrval(PAR_MACDLIB,""))=="")
		// Select the macro definition input file
		if ((macdfname=askfile(UPRINPFILE,extlist,0))=="")
			error_abort();
	if (curprocmode) {
		// Check if dialog box support
		if (bae_dialclr())
			error(ERRNOWIN);
		// Perform BAE Demo check with abort
		BAE_Demo_check(2);
		}
	// Build the output library file name
	ddbfname=convstring(macdfname,0)+DDBEXT;
	// Save current state for undo
	bae_callmenu(MNU_BAESAVESTATE);
	// Parse the macro definition file
	parsefile(macdfname);
	if (curprocmode==0) {
		// Done
		bae_prtdialog(REPDONE);
		exit(0);
		}
	if (trefn==0)
		errormsg(ERRNOTEMP,macdfname);
	curprocmode=0;
	do {
	    bae_nameclr();
	    for (i=0;i<trefn;i++)
		bae_nameadd(trefl[i].name,"","","",2);
	    // Select type reference name
	    bae_setintpar(16,3126);
	    if (bae_askname(trefname,UPRSELTYPE,MAXKEYLEN))
		break;
	    // Search the type
	    for (trefidx=0;trefidx<trefn;trefidx++)
		if (trefname==trefl[trefidx].name)
			break;
	    if (trefidx>=trefn)
		errormsg(ERRTYPENAME,trefname);
	    pcol=10.0;
	    elen=11.0;
	    for (i=0;i<trefl[trefidx].pn;i++) {
		if ((len=bae_dialgettextlen(0,trefl[trefidx].pl[i].name))>pcol)
			pcol=len;
		if (trefl[trefidx].pl[i].typ==PARAM_STRL)
			for (j=0;j<trefl[trefidx].pl[i].svaln;j++)
				if ((len=bae_dialgettextlen(0,
				 trefl[trefidx].pl[i].svall[j]))>elen)
					elen=len;
		}
	    pcol+=1.0;
	    elen+=1.0;
	    pstkrep=1;
	    do {
		bae_dialclr();
		cunits= bae_getcoorddisp() ? 2 : 0;
		// Init. the y coordinate
		cy=DIAL_TOPMARG;
		for (i=0;i<trefl[trefidx].pn;i++)
		    switch (trefl[trefidx].pl[i].typ) {
			case PARAM_DIM :
			trefl[trefidx].pl[i].idx=
			 dial_distpar(trefl[trefidx].pl[i].name,
			  5,trefl[trefidx].pl[i].dval,pcol,cy);
			break;
			case PARAM_STR :
			trefl[trefidx].pl[i].idx=
			 dial_namestringpar(trefl[trefidx].pl[i].name,
			  trefl[trefidx].pl[i].sval,MAXKEYLEN,pcol,cy);
			break;
			case PARAM_DIML :
			if (trefl[trefidx].pl[i].dvaln==1) {
				trefl[trefidx].pl[i].idx=(-1);
				}
			else {
				dial_label(0.0,cy,trefl[trefidx].pl[i].name);
				trefl[trefidx].pl[i].idx=dial_selbox(
				 trefl[trefidx].pl[i].pidx,pcol,cy);
				for (j=0;j<trefl[trefidx].pl[i].dvaln;j++) {
				    if (cunits)
					paramstr=bae_numstring(cvtlength(
					 trefl[trefidx].pl[i].dvall[j],0,3),5)+
					 " mil";
				    else
					paramstr=bae_numstring(cvtlength(
					 trefl[trefidx].pl[i].dvall[j],0,2),5)+
					 " mm";
				    dial_sbentry(0,j,paramstr);
				    }
				}
			break;
			case PARAM_STRL :
			if (trefl[trefidx].pl[i].svaln==1) {
				trefl[trefidx].pl[i].idx=(-1);
				}
			else {
				dial_label(0.0,cy,trefl[trefidx].pl[i].name);
				trefl[trefidx].pl[i].idx=dial_selbox(
				 trefl[trefidx].pl[i].pidx,pcol,cy);
				for (j=0;j<trefl[trefidx].pl[i].svaln;j++)
				    dial_sbentry(0,j,
				     trefl[trefidx].pl[i].svall[j]);
				}
			break;
			default :
			}
		dial_hsep(cy);
		// Store the coordinate unit controls
		dial_label(40.0,cy,UPRDUNIT);
		bae_dialaddcontrol(PA_RBF,0,1,cunits,0.0,0.0,
		 0.0,"",0,DIAL_LEFTMARG+pcol,cy,0.0,UPRDUNITMM);
		bae_dialaddcontrol(PA_RBN,2,2,0,0.0,0.0,0.0,"",
		 0,DIAL_LEFTMARG+pcol+6.0,cy,0.0,UPRDUNITMIL);
		dial_okabort(cy);
		paramrep=1;
		do {
		    // Call the dialog function
		    bae_setintpar(16,3107);
		    switch (bae_dialaskparams(
		     trefl[trefidx].name,cunits,
		     DIAL_LEFTMARG+pcol+12.0+DIAL_RIGHTSMARG,cy)) {
			case 0 :
			paramrep=2;
			// Get and check parameters
			for (i=0;i<trefl[trefidx].pn;i++)
			    switch (trefl[trefidx].pl[i].typ) {
				case PARAM_DIM :
				bae_dialgetdata(trefl[trefidx].pl[i].idx,0,
				 trefl[trefidx].pl[i].dval,"");
				if (trefl[trefidx].pl[i].dval<=0.0)
					paramrep=1;
				break;
				case PARAM_STR :
				trefl[trefidx].pl[i].idx=
				bae_dialgetdata(trefl[trefidx].pl[i].idx,0,0.0,
				 trefl[trefidx].pl[i].sval);
				if (trefl[trefidx].pl[i].sval=="")
					paramrep=1;
				break;
				case PARAM_DIML :
				if (trefl[trefidx].pl[i].dvaln==1) {
					trefl[trefidx].pl[i].dval=
					 trefl[trefidx].pl[i].dvall[0];
					}
				else {
					bae_dialgetdata(trefl[
					 trefidx].pl[i].idx,paramidx,0.0,"");
					trefl[trefidx].pl[i].dval=
					 trefl[trefidx].pl[i].dvall[paramidx];
					trefl[trefidx].pl[i].pidx=paramidx;
					}
				break;
				case PARAM_STRL :
				if (trefl[trefidx].pl[i].svaln==1) {
					trefl[trefidx].pl[i].sval=
					 trefl[trefidx].pl[i].svall[0];
					}
				else {
					bae_dialgetdata(trefl[
					 trefidx].pl[i].idx,paramidx,0.0,"");
					trefl[trefidx].pl[i].sval=
					 trefl[trefidx].pl[i].svall[paramidx];
					trefl[trefidx].pl[i].pidx=paramidx;
					}
				break;
				default :
				}
			break;
			case 1 :
			for (i=0;i<trefl[trefidx].pn;i++) {
			    if (trefl[trefidx].pl[i].typ!=PARAM_DIML ||
			     trefl[trefidx].pl[i].dvaln==1)
				continue;
			    for (j=0;j<trefl[trefidx].pl[i].dvaln;j++) {
				paramstr=bae_numstring(cvtlength(
				 trefl[trefidx].pl[i].dvall[j],0,3),5)+" mil";
				bae_dialsetdata(trefl[trefidx].pl[i].idx+j+1,
				  PA_SBE,j,0.0,paramstr);
				}
			    bae_dialgetdata(
			     trefl[trefidx].pl[i].idx,paramidx,0.0,"");
			    bae_dialsetdata(trefl[trefidx].pl[i].idx,
			     PA_SB|PA_HBRDREL,paramidx,0.0,"");
			    }
			cunits=0;
			break;
			case 2 :
			cunits=2;
			for (i=0;i<trefl[trefidx].pn;i++) {
			    if (trefl[trefidx].pl[i].typ!=PARAM_DIML ||
			     trefl[trefidx].pl[i].dvaln==1)
				continue;
			    for (j=0;j<trefl[trefidx].pl[i].dvaln;j++) {
				paramstr=bae_numstring(cvtlength(
				 trefl[trefidx].pl[i].dvall[j],0,2),5)+" mm";
				bae_dialsetdata(trefl[trefidx].pl[i].idx+j+1,
				  PA_SBE,j,0.0,paramstr);
				}
			    bae_dialgetdata(
			     trefl[trefidx].pl[i].idx,paramidx,0.0,"");
			    bae_dialsetdata(trefl[trefidx].pl[i].idx,
			     PA_SB|PA_HBRDREL,paramidx,0.0,"");
			    }
			break;
			default :
			paramrep=0;
			pstkrep=0;
			}
		    } while (paramrep==1);
		if (paramrep==2) {
			// Build the parameter list
			paramstr="(";
			for (i=0;i<trefl[trefidx].pn;i++) {
			    if (i!=0)
				paramstr+=",";
			    switch (trefl[trefidx].pl[i].typ) {
				case PARAM_DIM :
				case PARAM_DIML :
				if (cunits)
					paramstr+=bae_numstring(cvtlength(
					 trefl[trefidx].pl[i].dval,0,3),5)+
					 " mil";
				else
					paramstr+=bae_numstring(cvtlength(
					 trefl[trefidx].pl[i].dval,0,2),5)+
					 " mm";
				break;
				case PARAM_STR :
				case PARAM_STRL :
				paramstr+="\""+trefl[trefidx].pl[i].sval+"\"";
				break;
				}
			    }
			paramstr+=");";
			pushparam();
			for (j=0;j<trefl[trefidx].pn;j++) {
			    switch (trefl[trefidx].pl[j].typ) {
				case PARAM_DIM :
				case PARAM_DIML :
				curparaml[curparamn].dval=
				 trefl[trefidx].pl[j].dval;
				storetermcmd(CMD_CONST,0,
				 trefl[trefidx].pl[j].dval,"");
				break;
				case PARAM_STR :
				case PARAM_STRL :
				storetermcmd(CMD_CONST,0,0.0,
				 trefl[trefidx].pl[j].sval);
				break;
				}
			    p_param();
			    }
			oldparamn=curparamn;
			// Create entries for all types
			for (i=0;i<trefl[trefidx].typen;i++) {
				typeidx=trefl[trefidx].typel[i];
				curparamn=oldparamn;
				if (typecreate(typeidx,1)==0)
					continue;
				sprintf(trefl[trefidx].el[trefl[trefidx].en],
				 "%s%s\n",
				 typel[trefl[trefidx].typel[i]].name,paramstr);
				trefl[trefidx].en++;
				en++;
				}
			popparam();
			}
		} while (pstkrep);
	    } while (typerep);
	// Check if elements created
	if (en==0)
		exit(0);
	bakfname=convstring(macdfname,0)+".old";
	// Set file error mode
	fseterrmode(0);
	if ((sfh=fopen(bakfname,0))!=(-1)) {
		fclose(sfh);
		remove(bakfname);
		}
	if (rename(macdfname,bakfname)) {
		fseterrmode(1);
		errormsg(ERRBAKFILE,bakfname);
		}
	if ((dfh=fopen(macdfname,2))==(-1)) {
		fseterrmode(1);
		rename(bakfname,macdfname);
		exit(0);
		}
	if ((sfh=fopen(bakfname,0))==(-1)) {
		fclose(dfh);
		fseterrmode(1);
		rename(bakfname,macdfname);
		exit(0);
		}
	// Get first replacement line
	trefidx=0;
	while (trefidx<trefn && trefl[trefidx].en==0)
		trefidx++;
	nextline=trefl[trefidx].line;
	// Query host name
	if ((getenv("HOST",hostname)!=0 || hostname=="") &&
	 getenv("USERDOMAIN",hostname)!=0)
		hostname="";
	// Query user name
	if ((getenv("USER",username)!=0 || username=="") &&
	 getenv("USERNAME",username)!=0)
		username="";
	if (username=="")
		username=hostname;
	else if (hostname!="")
		username=username+"/"+hostname;
	// Get date and time
	localtime(sec,min,hour,day,month,year,weekday,yearday);
	sprintf(username,"/* %s %s, (%02d.%02d.%04d / %02d:%02d:%02d) */\n",
	 REPADD,username,day,month+1,year+1900,hour,min,sec);
	// Repetively get string from input file and modify/append it
	curline=0;
	while (fgets(sbuf,1024,sfh)==0) {
		curline++;
		fputs(sbuf,dfh);
		if (curline==nextline) {
			indent="   ";
			for (i=0;(c=sbuf[i])!='\0';i++) {
				if (c!=' ' && c!='\t') {
					if (c=='Q')
						indent=strextract(sbuf,0,i-1);
					break;
					}
				}
			fputs(indent,dfh);
			fputs(username,dfh);
			for (i=0;i<trefl[trefidx].en;i++) {
				fputs(indent,dfh);
				fputs(trefl[trefidx].el[i],dfh);
				}
			// Get next replacement line
			trefidx++;
			while (trefidx<trefn && trefl[trefidx].en==0)
				trefidx++;
			nextline= trefidx>=trefn ? (-1) : trefl[trefidx].line;
			}
		}
	// Close files
	fclose(sfh);
	fclose(dfh);
	fseterrmode(1);
	// Done
	sprintf(msg,REPSTKCNT,en);
	bae_prtdialog(msg);
}

/*________________________________________________________________*/
// Scanner/parser functions

/*________________________________________________________________*/
#bnf {	// LMACREAD BNF input syntax definition
	COMMENT ("/*","*/") ;
	COMMENT ("//") ;

	macdfile : sections EOF
		;
	sections : sections section
		| section
		;
	section : constant
		| range
		| shapes
		| pads
		| padstacktypes
		| padstacks
		| includefile
		| EOFINC
		|
		;
	constant : "CONST" name (p_constname) constval ";"
		;
	constval : constnum (p_constval)
		| singlelayerdef (p_constlay)
		| drillclass (p_constdrl)
		| conststring (p_conststring)
		;
	range : "RANGE" name (p_constname) constval ";"
		;
	shapes : "SHAPES" "{" (p_listclear) shapedefs "}"
		;
	shapedefs : shapedefs shapedef
		| shapedef
		|
		;
	shapedef : name (p_shapestart) "(" paramdeflist ")"
		 "{" vardefs pointlist (p_polyend) "}" (p_shapeend)
		;
	paramdeflist : paramdef "," paramdeflist
		| paramdef
		;
	paramdef : name (p_paramname)
		|
		;
	vardefs : vardefs varassignment
		| varassignment
		|
		;
	varassignment : name (p_varname) "=" cond (p_varvalue) ";"
		;
	pointlist : pointlist point
		| point
		;
	point : "POINT" xycoord (p_ptyp(0)) ";"
		| "ARCLEFT" xycoord (p_ptyp(1)) ";"
		| "ARCRIGHT" xycoord (p_ptyp(2)) ";"
		| "NEW" (p_ptyp(3)) optnmvis ";"
		;
	xycoord : "(" cond (p_xcoord) "," cond (p_ycoord) ")"
		;
	pads : "PADS" "{" (p_listclear) paddefs "}"
		;
	paddefs : paddefs paddef
		| paddef
		|
		;
	paddef : padheader paddefcmds shapeorpoly (p_storepad)
		;
	paddefcmds : paddefcmds paddefcmd
		| paddefcmd
		;
	paddefcmd : layerlist
		|
		;
	padheader : cond (p_padstart) optpadcomment
		;
	optpadcomment : "," cond (p_padcomment)
		|
		;
	shapeorpoly : shaperef
		| polydef
		;
	shaperef : shapetype name (p_shaperefstart) "(" paramlist ")"
		 optrules ";" (p_shaperefend)
		;
	polydef :  polytype "{" pointlist (p_polyend) "}" (p_storepoly)
		;
	refparamlist : refparamlist "," refparam
		| refparam
		;
	refparam : refparamtype DQSTR (p_refparamname)
		| constnum (p_dimentry(1))
		| conststring (p_strentry(1))
		;
	refparamtype : "dim" (p_refparamtype(0))
		| "string" (p_refparamtype(1))
		| "dimlist" (p_refparamtype(2)) "{" dimlist "}"
		| "stringlist" (p_refparamtype(3)) "{" strlist "}"
		;
	dimlist : dimlist "," dimentry
		| dimentry
		;
	dimentry : constnum (p_dimentry(0))
		;
	strlist : strlist "," strentry
		| strentry
		;
	strentry : conststring (p_strentry(0))
		;
	paramlist : paramlist "," param
		| param
		;
	param : cond (p_param)
		|
		;
	padstacktypes : "PADSTACKTYPES" "{" pstktdefs "}"
		;
	pstktdefs : pstktdefs pstktdef
		| pstktdef
		|
		;
	pstktdef : IDENT (p_typestart) "(" paramdeflist ")"
		 "{" vardefs (p_typevars) typdefs "}" (p_typeend)
		;
	typdefs : typdefs typdef
		| typdef
		|
		;
	typdef : "PADREF" cond (p_padref) padcmds (p_padrefend) ";"
		| "PADDEF" padheader paddefcmds shapeorpoly (p_storepad)
		| "TEXT" DQSTR (p_textstart) size textcmds (p_storetext) ";"
		| "DRILL" (p_drillstart) size drlcmds (p_storedrill) ";"
		| "POLYGON" polycmds shapeorpoly (p_plcpoly)
		;
	padstacks : "PADSTACKS" "{" (p_listclear) pstkdefs "}"
		;
	pstkdefs : pstkdefs pstkdef
		| pstkdef
		|
		;
	pstkdef : cond (p_pstkstart) optpstkcomment "{" pstkcmds "}" (p_pstkend)
		| IDENT (p_typerefname) typeparamlists ";" (p_typeclear)
		| "[" typereflist "]" typeparamlists ";" (p_typeclear)
		| "QUERY" DQSTR (p_pstktemp) ":" IDENT (p_typerefname)
		 "(" (p_reftypes) refparamlist ")" (p_pstktend) ";"
		| "QUERY" DQSTR (p_pstktemp) ":" "[" typereflist "]"
		 "(" (p_reftypes) refparamlist ")" (p_pstktend) ";"
		;
	optpstkcomment : "," cond (p_pstkcomment)
		|
		;
	typereflist : typereflist "," typeref
		| typeref
		;
	typeref : IDENT (p_typerefname)
		;
	typeparamlists : typeparamlists "," typeparamlist
		| typeparamlist
		;
	typeparamlist : "(" (p_typerefstart) paramlist ")" (p_typerefend)
		;
	pstkcmds : pstkcmds pstkcmd
		| pstkcmd
		;
	pstkcmd : "PADDEF" padheader paddefcmds shapeorpoly (p_storepad)
		| "PADREF" cond (p_padref) padcmds (p_padrefend) ";"
		| "TEXT" DQSTR (p_textstart) size textcmds (p_storetext) ";"
		| "DRILL" (p_drillstart) size drlcmds (p_storedrill) ";"
		| "POLYGON" (p_listclear) polycmds shapeorpoly (p_plcpoly)
		;
	padcmds : padcmds padcmd
		| padcmd
		;
	padcmd : xycoord (p_ptyp(0))
		| layerlist
		| angle
		| mirror
		| rules
		|
		;
	drlcmds : drlcmds drlcmd
		| drlcmd
		;
	drlcmd : xycoord (p_ptyp(0))
		| drillclassspec
		| rules
		|
		;
	textcmds : textcmds textcmd
		| textcmd
		;
	textcmd : xycoord (p_ptyp(0))
		| layerlist
		| "CENTER" (p_texthcenter)
		| "HCENTER" (p_texthcenter)
		| "VCENTER" (p_textvcenter)
		| angle
		| mirror
		| rules
		|
		;
	polycmds : polycmds polycmd
		| polycmd
		;
	polycmd : layerlist
		| rules
		|
		;
	mirror : "MIRROR" (p_mirror)
		;
	shapetype : "SHAPE" polytype
		;
	polytype : polybtype optpolymvis
		;
	polybtype : "FILLED" (p_polytyp(0))
		| "KEEPOUT" (p_polytyp(1))
		| "LINE" (p_polytyp(2))
		| "CLOSEDLINE" (p_polytyp(3))
		;
	optpolymvis : "TOP" (p_polymvis(1))
		| "BOTTOM" (p_polymvis(2))
		|
		;
	optnmvis : "TOP" (p_paddmvis(4))
		| "BOTTOM" (p_paddmvis(8))
		|
		;
	drillclassspec : drillclass
		| IDENT (p_classref)
		;
	drillclass : drillbaseclass
		| drillbaseclass "MIRROR" (p_mirrclass) drillbaseclass
		;
	drillbaseclass : "-" (p_class(0))
		| "A" (p_class(1))
		| "B" (p_class(2))
		| "C" (p_class(3))
		| "D" (p_class(4))
		| "E" (p_class(5))
		| "F" (p_class(6))
		| "G" (p_class(7))
		| "H" (p_class(8))
		| "I" (p_class(9))
		| "J" (p_class(10))
		| "K" (p_class(11))
		| "L" (p_class(12))
		| "M" (p_class(13))
		| "N" (p_class(14))
		| "O" (p_class(15))
		| "P" (p_class(16))
		| "Q" (p_class(17))
		| "R" (p_class(18))
		| "S" (p_class(19))
		| "T" (p_class(20))
		| "U" (p_class(21))
		| "V" (p_class(22))
		| "W" (p_class(23))
		| "X" (p_class(24))
		| "Y" (p_class(25))
		| "Z" (p_class(26))
		;
	rules : "RULES" (p_initrule) "(" rulelist ")"
		;
	optrules : rules
		|
		;
	rulelist : rulelist "," ruledef
		| ruledef
		|
		;
	ruledef : cond (p_rulename)
		| "INT" predname "=" cond (p_predval(1))
		| "DBL" predname "=" cond (p_predval(2))
		| "DIM" predname "=" cond (p_predval(2))
		| "STR" predname "=" cond (p_predval(3))
		;
	predname : IDENT (p_predname)
		;
	layerlist : layerlist "," layerdef
		| layerdef
		;
	layerdef : singlelayerdef
		| "SIG" NUMBER (p_layer) "," siglayerlist
		;
	siglayerlist : siglayerlist "," NUMBER (p_layer)
		| NUMBER (p_layer)
		;
	singlelayerdef : "SIG" NUMBER (p_layer)
		| "ALL" (p_alllayer)
		| "INNER" (p_innerlayer)
		| "TOP" (p_toplayer)
		| "DOC" NUMBER (p_doclayer) docside
		| IDENT (p_layref)
		;
	docside : "BOTTOM" (p_docside(0))
		| "TOP" (p_docside(1))
		| "BOTH" (p_docside(2))
		;
	size : cond (p_size)
		;
	angle : "ANGLE" cond (p_angle)
		;
	cond : equality
		| equality "?" cond ":" cond (p_cond)
		;
	equality : comparison
		| equality "==" comparison (p_equal)
		| equality "!=" comparison (p_nequal)
		;
	comparison : sum
		| comparison "<" sum (p_lt)
		| comparison "<=" sum (p_le)
		| comparison ">" sum (p_gt)
		| comparison ">=" sum (p_ge)
		;
	sum : product
		| sum "+" product (p_add)
		| sum "-" product (p_sub)
		;
	product : unary
		| product "*" unary (p_mul)
		| product "/" unary (p_div)
		;
	unary : primary
		| "-" unary (p_neg)
		;
	primary : IDENT (p_ref)
		| constnum (p_constpush)
		| conststring (p_sconstpush)
		| "(" sum ")"
		| "str" "(" sum "," sum ","
		 conststring (p_sconstpush) ")" (p_str)
		| "numstr" "(" sum "," sum "," sum ")" (p_numstr)
		;
	constnum : NUMBER (p_val) optconvfac
		;
	conststring : SQSTR (p_name)
		| DQSTR (p_name)
		;
	optconvfac : "mm" (p_mm)
		| "cm" (p_cm)
		| "Inch" (p_inch)
		| "Zoll" (p_inch)
		| "mil" (p_mil)
		| NUMBER (p_conv)
		|
		;
	name : IDENT (p_name)
		| SQSTR (p_name)
		| DQSTR (p_name)
		;
	includefile : "#" (p_eolnflag(1)) "include" DQSTR (p_include)
		 EOLN (p_eolnflag(0))
		;
}	// BNF syntax definition end
/*________________________________________________________________*/

void parsefile(string fn)
/*
// Parse an input file
// Parameter :
//	string fn		: File name
*/
{
	int status			/* Parser status */;
	// Parse the input file and evaluate the parser status
	synscaneoln(0);
	synsetintpar(0,1);
	curdfname=fn;
	if ((status=synparsefile(fn))==0) {
		// No error
		synsetintpar(0,0);
		return;
		}
	synsetintpar(0,0);
	if (status>=arylength(PARSEERRS))
		sprintf(msg,PARSEERRS[arylength(PARSEERRS)-1],status);
	else
		sprintf(msg,PARSEERRS[status],fn,synscanline(),synscanstring());
	// Print the error message
	error(msg);
}

// Parser action routines

int p_include()
/*
// Handle the include file request
// Return value :
//	zero if done or (-1) on error
*/
{
	string ofn			/* Old parse file name */;
	string fn			/* Include file name */;
	int status			/* Parser status */;
	synscaneoln(0);
	// Parse the input file and evaluate the parser status
	ofn=curdfname;
	curdfname=fn=synscanstring();
	if ((status=synparseincfile(fn))!=0) {
		synsetintpar(0,0);
		if (status>=arylength(PARSEERRS))
			sprintf(msg,PARSEERRS[arylength(PARSEERRS)-1],status);
		else
			sprintf(msg,PARSEERRS[status],
			 fn,synscanline(),synscanstring());
		// Print the error message
		error(msg);
		}
	curdfname=ofn;
	// Return without errors
	return(0);
}

int p_eolnflag(int flag)
/*
// Handle the end of line store request
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	int flag		: End of line flag
*/
{
	synscaneoln(flag);
	// Return without errors
	return(0);
}

int p_name()
/*
// Handle the name string store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curname=synscanstring();
	// Return without errors
	return(0);
}

int p_predname()
/*
// Handle the predicate name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curpred=synscanstring();
	// Return without errors
	return(0);
}

int p_initrule()
/*
// Handle the rule list init. request
// Return value :
//	zero if done or (-1) on error
*/
{
	currulen=0;
	// Return without errors
	return(0);
}

int p_rulename()
/*
// Handle the rule name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	currules[currulen].term=curterm;
	currules[currulen].termn=curtermn;
	currules[currulen].typ=RUL_NAME;
	currules[currulen].predname="";
	currulen++;
	curtermn=0;
	// Return without errors
	return(0);
}

int p_predval(int typ)
/*
// Handle the integer value store request
// Return value :
//	zero if done or (-1) on error
// Parameter :
//	int typ			: Predicate type
*/
{
	currules[currulen].term=curterm;
	currules[currulen].termn=curtermn;
	currules[currulen].typ=typ;
	currules[currulen].predname=curpred;
	currulen++;
	curtermn=0;
	// Return without errors
	return(0);
}

int p_size()
/*
// Handle the size store request
// Return value :
//	zero if done or (-1) on error
*/
{
	cursize=curterm;
	cursizen=curtermn;
	curtermn=0;
	// Return without errors
	return(0);
}

int p_angle()
/*
// Handle the angle store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curang=curterm;
	curangn=curtermn;
	curtermn=0;
	// Return without errors
	return(0);
}

int p_mirror()
/*
// Handle the mirror flag store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curmirr=1;
	// Return without errors
	return(0);
}

int p_texthcenter()
/*
// Handle the text horizontal center fag store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curmode|=TEXTHCENT;
	// Return without errors
	return(0);
}

int p_textvcenter()
/*
// Handle the text vertical center fag store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curmode|=TEXTVCENT;
	// Return without errors
	return(0);
}

int p_constname()
/*
// Handle the constant name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	int i				/* Loop control variable */;
	for (i=0;i<constn;i++)
		if (curname==constl[i].name) {
			sprintf(msg,ERRCONSTDUP,
			 curdfname,synscanline(),curname);
			bae_msgbox(2,msg,"");
			exit(0);
			}
	constl[constn].name=curname;
	constl[constn].ival=0;
	constl[constn].dval=0.0;
	constl[constn].sval="";
	curconstref=constn;
	constn++;
	curlayern=0;
	// Return without errors
	return(0);
}

int p_constval()
/*
// Handle the constant value store request
// Return value :
//	zero if done or (-1) on error
*/
{
	constl[curconstref].dval=curval/curconv;
	// Return without errors
	return(0);
}

int p_constlay()
/*
// Handle the constant layer store request
// Return value :
//	zero if done or (-1) on error
*/
{
	constl[curconstref].ival=curlayerl[0];
	// Return without errors
	return(0);
}

int p_constdrl()
/*
// Handle the constant drill class store request
// Return value :
//	zero if done or (-1) on error
*/
{
	constl[curconstref].ival=curclass;
	// Return without errors
	return(0);
}

int p_conststring()
/*
// Handle the constant string value store request
// Return value :
//	zero if done or (-1) on error
*/
{
	constl[curconstref].sval=curname;
	// Return without errors
	return(0);
}

int p_varname()
/*
// Handle the variable name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	// Treat this as additional parameters
	paramnames[paramnamen]=curname;
	paramnamen++;
	// Return without errors
	return(0);
}

int p_varvalue()
/*
// Handle the variable value store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curvarl[curvarn].term=curterm;
	curvarl[curvarn].termn=curtermn;
	curvarn++;
	curtermn=0;
	// Return without errors
	return(0);
}

int p_shaperefstart()
/*
// Handle the shape name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curshapename=curname;
	// Reset any shape specific lists
	curpointn=curtermn=curparrefn=currulen=0;
	// Return without errors
	return(0);
}

int p_shaperefend()
/*
// Handle the shape reference place request
// Return value :
//	zero if done or (-1) on error
*/
{
	int shapeidx			/* Shape index */;
	int polytyp			/* Polygon type */;
	int polyclose			/* Polygon close flag */;
	// Search the shape
	for (shapeidx=0;shapeidx<shapen;shapeidx++)
		if (curshapename==shapel[shapeidx].name)
			break;
	if (shapeidx>=shapen) {
		// Shape not found
		sprintf(msg,ERRSHAPEREF,curdfname,synscanline(),curshapename);
		bae_msgbox(2,msg,"");
		exit(0);
		}
	// Get the polygon type
	switch (curpolytyp) {
		// Filled area
		case 0 :
		polytyp=L_POLYCOPPASS;
		polyclose=0;
		break;
		// Keepout area
		case 1 :
		polytyp=L_POLYKEEPOUT;
		polyclose=0;
		break;
		// Closed documentary line
		case 3 :
		polytyp=L_POLYDOCLINE;
		polyclose=1;
		break;
		// Documentary line
		case 2 :
		default :
		polytyp=L_POLYDOCLINE;
		polyclose=0;
		}
	// Store the polygon
	curpoly.polytyp=polytyp;
	curpoly.polyclose=polyclose;
	curpoly.pl=shapel[shapeidx].pl;
	curpoly.pn=shapel[shapeidx].pn;
	curpoly.vl=shapel[shapeidx].vl;
	curpoly.vn=shapel[shapeidx].vn;
	curpoly.sl=curparrefl;
	curpoly.sn=curparrefn;
	curpoly.layerl=curlayerl;
	curpoly.layern=curlayern;
	curpoly.mvis=0;
	curpoly.rules=currules;
	curpoly.rulen=currulen;
	curpointn=currulen=curtermn=curparrefn=curlayern=0;
	return(0);
}

int p_typestart()
/*
// Handle the type name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	typel[typen].name=synscanstring();
	typel[typen].typename=(-1);
	typel[typen].typecomm=(-1);
	typel[typen].tn=0;
	typel[typen].pn=0;
	typel[typen].dn=0;
	typel[typen].padn=0;
	typel[typen].pdn=0;
	typel[typen].polyn=0;
	pushparam();
	curpointn=curtermn=0;
	curplcmode=0;
	// Return without errors
	return(0);
}

int p_typevars()
/*
// Handle the type name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	int vn	= 0			/* Variable count */;
	int i				/* Loop control variable */;
	for (i=parambasepl[parambasen-1];i<paramnamen;i++)
		if ("name"==paramnames[i])
			typel[typen].typename=i-parambasepl[parambasen-1]+
			 curparamn-parambasel[parambasen-1];
		else if ("comment"==paramnames[i])
			typel[typen].typecomm=i-parambasepl[parambasen-1]+
			 curparamn-parambasel[parambasen-1];
	if (typel[typen].typename<0) {
		sprintf(msg,
		 ERRUNTYPE,curdfname,synscanline(),typel[typen].name);
		bae_msgbox(2,msg,"");
		exit(0);
		}
	for (i=parambasevl[parambasen-1];i<curvarn;i++) {
		typel[typen].vl[vn]=curvarl[i];
		vn++;
		}
	typel[typen].vn=vn;
	// Return without errors
	return(0);
}

int p_typeend()
/*
// Handle the type end store request
// Return value :
//	zero if done or (-1) on error
*/
{
	typen++;
	curplcmode=1;
	popparam();
	// Return without errors
	return(0);
}

int p_typerefname()
/*
// Handle the type name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	string name			/* Type name string */;
	int typeidx			/* Type index */;
	name=synscanstring();
	// Search the type
	for (typeidx=0;typeidx<typen;typeidx++)
		if (name==typel[typeidx].name) {
			// Store type reference
			curtypel[curtypen]=typeidx;
			curtypen++;
			// Return without errors
			return(0);
			}
	// Type not found
	sprintf(msg,ERRTYPEREF,curdfname,synscanline(),curname);
	bae_msgbox(2,msg,"");
	return(-1);
}

int p_typerefstart()
/*
// Handle the type reference store request
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	int mode		: Type definition mode
*/
{
	pushparam();
	// Return without errors
	return(0);
}

int p_typerefend()
/*
// Handle the type reference place request
// Return value :
//	zero if done or (-1) on error
*/
{
	int oldparamn	= curparamn	/* Old parameter count */;
	int tridx			/* Type reference index */;
	if (curprocmode==0)
		// Loop for all type references
		for (tridx=0;tridx<curtypen;tridx++) {
			curparamn=oldparamn;
			typecreate(curtypel[tridx],0);
			}
	popparam();
	return(0);
}

int typecreate(int typeidx,int dblwarn)
/*
// Create padstack type with current parameter list
// Return value :
//	one if padstack created, else zero
// Parameters :
//	int typeidx		: Type list index
//	int dblwarn		: Double padstack warning flag
*/
{
	int i				/* Loop control variable */;
	// Store the type variables
	curpstkname=curpstkcomm="";
	for (i=0;i<typel[typeidx].vn;i++) {
		curparaml[curparamn]=evalexpr(
		 typel[typeidx].vl[i].term,typel[typeidx].vl[i].termn);
		if ((curparamn-parambasel[parambasen-1])==
		 typel[typeidx].typename)
			curpstkname=curparaml[curparamn].sval;
		else if ((curparamn-parambasel[parambasen-1])==
		 typel[typeidx].typecomm)
			curpstkcomm=curparaml[curparamn].sval;
		curparamn++;
		}
	// Write all pad definitions
	for (i=0;i<typel[typeidx].pdn;i++) {
		curpaddef=typel[typeidx].pdl[i];
		createpad();
		}
	if (curpstkname=="")
		return(0);
	// Check if padstack already exists
	if (existddbelem(ddbfname,DDBCLLSTK,curpstkname)==1) {
		if (dblwarn) {
			sprintf(msg,REPDBLSTK,curpstkname);
			bae_msgbox(0,msg,"");
			}
		return(0);
		}
	// Create the padstack element
	creelem(DDBCLLSTK,ddbfname,curpstkname);
	if (curpstkcomm!="")
		bae_setstrpar(0,curpstkcomm);
	// Write all padstack pads
	for (i=0;i<typel[typeidx].padn;i++) {
		curpad=typel[typeidx].padl[i];
		placepad();
		}
	// Write all padstack drills
	for (i=0;i<typel[typeidx].dn;i++) {
		curdrill=typel[typeidx].dl[i];
		placedrill();
		}
	// Write all padstack texts
	for (i=0;i<typel[typeidx].tn;i++) {
		curtext=typel[typeidx].tl[i];
		placetext();
		}
	// Write all padstack polygons
	for (i=0;i<typel[typeidx].polyn;i++) {
		curpoly=typel[typeidx].polyl[i];
		placepoly();
		}
	// Shrink the workspace
	baewsshrink(1);
	// Save the padstack element
	bae_clriactqueue();
	bae_setintpar(22,1);
	call(MNU_GEDSAVELEM);
	bae_setintpar(22,0);
	// Padstack created
	return(1);
}

int p_typeclear()
/*
// Handle the type list clear request
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	int mode		: Type definition mode
*/
{
	curtypen=0;
	// Return without errors
	return(0);
}

int p_pstktemp()
/*
// Handle the padstack template reference name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	trefl[trefn].name=synscanstring();
	trefl[trefn].pn=0;
	trefl[trefn].en=0;
	trefl[trefn].typen=0;
	// Return without errors
	return(0);
}

int p_pstktend()
/*
// Handle the padstack template reference end request
// Return value :
//	zero if done or (-1) on error
*/
{
	trefl[trefn].line=synscanline();
	trefn++;
	return(0);
}

int p_reftypes()
/*
// Handle the reference types store request
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	int mode		: Type definition mode
*/
{
	trefl[trefn].typel=curtypel;
	trefl[trefn].typen=curtypen;
	curtypen=0;
	// Return without errors
	return(0);
}

int p_refparamname()
/*
// Handle the type name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	trefl[trefn].pl[trefl[trefn].pn].name=synscanstring();
	trefl[trefn].pn++;
	// Return without errors
	return(0);
}

int p_refparamtype(int typ)
/*
// Handle the type name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	trefl[trefn].pl[trefl[trefn].pn].typ=typ;
	trefl[trefn].pl[trefl[trefn].pn].dvaln=0;
	trefl[trefn].pl[trefl[trefn].pn].svaln=0;
	trefl[trefn].pl[trefl[trefn].pn].pidx=0;
	// Return without errors
	return(0);
}

int p_dimentry(int typset)
/*
// Handle the dimension list value store request
// Return value :
//	zero if done or (-1) on error
*/
{
	if (typset)
		p_refparamtype(PARAM_DIML);
	trefl[trefn].pl[trefl[trefn].pn].dvall[
	 trefl[trefn].pl[trefl[trefn].pn].dvaln]=curval/curconv;
	trefl[trefn].pl[trefl[trefn].pn].dvaln++;
	if (typset) {
		trefl[trefn].pl[trefl[trefn].pn].name="";
		trefl[trefn].pn++;
		}
	// Return without errors
	return(0);
}

int p_strentry(int typset)
/*
// Handle the string list value store request
// Return value :
//	zero if done or (-1) on error
*/
{
	if (typset)
		p_refparamtype(PARAM_STRL);
	trefl[trefn].pl[trefl[trefn].pn].svall[
	 trefl[trefn].pl[trefl[trefn].pn].svaln]=curname;
	trefl[trefn].pl[trefl[trefn].pn].svaln++;
	if (typset) {
		trefl[trefn].pl[trefl[trefn].pn].name="";
		trefl[trefn].pn++;
		}
	// Return without errors
	return(0);
}

int p_shapestart()
/*
// Handle the shape name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curshapename=curname;
	// Reset any shape specific lists
	curpointn=curtermn=0;
	pushparam();
	// Return without errors
	return(0);
}

int p_shapeend()
/*
// Handle the shape store request
// Return value :
//	zero if done or (-1) on error
*/
{
	int vn	= 0			/* Variable count */;
	int i				/* Loop control variable */;
	for (i=parambasevl[parambasen-1];i<curvarn;i++) {
		shapel[shapen].vl[vn]=curvarl[i];
		vn++;
		}
	shapel[shapen].vn=vn;
	// Store shape data
	shapel[shapen].name=curshapename;
	shapel[shapen].pl=curpointl;
	shapel[shapen].pn=curpointn;
	shapen++;
	popparam();
	curpointn=curtermn=0;
	curpolymvis=0;
	curshapename="";
	// Return without errors
	return(0);
}

int p_polyend()
/*
// Handle the polygon point list end request
// Return value :
//	zero if done or (-1) on error
*/
{
	curpointl[curpointn].typ=3;
	curpointn++;
	// Return without errors
	return(0);
}

int p_storepoly()
/*
// Handle the polygon place request
// Return value :
//	zero if done or (-1) on error
*/
{
	int polytyp			/* Polygon type */;
	int polyclose			/* Polygon close flag */;
	// Get the polygon type
	switch (curpolytyp) {
		// Filled area
		case 0 :
		polytyp=L_POLYCOPPASS;
		polyclose=0;
		break;
		// Keepout area
		case 1 :
		polytyp=L_POLYKEEPOUT;
		polyclose=0;
		break;
		// Closed documentary line
		case 3 :
		polytyp=L_POLYDOCLINE;
		polyclose=1;
		break;
		// Documentary line
		case 2 :
		default :
		polytyp=L_POLYDOCLINE;
		polyclose=0;
		}
	curpoly.polytyp=polytyp;
	curpoly.polyclose=polyclose;
	curpoly.pl=curpointl;
	curpoly.pn=curpointn;
	curpoly.vn=0;
	curpoly.sn=0;
	curpoly.layerl=curlayerl;
	curpoly.layern=curlayern;
	curpoly.mvis=curpolymvis;
	curpoly.rules=currules;
	curpoly.rulen=currulen;
	curpointn=currulen=curtermn=curlayern=0;
	return(0);
}

int p_plcpoly()
/*
// Handle the polygon place request
// Return value :
//	zero if done or (-1) on error
*/
{
	if (curplcmode==1) {
		if (curpstkname!="")
			placepoly();
		}
	else {
		// Store polygon to type definition
		typel[typen].polyl[typel[typen].polyn]=curpoly;
		typel[typen].polyn++;
		}
	curpointn=currulen=curtermn=curlayern=0;
	return(0);
}

int p_listclear()
/*
// Handle the all list clear request
// Return value :
//	zero if done or (-1) on error
*/
{
	curpointn=currulen=curtermn=curlayern=curangn=cursizen=0;
	curpolymvis=0;
	// Return without errors
	return(0);
}

int p_padstart()
/*
// Handle the pad name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curpadname=curterm;
	curpadnamen=curtermn;
	curpadcommn=0;
	curpointn=curtermn=0;
	curshapename="";
	curpolymvis=0;
	curlayern=currulen=0;
	if (curplcmode==1)
		pushparam();
	// Return without errors
	return(0);
}

int p_padcomment()
/*
// Handle the pad comment store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curpadcomm=curterm;
	curpadcommn=curtermn;
	curtermn=0;
	// Return without errors
	return(0);
}

int p_storepad()
/*
// Handle the polygon place request
// Return value :
//	zero if done or (-1) on error
*/
{
	string ename = ""		/* Element name */;
	curpaddef.name=curpadname;
	curpaddef.namen=curpadnamen;
	curpaddef.comm=curpadcomm;
	curpaddef.commn=curpadcommn;
	curpaddef.poly=curpoly;
	if (curplcmode==1) {
		if (curprocmode==0) {
			if (bae_planddbclass()==DDBCLLSTK) {
				ename=bae_planename();
				bae_clriactqueue();
				bae_setintpar(22,1);
				call(MNU_GEDSAVELEM);
				bae_setintpar(22,0);
				}
			createpad();
			}
		popparam();
		if (curprocmode==0 && ename!="") {
			bae_setintpar(22,1);
			loadddbelem(ddbfname,ename,DDBCLLSTK);
			}
		}
	else {
		// Store pad definition to type definition
		typel[typen].pdl[typel[typen].pdn]=curpaddef;
		typel[typen].pdn++;
		}
	curpointn=currulen=curtermn=curlayern=0;
	return(0);
}

int p_padref()
/*
// Handle the pad name reference store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curpadname=curterm;
	curpadnamen=curtermn;
	curpointn=currulen=curtermn=curlayern=curangn=0;
	curmirr=0;
	// Return without errors
	return(0);
}

int p_padrefend()
/*
// Handle the pad reference store request
// Return value :
//	zero if done or (-1) on error
*/
{
	// Store the pad data
	curpad.name=curpadname;
	curpad.namen=curpadnamen;
	curpad.layerl=curlayerl;
	curpad.layern=curlayern;
	curpad.pl=curpointl;
	curpad.pn=curpointn;
	curpad.ang=curang;
	curpad.angn=curangn;
	curpad.mirr=curmirr;
	curpad.rules=currules;
	curpad.rulen=currulen;
	// Check operation mode
	if (curplcmode==1) {
		// Check if padstack defined
		if (curpstkname=="")
			return(0);
		// Place current pad
		placepad();
		}
	else {
		// Store pad to type definition
		typel[typen].padl[typel[typen].padn]=curpad;
		typel[typen].padn++;
		}
	curpointn=currulen=curtermn=curlayern=cursizen=curangn=0;
	// Return without errors
	return(0);
}

int p_textstart()
/*
// Handle the name string store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curtext.text=synscanstring();
	curpointn=currulen=curtermn=curlayern=cursizen=curangn=0;
	curmirr=0;
	curmode=0;
	// Return without errors
	return(0);
}

int p_storetext()
/*
// Handle the text store request
// Return value :
//	zero if done or (-1) on error
*/
{
	// Store the text data
	curtext.layerl=curlayerl;
	curtext.layern=curlayern;
	curtext.pl=curpointl;
	curtext.pn=curpointn;
	curtext.ang=curang;
	curtext.angn=curangn;
	curtext.size=cursize;
	curtext.sizen=cursizen;
	curtext.mirr=curmirr|curmode;
	curtext.rules=currules;
	curtext.rulen=currulen;
	// Check operation mode
	if (curplcmode) {
		// Check if padstack defined
		if (curpstkname=="")
			return(0);
		// Place current text
		placetext();
		}
	else {
		// Store text to type definition
		typel[typen].tl[typel[typen].tn]=curtext;
		typel[typen].tn++;
		}
	curpointn=currulen=curtermn=curlayern=cursizen=curangn=0;
	// Return without errors
	return(0);
}

int p_drillstart()
/*
// Handle the drill store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curclass=curmclass=0;
	curpointn=currulen=curtermn=curlayern=0;
	curpolymvis=0;
	curshapename="";
	// Return without errors
	return(0);
}

int p_storedrill()
/*
// Handle the drill store request
// Return value :
//	zero if done or (-1) on error
*/
{
	// Store the drill data
	curdrill.pl=curpointl;
	curdrill.pn=curpointn;
	curdrill.size=cursize;
	curdrill.sizen=cursizen;
	curdrill.class=curclass;
	curdrill.rules=currules;
	curdrill.rulen=currulen;
	// Check operation mode
	if (curplcmode==1) {
		// Check if padstack defined
		if (curpstkname=="")
			return(0);
		// Place current drill
		placedrill();
		}
	else {
		// Store text to type definition
		typel[typen].dl[typel[typen].dn]=curdrill;
		typel[typen].dn++;
		}
	curpointn=currulen=curtermn=curlayern=cursizen=0;
	// Return without errors
	return(0);
}

int p_pstkstart()
/*
// Handle the padstack name store request
// Return value :
//	zero if done or (-1) on error
*/
{
	struct datades res		/* Result buffer */;
	res=evalexpr(curterm,curtermn);
	curpstkname=res.sval;
	strlower(curpstkname);
	curpointn=curtermn=0;
	curshapename="";
	curlayern=0;
	curplcmode=1;
	pushparam();
	// Check if padstack already exists
	if (curprocmode!=0 || existddbelem(ddbfname,DDBCLLSTK,curpstkname)==1) {
		curpstkname="";
		return(0);
		}
	creelem(DDBCLLSTK,ddbfname,curpstkname);
	// Return without errors
	return(0);
}

int p_pstkcomment()
/*
// Handle the padstack comment store request
// Return value :
//	zero if done or (-1) on error
*/
{
	struct datades res		/* Result buffer */;
	if (curpstkname=="")
		return(0);
	res=evalexpr(curterm,curtermn);
	if ((curpstkcomm=res.sval)!="")
		bae_setstrpar(0,curpstkcomm);
	// Return without errors
	return(0);
}

int p_pstkend()
/*
// Handle the pad end request
// Return value :
//	zero if done or (-1) on error
*/
{
	popparam();
	if (curpstkname=="")
		return(0);
	// Shrink the workspace
	baewsshrink(1);
	// Save the padstack element
	bae_clriactqueue();
	bae_setintpar(22,1);
	call(MNU_GEDSAVELEM);
	bae_setintpar(22,0);
	return(0);
}

int p_paramname()
/*
// Handle the parameter name definition store request
// Return value :
//	zero if done or (-1) on error
*/
{
	paramnames[paramnamen]=curname;
	paramnamen++;
	// Return without errors
	return(0);
}

int p_param()
/*
// Handle the parameter store request
// Return value :
//	zero if done or (-1) on error
*/
{
	if (curplcmode==1) {
		curparaml[curparamn]=evalexpr(curterm,curtermn);
		curparamn++;
		}
	else {
		curparrefl[curparrefn].term=curterm;
		curparrefl[curparrefn].termn=curtermn;
		curparrefn++;
		}
	curtermn=0;
	// Return without errors
	return(0);
}

int p_constpush()
/*
// Handle the constant value store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_CONST,0,curval/curconv,"");
	return(0);
}

int p_sconstpush()
/*
// Handle the string constant value store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_CONST,0,0.0,curname);
	return(0);
}

int p_neg()
/*
// Handle the negate command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_NEG,0,0.0,"");
	return(0);
}

int p_add()
/*
// Handle the add command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_ADD,0,0.0,"");
	return(0);
}

int p_str()
/*
// Handle the string pattern command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_STR,0,0.0,"");
	return(0);
}

int p_numstr()
/*
// Handle the string number command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_NUMSTR,0,0.0,"");
	return(0);
}

int p_cond()
/*
// Handle the condition command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_COND,0,0.0,"");
	return(0);
}

int p_equal()
/*
// Handle the equality compare command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_EQU,0,0.0,"");
	return(0);
}

int p_nequal()
/*
// Handle the non equality compare command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_NEQU,0,0.0,"");
	return(0);
}

int p_lt()
/*
// Handle the less than command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_LT,0,0.0,"");
	return(0);
}

int p_le()
/*
// Handle the less or equal command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_LE,0,0.0,"");
	return(0);
}

int p_gt()
/*
// Handle the greater than command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_GT,0,0.0,"");
	return(0);
}

int p_ge()
/*
// Handle the greater or equal command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_GE,0,0.0,"");
	return(0);
}

int p_sub()
/*
// Handle the subtracte command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_SUB,0,0.0,"");
	return(0);
}

int p_mul()
/*
// Handle the multiply command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_MUL,0,0.0,"");
	return(0);
}

int p_div()
/*
// Handle the divide command store request
// Return value :
//	zero if done or (-1) on error
*/
{
	storetermcmd(CMD_DIV,0,0.0,"");
	return(0);
}

int p_ref()
/*
// Handle the reference store request
// Return value :
//	zero if done or (-1) on error
*/
{
	int i				/* Loop control variable */;
	curname=synscanstring();
	// First check if element parameter
	for (i=parambasepl[parambasen-1];i<paramnamen;i++)
		if (curname==paramnames[i]) {
			storetermcmd(CMD_PARAM,
			 i-parambasepl[parambasen-1],0.0,"");
			return(0);
			}
	// Check if constant definition
	for (i=0;i<constn;i++)
		if (curname==constl[i].name) {
			storetermcmd(CMD_CONST,0,constl[i].dval,constl[i].sval);
			return(0);
			}
	sprintf(msg,ERRPARREF,curdfname,synscanline(),curname);
	bae_msgbox(2,msg,"");
	return(-1);
}

int p_layref()
/*
// Handle the layer reference store request
// Return value :
//	zero if done or (-1) on error
*/
{
	int i				/* Loop control variable */;
	curname=synscanstring();
	// Check if constant definition
	for (i=0;i<constn;i++)
		if (curname==constl[i].name) {
			curlayerl[curlayern]=constl[i].ival;
			curlayern++;
			return(0);
			}
	sprintf(msg,ERRPARREF,curdfname,synscanline(),curname);
	bae_msgbox(2,msg,"");
	return(-1);
}

int p_classref()
/*
// Handle the drill class reference store request
// Return value :
//	zero if done or (-1) on error
*/
{
	int i				/* Loop control variable */;
	curname=synscanstring();
	// Check if constant definition
	for (i=0;i<constn;i++)
		if (curname==constl[i].name) {
			curclass=constl[i].ival;
			return(0);
			}
	sprintf(msg,ERRPARREF,curdfname,synscanline(),curname);
	bae_msgbox(2,msg,"");
	return(-1);
}

int p_polytyp(int typ)
/*
// Handle the polygon type store request
// Return value :
//	zero if done or (-1) on error
// Parameter :
//	int typ			: Shape type
*/
{
	curpolytyp=typ;
	curpolymvis=0;
	// Return without errors
	return(0);
}

int p_polymvis(int mvis)
/*
// Handle the polygon mirror visibility store request
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	int mvis		: Mirror visibility
*/
{
	curpolymvis=mvis;
	// Return without errors
	return(0);
}

int p_class(int class)
/*
// Handle the drill class store request
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	int class		: Drill class
*/
{
	// Check if mirror class extension
	if (curmclass) {
		if (class!=curclass)
			curclass|=DRLCMIRR|(class<<DRLCSHFT2);
		curmclass=0;
		}
	else {
		curclass=class;
		}
	// Return without errors
	return(0);
}

int p_mirrclass()
/*
// Handle the drill mirror class request
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	int class		: Drill class
*/
{
	curmclass=1;
	// Return without errors
	return(0);
}

int p_layer()
/*
// Receive a layer specification
// Return value :
//	zero if done or (-1) on error
*/
{
	curlayerl[curlayern]=atoi(synscanstring())-1;
	curlayern++;
	// Return without errors
	return(0);
}

int p_alllayer()
/*
// Receive an all layer specification
// Return value :
//	zero if done or (-1) on error
*/
{
	curlayerl[curlayern]=LAYERALL;
	curlayern++;
	// Return without errors
	return(0);
}

int p_toplayer()
/*
// Receive a top layer specification
// Return value :
//	zero if done or (-1) on error
*/
{
	curlayerl[curlayern]=LAYERTOP;
	curlayern++;
	// Return without errors
	return(0);
}

int p_innerlayer()
/*
// Receive an inner layer specification
// Return value :
//	zero if done or (-1) on error
*/
{
	curlayerl[curlayern]=LAYERBTW;
	curlayern++;
	// Return without errors
	return(0);
}

int p_doclayer()
/*
// Handle the documentary layer specification
// Return value :
//	zero if done or (-1) on error
*/
{
	curlayerl[curlayern]=1024+16*(atoi(synscanstring())-1);
	// Return without errors
	return(0);
}

int p_docside(int side)
/*
// Handle the documentary layer side specification
// Return value :
//	zero if done or (-1) on error
// Parameter :
//	int side		: Side code
*/
{
	curlayerl[curlayern]|=side;
	curlayern++;
	// Return without errors
	return(0);
}

int p_xcoord()
/*
// Handle the point x coordinate term store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curpointl[curpointn].xl=curterm;
	curpointl[curpointn].xn=curtermn;
	curtermn=0;
	// Return without errors
	return(0);
}

int p_ycoord()
/*
// Handle the point y coordinate term store request
// Return value :
//	zero if done or (-1) on error
*/
{
	curpointl[curpointn].yl=curterm;
	curpointl[curpointn].yn=curtermn;
	curtermn=0;
	// Return without errors
	return(0);
}

int p_ptyp(int typ)
/*
// Handle the point type store request
// Return value :
//	zero if done or (-1) on error
// Parameter :
//	int typ			: Point type
*/
{
	if (curpointn==0 && typ<3) {
		curpointl[curpointn+1]=curpointl[curpointn];
		curpointl[curpointn].typ=3;
		curpointn++;
		}
	curpointl[curpointn].typ=typ;
	curpointn++;
	// Return without errors
	return(0);
}

int p_paddmvis(int mvis)
/*
// Handle the polygon mirror visibility store request
// Return value :
//	zero if done or (-1) on error
// Parameters :
//	int mvis		: Mirror visibiltiy flag
*/
{
	if (curpointn>0)
		curpointl[curpointn-1].typ|=mvis;
	// Return without errors
	return(0);
}

int p_val()
/*
// Receive a value specification
// Return value :
//	zero if done or (-1) on error
*/
{
	string valstr			/* Value string */;
	int len				/* Value string length */;
	// Get the value string
	valstr=synscanstring();
	strlower(valstr);
	curval=atof(valstr);
	curconv=1.0;
	len=strlen(valstr);
	// Check for trailing unit designators
	if (len>4 &&
	 ((valstr[len-4]=='z' && valstr[len-3]=='o' &&
	  valstr[len-2]=='l' && valstr[len-1]=='l') ||
	 (valstr[len-4]=='i' && valstr[len-3]=='n' &&
	  valstr[len-2]=='c' && valstr[len-1]=='h')))
		return(p_inch());
	if (len>3 &&
	 valstr[len-3]=='m' && valstr[len-2]=='i' && valstr[len-1]=='l')
		return(p_mil());
	if (len>2) {
		if (valstr[len-2]=='c' && valstr[len-1]=='m')
			return(p_cm());
		if (valstr[len-2]=='m' && valstr[len-1]=='m')
			return(p_mm());
		}
	// Return without errors
	return(0);
}

int p_mm()
/*
// Receive a mm conversion factor
// Return value :
//	zero if done or (-1) on error
*/
{
	curconv=1000.0;
	// Return without errors
	return(0);
}

int p_cm()
/*
// Receive a cm conversion factor
// Return value :
//	zero if done or (-1) on error
*/
{
	curconv=100.0;
	// Return without errors
	return(0);
}

int p_inch()
/*
// Receive an inch conversion factor
// Return value :
//	zero if done or (-1) on error
*/
{
	curconv=1.0/0.0254;
	// Return without errors
	return(0);
}

int p_mil()
/*
// Receive a mil conversion factor
// Return value :
//	zero if done or (-1) on error
*/
{
	curconv=1.0/0.0000254;
	// Return without errors
	return(0);
}

int p_conv()
/*
// Receive a conversion factor
// Return value :
//	zero if done or (-1) on error
*/
{
	curconv=atof(synscanstring());
	// Return without errors
	return(0);
}

void storetermcmd(int cmd,int ival,double dval,string sval)
/*
// Store expression stack command
// Parameters :
//	int cmd			: Term command
//	int ival		: Term integer value
//	double dval		: Term double value
//	string sval		: Term string value
*/
{
	curterm[curtermn].cmd=cmd;
	curterm[curtermn].ival=ival;
	curterm[curtermn].dval=dval;
	curterm[curtermn].sval=sval;
	curterm[curtermn].name="";
	curtermn++;
}

struct datades evalexpr(struct datades terml[],int termn)
/*
// Evaluate expression term
// Return value :
//	evaluation result
// Parameters :
//	struct datades terml[]	: Term item list
//	int termn		: Term item count
*/
{
	struct datades exprstk[]	/* Expression stack */;
	struct datades retval		/* Return value */;
	int ival			/* Integer value */;
	double dval			/* Double value */;
	string sval			/* String value */;
	int exprstkn = 0		/* Expression stack pointer */;
	int i				/* Loop control variable */;
	// Execute all term commands
	for (i=0;i<termn;i++) {
		ival=terml[i].ival;
		dval=terml[i].dval;
		sval=terml[i].sval;
		switch (terml[i].cmd) {
			case CMD_CONST :
			exprstk[exprstkn].dval=dval;
			exprstk[exprstkn].sval=sval;
			exprstkn++;
			break;
			case CMD_PARAM :
			ival+=parambasel[parambasen-1];
			if (ival<curparamn)
				exprstk[exprstkn]=curparaml[ival];
			else
				exprstk[exprstkn]=nilval;
			exprstkn++;
			break;
			case CMD_NEG :
			if (exprstkn<=0)
				break;
			exprstk[exprstkn-1].dval=(-exprstk[exprstkn-1].dval);
			break;
			case CMD_ADD :
			if (exprstkn<=1)
				break;
			exprstkn--;
			exprstk[exprstkn-1].dval=
			 exprstk[exprstkn-1].dval+exprstk[exprstkn].dval;
			exprstk[exprstkn-1].sval=
			 exprstk[exprstkn-1].sval+exprstk[exprstkn].sval;
			break;
			case CMD_SUB :
			if (exprstkn<=1)
				break;
			exprstkn--;
			exprstk[exprstkn-1].dval=
			 exprstk[exprstkn-1].dval-exprstk[exprstkn].dval;
			break;
			case CMD_MUL :
			if (exprstkn<=1)
				break;
			exprstkn--;
			exprstk[exprstkn-1].dval=
			 exprstk[exprstkn-1].dval*exprstk[exprstkn].dval;
			break;
			case CMD_DIV :
			if (exprstkn<=1)
				break;
			exprstkn--;
			if (exprstk[exprstkn].dval!=0.0)
				exprstk[exprstkn-1].dval=
				 exprstk[exprstkn-1].dval/
				  exprstk[exprstkn].dval;
			break;
			case CMD_STR :
			if (exprstkn<=2)
				break;
			exprstkn-=2;
			if (exprstk[exprstkn].dval==0.0)
				dval=0.0;
			else
				dval=exprstk[exprstkn-1].dval/
				 exprstk[exprstkn].dval;
			sprintf(exprstk[exprstkn-1].sval,
			 exprstk[exprstkn+1].sval,dval);
			exprstk[exprstkn-1].dval=0.0;
			break;
			case CMD_NUMSTR :
			if (exprstkn<=2)
				break;
			exprstkn-=2;
			if (exprstk[exprstkn].dval==0.0)
				dval=0.0;
			else
				dval=exprstk[exprstkn-1].dval/
				 exprstk[exprstkn].dval;
			exprstk[exprstkn-1].sval=bae_numstring(dval,
			 exprstk[exprstkn+1].dval);
			exprstk[exprstkn-1].dval=0.0;
			break;
			case CMD_EQU :
			if (exprstkn<=1)
				break;
			exprstkn--;
			if (exprstk[exprstkn-1].sval!="" ||
			 exprstk[exprstkn].sval!="") {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].sval==
				 exprstk[exprstkn].sval ? 1 : 0 ;
				}
			else if (exprstk[exprstkn-1].dval!=0.0 ||
			 exprstk[exprstkn].dval!=0.0) {
				exprstk[exprstkn-1].ival=
				 fabs(exprstk[exprstkn-1].dval-
				  exprstk[exprstkn].dval)<=SMALLVAL ? 1 : 0 ;
				}
			 else {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].ival==
				 exprstk[exprstkn].ival ? 1 : 0 ;
				}
			exprstk[exprstkn-1].dval=0.0;
			exprstk[exprstkn-1].sval="";
			break;
			case CMD_NEQU :
			if (exprstkn<=1)
				break;
			exprstkn--;
			if (exprstk[exprstkn-1].sval!="" ||
			 exprstk[exprstkn].sval!="") {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].sval!=
				 exprstk[exprstkn].sval ? 1 : 0 ;
				}
			else if (exprstk[exprstkn-1].dval!=0.0 ||
			 exprstk[exprstkn].dval!=0.0) {
				exprstk[exprstkn-1].ival=
				 fabs(exprstk[exprstkn-1].dval-
				  exprstk[exprstkn].dval)>SMALLVAL ? 1 : 0 ;
				}
			 else {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].ival!=
				 exprstk[exprstkn].ival ? 1 : 0 ;
				}
			exprstk[exprstkn-1].dval=0.0;
			exprstk[exprstkn-1].sval="";
			break;
			case CMD_LT :
			if (exprstkn<=1)
				break;
			exprstkn--;
			if (exprstk[exprstkn-1].sval!="" ||
			 exprstk[exprstkn].sval!="") {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].sval<
				 exprstk[exprstkn].sval ? 1 : 0 ;
				}
			else if (exprstk[exprstkn-1].dval!=0.0 ||
			 exprstk[exprstkn].dval!=0.0) {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].dval<
				  (exprstk[exprstkn].dval-SMALLVAL) ? 1 : 0 ;
				}
			 else {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].ival<
				 exprstk[exprstkn].ival ? 1 : 0 ;
				}
			exprstk[exprstkn-1].dval=0.0;
			exprstk[exprstkn-1].sval="";
			break;
			case CMD_LE :
			if (exprstkn<=1)
				break;
			exprstkn--;
			if (exprstk[exprstkn-1].sval!="" ||
			 exprstk[exprstkn].sval!="") {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].sval<=
				 exprstk[exprstkn].sval ? 1 : 0 ;
				}
			else if (exprstk[exprstkn-1].dval!=0.0 ||
			 exprstk[exprstkn].dval!=0.0) {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].dval<=
				  (exprstk[exprstkn].dval+SMALLVAL) ? 1 : 0 ;
				}
			 else {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].ival<=
				 exprstk[exprstkn].ival ? 1 : 0 ;
				}
			exprstk[exprstkn-1].dval=0.0;
			exprstk[exprstkn-1].sval="";
			break;
			case CMD_GT :
			if (exprstkn<=1)
				break;
			exprstkn--;
			if (exprstk[exprstkn-1].sval!="" ||
			 exprstk[exprstkn].sval!="") {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].sval>
				 exprstk[exprstkn].sval ? 1 : 0 ;
				}
			else if (exprstk[exprstkn-1].dval!=0.0 ||
			 exprstk[exprstkn].dval!=0.0) {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].dval>
				  (exprstk[exprstkn].dval+SMALLVAL) ? 1 : 0 ;
				}
			 else {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].ival>
				 exprstk[exprstkn].ival ? 1 : 0 ;
				}
			exprstk[exprstkn-1].dval=0.0;
			exprstk[exprstkn-1].sval="";
			break;
			case CMD_GE :
			if (exprstkn<=1)
				break;
			exprstkn--;
			if (exprstk[exprstkn-1].sval!="" ||
			 exprstk[exprstkn].sval!="") {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].sval>=
				 exprstk[exprstkn].sval ? 1 : 0 ;
				}
			else if (exprstk[exprstkn-1].dval!=0.0 ||
			 exprstk[exprstkn].dval!=0.0) {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].dval>=
				  (exprstk[exprstkn].dval-SMALLVAL) ? 1 : 0 ;
				}
			 else {
				exprstk[exprstkn-1].ival=
				 exprstk[exprstkn-1].ival>=
				 exprstk[exprstkn].ival ? 1 : 0 ;
				}
			exprstk[exprstkn-1].dval=0.0;
			exprstk[exprstkn-1].sval="";
			break;
			case CMD_COND :
			if (exprstkn<=2)
				break;
			exprstkn-=2;
			if (exprstk[exprstkn-1].ival)
				exprstk[exprstkn-1]=exprstk[exprstkn];
			else
				exprstk[exprstkn-1]=exprstk[exprstkn+1];
			}
		}
	// Return expression result
	if (exprstkn==1)
		retval=exprstk[0];
	else
		retval=nilval;
	return(retval);
}

STRINGS evalrules(struct ruledes rulel[],int rulen)
/*
// Evaluate expression term
// Return value :
//	evaluation result
// Parameters :
//	struct datades terml[]	: Term item list
//	int termn		: Term item count
*/
{
	struct datades res		/* Result buffer */;
	string resl[] ={""}		/* Rule return name list */;
	char c				/* Current character */;
	int curbit			/* Current bit value */;
	int i, j			/* Loop control variables */;
	// Evaluate all rules
	for (i=0;i<rulen;i++) {
		res=evalexpr(rulel[i].term,rulel[i].termn);
		switch (rulel[i].typ) {
			case RUL_INT :
			if (res.sval!="" && res.ival==0) {
				// Loop for all bits
				curbit=1;
				for (j=0;j<32;j++) {
					// Check if end of string
					if ((c=res.sval[j])=='\0')
						break;
					// Check if bit set
					if (c!=' ' && c!='-' && c!='0' &&
					 c!='o' && c!='O')
						res.ival|=curbit;
					// Switch to next bit
					curbit<<=1;
					}
				}
			sprintf(resl[i],":%s:%s=%d;",
			 RS_PCBSUBJ,rulel[i].predname,res.ival);
			break;
			case RUL_DBL :
			if (floor(res.dval)==ceil(res.dval))
				sprintf(resl[i],":%s:%s=%.1f;",
				 RS_PCBSUBJ,rulel[i].predname,res.dval);
			else
				sprintf(resl[i],":%s:%s=%.9g;",
				 RS_PCBSUBJ,rulel[i].predname,res.dval);
			break;
			case RUL_STR :
			sprintf(resl[i],":%s:%s='%s';",
			 RS_PCBSUBJ,rulel[i].predname,res.sval);
			break;
			case RUL_NAME :
			default :
			resl[i]=res.sval;
			strlower(resl[i]);
			}
		}
	// Return rule list
	return(resl);
}

void creelem(int planddbclass,string fname,string ename)
/*
// Create a DDB file element
// Parameters :
//	int planddbclass	: Plan DDB class
//	string fname		: DDB file name
//	string ename		: Element name
*/
{
	// Perform the create element call
	bae_clriactqueue();
	bae_storemenuiact(1,planddbclass-100,LMB);
	bae_storetextiact(1,fname);
	bae_storetextiact(1,ename);
	if (bae_plannotsaved())
		bae_storetextiact(1,M_UINYES());
	bae_storetextiact(1,"5");
	bae_storetextiact(1,"5");
	bae_setintpar(22,1);
	call(MNU_GEDCREELEM);
	bae_setintpar(22,0);
}

void createpad()
/*
// Create pad from current pad definition
*/
{
	struct datades res		/* Result buffer */;
	string padname			/* Pad name buffer */;
	string padcomm			/* Pad comment buffer */;
	res=evalexpr(curpaddef.name,curpaddef.namen);
	padname=res.sval;
	strlower(padname);
	// Check if pad already exists
	if (curprocmode!=0 || existddbelem(ddbfname,DDBCLLPAD,padname)==1)
		return;
	if (curpaddef.commn!=0) {
		res=evalexpr(curpaddef.comm,curpaddef.commn);
		padcomm=res.sval;
		}
	else {
		padcomm="";
		}
	creelem(DDBCLLPAD,ddbfname,padname);
	if (padcomm!="")
		bae_setstrpar(0,padcomm);
	curpoly=curpaddef.poly;
	placepoly();
	// Shrink the workspace
	baewsshrink(1);
	// Save the pad element
	bae_clriactqueue();
	bae_setintpar(22,1);
	call(MNU_GEDSAVELEM);
	bae_setintpar(22,0);
}

void placepad()
/*
// Place the current pad
*/
{
	index L_FIGURE fig		/* Figure list index */;
	struct datades res		/* Result buffer */;
	string padname			/* Pad name */;
	double x, y			/* Coordinates */;
	double ang			/* Angle coordinates */;
	int i				/* Loop control variable */;
	// Get the pad name
	res=evalexpr(curpad.name,curpad.namen);
	padname=res.sval;
	// Get the pad layers
	curlayerl=curpad.layerl;
	curlayern=curpad.layern;
	// Check if standard layer
	if (curlayern==0) {
		curlayerl[0]=0;
		curlayern=1;
		}
	if (curpad.pn>0) {
		// Get the X coordinate
		res=evalexpr(curpad.pl[0].xl,curpad.pl[0].xn);
		x=res.dval;
		// Get the Y coordinate
		res=evalexpr(curpad.pl[0].yl,curpad.pl[0].yn);
		y=res.dval;
		}
	else {
		x=y=0.0;
		}
	if (curpad.angn>0) {
		res=evalexpr(curpad.ang,curpad.angn);
		ang=cvtangle(res.dval,1,0);
		}
	else {
		ang=0.0;
		}
	// Store pad(s)
	for (i=0;i<curlayern;i++) {
		if (ged_storeuref(padname,x,y,ang,curlayerl[i],curpad.mirr)) {
			sprintf(msg,ERRPLCPAD,synscanline(),padname);
			error(msg);
			}
		// Attach rule(s)
		if (curpad.rulen>0 && lay_lastfigelem(fig)==0 &&
		 lay_rulefigatt(fig,evalrules(curpad.rules,curpad.rulen)))
			rs_error(-1);
		}
}

void placepoly()
/*
// Place the current polygon
*/
{
	index L_FIGURE fig		/* Figure list index */;
	struct datades res		/* Result buffer */;
	double x, y			/* Point coordinates */;
	double x1, y1			/* First point coordinates */;
	int i1		= 1		/* First point index */;
	int mvis	= curpoly.mvis	/* Polygon mirror visibility */;
	int baseoff			/* Shape reference base offset */;
	int i, j			/* Loop control variables */;
	// Get the text layers
	curlayerl=curpoly.layerl;
	curlayern=curpoly.layern;
	curpointl=curpoly.pl;
	curpointn=curpoly.pn;
	// Check if standard layer
	if (curlayern==0) {
		curlayerl[0]=0;
		curlayern=1;
		}
	if (curpoly.sn) {
		baseoff=curparamn;
		// Store the polygon parameters
		for (i=0;i<curpoly.sn;i++)
			curparaml[curparamn+i]=
			 evalexpr(curpoly.sl[i].term,curpoly.sl[i].termn);
		curparamn+=curpoly.sn;
		pushparam();
		parambasel[parambasen-1]=baseoff;
		}
	// Store the polygon variables
	for (i=0;i<curpoly.vn;i++)
		curparaml[curparamn+i]=
		 evalexpr(curpoly.vl[i].term,curpoly.vl[i].termn);
	curparamn+=curpoly.vn;
	// Get the polygon points
	bae_clearpoints();
	for (i=0;i<curpointn;i++) {
		// Check if polygon start marker
		if (curpointl[i].typ>=3) {
			// Check if last polygon flush
			if (i!=0) {
				// Close shape
				if (curpoly.polyclose)
					bae_storepoint(x1,y1,0);
				// Store polygon(s)
				for (j=0;j<curlayern;j++) {
					if (ged_storepoly(curlayerl[j],
					 (curpoly.polytyp==L_POLYCOPPASS &&
					  curlayerl[j]>=DOCLAYBASE) ?
					  L_POLYDOCAREA : curpoly.polytyp,
					 "",mvis)) {
						sprintf(msg,ERRPLCPOLY,
						 synscanline());
						error(msg);
						}
					// Attach rule(s)
					if (curpoly.rulen>0 &&
					 lay_lastfigelem(fig)==0 &&
					 lay_rulefigatt(fig,evalrules(
					  curpoly.rules,curpoly.rulen)))
						rs_error(-1);
					}
				}
			bae_clearpoints();
			if (curpointl[i].typ&8)
				mvis=2;
			else if (curpointl[i].typ&4)
				mvis=1;
			else
				mvis=curpoly.mvis;
			i1=i+1;
			continue;
			}
		// Get the X coordinate
		res=evalexpr(curpointl[i].xl,curpointl[i].xn);
		x=res.dval;
		// Get the Y coordinate
		res=evalexpr(curpointl[i].yl,curpointl[i].yn);
		y=res.dval;
		// Store the point
		bae_storepoint(x,y,curpointl[i].typ);
		if (i==i1) {
			x1=x; y1=y;
			}
		}
	if (curpoly.sn)
		popparam();
}

void placetext()
/*
// Place the current text
*/
{
	index L_FIGURE fig		/* Figure list index */;
	struct datades res		/* Result buffer */;
	double x, y			/* Text coordinates */;
	double ang			/* Text angle */;
	double size			/* Text size */;
	int i				/* Loop control variable */;
	// Get the text layers
	curlayerl=curtext.layerl;
	curlayern=curtext.layern;
	// Check if standard layer
	if (curlayern==0) {
		curlayerl[0]=0;
		curlayern=1;
		}
	if (curtext.pn>0) {
		// Get the X coordinate
		res=evalexpr(curtext.pl[0].xl,curtext.pl[0].xn);
		x=res.dval;
		// Get the Y coordinate
		res=evalexpr(curtext.pl[0].yl,curtext.pl[0].yn);
		y=res.dval;
		}
	else {
		// Assume origin text
		x=y=0.0;
		}
	// Get text placement angle
	if (curtext.angn>0) {
		res=evalexpr(curtext.ang,curtext.angn);
		ang=cvtangle(res.dval,1,0);
		}
	else {
		// Assume horizontal text
		ang=0.0;
		}
	// Get text height
	res=evalexpr(curtext.size,curtext.sizen);
	size=res.dval;
	// Store text(s)
	for (i=0;i<curlayern;i++) {
		if (ged_storetext(
		 curtext.text,x,y,ang,size,curlayerl[i],curtext.mirr)) {
			sprintf(msg,ERRPLCTEXT,synscanline(),curtext.text);
			error(msg);
			}
		// Attach rule(s)
		if (curtext.rulen>0 && lay_lastfigelem(fig)==0 &&
		 lay_rulefigatt(fig,evalrules(curtext.rules,curtext.rulen)))
			rs_error(-1);
		}
}

void placedrill()
/*
// Place the current drill
*/
{
	index L_FIGURE fig		/* Figure list index */;
	struct datades res		/* Result buffer */;
	double x, y			/* Text coordinates */;
	double size			/* Text size */;
	if (curdrill.pn>0) {
		// Get the X coordinate
		res=evalexpr(curdrill.pl[0].xl,curdrill.pl[0].xn);
		x=res.dval;
		// Get the Y coordinate
		res=evalexpr(curdrill.pl[0].yl,curdrill.pl[0].yn);
		y=res.dval;
		}
	else {
		x=y=0.0;
		}
	res=evalexpr(curdrill.size,curdrill.sizen);
	size=res.dval;
	// Store drill
	if (ged_storedrill(x,y,size*0.5,curdrill.class)) {
		sprintf(msg,ERRPLCDRILL,synscanline());
		error(msg);
		}
	// Attach rule(s)
	if (curdrill.rulen>0 && lay_lastfigelem(fig)==0 &&
	 lay_rulefigatt(fig,evalrules(curdrill.rules,curdrill.rulen)))
		rs_error(-1);
}

void pushparam()
/*
// Push current parameter count on parameter base stack
*/
{
	parambasel[parambasen]=curparamn;
	parambasevl[parambasen]=curvarn;
	parambasepl[parambasen]=paramnamen;
	parambasen++;
}

void popparam()
/*
// Pop current parameter count from parameter base stack
*/
{
	parambasen--;
	curparamn=parambasel[parambasen];
	curvarn=parambasevl[parambasen];
	paramnamen=parambasepl[parambasen];
}

// User Language program end