/* SCM.ULH (SCM) -- User Language SCM/Schematic Editor Utilities */
/* SCM.ULH (SCM) -- User Language SCM/Schematic Editor 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 (100211) ENHANCEMENT:
//		Introduced function caploadlastcon.
//	rl (091020) RELEASED FOR BAE V7.4.
//	rl (081014) RELEASED FOR BAE V7.2.
//	rl (080904) ENHANCEMENT:
//		Introduced function polytypename.
//	rl (071029) RELEASED FOR BAE V7.0.
//	rl (060829) RELEASED FOR BAE V6.8.
//	rl (050906) RELEASED FOR BAE V6.6.
//	rl (040811) RELEASED FOR BAE V6.4.
//	rl (030904) RELEASED FOR BAE V6.2.
//	rl (021209) RELEASED FOR BAE V6.0.
//	rl (020723) CHANGE:
//		Added predicate assignment routines.
//	rl (020618) RELEASED FOR BAE V5.4.
//	rl (020319) ENHANCEMENT:
//		Introduced function capchkattrname.
//	rl (020207) BUGFIX:
//		Fixed problem with alternate rule database file name
//		specified by environment variable BAE_RULELIB.
//	rl (011005) BUGFIX:
//		Fixed problem with missing parameter of rsc_getplanrules.
//	mb (010914) CHANGE:
//		Redundant functions removed.
//	rl (010625) RELEASED FOR BAE V5.0.
//	rl (010605) ENHANCMENT:
//		Added connection rule utility functions.
//	rl (010314) ENHANCMENT:
//		Introduced spice rule definitions.
//	rl (000509) RELEASED FOR BAE V4.6.
//	rl (000315) ENHANCMENT:
//		Introduced rotation visibility definitions.
//	rl (990813) RELEASED FOR BAE V4.4.
//	rl (990506) ENHANCMENT:
//		Introduced Neural Rule System functions/definitions.
//	rl (981014) RELEASED FOR BAE V4.2.
//	rl (981014) ENHANCEMENT:
//		Introduced function capgetpname.
//	mb (970613) CHANGE:
//		Applied new UL system function ddbcopyelem.
//	mb (970611) CHANGE:
//		Applied new UL system function ddbcheck.
//	mb (970129) CHANGE:
//		Menu item number definitions moved to std.ulh.
//	mb (960917) RELEASED FOR BAE V3.4.
//	mb (95) RELEASED FOR BAE V3.2.
//	mb (94) RELEASED FOR BAE V3.0.
//	mb (94) ENHANCEMENT:
//		Introduced function capcopyelem.
//	mb (93) RELEASED FOR BAE V2.6.
//	mb (93) ORIGINAL CODING.
//
// DESCRIPTION
//
// The definitions and declarations from include file scm.ulh are
// compatible with the Schematic Editor User Language interpreter
// environment of the Bartels AutoEngineer. scm.ulh provides
// SCM utilities for data conversion, SCM workarea manipulation,
// SCM element copy, etc.
//
// FUNCTIONS
//
// SCM database element access:
//	capcopyelem -- Copy an SCM element with all references
//	capgetpname -- Get the layout part name for a given schematic part
//
// SCM layout netlist access:
//	caploadlastcon -- Load the last packager created project layout netlist
//
// SCM variant handling:
//	getactivevariant -- Get active variant
//	varcheck -- Abort function if variant active
//
// Polygon type handling:
//	cappolytypename -- Get polygon type name from type code
//
// Capture Rule System:
//   Rule System error handling:
//	rsc_error -- Issue Rule System error and optionally end program on error
//   Rule predicate assignments:
//	rsc_assconintpred -- Assign an integer predicate to a con. segment el.
//	rsc_asscondblpred -- Assign a float predicate to a con. segment elem.
//	rsc_assconstrpred -- Assign a string predicate to a con. segment elem.
//	rsc_assfigintpred -- Assign an integer predicate to a figure list el.
//	rsc_assfigdblpred -- Assign a float predicate to a figure list element
//	rsc_assfigstrpred -- Assign a string predicate to a figure list elem.
//	rsc_assplanintpred -- Assign an integer predicate to the whole plan
//	rsc_assplandblpred -- Assign a float predicate to the whole plan
//	rsc_assplanstrpred -- Assign a string predicate to the whole plan
//   Rule name query:
//	rsc_database -- Get the Rule System database path name
//	rsc_getconrules -- Get rules attached to specific connection segment
//	rsc_getfigrules -- Get rules attached to specific figure list element
//	rsc_getplanrules -- Get rules attached to current plan or all plans
//	rsc_getpoolrules -- Get rules attached to specific pool element
//	rsc_getrules -- Get rules stored to Rule System database
//	rsc_isconrule -- Check if specific rule is attached to con. segment
//	rsc_isfigrule -- Check if specific rule is attached to figure element
//	rsc_isplanrule -- Check if specific rule is attached to current plan
//	rsc_ispoolrule -- Check if specific rule is attached to pool element
//	rsc_isrule -- Test if specific rule is defined/available
//	rsc_selectrule -- Select a rule from the Rule System database
*/

// Avoid multiple inclusion
#ifndef INCLUDE_SCM
#define INCLUDE_SCM

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

// 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_OCSCMDB	3		// SCM database element/object
#define RS_OCCON	4		// Connection segment element/object

// Rule system names
#define RS_SCMSUBJ	"scm_rules"	// Rule system SCM subject name
#define RS_SYMSTART	"sym_start"	// Rule system sym. numb. start pred.
#define RS_SYMDOCU	"sym_docu"	// Rule system sym. documentation pred.
#define RS_GLUED	"glued"		// Glued element predicate
#define RS_CONMODE	"conmode"	// Rule system connectivity mode pred.
#define RS_BUSTAPMODE	"bustap_mode"	// Rule system bus tap mode pred.
#define RS_NAMELABEL	"name_label"	// Rule system name label predicate
#define RS_BUSFILL	"bus_fill"	// Rule system bus fill predicate
#define RS_AUTOBUS	"auto_bus_con"	// Rule system auto. bus con. predicate
#define RS_ROTVIS	"rot_vis"	// Rule system rot. vis. 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_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_PLOTTSFAC	"plottsfac"	// Rule system plot text size pred.
#define RS_PDFLAY	"pdf_layer"	// Rule system PDF layer predicate
#define RS_NETAREANSIZ	"netarea_namesize"
					// Rule system net area name size pred.
#define RS_VARIANT	"variant"	// Rule system variant predicate
#define RS_VARNAME	"variant_name"	// Rule system variant name predicate
#define RS_MAXVAR	"variant_max"	// Rule system var. max.num. predicate
#define RS_VARDOCVIS	"vardocvis"	// Rule system variant doc. vis. pred.
#define RS_VARPLOTDIS	"varplotdis_"	// Rule sys. variant plot. dis. pred.
#define RS_TXTCLASS	"text_class"	// Rule system text class pred.
#define RS_TXTCDIS	"text_class_dis"// Rule system text class dis. pred.
#define RS_PICKDIS	"picksel_dis"	// Rule sys. pick sel. dis. pred. name
#define RS_PINCON	"pin_con"	// Pin con. call predicate name
#define RS_PINMOVE	"pin_move"	// Pin movement allowed flag pred.
#define RS_PMARKPLT	"pin_marker_plot"
					// Pin marker plot pred. name
#define RS_PINDRC	"pin_drc"	// Pin DRC predicate name
#define RS_ATTADIS	"attr_assign_dis"// Rule system attr. ass. dis. pred.
#define RS_ATTVAR0	"attr_base_only"// Rule system attr. base only pred.
#define RS_INIVAL	"inival"	// Rule system attr. ini. val. pred.
#define RS_SPICEPINIDX	"spicepinidx"	// Rule system spice pin predicate
#define RS_SPICEMODEL	"spicemodel"	// Rule system spice model predicate
#define RS_GROUPNAME	"grpname"	// Rule system group name 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_PINTYPE	"pintype"	// Pin type predicate
#define RS_TNETAREA     "tag_netarea"	// Tag net area predicate
#define RS_FCTNAME	"fctname%d"	// Function name predicate
#define RS_FCTSEQ	"fctseq%d"	// Function call sequence predicate

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

// Text mode definitions
#define TEXTNORM	0x00		// Normal text mode
#define TEXTCOMM	0x01		// Commentary text mode
#define TEXTFRM1	0x02		// Frame 1 text mode
#define TEXTFRM2	0x04		// Frame 2 text mode
#define TEXTOFRM	0x08		// Open frame text mode
#define TEXTNROT	0x10		// No text rotation mode
#define TEXTHCENT	0x20		// Text horizontal center mode
#define TEXTVCENT	0x40		// Text vertical center mode
#define TEXTRIGHT	0x80		// Text right aligment mode
#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

// Symbol attribute set treatment flags
#define SYMATTSDEL	0x01		// Remove mode bit
#define SYMATTSDRW	0x02		// Redraw mode bit
#define SYMATTSSTD	(SYMATTSDEL|SYMATTSDRW)
					// Standard attribute set

/* Tag capable symbol pin types */
#define SYPSTD		0x00		// Standard symbol pin
#define SYPSYMTAG	0x01		// Tag referencing to a symbol
#define SYPPINTAG	0x02		// Tag referencing to a pin
#define SYPNETTAG	0x03		// Tag referencing to a net
#define SYPNPNTAG	0x04		// Tag referencing to a net pin
#define SYPNARTAG	0x05		// Tag referencing to a net area
#define SYPPARTAG	0x06		// Tag referencing to a part area

/* Layout netlist data variables */
#define GV_PACKSEC	"lc_psec"	// Layout connection packager run second
#define GV_PACKMIN	"lc_pmin"	// Layout connection packager run minute
#define GV_PACKHOUR	"lc_phour"	// Layout connection packager run hour
#define GV_PACKDAY	"lc_pday"	// Layout connection packager run day
#define GV_PACKMON	"lc_pmon"	// Layout connection packager run month
#define GV_PACKYEAR	"lc_pyear"	// Layout connection packager run year

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

/* Variant data */
int act_var				/* Active variant */;

//__________________________________________________________________
// SCM database element access

int capcopyelem(int class,
 string sfn,string dfn,string sen,string den,int mrgsrc)
/*
// Copy an SCM 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 C_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
	// 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 DDBCLSCM :
		case DDBCLSSYM :
		case DDBCLSLAB :
		case DDBCLSMRK :
		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 capgetpname(index C_FIGURE fig)
/*
// Get the layout part name for a given schematic part figure list element
// Return value :
//	Layout part name
// Parameters :
//	index C_FIGURE fig	: Figure list index
*/
{
	string pname;			// Part name
	// Check if valid symbol element
	if (fig.TYP!=C_FIGNREF || fig.NREF.MACRO.CLASS!=DDBCLSSYM)
		return("");
	// Query layout part name attribute
	if (cap_getpartattrib(fig.NAME,"$",pname)!=0 || pname=="")
		// Set default name
		pname=fig.NAME;
	// Return the part name
	return(pname);
}

//__________________________________________________________________
// SCM layout netlist access

int caploadlastcon()
/*
// Load the last packager created project layout netlist
// Return value :
//	zero if done or (-1) on error
*/
{
	string fname = bae_planfname()	/* Project file name */;
	string conname			/* Connection name */;
	string lfname = "?"		/* Last connection file name */;
	string lename = "?"		/* Last connection element name */;
	int lsec, lmin, lhour		/* Last connection creation time */;
	int lday, lmon, lyear		/* Last connection creation date */;
	int nsec, nmin, nhour		/* New connection creation time */;
	int nday, nmon, nyear		/* New connection creation date */;
	// Check the plan class
	if (bae_planddbclass()!=DDBCLSCM)
		return(-1);
	// Get the last packager created layout netlist data
	if ((conname=bae_getpacktime(0,0,0,0,0,0))=="")
		return(-1);
	if (ddbupdtime(fname,DDBCLPCON,
	 conname,nsec,nmin,nhour,nday,nmon,nyear)!=1) {
		nsec=nmin=nhour=nday=nmon=nyear=(-2);
		}
	if (varget(GV_PACKSEC,lsec))
		lsec=(-1);
	if (varget(GV_PACKMIN,lmin))
		lmin=(-1);
	if (varget(GV_PACKHOUR,lhour))
		lhour=(-1);
	if (varget(GV_PACKDAY,lday))
		lday=(-1);
	if (varget(GV_PACKMON,lmon))
		lmon=(-1);
	if (varget(GV_PACKYEAR,lyear))
		lyear=(-1);
	// Check if layout netlist already loaded
	if (cap_layconload(lfname,lename)==0 && lfname==fname &&
	 lename==conname && lsec==nsec && lmin==nmin && lhour==nhour &&
	 lday==nday && lmon==nmon && lyear==nyear)
		// Connection already loaded
		return(0);
	// Load the layout netlist
	if (cap_layconload(fname,conname))
		// Load failed
		return(-1);
	// Store packager date
	varset(GV_PACKSEC,nsec);
	varset(GV_PACKMIN,nmin);
	varset(GV_PACKHOUR,nhour);
	varset(GV_PACKDAY,nday);
	varset(GV_PACKMON,nmon);
	varset(GV_PACKYEAR,nyear);
	// Return without errors
	return(0);
}

//__________________________________________________________________
// SCM variant handling

void getactivevariant()
/*
// Get active variant
*/
{
	// Query the current active variant
	if (bae_planddbclass()!=DDBCLSCM ||
	 cap_rulequery(RS_OCSCMDB,0,RS_SCMSUBJ,RS_VARIANT,"?d",act_var)<1)
		// Set default variant
		act_var=0;
}

void varcheck()
/*
// Abort function if variant active
*/
{
	string ERRVARFUNC = M("Diese Funktion ist nur in der Basisvariante erlaubt!",
			      "Function only allowed in base variant edit mode!");
	int act_var			/* Active variant number */;
	// Query the current active variant
	if (cap_rulequery(RS_OCSCMDB,0,RS_SCMSUBJ,RS_VARIANT,
	 "?d",act_var)>0 && act_var>0)
		error(ERRVARFUNC);
}

//__________________________________________________________________
// Polygon type handling

string cappolytypename(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 ITMDOCLINE	= M("Grafik&linie"   ,"Graphic &Line");
	string ITMDOCAREA	= M("Grafik&flaeche" ,"Graphic &Area");
	string ITMCONAREA	= M("&Kontaktbereich","&Contact Area");
	string ITMDOTLINE	= M("&Punktlinie"    ,"&Dot Line");
	string ITMNETAREA	= M("&Netzbereich"   ,"&Net Area");
	string ITMUNDEF		= M("*** UNBEKANNT ***","*** UNKNOWN ***");
	// Test polygon type
	switch (typ) {
		case C_POLYDOCLINE : return(ITMDOCLINE);
		case C_POLYDOCAREA : return(ITMDOCAREA);
		case C_POLYCONAREA : return(ITMCONAREA);
		case C_POLYDOTLINE : return(ITMDOTLINE);
		case C_POLYNETAREA : return(ITMNETAREA);
		}
	// Unknown type
	return(ITMUNDEF);
}

//__________________________________________________________________
// Neural Rule System definitions/functions

// Initialyzers

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

// Rule System error handling

void rsc_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
	cap_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 rsc_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 rsc_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,rsc_database(),
	 DDBCLRULE,M("Regel ? ","Rule ? ")) ? "" : rn);
}

int rsc_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(rsc_database(),DDBCLRULE,rulename)==0 ||
	  (bae_planddbclass()!=DDBCLUNDEF &&
	   ddbcheck(bae_planfname(),DDBCLRULE,rulename)==0)));
}

int rsc_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=CINITSTRL();
	// Scan the Rule System database for rule definitions
	while (scanddbenames(rsc_database(),DDBCLRULE,rn)==1)
		// Store the rule name
		rl[rc++]=rn;
	// Return the rule count
	return(rc);
}

int rsc_getplanrules(STRINGS rl,int project)
/*
// Get rules attached to current plan
// Return value :
//	rule count
// Parameters :
//	STRINGS rl		: Rule name list
//	int project		: Global project rule flag
*/
{
	int rc;				// Rule count
	int i;				// Loop control variables
	// Get the rule count
	if ((rc=cap_getrulecnt(project ? RS_OCSCMDB : RS_OCPLAN,0))<0)
		// Issue other than no rules found errors
		rsc_error(0);
	// Get and store the rule names
	for (rl=CINITSTRL(),i=0;i<rc;i++)
		if (cap_getrulename(
		 project ? RS_OCSCMDB : RS_OCPLAN,0,i,rl[i]))
			rsc_error(0);
	// Return the rules count
	return(rc);
}

int rsc_getfigrules(index C_FIGURE fig,STRINGS rl)
/*
// Get rules attached to specific figure list element
// Return value :
//	rule count
// Parameters :
//	index C_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=cap_getrulecnt(RS_OCFIG,fig))<0)
		// Issue other than no rules found errors
		rsc_error(0);
	// Get and store the rule names
	for (rl=CINITSTRL(),i=0;i<rc;i++)
		if (cap_getrulename(RS_OCFIG,fig,i,rl[i]))
			rsc_error(0);
	// Return the rules count
	return(rc);
}

int rsc_getpoolrules(index C_POOL pool,STRINGS rl)
/*
// Get rules attached to specific pool element
// Return value :
//	rule count
// Parameters :
//	index C_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=cap_getrulecnt(RS_OCPOOL,pool))<0)
		// Issue other than no rules found errors
		rsc_error(0);
	// Get and store the rule names
	for (rl=CINITSTRL(),i=0;i<rc;i++)
		if (cap_getrulename(RS_OCPOOL,pool,i,rl[i]))
			rsc_error(0);
	// Return the rules count
	return(rc);
}

int rsc_getconrules(index C_CONSEG conseg,STRINGS rl)
/*
// Get rules attached to specific connection segment
// Return value :
//	rule count
// Parameters :
//	index C_CONSEG conseg	: Connection segment index
//	STRINGS rl		: Rule name list
*/
{
	int rc;				// Rule count
	int i;				// Loop control variables
	// Get the rule count
	if ((rc=cap_getrulecnt(RS_OCCON,conseg))<0)
		// Issue other than no rules found errors
		rsc_error(0);
	// Get and store the rule names
	for (rl=CINITSTRL(),i=0;i<rc;i++)
		if (cap_getrulename(RS_OCCON,conseg,i,rl[i]))
			rsc_error(0);
	// Return the rules count
	return(rc);
}

int rsc_isplanrule(string rulename,int project)
/*
// 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 project		: Global project rule flag
*/
{
	int rc;				// Rule count
	string rn;			// Rule name buffer
	int i;				// Loop control variable
	// Get the rule count
	if ((rc=cap_getrulecnt(project ? RS_OCSCMDB : RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rc;i++)
			if (cap_getrulename(
			  project ? RS_OCSCMDB : RS_OCPLAN,0,i,rn)==0
			 && rn==rulename)
				return(rsc_isrule(rulename) ? 1 : (-1));
	// Return the rule not attached code
	return(0);
}

int rsc_isfigrule(index C_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 C_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=cap_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rc;i++)
			if (cap_getrulename(RS_OCFIG,fig,i,rn)==0
			 && rn==rulename)
				return(rsc_isrule(rulename) ? 1 : (-1));
	// Return the rule not attached code
	return(0);
}

int rsc_ispoolrule(index C_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 C_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=cap_getrulecnt(RS_OCPOOL,pool))>0)
		// Scan the rule name list
		for (i=0;i<rc;i++)
			if (cap_getrulename(RS_OCPOOL,pool,i,rn)==0
			 && rn==rulename)
				return(rsc_isrule(rulename) ? 1 : (-1));
	// Return the rule not attached code
	return(0);
}

int rsc_isconrule(index C_CONSEG conseg,string rulename)
/*
// Check if specific rule is attached to connection segment
// Return value :
//	( 0) if not defined/attached,
//	( 1) if attached and defined/available,
//	(-1) if attached and undefined/unavailable
// Parameters :
//	index C_CONSEG conseg	: Connection segment 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=cap_getrulecnt(RS_OCCON,conseg))>0)
		// Scan the rule name list
		for (i=0;i<rc;i++)
			if (cap_getrulename(RS_OCCON,conseg,i,rn)==0
			 && rn==rulename)
				return(rsc_isrule(rulename) ? 1 : (-1));
	// Return the rule not attached code
	return(0);
}

void rsc_assconstrpred(
 index C_CONSEG conseg,string name,string val,string defval,string delpat)
/*
// Assign a string predicate to a specific figure list element
// Parameters :
//	index C_CONSEG conseg	: Connection segment index
//	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 crulel[]			/* Rule list */;
	int crulen			/* 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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	crulen=0;
	if ((rnc=cap_getrulecnt(RS_OCCON,conseg))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_getrulename(RS_OCCON,conseg,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				crulel[crulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		sprintf(crulel[crulen],"%s'%s';",pdefprefix,val);
		crulen++;
		}
	// Check if rules defined
	if (crulen) {
		// Attach rule(s)
		if (cap_ruleconatt(conseg,crulel))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_rulecondet(conseg))
			rsc_error(-1);
		}
}

void rsc_assconintpred(
 index C_CONSEG conseg,string name,int val,int defval,string delpat)
/*
// Assign an integer predicate to a specific figure list element
// Parameters :
//	index C_CONSEG conseg	: Connection segment 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 crulel[]			/* Rule list */;
	int crulen			/* 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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	crulen=0;
	if ((rnc=cap_getrulecnt(RS_OCCON,conseg))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_getrulename(RS_OCCON,conseg,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				crulel[crulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		sprintf(crulel[crulen],"%s%d;",pdefprefix,val);
		crulen++;
		}
	// Check if rules defined
	if (crulen) {
		// Attach rule(s)
		if (cap_ruleconatt(conseg,crulel))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_rulecondet(conseg))
			rsc_error(-1);
		}
}

void rsc_asscondblpred(
 index C_CONSEG conseg,string name,double val,double defval,string delpat)
/*
// Assign an float predicate to a specific figure list element
// Parameters :
//	index C_CONSEG conseg	: Connection segment 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 crulel[]			/* Rule list */;
	int crulen			/* 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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	crulen=0;
	if ((rnc=cap_getrulecnt(RS_OCCON,conseg))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_getrulename(RS_OCCON,conseg,i,rn)==0 &&
			 strextract(rn,0,pdefend)!=pdefprefix &&
			 (delpat=="" || !strmatch(rn,delpat)))
				// Store the rule name
				crulel[crulen++]=rn;
	// Check if non default predicate defined
	if (val!=defval) {
		// Define rule
		if (floor(val)==ceil(val))
			sprintf(crulel[crulen],"%s%.1f;",pdefprefix,val);
		else
			sprintf(crulel[crulen],"%s%.9g;",pdefprefix,val);
		crulen++;
		}
	// Check if rules defined
	if (crulen) {
		// Attach rule(s)
		if (cap_ruleconatt(conseg,crulel))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_rulecondet(conseg))
			rsc_error(-1);
		}
}

void rsc_assfigstrpred(
 index C_FIGURE fig,string name,string val,string defval,string delpat)
/*
// Assign a string predicate to a specific figure list element
// Parameters :
//	index C_FIGURE fig	: Figure list element index
//	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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	frulen=0;
	if ((rnc=cap_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_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 (cap_rulefigatt(fig,frulel))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_rulefigdet(fig))
			rsc_error(-1);
		}
	// Update rule dependant data of this element
	if (uliptype()==ULIPSCM)
		scm_drawelem(fig,4);
}

void rsc_assfigintpred(
 index C_FIGURE fig,string name,int val,int defval,string delpat)
/*
// Assign an integer predicate to a specific figure list element
// Parameters :
//	index C_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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	frulen=0;
	if ((rnc=cap_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_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 (cap_rulefigatt(fig,frulel))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_rulefigdet(fig))
			rsc_error(-1);
		}
	// Update rule dependant data of this element
	if (uliptype()==ULIPSCM)
		scm_drawelem(fig,4);
}

void rsc_assfigdblpred(
 index C_FIGURE fig,string name,double val,double defval,string delpat)
/*
// Assign an float predicate to a specific figure list element
// Parameters :
//	index C_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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	frulen=0;
	if ((rnc=cap_getrulecnt(RS_OCFIG,fig))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_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 (cap_rulefigatt(fig,frulel))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_rulefigdet(fig))
			rsc_error(-1);
		}
	// Update rule dependant data of this element
	if (uliptype()==ULIPSCM)
		scm_drawelem(fig,4);
}

void rsc_assplanstrpred(
 int prjflag,string name,string val,string defval,string delpat)
/*
// Assign a string predicate to a specific figure list element
// Parameters :
//	int prjflag		: Whole project flag
//	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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	prulen=0;
	if ((rnc=cap_getrulecnt(prjflag ? RS_OCSCMDB : RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_getrulename(
			  prjflag ? RS_OCSCMDB : 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 (cap_ruleplanatt(prulel,prjflag))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_ruleplandet(prjflag))
			rsc_error(-1);
		}
}

void rsc_assplanintpred(
 int prjflag,string name,int val,int defval,string delpat)
/*
// Assign an integer predicate to a specific figure list element
// Parameters :
//	int prjflag		: Whole project flag
//	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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	prulen=0;
	if ((rnc=cap_getrulecnt(prjflag ? RS_OCSCMDB : RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_getrulename(
			  prjflag ? RS_OCSCMDB : 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 (cap_ruleplanatt(prulel,prjflag))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_ruleplandet(prjflag))
			rsc_error(-1);
		}
}

void rsc_assplandblpred(
 int prjflag,string name,double val,double defval,string delpat)
/*
// Assign an float predicate to a specific figure list element
// Parameters :
//	int prjflag		: Whole project flag
//	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_SCMSUBJ,name);
	pdefend=strlen(pdefprefix)-1;
	// Get the rule count
	prulen=0;
	if ((rnc=cap_getrulecnt(prjflag ? RS_OCSCMDB : RS_OCPLAN,0))>0)
		// Scan the rule name list
		for (i=0;i<rnc;i++)
			// Get rule name, dismiss old predicate rule
			if (cap_getrulename(
			  prjflag ? RS_OCSCMDB : 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 (cap_ruleplanatt(prulel,prjflag))
			rsc_error(-1);
		}
	else {
		// Detach rule
		if (rnc!=0 && cap_ruleplandet(prjflag))
			rsc_error(-1);
		}
}

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

// Conditional file inclusion end
#endif	// INCLUDE_SCM

// User Language include file end