/* LAY.ULH (LAY) -- User Language Layout Utilities */
/* LAY.ULH (LAY) -- User Language Layout-Utilities */
/*
// Copyright (c) 1993-2013 Bartels System GmbH, Muenchen
// Author: Manfred Baumeister
// Changes History:
//	rl (131029) RELEASED FOR BAE V8.0.
//	rl (120427) RELEASED FOR BAE V7.8.
//	rl (101019) RELEASED FOR BAE V7.6.
//	rl (100325) ENHANCEMENT:
//		Introduced trclayer function.
//	rl (100319) ENHANCEMENT:
//		Introduced layerfadein function.
//	rl (091020) RELEASED FOR BAE V7.4.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (080430) ENHANCEMENT:
//		Introduced polytypecheck,polylaycheck,polylaytype functions.
//	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 (040314) ENHANCEMENT:
//		Introduced polytypename function.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (030227) CHANGE:
//		Added text mode definitions.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (020723) CHANGE:
//		Added predicate assignment routines.
//	rl (020717) CHANGE:
//		Added drill tool tolerance predicates.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (020207) BUGFIX:
//		Fixed problem with alternate rule database file name
//		specified by environment variable BAE_RULELIB.
//	mb (010914) CHANGE:
//		Redundant functions removed.
//	rl (010625) RELEASED FOR BAE V5.0.
//	rl (010606) CHANGE:
//		Added new DRC error marker definitions.
//	rl (010409) CHANGE:
//		Added connection part status bits definitions.
//	rl (000720) RELEASED FOR BAE V4.6.
//	rl (000720) CHANGE:
//		Added new drill class definitions.
//	rl (990813) RELEASED FOR BAE V4.4.
//	rl (980910) RELEASED FOR BAE V4.2.
//	mb (980710) ENHANCEMENT:
//		Dynamic multi-language support introduced.
//	rl (980420) CHANGE:
//		Rule system object class definitions
//		(#define RS_*) made public.
//	rl (970929) RELEASED FOR BAE V4.0.
//	mb (970613) CHANGE:
//		Applied new UL system function ddbcopyelem.
//	mb (970611) CHANGE:
//		Applied new UL system function ddbcheck.
//	mb (970117) ENHANCMENT:
//		Introduced Neural Rule System functions.
//	mb (960917) RELEASED FOR BAE V3.4.
//	mb (960304) BUGFIX:
//		Bugs fixed in angle and segmentlen functions.
//	mb (95) ENHANCEMENT:
//		Introduced function purelayername.
//	mb (95) RELEASED FOR BAE V3.2.
//	mb (941211) ENHANCEMENT:
//		Introduced function layername.
//	mb (94) RELEASED FOR BAE V3.0.
//	mb (94) ENHANCEMENT:
//		Introduced function laycopyelem.
//	mb (93) RELEASED FOR BAE V2.6.
//	mb (93) ORIGINAL CODING.
//
// DESCRIPTION
//
// The definitions and declarations from include file lay.ulh are
// compatible with the Layout Editor, the Neural Autorouter, and the
// CAM Processor User Language interpreter environments of the
// Bartels AutoEngineer. lay.ulh provides utilities for analytical geometry,
// layout element copy, layer name handling, etc. lay.ulh also provides
// utilities for accessing and applying the Bartels Rule System features
// within the BAE layout system.
//
// FUNCTIONS
//
// Analytic geometry:
//	angle -- Get the angle of a circle arc point
//	segmentlen -- Get the length of a polygon segment
//	coordmatch -- Check for coordinaten pair match with tolerance
//
// Layout database element access:
//	laycopyelem -- Copy a layout element with all references
//	laydefelemname -- Get default layout element name for given file
//
// Layout layer handling:
//	layername -- Get layer name from layer number
//	purelayername -- Get pure layer name
//	vislayer -- Check layer visibility
//	trclayer -- Get transformed layer code
//	layclass -- Get layer class bits for given layer
//	layerfadein -- Ensure given layer is visible
//
// Polygon type handling:
//	polytypename -- Get polygon type name from type code
//	polytypecheck -- Check if given polygon type allowed on current element
//	polylaycheck -- Check if given layer allowed for given polygon type
//	polylaytype -- Return ged_asklayer() layer type for given polygon type
//
// Layout Rule System:
//   Rule System error handling:
//	rs_error -- Issue Rule System error and optionally end program on error
//   Rule predicate assignments:
//	rs_assfigintpred -- Assign an integer predicate to a figure list elem.
//	rs_assfigdblpred -- Assign a float predicate to a figure list element
//	rs_assfigstrpred -- Assign a string predicate to a figure list element
//	rs_assplanintpred -- Assign an integer predicate to the whole plan
//	rs_assplandblpred -- Assign a float predicate to the whole plan
//	rs_assplanstrpred -- Assign a string predicate to the whole plan
//   Rule assignments:
//	rs_assfigrule -- Assign a rule to a figure list element
//	rs_assplanrule -- Assign a rule to the whole plan
//   Rule name query:
//	rs_database -- Get the Rule System database path name
//	rs_getfigrules -- Get rules attached to specific figure list element
//	rs_getplanrules -- Get rules attached to current plan
//	rs_getpoolrules -- Get rules attached to specific pool element
//	rs_getrules -- Get rules stored to Rule System database
//	rs_isfigrule -- Check if specific rule is attached to figure element
//	rs_isplanrule -- Check if specific rule is attached to current plan
//	rs_ispoolrule -- Check if specific rule is attached to pool element
//	rs_isrule -- Test if specific rule is defined/available
//	rs_selectrule -- Select a rule from the Rule System database
*/

// Avoid multiple inclusion
#ifndef INCLUDE_LAY
#define INCLUDE_LAY

// Includes
#include "std.ulh"			// User Language standard include

// Layer number definitions
#define LAYERINV	(-0x4000)	// Invalid layer code
#define LAYERALL	(-1)		// All signal layer
#define LAYERBRD	(-2)		// Board outline layer
#define LAYERINS	(-3)		// Insertion layer (old unused)
#define LAYERUNR	(-4)		// Unroutes layer
#define LAYERTOP	(-5)		// Top layer
#define LAYERBTW	(-6)		// Inside signal layer
#define LAYERDRL	(-7)		// Drill hole display item layer
#define LAYERWAR	(-8)		// Workarea display item layer
#define LAYERORG	(-9)		// Origin display item layer
#define LAYERERR	(-10)		// Error display item layer
#define LAYERHLG	(-11)		// Highlight display item layer
#define LAYERDRLD	(-12)		// Drill class '-' display item layer
#define LAYERDRLA	(-13)		// Drill class 'A' display item layer
#define LAYERDRLZ	(-38)		// Drill class 'Z' display item layer
#define LAYERCOMB	(-98)		// Combined output layer
#define SIGLAYMAX	100		// Maximum signal layer count
#define POWLAYMAX	12		// Maximum power layer count
#define DOCLAYMAX	100		// Maximum documentary layer count
#define POWLAYBASE	0x300		// Power layer base
#define DOCLAYBASE	0x400		// Documentary layer base
#define DOCLAYSHIFT	0x10		// Documentary layer shift
#define DOCLAYSMASK	0x0F		// Documentary layer side mask
#define DOCSIDEMAX	3		// Max. doc. layer side codes

/* Layer class definitions */
#define LTYPPURE	0x01		/* Pure signal layer */
#define LTYPSIG		0x02		/* Signal layer */
#define LTYPDOC		0x04		/* Documentary layer */
#define LTYPDOCSIG	0x08		/* Documentary or signal layer */
#define LTYPPOW		0x10		/* Power layer */

// Drill class definitions
#define DRLCLASSMAX	('Z'-'A'+1)	/* Maximum drill class */
#define DRLCMIRR	0x0080		// Drill class mirror flag
#define DRLCMASK1	0x001F		// First drill class mask
#define DRLCMASK2	0x1F00		// Second drill class mask
#define DRLCSHFT2	0x08		// Second drill class shift

// Documentary layer side item strings
#define DOCLAYSIDN	"(N)"
#define DOCLAYSID1	"(1)"
#define DOCLAYSID2	"(2)"
#define DOCLAYSIDB	"(B)"

// Coordinate compare definitions
#define SMALLCOORD	0.000001	// Small coordinate compare value

// Rule system object class codes
#define RS_OCINV	(-1)		// Invalid/unknown object
#define RS_OCPLAN	0		// Plan/current element/object
#define RS_OCFIG	1		// Figure list element/object
#define RS_OCPOOL	2		// Pool list element/object
#define RS_OCLAYS	3		// Layer stackup element/object

// Connection part status bits
#define CPART_PLC	0x01		// Connection part placed flag
#define CPART_SEL	0x02		// Connection part selection flag

// Figure list element range grid
#define RANGEGRID	0.000254	// Range base grid

// Layout DRC error marker types
#define DRC_ERRMCOP	1		// DRC copper distance violation
#define DRC_ERRMDOC	2		// DRC doc. forb. area violation
#define DRC_ERRMHGT	3		// DRC doc. forb. area height viol.
#define DRC_ERRMHFD	4		// DRC HF design rule violation
#define DRC_ERRMPOLY	5		// DRC dropped polygon marker
#define DRC_ERRMPDST	6		// DRC part distance marker
#define DRC_ERRMPSIDE	7		// DRC part plc. side violation
#define DRC_ERRMPHINT	8		// DRC fill polygon error hint
#define DRC_ERRMPMAC	9		// DRC wrong part macro
#define DRC_ERRMTDBL	10		// DRC double trace segment
#define DRC_ERRTMASK	0x00FFFF	// DRC error type mask
#define DRC_ERRCMASK	0x1E0000	// DRC error class mask
#define DRC_ERRHIDE	0x010000	// DRC error hide flag

/* Polygon sub types */
#define L_POLYFILLFA	0x01		// Copper fill forbidden area
#define L_POLYVIAFA	0x02		// Via forbidden area
#define L_POLYROUTFA	0x04		// Router forbidden area
#define L_POLYCROSSFA	0x08		// Cross check forbidden area
#define L_POLYFULLFA	0x10		// Full check forbidden area

#define L_POLYSOLIDCF	0x01		// Solid fill copper fill area
#define L_POLYHATCHCF	0x02		// Hatch copper fill area

#define L_POLYTRCBUS	0x01		// Trace bus anchor line

#define L_POLYFILLAL	0xF000		// Copper fill alt. layer area meta code

/* Polygon fill tree modes */
#define L_PFTREESTD	0		// Standard tree distance mode
#define L_PFTREEOFF	1		// Ignore tree distance mode

// Text modes
#define TEXTPHYS	0x0000		// Physical text mode
#define TEXTLOG		0x0001		// Logical text mode
#define TEXTNOROT	0x0002		// No rotate text mode
#define TEXTFRM1	0x0040		// Frame 1 text mode
#define TEXTFRM2	0x0080		// Frame 2 text mode
#define TEXTOFRM	0x0100		// Open frame text mode
#define TEXTHCENT	0x0200		// Text horizontal center mode
#define TEXTVCENT	0x0400		// Text vertical center mode
#define TEXTRIGHT	0x0800		// Text right aligment mode
#define TEXTOMSK	0x000F		// Text orientation mode mask
#define TEXTEMSK	0x0FC0		// Text extended modes mask
#define FRM1XOFF	6.0/32.0	// Frame 1 x relativ offset
#define FRM1YOFF	6.0/48.0	// Frame 1 y relativ offset
#define FRM2XOFF	12.0/32.0	// Frame 2 x relativ offset
#define FRM2YOFF	12.0/48.0	// Frame 2 y relativ offset

// Rule system names
#define RS_PCBSUBJ	"pcb_rules"	// Rule system PCB subject name
#define RS_EDITWIDE	"editwide"	// Rule system edit wide predicate
#define RS_PADFTDFLAG	"pad_ftdflag"	// Pad heat trap disable flag predicate
#define RS_PADHTWIDTH	"pad_htwidth"	// Pad heat trap width predicate
#define RS_PADAPLOT	"pad_allplot"	// Pad always plot predicate
#define RS_PSTKDDFLAG	"pstk_ddflag%d"	// Padstack doc. disable flag pred.
#define RS_PSTKMINW	"pstk_minwidth"	// Padstack min. trace width predicat.
#define RS_PSTKMAXW	"pstk_maxwidth"	// Padstack max. trace width predicate
#define RS_POLYDASH	"poly_dash"	// Rule system polygon dash predicate
#define RS_POLYDASHLEN	"poly_dashlen"	// Rule system poly. dash len. pred.
#define RS_POLYDASHSPC	"poly_dashspc"	// Rule system poly. dash space pred.
#define RS_POLYGRLCHK   "poly_gridlesscheck"
					// Polygon gridless check predicate
#define RS_POLYROUTBITM "poly_routbitmask"
					// Polygon router bit mask predicate
#define RS_POLYSUBTYPE	"poly_subtype"	// Polygon sub type predicate
#define RS_POLYGAPCOV	"poly_gapcover"	// Polygon gap cover predicate
#define RS_POLYFILLIS	"fill_isoldist"	// Copper fill isol. dist. predicate
#define RS_POLYFILLMA	"fill_minarea"	// Copper fill min. area size predicate
#define RS_POLYFILLTM	"fill_tracemode"// Copper fill trace mode predicate
#define RS_POLYFILLHT	"fill_htmode"	// Copper fill heat trap mode pred.
#define RS_POLYFILLHC	"fill_htcount"	// Copper fill heat trap cnt. pred.
#define RS_POLYFILLHW	"fill_htwidth"	// Copper fill isol. dist. predicate
#define RS_POLYFILLHI	"fill_htisol"	// Copper fill heat trap isol. pred.
#define RS_POLYFILLAA	"fill_aangmode"	// Copper fill acute ang. mode pred.
#define RS_POLYFILLDL	"fill_dstlay"	// Copper fill dest. layer predicate
#define RS_POLYFILLDT	"fill_dsttyp"	// Copper fill dest.poly type pred.
#define RS_POLYFILLDM	"fill_distmode"	// Copper fill tree dist.mode pred.
#define RS_POLYFILLPA	"fill_part"	// Copper fill tree part predicate
#define RS_POLYFILLPI	"fill_pin"	// Copper fill tree pin predicate
#define RS_POLYFILLPR	"fill_prio"	// Copper fill priority predicate
#define RS_ENVVAR	"envvar"	// Rule system text env. var. predicate
#define RS_PLOTWIDTH	"plotwidth"	// Rule system plot width predicate
#define RS_PLOTRGB	"plotrgb"	// Rule system plot color predicate
#define RS_PLOTFONT	"plotfont"	// Rule system plot font predicate
#define RS_PDFLAY	"pdf_layer"	// Rule system PDF layer predicate
#define RS_WRLATTR	"wrlattr"	// Rule system WRL predicate
#define RS_WRLSCALE	"wrlmodscale"	// Rule system WRL model scale pred.
#define RS_WRLHOFF	"wrlmodhoff"	// Rule sys. WRL model height off. pred.
#define RS_VARIANT	"variant"	// Rule system variant predicate
#define RS_VARNAME	"variant_name"	// Rule system variant name predicate
#define RS_VARDOCVIS	"vardocvis"	// Rule system variant doc. vis. pred.
#define RS_LLNVIS	"llnvis"	// Rule system $llname vis. predicate
#define RS_GLUED	"glued"		// Glued element predicate
#define RS_HEIGHT	"height"	// Rule system height predicate
#define RS_HEIGHTOFF	"heightoff"	// Rule system height offset predicate
#define RS_HEIGHTLIM	"heightlimit"	// Rule system height limit predicate
#define RS_HEIGHTPCB	"heightpcb"	// Height PCB thick. rel. predicate
#define RS_POLYPHIGN	"poly_pheightignore" // Polygon part height ignore pred.
#define RS_PARTDEFANG	"part_defangle"	// Part default angle predicate
#define RS_PARTDEFMIRR	"part_defmirr"	// Part default mirror. predicate
#define RS_PARTTYPE	"part_type"	// Part SMD/THT type predicate
#define RS_PARTTEXT	"textnr"	// Part manufacturing hint predicate
#define RS_PARTIDFMECH	"part_idfmechref" // Part IDF mechanical name predicate
#define RS_PARTIDFTYPE	"part_idfmechtyp" // Part IDF mechanical type predicate
#define RS_PARTODBPP	"part_odbppout"	// Part ODB++ output control predicate
#define RS_PHEIGHTOFF	"partheightoff"	// Rule system part height off pred.
#define RS_PARTDRCEXC	"partdrcexc"	// Rule system part DRC exclude pred.
#define RS_PARTDNAME	"partdistname"	// Rule system part DRC dst.name pred.
#define RS_PARTDVAL	"partdistvalue"	// Rule system part DRC dst.val. pred.
#define RS_PARTDOCU	"part_docu"	// Rule system part documentation pred.
#define RS_VIAPTRC	"viapad_trc"	// Via pad trace flag predicate
#define RS_PICKDIS	"picksel_dis"	// Pick sel. dis. pred. name
#define RS_PINMOVE	"pin_move"	// Pin movement allowed flag pred.
#define RS_REFRULE	"ref_rule"	// Rule system ref. rule name pred.
#define RS_DRLPOWLMASK	"drl_powlaymask"// Drill power layer mask predicate
#define RS_DRLHTMASK	"drl_htmask"	// Drl.pow.lay. heat trap mask pred.
#define RS_DRLTOLPOS	"drl_tolpos"	// Drill hole positive tolerance
#define RS_DRLTOLNEG	"drl_tolneg"	// Drill hole negative tolerance
#define RS_DRLCOMM	"drl_comment"	// Drill hole comment
#define RS_NETTYPE	"net_type"	// Net type predicate
#define RS_GRPDRCBLK	"net_drcblk"	// Net group DRC block predicate
#define RS_UNCONDRC	"uncon_drc"	// Unconnected items DRC mode predicate
#define RS_NCNETTYPE	"uncon_nettype"	// Uncon. items net type predicate
#define RS_DRCBLOCK	"drcblk"	// Element DRC parameter block pred.
#define RS_DRCBLOCKN	"drcblkname%d"	// DRC block name predicate
#define RS_ATTADIS	"attr_assign_dis"// Rule system attr. ass. dis. pred.
#define RS_INIVAL	"inival"	// Rule system attr. ini. val. pred.
#define RS_GROUPNAME	"grpname"	// Rule system group name predicate
#define RS_BUSTRCCNT	"bus_trccnt"	// Bus trace count
#define RS_BUSTRCSPC	"bus_trcspc"	// Bus trace spacing
#define RS_BUSTRCW	"bus_trcw"	// Bus trace width
#define RS_BUSTRCC	"bus_trcc"	// Bus trace corner mode
#define RS_FORCETCON	"trace_partcon"	// Trace part level con. predicate
#define RS_TRACEHT	"trace_ht"	// Heat trap trace predicate
#define RS_TSCWIDTH     "trc_shieldcover"
					// Trace shield cover width prd.
#define RS_TRCIMP	"trc_impedance"	// Trace impedance predicate
#define RS_TRCSKIPXS	"trc_skipxs%d"	// Trace length skip x start coord.pred.
#define RS_TRCSKIPYS	"trc_skipys%d"	// Trace length skip y start coord.pred.
#define RS_TRCSKIPXE	"trc_skipxe%d"	// Trace length skip x end coord. pred.
#define RS_TRCSKIPYE	"trc_skipye%d"	// Trace length skip y end coord. pred.
#define RS_LAYSCANIGN	"nolayerscan"	// Ignore for layer scan predicate
#define RS_PAIRSTK1	"pairstk1"	// 1st replacement padstack predicate
#define RS_PAIRSTK2	"pairstk2"	// 2nd replacement padstack predicate
#define RS_PAIRGRID	"pairgrid"	// Layer pair trace grid predicate
#define RS_LAYPAIR	"layer_pairs"	// Layer pairs predicate
#define RS_LAYSCODE	"laystack_code"	// Layer stackup layer code predicate
#define RS_LAYEPSR	"laystack_epsr"	// Layer stackup epsilon r predicate
#define RS_TANDELTA	"laystack_tand"	// Layer stackup tangens delta pred.
#define RS_LAYTHICK	"laystack_thick"// Layer stackup layer thickness pred.
#define RS_LAYISO	"laystack_iso"	// Layer stackup isolation predicate
#define RS_LAYSURFACE	"laystack_surf"	// Layer stackup surface type predicate
#define RS_LAYFILL	"laystack_fill"	// Layer stackup fill layer predicate
#define RS_LAYCOMMENT	"laystack_comm"	// Layer stackup comment predicate
#define RS_LAYMAT	"laystack_mat"	// Layer stackup material predicate
#define RS_LAYCORE	"laystack_core"	// Layer stackup core predicate
#define RS_LAYTOL	"laystack_tol"	// Layer stackup tolerance predicate
#define RS_PCBTHICK	"pcb_thick"	// PCB total thickness pred.

#define RS_VIACHKRANGE	"viachkrange"	// Via check grid range predicate
#define RS_VIAFILLNET	"viafillnet"	// Via fill net predicate
#define RS_AUTOKO	"autokeepout"	// Automatic keepout ID predicate
#define RS_MEASUREID	"measureid"	// Meas. element marker ID predicate
#define RS_MTEXTID	"mtextid"	// Multi line text ID predicate
#define RS_MTEXTROW	"mtextrow"	// Multi line text row predicate
#define RS_MTEXTCOL	"mtextcol"	// Multi line text column predicate
#define RS_MTEXTLS	"mtextls"	// Multi line text spacing predicate

#define RS_PARTNOMIRR	"part_nomirr"	// Part no mirror. predicate
#define RS_PARTPKGTYP	"spea_pkg_typ"	// Part Spea tester pack. type predicate

#define RS_FCTNAME	"fctname%d"	// Function name predicate
#define RS_FCTSEQ	"fctseq%d"	// Function call sequence predicate


//__________________________________________________________________
// Start library-specific source code
#ifndef USELIB
#ifndef LIBLAY

//__________________________________________________________________
// Analytic geometry

double angle(double cx,double cy,double x,double y)
/*
// Get the angle of a circle arc point
// Return value :
//	resulting angle value (in radians; 0..2*PI)
// Parameters :
//	double cx		: Circle center X coordinate
//	double cy		: Circle center Y coordinate
//	double x		: Circle arc point X coordinate
//	double y		: Circle arc point Y coordinate
*/
{
	double res;			// Result value
	// Get arc tangent of angle defined by circle point
	res=atan2(y-cy,x-cx);
	// Test the result
	if (res<0.0)
		// Get the "absolute" angle value
		res+=2.0*cvtangle(180.0,1,2);
	// Return the result value
	return(res);
}

double segmentlen(int pc,int t,double x,double y,
 int t1,double x1,double y1,int t2, double x2,double y2,int sc)
/*
// Get the length of a polygon segment
// Return value :
//	segment length in meter
// Parameters :
//	int pc			: Point counter
//	int t			: Current point type
//	double x		: Current point X coordinate
//	double y		: Current point Y coordinate
//	int t1			: Previous point type
//	double x1		: Previous point X coordinate
//	double y1		: Previous point Y coordinate
//	int t2			: Pre-previous point type
//	double x2		: Pre-previous point X coordinate
//	double y2		: Pre-previous point Y coordinate
//	int sc			: Segment count
*/
{
	double res;			// Result value
	// Test if segment not yet completed
	if (pc<2) {
		// Move current to previous point
		x1=x; y1=y; t1=t;
		// Return zero length
		return(0.0);
		}
	// Increment the segment count
	sc++;
	// Test if 2 point segment
	if (pc==2) {
		// Test on straight segment
		if (t==0) {
			// Get the straight segment length
			res=dist(x1,y1,x,y);
			// Move current to previous point
			x1=x; y1=y; t1=t;
			// Reset the point counter
			pc=1;
			// Return the result value
			return(res);
			}
		// Arc center assumed
		// Move previous to pre-previous point
		x2=x1; y2=y1; t2=t1;
		// Move current to previous point
		x1=x;  y1=y;  t1=t;
		// Return zero length
		return(0.0);
		}
	// Arc segment type assumed
	// Evaluate the center (previous) point type
	if (t1==1)
		// Left arc; get the arc length (current<-pre-previous)
		res=
		 arclen(dist(x1,y1,x,y),angle(x1,y1,x2,y2),angle(x1,y1,x,y));
	else if (t1==2)
		// Right arc; get the arc length (pre-previous<-current)
		res=
		 arclen(dist(x1,y1,x,y),angle(x1,y1,x,y),angle(x1,y1,x2,y2));
	// Move current to previous point
	t1=t; x1=x; y1=y;
	// Reset the point counter
	pc=1;
	// Return the result value
	return(res);
}

static double arclen(double r,double a1,double a2)
/*
// Get arc segment length by radius and start-/end-point angle
// Return value :
//	resulting arc segment length value
// Parameters :
//	double r		: Radius
//	double a1		: Start point angle (in radians)
//	double a2		: End point angle (in radians)
*/
{
	// Arc; "absolute" angle between start and end point
	double arc = a1<=a2 ? a2-a1 : 2.0*cvtangle(180.0,1,2)+a2-a1;
	// Get and return the arc segment length
	return(arc*r);
}

int coordmatch(double x1,double y1,double x2,double y2)
/*
// Coordinate pair match with tolerance
// Return value :
//	1 if match else zero
// Parameters :
//	double x1		: 1st point X coordinate
//	double y1		: 1st point Y coordinate
//	double x2		: 2nd point X coordinate
//	double y2		: 2nd point Y coordinate
*/
{
	return((fabs(x2-x1)<=SMALLCOORD && fabs(y2-y1)<=SMALLCOORD) ? 1 : 0);
}

//__________________________________________________________________
// Layout database element access

int laycopyelem(int class,
 string sfn,string dfn,string sen,string den,int mrgsrc)
/*
// Copy a layout element with all references
// Return value :
//	zero if done, ( 1) if macro missing, (-1) on error
// Parameters :
//	int class		: Element DDB class
//	string sfn		: Source file name
//	string dfn		: Destination file name
//	string sen		: Source element name
//	string den		: Destination element name
//	int mrgsrc		: Merge source flag
*/
{
#define BAKEXT		".bak"		// Backup file extension
	string bfn;			// Backup file name
	index L_MACRO mac;		// Macro index
	struct {			// Macro descriptor
		string n;		//  Macro name
		int c;			//  Macro class
		} macs[];		// Macro list
	int maccnt	= 0;		// Macro count
	int macmissing	= 0;		// Macro missing flag
	// Get the backup file name
	bfn=strextract(dfn,0,strlen(dfn)-5)+BAKEXT;
	// Check if UL system function can be used
	if (sen==den && sfn!=dfn) {
		// Copy element to backup file, ignore errors
		ddbcopyelem(dfn,bfn,class,sen,1);
		// Copy DDB element; return completion status
		return(ddbcopyelem(sfn,dfn,class,sen,mrgsrc)<0 ? (-1) : 0);
		}
	// Check the DDB plan class
	switch (class) {
		// Valid classes
		case DDBCLLAY :
		case DDBCLLPRT :
		case DDBCLLSTK :
		case DDBCLLPAD :
		break;
		// Invalid class
		default :
		return(-1);
		}
	// Test if copy must be done
	if (!mrgsrc && ddbcheck(dfn,class,den)==0 || dfn==sfn && den==sen)
		// Do not overcopy existing destination element
		return(0);
	// Copy element to backup file, ignore errors
	ddbcopyelem(dfn,bfn,class,den,1);
	// Copy (load & store) the element
	if (bae_loadelem(sfn,sen,class)==(-1) || bae_storeelem(dfn,den))
		// Copy error
		return(-1);
	// Test if equal files
	if (sfn==dfn)
		// Copy done
		return(0);
	// Get all macros
	forall (mac) {
		// Check if source element exists
		if (ddbcheck(sfn,mac.CLASS,mac.NAME)) {
			// Macro missing; continue
			macmissing=1;
			continue;
			}
		// Test if macro exists
		if (mrgsrc || ddbcheck(dfn,mac.CLASS,mac.NAME)) {
			// Store the macro
			macs[maccnt].c=mac.CLASS;
			macs[maccnt].n=mac.NAME;
			maccnt++;
			}
		}
	// Copy all macros
	while ((maccnt--)>0) {
		// Copy element to backup file, ignore errors
		ddbcopyelem(dfn,bfn,macs[maccnt].c,macs[maccnt].n,1);
		// Copy (load & store) the element
		if (bae_loadelem(sfn,macs[maccnt].n,macs[maccnt].c)==(-1)
		 || bae_storeelem(dfn,macs[maccnt].n))
			// Copy error
			return(-1);
		}
	// Return with macro missing flag
	return(macmissing);
}

string laydefelemname(string fn)
/*
// Get default layout element name for given file
// Return value :
//	Element name string
// Parameter :
//	string fn		: Project file name
*/
{
	string name			/* Name string */;
	char c				/* Character buffer */;
	int i				/* Loop control variable */;
	// Check if fix element name
	if (lay_defelemname()!="*")
		return(lay_defelemname());
	// Get file base name
	name=convstring(fn,2);
	// Restrict name length
	if (strlen(name)>MAXKEYLEN)
		name[MAXKEYLEN]='\0';
	// Convert to valid name
	strlower(name);
	for (i=0;(c=name[i])!='\0';i++)
		if (c==' ' || iscntrl(c))
			name[i]='_';
	// Return converted name
	return(name);
}

//__________________________________________________________________
// Polygon type handling

string polytypename(int typ)
/*
// Get polygon type name from type code
// Return value :
//	polygon type name string
// Parameter :
//	int typ			: Polygon type
*/
{
	// Polygon type item strings
	string ITMCOPPASS	= M("&Kupferflaeche"    ,"Passive &Copper Area");
	string ITMKEEPOUT	= M("&Sperrflaeche"     ,"&Keep Out Area");
	string ITMBRDOUT	= M("&Umrandung"        ,"&Board Outline");
	string ITMCOPACT	= M("&Potentialflaeche" ,"Active Co&pper Area");
	string ITMDOCLINE	= M("Dokumentar&linie"  ,"Documentary &Line");
	string ITMDOCAREA	= M("&Dokumentarflaeche","&Documentary Area");
	string ITMCOPFILL	= M("&Fuellbereich"     ,"Copper &Fill Area");
	string ITMHTCHCOP	= M("&Schraffurflaeche" ,"Copper &Hatch Area");
	string ITMSPPAREA	= M("Geteilte &Versorgungslage","&Split Power Plane Area");
	string ITMUNDEF		= M("*** UNBEKANNT ***","*** UNKNOWN ***");
	// Test polygon type
	switch (typ) {
		case L_POLYCOPPASS : return(ITMCOPPASS);
		case L_POLYKEEPOUT : return(ITMKEEPOUT);
		case L_POLYBRDOUT : return(ITMBRDOUT);
		case L_POLYCOPACT : return(ITMCOPACT);
		case L_POLYDOCLINE : return(ITMDOCLINE);
		case L_POLYDOCAREA : return(ITMDOCAREA);
		case L_POLYCOPFILL : return(ITMCOPFILL);
		case L_POLYHTCHCOP : return(ITMHTCHCOP);
		case L_POLYSPPAREA : return(ITMSPPAREA);
		}
	// Unknown type
	return(ITMUNDEF);
}

string purepolytypename(int typ)
/*
// Get pure polygon type name from type code
// Return value :
//	polygon type name string
// Parameter :
//	int typ			: Polygon type
*/
{
	// Remove menu item accelerators
	return(bae_plainmenutext(polytypename(typ)));
}

int polytypecheck(int typ)
/*
// Check if given polygon type is allowed on current element
// Return value :
//	zero if allowed, 1 if not allowed, 2 if board outline already placed
// Parameter :
//	int typ			: Polygon type
*/
{
	index L_POLY poly		/* Polygon index */;
	int ddbcl = bae_planddbclass()	/* Current DDB element class */;
	// Test polygon type
	switch (typ) {
		case L_POLYCOPPASS :
		return((ddbcl==DDBCLLAY || ddbcl==DDBCLLPRT ||
		 ddbcl==DDBCLLPAD) ? 0 : 1);
		case L_POLYKEEPOUT :
		return((ddbcl==DDBCLLAY || ddbcl==DDBCLLPRT ||
		 ddbcl==DDBCLLSTK) ? 0 : 1);
		case L_POLYBRDOUT :
		if (ddbcl!=DDBCLLAY)
			return(1);
		// Check if board outline already placed
		forall (poly) {
			if (poly.TYP==L_POLYBRDOUT)
				return(2);
			// Board outline is always the first polygon
			break;
			}
		return(0);
		case L_POLYCOPACT :
		return((ddbcl==DDBCLLAY || ddbcl==DDBCLLPRT ||
		 ddbcl==DDBCLLSTK) ? 0 : 1);
		case L_POLYDOCLINE :
		return(ddbcl!=DDBCLUNDEF ? 0 : 1);
		case L_POLYDOCAREA :
		return(ddbcl!=DDBCLUNDEF ? 0 : 1);
		case L_POLYCOPFILL :
		return((ddbcl==DDBCLLAY || ddbcl==DDBCLLPRT) ? 0 : 1);
		case L_POLYHTCHCOP :
		return(1);
		case L_POLYSPPAREA :
		return((ddbcl==DDBCLLAY || ddbcl==DDBCLLPRT ||
		 ddbcl==DDBCLLSTK) ? 0 : 1);
		case (-1) :
		return(0);
		}
	// Unknown type
	return(1);
}

int polylaycheck(int layer,int typ)
/*
// Check if given layer is allowed for given polygon type
// Return value :
//	zero if allowed, 1 if not allowed
// Parameter :
//	int layer		: Polygon layer
//	int typ			: Polygon type
*/
{
	int laytypclass = layclass(layer)
					/* Layer type class */;
	// First check if polygon type allowed at all on this level
	if (polytypecheck(typ)!=0)
		return(1);
	// Test polygon type
	switch (typ) {
		case L_POLYBRDOUT :
		return(layer==LAYERBRD ? 0 : 1);
		case L_POLYKEEPOUT :
		return((laytypclass&LTYPDOCSIG)!=0 ? 0 : 1);
		case L_POLYCOPPASS :
		return((laytypclass&LTYPSIG)!=0 ? 0 : 1);
		case L_POLYCOPACT :
		return((laytypclass&LTYPSIG)!=0 ? 0 : 1);
		case L_POLYDOCLINE :
		return((laytypclass&LTYPDOC)!=0 ? 0 : 1);
		case L_POLYDOCAREA :
		if (bae_swconfig(0)==BAE_HighEnd)
			return((laytypclass&LTYPDOCSIG)!=0 ? 0 : 1);
		return((laytypclass&LTYPDOC)!=0 ? 0 : 1);
		case L_POLYCOPFILL :
		return((laytypclass&LTYPDOCSIG)!=0 ? 0 : 1);
		case L_POLYHTCHCOP :
		return(1);
		case L_POLYSPPAREA :
		return((laytypclass&LTYPPOW)!=0 ? 0 : 1);
		}
	// Unknown type
	return(1);
}

int polylaytype(int typ)
/*
// Get ged_asklayer() layer type for given polygon type
// Return value :
//	layer type
// Parameter :
//	int typ			: Polygon type
*/
{
	// First check if polygon type allowed at all on this level
	if (polytypecheck(typ)!=0)
		return(-1);
	// Test polygon type
	switch (typ) {
		case L_POLYBRDOUT :
		return(-1);
		case L_POLYKEEPOUT :
		case L_POLYCOPFILL :
		return(0);
		case L_POLYCOPPASS :
		case L_POLYCOPACT :
		return(2);
		case L_POLYDOCLINE :
		return(3);
		case L_POLYDOCAREA :
		return(bae_swconfig(0)==BAE_HighEnd ? 0 : 3);
		case L_POLYHTCHCOP :
		return(-1);
		case L_POLYSPPAREA :
		return(6);
		case (-1) :
		return(0);
		}
	// Unknown type
	return(-1);
}

//__________________________________________________________________
// Layout layer handling

string layername(int layer)
/*
// Get layer name from layer number
// Return value :
//	layer name string or empty string if invalid layer number
// Parameter :
//	int layer		: Layer number
*/
{
#define DOCSIDEMASK	0x3		// Documentary layer side mask
	// Layout layer/display item strings
	string ITMLAYSIG	= M("Signallage "     ,"Signal Layer "     );
	string ITMLAYPOW	= M("Versorgungslage ","Power Layer "	   );
	string ITMLAYDOC	= M("Dokumentarlage " ,"Documentary Layer ");
	string ITMLAYALL	= M("Alle Lagen"      ,"All Layers"	   );
	string ITMLAYBRD	= M("Umrandung"       ,"Board Outline"	   );
	string ITMLAYINS	= M("Bestueckungslage","Insertion Layer"   );
	string ITMLAYUNR	= M("Unroutes"	      ,"Airlines"	   );
	string ITMLAYBTW	= M("Innenlagen"      ,"Inside Layers"	   );
	string ITMDSPDRL	= M("Bohrungen"       ,"Drill Holes"	   );
	string ITMDSPDRLD	= M("Bohrklasse '-'"  ,"Drill Class '-'"   );
	string ITMDSPDRLP	= M("Bohrklasse '%c'" ,"Drill Class '%c'"  );
	string ITMDSPWA		= M("Arbeitsbereich"  ,"Workarea"	   );
	string ITMDSPORG	= M("Nullpunkt"       ,"Origin"		   );
	string ITMDSPERR	= M("Fehler"	      ,"Error"		   );
	string ITMDSPHL		= M("Highlight"       ,"Highlight"	   );
	string ITMMLAY		= M("Mehrlagenplot"   ,"Multiple Layers"   );
	string ITMUNDEF	= M("*** UNDEFINIERT ***","*** UNDEFINED ***");
	index L_POWLAYER powlay;	// Power layer index
	string strbuf;			// String buffer
	int doclayer;			// Documentary layer number
	int powlayer;			// Documentary layer number
	// Test if documentary layer
	if (layer>=DOCLAYBASE
	 && (doclayer=((layer-DOCLAYBASE)/DOCLAYSHIFT))<DOCLAYMAX) {
		// Convert documentary layer side code to item string
		switch (layer&DOCSIDEMASK) {
			case (-1) : strbuf=DOCLAYSIDN; break;
			case 0    : strbuf=DOCLAYSID1; break;
			case 1    : strbuf=DOCLAYSID2; break;
			case 2    : strbuf=DOCLAYSIDB; break;
			default   : strbuf=ITMUNDEF; break;
			}
		// Get the full doc layer name and return it
		return(ITMLAYDOC+
		 bae_plainmenutext(lay_doclayname(doclayer))+" "+strbuf);
		}
	// Test if power layer
	if (layer>=POWLAYBASE && layer-POWLAYBASE<POWLAYMAX) {
		strbuf="";
		powlayer=POWLAYBASE;
		forall (powlay) {
			if (powlayer==layer) {
				if (powlay.CNET.NAME!="")
					return(ITMLAYPOW+
					 itoa(layer-POWLAYBASE+1)+" ("+
					 powlay.CNET.NAME+")");
				break;
				}
			powlayer++;
			}
		return(ITMLAYPOW+itoa(layer-POWLAYBASE+1));
		}
	// Test if signal layer
	if (layer>=0 && layer<SIGLAYMAX)
		return(ITMLAYSIG+itoa(layer+1));
	// Test if drill class
	if (layer>=(-38) && layer<(-12)) {
		sprintf(strbuf,ITMDSPDRLP,'A'-layer-13);
		return(strbuf);
		}
	// Test if special layer
	switch (layer) {
		case ( -1) : return(ITMLAYALL);
		case ( -2) : return(ITMLAYBRD);
		case ( -3) : return(ITMLAYINS);
		case ( -4) : return(ITMLAYUNR);
		case ( -5) : return(bae_plainmenutext(lay_toplayname()));
		case ( -6) : return(ITMLAYBTW);
		case ( -7) : return(ITMDSPDRL);
		case ( -8) : return(ITMDSPWA);
		case ( -9) : return(ITMDSPORG);
		case (-10) : return(ITMDSPERR);
		case (-11) : return(ITMDSPHL);
		case (-12) : return(ITMDSPDRLD);
		case (-98) : return(ITMMLAY);
		}
	// Invalid layer
	return(ITMUNDEF);
}

string purelayername(int layer)
/*
// Get pure layer name
// Return value :
//	layer name without documentary layer designator
// Parameter :
//	int layer		: Layer number
*/
{
	// Layout layer/display item strings
	string ITMLAYDOC	= M("Dokumentarlage " ,"Documentary Layer ");
	string lname;			// Layer name buffer
	// Get the layer name
	lname=layername(layer);
	// Test if documentary layer name
	if (strmatch(lname,ITMLAYDOC+"*"))
		// Strip documentary layer designator
		lname=strextract(lname,strlen(ITMLAYDOC),strlen(lname)-1);
	// Return the layer name
	return(lname);
}

int vislayer(int layer)
/*
// Check layer visibility
// Return value :
//	1 if layer visible else 0
// Parameter :
//	int layer		: Layer number
*/
{
	int color;			// Layer color code
	// Get the layer color
	color=bae_getcolor(layer);
	return((color<0 || (color&0x0F)==0x00) ? 0 : 1);
}

int trclayer(int layer)
/*
// Get transformed trace layer code
// Return value :
//	signal layer code
// Parameter :
//	int layer		: Trace layer number
*/
{
	// Transform top layer code
	return(layer==LAYERTOP ? lay_plantoplay() : layer);
}

int layclass(int layer)
/* Get layer class bits for given layer */
/* Returns : bit coded layer type code, zero if invalid layer */
/*
//	int layer			: Layer number
*/
{
	int doclaycode                  /* Documentary layer code */;
	int doclayside                  /* Documentary layer side */;
	int doclayidx                   /* Documentary layer index */;
	/* Check for pure signal layer */
	if (layer>=0 && layer<SIGLAYMAX)
		return(LTYPPURE|LTYPSIG|LTYPDOCSIG);
	/* Check for other signal layers */
	if (layer==LAYERTOP || layer==LAYERALL || layer==LAYERBTW)
		return(LTYPSIG|LTYPDOCSIG);
	/* Check for power layer */
	if (layer>=POWLAYBASE && layer<POWLAYBASE+POWLAYMAX)
		return(LTYPPOW);
	/* Get the documentary layer info. */
	doclayidx=layer-DOCLAYBASE;
	doclaycode=doclayidx>>DOCLAYSHIFT;
	doclayside=doclayidx&DOCLAYSMASK;
	/* Check for documentary layer */
	if (layer>=DOCLAYBASE &&
	doclaycode<DOCLAYMAX && doclayside<DOCSIDEMAX)
		return(LTYPDOC|LTYPDOCSIG);
	/* Invalid layer */
	return(0);
}

void layerfadein(int layer,int defcolor,int redraw)
/*
// Ensure given layer is visible
// Parameters :
//	int layer		: Layer code
//	int defcolor		: Default color code
//	int redraw		: Redraw flag
*/
{
	int oldcolor = bae_getcolor(layer)
					/* Old layer color value */;
	// Set default layer color if black
	if (oldcolor==0 || oldcolor==(-1))
		bae_setcolor(layer,defcolor);
	// Fade-in layer if cur. faded out
	else if (oldcolor<(-1))
		bae_setcolor(layer,-oldcolor-1);
	else
		// Layer already visible
		return;
	// Redraw screen
	if (redraw)
		screenredraw();
}

//__________________________________________________________________
// Neural Rule System definitions/functions

// Initialyzers

static STRINGS INITSTRL()
/*
// Initialyze string list
// Return value :
//	Initialyzed string list
*/
{
	STRINGS sl	= {""};		// Initialyzed string list
	// Return initialyzed string list
	return(sl);
}

// Rule System error handling

void rs_error(int igncode)
/*
// Issue Rule System error and optionally end program on error
// Parameters :
//	int igncode		: Ignorable error code
*/
{
	// Messages
	string RSERRPX	= M("Regelsystem Status %d : ",
			   "Rule System Status %d : ");
	string RSERRXXX	= M("Allgemeiner/interner Fehler!",
			    "Unknown/unspecified Rule System error!");
	string RSERR000	= M("Operation/Funktion erfolgreich beendet.",
			    "Operation completed without errors.");
	string RSERR001	= M("Zu wenig Hauptspeicher!","Out of memory!");
	string RSERR002	= M("Interner Fehler %s!","Internal error %s!");
	string RSERR003	= M("Ungueltiger Funktionsparameter!",
			    "Function parameter invalid!");
	string RSERR128	= M("Regeldatenbank kann nicht angelegt werden!",
			    "Rule database file create error!");
	string RSERR129	= M("Regeldatenbank Lese-/Schreibfehler!",
			    "Rule database file read/write error!");
	string RSERR130	= M("Regeldatenbank von falschem Typ!",
			    "Rule database file wrong type!");
	string RSERR131	= M("Regeldatenbankstruktur beschaedigt!",
			    "Rule database file structure bad!");
	string RSERR132	= M("Regeldatenbankdatei nicht gefunden!",
			    "Rule database file not found!");
	string RSERR133	= M("Regeldatenbank allgemeiner/interner Fehler!",
			    "Rule database unknown/internal error!");
	string RSERR134	= M("Regel '%s' nicht in Regeldatenbank gefunden!",
			    "Rule '%s' not found in rule database!");
	string RSERR135	= M("Ungueltiges Regelformat (Interner Fehler %s)!",
			    "Invalid rule format (internal error %s)!");
	string RSERR136	= M("Objekt nicht gefunden!","Object not found!");
	string RSERR137	= M("Objekt mehrfach definiert (Interner Fehler)!",
			    "Object double defined (internal error)!");
	string RSERR138	= M("Inkompatible Definition der Variablen '%s'!",
			    "Incompatible variable '%s' definition!");
	string RSERR139	= M(
	 "RULECOMP-Version/Regelkompilat '%s' inkompatibel!",
	 "RULECOMP version/rule compilation '%s' incompatible!");
	string RSABORT	= M("\nAbbruch ?","\nAbort ?");
	int errcode;			// Rule system error code
	string erritem;			// Rule system error item
	string errstr;			// Rule system error string
	string errfmt;			// Rule system error format
	// Get the error code and error item string
	lay_ruleerr(errcode,erritem);
	// Abort if ignorable error code
	if (errcode==0 || errcode==igncode)
		return;
	// Get the error code specific error format string
	switch (errcode) {
		case   0 : errfmt=RSERR000; break;
		case   1 : errfmt=RSERR001; break;
		case   2 : errfmt=RSERR002; break;
		case   3 : errfmt=RSERR003; break;
		case 128 : errfmt=RSERR128; break;
		case 129 : errfmt=RSERR129; break;
		case 130 : errfmt=RSERR130; break;
		case 131 : errfmt=RSERR131; break;
		case 132 : errfmt=RSERR132; break;
		case 133 : errfmt=RSERR133; break;
		case 134 : errfmt=RSERR134; break;
		case 135 : errfmt=RSERR135; break;
		case 136 : errfmt=RSERR136; break;
		case 137 : errfmt=RSERR137; break;
		case 138 : errfmt=RSERR138; break;
		case 139 : errfmt=RSERR139; break;
		default  : errfmt=RSERRXXX; break;
		}
	// Build the error message
	sprintf(errstr,RSERRPX+errfmt,errcode,erritem);
	// Display the error message and exit from program
	if (igncode<0 && bae_msgboxverify(errstr+RSABORT,"")!=1) {
		perror(errstr);
		return;
		}
	error(errstr);
}

// Rule name query

string rs_database()
/*
// Get the Rule System database path name
// Return value :
//	Rule System database path name
*/
{
	// Get and return the Rule System database path name
	return(strgetconffilename(RULEDBVNAME,RULEDBFNAME,1));
}

string rs_selectrule()
/*
// Select a rule from the Rule System database
// Return value :
//	rule name or empty string on abort
*/
{
	string rn	= "";		// Rule name buffer
	// Select and return rule name
	return(bae_askddbename(rn,rs_database(),
	 DDBCLRULE,M("Regel ? ","Rule ? ")) ? "" : rn);
}

int rs_isrule(string rulename)
/*
// Test if specific rule is defined/available
// Return value :
//	non-zero if rule defined/available, or zero else
// Parameters :
//	string rulename		: Rule name
*/
{
	// Perform rule exist check and return checking result
	return(rulename[0]==':' ? 1 :
	 (ddbcheck(rs_database(),DDBCLRULE,rulename)==0 ||
	  (bae_planddbclass()!=DDBCLUNDEF &&
	   ddbcheck(bae_planfname(),DDBCLRULE,rulename)==0)));
}

int rs_getrules(STRINGS rl)
/*
// Get rules stored to Rule System database
// Return value :
//	rule count
// Parameters :
//	STRINGS rl		: Rule name list
*/
{
	string rn	= "";		// Current rule name
	int rc		= 0;		// Rule count
	// Init the rule name list
	rl=INITSTRL();
	// Scan the Rule System database for rule definitions
	while (scanddbenames(rs_database(),DDBCLRULE,rn)==1)
		// Store the rule name
		rl[rc++]=rn;
	// Return the rule count
	return(rc);
}

int rs_getplanrules(STRINGS rl)
/*
// Get rules attached to current plan
// Return value :
//	rule count
// Parameters :
//	STRINGS rl		: Rule name list
*/
{
	int rc;				// Rule count
	int i;				// Loop control variables
	// Get the rule count
	if ((rc=lay_getrulecnt(RS_OCPLAN,0))<0)
		// Issue other than no rules found errors
		rs_error(0);
	// Get and store the rule names
	for (rl=INITSTRL(),i=0;i<rc;i++)
		if (lay_getrulename(RS_OCPLAN,0,i,rl[i]))
			rs_error(0);
	// Return the rules count
	return(rc);
}

int rs_getfigrules(index L_FIGURE fig,STRINGS rl)
/*
// Get rules attached to specific figure list element
// Return value :
//	rule count
// Parameters :
//	index L_FIGURE fig	: Figure list element index
//	STRINGS rl		: Rule name list
*/
{
	int rc;				// Rule count
	int i;				// Loop control variables
	// Get the rule count
	if ((rc=lay_getrulecnt(RS_OCFIG,fig))<0)
		// Issue other than no rules found errors
		rs_error(0);
	// Get and store the rule names
	for (rl=INITSTRL(),i=0;i<rc;i++)
		if (lay_getrulename(RS_OCFIG,fig,i,rl[i]))
			rs_error(0);
	// Return the rules count
	return(rc);
}

int rs_getpoolrules(index L_POOL pool,STRINGS rl)
/*
// Get rules attached to specific pool element
// Return value :
//	rule count
// Parameters :
//	index L_POOL pool	: Pool list element index
//	STRINGS rl		: Rule name list
*/
{
	int rc;				// Rule count
	int i;				// Loop control variables
	// Get the rule count
	if ((rc=lay_getrulecnt(RS_OCPOOL,pool))<0)
		// Issue other than no rules found errors
		rs_error(0);
	// Get and store the rule names
	for (rl=INITSTRL(),i=0;i<rc;i++)
		if (lay_getrulename(RS_OCPOOL,pool,i,rl[i]))
			rs_error(0);
	// Return the rules count
	return(rc);
}

int rs_isplanrule(string rulename)
/*
// Check if specific rule is attached to current plan
// Return value :
//	( 0) if not defined/attached,
//	( 1) if attached and defined/available,
//	(-1) if attached and undefined/unavailable
// Parameters :
//	string rulename		: Rule name
*/
{
	int rc;				// Rule count
	string rn;			// Rule name buffer
	int i;				// Loop control variable
	// Get the rule count
	if ((rc=lay_getrulecnt(RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rc;i++)
			if (lay_getrulename(RS_OCPLAN,0,i,rn)==0
			 && rn==rulename)
				return(rs_isrule(rulename) ? 1 : (-1));
	// Return the rule not attached code
	return(0);
}

int rs_isfigrule(index L_FIGURE fig,string rulename)
/*
// Check if specific rule is attached to figure element
// Return value :
//	( 0) if not defined/attached,
//	( 1) if attached and defined/available,
//	(-1) if attached and undefined/unavailable
// Parameters :
//	index L_FIGURE fig	: Figure list element index
//	string rulename		: Rule name
*/
{
	int rc;				// Rule count
	string rn;			// Rule name buffer
	int i;				// Loop control variable
	// Get the rule count
	if ((rc=lay_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rc;i++)
			if (lay_getrulename(RS_OCFIG,fig,i,rn)==0
			 && rn==rulename)
				return(rs_isrule(rulename) ? 1 : (-1));
	// Return the rule not attached code
	return(0);
}

int rs_ispoolrule(index L_POOL pool,string rulename)
/*
// Check if specific rule is attached to pool element
// Return value :
//	( 0) if not defined/attached,
//	( 1) if attached and defined/available,
//	(-1) if attached and undefined/unavailable
// Parameters :
//	index L_POOL pool	: Pool list element index
//	string rulename		: Rule name
*/
{
	int rc;				// Rule count
	string rn;			// Rule name buffer
	int i;				// Loop control variable
	// Get the rule count
	if ((rc=lay_getrulecnt(RS_OCPOOL,pool))>0)
		// Scan the rule name list
		for (i=0;i<rc;i++)
			if (lay_getrulename(RS_OCPOOL,pool,i,rn)==0
			 && rn==rulename)
				return(rs_isrule(rulename) ? 1 : (-1));
	// Return the rule not attached code
	return(0);
}

void rs_assfigstrpred(
 index L_FIGURE fig,string name,string val,string defval,string delpat)
/*
// Assign a string predicate to a specific figure list element
// Parameters :
//	index L_FIGURE fig	: Figure list element
//	string name		: Predicate name
//	string val		: Predicate value
//	string defval		: Predicat default value
//	string delpat		: Old rule deletion name pattern
*/
{
	string pdefprefix		/* Predicate def. prefix */;
	int pdefend			/* Predicate def. end */;
	string frulel[]			/* Rule list */;
	int frulen			/* Rule count */;
	string rn			/* Rule name buffer */;
	int rnc				/* Rule name count */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	frulen=0;
	if ((rnc=lay_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (lay_getrulename(RS_OCFIG,fig,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				frulel[frulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		sprintf(frulel[frulen],"%s'%s';",pdefprefix,val);
		frulen++;
		}
	// Check if rules defined
	if (frulen) {
		// Attach rule(s)
		if (lay_rulefigatt(fig,frulel))
			rs_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && lay_rulefigdet(fig))
			rs_error(-1);
		}
	// Update rule dependant data of this element
	if (uliptype()==ULIPGED)
		ged_drawelem(fig,4);
}

void rs_assfigintpred(
 index L_FIGURE fig,string name,int val,int defval,string delpat)
/*
// Assign an integer predicate to a specific figure list element
// Parameters :
//	index L_FIGURE fig	: Figure list element index
//	string name		: Predicate name
//	int val			: Predicate value
//	int defval		: Predicat default value
//	string delpat		: Old rule deletion name pattern
*/
{
	string pdefprefix		/* Predicate def. prefix */;
	int pdefend			/* Predicate def. end */;
	string frulel[]			/* Rule list */;
	int frulen			/* Rule count */;
	string rn			/* Rule name buffer */;
	int rnc				/* Rule name count */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	frulen=0;
	if ((rnc=lay_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (lay_getrulename(RS_OCFIG,fig,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				frulel[frulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		sprintf(frulel[frulen],"%s%d;",pdefprefix,val);
		frulen++;
		}
	// Check if rules defined
	if (frulen) {
		// Attach rule(s)
		if (lay_rulefigatt(fig,frulel))
			rs_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && lay_rulefigdet(fig))
			rs_error(-1);
		}
	// Update rule dependant data of this element
	if (uliptype()==ULIPGED)
		ged_drawelem(fig,4);
}

void rs_assfigdblpred(
 index L_FIGURE fig,string name,double val,double defval,string delpat)
/*
// Assign an float predicate to a specific figure list element
// Parameters :
//	index L_FIGURE fig	: Figure list element index
//	string name		: Predicate name
//	double val		: Predicate value
//	double defval		: Predicat default value
//	string delpat		: Old rule deletion name pattern
*/
{
	string pdefprefix		/* Predicate def. prefix */;
	int pdefend			/* Predicate def. end */;
	string frulel[]			/* Rule list */;
	int frulen			/* Rule count */;
	string rn			/* Rule name buffer */;
	int rnc				/* Rule name count */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	frulen=0;
	if ((rnc=lay_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (lay_getrulename(RS_OCFIG,fig,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				frulel[frulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		if (floor(val)==ceil(val))
			sprintf(frulel[frulen],"%s%.1f;",pdefprefix,val);
		else
			sprintf(frulel[frulen],"%s%.9g;",pdefprefix,val);
		frulen++;
		}
	// Check if rules defined
	if (frulen) {
		// Attach rule(s)
		if (lay_rulefigatt(fig,frulel))
			rs_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && lay_rulefigdet(fig))
			rs_error(-1);
		}
	// Update rule dependant data of this element
	if (uliptype()==ULIPGED)
		ged_drawelem(fig,4);
}

void rs_assplanstrpred(string name,string val,string defval,string delpat)
/*
// Assign a string predicate to the whole plan
// Parameters :
//	string name		: Predicate name
//	string val		: Predicate value
//	string defval		: Predicat default value
//	string delpat		: Old rule deletion name pattern
*/
{
	string pdefprefix		/* Predicate def. prefix */;
	int pdefend			/* Predicate def. end */;
	string prulel[]			/* Rule list */;
	int prulen			/* Rule count */;
	string rn			/* Rule name buffer */;
	int rnc				/* Rule name count */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	prulen=0;
	if ((rnc=lay_getrulecnt(RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (lay_getrulename(RS_OCPLAN,0,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				prulel[prulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		sprintf(prulel[prulen],"%s'%s';",pdefprefix,val);
		prulen++;
		}
	// Check if rules defined
	if (prulen) {
		// Attach rule(s)
		if (lay_ruleplanatt(prulel))
			rs_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && lay_ruleplandet())
			rs_error(-1);
		}
}

void rs_assplanintpred(string name,int val,int defval,string delpat)
/*
// Assign an integer predicate to the whole plan
// Parameters :
//	string name		: Predicate name
//	int val			: Predicate value
//	int defval		: Predicat default value
//	string delpat		: Old rule deletion name pattern
*/
{
	string pdefprefix		/* Predicate def. prefix */;
	int pdefend			/* Predicate def. end */;
	string prulel[]			/* Rule list */;
	int prulen			/* Rule count */;
	string rn			/* Rule name buffer */;
	int rnc				/* Rule name count */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	prulen=0;
	if ((rnc=lay_getrulecnt(RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (lay_getrulename(RS_OCPLAN,0,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				prulel[prulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		sprintf(prulel[prulen],"%s%d;",pdefprefix,val);
		prulen++;
		}
	// Check if rules defined
	if (prulen) {
		// Attach rule(s)
		if (lay_ruleplanatt(prulel))
			rs_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && lay_ruleplandet())
			rs_error(-1);
		}
}

void rs_assplandblpred(string name,double val,double defval,string delpat)
/*
// Assign an float predicate to the whole plan
// Parameters :
//	string name		: Predicate name
//	double val		: Predicate value
//	double defval		: Predicat default value
//	string delpat		: Old rule deletion name pattern
*/
{
	string pdefprefix		/* Predicate def. prefix */;
	int pdefend			/* Predicate def. end */;
	string prulel[]			/* Rule list */;
	int prulen			/* Rule count */;
	string rn			/* Rule name buffer */;
	int rnc				/* Rule name count */;
	int i				/* Loop control variable */;
	// Get predicate rule definition prefix
	sprintf(pdefprefix,":%s:%s=",RS_PCBSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	prulen=0;
	if ((rnc=lay_getrulecnt(RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (lay_getrulename(RS_OCPLAN,0,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				prulel[prulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		if (floor(val)==ceil(val))
			sprintf(prulel[prulen],"%s%.1f;",pdefprefix,val);
		else
			sprintf(prulel[prulen],"%s%.9g;",pdefprefix,val);
		prulen++;
		}
	// Check if rules defined
	if (prulen) {
		// Attach rule(s)
		if (lay_ruleplanatt(prulel))
			rs_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && lay_ruleplandet())
			rs_error(-1);
		}
}

void rs_assfigrule(index L_FIGURE fig,string name)
/*
// Assign a rule to a specific figure list element
// Parameters :
//	index L_FIGURE fig	: Figure list element
//	string name		: Rule name
*/
{
	string frulel[]			/* Rule list */;
	int frulen			/* Rule count */;
	string rn			/* Rule name buffer */;
	int rnc				/* Rule name count */;
	int i				/* Loop control variable */;
	// Get the rule count
	frulen=0;
	if ((rnc=lay_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (lay_getrulename(RS_OCFIG,fig,i,rn)==0 && rn!=name)
				// Store the rule name
				frulel[frulen++]=rn;
	// Append rule
	frulel[frulen]=name;
	frulen++;
	// Attach rule(s)
	if (lay_rulefigatt(fig,frulel))
		rs_error(-1);
}

void rs_assplanrule(string name)
/*
// Assign a rule to the whole plan
// Parameter :
//	string name		: Rule name
*/
{
	string prulel[]			/* Rule list */;
	int prulen			/* Rule count */;
	string rn			/* Rule name buffer */;
	int rnc				/* Rule name count */;
	int i				/* Loop control variable */;
	// Get the rule count
	prulen=0;
	if ((rnc=lay_getrulecnt(RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (lay_getrulename(RS_OCPLAN,0,i,rn)==0 && rn!=name)
				// Store the rule name
				prulel[prulen++]=rn;
	// Append rule
	prulel[prulen]=name;
	prulen++;
	// Attach rule(s)
	if (lay_ruleplanatt(prulel))
		rs_error(-1);
}

//__________________________________________________________________
// End library-specific source code
#endif	// LIBLAY
#endif	// USELIB

// Conditional file inclusion end
#endif	// INCLUDE_LAY

// User Language include file end