PCE version 4C man_modulenamespaceid_tablemodified current_idOIxN class/pceN referenceC hash_tablerefersizeOIxNbothIBsNM.pce.S.catchedCman_method_card identifiermodule last_modifiednamesummary descriptionsee_alsoinherit diagnosticsdefaultsbugsOIxNM.pce.S.catchedRICdateOIx*´˜QNcatchednCstringOIx«Test if the indicated error_id is currently catched. If this method succeeds, raising the indicated error will make the method fail rather than printing an error-message.CchainsizeOIxIeNM.pce.S.catch_errorEN$class/error$C.errorXnnnnsNM.pce.G.unresolved_typesOIxNM.pce.G.unresolved_typesRIOIx,„»­Nunresolved_typesnOI xÈScans @types for types that are of `type <-kind: class', but have no initialised class associated with them. A name that is not the name of an existing class will be converted into a type of kind `class'. This type is only useful after the class is actually created. This mechanism allows the programmer to refer to classes as a type before defining them. The most likely cause of this trouble is a misspelled type-name or a forgotten class definition.nnnnnsNV.pce.catch_error_signalsCman_variable_card identifiermodule last_modifiednamesummary descriptionsee_alsoinheritdefaultsOI xNV.pce.catch_error_signalsRIOI x,„·qNcatch_error_signalsnOI x%Determines PCE's response to (normally) fatal error situations reported by the operating system. When such an error occurs, a [PCE SYSTEM ERROR] is generated. The following signals are considered fatal: SIGQUIT So, ^\ can be used to generate an error SIGILL Illegal instruction SIGEMT Emulator trap SIGBUS Bus error (illegal aligned pointer) SIGSEGV Segmentation fault (out-of-range pointer) SIGSYS Bad argument to system call SIGPIPE Broken pipe SIGFPE Floating point exception See your Unix manual for details on these signals.OI xIeN M.pce.S.crashENV.pce.print_c_stackXnOIxuThe initial value is @off (do not trap signals). Some host languages switch this flag to @on at initialisation time.sNM.pce.S.bannerOIxNM.pce.S.bannerRIOIx*´”NbannernOIxœWrites a standard banner message for PCE, indicating version, hardware, operating system, the hostlanguage to which PCE is connected and a copyright notice.OIxIeN V.pce.versionEN$class/host$V.host.systemXnnnnsNM.pce.G.object_from_referenceOIxNM.pce.G.object_from_referenceRIOIx:váNobject_from_referencenOIxConverts an object name or integer object-reference into an true object: ?- get(@pce, object_from_reference, prolog, Obj) Obj = @prolog This is the inverse of `object <-object_reference'. See also `object <-convert'. These methods are used seldomly by application programmers.OIxIeN)$class/object$M.object.G.object_referenceENM.pce.S.for_name_referenceXnnnnsN M.pce.G.userOIxN M.pce.G.userRIOIx:î€ÃNusernOIx¾Login name of user. On Unix systems this uses either getlogin() or password information from the current UID. On Windows it examines the environment variable %USER%. See also <-user_info.nnnnnsNV.pce.catched_errorsOIxNV.pce.catched_errorsRIOIx*´¡—Ncatched_errorsnOIxjChain holding all errors currently catched. Each element is either an error_id or a chain with error_id'.OIxIeNM.pce.S.catch_errorEN$class/error$C.errorXnnsNM.pce.G.environment_variableOIxNM.pce.G.environment_variableRIOIx,}EÓNenvironment_variablenOI xÀRead named Unix environment variable which' value is returned as a name. If `name' is `PCEHOME' and this is not defined as a Unix environment variable, the value of `@pce <-home' is returned.OI!xIEN V.pce.homeXnOI"xKIf the variable is not defined `pce <-environment_variable' fails silently.nnsNV.pce.exit_messagesOI#xNV.pce.exit_messagesRIOI$x*µ¬N exit_messagesnOI%xÃChain of code objects. When the PCE process is killed, each of these messages is executed in turn with the following argument: @arg1 Exit status of the process Filled by `pce ->exit_message'.OI&xIeN$errors$!.killed_on_exiteNM.pce.S.exit_messageEN M.pce.S.dieXnnsN M.pce.S.infoOI'xN M.pce.S.infoRIOI(x*·+öNinfonnOI)xIEN V.pce.versionXnnnnsNM.pce.G.answer_stack_sizeOI*xNM.pce.G.answer_stack_sizeRIOI+x6’åNanswer_stack_sizenOI,xýStatistics on the incremental garbage collection system. Objects created that are not related to any other object are pushed on the `answer' stack. They are deleted from this stack iff * They are related to another object * They are `object ->lock_object'ed (or given a named reference) * The answer-stack is rewinded to a point before the creation of the object. Both event-call-back and the execution of a PCE method mark and rewind this stack. Thus ?- new(X, point). Creates a point and leaves it on the answer-stack, while ?- [user]. create_point :- new(X, point). ^D ?- send(@prolog, create_point). Creates a point, pushes it on the answer-stack. Then rewinds this stack on exit of the `@prolog ->create_point', garbage collection the point object. Thus ?- pceusage(send(@prolog, create_point)). 0.00 seconds, 0 bytes, 1 created - 1 freed = 0 objects NOTE: pceusage/1 should often be called twice to get the intended result. The first call may create objects in the XPCE/Prolog cache.nnnnnsNV.pce.last_errorOI-xNV.pce.last_errorRIOI.x,„´½N last_errornOI/xOLast error catched by the application. See also ->catch_error and ->catch_pop.OI0xIeNM.pce.G.os_errorENV.pce.error_objectXnnsNV.pce.debuggingOI1xNV.pce.debuggingRIOI2x/Aô¶N debuggingnOI3xXVariable to indicate debugging-status of PCE. Set by `pce ->trace' and `method->trace'.OI4xIEN M.pce.S.debugXnOI5x@off (no debugging)sNM.pce.S.catch_popOI6xNM.pce.S.catch_popRIOI7x*´ž>N catch_popnOI8xORestores the catched errors to the state before the latest `pce ->catch_error'.OI9xIeNM.pce.S.catch_errorEN$class/error$C.errorXnnnnsNM.pce.S.succeedOI:xNM.pce.S.succeedRIOI;x0µº$NsucceednOIxNM.pce.S.for_name_referenceRIOI?x,„½óNfor_name_referencenOI@xiExecutes code for each defined global name reference (e.g. @pce, @arg1). The exit status of the code is ignored. Arguments: @arg1 Name of the global object (e.g. `pce', `arg1'). This method passes the reference-names rather than the objects themselves. As various of them are functions, good understanding of the expansion-rules for functions is necessary.OIAxIeNM.pce.G.object_from_referenceENM.pce.S.rename_referenceXnnnnsNV.pce.operating_systemOIBxNV.pce.operating_systemRIOICx:Ì\ Noperating_systemnOIDx°Identifier for the operating system running on your system. On Unix systems this is extracted from the autoconf standard system naming --. On MS-Windows this is one of: win32 The actual version could not be retreived win32s XPCE dowsn't run on this .. win95 DOS-7 based Windows (95,98,ME,...) winnt NT based Windows (NT, 2000) See also <-machine, <-window_system, <-window_system_revision and ->has_feature.OIExIEN V.pce.machineXnnsNM.pce.G.objects_allocatedOIFxNM.pce.G.objects_allocatedRIOIGx<ÈJ€Nobjects_allocatednOIHxƒObsolete method returning the same as get(class(object), no_created, @on, Count) See `class <-no_created' and `class<-no_freed'.OIIxIeNM.pce.G.objects_freedeN$class/class$V.class.no_createdEN $tools$10XnnnnsNM.pce.S.console_labelOIJxNM.pce.S.console_labelRIOIKx3L N console_labelnOILx$Set the label of the console-window from which XCE was started. Currently only implemented for the MS-Windows version of XPCE, and XPCE started from a Unix xterm(1) application. The latter is verified by checking the environment variable TERM for the value `xterm'. See also ->show_console.nnnnnsNM.pce.S.debug_subjectOIMxNM.pce.S.debug_subjectRIOINx9ì ÈN debug_subjectnOIOxØPrints messages to the terminal to debug certain aspects of the system. The debug_id's supported change quickly from release to release. Below is a tentative list. absolute_position Translation of relative coordinates allocate memory allocation compute Graphicals ->request_compute and ->compute cursor Determining visual cursor dialog Dialog layout editor Various editor happenings event Various things with events fill Filling text (editor) flash Flashing graphicals float Floating point conversions focus Event focusing fragment Fragment handling frame Various frame events gc Incremental garbage collection get_xref Maintenance of X id database image Some image functions clone Cloning objects menu Menu repaint message Execution of message objects obtain Failing obtainers path Smoothing paths popup Popup menu's post Event posting (event ->post) postscript PostScript generation process Actions on handling subprocesses redraw Repaint management save `Object ->save_in_file' scan `char_array <-scan' scroll Scrollbar handling shift text_image shifting of lines spatial execution of spatial constraints text Updating of text_images undo Undo in text_buffers xref X window references database ->nodebug_subject removes an item from this list. User code may exploit the same mechanism and test whether debugging a subject is enabled using ->debugging_subject.OIPxIeN$class/display$M.display.S.openENM.pce.S.nodebug_subjecteN $topics$148eN M.pce.S.debugXnnnnsN M.pce.S.dieOIQxN M.pce.S.dieRIOIRx0µªÛNdienOISxExit from the combined PCE/{Prolog,Lisp,...} process indicating status. It performs the following steps: * Request the host language to exit. This is done using the C-interface call hostAction(HOST_HALT). With a completely implemented interface, this in return will call PCE's cleanup functions registered with hostAction(HOST_ONHALT) and terminate the process. * If the host refuses to kill the process, PCE itself will call its registered cleanup functions and call exit() with the argument status. With a proper implemented interface, the normal termination will execute the `@pce <-exit_messages', kill possible subprocesses and terminate the process. The termination process is the same regardless of whether the host-language terminate functions is called or `pce->die' is invoked.OITxIENV.pce.exit_messagesXnnOIUx9The default termination status is 0 (indicating success).nsN M.pce.S.failOIVxN M.pce.S.failRIOIWx*µ­"NfailnOIXx'Fails immediately without side-effects.OIYxIENM.pce.S.succeedXnnnnsNM.pce.S.syntaxOIZxNM.pce.S.syntaxRIOI[x,}EÐNsyntaxnOI\x´Some languages (notably LISP) use case-insensitive keywords, internally represented in upper-case. Host-language keywords are most naturally mapped on PCE-names. This method, which is normally send by the LISP interface right after PCE has been initialised performs the following actions: # Map names to uppercase All predefined names of PCE that are strictly lowercase are mapped onto uppercase. This implies the lowercase equivalents disappear: classes, methods, variables and all other constants referred to in this manual will have uppercase names. # Change the word-separator. The default word separator of PCE,the '_' is replaced by the given character in all name objects.OI]xIEN$class/name$M.name.S.syntaxXnnOI^x.The default word separator is '_' (unchanged).OI_xTo get compatible resource-handling, resources defined as type `name' will be mapped to uppercase (and have their word-separator changed) when converted. Also, generated object-identifiers (for fonts, classes, etc.) will be mapped to upper-case. The run-time generated keywords may lead to unexpected behaviour. Finally, when converting of a bitmap- or image-name to a filename, the name is downcased. This makes it implossible to use automatic conversion when the file-name consists of uppercase characters.sNM.pce.S.for_nameOI`xNM.pce.S.for_nameRIOIax,„ªqNfor_namenOIbxExecutes the code object on all instances of class name. @arg1 is bound the the successive name objects. This method is safe: the name-base may be manipulated during its execution. Tbe code will not be executed for named added during the execution of `pce ->for_name'.nnnnnsN V.pce.homeOIcxN V.pce.homeRIOIdx*§I#NhomenOIexwHome directory of the pce system. Its value is used to find * PostScript header file /postscript/pce.ps * Standard bitmaps /bitmaps * The sources /src * The online manual material /man/reference The Prolog interface also adds the library directory /prolog/lib containing the PCE libraries (manual, demo programs, pcedraw, utilities).OIfxIeNM.pce.G.environment_variableENM.pce.G.postscript_headerXnnsNM.pce.S.load_defaultsOIgxNM.pce.S.load_defaultsRIOIhx5}HN load_defaultsnOIixÚLoads class_variable object default values from the given source. Initialisation of XPCE loads <-defaults. A Defaults file consists of statements. Each statement is on a seperate line. A statement may be split over several lines by preceeding the newline with a backslash (\). The exclamation mark (\!) is the line-comment character. All input from a ! upto the following newline is replaced by a single space-character. Empty lines or lines containing only blank space are ignored. Default files may include other default files using the statement #include Default statements are of the form: .: Where denotes the name of the class, or * to indicate the default applies for any class defining this class-variable. If both forms are found, the statement with the explicit class-name is used. denotes the class-variable name. is the default value of the class-variable. The syntax for is similar to the arguments of send/[2-12]. The (informal) syntax for is below. := | | | @ | | := [ {, } ] | [ {} ] := () | ( {, }) | | | | "" := {|""} := {|} | '{|''}}'nnnnnsN V.pce.machineOIjxN V.pce.machineRIOIkx,„¾aNmachinenOIlx3Identifier name for the hardware architecture used.OImxIENV.pce.operating_systemXnnsNM.pce.G.cpu_timeOInxNM.pce.G.cpu_timeRIOIox*Àx)Ncpu_timenOIpxÞCPU time used by the process PCE belongs to. When the argument is @default, this is the combined user and system time, otherwise it is the time specified. Note that the host language is normally part of the same process.OIqxIEN M.pce.S.benchXnnnnsN M.pce.G.dateOIrxN M.pce.G.dateRIOIsx,„µGNdatenOItxóRequests the system time using the C-library function ctime(3) and returns the result as a string object. The returned string has no trailing newline (as its Unix counterpart). Its format is: Sun Sep 16 01:03:52 1973 See also class date.OIuxIeN$class/date$M.date.G.stringEN$class/date$C.dateXnnnnsN M.pce.S.benchOIvxN M.pce.S.benchRIOIwx0µ¥vNbenchnOIxxœSends messages in a tight loop for benchmarking purposed. First argument is the message that is executed repeatedly. Second argument is the number of iterations. Last argument indicates which part of the message invocation is placed in the loop. The rest is moved out of the loop. Its values are: # forward Invoke the full `message ->forward' behaviour # execute As ->forward, put pushing and popping the argument stack outside the loop. # send Invokes the full send() virtual machine operation # invoke Move method-resolution outside the loop. Typechecking the arguments and starting the implementing code is all which is left inside the loop.OIyxIENM.pce.G.cpu_timeXnnnnsN V.pce.versionOIzxN V.pce.versionRIOI{x0µÃÜNversionnOI|x»Current version number of XPCE. When documenting this method: '4.4.3, September 1992' Its format: # First digit (4) Current major release. Generally indicates major revisions and a large number of incompatible changes: version 4 is based on X-windows whereas version 3 was using SunView. Version 4 adds user-defined classes, type inferencing, completely reorganised graphics and many more. Version 5 is not (yet) foreseen. # Second digit (4) Indicates minor releases with limited compatibility issues. # Third digit (3) Patch number. No incompatibilities except for minor one's for which we do not expect any normal application to be sensitive. These fields are followed by an indication of the time of release. If the <-version is requested with the argument `name', the time of the release is omitted (i.e. 4.4.3). Finally, if the version is requested as a number, the value 10000 * major + 100 + minor + patch is returned.OI}xIeNM.pce.S.bannerEN M.pce.S.infoXnnsNM.pce.G.os_errorOI~xNM.pce.G.os_errorRIOIx*·wNos_errornOI€x§Name indicating the last operating-system generated error. That is, the text that would normally be printed by the Unix utility perror(2). Its use is not encouraged.OIxIENV.pce.last_errorXnnnnsNV.pce.trap_errorsOI‚xNV.pce.trap_errorsRIOIƒx14IN trap_errorsnOI„xÕThis flag, which is only available in the development version, controls XPCE's behaviour if a runtime error is trapped in an application. When @on (default), the system will normally enter the tracer, allowing the user to inspect the context of the error. If @off, the system will use the `object->report' mechanism to report the error and the tracer will not be trapped. The latter behaviour is the only behaviour supported by the runtime system. See also ->trace.nnnsNV.pce.defaultsOI…xNV.pce.defaultsRIOI†x5}HËNdefaultsnOI‡xYFile/rc from which to load defaults. See ->load_defaults, class class_variable and class_variable/4. The default value is the file("$PCEHOME/Defaults") A runtime application that wishes the defauts to be in the resource file should do: resource(pce, defaults, pce('Defaults')). :- initialization send(@pce, defaults, rc(pce, defaults)).nnnsNM.pce.S.define_classOIˆxNM.pce.S.define_classRIOI‰x0µ«ÑN define_classnOIŠx=Declare a class without details. The system will run `code' when an action is performed that requires details of the class (such as creating an instance). All, except for some vital kernel classes of XPCE itself have been declared this way to delay/avoid building the class-definitions. See also `class ->realise'.nnnnnsNV.pce.exception_handlersOI‹xNV.pce.exception_handlersRIOIŒx6ÝNexception_handlersnOIxSheet with exception handlers used by `Pce ->exception'. Each entry of this sheet maps an exception-name onto a code object which is executed when the corresponding exception occurs. The argument bindings for @arg1, ... are the second, ... argument passed to `Pce ->exception'. The following exceptions are currently defined: # undefined_class An attempt is made to reference an non-existing class while doing one of the following: * Create an object * Load an object from file using `File <-object' * Create a subclass Parameters: @arg1: class name # undefined_error Called from `error<-convert' if the error id is not in @errors. If defined, it should create an error object with the requested identifier. Parameters: @arg1: identifier of missing error object. # undefined_assoc An attempt is made to resolve a symbolic reference (i.e. @pce), but the reference is unknown. Parameters: @arg1: reference name # redefined_assoc An attempt is made to create an object with the same symbolic reference as an already existing object. Parameters: @arg1: The existing reference name # initialisation_failed The ->initialisation method for some instance failed. Parameters: @arg1: The (partial) instance @arg2 ... The arguments given to ->initialiseOIŽxIeNM.pce.S.exceptionEN$predicates$17XnnsNV.pce.application_dataOIxNV.pce.application_dataRIOIxF·€¸Napplication_datanOI‘xèDirectory for storing xpce-related application data. On Unix systems the default is ~/.xpce. On Windows it is /xpce, where is the directory from CSIDL_APPDATA. This directory typically contains the following files: * Defaults User-level class variable values. * Geometry Saved geometries for persistent frames (see persistent_frame.pl). * emacs_bookmarks Bookmarks created by PceEmacs Applications using the pce_config.pl library create additional files.nnnsNM.pce.S.write_lnOI’xNM.pce.S.write_lnRIOI“x*·/XNwrite_lnnOI”xWrites the arguments as `pce->write' and terminates the line with a newline. Useful for dumping information to the terminal: send(@images, for_all, message(@pce, write_ln, @arg1, @arg2)). Dumps a map of all named image objects (which is initially empty).OI•xIEN M.pce.S.writeXnnnnsNM.pce.S.informOI–xNM.pce.S.informRIOI—x,„´‡NinformnOI˜xiIf there is an open display, run `display ->inform'. Otherwise ->format the information on the terminal.OI™xIeN!$class/display$M.display.S.informENM.pce.S.confirmXnnnnsNM.pce.S.formatOIšxNM.pce.S.formatRIOI›x,„´fNformatnOIœxsWrite formatted output to the main window. Normally only used for reporting debugging information. For example, the following query dumps the mapping represented by the hash_table object @classes to the terminal: ?- send(@classes, for_all, message(@pce, format, '%s\t%s\n', @arg1, @arg2)). See `string ->format' for a description of the format specification.nnnnnsNM.pce.S.iconify_consoleOIxNM.pce.S.iconify_consoleRIOIžx3LINiconify_consolenOIŸxshow_console: iconic.nnnnnsNC.pceCman_class_card identifiermodule last_modifiednamesummary descriptionsee_alsoinherituser_interfacebugsOI xNC.pceRIOI¡x,„ªPNpcenOI¢xClass pce has one predefined instance, called `@pce'. The object @pce provides operations to control the overall environment of PCE as well as operations that are not a clear action on some object. @pce is also used to control the debugger/tracer; handle exceptions, etc.OI£xIeN $topics$74eN $topics$75eN $topics$73eN $objects$1EN$class/host$C.hostXnnnsNM.pce.S.exit_messageOI¤xNM.pce.S.exit_messageRIOI¥x*µ¬»N exit_messagenOI¦xuPrepends code object to `pce <-exit_messages'. That is: the last exit message registered will be executed the first.OI§xIENV.pce.exit_messagesXnnnnsNM.pce.S.exceptionOI¨xNM.pce.S.exceptionRIOI©x)|øN exceptionnOIªxóRaise an exception. The first argument is the name of the exception. The remaining arguments are passed as context parameters to the code dealing with the exception. The exception handlers are defined in the sheet `Pce <-exception_handlers'.OI«xIeN$class/class$M.class.G.converteN$class/class$M.class.G.instanceENV.pce.exception_handlersXnnnOI¬x'The exception mechanism is rudimentaly.sNM.pce.S.nodebug_subjectOI­xNM.pce.S.nodebug_subjectRIOI®x,„À0Nnodebug_subjectnnOI¯xIENM.pce.S.debug_subjectXOI°xIENM.pce.S.debug_subjectXnnnsNM.pce.S.list_wasted_coreOI±xNM.pce.S.list_wasted_coreRIOI²x,„¸üNlist_wasted_corenOI³xÓDumps a map of wasted-core cells. Wasted core is core allocated, freed and not yet reused. With list_content @on, PCE tries to identify the object deleted. This might lead to crashes. See also <-core_wasted.OI´xIENM.pce.G.core_wastedXnnnnsNM.pce.S.confirmOIµxNM.pce.S.confirmRIOI¶x25uËNconfirmnOI·xÃIf pce is connected to an open display, invokes `display ->confirm' on @display. Otherwise the text is formatted on the terminal and PCE requests the user to type `y' or `n'. Used infrequently.OI¸xIeNM.pce.S.informEN"$class/display$M.display.S.confirmXnnnnsNM.pce.S.featureOI¹xNM.pce.S.featureRIOIºx.ÝøéNfeaturennnOI»xIENV.pce.featuresXnnnsN M.pce.S.writeOI¼xN M.pce.S.writeRIOI½x*·-{NwritenOI¾x•Write the arguments using PCE's internal pretty-printing routine. The arguments are separated by spaces. Note that output is generally not flushed.OI¿xIENM.pce.S.write_lnXnnnnsNM.pce.S.multi_threadingOIÀxNM.pce.S.multi_threadingRIOIÁx82Š}Nmulti_threadingnOIÂxÂEnable thread-safe access to XPCE. This method is normally sent from the host-language interface at initialisation time if the host-language wishes to access XPCE from multiple threads. The host-language interface should use the functions pceMTLock() and pceMTUnlock() as wrappers around access to XPCE. This method fails with an error when invoked too late (for the X11 version this implies after the window system has been initialised). It fails silently if this version of XPCE is not compiled to support multi-threading. XPCE multi-threading support is currently rather limited: it consists of one global `recursive' mutex that ensures the system is activated in a single-thread only. This mutex should be locked by the host-language around access to the basic operations (send, get, new and object) and is locked by XPCE itself for any event processed. XPCE call-back occurs in the thread waiting for events. In the normal XPCE/Prolog context this is the main-thread. As the system is locked during event-processing, smooth interactive operation requires event-processing to be completed quickly. If an event causes a long operation to start the host-language should run this operation in another thread.nnnnnsNM.pce.S.catch_errorOIÃxNM.pce.S.catch_errorRIOIÄx:/ÞN catch_errornOIÅx$Inform PCE's error recovery mechanism that the application takes care of the indicated error, one of the indicated errors or all errors (@default). If such an error occurs the method normally fails silently, setting <-last_error. The method `pce ->catch_pop' restores the catched errors to the state before invoking ->catch_error. The prolog predicate pce_catch_error/2 provides an interface: ?- send(@pce, hello, pce). [PCE error: send: No implementation for: @pce/pce ->hello in: send(@pce/pce, hello, pce)] PCE: 1 fail: send(@pce/pce, hello, pce) ? While ?- pce_catch_error(no_behaviour, send(@pce, hello, pce)). No After which ?- get(@pce, last_error, E). ==> E = no_behaviour Note that errors with <-feedback: throw can also be handled using Prolog exception-handling.OIÆxIeNM.pce.S.catch_popeNM.pce.S.catchedeNV.pce.catched_errorsEN$class/error$C.errorXnnnnsNM.pce.S.debugging_subjectOIÇxNM.pce.S.debugging_subjectRIOIÈx9ì Ndebugging_subjectnOIÉxóTest whether the named subject is registered using ->debug_subject and <-debugging is @on. This test may be used in application code to exploit this debugging mechanism of XPCE. In a runtime system this method is available, but fails always.nnnnnsNM.pce.S.initialiseOIÊxNM.pce.S.initialiseRIOIËx,„¬N initialisenOIÌxfCalled at boot time to create the one-and-only instance called @pce. No more instances may be created.nnnnnsNM.pce.G.max_integerOIÍxNM.pce.G.max_integerRIOIÎx3lbN max_integernOIÏxHighest/lowest integer value that may be represented using PCE's data-type `int' or `number'. Current range: -2^29 ... 2^29 - 1 (-536870912 ... 536870911)OIÐxIeN$class/number$C.numberENM.pce.G.min_integerXnnnnsNM.pce.G.min_integerOIÑxNM.pce.G.min_integerRIOIÒx,”ÕN min_integernnOIÓxIENM.pce.G.max_integerXOIÔxIENM.pce.G.max_integerXnnnsN M.pce.G.fdOIÕxN M.pce.G.fdRIOIÖx*µ­¦NfdnOI×xáNumber of remaining unused Unix file-descriptors. When PCE was based on the SunView windowing environment, each window used a file descriptor and an ungraceful error was generated when no more filedescriptors were available.nnnnnsNM.pce.S.rename_referenceOIØxNM.pce.S.rename_referenceRIOIÙx,„¾,Nrename_referencenOIÚx¾Change the name of a global reference. This method may be used to rename functions. Its use is strongly discouraged for normal application programmers. See also `object ->name_reference'.OIÛxIeN'$class/object$M.object.S.name_referenceENM.pce.S.for_name_referenceXnnnnsNM.pce.S.show_consoleOIÜxNM.pce.S.show_consoleRIOIÝx3KºN show_consolenOIÞxControl visibility of the console window, if accessible. This call only works in the Windows version of XPCE, and only if the host interface honours the hostQuery(HOST_CONSOLE) request. The meaning of the argument: # open The console is opened normally. This is the normal situation for program development. # iconic The console is displayed as an icon. This is useful for testing applications. If the applications behaves strange, the console may be opened to check it for error messages. # hidden The console windows is removed from the display. This is the normal situation for finished applications. Make sure that the application terminates if the last windows disappears (see library(pce_main) for some standard predicates to realise the toplevel control loop).nnnnnsNM.pce.G.instanceOIßxNM.pce.G.instanceRIOIàx-©ÀNinstancenOIáxCreate an object (as Prolog new/2 or Lisp pce-new()). @pce <-instance converts the first argument into a class. This process deals with handling class-names rather then class objects and invokes the autoloader if the class does not yet exist (see pce_autoload/2 and <-exception_handlers). Next, the method `Class <-instance' is called to create the new instance. The following function creates a new point object each time it is evaluated: ?(@pce, instance, point, 4, 5) See also class create, `class <-instance' and @vmi_new.OIâxIeN$class/class$M.class.G.instanceeN $predicates$1EN $topics$7XnnnnsNM.pce.S.expose_consoleOIãxNM.pce.S.expose_consoleRIOIäx3LNexpose_consolenOIåx§Backward compatibility equivalent of ->show_console: open. Expose the console window of XPCE. Only implemented for the MS-Windows version. See also ->console_label.nnnnnsNM.pce.G.objects_freedOIæxNM.pce.G.objects_freedRIOIçx(S< N objects_freednnOIèxIeN$class/class$V.class.no_freedeNM.pce.G.objects_allocatedEN $tools$10XnnnnsN M.pce.G.pidOIéxN M.pce.G.pidRIOIêx0o0NpidnOIëx×Unix process identifier for this process. May be used to create unique system-wide names. Note that file objects with a proper temporary name may be created using ?- new(TmpFile, file). See `file ->initialise'.nnnnnsNM.pce.G.core_wastedOIìxNM.pce.G.core_wastedRIOIíx*´™±N core_wastednOIîx2Memory allocated by PCE, but currently not in use.OIïxIeNM.pce.S.list_wasted_coreeNM.pce.G.core_usageEN $tools$10XnnnnsNM.pce.G.core_usageOIðxNM.pce.G.core_usageRIOIñx*´™™N core_usagenOIòxÃNumber of bytes core allocated by PCE. Notes: 1) Memory requested by the X-window libraries or the host-language is not included 2) Memory requested by PCE is never returned to the process.OIóxIeNM.pce.G.core_wastedEN $tools$10XnnnnsNM.pce.G.deferred_unallocedOIôxNM.pce.G.deferred_unallocedRIOIõx,„½ÛNdeferred_unallocednOIöxÄNumber of objects that has been ->free'd by the user, but are still referenced. To avoid crashes, the memory belonging to such objects is not freed as long as there are references to the object.nnnnnsNM.pce.G.convertOI÷xNM.pce.G.convertRIOIøx0µœGNconvertnOIùx›The method `pce <-convert' provides access to `type <-check', the PCE type checking and conversion system. The first argument is the object to be checked/converted. The second is the type that should be met. Equivalent to `type <-check', but generally more comfortable as this method will automatically translate a type specification into a type object. The following example converts anything convertible to an integer to an integer: convert_to_int(Any, Int) :- get(@pce, convert, Any, int, Int). After which convert_to_int('78', X) ==> 78 convert_to_int(string('1992'), X) ==> 1992 convert_to_int(hello, X) fails convert_to_int(100, X) ==> 100OIúxIeN$class/type$M.type.G.checkeN$class/type$M.type.G.converteN $topics$118XnnnnXaCnumber O Iûxx