|
|
This section describes (in alphabetical order) the standard system functions of the
Bartels User Language. See
Appendix C.1 for function description notations.
abs - Absolute value of an integer (STD)
Synopsis
int abs( // Returns result value
int; // Input integer value
);
Description
The
abs function calculates and returns the absolute value of the given integer value.
acos - Arc cosine (STD)
Synopsis
double acos( // Returns result value (STD3)
double [-1.0,1.0]; // Input cosine value
);
Description
The
acos function calculates and returns the arc cosine value of the given double value. The resulting angle value is in radians.
angclass - Classify an angle value (STD)
Synopsis
int angclass( // Returns angle class code
double; // Input angle value (STD3)
);
Description
The
angclass function determines and returns a class code for the given angle value. Possible return values are 0 for 0 degree angle, 1 for 90 degree angle, 2 for 180 degree angle, 3 for 270 degree angle or (-1) for other angle values. The input angle value must be in radians.
arylength - Get array length (STD)
Synopsis
int arylength( // Returns array element count
void; // Any input value
);
Description
The
arylength function returns the array element count for the given (array) input value.
asin - Arc sine (STD)
Synopsis
double asin( // Returns result value (STD3)
double [-1.0,1.0]; // Input sine value
);
Description
The
asin function calculates and returns the arc sine value of the given double value. The resulting angle value is in radians.
askcoord - Interactive X/Y coordinate value query (STD)
Synopsis
int askcoord( // Returns status
& double; // Returns X coordinate value (STD2)
& double; // Returns Y coordinate value (STD2)
int [0,1]; // Input mode:
// 0 = Coordinates relative to last position
// 1 = Coordinates absolute
);
Description
The
askcoord function activates a dialog X and Y coordinate value input. The input mode specifies whether absolute
() or relative
() coordinates are to be queried. The user input is returned with the first two function parameters. For absolute coordinate queries, these parameters are also input parameters for preset coordinate values. The function returns zero if the query was successful or nonzero if the query was aborted.
askdbl - Interactive double value query (STD)
Synopsis
int askdbl( // Returns status
& double; // Returns double value
string; // Prompt string
int; // Maximum input string length
);
Description
The
askdbl function asks the user for a double value, indicating the required interaction with the given prompt string. The user input double value is returned with the first parameter. The function return value is nonzero, if an invalid input value has been specified.
askdist - Interactive distance value query (STD)
Synopsis
int askdist( // Returns status
// -1 = Eingabe ungültig/abgebrochen
// 0 = Valid distance input value entered
// 1 = Valid distance input value entered,
// corner button pressed
& double; // Returns distance value
string; // Prompt string
int [0,15]; // Input control:
// 1 = Negative input allowed
// 2 = Circular input allowed
// 4 = String item prompt message
// 8 = Round corner button
);
Description
The
askdist function asks the user for a distance value, indicating the required interaction with the given prompt string. The third parameter determines the type of valid inputs. The user input value is interpreted in default user units, and is returned with the first parameter. The function returns zero for valid distance value inputs, 1 for valid distance value inputs with corner button pressed, or (-1) for invalid inputs or if the input function was aborted.
askint - Interactive integer value query (STD)
Synopsis
int askint( // Returns status
& int; // Returns integer value
string; // Prompt string
int; // Maximum input number length
);
Description
The
askint function asks the user for an integer value, indicating the required interaction with the given prompt string. The user input integer value is returned with the first parameter. The function returns nonzero if an invalid input value has been specified.
askstr - Interactive string value query (STD)
Synopsis
string askstr( // Returns string
string; // Prompt string
int; // Maximum input string length
);
Description
The
askstr function asks the user for a string value, indicating the required interaction with the given prompt string. The user input string value is passed with the function return value.
atan - Arc tangent (STD)
Synopsis
double atan( // Returns result value
double; // Input angle value (STD3)
);
Description
The
atan function calculates and returns the arc tangent value of the given angle value. The input angle value must be in radians.
atan2 - Arc tangent of the angle defined by a point (STD)
Synopsis
double atan2( // Returns result value (STD3)
double; // Input point Y coordinate
double; // Input point X coordinate
);
Description
The
atan2 function calculates and returns the arc tangent value of the angle defined by the given input point coordinates (and the origin point). The resulting angle value is in radians.
atof - Convert string to floating point value (STD)
Synopsis
double atof( // Returns floating point value
string; // Input string
);
Description
The
atof function converts and returns the double value represented by the given string value. The result is undefined if the double value cannot be represented.
atoi - Convert string to integer value (STD)
Synopsis
int atoi( // Returns integer value
string; // Input string
);
Description
The
atoi function converts and returns the integer value represented by the given string value. The result is undefined if the integer value cannot be represented.
bae_askddbename - Interactive DDB element name query (STD)
Synopsis
int bae_askddbename( // Returns status
& string; // Returns element name
string; // DDB file name
int ]0,[; // DDB element class (STD1)
string; // Prompt string
// empty string: Standard file dialog
// ! prefix: Save file dialog
// otherwise: Load file dialog
);
Description
The
bae_askddbename function allows the user to select a DDB element name by either keyboard input or mouse-selection in a request popup window showing the list of available elements. If the prompt string is an empty string the function uses the standard prompt for DDB element name queries. Any name passed with the first parameter is used as default element name selection. I.e., an empty string must be passed to the first parameter if no default element name is required and/or allowed. The function returns nonzero if no valid element name was selected or zero otherwise.
bae_askddbfname - Interactive DDB file name query (STD)
Synopsis
int bae_askddbfname( // Returns status
& string; // Returns file name
int [0,1]; // Existence check
int [0,3]; // File name dialog mode (bit flags):
// 1 = Check if file exists
// 2 = specified file name is default
string; // Prompt string
// empty string: Standard file dialog
// ! prefix: Save file dialog
// otherwise: Load file dialog
);
Description
The
bae_askddbfname function allows the user to select a DDB file name by either keyboard input or mouse-selection in a request popup window showing the list of available DDB files. The standard BAE DDB file name prompt is used if an empty prompt string is specified. A file save dialog is activated instead of a file open dialog if the first character of the file name prompt string is an exclamation mark
(!), i.e., the exclamation mark is faded out and the confirmation button of the Windows file name dialog changes from
to
. The function returns nonzero if no valid file name was selected and/or existence check is nonzero and the file doesn't exist or zero otherwise.
bae_askdirname - Interactive directory name query (STD)
Synopsis
int bae_askdirname( // Returns status
& string; // Returns directory name
string; // Directory name for scan start
string; // Prompt string
);
Description
The
bae_askdirname function allows the user to select a directory name by either keyboard input or mouse-selection in a request popup window showing the list of available directories. The directory name for scan start specifies the top level directory for the popup window directory selection display. If the prompt string is an empty string the function uses the standard prompt for directory name queries. The function returns nonzero if no valid directory name was selected or zero otherwise.
bae_askfilename - Interactive file name query (STD)
Synopsis
int bae_askfilename( // Returns status
& string; // Returns file name
string; // File name extension string
string; // Prompt string
// empty string: Standard file dialog
// ! prefix: Save file dialog
// otherwise: Load file dialog
);
Description
The
bae_askfilename function allows the user to select a file name by either keyboard input or mouse-selection in a popup window showing the list of available files. The file name extension string can be used to set a file name extension filter. On empty string input, all files are scanned/displayed. On extension specification (e.g.,
.ddb,
.dat,
.txt,
.,
.*, etc.), only those files matching the extension are scanned and/or displayed. The
- tag works for file name exclusion. On
- input all files matching BAE system or data file extensions
(.ass,
.con,
.ddb,
.def,
.exe,
.fre,
.ulc and
.usf, respectively) are faded-out from display (this feature can be used for output/plot file queries where system/library/project files must not be selected). The standard BAE file name prompt is used if an empty prompt string is specified. A file save dialog is activated instead of a file open dialog if the first character of the file name prompt string is an exclamation mark
(!), i.e., the exclamation mark is faded out and the confirmation button of the Windows file name dialog changes from
to
. The function returns nonzero if no valid file name was selected or zero otherwise.
bae_askmenu - Interactive BAE menu query (STD)
Synopsis
int bae_askmenu( // Returns selected menu item index (0..49),
// or (-1) on menu selection abort
int [1,50]; // Menu item count
string; // First menu item string
[] // Subsequent menu item strings
);
Description
The
bae_askmenu function activates a user-specific menu with up to 48 mouse-selectable menu items. The function returns the number of the selected menu item or (-1) if the menu selection was aborted. Menu item numbering starts at 0.
See also
Function bae_defmenusel.
bae_askname - Activate BAE name selection dialog (STD)
Synopsis
int bae_askname( // Status
& string; // Returns selected name
string; // Prompt string (or empty string)
int; // Maximum input string length
);
Description
The
bae_askname function activates a dialog for selecting a name from the name list which is currently defined with the
bae_nameadd function.
The second parameter specifies a non-standard input prompt. The system uses a predefined standard prompt if an empty string is passed as prompt string.
The third parameter sets the maximum user input string length.
The selected name is returned through the first parameter.
The function returns zero if a name was selected or nonzero if the function was aborted without valid name selection.
See also
Functions bae_nameadd,
bae_nameclr,
bae_nameget.
bae_asksymname - Interactive BAE library element query (STD)
Synopsis
int bae_asksymname( // Returns status
& string; // Returns library element name
& string; // Returns DDB library file name
int ]0,[; // Database class (STD1)
string; // Library file directory
string; // Default library path name
string; // Default symbol/element name
);
Description
The
bae_asksymname function activates a dialog for selecting a library element of the specified database class from a selectable library file. The function returns zero if a library element was successfully selected or non-zero if the user aborted the dialog without valid element selection.
bae_callmenu - BAE menu function call (STD)
Synopsis
int bae_callmenu( // Returns status
int [0,9999]; // Menu function number (STD4)
);
Description
The
bae_callmenu function calls the specified BAE menu function passing the interactions defined with the
bae_store*iact functions. The function returns nonzero on menu function errors or invalid menu function numbers.
bae_charsize - Get BAE text/character dimensions (STD)
Synopsis
void bae_charsize(
& double; // Returns character width (pixels)
& double; // Returns character height (pixels)
);
Description
The
bae_charsize function determines the current BAE character dimensions and returns the corresponding pixel values with its parameters.
bae_cleardistpoly - Clear internal BAE distance query polygon (STD)
Synopsis
void bae_cleardistpoly(
);
Description
The
bae_cleardistpoly function deletes the internal distance query polygon created with the
bae_storedistpoly function.
See also
Functions
bae_storedistpoly.
bae_clearpoints - Clear internal BAE polygon buffer (STD)
Synopsis
void bae_clearpoints(
);
Description
The
bae_clearpoints function deletes the internally stored polygon point list. This function should be called before the first
bae_storepoint call to delete previously stored points.
See also
Functions
bae_getpolyrange,
bae_storedistpoly,
bae_storepoint.
bae_clriactqueue - Clear the BAE interaction queue (STD)
Synopsis
void bae_clriactqueue(
);
Description
The
bae_clriactqueue function deletes all interactions stored in the interaction queue. The interaction queue is used for passing interactions to the BAE menu functions activated through
bae_callmenu.
bae_crossarcarc - Determine cross point(s) of two arcs (STD)
Synopsis
int bae_crossarcarc( // Crosspoint count
double; // Arc 1 start point X coordinate (STD2)
double; // Arc 1 start point Y coordinate (STD2)
double; // Arc 1 center point X coordinate (STD2)
double; // Arc 1 center point Y coordinate (STD2)
int [1,2]; // Arc 1 center point type code (STD15)
double; // Arc 1 end point X coordinate (STD2)
double; // Arc 1 end point Y coordinate (STD2)
double; // Arc 2 start point X coordinate (STD2)
double; // Arc 2 start point Y coordinate (STD2)
double; // Arc 2 center point X coordinate (STD2)
double; // Arc 2 center point Y coordinate (STD2)
int [1,2]; // Arc 2 center point type code (STD15)
double; // Arc 2 end point X coordinate (STD2)
double; // Arc 2 end point Y coordinate (STD2)
& double; // Crosspoint 1 X coordinate (STD2)
& double; // Crosspoint 1 Y coordinate (STD2)
& double; // Crosspoint 2 X coordinate (STD2)
& double; // Crosspoint 2 Y coordinate (STD2)
);
Description
The
bae_crossarcarc function determines the crossing points for the specified arcs. The function returns the number of crosspoints (0, 1, or 2). The coordinates of existing crosspoints are also returned through the crosspoint functions parameters.
See also
Functions bae_crosslineline,
bae_crosslinepoly,
bae_crosssegarc,
bae_crosssegseg.
bae_crosslineline - Determine cross point of wide line segments (STD)
Synopsis
int bae_crosslineline( // Crossing flag
double; // Line 1 start point X coordinate (STD2)
double; // Line 1 start point Y coordinate (STD2)
double; // Line 1 end point X coordinate (STD2)
double; // Line 1 end point Y coordinate (STD2)
double ]0.0,[; // Line 1 width (STD2)
double; // Line 2 start point X coordinate (STD2)
double; // Line 2 start point Y coordinate (STD2)
double; // Line 2 end point X coordinate (STD2)
double; // Line 2 end point Y coordinate (STD2)
double ]0.0,[; // Line 2 width (STD2)
);
Description
The
bae_crosslineline function checks whether the specified wide line segments are crossing each other. The function returns 1 if the segments are crossing each other or zero otherwise.
See also
Functions bae_crossarcarc,
bae_crosslinepoly,
bae_crosssegarc,
bae_crosssegseg.
bae_crosslinepoly - Determine cross point of wide line with polygon (STD)
Synopsis
int bae_crosslinepoly( // Crossing flag
double; // Line start point X coordinate (STD2)
double; // Line start point Y coordinate (STD2)
double; // Line end point X coordinate (STD2)
double; // Line end point Y coordinate (STD2)
double ]0.0,[; // Line width (STD2)
);
Description
The
bae_crosslinepoly function checks whether the specified wide line segment crosses the temporary polygon created with
bae_storepoint. The function returns 1 if the segment crosses the polygon or zero otherwise.
See also
Functions bae_crossarcarc,
bae_crosslineline,
bae_crosssegarc,
bae_crosssegseg,
bae_storepoint.
bae_crosssegarc - Determine cross point(s) of segment with arc (STD)
Synopsis
int bae_crosssegarc( // Crosspoint count
double; // Segment start point X coordinate (STD2)
double; // Segment start point Y coordinate (STD2)
double; // Segment end point X coordinate (STD2)
double; // Segment end point Y coordinate (STD2)
double; // Arc start point X coordinate (STD2)
double; // Arc start point Y coordinate (STD2)
double; // Arc center point X coordinate (STD2)
double; // Arc center point Y coordinate (STD2)
int [1,2]; // Arc center point type code (STD15)
double; // Arc end point X coordinate (STD2)
double; // Arc end point Y coordinate (STD2)
int [0,1]; // Crosspoint priority flag
& double; // Crosspoint 1 X coordinate (STD2)
& double; // Crosspoint 1 Y coordinate (STD2)
& double; // Crosspoint 2 X coordinate (STD2)
& double; // Crosspoint 2 Y coordinate (STD2)
);
Description
The
bae_crosssegarc function determines the crossing points for the specified segment and arc. The function returns the number of crosspoints (0, 1, or 2). The coordinates of existing crosspoints are also returned through the crosspoint functions parameters.
See also
Functions bae_crossarcarc,
bae_crosslineline,
bae_crosslinepoly,
bae_crosssegseg.
bae_crosssegseg - Determine cross point of segments/lines (STD)
Synopsis
int bae_crosssegseg( // Crossing flag
int [0,1]; // Infinite line comparison flag
double; // Line 1 start point X coordinate (STD2)
double; // Line 1 start point Y coordinate (STD2)
double; // Line 1 end point X coordinate (STD2)
double; // Line 1 end point Y coordinate (STD2)
double; // Line 2 start point X coordinate (STD2)
double; // Line 2 start point Y coordinate (STD2)
double; // Line 2 end point X coordinate (STD2)
double; // Line 2 end point Y coordinate (STD2)
& double; // Crosspoint X coordinate (STD2)
& double; // Crosspoint Y coordinate (STD2)
);
Description
The
bae_crosssegseg function checks whether the specified segments and/or lines are crossing each other. The first function parameter specifies whether a segment comparison or a infinite line comparison should be carried out. The function returns 1 if a crosspoint was found or zero otherwise. The crosspoint coordinates are returned through the last two function parameters if a crosspoint was found.
See also
Functions bae_crossarcarc,
bae_crosslineline,
bae_crosslinepoly,
bae_crosssegarc.
bae_dashpolyline - Vectorize dashed BAE polygon (STD)
Synopsis
int bae_dashpolyline( // Returns status
int; // Polygon dash mode:
// 0 = straight line (no dash)
// 1 = dashed line
// 2 = dotted line
// 3 = dashed/dotted line
double ]0.0,[; // Polygon dash base length (STD2)
double ]-0.5,0.5[; // Polygon dash relative spacing
* int; // Polygon line scan function
* int; // Polygon arc scan function
);
Description
The
bae_dashpolyline function vectorizes the polygon previously stored with
bae_storepoint using the specified dash parameters. The polygon line and arc scan functions are automatically called for each polygon line and/or arc, respectively. The function returns zero if the vectorization was successful, or nonzero on error or if the scan was aborted.
Polygon line scan function
int polylinescanfuncname(
double xs, // Line start point X coordinate (STD2)
double ys, // Line start point Y coordinate (STD2)
double xe, // Line end point X coordinate (STD2)
double ye // Line end point Y coordinate (STD2)
)
{
// Polygon line scan function statements
:
return(errstat);
}
The return value of the polygon line scan function should be zero if the scan was ok or nonzero on error or if the scan should be aborted.
Polygon arc scan function
int polylinescanfuncname(
double xs, // Arc start point X coordinate (STD2)
double ys, // Arc start point Y coordinate (STD2)
double xe, // Arc end point X coordinate (STD2)
double ye // Arc end point Y coordinate (STD2)
double xc, // Arc center point X coordinate (STD2)
double yc // Arc center point Y coordinate (STD2)
int cwflag; // Arc clockwise flag:
// 0 = arc counter-clockwise
// else = arc clockwise
)
{
// Polygon arc scan function statements
:
return(errstat);
}
The return value of the polygon arc scan function should be zero if the scan was ok or nonzero on error or if the scan should be aborted.
See also
Functions
bae_clearpoints,
bae_storepoint.
bae_deffuncprog - Define BAE function key (STD)
Synopsis
int bae_deffuncprog( // Returns status
int [1,128]; // Function key number
string; // User Language program name or
// # followed by menu item (STD4)
);
Description
The
bae_deffuncprog function assigns the given
User Language program (or BAE menu function) to the given function key. An empty string program name specification can be used to reset the current assignment. The function returns zero if done or nonzero on error (i.e., invalid parameters or reset request for undefined key bindings).
See also
Functions
bae_getfuncprog,
bae_resetmenuprog.
bae_defkeyprog - Define BAE standard key (STD)
Synopsis
int bae_defkeyprog( // Returns status
int; // Key character
string; // User Language program name or
// # followed by menu item (STD4)
);
Description
The
bae_defkeyprog function assigns the specified
User Language program (or BAE menu function) to the given standard key. An empty string program name specification can be used to reset the current assignment. The function returns zero if done, or nonzero on error (i.e., invalid parameters or reset request for undefined key bindings).
See also
Functions
bae_getkeyprog,
bae_resetmenuprog.
bae_defmenu - BAE menu definition start (STD)
Synopsis
int bae_defmenu( // Returns status
int [0,999]; // Menu code number
int [0,999]; // Menu area code number:
// 1 = main menu area
// 101 = first submenu area
// 102 = second submenu area
// : = : submenu area
);
Description
The
bae_defmenu function starts the definition of a standard menu in the currently active BAE module. The function returns (-1) on error or zero otherwise. After calling
bae_defmenu, the
bae_defmenutext function should be applied for defining the menu entries. The menu definition initiated with
bae_defmenu must be terminated by a call to the
bae_endmenu function. The
bae_resetmenuprog function can be used to reset all menu assignments, thus restoring the default menu configuration of the currently active BAE module.
See also
Functions
bae_defmenuprog,
bae_defmenutext,
bae_endmenu,
bae_redefmenu,
bae_resetmenuprog.
bae_defmenuprog - Define BAE menu entry (STD)
Synopsis
int bae_defmenuprog( // Selection code or (-1) on error
int [0,999]; // Menu number
int [0,99]; // Menu line
string; // Menu text
string; // User Language program name or
// # followed by menu item (STD4)
int; // Menu entry processing key:
// 8000000h = always available
// 7FFFFFFh = available for each
// element type
// else = (combined) DDB class
// processing key
);
Description
The
bae_defmenuprog function assigns the specified menu text and the named
User Language program (or BAE menu function) to the given menu entry. The menu number specifies the number of the main menu, whilst the menu line designates the position in the according submenu. An empty string program name specification can be used to reset the current assignment. The menu entry processing key activates ghost menu configurations. The processing key is a coded integer value as retrieved and/or defined using the
bae_getclassbitfield and
bae_getmenubitfield functions (hex value 80000000h can be entered to allow for application in any case). The
bae_defmenuprog function returns zero if done or nonzero on error (i.e., invalid parameters or reset request for undefined menu assignments). The
bae_resetmenuprog function can be used to reset all menu assignments, thus restoring the default menu configuration of the currently active BAE module.
See also
Functions
bae_getclassbitfield,
bae_getmenubitfield,
bae_getmenuprog,
bae_getmenutext,
bae_redefmenu,
bae_resetmenuprog.
bae_defmenusel - Set BAE menu default selection (STD)
Synopsis
void bae_defmenusel(
int [-1,29]; // Menu item index
// or (-1) for selection text store
);
Description
The
bae_defmenusel function sets the default selection for the next
bae_askmenu call. This allows for the indication of the currently selected menu option. BAE Windows versions indicate the default selection through a tick marker, Motif versions grey-shade the preselected menu item, and the DOS versions and/or the sidemenu configurations preselect the menu item specified through the menu item index parameter. The
bae_defmenusel selection is only valid for the next
bae_askmenu call.
bae_askmenu resets this selection, i.e.,
bae_defmenusel must be used to re-activate any required default selection for subsequent
bae_askmenu calls.
See also
Function
bae_askmenu.
bae_defmenutext - Define BAE menu item text (STD)
Synopsis
int bae_defmenutext( // Returns status
int [0,99]; // Menu line
string; // Menu text
int; // Menu entry processing key:
// 8000000h = always available
// 7FFFFFFh = available for each element type
// else = (combined) DDB class processing key
);
Description
The
bae_defmenutext function must be called after
bae_defmenu and/or
bae_defselmenu to store the given menu line text at the specified menu line of the current menu definition. A pulldown menu seperator line is inserted prior to the menu entry if the menu line text starts with a percent character
(%). The commercial and-character
& can be used to define menu accelerator keys, with the character preceded by the
& sign defining the key for selecting the menu item through the keyboard. The menu entry processing key activates ghost menu configurations. The processing key is a coded integer value as retrieved and/or defined using the
bae_getclassbitfield and
bae_getmenubitfield functions (hex value 80000000h can be entered to allow for application in any case). The function returns (-1) on error or zero otherwise. The
bae_resetmenuprog function can be used to reset all menu assignments, thus restoring the default menu configuration of the currently active BAE module.
See also
Functions
bae_defmenu,
bae_defselmenu,
bae_getclassbitfield,
bae_getmenubitfield,
bae_plainmenutext,
bae_redefmenu,
bae_resetmenuprog.
bae_defselmenu - BAE menu definition start (STD)
Synopsis
int bae_defselmenu( // Returns status
int [0,999]; // Menu code number
int [0,999]; // Menu area code number:
// 1 = main menu area
// 101 = first submenu area
// 102 = second submenu area
// : = : submenu area
);
Description
The
bae_defselmenu function starts the definition of a standard menu in the currently active BAE module. The function returns (-1) on error or zero otherwise. After calling
bae_defselmenu, the
bae_defmenutext function should be applied for defining the menu entries. The menu definition initiated with
bae_defselmenu must be terminated by a call to the
bae_endmenu function. The
bae_resetmenuprog function can be used to reset all menu assignments, thus restoring the default menu configuration of the currently active BAE module.
See also
Functions
bae_defmenuprog,
bae_defmenutext,
bae_endmenu,
bae_redefmenu,
bae_resetmenuprog.
bae_dialaddcontrol - BAE dialog element definition (STD)
Synopsis
int bae_dialaddcontrol( // Dialog element index or (-1) on error
int [0,[; // Parameter type (STD5)
int; // Minimum int parameter value
int; // Maximum int parameter value
int; // Initial int parameter value
double; // Minimum double parameter value
double; // Maximum double parameter value
double; // Initial double parameter value
string; // Initial string parameter value
int [0,[; // Maximum string parameter value length
double; // Dialog element X position [character units]
double; // Dialog element Y position [character units]
double; // Dialog element dimension [character units]
string; // Parameter name/prompt
);
Description
The
bae_dialaddcontrol function defines a dialog element for the specified parameter type. Subsequent calls to the
bae_dialaskparams, function activate a dialog with the dialog element displayed at the specified position and size. Any label and/or prompt to be displayed with the dialog element can be specified through the parameter name/prompt function parameter. The parameter value setting(s) for the new dialog element must be passed through the function parameter(s) matching the specified dialog element parameter type. The function returns a non-negative dialog element index if the dialog element creation was successful or (-1) otherwise. The dialog element index is used as dialog element selection parameter in subsequent calls to the
bae_dialgetdata and
bae_dialsetdata functions. Dialog elements created with
bae_dialaddcontrol are valid and/or available until the next
bae_dialclr call.
See also
Functions
bae_dialadvcontrol,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxbufload,
bae_dialboxbufstore,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialadvcontrol - Add advanced BAE dialog element (STD)
Synopsis
int bae_dialadvcontrol( // Returns new dialog control index or (-1) on error
int [0,[; // Parameter type (STD5)
int; // Minimum int parameter value
int; // Maximum int parameter value
int; // Initial int parameter value
double; // Minimum double parameter value
double; // Maximum double parameter value
double; // Initial double parameter value
string; // Initial string parameter value
int [0,[; // Maximum string parameter value length
double; // Dialog element X coordinate [character units]
double; // Dialog element Y coordinate [character units]
double; // Dialog element width [character units]
double; // Dialog element height [character units]
string; // Parameter name/prompt
);
Description
The
bae_dialadvcontrol function defines an advanced dialog element (with element height specification) for the specified parameter type. Subsequent calls to the
bae_dialaskparams, function activate a dialog with the dialog element displayed at the specified position, width and height. Any label and/or prompt to be displayed with the dialog element can be specified through the parameter name/prompt function parameter. The parameter value setting(s) for the new dialog element must be passed through the function parameter(s) matching the specified dialog element parameter type. The function returns a non-negative dialog element index if the dialog element creation was successful or (-1) otherwise. The dialog element index is used as dialog element selection parameter in subsequent calls to the
bae_dialgetdata and
bae_dialsetdata functions. Dialog elements created with
bae_dialadvcontrol are valid and/or available until the next
bae_dialclr call.
See also
Functions
bae_dialaddcontrol,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxbufload,
bae_dialboxbufstore,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialaskcall - Activate BAE dialog with listbox element callback function (STD)
Synopsis
int bae_dialaskcall( // Returns positive action code, or
// ( 0) on , or
// (-1) on or error
string; // Dialog title
int [0,3]; // Distance output units:
// 0 = mm
// 1 = Inch
// 2 = mil
// 3 = um
double ]0.0,[; // Dialog width [character units]
double ]0.0,[; // Dialog height [character units]
* int; // Listbox element callback function
);
Description
The
bae_dialaskcall function activates a dialog with the dialog elements previously defined with
bae_dialaddcontrol. The dialog title specified with the first function parameter is displayed in the title bar of the dialog window. The size of the dialog window can be specified through the dialog width and height function parameters. The function return value is set to zero if the
dialog button is pressed. Pressing a non-default action button dialog element with a positive action code assignment causes
bae_dialaskcall to return with the specified action code. A value of (-1) is returned on error or
dialog button activation. The
bae_dialgetdata, function can be used to retrieve dialog parameter values after successfully completing
bae_dialaskcall. Distance and/or length parameter values are automatically displayed and/or returned according to the distance output units mode function parameter passed to
bae_dialaskcall. The last parameter allows for the specification of a user-defined callback function which is automatically called if an element of a listbox with
PA_MCALLBACK type definition is selected.
Listbox Element Callback Function
int callbackfuncname(
int reason, // Callback reason
int boxidx, // Dialog box index
int itemidx, // List element index
int itemid, // List element id
string itemstr // List element text
)
{
// Function statements
:
return(errstat);
}
The callback function should return zero upon successfull completion, or non-zero for errors or abort requests.
See also
Functions bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxparam,
bae_dialboxperm,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialaskparams - Activate BAE dialog (STD)
Synopsis
int bae_dialaskparams( // Returns positive action code, or
// ( 0) on , or
// (-1) on or error
// (-2) on dialog size change
string; // Dialog title
int [0,3]; // Distance output units:
// 0 = mm
// 1 = Inch
// 2 = mil
// 3 = um
double ]0.0,[; // Dialog width [character units]
double ]0.0,[; // Dialog height [character units]
);
Description
The
bae_dialaskparams function activates a dialog with the dialog elements previously defined with
bae_dialaddcontrol. The dialog title specified with the first function parameter is displayed in the title bar of the dialog window. The size of the dialog window can be specified through the dialog width and height function parameters. The function return value is set to zero if the
dialog button is pressed. Pressing a non-default action button dialog element with a positive action code assignment causes
bae_dialaskparams to return with the specified action code. A value of (-1) is returned on error or
dialog button activation. A value of (-2) is returned if the dialog size is changed. The
bae_dialgetdata, function can be used to retrieve dialog parameter values after successfully completing
bae_dialaskparams. Distance and/or length parameter values are automatically displayed and/or returned according to the distance output units mode function parameter passed to
bae_dialaskparams.
See also
Functions bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialbmpalloc,
bae_dialboxperm,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialbmpalloc - Create BAE dialog bitmap (STD)
Synopsis
int bae_dialbmpalloc( // Returns non-negative bitmap id or (-1) on error
double ]0.0,[; // Requested bitmap width [character units]
double ]0.0,[; // Requested bitmap height [character units]
int [2,31]; // Bitmap id
& int; // Generated bitmap width [Pixel]
& int; // Generated bitmap height [Pixel]
);
Description
The
bae_dialbmpalloc function creates a bitmap with the specified parameters in a dialog box to be activated with
bae_dialaskparams. The function returns (-1) on error or a non-negative bitmap id (and the generated bitmap dimensions) if the bitmap was successfully created. Once the bitmap is generated, the
bae_popsetarea function is used to select the bitmap for subsequent graphic output with the
bae_popdrawtext and
bae_popdrawpoly functions.
See also
Functions
bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialaskparams,
bae_dialboxperm,
bae_dialclr,
bae_popdrawpoly,
bae_popdrawtext,
bae_popsetarea.
bae_dialboxbufload - Restore BAE dialog box data from buffer (STD)
Synopsis
int bae_dialboxbufload( // Status
int [1,[; // Dialog box buffer id
);
Description
The
bae_dialboxbufload function is used to restore dialog box definitions which were previously saved with the
bae_dialboxbufstore function. The function returns zero if the dialog box definitions were successfully loaded or nonzero on error.
See also
Functions bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialboxbufstore,
bae_dialclr.
bae_dialboxbufstore - Store BAE dialog box data to buffer (STD)
Synopsis
int bae_dialboxbufstore( // Dialog box id (>0) or (-1) on error
);
Description
The
bae_dialboxbufstore function saves the current dialog box definitions to an internal buffer. The functions returns a buffer id or (-1) on error. The buffer id can be used in subsequent calls to the
bae_dialboxbufload function for restoring these dialog box definitions.
See also
Functions bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialboxbufload,
bae_dialclr.
bae_dialboxperm - Activate modeless BAE dialog (STD)
Synopsis
int bae_dialboxperm( // Returns positive dialog box id, or
// (-1) on dialog box creation error, or
// (-2) if maximum dialog box count reached
string; // Dialog title
int [0,3]; // Distance output units:
// 0 = mm
// 1 = Inch
// 2 = mil
// 3 = um
double ]0.0,[; // Dialog width [character units]
double ]0.0,[; // Dialog height [character units]
);
Description
The
bae_dialboxperm function activates a modeless dialog with the dialog elements previously defined with
bae_dialaddcontrol. The dialog title specified with the first function parameter is displayed in the title bar of the dialog window. The size of the dialog window can be specified through the dialog width and height function parameters. The function returns the positive dialog box id if the dialog was successfully generated, or a negative value on error. The
bae_dialgetdata function can be used to retrieve dialog parameter values after successfully completing
bae_dialboxperm (and dialog activation with
bae_dialsetcurrent). Distance and/or length parameter values are automatically displayed and/or returned according to the distance output units mode function parameter passed to
bae_dialboxperm.
See also
Functions bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialclr,
bae_dialgetdata,
bae_dialsetcurrent,
bae_dialsetdata.
bae_dialclr - Clear BAE dialog elements (STD)
Synopsis
int bae_dialclr( // Returns status
);
Description
The
bae_dialclr function clears/deletes all BAE dialog elements previously defined with
bae_dialaddcontrol. The function return value is nonzero if dialogs are not supported in the current BAE user interface environment. To clear any dialog elements from previous dialog definitions,
bae_dialclr should be called before starting a new BAE dialog definitions The function return value should be checked, and alternative user input facilities should be provided if dialogs are not supported.
See also
Functions
bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxbufload,
bae_dialboxbufstore,
bae_dialboxperm,
bae_dialgetdata,
bae_dialsetdata.
bae_dialgetdata - Get BAE dialog element parameter (STD)
Synopsis
int bae_dialgetdata( // Returns status
int [0,[; // Dialog element index
& int; // Dialog element integer value
& double; // Dialog element double value
& string; // Dialog element string value
);
Description
The
bae_dialgetdata function is used to retrieve dialog element parameter values after successful
bae_dialaskparams calls. The query dialog element is selected through the dialog element index returned by
bae_dialaddcontrol at the creation of the dialog element. The parameter value is returned through the function parameter matching the data type of the queried dialog element. The function returns nonzero if the dialog element parameter query failed.
See also
Functions
bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskparams,
bae_dialclr,
bae_dialsetdata.
bae_dialgettextlen - Get BAE dialog text length (STD)
Synopsis
double bae_dialgettextlen( // Returns text length [character units]
int [0,[; // Dialog text (font) type
string; // Dialog text string
);
Description
The
bae_dialgettextlen function calculates and returns the spacial requirements for displaying the specified dialog text string.
bae_dialsetcurrent - Set current BAE dialog box (STD)
Synopsis
int bae_dialsetcurrent( // Returns status
int [0,[; // Dialog box id
);
Description
The
bae_dialsetcurrent activates the (modeless) dialog box specified through the dialog box id for subsequent dialog box operations. The functions returns zero if a dialog was successfully selected, or nonzero otherwise.
See also
Functions bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskcall,
bae_dialaskparams,
bae_dialbmpalloc,
bae_dialboxperm,
bae_dialclr,
bae_dialgetdata,
bae_dialsetdata.
bae_dialsetdata - Set BAE dialog element parameter (STD)
Synopsis
int bae_dialsetdata( // Returns status
int [0,[; // Dialog element index
int [0,[; // Dialog element parameter type (STD5)
int; // Dialog element integer value
double; // Dialog element double value
string; // Dialog element string value
);
Description
The
bae_dialsetdata function is used to set dialog element parameter types and/or values previously defined with the
bae_dialaddcontrol function. The dialog element to be changed is selected through the dialog element index returned by
bae_dialaddcontrol at the creation of the dialog element. The new dialog element parameter value must be passed through the function parameter matching the specified dialog element parameter type. The function returns nonzero if the dialog element parameter value change failed.
See also
Functions
bae_dialaddcontrol,
bae_dialadvcontrol,
bae_dialaskparams,
bae_dialclr,
bae_dialgetdata.
bae_endmainmenu - BAE main menu definition end (STD)
Synopsis
int bae_endmainmenu( // Returns status
);
Description
The
bae_endmainmenu function terminates a main menu redefinition previously initiated with the
bae_redefmainmenu function. The function returns (-1) on error or zero otherwise.
See also
Function
bae_redefmainmenu.
bae_endmenu - BAE menu definition end (STD)
Synopsis
int bae_endmenu( // Returns status
);
Description
The
bae_endmenu function terminates a menu definition previously initiated with either of the functions
bae_defmenu or
bae_defselmenu. The function returns (-1) on error or zero otherwise.
See also
Functions
bae_defmenu,
bae_defselmenu.
bae_fontcharcnt - Get BAE font character count (STD)
Synopsis
int bae_fontcharcnt( // Returns font character count
);
Description
The
bae_fontcharcnt function returns the number of characters defined in the currently active BAE text font.
bae_fontname - Get BAE text font name (STD)
Synopsis
string bae_fontname( // Returns text font name
);
Description
The
bae_fontname function returns the text font name of the currently loaded BAE element.
bae_getactmenu - Get active BAE menu entry number (STD)
Synopsis
int bae_getactmenu( // Returns menu entry number (STD4)
);
Description
The
bae_getactmenu function returns the menu entry number
(STD4) of the currently active BAE menu function or (-1) if no menu function is active. This feature is useful for key-called
User Language programs.
bae_getanglelock - Get BAE angle lock flag (STD)
Synopsis
int bae_getanglelock( // Returns angle lock flag (STD9)
);
Description
The
bae_getanglelock function returns the current BAE angle lock mode (0=angle unlocked, 1=angle locked).
See also
Function
bae_setanglelock.
bae_getbackgrid - Get BAE display grid (STD)
Synopsis
void bae_getbackgrid(
& double; // Returns X display grid (STD2)
& double; // Returns Y display grid (STD2)
);
Description
The
bae_getbackgrid function returns the current BAE X/Y display grid values with its parameters. Zero grid values refer to switched-off grids.
See also
Function
bae_setbackgrid.
bae_getcasstime - Get date/time of last project connection data update caused by Packager/Backannotation (STD)
Synopsis
string bae_getcasstime( // Returns Packager net lsit name
& int; // Returns time second
& int; // Returns time minute
& int; // Returns time hour
& int; // Returns date day
& int; // Returns date month
& int; // Returns date year
);
Description
The
bae_getcasstime function can be used to retrieve the date and time of the last project netlist updated caused by
Packager or
.
See also
Functions bae_getpackdata,
bae_getpacktime.
bae_getclassbitfield - Get BAE DDB class processing key (STD)
Synopsis
int bae_getclassbitfield( // Returns processing key
int ]0,[; // DDB database class code (STD1)
);
Description
The
bae_getclassbitfield function returns the processing key code assigned to the specified DDB database class. The function returns (-1) for invalid and/or unknown database class specifications.
The processing key is a coded integer value which - in a BAE module - is unique for each processable DDB database class. Such key codes can be combined using bit-or operations and can subsequently be assigned to specific menu entries using either of the
bae_defmenutext,
bae_defmenuprog or
bae_redefmenu functions, thus allowing for the configuration of menu functions which can only be applied on certain database classes.
See also
Functions
bae_defmenuprog,
bae_defmenutext,
bae_getmenubitfield,
bae_redefmenu.
bae_getcmdbuf - BAE command history query (STD)
Synopsis
int bae_getcmdbuf( // Returns status
int [-50,2099]; // Command buffer index 0 to 49
// or 1000 to 1099 for Undo items 1 to 100
// or 2000 to 2099 for Redo items 1 to 100
// or negative value for message history
& string; // Command (sequence) string
& string; // Command notification text
);
Description
The
bae_getcmdbuf function is used to query the current context menu command history, i.e., the list of commands activated through the right mouse button. The command buffer index parameter selects the command to be queried (zero being the most recent command). The command (sequence) string and the command notification text (as displayed in the title bar) are returned through the second and third function parameter. The function returns 1 if the query was successful or zero if an invalid command buffer index was specified.
See also
Function bae_storecmdbuf.
bae_getcolor - Get BAE color value (STD)
Synopsis
int bae_getcolor( // Color value (STD18)
int; // Display item type (SCM1|LAY9|ICD9)
);
Description
The
bae_getcolor function returns the color value currently set for the given display item type. The display item type value must be set according to the currently active
User Language Interpreter environment.
See also
Function
bae_setcolor.
bae_getcoorddisp - Get BAE coordinate display mode (STD)
Synopsis
int bae_getcoorddisp( // Returns coordinate display mode (STD7)
);
Description
The
bae_getcoorddisp function returns the current BAE coordinate display mode. The return value is 0 for mm display units (micrometer units in
IC Design) or 1 for Inch display units (mil units in
IC Design).
See also
Function
bae_setcoorddisp.
bae_getdblpar - Get BAE double parameter (STD)
Synopsis
int bae_getdblpar( // Returns status
int [0,[; // Parameter type/number:
// 0 = maximum dialog box width
// 1 = maximum dialog box height
// 2 = display zoom factor
// 3 = Rubberband corner radius (STD2)
// 4 = Rubberband X vector coordinate (STD2)
// 5 = Rubberband Y vector coordinate (STD2)
// 6 = fixed X pick coordinate (STD2)
// 7 = fixed Y pick coordinate (STD2)
// 8 = Dialog box width:
// 9 = Dialog box height:
// 10 = Screen pick aperture (STD2)
// 11 = Element selection preview area relative size [0.05, 0.95]
// 12 = Dialog box X unit pixels
// 13 = Dialog box Y unit pixels
& double; // Returns parameter value
);
Description
The
bae_getdblpar function is used to query
Bartels AutoEngineerdouble parameter settings. The functions returns zero if the query was successful or (-1) otherwise.
See also
Functions bae_getintpar,
bae_getstrpar,
bae_setdblpar,
bae_setintpar,
bae_setstrpar.
bae_getfuncprog - Get BAE function key definition (STD)
Synopsis
string bae_getfuncprog( // Program name
int [1,128]; // Function key number
);
Description
The
bae_getfuncprog function returns the name of the
User Language program (or the hash-preceded BAE menu function number) assigned to the specified function key. An empty string is returned if no program is assigned to the key or if the function key number specification is invalid.
bae_getgridlock - Get BAE grid lock flag (STD)
Synopsis
int bae_getgridlock( // Returns grid lock flag (STD8)
);
Description
The
bae_getgridlock function returns the current BAE grid lock mode (0=grid unlocked, 1=grid locked).
See also
Function
bae_setgridlock.
bae_getgridmode - Get BAE grid dependency mode (STD)
Synopsis
int bae_getgridmode( // Returns automatic grid setting mode
// 0x01: input grid = 0.25 × display grid
// 0x02: input grid = 0.50 × display grid
// 0x04: input grid = 1.00 × display grid
// 0x08: input grid = 2.00 × display grid
// 0x10: display grid = 0.25 × input grid
// 0x20: display grid = 0.50 × input grid
// 0x40: display grid = 1.00 × input grid
// 0x80: display grid = 2.00 × input grid
);
Description
The
bae_getgridmode function returns the current BAE grid dependency mode.
See also
Function
bae_setgridmode.
bae_getinpgrid - Get BAE input grid (STD)
Synopsis
void bae_getinpgrid(
& double; // Returns X input grid (STD2)
& double; // Returns Y input grid (STD2)
);
Description
The
bae_getinpgrid function returns the current BAE X/Y input grid values with its parameters. Zero grid values refer to switched-off grids.
See also
Function
bae_setinpgrid.
bae_getintpar - Get BAE integer parameter (STD)
Synopsis
int bae_getintpar( // Returns status
int [0,[; // Parameter type/number:
// 0 = Input coordinate range checking:
// 0 = range check enabled
// 1 = range check disabled
// 1 = Module change autosave mode:
// 0 = autosave without prompt
// 1 = prompt before autosave
// 2 = Display disable mode:
// 0 = display enabled
// 1 = display disabled
// 3 = User interface menu/mouse mode:
// 0 = Sidemenu configuration
// 1 = Pulldown menu, LMB context
// 2 = Pulldwon menu, RMB context
// 4 = Workspace text color mode:
// 0 = standard colors
// 1 = inverted standard colors
// 2 = workspace related colors
// 5 = Load display mode:
// 0 = display overview after load
// 1 = handle load display in bae_load
// 6 = File dialog view:
// 0 = old BAE style file selection
// 1 = Explorer style default view
// 2 = Explorer style list view
// 3 = Explorer style details
// 4 = Explorer style small icons
// 5 = Explorer style large icons
// 6 = Use default style and size
// 7 = Element selection box mode:
// 0 = display name only
// 1 = display name and date
// 8 = Element selection sort mode:
// 0|1 = sort by name
// 2 = sort numerically
// 3 = sort by date
// 9 = Placement visibility:
// 0 = placed elements visible
// 1 = unplaced elements visible
// 10 = Last file system error
// 11 = Command history disable flag:
// 0 = Command history enabled
// 1 = Command history disabled
// 12 = Popup menu mouse warp mode:
// 0 = No popup menu mouse warp
// 1 = First popup menu entry mouse warp
// 2 = Preselected menu entry mouse warp
// +4 = Mouse position restore warp
// +8 = Element pick position warp
// 13 = Save disable flag:
// 0 = save enabled
// 1 = save disabled
// 14 = Mouse rectangle min. size:
// ]0,[ = min. rectangle size
// 15 = Mouse info display mode:
// 0 = Tooltip info display
// 1 = Continuous crosshair info display
// 2 = Crosshair info display with Ctrl
// 16 = Next dialog box id
// 17 = Last created tooltip id
// 18 = Polygon drop count
// 19 = Polygon check disabled flag:
// 0 = Polygon check enabled
// 1 = Polygon check disabled
// 20 = Cursor key grid mode:
// 0 = Input grid
// 1 = Pixel grid
// 21 = Unsaved plan flag
// 22 = Element batch load mode:
// 0 = no batch load
// 1 = Batch load
// 2 = batch load, restore zoom window
// 23 = Grid lines display:
// 0 = Dot grid
// 1 = Line grid
// 24 = Display mirroring flag
// 25 = Input grid display flag
// 26 = Mouse function repeat mode:
// 0 = Repeat menu function
// +1 = Repeat keystroke function
// +2 = Repeat context menu function
// 27 = Maximum Undo/Redo count
// 28 = Menu tree view mode:
// 0 = No menu tree view window
// 1 = Left attached menu tree view window
// 2 = Right attached menu tree view window
// 29 = Menu tree view pixel width
// 30 = Message history disabled flag
// 31 = Element load message mode:
// 0 = Standard message
// 1 = User message
// 2 = User error message
// 32 = Pick marker display mode:
// 0 = Circle marker
// 1 = Diamond marker
// 33 = Mouse drag status:
// 0 = No mouse drag
// 1 = Request mouse drag
// 2 = Mouse dragged
// 3 = Request mouse drag release
// 34 = Menu function repeat request flag
// 35 = Function aborted flag
// 36 = Plan selection preview flag
// 37 = File error display mode:
// 0 = Status message only
// 1 = Confirm message box
// 38 = Element selection reference display mode:
// 0 = Display project file references
// 1 = Display library file references
// 39 = Mouse double-click mode:
// 0 = Map double-click and select 0 to right mouse button
// 1 = Ignore double-click
// 2 = Map double-click to right mouse button
// 40 = Mouse pick double-click mode:
// 0 = Map double-click to right mouse button
// 1 = Ignore double-click
// 41 = Dialog control support flags:
// 0 = No dialog control elements supported
// |1 = Base dialog control set supported
// |2 = List view supported
// |4 = Progress display supported
// |8 = Toolbar button supported
// 42 = Progress box display mode:
// 0 = No progress box window
// 1 = Display progress window
// 43 = Progress box abort request flag
// 44 = Middle mouse button disable flag
// 45 = Current undo items count
// 46 = File drag and drop operation flag
// 47 = Autoraise BAE window flag
// 48 = Menu function active count
// 49 = Internal polygon list point count
// 50 = Alternate configuration file priority
// 51 = Dialog position save mode:
// 0 = Store absolute coordinates
// 1 = Store main window relative coordinates
// 2 = Store main window monitor absolute coordinates
// 52 = Message box default button index:
// (-1) = No default (Abort or No)
// 0-2 = Default button index
& int; // Returns parameter value
);
Description
The
bae_getintpar function is used to query
Bartels AutoEngineer integer parameter settings. The functions returns zero if the query was successful or (-1) otherwise.
See also
Functions bae_getdblpar,
bae_getstrpar,
bae_setdblpar,
bae_setintpar,
bae_setstrpar.
bae_getinvcolor - Get BAE color inversion mode (STD)
Synopsis
int bae_getinvcolor( // Returns inverted color palette flag
);
Description
The
bae_getinvcolor function checks whether the BAE system color palette is "inverted". The system color palette is considered inverted if the darkest color in palette (as defined through a
bae.col file in the BAE programs directory) is not black. The function returns nonzero if the BAE system color palette appears to be inverted or zero else.
bae_getmenubitfield - Get BAE menu function processing key (STD)
Synopsis
int bae_getmenubitfield( // Returns processing key
int [0,999]; // Menu code
int [0,99]; // Menu line
);
Description
The
bae_getmenubitfield function returns the processing code assigned to the menu entry specified with the main menu code and the menu line number in the corresponding submenu. The function returns (-1) for invalid and/or unknown menu entry specifications.
The processing key is a coded integer value specifying a set of element types which can be subject to the menu function. This key is utilized throughout the
Bartels AutoEngineer to activate and/or deactivate specific menu functions according to the type of element currently loaded (note that the ghost menu layouts of the BAE Windows versions are a typical application of this feature). With the hex value 80000000h assigned to its processing key, a menu function can always be applied (i.e., even if no element is loaded). With the hex value 7FFFFFFFh assigned to its processing key, a menu function can be applied to any currently loaded element type. Other processing key codes are defined in each BAE module according to the DDB database classes which can be processed. The processing key code for a specific database class can be retrieved with the
bae_getclassbitfield function. Such processing key codes can be combined using bit-or operations and can subsequently be assigned to specific menu entries using either of the
bae_defmenutext,
bae_defmenuprog or
bae_redefmenu functions, thus allowing for a user-defined ghost menu setup.
See also
Functions
bae_defmenuprog,
bae_defmenutext,
bae_getclassbitfield,
bae_redefmenu.
bae_getkeyprog - Get BAE standard key definition (STD)
Synopsis
string bae_getkeyprog( // Program name
int; // Key character
);
Description
The
bae_getkeyprog function returns the name of the
User Language program (or the hash-preceded BAE menu function number) assigned to the specified standard key. An empty string is returned if no program is assigned to the key or if the key character specification is invalid.
See also
Functions
bae_defkeyprog,
bae_resetmenuprog.
bae_getmenuitem - BAE menu item query (STD)
Synopsis
int bae_getmenuitem( // Return status
& int; // Menu code
& string; // Menu text(s)
& string; // Menu command
);
Description
The
bae_getmenuitem function activates a menu function selection for menu item information query (i.e., the selected menu function is not executed). The menu code parameter returns the numeric menu call code of the selected menu item. The menu text parameter returns the selected hierarchical menu item text sequence (with menu texts separated by
->). The menu command parameter returns the menu command string/sequence assigned to the selected menu item. The function returns zero if the query was successful or nonzero for failed or aborted queries.
See also
Functions
bae_callmenu,
bae_defmenuprog,
bae_getmenuprog,
bae_getmenutext.
bae_getmenuprog - Get BAE menu entry definition (STD)
Synopsis
string bae_getmenuprog( // Program name
int [0,999]; // Menu code
int [0,99]; // Menu line
);
Description
The
bae_getmenuprog function returns the name of the
User Language program (or the hash-preceded BAE menu function number) assigned to the specified menu entry. The menu code parameter specifies the main menu number, whilst the menu line parameter specifies the position in the corresponding submenu. An empty string is returned if no program is assigned to the menu entry or if the menu entry does not exist.
See also
Functions
bae_defmenuprog,
bae_getmenuitem,
bae_getmenutext,
bae_resetmenuprog.
bae_getmenutext - Get BAE menu text (STD)
Synopsis
string bae_getmenutext( // Menu text
int [0,999]; // Menu code
int [0,99]; // Menu line
);
Description
The
bae_getmenutext function returns the menu text which is assigned to the given menu entry. The menu code parameter specifies the main menu number, whilst the menu line parameter specifies the position in the corresponding submenu. An empty string is returned if the specified menu entry does not exist.
See also
Functions
bae_defmenuprog,
bae_getmenuitem,
bae_getmenuprog,
bae_plainmenutext,
bae_resetmenuprog.
bae_getmoduleid - Get BAE module id (STD)
Synopsis
string bae_getmoduleid( // Returns module id
);
Description
The
bae_getmoduleid retrieves the module name/identification of the currently active BAE program module.
See also
Function
bae_setmoduleid.
bae_getmsg - Get BAE HighEnd message (STD/HighEnd)
Synopsis
string bae_getmsg( // Returns current message string
);
Description
The
bae_getmsg function is only available in
BAE HighEnd.
bae_getmsg is used for receiving pending messages from the
BAE HighEnd message system. Messages are send to program instances of a
BAE HighEnd session using the
bae_sendmsg function. A
BAE HighEnd session is started with a BAE call and includes any other BAE program instance subsequently started with the
function from the BAE main menu or with the
function from the
Schematic Editor. Each
BAE HighEnd module receiving a message automatically activates the
User Language program named
bae_msg. If
bae_msg is not available, the system tries to start an interpreter-specific
User Language program
(scm_msg in the Schematic Editor,
ged_msg in the Layout Editor,
ar_msg in the Autorouter, etc.). The
bae_getmsg function must be used in the
*_msg
User Language program to retrieve pending messages. Pending messages are only available during the execution of the
*_msg
User Language program, i.e., any message not retrieved by the
*_msg program using the
bae_getmsg function is lost. The message text string can be used for triggering certain actions in the destination program instances.
See also
Function
bae_sendmsg.
bae_getpackdata - Get last project Packager run data (STD)
Synopsis
int bae_getpackdata( // Returns status
string; // Project file name
& string; // Returns layout library file name
& string; // Returns net list name
);
Description
The
bae_getpackdata retrieves the layout library file and net list name parameters used for the last
Packager run on the specified project file. The function returns zero if the query was successful or non-zero if the paramater data was not found.
See also
Functions bae_getcasstime,
bae_getpacktime.
bae_getpacktime - Get last project Packager run date/time (STD)
Synopsis
int bae_getpacktime( // Returns status
string; // Project file name
& int; // Returns time second
& int; // Returns time minute
& int; // Returns time hour
& int; // Returns date day
& int; // Returns date month
& int; // Returns date year
);
Description
The
bae_getpacktime retrieves the date and time of the last
Packager run for the specified project file. The function returns zero if the query was successful or non-zero if the date/time information was not available.
See also
Functions bae_getcasstime,
bae_getpackdata.
bae_getpolyrange - Get internal BAE polygon range (STD)
Synopsis
int bae_getpolyrange( // Returns status
& double; // Returns polygon range left boundary
& double; // Returns polygon range lower boundary
& double; // Returns polygon range right boundary
& double; // Returns polygon range upper boundary
);
Description
The
bae_getpolyrange function is used to query the range of the internal BAE polygon defined with
bae_storepoint. The function returns zero if the query was successful or non-zero otherwise.
See also
Functions
bae_clearpoints,
bae_storepoint.
bae_getstrpar - Get BAE string parameter (STD)
Synopsis
int bae_getstrpar( // Rückgabe Status
int [0,[; // Parameter type/number:
// 0 = Current element comment text
// 1 = Current element specification
// 2 = Last file access error file
// 3 = Last file access error item
// [ 4 = System parameter - no read access ]
// [ 5 = System parameter - no read access ]
// 6 = Last loaded color table
// 7 = Menu text of last called function
// 8 = Current menu item element text
// 9 = Current element load user message
// 10 = Clipboard text string
// 11 = Next module call file argument
// 12 = Next module call element argument
// 13 = Next module call command/type argument
// 14 = Last output file name
// 15 = Host name
// [ 16 = System parameter - no read access ]
// 17 = All users data directory
// 18 = Current user data directory
// 19 = Alternate configuration data directory
// 20 = Local data column
// 21 = Global data column
& string; // Returns parameter value
);
Description
The
bae_getstrpar function is used to query
Bartels AutoEngineer string parameter settings. The functions returns zero if the query was successful or (-1) otherwise.
See also
Functions bae_getdblpar,
bae_getintpar,
bae_setdblpar,
bae_setintpar,
bae_setstrpar.
bae_inittextscreen - Clear/initialize the BAE text screen (STD)
Synopsis
void bae_inittextscreen(
);
Description
The
bae_inittextscreen function clears the BAE graphic workarea and initializes the BAE text screen. The text cursor is set to the upper left corner of the text screen.
bae_inpoint - Input BAE point/coordinates with mouse (STD)
Synopsis
int bae_inpoint( // Returns status
double; // Start X coordinate (STD2)
double; // Start Y coordinate (STD2)
& double; // Returns input X coordinate (STD2)
& double; // Returns input Y coordinate (STD2)
int; // Drawing mode:
// 0 = no tracking display
// 1 = rubberband frame display
// 2 = rubberband line display
// 3 = rubberband circle display
// 4 = rubberband distance display
// 5 = rubberband zoom window display
// 6 = rubberband square display
// 7 = rubberband centered square display
// 8 = rubberband centered window display
// 9 = rubberband line polygon display
// 10 = rubberband outline polygon display
// 11 = rubberband circle center display
// 12 = rubberband fixed
// 13 = rubberband centered zoom window
// 14 = No window display, RMB immediate abort
// 15 = Fixed offset display
);
Description
The
bae_inpoint function activates an interactive coordinate point specification request (with mouse and optional submenu). The start coordinates specify the start point for
commands. The selected point coordinates are passed with the return parameters.
A drawing mode value of 1 activates rubberband frame drawing from the start coordinate to the current mouse coordinate during coordinate selection. A drawing mode value of 2 activates rubberband line drawing from the start coordinate to the current mouse coordinate during coordinate selection. The function returns nonzero if a point has been selected or (-1) if the point selection has been aborted.
See also
Function
bae_inpointmenu.
bae_inpointmenu - Input BAE point/coordinates with mouse and right mouse button callback function (STD)
Synopsis
int bae_inpointmenu( // Returns status
double; // Start X coordinate (STD2)
double; // Start Y coordinate (STD2)
& double; // Returns input X coordinate (STD2)
& double; // Returns input Y coordinate (STD2)
int; // Drawing mode:
// 0 = no tracking display
// 1 = rubberband frame display
// 2 = rubberband line display
// 3 = rubberband circle display
// 4 = rubberband distance display
// 5 = rubberband zoom window display
// 6 = rubberband square display
// 7 = rubberband centered square display
// 8 = rubberband centered window display
// 9 = rubberband line polygon display
// 10 = rubberband outline polygon display
// 11 = rubberband circle center display
// 12 = rubberband fixed
// 13 = rubberband centered zoom window
// 14 = unused
// 15 = Fixed offset display
);
Description
The
bae_inpointmenu function activates an interactive coordinate point specification request (with mouse and optional submenu). The start coordinates specify the start point for
commands. The selected point coordinates are passed with the return parameters. A drawing mode value of 1 activates rubberband frame drawing from the start coordinate to the current mouse coordinate during coordinate selection. A drawing mode value of 2 activates rubberband line drawing from the start coordinate to the current mouse coordinate during coordinate selection. The last parameter allows for the specification of a callback function (e.g., for displaying a specific options menu) to be activated if the right mouse button is pressed. The function returns nonzero if a point has been selected or (-1) if the point selection has been aborted.
Right mouse button callback function
int callbackfunction( // Status
double x // Current input X coordinate
double y // Current input Y coordinate
)
{
// Right mouse button callback function statements
:
return(status);
}
The right mouse button callback function return value should be 0 to signal input completion, 1 to continue input, or any other value to abort input. Modified X/Y input coordinate parameters can be returned for zero callback function return values (input completed).
See also
Function
bae_inpoint.
bae_language - Get BAE user interface language code (STD)
Synopsis
string bae_language( // Returns language code:
// DE = German
// EN = English
// for future use:
// FR = French
// IT = Italian
// SP = Spanish
// SV = Swedish
);
Description
The
bae_language function returns a code for identifying the language which is currently activated in the BAE user interface. This information can be used to support dynamic multi-language support.
bae_loadcoltab - Load BAE color table (STD)
Synopsis
int bae_loadcoltab( // Returns status
string; // Color table name
);
Description
The
bae_loadcoltab function loads the color table with the given name to the BAE. The function returns nonzero if the color table cannot be loaded.
bae_loadelem - Load BAE element (STD)
Synopsis
int bae_loadelem( // Returns status
string; // File name
string; // Element name
int [100,[; // DDB class (STD1)
);
Description
The
bae_loadelem function loads a BAE element from DDB file to memory. The element is specified by the DDB file name, the element name and the DDB class. Possible
Schematic Editor DDB class codes are 800, 801, 802 and 803 for SCM sheet, SCM symbol, SCM marker and SCM label, respectively. Possible BAE Layout DDB class codes are 100, 101, 102 and 103 for PCB layout, layout part, layout padstack and layout pad, respectively. Possible
IC Design DDB class codes are 1000, 1001 and 1002 for IC layout, IC cell and IC pin, respectively. The function returns zero if the element was successfully loaded, (-1) on file access errors, 1 on text font load faults, 2 if referenced macros (library elements) are missing or 3 on unplaced parts and/or missing pins, i.e., if part symbols placed on a loaded layout do not match the net list specifications.
An empty element name can be specified with PCB Layout element class 100 for automatically loading the layout element with the default layout element name (see
LAYDEFELEMENT command for
bsetup).
bae_loadelem automatically processes pending
requests when loading SCM plans to the
Schematic Editor.
Warning
The
bae_loadelem function changes all currently loaded BAE element data. As a result, any active index variable becomes invalid. It is strongly recommended to refrain from using
bae_loadelem in index variable accessing program blocks such as
forall loops. Since
bae_loadelem reset the
facility, it is also strongly recommended to check (with
bae_plannotsaved) whether the current element has been saved before calling
bae_loadelem.
bae_loadfont - Load BAE text font (STD)
Synopsis
int bae_loadfont( // Returns status
string; // Text font name
);
Description
The
bae_loadfont function loads the name-specified BAE text font. The function returns nonzero on font load errors or zero otherwise.
bae_menuitemhelp - Display BAE menu item help (STD)
Synopsis
int bae_menuitemhelp( // Status
int [0,9999]; // Menu code (STD4)
string; // Help file name (Windows .hlp file)
);
Description
The
bae_menuitemhelp displays the Windows online help file topic for the specified menu code. The function returns nonzero if invalid parameters are specified.
Limitations
bae_menuitemhelp operates only under Windows.
bae_msgbox - Activate BAE message popup (STD)
Synopsis
void bae_msgbox(
int; // Message box style/icon:
// 0 = info (information)
// 1 = warning (exclamation-point)
// 2 = error (question-mark)
// 3 = fatal error (stop-sign)
// else = no icon
string; // Message box text string
string; // Message box title string
);
Description
The
bae_msgbox function activates a message box popup with a confirmation
() button. The appearance of the message popup window can be selected with the first parameter. The message box text string is displayed in the popup area. The message box title string is used as header string to be displayed in the message box popup window title bar. The appearance and layout of the message box (popup positioning, title bar display, confirmation button, text alignment, word wrapping, etc.) can differ depending on the host operating system platform.
See also
Functions
bae_msgboxverify,
bae_msgboxverifyquit.
bae_msgboxverify - Activate BAE message popup with Yes/No verification (STD)
Synopsis
int bae_msgboxverify( // Returns answer code:
// 1 = Yes
// 0 = No (default)
string; // Message box text string
string; // Message box title string
);
Description
The
bae_msgboxverify function activates a message box popup with a
Yes/No verification query. The function returns 1 on
Yes input/selection or zero otherwise. The message box text string is displayed in the popup area. The message box title string is used as header string to be displayed in the message box popup window title bar. The appearance and layout of the message box (popup positioning, title bar display, yes/no buttons, text alignment, word wrapping, etc.) can differ depending on the host operating system platform.
See also
Functions
bae_msgbox,
bae_msgboxverifyquit.
bae_msgboxverifyquit - Activate BAE message popup with Yes/No/Quit verification (STD)
Synopsis
int bae_msgboxverifyquit( // Returns answer code:
// 1 = Yes
// 0 = No
// else = Cancel/Quit (default)
string; // Message box text string
string; // Message box title string
);
Description
The
bae_msgboxverifyquit function activates a message box popup with a
Yes/No/Quit verification query. The function returns 1 on
Yes input/selection or zero on
No input/selection. Any other return value indicates a
Cancel/Quit request. The message box text string is displayed in the popup area. The message box title string is used as header string to be displayed in the message box popup window title bar. The appearance and layout of the message box (popup positioning, title bar display, yes/no/quit buttons, text alignment, word wrapping, etc.) can differ depending on the host operating system platform.
See also
Functions
bae_msgbox,
bae_msgboxverify.
bae_msgprogressrep - Activate/update BAE progress display (STD)
Synopsis
int bae_msgprogressrep( // Returns non-zero on error
string; // Progress display text string
int [0,258]; // Progress display type:
// 1 : Percentage progress
// 2 : Marquee progress slider
// |256 : Display abort button
int [0,10000]; // Progress display completion value [%*100]
int [0,[; // Progress display min. character length
);
Description
The bae_msgprogressrep activates and/or updates the current BAE progress display with the specified parameters. The function returns zero on success or non-zero on error (if invalid parameters were specified). The bae_msgprogressterm function can be used to terminate the progress display.
See also
Function bae_msgprogressterm.
bae_msgprogressterm - Terminate BAE progress display (STD)
Synopsis
void bae_msgprogressterm(
);
Description
The bae_msgprogressterm terminates the previously with bae_msgprogressrep activated BAE progress display.
See also
Function bae_msgprogressrep.
bae_mtpsize - Get BAE popup display area dimensions (STD)
Synopsis
void bae_mtpsize(
& int; // Returns popup menu text columns
& int; // Returns popup menu text rows
);
Description
The
bae_mtpsize function retrieves the size of the graphic workarea available for displaying popup menus or toolbars defined with
bae_popshow and/or
bae_settbsize. The display area width is returned with the popup menu text columns parameter, whilst the display area height is returned with the popup menu text rows parameter. The
bae_charsize function can be utilized to convert these values to standard length units.
See also
Functions
bae_charsize,
bae_popshow,
bae_twsize,
bae_settbsize.
bae_nameadd - Add BAE name selection list element (STD)
Synopsis
int bae_nameadd( // Name list index/ID or (-1) on error
string; // Name
string; // Date string
string; // Date sort string
int; // Sort mode:
// 0 = append (no sorting)
// 1 = sort alphanumerically
// 2 = sort numerically
// 3 = sort by date
// 4 = sort for ID creation
);
Description
The
bae_nameadd function adds a name entry to the BAE name selection list. This list is used by the
bae_askname function for activating name selection dialogs. The
bae_nameclr function can or/should be used prior to the first
bae_nameadd call to clear any previously stored entries from the name selection list. The function returns a name list index/ID or (-1) on error.
See also
Functions bae_askname,
bae_nameclr,
bae_nameget.
bae_nameclr - Clear BAE name selection list (STD)
Synopsis
void bae_nameclr(
);
Description
The
bae_nameclr function clears the name list currently defined with
bae_nameadd.
See also
Functions bae_askname,
bae_nameadd,
bae_nameget.
bae_nameget - Get BAE name selection list element (STD)
Synopsis
int bae_nameget( // Status
int; // Name list index
& string; // Returns name
& string; // Returns date string
& string; // Returns date sort string
& string; // Returns comment
& int; // Returns name entry count or name ID
);
Description
The
bae_nameget can be used to query BAE name selection list entries defined by
bae_nameadd. The function returns zero if the query was successfully or nonzero otherwise.
See also
Functions bae_askname,
bae_nameadd,
bae_nameclr.
bae_numstring - Create numeric string (STD)
Synopsis
string bae_numstring( // Returns numeric string
double; // Input value
int [0,[; // Maximum precision
);
Description
The
bae_numstring converts the input value into a string with the specified precision (number of decimal points.
bae_peekiact - BAE interaction queue query (STD)
Synopsis
int bae_peekiact( // Returns pending interaction status/type:
// 0 = No automatic interaction pending
// 1 = Mouse interaction pending
// 2 = Text interaction pending
// 3 = Menu interaction pending
// 4 = Wait key interaction pending
);
Description
The
bae_peekiact can be used to check whether an automatic interaction is pending in the current interaction queue. The function returns a type code for the next automatic interaction queue item, or zero if no automatic interaction is pending.
See also
Functions
bae_storekeyiact,
bae_storemenuiact,
bae_storemouseiact,
bae_storetextiact.
bae_plainmenutext - BAE menu item text conversion (STD)
Synopsis
string bae_plainmenutext( // Returns answer string
string; // Menu item string
);
Description
The
bae_plainmenutext function strips all special characters for menu separator line specifications
(%), key accelerators
(&), etc. from the specified menu item string. The resulting plain menu item string is returned as function result.
See also
Functions
bae_defmenutext,
bae_getmenutext.
bae_planddbclass - Get BAE element DDB class code (STD)
Synopsis
int bae_planddbclass( // Returns BAE element DDB class code (STD1)
);
Description
The
bae_planddbclass functions returns the DDB class code of the currently loaded BAE element. Possible
Schematic Editor return values are 800 for SCM sheet, 801 for SCM symbol, 802 for SCM marker or 803 for SCM label. Possible BAE Layout return values are 100 for PCB layout, 101 for layout part, 102 for layout padstack or 103 for layout pad. Possible
IC Design return values are 1000 for IC layout, 1001 for IC cell and 1001 for IC pin. The function returns (-1) if no element is loaded.
bae_planename - Get BAE element name (STD)
Synopsis
string bae_planename( // Returns BAE element name
);
Description
The
bae_planename function returns the element name of the currently loaded BAE element or an empty string if no element is currently loaded.
See also
Function
bae_plansename.
bae_planfname - Get BAE element file name (STD)
Synopsis
string bae_planfname( // Returns BAE element file name
);
Description
The
bae_planfname function returns file name of the currently loaded BAE element or and empty string if no element is currently loaded.
See also
Functions
bae_plansfname,
bae_setplanfname.
bae_plannotsaved - Get BAE element not saved flag (STD)
Synopsis
int bae_plannotsaved( // Returns BAE element not saved flag
);
Description
The
bae_plannotsaved function checks whether the currently loaded BAE element has been saved. The functions zero if the element has been saved or 1 if changes have been made since the last save.
bae_plansename - Get BAE destination element name (STD)
Synopsis
string bae_plansename( // Returns BAE destination element name
);
Description
The
bae_plansename function returns the destination element name of the currently loaded BAE element or an empty string if no element is currently loaded. This function should be used for element name queries during
operations.
See also
Function
bae_planename.
bae_plansfname - Get BAE destination element file name (STD)
Synopsis
string bae_plansfname( // Returns BAE destination element file name
);
Description
The
bae_plansfname function returns the destination file name of the currently loaded BAE element or an empty string if no element is currently loaded. This function should be used for element file name queries during
operations.
See also
Function
bae_planfname.
bae_planwslx - Get BAE element left workspace boundary (STD)
Synopsis
double bae_planwslx( // Returns left workspace boundary (STD2)
);
Description
The
bae_planwslx function returns the left (lower X) workspace boundary of the currently loaded BAE element.
bae_planwsly - Get BAE element lower workspace boundary (STD)
Synopsis
double bae_planwsly( // Returns lower workspace boundary (STD2)
);
Description
The
bae_planwsly function returns the lower (lower Y) workspace boundary of the currently loaded BAE element.
bae_planwsnx - Get BAE element origin X coordinate (STD)
Synopsis
double bae_planwsnx( // Returns origin X coordinate (STD2)
);
Description
The
bae_planwsnx function returns the origin X coordinate of the currently loaded BAE element.
bae_planwsny - Get BAE element origin Y coordinate (STD)
Synopsis
double bae_planwsny( // Returns origin Y coordinate (STD2)
);
Description
The
bae_planwsny function returns the origin Y coordinate of the currently loaded BAE element.
bae_planwsux - Get BAE element right workspace boundary (STD)
Synopsis
double bae_planwsux( // Returns right workspace boundary (STD2)
);
Description
The
bae_planwsux function returns the right (upper X) workspace boundary of the currently loaded BAE element.
bae_planwsuy - Get BAE element upper workspace boundary (STD)
Synopsis
double bae_planwsuy( // Returns upper workspace boundary (STD2)
);
Description
The
bae_planwsuy function returns the upper (upper Y) workspace boundary of the currently loaded BAE element.
bae_popareachoice - Define choice field in active BAE popup menu (STD)
Synopsis
int bae_popareachoice( // Returns status
double [0.0,[; // From row number
double [0.0,[; // From column number
double [0.0,[; // To row number
double [0.0,[; // To column number
string; // Selection return string
);
Description
The
bae_popareachoice function defines a rectangular selection field in the currently active popup menu area. The active popup menu area is selected with the
bae_popsetarea function and can be either the standard popup menu area to be defined and/or displayed with
bae_popshow or the toolbar menu area to be defined and/or displayed with
bae_settbsize. The selection area is defined with the text row and column range function parameters, whereas row zero refers to the top of the popup area and column zero refers to the left of the popup area. The
bae_tbsize function can be used to retrieve the current toolbar dimensions. The
bae_charsize function can be utilized to convert text coordinates to standard length units. The selection return string parameter defines the answer string to be returned with the
bae_readtext function on selections in the defined choice area. The function returns (-1) on missing and/or invalid parameter specifications, 1 if a button was created, or zero otherwise.
See also
Functions bae_charsize,
bae_popcolbar,
bae_popcolchoice,
bae_popsetarea,
bae_popshow,
bae_poptext,
bae_poptextchoice,
bae_readtext,
bae_settbsize,
bae_tbsize.
bae_popcliparea - Define clipping area in active BAE popup menu (STD)
Synopsis
void bae_popcliparea(
int [0,1]; // Clipping enable flag:
// 0 = disable clipping
// 1 = enable clipping
double [0.0,[; // From row number
double [0.0,[; // From column number
double [0.0,[; // To row number
double [0.0,[; // To column number
);
Description
The
bae_popcliparea function enables (clipping enable flag nonzero) and/or disables (clipping enable flag zero) clipping in the currently active BAE popup menu area. The active popup menu area is selected with the
bae_popsetarea function and can be either the standard popup menu area to be defined and/or displayed with
bae_popshow or the toolbar menu area to be defined and/or displayed with
bae_settbsize. Clipping is most useful for restricting graphic output to certain areas when displaying polygons in popup areas and/or toolbars using the
bae_popdrawpoly function. The clipping area is defined with the text row and column range function parameters, whereas row zero refers to the top of the popup area and column zero refers to the left of the popup area. The
bae_charsize function can be utilized to convert text coordinates to standard length units.
See also
Functions
bae_charsize,
bae_popdrawpoly,
bae_popsetarea,
bae_popshow,
bae_settbsize.
bae_popclrtool - Clear BAE toolbar popup area (STD)
Synopsis
void bae_popclrtool(
);
Description
The
bae_popclrtool function can be used to clear and/or deactivate all elements from the current toolbar area.
See also
Functions
bae_popsetarea,
bae_settbsize.
bae_popcolbar - Define BAE popup menu color bar display (STD)
Synopsis
int bae_popcolbar( // Returns nonzero on error
double [0.0,[; // From row number
double [0.0,[; // From column number
double [0.0,[; // To row number
double [0.0,[; // To column number
int [0,[; // Color value (STD18)
);
Description
The
bae_popcolbar function defines a non-selectable color bar in the popup menu previously activated by
bae_popshow. The color bar size and position emerge from the specified row and column parameters with the zero coordinate [0,0] referring to the top left corner of the popup area. The color bar's color is specified with the given color value parameter. The function returns nonzero on invalid parameter specifications.
See also
Functions
bae_popcolchoice,
bae_popshow,
bae_poptext,
bae_poptextchoice.
bae_popcolchoice - Define BAE popup menu color bar selector (STD)
Synopsis
int bae_popcolchoice( // Returns nonzero on error
double [0.0,[; // From row number
double [0.0,[; // From column number
double [0.0,[; // To row number
double [0.0,[; // To column number
int [0,[; // Color value (STD18)
string; // Answer string to be returned
);
Description
The
bae_popcolchoice function defines a mouse-selectable color bar in the popup menu previously activated by
bae_popshow. The color bar size and position emerge from the specified row and column parameters with the zero coordinate [0,0] referring to the top left corner of the popup area. The color bar's color is specified with the given color value parameter. The function returns nonzero on invalid parameter specifications. The selection of a color bar defined with
bae_popcolchoice can be enabled through a call to the
bae_readtext function. The
bae_readtext return value is then set to the
bae_popcolchoice answer string parameter.
See also
Functions
bae_popcolbar,
bae_popshow,
bae_poptext,
bae_poptextchoice,
bae_readtext.
bae_popdrawpoly - Display/draw polygon in active BAE popup menu (STD)
Synopsis
int bae_popdrawpoly( // Returns status
int [0,[; // Polygon color (STD18)
int [0,3]; // Polygon drawing mode (STD19)
int [0,15]; // Polygon fill mode (STD20)
);
Description
The
bae_popdrawpoly function draws the internal polygon defined with the
bae_storepoint function to the currently active popup menu area using the color, drawing mode and filling properties specified with the corresponding function parameters. The active popup menu area is selected with the
bae_popsetarea function and can be either the standard popup menu area to be defined and/or displayed with
bae_popshow or the toolbar menu area to be defined and/or displayed with
bae_settbsize. The polygon display can be restricted to a certain popup menu region using the
bae_popcliparea function. The
bae_popareachoice function can be utilized for allowing the polygon display or certain parts of it to be selected with the
bae_readtext function. The
bae_setpopdash function can be used to set the base length for dash lines. The
bae_clearpoints function can be used to clear the internal polygon data to prepare for subsequent polygon definitions. The function returns zero if the polygon was drawn without errors or nonzero otherwise.
See also
Functions
bae_clearpoints,
bae_dialbmpalloc,
bae_popareachoice,
bae_popcliparea,
bae_popcolbar,
bae_popcolchoice,
bae_popdrawtext,
bae_popsetarea,
bae_popshow,
bae_readtext,
bae_setpopdash,
bae_settbsize,
bae_storepoint.
bae_popdrawtext - Display/draw text in active BAE popup menu (STD)
Synopsis
int bae_popdrawtext( // Returns status
int; // Text row
int; // Text column
int [0,[; // Text display color (STD18)
int [0,[; // Text background color (STD18)
string; // Text string
);
Description
The
bae_popdrawtext function displays the given text string at the specified row and column coordinates in the currently active popup menu area using the colors specified for text display and background. The active popup menu area is selected with the
bae_popsetarea function and can be either the standard popup menu area to be defined and/or displayed with
bae_popshow or the toolbar menu area to be defined and/or displayed with
bae_settbsize. The
bae_charsize function can be utilized to convert text coordinates to standard length units. The
bae_popareachoice function can be utilized for allowing the text display or certain parts of it to be selected with the
bae_readtext function. The function returns zero if the text was displayed without errors or nonzero otherwise.
See also
Functions
bae_charsize,
bae_dialbmpalloc,
bae_popareachoice,
bae_popdrawpoly,
bae_popsetarea,
bae_popshow,
bae_readtext,
bae_settbsize.
bae_popmouse - Get BAE popup/toolbar mouse position (STD)
Synopsis
void bae_popmouse(
& double; // Returns mouse X coordinate/column
& double; // Returns mouse Y coordinate/row
& int; // Returns mouse state:
// Bit 1 : Left mouse button pressed
// Bit 2 : Right mouse button pressed
// Bit 3 : Middle mouse button pressed
);
Description
The
bae_wsmouse function retrieves the current mouse coordinates (column and row) with the popup and/or toolbar area. The mouse state return parameter can be used to designate which mouse buttons are currently pressed.
See also
Function
bae_wsmouse.
bae_poprestore - Restore BAE popup menu area (STD)
Synopsis
void bae_poprestore(
);
Description
The
bae_poprestore function releases and restores the popup graphic work area previously defined with
bae_popshow.
See also
Function
bae_popshow.
bae_popsetarea - Clear BAE toolbar popup area (STD)
Synopsis
void bae_popsetarea(
int // Popup area code:
// 0 = Popup menu area
// 1 = Toolbar area
// 2..31 = Dialog bitmap area
);
Description
The
bae_popsetarea function activates the toolbar area (popup area code 1), the standard popup menu area (popup area code 2) or a dialog bitmap area (popup area code and/or popup bitmap number 2 through 31) for subsequent popup operations such as
bae_popareachoice,
bae_popcliparea,
bae_popdrawpoly or
bae_popdrawtext. The standard popup menu area is defined and/or displayed with the
bae_popshow function. The toolbar popup menu area is defined and/or displayed with the
bae_settbsize function. On default, the standard popup menu area is selected for popup operations.
See also
Functions
bae_dialbmpalloc,
bae_popareachoice,
bae_popcliparea,
bae_popdrawpoly,
bae_popdrawtext,
bae_popshow,
bae_settbsize.
bae_popshow - Activate BAE popup menu (STD)
Synopsis
int bae_popshow( // Returns nonzero on error
& double [0.0,[; // Popup rows count
& double [0.0,[; // Popup columns count
& double [0,1.0]; // Popup percentage left boundary
& double [0,1.0]; // Popup percentage bottom boundary
& double [0,1.0]; // Popup percentage right boundary
& double [0,1.0]; // Popup percentage top boundary
);
Description
The
bae_popshow function defines and generates a popup menu with the given parameters. The popup menu position and size emerge from the specified popup boundary parameters; the given values are interpreted relatively to the available graphic work area size; the boundary values range from 0.0 (minimum and/or left/lower boundary) to 1.0 (maximum and/or right/upper boundary). The
bae_mtpsize function can be used for determining the number of columns and/or rows available for popup display. The requested popup size is specified with the popup row and column count input parameters. These parameters are automatically re-calculated by
bae_popshow to denote the row and column counts actually visible in the given popup area boundaries. The function returns nonzero on invalid and/or inconsistent parameter specifications. The popup menu colors for texts, background and frame are taken from the corresponding BAE setup menu color values stored with the
bsetup utility program. The
bae_popareachoice,
bae_popcolbar,
bae_popcolchoice,
bae_popdrawpoly,
bae_popdrawtext,
bae_poptext and
bae_poptextchoice functions can be used after calling
bae_popshow to define selectable and non-selectable color bars, text buttons, graphic display and selection areas in the popup menu. The popup menu item selections can be enabled by calling the
bae_readtext function.
Warning
The
bae_poprestore function must be used to release and/or restore any graphic work area occupied by a popup menu.
See also
Functions
bae_mtpsize,
bae_popareachoice,
bae_popcliparea,
bae_popcolbar,
bae_popcolchoice,
bae_popdrawpoly,
bae_popdrawtext,
bae_poprestore,
bae_popsetarea,
bae_poptext,
bae_poptextchoice,
bae_readtext,
bae_settbsize, and BAE utility program
bsetup.
bae_poptext - Define BAE popup menu text display (STD)
Synopsis
int bae_poptext( // Returns nonzero on error
double [0.0,[; // Text row number
double [0.0,[; // Text column number
string; // Text string
);
Description
The
bae_poptext function defines a non-selectable text in the popup menu previously activated by
bae_popshow. The text display position emerges from the specified row and column parameters with the zero coordinate [0,0] referring to the top left corner of the popup area. The text to be displayed is specified with the given text string parameter. The function returns nonzero on invalid parameter specifications.
See also
Functions
bae_popcolbar,
bae_popcolchoice,
bae_popshow,
bae_poptextchoice.
bae_poptextchoice - Define BAE popup menu text selector (STD)
Synopsis
int bae_poptextchoice( // Returns nonzero on error
double [0.0,[; // Text row number
double [0.0,[; // Text column number
string; // Text string
string; // Answer string to be returned
);
Description
The
bae_poptextchoice function defines a mouse-selectable text in the popup menu previously activated by
bae_popshow. The text display position emerges from the specified row and column parameters with the zero coordinate [0,0] referring to the top left corner of the popup area. The text to be displayed is specified with the given text string parameter. The function returns nonzero on invalid parameter specifications. The selection of a text button defined with
bae_poptextchoice can be enabled through a call to the
bae_readtext function. The
bae_readtext return value is then set to the
bae_poptextchoice answer string parameter.
See also
Functions
bae_popcolbar,
bae_popcolchoice,
bae_popshow,
bae_poptext,
bae_readtext.
bae_postprocess - Run BAE postprocess (STD)
Synopsis
void bae_postprocess(
);
Description
The
bae_postprocess function runs a BAE postprocess on the currently loaded element. On layout level, the BAE postprocess forces a connectivity update and a design rule check.
bae_progdir - Get BAE program directory path name (STD)
Synopsis
string bae_progdir( // Returns BAE program directory path
);
Description
The
bae_progdir function returns the currently valid BAE programs directory path name. This information is useful for accessing data in the BAE programs directory (e.g., system color tables, aperture tables, etc.).
bae_prtdialog - Print string to BAE dialogue line (STD)
Synopsis
void bae_prtdialog(
string; // Message string
);
Description
The
bae_prtdialog function displays the specified message string in the BAE status line.
See also
Function
perror.
bae_querydist - Query BAE point to polygon distance (STD)
Synopsis
int bae_querydist( // Returns status
double; // Query X coordinate (STD2)
double; // Query Y coordinate (STD2)
& double; // Query distance return value (STD2)
);
Description
The
bae_querydist gets the distance between the point specified through the X and Y coordinate parameters and the internal distance query polygon previously stored with the
bae_storedistpoly function. The resulting distance is returned with the last function parameter. The distance value is positive for points outside the distance query polygon and negative for points inside the distance query polygon. The function returns zero if no error occurred or nonzero on error (missing distance query polygon).
See also
Function
bae_storedistpoly.
bae_readedittext - BAE text input/display (STD)
Synopsis
string bae_readedittext( // Returns answer string
string; // Prompt string
// ! prefix: Multiline text input/edit
// otherwise: Single line text input
string; // Default answer string
int [0,[; // Maximum input string length
);
Description
The
bae_readedittext function activates a text edit dialog with the prompt string being displayed in the dialog title bar. A multiline edit window instead of a single-line text edit box is activated if the first prompt string character is a quotation mark
(!).
The size of the dialog window can be changed if in multiline edit mode.
The text edit box contents is initialyzed with the specified default answer string. The edit dialog provides an
button for accepting the input and an
button for cancelling the text input operation. The maximum input/aswer string length is limited through the third function parameter.
causes the default answer string instead of the current edit text to be returned to the caller. The multiline text edit dialog provides additional buttons for loading contents from selectable input files into the text edit window
() and for saving the current edit text to output files
().
Warning
BAE Demo does not provide the option for saving the edit text and also deactivates the Windows context menu function for copying the edit text onto the clipboard.
See also
Function
bae_readtext.
bae_readtext - BAE text input with popup menu (STD)
Synopsis
string bae_readtext( // Returns answer string
string; // Prompt string
int; // Maximum input string length
);
Description
The
bae_readtext function asks the user for a string value. The required interaction is indicated by the given prompt string. The user input string value is passed with the function return value. The maximum keyboard input string length is specified with the corresponding function parameter. Mouse click input text is returned if previously enabled with the
bae_setmousetext function; such mouse click default text input is disabled through the
bae_readtext call. Popup menu item selections are simultaneously enabled by
bae_readtext if a popup menu was previously defined with the
bae_popshow function and mouse click text input is disabled. Possible popup menu selections are defined through
bae_popcolchoice and/or
bae_poptextchoice. The function return value is retrieved from the corresponding answer string parameters.
Warning
The
bae_readtext function deactivates all selection elements previously defined with
bae_popcolchoice,
bae_poptextchoice or
bae_setmousetext.
See also
Functions
bae_popcolchoice,
bae_popshow,
bae_poptextchoice,
bae_readedittext,
bae_setmousetext.
bae_redefmainmenu - BAE main menu redefinition start (STD)
Synopsis
int bae_redefmainmenu( // Returns status
);
Description
The
bae_redefmainmenu function starts the (re)definition of the main menu of the currently active BAE module. The function returns (-1) on error or zero otherwise. After calling
bae_redefmainmenu, the
bae_defmenu (to be terminated with
bae_endmenu) should be applied for defining the main menu entries. Then the
bae_defselmenu (to be terminated with
bae_endmenu) can be applied for configuring the submenus. Between
bae_defmenu or
bae_defselmenu calls and the call to
bae_endmenu the
bae_defmenutext function should be applied for defining the menu entries. The menu definition initiated with
bae_redefmenu must be terminated by a call to the
bae_endmainmenu function. The
bae_resetmenuprog function can be used to reset all menu assignments, thus restoring the default menu configuration of the currently active BAE module.
See also
Functions
bae_defmenu,
bae_defmenuprog,
bae_defmenutext,
bae_defselmenu,
bae_endmainmenu,
bae_endmenu,
bae_redefmenu,
bae_resetmenuprog.
bae_redefmenu - Redefine BAE menu item (STD)
Synopsis
int bae_redefmenu( // Returns status
int [0,999]; // Menu number
int [0,99]; // Menu line
string; // Menu text
int; // BAE menu function code (STD4)
int; // Menu entry processing key:
// 8000000h = always available
// 7FFFFFFh = available for each element type
// else = (combined) DDB class processing key
);
Description
The
bae_redefmenu function assigns the specified menu text and the BAE menu function to the given menu entry. The menu number specifies the number of the main menu, whilst the menu line designates the position in the according submenu. The menu entry processing key activates ghost menu configurations. The processing key is a coded integer value as retrieved and/or defined using the
bae_getclassbitfield and
bae_getmenubitfield functions (the hex value 80000000h can be used to allow for application in any case). The function returns (-1) on error or zero otherwise. The
bae_resetmenuprog function can be used to reset all menu assignments, thus restoring the default menu configuration of the currently active BAE module.
See also
Functions
bae_defmenuprog,
bae_getclassbitfield,
bae_getmenubitfield,
bae_redefmenu,
bae_resetmenuprog.
bae_resetmenuprog - Reset BAE menu definitions (STD)
Synopsis
void bae_resetmenuprog(
);
Description
The
bae_resetmenuprog function resets all key and menu assignments, thus restoring the default menu configuration of the currently active BAE module.
See also
Functions
bae_deffuncprog,
bae_defkeyprog,
bae_defmenu,
bae_defmenuprog,
bae_defmenutext,
bae_defselmenu,
bae_redefmainmenu,
bae_redefmenu.
bae_sendmsg - Send BAE HighEnd message (STD/HighEnd)
Synopsis
int bae_sendmsg( // Returns status
string; // Message text string
int [0,1]; // Send to projects members only flag
);
Description
The
bae_sendmsg function is only available in
BAE HighEnd. The function return value is nonzero if called outside
BAE HighEnd or on invalid parameter specifications.
bae_sendmsg sends the specified message string to the
BAE HighEnd message system. The second parameter controls whether the message should be send to all other BAE modules started in the same session or only to those BAE program instances which are currently processing elements from the same DDB file. A
BAE HighEnd session is started with a BAE call and includes any other BAE program instance subsequently started with the
function from the BAE main menu or with the
function from the
Schematic Editor. Each
BAE HighEnd module receiving a message automatically activates the
User Language program named
bae_msg. If
bae_msg is not available, the system tries to start an interpreter-specific
User Language program
(scm_msg in the Schematic Editor,
ged_msg in the Layout Editor,
ar_msg in the Schematic Editor, etc.). The
bae_getmsg function must be used in the
*_msg
User Language program to retrieve pending messages. Pending messages are only available during the execution of the
*_msg
User Language program, i.e., any message not retrieved by
*_msg is lost. The message text string can be used to trigger certain actions in the destination program instances.
See also
Function
bae_getmsg.
bae_setanglelock - Set BAE angle lock flag (STD)
Synopsis
int bae_setanglelock( // Returns status
int [0,1]; // Required angle lock flag (STD9)
);
Description
The
bae_setanglelock function sets the current BAE angle lock mode (0=angle unlocked, 1=angle locked). The function returns nonzero if an invalid angle lock flag value has been specified.
See also
Function
bae_getanglelock.
bae_setbackgrid - Set BAE display grid (STD)
Synopsis
int bae_setbackgrid( // Returns status
double [0.0,[; // Required X display grid (STD2)
double [0.0,[; // Required Y display grid (STD2)
);
Description
The
bae_setbackgrid function sets the BAE X/Y display grid values. Zero grid values refer to switched-off grids. The function returns nonzero, if invalid grid values are specified.
See also
Function
bae_getbackgrid.
bae_setclipboard - Store text string to (Windows) clipboard (STD)
Synopsis
int bae_setclipboard( // Returns status
string; // Text string
);
Description
The
bae_setclipboard function saves the specified text string to the Windows clipboard. The function returns zero if done, or nonzero on error.
bae_setcolor - Set BAE color value (STD)
Synopsis
int bae_setcolor( // Returns status
int; // Display item type (SCM1|LAY9|ICD9)
int; // Color value (STD18)
);
Description
The
bae_setcolor function sets the color for the given display item type to the specified value. The display item type value must be set according to the currently active
User Language Interpreter environment. The function returns nonzero on error.
Warning
To avoid redundant screen redraws at the color table redefinition, the
bae_setcolor system function does not perform a screen redraw. I.e., it is the responsibility of the caller to trigger screen redraws as required at the end of a color table definition sequence.
See also
Function
bae_getcolor.
bae_setcoorddisp - Set BAE coordinate display mode (STD)
Synopsis
int bae_setcoorddisp( // Returns status
int [0,1]; // Required coordinate display mode (STD7)
);
Description
The
bae_setcoorddisp function sets the current BAE coordinate display mode. The display mode is passed with the parameter, where 0 designates mm display units (micrometer in
IC Design) and 1 designates Inch display units (mil units in
IC Design). The function returns nonzero for invalid display mode parameters or zero otherwise.
See also
Function
bae_getcoorddisp.
bae_setdblpar - Set BAE double parameter (STD)
Synopsis
int bae_setdblpar( // Returns status
int [0,[; // Parameter type/number:
// 0 = maximum dialog box width
// 1 = maximum dialog box height
// 2 = display zoom factor
// 3 = Rubberband corner radius (STD2)
// 4 = Rubberband X vector coordinate (STD2)
// 5 = Rubberband Y vector coordinate (STD2)
// 6 = fixed X pick coordinate (STD2)
// 7 = fixed Y pick coordinate (STD2)
// [ 8 = System parameter - no write access ]
// [ 9 = System parameter - no write access ]
// 10 = Screen pick aperture (STD2)
// 11 = Element selection preview area relative size [0.05, 0.95]
// [ 12 = System parameter - no write access ]
// [ 13 = System parameter - no write access ]
double; // Parameter value
);
Description
The
bae_setdblpar function is used to set
Bartels AutoEngineer double system parameters. The function returns zero if the parameter assignment was successful, or (-1) otherwise. The
bae_getdblpar function can be used to query parameter values set with
bae_setdblpar.
See also
Functions
bae_getdblpar,
bae_getintpar,
bae_getstrpar,
bae_setintpar,
bae_setstrpar.
bae_setgridlock - Set BAE grid lock flag (STD)
Synopsis
int bae_setgridlock( // Returns status
int [0,1]; // Required grid lock flag (STD8)
);
Description
The
bae_setgridlock function sets the current BAE grid lock mode (0=grid unlocked, 1=grid locked). The function returns nonzero if an invalid grid lock flag value was specified.
See also
Function
bae_getgridlock.
bae_setgridmode - Set BAE grid dependency mode (STD)
Synopsis
int bae_setgridmode( // Returns status
int [0,255]; // Automatic gid setting mode:
// 0x01: input grid = 0.25 × display grid
// 0x02: input grid = 0.50 × display grid
// 0x04: input grid = 1.00 × display grid
// 0x08: input grid = 2.00 × display grid
// 0x10: display grid = 0.25 × input grid
// 0x20: display grid = 0.50 × input grid
// 0x40: display grid = 1.00 × input grid
// 0x80: display grid = 2.00 × input grid
);
Description
The
bae_setgridmode function sets the BAE grid dependency mode. The function returns nonzero if an invalid grid dependency mode was specified.
See also
Function
bae_getgridmode.
bae_setinpgrid - Set BAE input grid (STD)
Synopsis
int bae_setinpgrid( // Returns status
double [0.0,[; // Required X input grid (STD2)
double [0.0,[; // Required Y input grid (STD2)
);
Description
The
bae_setinpgrid function sets the BAE X/Y input grid values. Zero grid values refer to switched-off grids. The function returns nonzero if invalid grid values are specified.
See also
Function
bae_getinpgrid.
bae_setintpar - Set BAE integer parameter (STD)
Synopsis
int bae_setintpar( // Returns status
int [0,[; // Parameter type/number:
// 0 = Input coordinate range check mode:
// 0 = range check enabled
// 1 = range check disabled
// 1 = Module change autosave mode:
// 0 = autosave without prompt
// 1 = prompt before autosave
// 2 = Display disable mode:
// 0 = display enabled check
// 1 = display disabled
// [ 3 = Menu/mouse mode: ]
// [ system parameter write-protected ]
// 4 = Workspace text color mode:
// 0 = standard colors
// 1 = inverted standard colors
// 2 = workspace related colors
// 5 = Load display mode:
// 0 = display overview after load
// 1 = handle load display in bae_load
// 6 = File dialog view:
// 0 = old BAE style file selection
// 1 = Explorer style default view
// 2 = Explorer style list view
// 3 = Explorer style details
// 4 = Explorer style small icons
// 5 = Explorer style large icons
// 6 = Use default style and size
// 7 = Element selection box mode:
// 0 = display name only
// 1 = display name and date
// 8 = Element selection sort mode:
// 0|1 = sort by name
// 2 = sort numerically
// 3 = sort by date
// 9 = Inverted placement visibility flag:
// 0 = placed elements visible
// 1 = unplaced elements visible
// [ 10 = Last file system error: ]
// [ system parameter write-protected ]
// 11 = Command history disable flag:
// 0 = Command history enabled
// 1 = Command history disabled
// 12 = Popup menu mouse warp mode:
// 0 = No popup menu mouse warp
// 1 = First popup menu entry mouse warp
// 2 = Preselected menu entry mouse warp
// +4 = Mouse position restore warp
// +8 = Element pick position warp
// 13 = Save disable flag:
// 0 = save enabled
// 1 = save disabled
// 14 = Mouse rectangle min. size:
// ]0,[ = min. rectangle size
// 15 = Menu selection mouse info display flag:
// 0 = no continuous info display
// 1 = continuous info display
// 16 = Next dialog box id
// 17 = Last created tooltip id
// 18 = Polygon drop count
// 19 = Polygon check disabled flag:
// 0 = Enable polygon check
// 1 = Disable polygon check
// 20 = Cursor key grid mode:
// 0 = Input grid
// 1 = Pixel grid
// 21 = Unsaved plan flag
// 22 = Element batch load mode:
// 0 = no batch load
// 1 = Batch load
// 2 = batch load, restore zoom window
// 23 = Grid lines display:
// 0 = Dot grid
// 1 = Line grid
// 24 = Display mirroring flag
// 25 = Input grid display flag
// 26 = Mouse function repeat mode:
// 0 = Repeat menu function
// +1 = Repeat keystroke function
// +2 = Repeat context menu function
// [ 27 = Maximum Undo/Redo count: ]
// [ system parameter write-protected ]
// 28 = Menu tree view mode:
// 0 = No menu tree view window
// 1 = Left attached menu tree view window
// 2 = Right attached menu tree view window
// 29 = Menu tree view pixel width
// 30 = Message history disabled flag
// 31 = Element load message mode:
// 0 = Standard message
// 1 = User message
// 2 = User error message
// 32 = Pick marker display mode:
// 0 = Circle marker
// 1 = Diamond marker
// 33 = Mouse drag status:
// 0 = No mouse drag
// 1 = Request mouse drag
// 2 = Mouse dragged
// 3 = Request mouse drag release
// 34 = Menu function repeat request flag
// 35 = Function aborted flag
// 36 = Plan selection preview flag
// 37 = File error display mode:
// 0 = Status message only
// 1 = Confirm message box
// 38 = Element selection reference display mode:
// 0 = Display project file references
// 1 = Display library file references
// 39 = Mouse double-click mode:
// 0 = Map double-click and select 0 to right mouse button
// 1 = Ignore double-click
// 2 = Map double-click to right mouse button
// 40 = Mouse pick double-click mode:
// 0 = Map double-click to right mouse button
// 1 = Ignore double-click
// [ 41 = Dialog control support flags: ]
// [ system parameter write-protected ]
// 42 = Progress box display mode:
// 0 = No progress box window
// 1 = Display progress window
// 43 = Progress box abort request flag:
// 44 = Middle mouse button disable flag:
// [ 45 = Current undo items count: ]
// [ system parameter write-protected ]
// [ 46 = File drag and drop operation flag.: ]
// [ system parameter write-protected ]
// 47 = Autoraise BAE window flag
// [ 48 = Menu function active count ]
// [ system parameter write-protected ]
// [ 49 = Internal polygon list point count ]
// [ system parameter write-protected ]
// 50 = Alternate configuration file priority
// 51 = Dialog position save mode:
// 0 = Store absolute coordinates
// 1 = Store main window relative coordinates
// 2 = Store main window monitor absolute coordinates
// 52 = Message box default button index:
// (-1) = No default (Abort or No)
// 0-2 = Default button index
int; // Parameter value
);
Description
The
bae_setintpar function is used to set
Bartels AutoEngineer integer system parameters. The function returns zero if the parameter assignment was successful, or (-1) otherwise. The
bae_getintpar function can be used to query parameter values set with
bae_setintpar.
See also
Functions
bae_getdblpar,
bae_getintpar,
bae_getstrpar,
bae_setdblpar,
bae_setstrpar.
bae_setmoduleid - Set BAE module id (STD)
Synopsis
int bae_setmoduleid( // Status
string; // Module id
);
Description
The
bae_setmoduleid sets a name/identification for the currently active BAE program module. The function returns zero if the module id was successfully assigned or nonzero on error.
See also
Function
bae_getmoduleid.
bae_setmousetext - Set BAE mouse click input text (STD)
Synopsis
int bae_setmousetext( // Returns nonzero on error
string; // Answer text string to be returned
);
Description
The
bae_setmousetext function enables the specified answer string to be the default mouse click return value for the next
bae_readtext call. The next call to
bae_readtext resets the mouse click default text.
See also
Function
bae_readtext.
bae_setplanfname - Set BAE project file name (STD)
Synopsis
int bae_setplanfname( // Returns status
string; // BAE project file name
);
Description
The
bae_setplanfname function sets the BAE DDB project file name. The
.ddb file name extension if a BAE project file name without file name extension is specified. The function returns zero if the BAE project file name was successfully assigned, 1 if parameter specifications are missing and/or invalid or 2 if a BAE project file name is already assigned through the currently loaded element.
See also
Function
bae_planfname.
bae_setpopdash - Set BAE popup/toolbar polygon dash line parameters (STD)
Synopsis
void bae_setpopdash(
double ]0.0,[; // Dash base length (STD2)
double ]-0.5,0.5[; // Dash relative spacing
);
Description
The
bae_setpopdash function sets the base length and the relative spacing for dash lines to be created in popup menus and/or toolbars with the
bae_popdrawpoly function.
See also
Function
bae_popdrawpoly.
bae_setstrpar - Set BAE string parameter (STD)
Synopsis
int bae_setstrpar( // Returns status
int [0,[; // Parameter type/number:
// 0 = Current element comment text
// 1 = Current element specification
// [ 2 = System parameter - no write access ]
// [ 3 = System parameter - no write access ]
// 4 = Crosshair info text
// 5 = Tooltip text
// [ 6 = System parameter - no write access ]
// 7 = Menu text of currently active funktion
// 8 = Current menu item element text
// 9 = Current element load user message
// 10 = Clipboard text string
// 11 = Next module call file argument
// 12 = Next module call element argument
// 13 = Next module call command/type argument
// 14 = Last output file name
// [ 15 = System parameter - no write access ]
// 16 = Toolbar button character/resource item
// [ 17 = System parameter - no write access ]
// [ 18 = System parameter - no write access ]
// 19 = Alternate configuration data directory
// 20 = Local data column
// 21 = Global data column
string; // Parameter value
);
Description
The
bae_setstrpar function is used to set
Bartels AutoEngineer string system parameters. The function returns zero if the parameter assignment was successful, or (-1) otherwise. The
bae_getstrpar function can be used to query parameter values set with
bae_setstrpar.
See also
Functions
bae_getdblpar,
bae_getintpar,
bae_getstrpar,
bae_setdblpar,
bae_setintpar.
bae_settbsize - Define/display BAE toolbar area (STD)
Synopsis
void bae_settbsize(
double [0.0,[; // Toolbar size
int [0,3]; // Toolbar attachment mode:
// 0 = horizontally attached to
// lower workspace boundary
// 1 = vertically attached to
// right workspace boundary
// 2 = horizontally attached to
// upper workspace boundary
// 3 = vertically attached to
// left workspace boundary
);
Description
The
bae_settbsize function defines and/or displays a toolbar. The first parameter specifies the desired toolbar size depending on the attachment mode, i.e., with vertical attachment the toolbar size is interpreted as column count, whilst with horizontal attachment the toolbar size is interpreted as row count. A zero toolbar size specification can be used to fade out a currently visible toolbar. The dimension of the graphic area available for displaying toolbars can be retrieved with the
bae_mtpsize function. The
bae_tbsize function can be used to retrieve the current toolbar dimensions. The
bae_popsetarea function activates either the toolbar or the standard popup menu for subsequent popup operations. The
bae_popclrtool function can be used to clear and/or deactivate all elements from the current toolbar area.
See also
Functions
bae_mtpsize,
bae_popclrtool,
bae_popsetarea,
bae_tbsize.
bae_storecmdbuf - Store BAE command to command history (STD)
Synopsis
int bae_storecmdbuf( // Returns status
int [0,[; // Command store mode
// 0 : append command to history
string; // Command (sequence) string
string; // Command notification text
);
Description
The
bae_storecmdbuf function adds the specified command to the current BAE command history. The command store mode is used to specify the location for storing the command in the history and/or whether or how the command history should be reorganized. The command (sequence) string and the command notification text (as displayed in the title bar) are specified through the second and third function parameter. The function returns zero if the assignment was successful or non-zero otherwise.
See also
Function bae_getcmdbuf.
bae_storedistpoly - Store internal BAE distance query polygon (STD)
Synopsis
int bae_storedistpoly( // Status
);
Description
The
bae_storedistpoly function stores the internal polygon created with
bae_clearpoints and
bae_storepoint as distance query polygon. The
bae_querydist can then be used to query the distance between a given point and the distance query polygon. The
bae_cleardistpoly function can be used to delete the distance query polygon. The function returns zero if no error occurred, (-1) if the internal distance query polygon is already defined or (-2) in case of invalid polygon data.
See also
Functions
bae_cleardistpoly,
bae_clearpoints,
bae_querydist,
bae_storepoint.
bae_storeelem - Store BAE element (STD)
Synopsis
int bae_storeelem( // Returns status
string; // File name
string; // Element name
);
Description
The
bae_storeelem function stores the currently loaded BAE element to the specified file (i.e., this function is equivalent to
function from the
menu). The function returns 0 if the element has been successfully stored, 1 on invalid function parameters, 2 if no BAE element is currently loaded or (-1) on file access errors.
bae_storekeyiact - Store BAE key-press interaction to queue (STD)
Synopsis
void bae_storekeyiact(
int [0,3]; // Automatic interaction mode (STD21)
int; // Key character code (ASCII)
);
Description
The
bae_storekeyiact function stores a key-press interaction to the interaction queue to be passed to a
bae_callmenu-activated BAE menu function. The given key character code is automatically passed if the interaction flag is set, otherwise an interactive user input is required.
See also
Functions
bae_peekiact,
bae_storemenuiact,
bae_storemouseiact,
bae_storetextiact.
bae_storemenuiact - Store BAE menu interaction to queue (STD)
Synopsis
void bae_storemenuiact(
int [0,3]; // Automatic interaction mode (STD21)
int; // Menu line number (0..n-1)
int [1,3]; // Mouse key (STD17)
);
Description
The
bae_storemenuiact function stores a menu interaction to the interaction queue to be passed to a
bae_callmenu-activated BAE menu function. The given menu selection with mouse-click is passed automatically passed if the interaction flag is set, otherwise an interactive user input is required.
See also
Functions
bae_peekiact,
bae_storekeyiact,
bae_storemouseiact,
bae_storetextiact.
bae_storemouseiact - Store BAE mouse interaction to queue (STD)
Synopsis
void bae_storemouseiact(
int [0,3]; // Automatic interaction mode (STD21)
double; // Mouse X coordinate (STD2)
double; // Mouse Y coordinate (STD2)
int [0,15]; // Mouse coordinate mode:
// 0 = use given coordinates with snap to input grid
// 1 = use old mouse coordinates
// 2 = use given coordinates gridless
// +4 = set mouse pointer to specified position
// +8 = activate BAE window
int [0,3]; // Mouse key code (STD17)
[]; // Keyboard input
);
Description
The
bae_storemouseiact function stores a mouse interaction to the interaction queue to be passed to a
bae_callmenu-activated BAE menu function. The given positioning with mouse-click is automatically passed if the interaction flag is set, otherwise an interactive user input is required. A character must be passed to the keyboard input parameter if the mouse key code is set to zero.
See also
Functions bae_callmenu,
bae_peekiact,
bae_storekeyiact,
bae_storemenuiact,
bae_storetextiact.
bae_storepoint - Store point to internal BAE polygon (STD)
Synopsis
int bae_storepoint( // Returns status
double; // Point X coordinate (STD2)
double; // Point Y coordinate (STD2)
int [0,2]; // Point type (STD15)
);
Description
The
bae_storepoint function stores the specified point to the internal polygon point list. The function returns nonzero if invalid point parameters have been specified. The internal polygon point list is required for generating polygons or traces using the module-specific
*_storepoly and/or
*_storepath functions or the
bae_storedistpoly function. The internal BAE polygon can be deleted/cleared with the
bae_clearpoints function.
See also
Functions
bae_clearpoints,
bae_getpolyrange,
bae_storedistpoly.
bae_storetextiact - Store BAE text input interaction to queue (STD)
Synopsis
void bae_storetextiact(
int [0,3]; // Automatic interaction mode (STD21)
string; // Input text string
);
Description
The
bae_storetextiact function stores a text input interaction to the interaction queue to be passed to a
bae_callmenu-activated BAE menu function. The given text string is automatically passed if the interaction flag is set, otherwise an interactive user input is required.
See also
Functions
bae_peekiact,
bae_storekeyiact,
bae_storemenuiact,
bae_storemouseiact.
bae_swconfig - Get BAE software configuration (STD)
Synopsis
int bae_swconfig( // Returns software configuration code:
// (-1) = invalid configuration class,
// for configuration class 0:
// 0 = unknown system
// 1 = Bartels ACAD-PCB
// 2 = BAE Professional
// 3 = BAE HighEnd
// for configuration class 1:
// 0 = not BAE Demo software
// 1 = BAE Demo software
// 2 = BAE FabView software
// for configuration class 2:
// nonzero = BAE Economy software
// for configuration class 3:
// 0 = BAE standard menu screen
// 1 = BAE Windows standard menu
// 2 = BAE Windows pull-down menu
// 3 = BAE Motif standard menu
// 4 = BAE Motif pull-down menu
// for configuration class 4:
// nonzero = BAE Light software
// for configuration class 5:
// 0 = no BAE Schematics software
// 1 = BAE Schematics
// 2 = BAE HighEnd Schematics
// for configuration class 6:
// BAE version build number
int; // Configuration class:
// 0 = BAE software system query
// 1 = BAE Demo software check
// 2 = BAE Economy software check
// 3 = BAE user interface type query
// 4 = BAE Light software check
// 5 = BAE Schematics software check
// 6 = BAE version build number query
);
Description
The
bae_swconfig function returns the currently active BAE software configuration. This information is required for performing correct menu selections using
bae_defmenuprog,
bae_callmenu and
bae_store*iact calls in different software configurations such as
BAE Professional,
BAE HighEnd,
BAE Economy and/or
BAE Light, or in different user interfaces such as BAE standard user interface or BAE pull-down user interface under DOS/X11, Windows or Motif.
See also
Function
bae_swversion.
bae_swversion - Get BAE software version (STD)
Synopsis
string bae_swversion( // Returns software version string
// or operating system setting
int; // Software version query mode:
// 0 = BAE version number
// 1 = BAE release year (format YY)
// 2 = BAE release year (format YYYY)
// 3 = Operating system specific
// pattern for arbitrary string match
// (e.g., * under Linux, .* under MS-DOS)
// 4 = Operating system specific
// directory name delimiter
// (e.g., / under Linux, \ under MS-DOS)
);
Description
The
bae_swversion function returns BAE software version information or operating system specific BAE settings according to the specified software version query mode.
See also
Function
bae_swconfig.
bae_tbsize - Get BAE toolbar dimensions (STD)
Synopsis
void bae_tbsize(
& double; // Returns toolbar text columns
& double; // Returns toolbar text rows
);
Description
The
bae_tbsize function retrieves the size of the toolbar area currently defined with the
bae_settbsize function. The toolbar width is returned with the toolbar text columns parameter, whilst the toolbar height is returned with the toolbar text rows parameter. The
bae_charsize function can be utilized to convert these values to standard length units.
See also
Functions
bae_charsize,
bae_mtpsize,
bae_settbsize.
bae_twsize - Get BAE text screen workspace size (STD)
Synopsis
void bae_twsize(
& int; // Returns text column count
& int; // Returns text row count
);
Description
The
bae_twsize function determines the current size of the BAE text screen workarea. The text screen size is returned through the parameters, with the first parameter returning the text column count, and the second parameter returning the text row count. These functions are useful for dynamically adapting output routines to the BAE graphic environment.
See also
Function
bae_mtpsize.
bae_wswinlx - Get BAE workspace window left boundary (STD)
Synopsis
double bae_wswinlx( // Left workspace window boundary (STD2)
);
Description
The
bae_wswinlx function returns the left boundary coordinate of the currently visible workspace window.
bae_wswinly - Get BAE workspace window lower boundary (STD)
Synopsis
double bae_wswinly( // Lower workspace window boundary (STD2)
);
Description
The
bae_wswinly function returns the lower boundary coordinate of the currently visible workspace window.
bae_wswinux - Get BAE workspace window right boundary (STD)
Synopsis
double bae_wswinux( // Right workspace window boundary (STD2)
);
Description
The
bae_wswinux function returns the right boundary coordinate of the currently visible workspace window.
bae_wswinuy - Get BAE workspace window upper boundary (STD)
Synopsis
double bae_wswinuy( // Upper workspace window boundary (STD2)
);
Description
The
bae_wswinuy function returns the upper boundary coordinate of the currently visible workspace window.
bae_wsmouse - Get BAE workspace mouse position (STD)
Synopsis
void bae_wsmouse(
& double; // Returns mouse X coordinate (STD2)
& double; // Returns mouse Y coordinate (STD2)
& int; // Returns mouse state:
// Bit 0 : Beyond left workspace boundary
// Bit 1 : Beyond right workspace boundary
// Bit 2 : Beyond lower workspace boundary
// Bit 3 : Beyond upper workspace boundary
// Bit 4 : Left mouse button pressed
// Bit 5 : Right mouse button pressed
// Bit 6 : Middle mouse button pressed
);
Description
The
bae_wsmouse function retrieves the current mouse coordinates within the graphic workarea. The mouse state return parameter can be used to designate which mouse buttons are currently pressed or whether the mouse coordinates exceed any of the workspace boundaries.
See also
Function
bae_popmouse.
catext - Concatenate file name extension (STD)
Synopsis
void catext(
& string; // File name
string; // File name extension
);
Description
The
catext function appends the specified file name extension to the file name provided with the first function parameter if that file name doesn't have this extension yet.
See also
Function catextadv.
catextadv - Optionally concatenate file name extension (STD)
Synopsis
void catextadv(
& string; // File name
string; // File name extension
int; // Extension mode:
// 0 = Apply extension only if
// no extension yet
// 1 = Assume file name contains
// none or specified extension
// 2 = Force specified extension
);
Description
The
catextadv function optionally appends the specified file name extension to the specified file name. The extension mode parameter control whether and/or under which circumstances the extension is appended.
See also
Function catext.
ceil - Ceiling function (STD)
Synopsis
double ceil( // Returns result value
double; // Input value
);
Description
The
ceil function calculates and returns the smallest "integer" greater than or equal to the specified input double value.
clock - Get elapsed processor time (STD)
Synopsis
double clock( // Returns elapsed CPU time (seconds)
);
Description
The
clock function returns (in seconds) the CPU time elapsed since the start of the currently active BAE program module. This value should be used only for comparison purposes.
con_clear - Delete internal logical net list (STD)
Synopsis
void con_clear(
);
Description
The
con_clear function deletes the net list data previously stored with
con_storepart and/or
con_storepin from main memory.
con_clear should always be applied before the first call to
con_storepart to avoid net list mix with previously stored net data. The
con_clear function should also be called as soon as the net list data is not needed any more, e.g., after finishing a net list transformation since otherwise you might run short of main memory.
See also
Functions
con_storepart,
con_storepin,
con_write.
con_compileloglib - Compile logical library definition (STD)
Synopsis
int con_compileloglib( // Returns status
string; // DDB destination file name
string; // Logical library definition file name
string; // Logical library definition
);
Description
The
con_compileloglib function compiles the given logical library definition(s) and stores the compiled loglib definition(s) to the DDB destination file specified with the first function parameter. The logical library definition(s) must be provided according to the
loglib utility program input format specification.
con_compileloglib compiles either the logical library definition file specified with the second function parameter or the logical library definition passed through the third function parameter. The
NULL keyword can be specified to ignore either of these parameters. The function returns zero if the compilation was successful or nonzero otherwise.
See also
Functions
con_compileloglib,
con_getlogpart,
lay_deflibname,
scm_defloglname; BAE utility program
loglib.
con_deflogpart - Define a logical library part entry (STD)
Synopsis
int con_deflogpart( // Returns status
string; // DDB destination file name
string; // Logical library part name
string[]; // Physical library part name
int [0,1]; // Default assignment flag
);
Description
The
con_deflogpart function stores the given logical library part definition to the name-specified DDB destination file. The defined assignment of a physical library part to a logical part is requested by the BAE
Packager for transferring logical to physical net lists. The library entry defined through
con_deflogpart is an 1-to-1 assignment, i.e., the
Packager does not perform any pin name transformations. Note that gates, pin/gate swaps, power supply pins or attribute assignments cannot be defined with
con_deflogpart. A virtual part assignment is defined if an empty string is specified for the physical library part name. Alternate package types are defined if a list of multiple strings is given for the physical library part name. The
$plname attribute can be utilized for physical part name assignments if the default assignment flag is set. The function returns zero on successful library part definition, (-1) on missing and/or invalid parameters or (-2) on library file access errors.
See also
Functions
con_deflogpart,
con_getlogpart; BAE utility program
loglib.
con_getddbpattrib - Get part/pin attribute from DDB file (STD)
Synopsis
int con_getddbpattrib( // Returns status
string; // DDB file name
string; // Part name
string; // Pin name
& string; // Attribut name
// or empty string for plan name
// or ! for first attribute
// or !$attrname for next attribute
& string; // Attribute value
);
Description
The
con_getddbpattrib function gets a part or pin attribute value from a DDB file. The function returns 1 if the attribute value has been found, zero if the attribute does not exist or (-1) on file access errors. Part attributes are searched if an empty pin name is specified; otherwise pin attributes are searched.
The selected attribute name is returned with the attribute name function parameter if a placeholder (! or !$attrname) is specified for the attribute name.
See also
Function
con_setddbpattrib.
con_getlogpart - Get a logical library part definition (STD)
Synopsis
int con_getlogpart( // Returns status
string; // LOGLIB DDB file name
string; // Logical library part name
int; // Output columns
& string; // Returns logical library definition
);
Description
The
con_getlogpart function extracts ASCII-formatted logical library part definition of the name-specified logical part. The function returns zero on successful part definition extraction, (-1) on missing and/or invalid parameters, (-2) if the DDB file is not available, (-3) if the logical library part is not available or (-4) on logical library part load errors. The LOGLIB DDB file name is supposed to be a job file name or the default
Packager layout library name which can be determined using either the
scm_defloglname or the
lay_deflibname function.
See also
Functions
con_compileloglib,
con_deflogpart,
lay_deflibname,
scm_defloglname; BAE utility program
loglib.
con_setddbpattrib - Store part/pin attribute to DDB file (STD)
Synopsis
int con_setddbpattrib( // Returns status
string; // DDB file name
string; // Part name
string; // Pin name
string; // Attribute name
string; // Attribute value
);
Description
The
con_setddbpattrib function sets a part or pin attribute value in the given DDB file. The function returns nonzero on error. The part name is required; the specified part must be defined in the net list of the given DDB file. The pin name is optional. The attribute value is considered a part attribute value if an empty string is specified for the pin name; otherwise, a pin attribute assignment is assumed. Neither part nor pin names can contain upper case letters. The attribute name must start with the percent sign
($) and must not contain upper case letters. The attribute value can be an empty string for resetting previously assigned attribute values. Attribute value strings can be stored with a maximum length of up to 40 characters.
For
PA_NILVAL attribute value specifications, the attribute value assignment for the specified attribute is removed to mimic the behaviour of
button in the
Schematic Editor
See also
Function
con_getddbpattrib.
con_storepart - Store part to internal logical net list (STD)
Synopsis
int con_storepart( // Returns status
string; // Logical part name
string; // Logical part library name
);
Description
The
con_storepart function stores the given logical part to the internal logical net list kept in main memory. The function returns zero if the part has been successfully stored, (-1) on missing and/or invalid parameters or (-2) if the part is already defined. The internal logical net list can be written to a DDB file using the
con_write function.
Warning
Main memory is allocated when using the
con_store* functions. The
con_clear function should be called as soon as the net data is not needed any more, or otherwise you might run short of main memory.
See also
Functions
con_clear,
con_storepin,
con_write.
con_storepin - Store pin to internal logical net list (STD)
Synopsis
int con_storepin( // Returns status
string; // Logical part name
string; // Logical part pin name
string; // Net name
);
Description
The
con_storepin function stores the given logical part pin to the internal logical net list kept in main memory. The corresponding part must be stored already with the
con_storepart function. The pin is not connected if an empty string is specified for the net name; otherwise the pin is connected to the specified net. The net entry is automatically generated if no net with the given name exists. The function returns zero if the part pin has been successfully stored, (-1) on missing and/or invalid parameters, (-2) if the part is not yet defined, (-3) if the pin is already connected to the net list or (-4) on net list overflow. The internal logical net list can be written to a DDB file using the
con_write function.
Warning
Main memory is allocated when using the
con_store* functions. The
con_clear function should be called as soon as the net data is not needed any more, or otherwise you might run short of main memory.
See also
Functions
con_clear,
con_storepart,
con_write.
con_write - Write internal logical net list to file (STD)
Synopsis
int con_write( // Returns status
string; // DDB file name
string; // Net list element name
);
Description
The
con_write function stores internal logical net list generated with the
con_store* function to the specified net list element name in the given DDB file.
con_write also deletes the internal logical net list from memory. The function returns zero if the net list has been successfully written, (-1) on missing and/or invalid parameters, (-2) if no internal net list data is available or (-3) on net list write errors. The net list format produced by
con_write is identical to the format generated by the
Schematic Editor of the
Bartels AutoEngineer, i.e., the net lists generated with
con_write can be transformed to the
Bartels AutoEngineer layout system using the Packager.
Warning
The
con_* functions provide powerful tools for transforming third party net lists to the
Bartels AutoEngineer. It is strongly recommended to check destination files before storing net lists with the
con_write function to avoid conflicts with other net list data already defined in the destination file.
See also
Functions
con_clear,
con_storepart,
con_storepin.
convstring - Convert string (STD)
Synopsis
string convstring( // Returns converted string
string; // Input string
int; // Conversion mode:
// 0 = Get file name without extension
// 1 = Get file name without directory path
// 2 = Get file name without extension and directory path
);
Description
The
convstring function converts the input string according to the specified conversion mode and returns the converted string.
cos - Cosine (STD)
Synopsis
double cos( // Returns result value
double; // Input angle value (STD3)
);
Description
The
cos function calculates and returns the cosine value of the given angle value. The input angle value must be in radians.
cosh - Hyperbolic cosine (STD)
Synopsis
double cosh( // Returns result value
double; // Input angle value (STD3)
);
Description
The
cosh function calculates and returns the hyperbolic cosine value of the given angle value. The input angle value must be in radians.
cvtangle - Convert an angle value (STD)
Synopsis
double cvtangle( // Returns angle value
double; // Input angle value
int [0,3]; // Input angle units
int [0,3]; // Output angle units
);
Description
The
cvtangle function converts the specified angle value from input units to output units and returns the resulting angle value. Valid input/output angle unit codes are 0 for internal units (radians, STD3), 1 for degree units (180/pi radians), 2 for radians
(STD3) or 3 for grad units (200/pi radians).
cvtlength - Convert a length value (STD)
Synopsis
double cvtlength( // Returns length value
double; // Input length value
int [0,4]; // Input length units
int [0,4]; // Output length units
);
Description
The
cvtlength function converts the specified length value from input units to output units and returns the resulting length value. Valid input/output length unit codes are 0 for internal units (meter, STD2), 1 for inch units, 2 for millimeter units (mm), 3 for mil units (1/1000 inch) or 4 for micrometer units (um).
ddbcheck - Check DDB file/element availability (STD)
Synopsis
int ddbcheck( // Returns query status
string; // DDB file name
int; // DDB element class (STD1)
// or (-1) for valid DDB file check
string; // Element name or empty string for any class element check
);
Description
The
ddbcheck function checks whether an element with the specified DDB class and element name exists in the DDB file specified with the DDB file name parameter. If (-1) is specified instead of a valid DDB class code, then
ddbcheck only checks whether the specified file is a DDB file. If an empty element name string is specified, then
ddbcheck only checks whether the DDB file contains any element of the specified DDB class. The function returns zero if the DDB object was found and/or accessible or (-1) otherwise.
See also
Functions
ddbclassscan,
ddbelemrefcount,
ddbelemrefentry,
ddbclassid - Get DDB class identifier (STD)
Synopsis
string ddbclassid( // Returns DDB class identifier or empty string
int ]0,[; // DDB element class (STD1)
);
Description
The
ddbclassid function returns the DDB class identifier for the specified DDB class code. An empty string is returned on invalid/unknown DDB class specifications.
ddbclassscan - Scan DDB class elements (STD)
Synopsis
int ddbclassscan( // Returns scan status
string; // DDB file name
int ]0,[; // Element class code (STD1)
* int; // Element name callback function
);
Description
The
ddbclassscan function scans all elements matching the specified DDB class in the given DDB file. A user-defined callback function (see below) is automatically activated for each element scanned, unless the keyword
NULL is specified for the corresponding parameter. The function returns either the number of scanned elements or (-1) on invalid parameter specifications and/or errors from the callback function.
Element name callback function definition
int callbackfunction( // Continue scan request flag
string ename // Element name
)
{
// Element name callback function statements
:
return(scanstatus);
}
The element name callback function return value should be 1 for scan continue request, 0 for scan stop request or (-1) on error.
See also
Functions
ddbcheck,
ddbelemrefcount,
ddbelemrefentry.
ddbcopyelem - Copy DDB file element (STD)
Synopsis
int ddbcopyelem( // Returns status
string; // DDB source file name
string; // DDB destination file name
int ]0,[; // DDB database class code (STD1)
string; // DDB element name
int [0,1]; // Delete allowed (merge source) flag:
// 0 = do not overwrite existing
// elements in destination file
// 1 = allow overwriting of existing
// elements in destination file
);
Description
The
ddbcopyelem function copies the named DDB element of the specified DDB database class from the DDB source file to the DDB destination file. The DDB element name is preserved during the copy, i.e., the source and destination files must be different. The copy includes all dependent and/or referenced elements of the selected DDB element. The merge source switch parameter designates whether existing elements in the destination file can be overwritten (merge source; source file is master) or not (merge destination; destination file is master). The function returns zero if the copy operation was successful or (-1) otherwise (invalid/missing parameters or DDB file access failure).
Warnings
The
ddbcopyelem function is not subject to the
facility since it works on DDB file level. It is strongly recommended to use this function with care to prevent from unintentionally overwriting BAE design and/or system data.
See also
Functions ddbdelelem,
ddbrenameelem.
ddbdelelem - Delete DDB file element (STD)
Synopsis
int ddbdelelem( // Returns status
string; // DDB file name
int ]0,[; // DDB database class code (STD1)
string; // DDB element name
);
Description
The
ddbdelelem function deletes the named DDB file element of the specified DDB database class code from the given DDB file. The function returns zero if the delete operation was successful or (-1) otherwise (invalid/missing parameters or DDB file access failure).
Warnings
The
ddbdelelem function is not subject to the
facility since it works on DDB file level. It is strongly recommended to use this function with care to prevent from unintentionally deleting BAE design and/or system data.
See also
Functions ddbcopyelem,
ddbrenameelem.
ddbelemrefcount - Get DDB file element reference count (STD)
Synopsis
int ddbelemrefcount( // Returns reference count or (-1)
string; // DDB file name
int ]0,[; // DDB database class code (STD1)
string; // DDB element name
);
Description
The
ddbelemrefcount function retrieves the number of library elements referenced by the specified DDB element. The DDB element is specified with the corresponding DDB file name, DDB class code and element name function parameters. The function returns (-1) if the specified DDB element does not exist or cannot be accessed. The
ddbelemrefentry function can be used to retrieve the DDB database class codes and the element names of selected library references of a DDB element.
See also
Functions
ddbelemcheck,
ddbclassscan,
ddbelemrefentry.
ddbelemrefentry - Get DDB file element reference entry (STD)
Synopsis
int ddbelemrefentry( // Returns reference count or (-1)
string; // DDB file name
int ]0,[; // DDB database class code (STD1)
string; // DDB element name
int ]0,[; // Reference entry list index
& int ]0,[; // Reference entry DDB database class code (STD1)
& string; // Reference entry name
);
Description
The
ddbelemrefentry function retrieves the DDB database class code and the element name of the library element referenced by the DDB element specified with the DDB file name, DDB database class code and element name function parameters. The reference entry to be queried is specified with the reference list index parameter. The
ddbelemrefcount function can be used to retrieve the number of DDB element library reference entries. This value also designates the valid reference list index range to be specified for selecting a specific DDB element reference entry. The function returns zero if the query was successful or (-1) otherwise.
See also
Functions
ddbcheck,
ddbclassscan,
ddbelemrefcount.
ddbgetelemcomment - Get DDB file element comment (STD)
Synopsis
int ddbgetelemcomment( // Returns status
string; // DDB file name
int ]0,[, // DDB database class (STD1)
string; // DDB element name
& string; // Returns comment string
);
Description
The
ddbgetelemcomment function is used to query DDB file element comments which have been assigned with the
ddbsetelemcomment function.
The functions returns zero if the query was successful or (-1) otherwise (missing/invalid parameters or DDB access failure).
See also
Function ddbsetelemcomment.
ddbgetlaypartpin - Get DDB file layout part pin data (STD)
Synopsis
int ddbgetlaypartpin( // Returns status:
// ( 0) = no error, pin query successful
// (-1) = DDB file access error
// (-2) = Invalid parameters
// (-3) = Layout part symbol not found
// (-4) = Pin not defined
string; // DDB file name
string; // Layout part symbol name
int [0,[; // Pin index
& string; // Pin name
& string; // Pin symbol name
& double; // Pin X position (STD2)
& double; // Pin Y position (STD2)
& double; // Pin rotation angle (STD3)
& int; // Pin mirror mode (STD14)
);
Description
The
ddbgetlaypartpin function can be used to query layout part symbol pin information on DDB file level. Repetitive function calls with incremented pin index and the pin not defined return value as abort criteria can be applied for iterating all pins of an existing layout part symbol.
See also
Functions
ddbcheck,
ddbclassscan,
ddbelemrefcount,
ddbelemrefentry.
ddbrenameelem - Rename DDB file element (STD)
Synopsis
int ddbrenameelem( // Returns status
string; // DDB file name
int ]0,[, // DDB database class (STD1)
string; // Old DDB element name
string; // New DDB element name
);
Description
The
ddbrenameelem changes the element name of the specified DDB file element. The function returns zero if the rename operation was successful or (-1) otherwise (invalid/missing parameters or DDB file access failure).
Warnings
The
ddbrenameelem function is not subject to the
facility since it works on DDB file level. It is strongly recommended to use this function with care to prevent from unintentionally renaming BAE design and/or system data.
See also
Functions ddbcopyelem,
ddbdelelem.
ddbsetelemcomment - Set DDB file element comment (STD)
Synopsis
int ddbsetelemcomment( // Returns status
string; // DDB file name
int ]0,[, // DDB database class (STD1)
string; // DDB element name
string; // Comment string
);
Description
The
ddbsetelemcomment function can be used to assign comment texts to DDB file elements for subsequent queries with the
ddbgetelemcomment function.
The functions returns zero if the assignement was successful or (-1) otherwise (missing/invalid parameters or DDB access failure).
ddbsetelemcomment sets DDB element comments not only in DDB files but also in main memory if the processed DDB element is currently loaded in the
Bartels AutoEngineer.
See also
Function ddbgetelemcomment.
ddbupdtime - Get DDB file element update time (STD)
Synopsis
int ddbupdtime( // Returns status
string; // Input DDB file name
int [100,[; // Input DDB element class code (STD1)
string; // Input DDB element name
& int; // Returns update time seconds
& int; // Returns update time minutes
& int; // Returns update time hours
& int; // Returns update time days
& int; // Returns update time months
& int; // Returns update time year
);
Description
The
ddbupdtime function gets the date and time of the last change performed on the specified DDB file element. The function returns 1 on success, 0 if the DDB file element has not been found or (-1) on file access error or invalid parameters.
dirscan - Scan directory (STD)
Synopsis
int dirscan( // Returns scan status
string; // Directory path name
string; // File name extension:
// .EXT = denotes extension
// .* = all files/subdirectories
* int; // File name callback function
);
Description
The
dirscan function scans the specified directory for all file and/or subdirectory names matching the file name extension. A user-defined callback function (see below) is activated automatically for each file name scanned, unless the keyword
NULL is specified for the corresponding parameter. The function returns either the number of scanned file names or (-1) on invalid parameter specifications and/or errors from the callback function.
File name callback function
int callbackfunction( // Continue scan request flag
string fname // File name
)
{
// File name callback function statements
:
return(scanstatus);
}
The file name callback function return value should be 1 for scan continue request, 0 for scan stop request, or (-1) on error.
existddbelem - Check DDB file element (STD)
Synopsis
int existddbelem( // Returns status
string; // Input DDB file name
int [100,[; // Input DDB element class code (STD1)
string; // Input DDB element name
);
Description
The
existddbelem function checks if the specified DDB file element exists. The function returns 1 if the DDB file element has been found, 0 if the DDB file element has not been found or (-1) on file access error or invalid parameters.
exit - Terminate a program immediately (STD)
Synopsis
void exit(
int; // Return status
);
Description
The
exit function terminates the currently active
User Language program immediately and passes the specified status code to the program caller.
Warning
The return status is not evaluated by the
Bartels User Language Interpreter.
See also
Function ulsystem_exit.
exp - Exponential function (STD)
Synopsis
double exp( // Returns result value
double; // Input value
);
Description
The
exp function calculates and returns the exponential value of the given input value.
fabs - Absolute value of a double (STD)
Synopsis
double fabs( // Returns result value
double; // Input value
);
Description
The
fabs function calculates and returns the absolute value of the given double value.
fclose - Close a file (STD)
Synopsis
int fclose( // Returns status
int; // File handle
);
Description
The
fclose function closes the file specified with the given file handle. The function returns nonzero on file close errors.
fcloseall - Close all files opened by the program (STD)
Synopsis
int fcloseall( // Returns status
);
Description
The
fcloseall function closes all files opened by the currently active
User Language program. The function returns nonzero on file close errors.
feof - Test for end-of-file (STD)
Synopsis
int feof( // Returns status
int; // File handle
);
Description
The
feof function checks if the end of the file specified with the given file handle is reached. The function returns nonzero on end-of-file or zero otherwise.
fgetc - Read next character from file (STD)
Synopsis
int fgetc( // Returns character code (or -1 if EOF)
int; // File handle
);
Description
The
fgetc function reads the next character from the file specified with the given file handle. The fucntion returns the read character code on success or (-1) on file read errors or end-of-file (these states should be distinguished with the
feof function; the file function error handling mode must be set accordingly with the
fseterrmode function).
fgets - Read next line of text from file (STD)
Synopsis
int fgets( // Returns status
& string; // Returns text string
int; // Maximum text string length
int; // File handle
);
Description
The
fgetc function reads the next line of text from the file specified with the given file handle. Reading stops after a newline character is encountered or if the number of characters stored to the result string exceeds the maximum text string length. The return value is nonzero on file read errors or end-of-file (these states should be distinguished with the
feof function; the file functions error handling mode must be set accordingly with the
fseterrmode function).
filemode - Get file mode (STD)
Synopsis
int filemode( // Return file name
string; // File name
);
Description
The
filemode return the access mode of the specified file. The return value is 0 for write access, 1 for read-only access, or (-1) on file access failure.
See also
Functions filesize,
filetype.
filesize - Get file size (STD)
Synopsis
int filesize( // File size in bytes or (-1) on error
string; // File name
);
Description
The
filesize function returns the size of the specified file in bytes or (-1) on file access failure.
See also
Functions filemode,
filetype.
filetype - Get file type (STD)
Synopsis
int filetype( // Returns file type:
// (-1) = file access failure
// ( 0) = directory
// ( 1) = regular file
// ( 2) = character mode file
string; // File name
);
Description
The
filetype function returns the type of the specified file or (-1) if file access failure.
See also
Functions filemode,
filesize.
floor - Floor function (STD)
Synopsis
double floor( // Returns result value
double; // Input value
);
Description
The
floor function calculates and returns the largest "integer" not greater than the specified input double value.
fmod - Floating point remainder (STD)
Synopsis
double fmod( // Returns result value
double; // Dividend
double; // Divisor
);
Description
The
fmod function calculates and returns the floating point remainder of the division of the two input values. The result value has the same sign like the dividend. If the division result cannot be represented, the result value is undefined.
fopen - Open a file (STD)
Synopsis
int fopen( // Returns status
string; // File name
int [0,14]; // File access mode:
// 0 = r read (the only valid BAE Demo mode without |8)
// 1 = w write
// 2 = a append
// 3 = rb read binary
// 4 = wb write binary
// 5 = ab append binary
// |8 = autoclose (for BAE Demo write tests)
);
Description
The
fopen function opens the file with the specified file name and provides the required file access. The file access mode is 0 for file read access, 1 for file write access or 2 for file append access. On write access, the file is generated if it does not yet exist. The function returns (-1) on file open errors; on success, the return value is the file handle to be used for subsequent file access functions.
Limitation
When used in
BAE Demo software configurations,
fopen allows for file read access only.
fprintf - Print to a file using format (STD)
Synopsis
int fprintf( // Returns status
int; // File handle
string; // Format string
[] // Output parameter list
);
Description
The
fprintf function writes the data contained in the output parameter list to the file specified with the file handle. The format string contains information on how to format the output. The function returns nonzero on file write errors or zero otherwise.
Format string
The format string transforms the subsequent parameter values and performs a formatted output according to the format control information specified with the format string. The format string can contain normal characters and format elements. Normal character sequences are written unchanged whilst a format element causes transformation and formatted output of the next unprocessed output parameter value. Each format element starts with the percent sign
% and is delimited by a format control character. The following table lists the valid format control characters for output data type specifications:
| Character | Output Data Type |
|---|
d | Decimal integer format |
o | Octal integer format |
x | Hexadecimal integer format (lowercase) |
X | Hexadecimal integer format (uppercase) |
u | Unsigned decimal integer format |
c | Character format |
s | String format |
e | Scientific floating point format (lowercase) |
E | Scientific floating point format (uppercase) |
f | Fixed floating point format |
g | e or f, with shorter form to be used |
G | E or f, with shorter form to be used |
% | Print percent sign % |
The following output format specifications can be used between the percent sign and the format control character (n = numeric value):
| Character | Output Format |
|---|
- | left justify (default: right justify) |
+ | sign output with positive numeric values |
SPACE | blank output with positive numeric values |
# | octal output with leading 0
or hexadecimal output with leading 0x or 0X
or output with decimal point for e, E, f, g, G
or zeros after decimal point for g, G |
n | fieldwidth; i.e., minimum output length |
.n | precision; i.e., length of output string (with s)
or number of digits after decimal point (with f, g, G) |
l | long int decimal format (with d, o, x, X) |
With
e,
E,
f,
g and
G, six digits after the decimal point are printed on default. If the
* character appears instead of the fieldwidth or precision specification then the corresponding value is taken from the next unprocessed function parameter. A percent sign can be printed by specifying
%%. Control characters delimited by a backslash
(\) are treated like normal characters.
Warning
The number and types of the parameter values passed to
fprintf must match the number of percent sign / format control character pairs specified with the format stringl; otherwise garbage might be printed.
See also
Functions
printf,
sprintf.
fputc - Write a character to a file (STD)
Synopsis
int fputc( // Returns status
char; // Character
int; // File handle
);
Description
The
fputc function writes the given character to the file specified with the file handle. The function returns nonzero on file write error or zero otherwise.
fputs - Write a string to a file (STD)
Synopsis
int fputs( // Returns status
string; // String
int; // File handle
);
Description
The
fputs function writes the given string to the file specified with the file handle. The function returns nonzero on file write error or zero otherwise.
frexp - Break double into fraction and exponent (STD)
Synopsis
double frexp( // Returns fraction value
double; // Input value
& int; // Returns exponent value
);
Description
The
frexp function breaks the input double value fraction and exponent and returns the calculated fraction value; the exponent is returned with the second parameter.
fseterrmode - Set the file functions error handling mode (STD)
Synopsis
int fseterrmode( // Returns status
int [0,1]; // Error handling mode
);
Description
The
fseterrmode function sets the file functions error handling mode. The file error mode 1 causes the interpreter environment to handle file errors. The file error mode 0 leaves the
User Language program with the file error handle task. The initial file error handling mode on
User Language program calls is 1.
Warning
The file error handling mode should be set to 0, when using the functions
fgetc and/or
fgets. Otherwise a
User Language program might fault with file read errors when reaching end-of-file (see also functions
fgetc,
fgets).
get_date - Get the current system date (STD)
Synopsis
void get_date(
& int; // Returns day of the month (1..31)
& int; // Returns month of the year (0..11)
& int; // Returns year since 1900
);
Description
The
get_date function returns with its parameters the current system date.
get_time - Get the current system time (STD)
Synopsis
void get_time(
& int; // Returns hours since midnight (0..23)
& int; // Returns minutes after hour (0..59)
& int; // Returns seconds after minute (0..59)
);
Description
The
get_time function returns with its parameters the current system time.
getchr - Get a character from standard input (STD)
Synopsis
char getchr( // Returns character
);
Description
The
getchr function activates a character input request (from keyboard) and returns the input character value.
getcwd - Get current working directory path name (STD)
Synopsis
string getcwd( // Returns path name
);
Description
The
getcwd function returns the path name of the current working directory.
getenv - Get environment variable (STD)
Synopsis
int getenv( // Returns status
string; // Variable name
& string; // Variable value
);
Description
The
getenv function searches the environment variable list for an entry matching the specified variable name and returns the variable value with the corresponding parameter. The function returns zero if the variable is defined or nonzero otherwise (in which case the variable value parameter is left unchanged).
See also
Function putenv.
getextprog - Get file type specific application (STD)
Synopsis
int getextprog( // Returns status
string; // File name extension
& string; // Command string
);
Description
The
getextprog gets the application command string for opening file types with the specified file name extension. The function returns zero if the query was successful or (-1) if no application/command was found for the specified file name extension.
getstr - Get a line of text from standard input (STD)
Synopsis
int getstr( // Returns status
& string; // Returns text string
int; // Maximum text string length
);
Description
The
getstr function activates a string input request (from keyboard). Input characters are stored to the return text string parameter until the return/enter key
 key is pressed or the maximum text string length is reached. The function returns nonzero if invalid parameters have been specified.
isalnum - Test for alphanumeric character (STD)
Synopsis
int isalnum( // Returns boolean test result
char; // Input character
);
Description
The
isalnum function returns nonzero if the input character is alphanumeric or zero otherwise.
isalpha - Test for alphabetic character (STD)
Synopsis
int isalpha( // Returns boolean test result
char; // Input character
);
Description
The
isalpha function returns nonzero if the input character is alphabetic or zero otherwise.
iscntrl - Test for control character (STD)
Synopsis
int iscntrl( // Returns boolean test result
char; // Input character
);
Description
The
iscntrl function returns nonzero if the input character is a control character or zero otherwise.
isdigit - Test for numeric character (STD)
Synopsis
int isdigit( // Returns boolean test result
char; // Input character
);
Description
The
isdigit function returns nonzero if the input character is numeric or zero otherwise.
isgraph - Test for visible character (STD)
Synopsis
int isgraph( // Returns boolean test result
char; // Input character
);
Description
The
isgraph function returns nonzero if the input character is visible or zero otherwise.
islower - Test for lowercase alphabetic character (STD)
Synopsis
int islower( // Returns boolean test result
char; // Input character
);
Description
The
islower function returns nonzero if the input character is lowercase alphabetic or zero otherwise.
isprint - Test for printing character (STD)
Synopsis
int isprint( // Returns boolean test result
char; // Input character
);
Description
The
isprint function returns nonzero if the input character is a printing character (including space) or zero otherwise.
ispunct - Test for punctuation character (STD)
Synopsis
int ispunct( // Returns boolean test result
char; // Input character
);
Description
The
ispunct function returns nonzero if the input character is a punctuation character (i.e., a printing character that is not a digit, letter or space) or zero otherwise.
isspace - Test for whitespace character (STD)
Synopsis
int isspace( // Returns boolean test result
char; // Input character
);
Description
The
isspace function returns nonzero if the input character is a whitespace character (i.e., a space ' ', a form feed
\f, a horizontal tab
\t, a newline
\n, a carriage return
\r or a vertical tab
\v) or zero otherwise.
isupper - Test for uppercase alphabetic character (STD)
Synopsis
int isupper( // Returns boolean test result
char; // Input character
);
Description
The
isupper function returns nonzero if the input character is uppercase alphabetic or zero otherwise.
isxdigit - Test for hexadecimal numeric character (STD)
Synopsis
int isxdigit( // Returns boolean test result
char; // Input character
);
Description
The
isxdigit function returns nonzero if the input character is hexadecimal numeric or zero otherwise.
kbhit - Test if key hit (STD)
Synopsis
int kbhit( // Keyboard state
);
Description
The
kbhit function returns the current state of the keyboard input. A zero value is returned if no key was pressed. A nonzero return value signals a key was pressed. The key code remains in the keyboard input buffer and can be read with
getchr or other keyboard input functions.
See also
Function kbstate.
kbstate - Shift/control/alt key state query (STD)
Synopsis
int kbstate( // Keyboard state (bit values):
// 0x***1 = Shift pressed
// 0x***2 = Ctrl pressed
// 0x**1* = Left Alt key pressed
// 0x**2* = Right Alt key pressed
);
Description
The
kbstate function can be used to check whether
Shift,
Ctrl and/or
Alt keys are currently pressed.
See also
Function kbhit.
launch - Pass command to operating system without waiting for completion (STD)
Synopsis
int launch( // Startup status
string; // Command string
);
Description
The
launch function activates and/or executes the command specified in the command string parameter. The command is used to start and/or execute an application, and control is regained by BAE immediately after passing the command to the Windows operating system (the called application runs independentely from BAE). The function returns zero if the command was successfully launched or nonzero otherwise.
Limitations
The
launch function does not work in
BAE Demo software configurations.
Requirements
Executing MS-DOS (child) processes through the DOS Extender requires enough conventional memory to be available for running the executable. Conventional memory must be controlled with the
-MINREAL and
-MAXREAL variables of the
Phar Lap 386|DOS Extender. For running
User Language programs using the
launch function, the corresponding
User Language Interpreter environments must be re-configured by applying Phar Lap's redistributed CFIG386 tool as in
> cfig386 <EXEFILE> -maxreal 0ffffh
where
<EXEFILE> must be set to the appropriate
User Language Interpreter executable(s)
(scm.exe,
ged.exe,
neurrut.exe,
cam.exe,
gerview.exe and/or
ced.exe).
Warnings
Note that the
launch function introduces basic multi-processing/multi-tasking features which are not fully supported on PC-based systems or can cause some problems on network-based workstation systems (depending on whichever OS command is to be executed).
It is strongly recommended to redirect DOS command standard output to temporary files (and use some file view
User Language function for display); otherwise DOS standard output overwrites the BAE graphic user interface.
Erroneous DOS command calls cause error output to the screen, thus overwriting the BAE graphic interface. Due to the fact that DOS lacks from some substantial standard features such as redirect error output, this problem can only be solved by refraining and/or preventing from running erroneous DOS commands, e.g., by pre-checking the consistency of each DOS command to be called.
It is strongly recommended to refrain and/or prevent from calling interactive DOS commands and/or application software with the
launch function since otherwise the system will "hang up" due to the fact that DOS standard input cannot be redirected from the BAE graphic user interface. It is also strongly recommended to refrain and/or prevent from directly calling UNIX commands which expect some user input (such as
more,
vi, etc.); this problem can be solved by a command cast to background (&) command shell start where the desired command should be called from (which however might cause a terminal device connection problem under remote login).
See also
Function
system.
ldexp - Multiply by a power of 2
Synopsis
double ldexp( // Returns result value
double; // Input value
& int; // Exponent
);
Description
The
ldexp function calculates and returns the result of (input double value) multiplied with (2 power exponent value).
localtime - Get local processor system date and time (STD)
Synopsis
double localtime( // Returns elapsed CPU time (in seconds)
& int; // Returns seconds after minute (0..59)
& int; // Returns minutes after hour (0..59)
& int; // Returns hours since midnight (0..23)
& int; // Returns day of month (1..31)
& int; // Returns month of year (0..11)
& int; // Returns years since 1900
& int; // Returns days since Sunday (0..6)
& int; // Returns days of year (0..365)
);
Description
The
localtime functions returns with its parameters the system time and date (including weekday and day of year). The function returns the elapsed CPU time (in seconds).
log - Natural logarithm; base e (STD)
Synopsis
double log( // Returns result value
double ]0.0,[; // Input value
);
Description
The
log function calculates and returns the natural logarithm (base e) for the given non-negative input double value.
log10 - Common logarithm; base ten (STD)
Synopsis
double log10( // Returns result value
double ]0.0,[; // Input value
);
Description
The
log function calculates and returns the common logarithm (base ten) for the given non-negative input double value.
mkdir - Create directory (STD)
Synopsis
int mkdir( // Returns status
string; // Directory path name
);
Description
The
mkdir creates a directory with the specified directory path name. The functions returns zero if the directory was successfully created or (-1) if the creation of the directory failed due to missing or wrong parameters or directory access error.
modf - Break double into integer and fractional parts (STD)
Synopsis
double modf( // Returns fractional value
double; // Input value
& double; // Returns integer value
);
Description
The
modf function breaks the given input double value into integer and fractional parts. The resulting "integer" value is passed with the second parameter. The resulting fractional part is passed with the function return value.
namestrcmp - Name string compare (STD)
Synopsis
int namestrcmp( // Returns comparison result
string; // First name
string; // Second name
);
Description
The
namestrcmp function compares the specified input strings. A case-insensitive
character-by-character alphanumeric comparison is applied. The function returns zero if the strings are equal, (-1) if the first string is smaller than the second string, or 1 if the first string is greater than the second string.
See also
Functions numstrcmp,
strcmp.
numstrcmp - Numeric string compare (STD)
Synopsis
int numstrcmp( // Returns comparison result
string; // First input string
string; // Second input string
);
Description
The
numstrcmp function compares the specified input strings. The function returns zero if the strings are equal, (-1) if the first string is smaller than the second string or 1 otherwise.
numstrcmp operates like the
strcmp function unless for numeric parts of the compare strings for which numeric comparison is applied. I.e., this results in sequences such as R1, R2, ..., R10, R11 (instead of R1, R10, R11, ..., R2).
See also
Functions namestrcmp,
strcmp.
perror - Print error message (STD)
Synopsis
void perror(
string; // Message string
);
Description
The
perror function displays the specified message string in the status line of the BAE user interface.
The status line display is inverted for a short moment (single blink effect) to attract the user's attention.
The status line is cleared if an empty message string is passed to the function.
See also
Function
bae_prtdialog.
pow - Raise a double to a power (STD)
Synopsis
double pow( // Returns result value
double; // Base input value
double; // Exponent input value
);
Description
The
pow function calculates and returns the value of (base input value) power (exponent input value).
printf - Print to standard output using format (STD)
Synopsis
void printf(
string; // Format string
[] // Parameter list
);
Description
The
fprintf function writes the data contained in the output parameter list to the BAE text output workarea. The format string contains information on how to format the output (see also description of the
fprintf function).
See also
Functions
fprintf,
sprintf.
programid - Get current program name (STD)
Synopsis
string programid( // Returns program name
);
Description
The
programid function returns the name of the currently active
User Language program.
putchr - Write a character to standard output (STD)
Synopsis
int putchr( // Returns status
char; // Character
);
Description
The
putchr function writes the specified character to the BAE text output workarea. The function returns nonzero on error.
putenv - Set environment variable (STD)
Synopsis
int putenv( // Returns status
string; // Variable name
string; // Variable value
);
Description
The
putenv function assigns a value to the specified operating system environment variable. The function returns zero if the assignment was successfull or (-1) if the variable was not found.
See also
Function getenv.
puts - Write a string to standard output (append NL) (STD)
Synopsis
int puts( // Returns status
string; // String
);
Description
The
puts function writes the specified string to the BAE text output workarea and appends a newline. The function returns nonzero on error.
putstr - Write a string to standard output (STD)
Synopsis
int putstr( // Returns status
string; // String
);
Description
The
puts function writes the specified string to the BAE text output workarea. The function returns nonzero on error.
quicksort - Sort index list (STD)
Synopsis
int quicksort( // Returns status
& void; // Index list (integer array)
int; // Index count
* int; // Element compare function
);
Description
The
quicksort function sorts the specified index list. The return value is 0 if the list was successfully sorted, or (-1) on error.
Element compare callback function
int sortfuncname(
int idx1, // Index 1
int idx2, // Index 2
)
{
// Compare index 1 to index 2
:
return(compareresult);
}
The return value of the element compare function must be (-1) if the first index is smaller than the second index, 1 if the first index is greater than the second index, or 0 if both index values are equeal.
remove - Delete a file or directory (STD)
Synopsis
int remove( // Returns status
string; // Path name
);
Description
The
remove function deletes the file or directory with the specified path name. The function returns nonzero on error.
rename - Change the name of a file (STD)
Synopsis
int rename( // Returns status
string; // Old file name
string; // New file name
);
Description
The
rename function changes the name of a file. The function returns nonzero on error.
rewind - Seek to the beginning of a file (STD)
Synopsis
void rewind(
int; // File handle
);
Description
The
rewind function sets the file pointer of the file specified with the given file handle to the beginning of this file.
rulecompile - Compile a rule definition (STD)
Synopsis
int rulecompile( // Returns status
string; // Destination file name
string; // Rule name
string; // Rule code
);
Description
The
rulecompile function compiles the specified rule code and saves the compiled rule with the given name to the destination file. The function returns zero on success or non-zero on error.
See also
Function
rulesource.
rulesource - Get rule definition source code (STD)
Synopsis
int rulesource( // Returns status
string; // Rule database file name
string; // Rule name
& string; // Rule source code
);
Description
The
rulesource function
retrieves the source code for the named rule definition from the specified rule database file. The rule definition source code is returned as string through the corresponding function parameter. The functions returns zero if the query was successful, (-1) if parameters are missing or invalid, (-2) if the rule database access failed, (-3) if the rule definition wasn't found or (-5) if the rule definition access failed.
See also
Function
rulecompile.
scanddbenames - Scan DDB file element names (STD)
Synopsis
int scanddbenames( // Returns scan status
string; // DDB file name
int [0,[; // DDB element class (STD1) or zero for cache flush
& string; // Input/output element name
);
Description
The
scanddbenames function scans the DDB file element following the one specified (the name of the scanned element is passed with the element name parameter). The first DDB file element is scanned if the input element name is an empty string. The scan works only in the specified DDB element class. The function returns 1 if an element has been found, 0 if no next element has been found or (-1) on DDB file access errors or invalid parameters.
scandirfnames - Scan directory file names (STD)
Synopsis
int scandirfnames( // Returns scan status
string; // Directory path name
string; // Name extension:
// .EXT = extension .EXT
// .* = all files/subdirectories
& string; // Input/output name
);
Description
The
scandirfnames function scans the specified directory for the file or directory name entry following the input name specification; the name of the scanned file or directory is passed with the output file name parameter. The first directory name entry is scanned on empty string name input. The scan works only in the specified extension match. The function returns 1 if a name entry has been found, 0 if no next name entry has been found or (-1) on directory access errors or invalid parameters.
setprio - Set BAE process priority (STD)
Synopsis
void setprio(
int; // Process priority value
// - Unix/Linux:
// nice priority value
// - Windows:
// <0 = HIGH_PRIORITY_CLASS
// 0 = NORMAL_PRIORITY_CLASS
// >0 = IDLE_PRIORITY_CLASS
// - otherwise ignored
);
Description
The
setprio function sets the priority of the current BAE process according to the specified process priority value.
sin - Sine (STD)
Synopsis
double sin( // Returns result value
double; // Input angle value (STD3)
);
Description
The
sin function calculates and returns the sine value of the given angle value. The input angle value must be in radians.
sinh - Hyperbolic Sine (STD)
Synopsis
double sinh( // Returns result value
double; // Input angle value (STD3)
);
Description
The
sinh function calculates and returns the hyperbolic sine value of the given angle value. The input angle value must be in radians.
sprintf - Print to string using format (STD)
Synopsis
int sprintf( // Returns decoded character count
& string; // Output string
string; // Format string
string; // Format string
[] // Parameter list
);
Description
The
sprintf function writes the data contained in the output parameter list to the output string, i.e.,
sprintf performs a format conversion in memory. The format string contains information on how to format the output (see also the description of the
fprintf function). The function returns the number of successfully decoded characters, i.e., the length of the resulting output string.
See also
Functions
fprintf,
printf.
sqlcmd - SQL command execution (STD)
Synopsis
int sqlcmd( // Returns status
string; // Database file name
string; // SQL command
* int; // Data return function
);
Description
The
sqlcmd function is used to control the data transfer from and to a relational database system initialized with
sqlinit. This is done via a SQL like query language. The first parameter of the function
sqlcmd specifies the name of the database file to be opened for usage. The second parameter specifies the SQL command to be executed for database access. The selected data fields are returned to the caller via the data callback function specified with the third parameter. If no data callback function is used the third function parameter should be set to
NULL. The function returns nonzero on missing or invalid parameters or on SQL database errors. In case of a database error, the exact error reason can be determined by the
sqlerr function.
SQL Commands
The database query language interpreted by
sqlcmd is a restricted subset of the Structured Query Language (SQL) for relational databases. The following basic commands are supported:
create table |
drop table |
insert into table values |
quickinsert into table values |
index table |
select from table |
delete from table |
help |
The following data types are supported for the representation of data:
| Keyword | Data Type |
integer | Integer values in range [-2147483648, 2147483647] |
float | Float values in range [-10^308, 10^308] with a precision of about 15 leading digits |
string | Strings (enclosed with apostrophes) |
boolean | Logical value (FALSE or TRUE) |
date | Date; on input dd/mm/yyyy, on output yyyymmdd |
Command create table
The
create command generates a database table structure. The command requires a table name and a list of field names and corresponding data types. The field name sequence defined with this list is used for data field output unless an explicit output field order is specified. The syntax of the
create command is:
create table tablename ( name1 type1, ..., namen typen ) ;
An index is generated for each database field. Indices are automatically during database queries. The user has not to care about the optimal use of indices. The index for string variables is restricted to the first 39 characters.
Command drop table
The
drop command deletes a table structure with table all entries from the database file. The syntax of the
drop command is:
drop table tablename ;
Command insert into
The
insert command stores a data record to a table. The specified values must match the table definition in number and data type sequence. The syntax of the
insert command is:
insert into tablename values ( val1, ..., valn ) ;
Command quickinsert insert into
The
quickinsert is similar to the
insert command. However, unlike
insert,
quickinsert does not update any field indices after storing data records into a database table. The
index table command (see below) can be used for field index updates after (multiple)
quickinsert applications. Performing a single
index table call is much quicker than updating indices through repeated
insert calls. I.e.,
quickinsert and
index table are useful for quickly inserting large numbers of records into a database. Please note however that data entered with
quickinsert is not included in any query results until a
index table takes place.
Command index table
The
index table command is used to create the field indices for data records which have been inserted into a database table with the
quickinsert command (see above). The syntax of the
index command is:
index table tablename ;
Command select from
The
select command provides a query to the database contents. The set of output records can be restricted to records matching some condition using the optional
where clause. All records are returned if no
where clause is specified. The syntax of the
select command is:
select [ field1, ..., fieldn ] from table1, ..., tablen
[ where ... ] ;
The specification of output fields is optional. All database fields are be returned in the order of their definition if no output fields are given. If an output field is defined in more than one table, then this ambiguity must be resolved by the specification of the field name in the form
table.field. The same specification must be given, when referring to that field in the
where clause. The
where clause consists of comparisons which can be combined with the logical operators
AND (logical and),
OR (logical or) and
NOT (logical negation). The comparison operators
= (equal),
<> (not equal),
> (greater than),
>= (greater than or equal),
< (less than) and
<= (less than or equal) are valid for all data types. The
PREVTO (select previous similar to pattern string) and
NEXTTO (select next similar to pattern string) operators and the string pattern match operator
LIKE are additionally provided for the string data type. The right side of these operators represents a pattern string which can contain the wildcard characters
% (specifying arbitrary substring) and
? (specifying arbitrary character). The operators of a comparison expression must be type compatible, i.e., of the same data type. The only exception to this rule is the combination of
integer and
float data types. Terms can consist of operators combining data field references and constants. The operators are
+ (addition),
- (subtraction),
* (multiplication),
/ (division),
% (division modulo),
UPPER (string conversion to upper case) and
LOWER (string conversion to lower case). The following table lists the valid combinations of operators and data types of referenced data fields or constants:
| Operator | Data Type |
|---|
+ | integer, float, string |
- | integer, float |
* | integer, float |
/ | integer, float |
% | integer, float |
UPPER() | string |
LOWER() | string |
The data types
date and
boolean can be combined by none of the defined operators.
Command delete from
The
delete command deletes data records from a database table. The syntax of the
delete command is:
delete from tablename [ where ... ] ;
The optional
where clause syntax accords to the
where clause of the
select command. The
delete command deletes the data records from a table matching the condition specified with the
where clause. All data records of the specified table are deleted if no
where clause is specified.
Command cache
The
cache command can be used for optionally keeping SQL databases open for multiple read/write SQL operations. These features can be used to avoid time-consuming database open and close operations between multiple SQL read/write operations. Facilitating the SQL cache can increase the performance of certain applications dramatically, especially if SQL databases are accessed over a network. The syntax of
cache supports the following commands:
cache read on ;
cache write on ;
cache off ;
Command help
The
help command can be used for retrieving information about the database table structures. The syntax of the
help command is:
help [ tablename ] ;
The data retrieved with the
help command is returned to the caller by the data callback function. The table name specification is optional. If no table name is given, then the
help command returns the names of the defined database tables via the table name parameter of the data callback function, i.e., the data callback function is called once per table. If a table name is given, then the
help command returns the table field names and data types via the corresponding parameters of the data callback function, i.e. the data callback function is called once for each table field.
Data return function
int datafunc(
string dstr, // String or date
int dint, // Integer or logical value
double ddbl, // Float value
int dval, // Data valid flag:
// 0 = invalid data
// 1 = valid data
int dtype, // Data field type:
// 2 = integer
// 3 = float
// 4 = string
// 5 = date (format "yyyymmdd")
// 6 = logical value (0=FALSE,1=TRUE)
string dtable, // Table name
string dfield, // Data field name
int didx // Data output field index
)
{
// Data return function statements
:
return(errstat);
}
The data callback function is used to return selected data fields to the caller of
sqlcmd. The function is automatically called once for each data field. Hence this function is called fifty times if 10 data records with 5 data fields each are selected. The index of the data output field specifies the position of the output field in the current record. It ranges from 1 to the number of defined data output fields. The return value of the data callback function should be zero if no (semantic) error occurred. In case of an error, a nonzero value must be returned to abort the database query.
Warning
The
sqlcmd function operates directly on database file level and is therefore not attached to the
mechanism.
See also
Functions
sqlerr,
sqlinit.
Example
Definition of a table named
partdata with the
symname (String),
val (String) and
partno (String) data fields in the
partdata.dat database file:
if (sqlinit("partdata.dat",1)!=0)
{
perror("SQL Init error!");
exit(0);
}
if (sqlcmd("partdata.dat",
"create table partdata (symname string,val string,partno string);",
NULL)!=0)
{
perror("SQL Query error!");
exit(0);
}
Data insertion:
if (sqlcmd("partdata.dat",
"insert into partdata values ('r','470','STK100470');",NULL)!=0)
{
perror("SQL Data input error!");
exit(0);
}
Data query:
if (sqlcmd("partdata.dat",
"select partno from partdata where symname='r' AND val='470';",
datafunc)!=0)
{
perror("SQL Query error!");
exit(0);
}
:
int datafunc(dstr,dint,ddbl,dval,dtype,dtable,dfield,didx)
string dstr;
int dint;
double ddbl;
int dval,dtype;
string dtable,dfield;
int didx;
{
printf("Part Number : %s\n");
}
Data delete:
if (sqlcmd("partdata.dat",
"delete from partdata where symname='r';",NULL)!=0)
{
perror("SQL Delete error!");
exit(0);
}
sqlerr - SQL error status query (STD)
Synopsis
void sqlerr(
& int; // Error code
& string; // Error item string
);
Description
The
sqlerr function is used to determine the error reason after an unsuccessful call of the
sqlcmd function.
Diagnosis
The error reason can be determined by the parameters returned by the
sqlerr function. The error item string identifies the element which caused the error. The following table lists the possible error codes:
| Error Code | Meaning |
|---|
| 0 | SQL command executed without errors |
| 1 | SQL command read error (internal) |
| 2 | SQL command too complex (more than 2000 terms) |
| 3 | Invalid numeric expression |
| 4 | SQL command file not found (internal) |
| 5 | SQL command item too long (more than 200 characters) |
| 6 | SQL command syntax error at <c> |
| 7 | General SQL command parser error |
| 8 | Error creating database |
| 9 | File access error |
| 10 | Too many open files |
| 11 | File <d> is of wrong type/not a database |
| 12 | Database file structure is damaged |
| 13 | Database file structure is invalid |
| 14 | Key <k> not found |
| 15 | Key <k> already defined |
| 16 | File <d> not found |
| 17 | Table element <t>.<f> has invalid data type |
| 18 | Too many table elements |
| 19 | Data entry length exceeds database limit |
| 20 | Multiple table delete not allowed |
| 21 | Command contains illegal type combination |
| 22 | Output field <f> undefined/not in any table |
| 23 | Output field <f> defined in different tables |
| 24 | Output table <t> undefined in from table list |
| 25 | Table <t> already defined |
| 26 | Database class limit exceeded |
| 27 | Table <t> not found |
| 28 | Error from data callback function |
| 29 | No delete record found |
| 30 | Unknown/new database format |
| 31 | Query field not in table(s) |
| 32 | Query field in multiple tables |
| 33 | File read access denied |
| 34 | File write access denied |
| 35 | General database error |
Depending on the error condition the error item string can describe a command element
<c>, a database file
<d>, a key
<k>, a table
<t> or a data field
<f>.
See also
Functions
sqlcmd,
sqlinit.
sqlinit - SQL database initialization (STD)
Synopsis
int sqlinit( // Returns status
string; // Database file name
int; // Database init mode
);
Description
The
sqlinit function initializes and/or creates a database system for further access by the
sql* functions. The database init mode can be zero for initializing an existing database file
(.ddb,
.dat) or 1 to create and initialize a new database file. The function return value is zero on successful initialization, 1 if the database file is already initialized or another value if an error occurred on initializing the database file. Databases processed with the
sql* functions are stored in
Bartels AutoEngineer DDB format. This introduces powerful features for including relational databases with
AutoEngineer library or design data. PPS data can be stored together with layout design data or part attributes can be set with data retrieved from a separate database. The relational database system uses the DDB classes ranged from 4096 to 8191. DDB class 4096 contains the structure of the defined tables. DDB class 4097 is used to manage free DDB classes; this class contains just one entry named
info, which is created by the
sqlinit function. The existence of this entry can be used to check whether a database is initialized or not. The DDB classes 4352 to 8191 are assigned dynamically when storing user-defined table records and indices. The number of DDB classes used by each table corresponds to the number of table fields plus 1.
See also
Functions
sqlcmd,
sqlerr.
sqrt - Square root (STD)
Synopsis
double sqrt( // Returns result value
double [0.0,[; // Input value
);
Description
The
sqrt function calculates and returns the square root of the given double input value.
strcmp - String compare (STD)
Synopsis
int strcmp ( // Returns comparison result
string; // First string
string; // Second string
);
Description
The
strcmp function compares the two input strings. A character-by character alphanumeric comparison is applied. The function returns zero if the strings are equal, (-1) if the first string is smaller than the second string or 1 otherwise.
See also
Functions namestrcmp,
numstrcmp.
strcspn - String prefix length not matching characters (STD)
Synopsis
int strcspn( // Returns match position
string; // Test string
string; // Suffix match pattern
);
Description
The
strcspn function returns the number of test string characters not matching any character contained in the suffix match pattern string. The test string is searched from start.
strdelchr - Delete characters from string (STD)
Synopsis
void strdelchr(
& string; // Input/output string
string; // Delete character set
int; // Delete start position
int; // Delete end position
);
Description
The
strdelchr function deletes from the input string all characters contained in the delete character set. The string is scanned from delete start to delete end position.
strextract - Extract sub-string from another string (STD)
Synopsis
string strextract( // Returns extracted string
string; // Input string
int; // Extract start position (0 - strlen-1)
int; // Extract end position (0 - strlen-1)
);
Description
The
strextract function extracts and returns the substring of the input string, which starts at the specified extract start position (counting from zero) and ends at the extract end position. The extract start and end positions are automatically adjusted to the input string boundaries. A reverse string extraction is applied, if the end position is smaller than the start position.
strextractfilepath - Extract directory name from a file path name string (STD)
Synopsis
string strextractfilepath( // Returns directory name
string; // Path name
);
Description
The
strextractfilepath function extracts and returns the directory name from the specified path name.
See also
Function
strgetpurefilename.
strgetconffilename - Get environment variable expanded configuration file name (STD)
Synopsis
string strgetconffilename( // Returns configuration file path name
string; // Environment variable name
string; // File base name
int; // Directory preference:
// 0 : Prefer program directory
// 1 : Prefer all users directory
// 2 : Prefer user directory
);
Description
The strgetconffilename returns the configuration file path name defined through the specified environment variable. The configuration file search is carried out in different configuration file directories according to the specified directory preference.
See also
Function strgetvarfilename.
strgetvarfilename - Get environment variable expanded file name string (STD)
Synopsis
string strgetvarfilename( // Returns file name
string; // Environment variable name
);
Description
The strgetvarfilename function returns the file and/or path name defined through the specified environment variable.
See also
Function strgetconffilename.
strgetpurefilename - Extract file name from file path name string (STD)
Synopsis
string strgetpurefilename( // Returns file name
string; // Path name
);
Description
The
strgetpurefilename function extracts and returns the file name from the specified path name.
See also
Function
strextractfilepath.
strlen - String length (STD)
Synopsis
int strlen( // Returns string length
string; // Test string
);
Description
The
strlen function determines and returns the length of the specified test string (the
NUL delimiter character is ignored).
strlistitemadd - Add string to string list (STD)
Synopsis
void strlistitemadd(
& string; // Comma-separated string list
string; // String
);
Description
The strlistitemadd adds the specified string in the comma-separated string list.
See also
Function strlistitemchk.
strlistitemchk - Search string in string list (STD)
Synopsis
int strlistitemchk( // Search result
string; // Comma-separated string list
string; // Search string
);
Description
The strlistitemchk searches the specified search string in the comma-separated string list. The functions returns zero if the search string is not in the string list, 1 if the search string is in the string list, or 2 if the search string matches the full length string list.
See also
Function strlistitemadd.
strlower - Convert string to lower case (STD)
Synopsis
void strlower(
& string; // Input/output string
);
Description
The
strlower function transforms the uppercase characters of the input string to lowercase.
strmatch - Test for string pattern match (STD)
Synopsis
int strmatch( // Returns string match flag
string; // Test string
string; // Pattern string (can contain wildcards)
);
Description
The
strmatch function checks, whether the test string matches the pattern string. The pattern string can contain wildcards. The
* character refers to any character sequence and
? refers to any single character. The function returns nonzero if the test string matches the pattern string or zero otherwise.
strnset - Fill part or all of string with any character (STD)
Synopsis
void strnset(
& string; // Input/output string
char; // Fill character
int; // Fill count
);
Description
The
strnset function replaces the leftmost characters of the input string with the specified fill character. The number of characters to be changed is specified with the fill count.
strreverse - Reverse string (STD)
Synopsis
void strreverse(
& string; // Input/output string
);
Description
The
strreverse function reverses the character sequence of the given input string.
strscannext - Forward find characters in string (STD)
Synopsis
int strscannext( // Returns match position
string; // Test string
string; // Match character set
int; // Scan start position (1 - strlen)
int; // Stop-on-match flag:
// 0 = continue on match
// 1 = stop on match
);
Description
The
strscannext function scans the test string for characters contained in the match character set. The scan starts from the specified scan start position (counting from 0) and proceeds towards the end of the test string. If the stop-on-match flag is set (1), the scan stops at the first character matching the match character set. If the stop-on-match flag is not set (0), the scan stops at the first character not matching the match character set. The function returns the match character position (or the test string length plus 1 on mismatch). The scan start position is automatically adjusted to the input string boundaries.
strscanprior - Backward find characters in string (STD)
Synopsis
int strscanprior( // Returns match position
string; // Test string
string; // Match character set
int; // Scan start position
int; // Stop-on-match flag:
// 0 = continue on match
// 1 = stop on match
);
Description
The
strscanprior function scans the test string for characters contained in the match character set. The scan starts from the specified scan start position and proceeds towards the beginning of the test string. If the stop-on-match flag is set (1), the scan stops at the first character matching the match character set. If the stop-on-match flag is not set (0), the scan stops at the first character not matching the match character set. The function returns the match character position (or zero on mismatch). The scan start position is automatically adjusted to the input string boundaries.
strset - Fill string with any character (STD)
Synopsis
void strset(
& string; // Input/output string
char; // Fill character
);
Description
The
strset function replaces all characters of the input string with the specified fill character.
strspn - String prefix length matching characters (STD)
Synopsis
int strspn( // Returns mismatch position
string; // Test string
string; // Prefix match pattern
);
Description
The
strspn returns the number of test string characters matching characters contained in the prefix match pattern string. The test string is searched from start.
strupper - Convert string to uppercase (STD)
Synopsis
void strupper(
& string; // Input/output string
);
Description
The
strupper transforms the lowercase characters of the input string to uppercase.
syngetintpar - Get BNF/scanner integer parameter (STD)
Synopsis
int syngetintpar( // Returns status
int [0,[; // Parameter type/number:
// 0 = String-Kontrollzeichenauswertungsmodus
// 1 = Activate comment text callback function
// 2 = Any identifier character flag
& int; // Returns parameter value
);
Description
The
syngetintpar function is used to query
User Language BNF/syntax scanner integer parameters previously set with
synsetintpar. The functions returns zero if the query was successful or (-1) otherwise.
See also
Functions synparsefile,
synparseincfile,
synparsestring,
synsetintpar.
synparsefile - BNF/parser input file scan (STD)
Synopsis
synparsefile( // Returns scan status
string; // Input file name
[]; // Optional comment callback function
);
Description
The
synparsefile function activates a parser for scanning the name-specified input file. The input file is processed according to the data format described with the BNF definition of the corresponding
User Language program. The BNF-defined parser action functions automatically called. The
synscanline and
synscanstring functions can be utilized in parser action functions to query the current input scan line number and the current input scan string. On request, the input scan string can be subject to semantic tests. The
synparsefile function is terminated if the end of the input file is reached or if a syntax error (or a semantic error encountered by a parser action function) has occurred.
Comment Callback Function
The second function parameter allows for the specification of a comment text callback function.
This function is activated if the corresponding scanner/parser parameter has been set with the synsetintpar function.
The callback function definition is as follows:
int commentfuncname(
string commentstring, // Comment without comment delimiters
)
{
// Function statements
:
return(stat);
}
The parser is stopped if the comment callback function returns a value other than zero. Otherwise the parser continues.
Diagnosis
The
synparsefile function return value denotes a certain scan status according to the following table:
| Return Value | Meaning |
0 | No error |
1 | No BNF definition available |
2 | Parser (synparsefile) is already active |
3 | File open error |
4 | Too many open files |
5 | Fatal read/write error |
6 | Scan item too long |
7 | Syntax error |
8 | Unexpected end of file |
9 | Stack overflow (BNF too complex) |
10 | Stack underflow (BNF erroneous) |
11 | Error from parser action function |
See also
Functions
syngetintpar,
synparseincfile,
synparsestring,
synscaneoln,
synscanigncase,
synscanline,
synscanstring,
synsetintpar, and
chapter 2.6.4 of this manual.
synparseincfile - BNF/parser include file scan (STD)
Synopsis
int synparseincfile( // Returns status
string; // Include file name
);
Description
The
synparseincfile function can be utilized for processing include files when parsing input files with the
synparsefile function. The parser starts reading at the beginning of the name-specified include file when calling the
synparseincfile function. The
EOFINC terminal symbol is returned if the end of the include file is reached, and reading continues where it was interrupted in the previously processed file. The function returns zero if no error occurred, (-1) on include file open errors or (-2) if the parser (i.e., the
synparsefile function) is not currently active.
Warning
The
EOFINC terminal symbol is required in the BNF definition whenever the
synparseincfile function is used; otherwise the parser issues an unexpected symbol syntax error when reaching the end of an include file. The
EOFINC terminal symbol is obsolete if the
synparseincfile function is not applied.
See also
Functions
syngetintpar,
synparsefile,
synparsestring,
synscaneoln,
synscanigncase,
synscanline,
synscanstring,
synsetintpar, and
chapter 2.6.4 of this manual.
synparsestring - BNF/parser input string scan (STD)
Synopsis
synparsestring( // Returns scan status
string; // Input string
[]; // Optional comment callback function
);
Description
The
synparsestring function activates a parser for scanning the given input string. The input string is processed according to the data format described with the BNF definition of the corresponding
User Language program. The BNF-defined parser action functions are automatically called. In these parser action functions, the
synscanline and
synscanstring functions can be utilized for getting the current input scan line number and the current input scan string. On request, the input scan string can be subject to semantic tests. The
synparsestring function is terminated if the end of the input string is reached or if a syntax error (or a semantic error encountered by a parser action function) has occurred.
Comment Callback Function
The second function parameter allows for the specification of a comment text callback function.
This function is activated if the corresponding scanner/parser parameter has been set with the synsetintpar function.
The callback function definition is as follows:
int commentfuncname(
string commentstring, // Comment without comment delimiters
)
{
// Function statements
:
return(stat);
}
The parser is stopped if the comment callback function returns a value other than zero. Otherwise the parser continues.
Diagnosis
The
synparsestring function return value denotes a certain scan status according to the following table:
| Return Value | Meaning |
0 | No error |
1 | No BNF definition available |
2 | Parser (synparsestring) is already active |
3 | File open error |
4 | Too many open files |
5 | Fatal read/write error |
6 | Scan item too long |
7 | Syntax error |
8 | Unexpected end of string |
9 | Stack overflow (BNF too complex) |
10 | Stack underflow (BNF erroneous) |
11 | Error from parser action function |
See also
Functions
syngetintpar,
synparsefile,
synparseincfile,
synscaneoln,
synscanigncase,
synscanline,
synscanstring,
synsetintpar, and
chapter 2.6.4 of this manual.
synscaneoln - BNF/scanner end-of-line recognition (STD)
Synopsis
int synscaneoln( // Return status
int [0,1]; // Scanner end-of-line recognition mode:
// 0 = deactivate EOLN recognition
// 1 = activate EOLN recognition
);
Description
The
synscaneoln function is used to enable and/or disable the end-of-line recognition for the BNF parser activated with the
synparsefile function. The end-of-line recognition is disabled on default. The function returns nonzero on error.
Warning
The usage of the
EOLN terminal symbol in a BNF definition is only valid if the end-of-line recognition is activated; otherwise end-of-line characters cause parser syntax errors.
See also
Functions
synparsefile,
synparseincfile,
synparsestring,
synscanigncase,
synscanline,
synscanstring, and
chapter 2.6.4 of this manual.
synscanigncase - BNF/scanner keyword case-sensitivity mode setting (STD)
Synopsis
int synscanigncase( // Return status
int [0,1]; // Keyword case-sensitivity mode:
// 0 = match case
// 1 = ignore case
);
Description
The
synscanigncase function is used to disable and/or enable keyword case-sensitivity for the BNF parser activated with the
synparsefile function. On default, keyword case-sensitivity is activated. The function returns nonzero on error.
See also
Functions
synparsefile,
synparseincfile,
synparsestring,
synscaneoln,
synscanline,
synscanstring, and
chapter 2.6.4 of this manual.
synscanline - BNF/scanner input line number (STD)
Synopsis
int synscanline( // Returns current scan line number
);
Description
The
synscanline function returns the input file line number currently processed by the
synparsefile function. The
synscanline function can be utilized in referenced parser action user functions to trace the scan process.
See also
Functions
synparsefile,
synparseincfile,
synparsestring,
synscaneoln,
synscanigncase,
synscanstring, and
chapter 2.6.4 of this manual.
synscanstring - BNF/scanner input string (STD)
Synopsis
string synscanstring( // Returns current scan string
);
Description
The
synscanstring function returns the string currently scanned by the
synparsefile function. The
synscanstring function can be utilized in referenced parser action user functions to check and store certain scanner input data.
See also
Functions
synparsefile,
synparseincfile,
synparsestring,
synscaneoln,
synscanigncase,
synscanline, and
chapter 2.6.4 of this manual.
synsetintpar - Set BNF/scanner integer parameter (STD)
Synopsis
int synsetintpar( // Returns status
int [0,[; // Parameter type/number:
// 0 = String control character interpretation mode
// 1 = Activate comment text callback function
// 2 = Any identifier character flag
int; // Parameter value
);
Description
The
synsetintpar function is used to set
User Language BNF/syntax scanner integer system parameters. The function returns zero if the parameter assignment was successful, or (-1) otherwise. The
syngetintpar function can be used to query parameter values set with
synsetintpar.
See also
Functions syngetintpar,
synparsefile,
synparseincfile,
synparsestring.
system - Pass command to operating system and wait for completion (STD)
Synopsis
int system( // Completion status
string; // Command string
);
Description
The
system function activates and/or executes the command specified in the command string parameter.
The command string is passed to the operating system command shell, and BAE waits until command execution is completed.
The function returns the status code returned by the operating system, the command interpreter or the executed program (whichever is last to execute before passing control back to BAE). A zero return value usually denotes successful execution, whilst nonzero return values notify errors and/or warnings.
Limitations
The
system function does not work in
BAE Demo software configurations.
Requirements
Executing MS-DOS (child) processes through DOS Extender requires enough conventional memory to be available for running the executable. Conventional memory must be controlled with the
-MINREAL and
-MAXREAL variables of the
Phar Lap 386|DOS Extender. For running
User Language programs using the
system function, the corresponding
User Language Interpreter environments must be re-configured by applying Phar Lap's redistributed CFIG386 tool as in
> cfig386 <EXEFILE> -maxreal 0ffffh
where
<EXEFILE> must be set to the appropriate
User Language Interpreter executable(s)
(scm.exe,
ged.exe,
neurrut.exe,
cam.exe,
gerview.exe and/or
ced.exe).
Warnings
Note that the
system function introduces basic multi-processing/multi-tasking features which are not fully supported on PC-based systems or can cause some problems on network-based workstation systems (depending on whichever OS command is to be executed).
It is strongly recommended to redirect DOS command standard output to temporary files (and use some file view
User Language function for display); otherwise, DOS standard output overwrites the BAE graphic user interface.
Erroneous DOS command calls cause error output to the screen, thus overwriting the BAE graphic interface. Due to the fact that DOS lacks from some substantial standard features such as redirect error output, this problem can only be solved by refraining and/or preventing from running erroneous DOS commands, e.g., by pre-checking the consistency of each DOS command to be called.
It is strongly recommended to refrain and/or prevent from calling interactive DOS commands and/or application software with the
system function since otherwise the system will "hang up" due to the fact that DOS standard input cannot be redirected from the BAE graphic user interface. It is also strongly recommended to refrain and/or prevent from directly calling UNIX commands which expect some user input (such as
more,
vi, etc.); this problem can be solved by a command cast to background (&) command shell start where the desired command should be called from (which however might cause a terminal device connection problem under remote login).
See also
Function
launch.
tan - Tangent (STD)
Synopsis
double tan( // Returns result value
double; // Input angle value (STD3)
);
Description
The
tan function calculates and returns the tangent value of the given angle value. The input angle value must be in radians.
tanh - Hyperbolic tangent (STD)
Synopsis
double tanh( // Returns result value
double; // Input angle value (STD3)
);
Description
The
tanh function calculates and returns the hyperbolic tangent value of the given angle value. The input angle value must be in radians.
tolower - Convert uppercase to lowercase character (STD)
Synopsis
char tolower( // Returns lowercase character
char; // Input character
);
Description
The
tolower function converts and returns the specified uppercase alphabetic input character to lowercase (or returns the input character unchanged if not uppercase alphabetic).
toupper - Convert lowercase to uppercase character (STD)
Synopsis
char toupper( // Returns uppercase character
char; // Input character
);
Description
The
toupper function converts and returns the specified lowercase alphabetic input character to uppercase (or returns the input character unchanged if not lowercase alphabetic).
uliptype - Get User Language interpreter environment (STD)
Synopsis
int uliptype( // Interpreter type:
// 0x0000 = invalid/unknown
// 0x0080 = SCM - Schematic Editor
// 0x0040 = GED - Layout Editor
// 0x0010 = AR - Autorouter
// 0x0008 = CAM - CAM Processor
// 0x0004 = CED - Chip Editor
// 0x1000 = CV - CAM View
);
Description
The
uliptype function returns the type of the currently active
User Language Interpreter environment.
ulipversion - Get User Language interpreter version (STD)
Synopsis
int ulipversion( // Returns interpreter version
);
Description
The
ulipversion function returns the internal version number of the currently active
User Language Interpreter environment.
ulproginfo - Get User Language program info (STD)
Synopsis
int ulproginfo( // Returns status
string; // Program name
& int; // Program version
& int; // Program caller type
);
Description
The
ulproginfo function gets the program version and the program caller type of a name-specified
User Language program. The program version is the internal version number of the
User Language Compiler used for compiling the program. The program caller type is a bit-mask value designating the
User Language Interpreter environments compatible for executing the
User Language program. The
ulproginfo function can be utilized together with the
ulip* functions to check whether a certain
User Language program can be executed in the current
User Language Interpreter environment.
See also
Functions
uliptype,
ulipversion.
ulsystem - Run another User Language program (STD)
Synopsis
int ulsystem( // Returns status
string; // Program name
& int; // Program counter
);
Description
The
ulsystem function executes the
User Language program with the specified program name. The function returns nonzero if an error occurred whilst loading or running the program (see below for diagnosis). On error, the program counter parameter returns the address of the machine program instruction, which caused the error (to be compared with the listing file generated by the
User Language Compiler).
Diagnosis
The
ulsystem function can return the following return values:
| Return Value | Meaning |
0 | Program successfully executed |
1 | DDB/database access error |
2 | Program already loaded |
3 | Program not found |
4 | Incompatible User Language Program Version |
5 | Incompatible index/function references |
6 | Stack underflow |
7 | Stack overflow |
8 | Division by zero |
9 | Error calling system function |
10 | System function not available |
11 | System function not implemented |
12 | User function not found |
13 | Invalid data type for user function |
14 | Invalid parameter list for user function |
15 | Error accessing array variable |
16 | Invalid array variable index |
17 | General file access error |
18 | General file read error |
19 | General file write error |
See also
Function ulsystem_exit.
ulsystem_exit - Run a User Language program after exiting current User Language program (STD)
Synopsis
void ulsystem_exit(
string; // Program name
);
Description
The
ulsystem function executes the
User Language program with the specified program name after exiting the current
User Language program.
See also
Functions exit,
ulsystem.
vardelete - Delete global User Language variable (STD)
Synopsis
int vardelete( // Returns status
string; // Variable name
);
Description
The
vardelete function is used for deleting a global
User Language variable previously defined with
varset. The function returns zero if the variable has been successfully deleted or (-1) if no variable with the specified name is defined.
See also
Functions
varget,
varset.
varget - Get global User Language variable value (STD)
Synopsis
int varget( // Returns status
string; // Variable name
& void; // Variable value
);
Description
The
varget function is used for retrieving the value of global
User Language variable previously defined with
varset. The function return value is zero if the query was successful, (-1) if no variable with the specified name is defined or (-2) if the data type of the variable does not match the data type of the variable value return parameter.
See also
Functions
vardelete,
varset.
varset - Set global User Language variable value (STD)
Synopsis
int varset( // Returns status
string; // Variable name
void; // Variable value
);
Description
The
varset functions defines a global
User Language variable with the specified variablen name and assigns the provided variable value. The variable value must match a basic data type
(int,
double,
char or
string), i.e., complex and/or combined data types such as arrays, structures or
index types are not allowed. The function returns zero on successful variable definition, (-1) for invalid variable name specifications or (-2) if the variable value does not match a basic data type. Global
User Language variable definitions are not deleted when the
User Language program exits, i.e., they stay resident until they are explicitly deleted with the
vardelete function or until the currently active BAE program module is exited. The
varget function can be used to retrieve the value of a global
User Language variable previously defined with
varset. Global
User Language variables can be used to exchange data between
User Language programs which run at different times in the same BAE module.
See also
Functions
vardelete,
varget.
Standard System Functions
© 1985-2024 Oliver Bartels F+E • Updated: 19 October 2013, 08:37 [UTC]
|
