fpc/packages/libxml/src/xpath.inc

(*
 * Summary: XML Path Language implementation
 * Description: API for the XML Path Language implementation
 *
 * XML Path Language implementation
 * XPath is a language for addressing parts of an XML document,
 * designed to be used by both XSLT and XPointer
 *     http://www.w3.org/TR/xpath
 *
 * Implements
 * W3C Recommendation 16 November 1999
 *     http://www.w3.org/TR/1999/REC-xpath-19991116
 *
 * Copy: See Copyright for the status of this software.
 *
 * Author: Daniel Veillard
 *)

{$IFDEF LIBXML_XPATH_ENABLED}

{$IFDEF POINTER}
  xmlXPathContextPtr = ^xmlXPathContext;
  xmlXPathParserContextPtr = ^xmlXPathParserContext;
  xmlNodeSetPtr = ^xmlNodeSet;
  xmlXPathObjectPtr = ^xmlXPathObject;
  xmlXPathObjectPtrPtr = ^xmlXPathObjectPtr;
  xmlXPathTypePtr = ^xmlXPathType;
  xmlXPathVariablePtr = ^xmlXPathVariable;
  xmlXPathFuncPtr = ^xmlXPathFunc;
  xmlXPathAxisPtr = ^xmlXPathAxis;
  xmlXPathCompExprPtr = ^xmlXPathCompExpr;
{$ENDIF}

{$IFDEF TYPE}
(**
 * The set of XPath error codes.
 *)

  xmlXPathError = (
    XPATH_EXPRESSION_OK = 0,
    XPATH_NUMBER_ERROR,
    XPATH_UNFINISHED_LITERAL_ERROR,
    XPATH_START_LITERAL_ERROR,
    XPATH_VARIABLE_REF_ERROR,
    XPATH_UNDEF_VARIABLE_ERROR,
    XPATH_INVALID_PREDICATE_ERROR,
    XPATH_EXPR_ERROR,
    XPATH_UNCLOSED_ERROR,
    XPATH_UNKNOWN_FUNC_ERROR,
    XPATH_INVALID_OPERAND,
    XPATH_INVALID_TYPE,
    XPATH_INVALID_ARITY,
    XPATH_INVALID_CTXT_SIZE,
    XPATH_INVALID_CTXT_POSITION,
    XPATH_MEMORY_ERROR,
    XPTR_SYNTAX_ERROR,
    XPTR_RESOURCE_ERROR,
    XPTR_SUB_RESOURCE_ERROR,
    XPATH_UNDEF_PREFIX_ERROR,
    XPATH_ENCODING_ERROR,
    XPATH_INVALID_CHAR_ERROR,
    XPATH_INVALID_CTXT,
    XPATH_STACK_ERROR,
    XPATH_FORBID_VARIABLE_ERROR,
    XPATH_OP_LIMIT_EXCEEDED,
    XPATH_RECURSION_LIMIT_EXCEEDED
  );

(*
 * A node-set (an unordered collection of nodes without duplicates).
 *)
  xmlNodeSet = record
    nodeNr  : cint;			(* number of nodes in the set *)
    nodeMax : cint;		(* size of the array as allocated *)
    nodeTab : xmlNodePtrPtr;	(* array of nodes in no particular order *)
    (* @@ with_ns to check wether namespace nodes should be looked at @@ *)
  end;

(*
 * An expression is evaluated to yield an object, which
 * has one of the following four basic types:
 *   - node-set
 *   - boolean
 *   - number
 *   - string
 *
 * @@ XPointer will add more types !
 *)

  xmlXPathObjectType = (
    XPATH_UNDEFINED = 0,
    XPATH_NODESET = 1,
    XPATH_BOOLEAN = 2,
    XPATH_NUMBER = 3,
    XPATH_STRING = 4,
    XPATH_POINT = 5,
    XPATH_RANGE = 6,
    XPATH_LOCATIONSET = 7,
    XPATH_USERS = 8,
    XPATH_XSLT_TREE = 9  (* An XSLT value tree, non modifiable *)
  );

  xmlXPathObject = record
    _type       : xmlXPathObjectType;
    nodesetval  : xmlNodeSetPtr;
    boolval     : cint;
    floatval    : cdouble;
    stringval   : xmlCharPtr;
    user        : pointer;
    index       : cint;
    user2       : pointer;
    index2      : cint;
  end;

(**
 * xmlXPathConvertFunc:
 * @obj:  an XPath object
 * @type:  the number of the target type
 *
 * A conversion function is associated to a type and used to cast
 * the new type to primitive values.
 *
 * Returns -1 in case of error, 0 otherwise
 *)
  xmlXPathConvertFunc = function(obj: xmlXPathObjectPtr; _type: cint): cint; EXTDECL;

(*
 * Extra type: a name and a conversion function.
 *)
  xmlXPathType = record
    name  : xmlCharPtr;		(* the type name *)
    func  : xmlXPathConvertFunc;		(* the conversion function *)
  end;

(*
 * Extra variable: a name and a value.
 *)
  xmlXPathVariable = record
    name  : xmlCharPtr;		(* the variable name *)
    value : xmlXPathObjectPtr;		(* the value *)
  end;

(**
 * xmlXPathEvalFunc:
 * @ctxt: an XPath parser context
 * @nargs: the number of arguments passed to the function
 *
 * An XPath evaluation function, the parameters are on the XPath context stack.
 *)

  xmlXPathEvalFunc = procedure(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL;

(*
 * Extra function: a name and a evaluation function.
 *)

  xmlXPathFunc = record
    name  : xmlCharPtr;		(* the function name *)
    func  : xmlXPathEvalFunc;		(* the evaluation function *)
  end;

(**
 * xmlXPathAxisFunc:
 * @ctxt:  the XPath interpreter context
 * @cur:  the previous node being explored on that axis
 *
 * An axis traversal function. To traverse an axis, the engine calls
 * the first time with cur == NULL and repeat until the function returns
 * NULL indicating the end of the axis traversal.
 *
 * Returns the next node in that axis or NULL if at the end of the axis.
 *)

  xmlXPathAxisFunc = function(ctxt: xmlXPathParserContextPtr; cur: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL;

(*
 * Extra axis: a name and an axis function.
 *)
  xmlXPathAxis = record
    name  : xmlCharPtr;		(* the axis name *)
    func  : xmlXPathAxisFunc;		(* the search function *)
  end;

(**
 * xmlXPathFunction:
 * @ctxt:  the XPath interprestation context
 * @nargs:  the number of arguments
 *
 * An XPath function.
 * The arguments (if any) are popped out from the context stack
 * and the result is pushed on the stack.
 *)
  xmlXPathFunction = procedure(ctxt: xmlXPathParserContextPtr; nargs: cint); EXTDECL;

(*
 * Function and Variable Lookup.
 *)

(**
 * xmlXPathVariableLookupFunc:
 * @ctxt:  an XPath context
 * @name:  name of the variable
 * @ns_uri:  the namespace name hosting this variable
 *
 * Prototype for callbacks used to plug variable lookup in the XPath
 * engine.
 *
 * Returns the XPath object value or NULL if not found.
 *)
  xmlXPathVariableLookupFunc = function(ctxt: pointer; name, ns_uri: xmlCharPtr): xmlXPathObjectPtr; EXTDECL;

(**
 * xmlXPathFuncLookupFunc:
 * @ctxt:  an XPath context
 * @name:  name of the function
 * @ns_uri:  the namespace name hosting this function
 *
 * Prototype for callbacks used to plug function lookup in the XPath
 * engine.
 *
 * Returns the XPath function or NULL if not found.
 *)
  xmlXPathFuncLookupFunc = function(ctxt: pointer; name, ns_uri: xmlCharPtr): xmlXPathFunction; EXTDECL;
{$ENDIF}

{$IFDEF CONST}
(**
 * xmlXPathFlags:
 * Flags for XPath engine compilation and runtime
 *)
(**
 * XML_XPATH_CHECKNS:
 *
 * check namespaces at compilation
 *)
  XML_XPATH_CHECKNS = (1 shl 0);
(**
 * XML_XPATH_NOVAR:
 *
 * forbid variables in expression
 *)
  XML_XPATH_NOVAR	 = (1 shl 1);
{$ENDIF}

{$IFDEF TYPE}
(**
 * xmlXPathContext:
 *
 * Expression evaluation occurs with respect to a context.
 * he context consists of:
 *    - a node (the context node) 
 *    - a node list (the context node list) 
 *    - a set of variable bindings 
 *    - a function library 
 *    - the set of namespace declarations in scope for the expression 
 * Following the switch to hash tables, this need to be trimmed up at
 * the next binary incompatible release.
 * The node may be modified when the context is passed to libxml2
 * for an XPath evaluation so you may need to initialize it again
 * before the next call.
 *)

  xmlXPathContext = record
    doc                 : xmlDocPtr;			(* The current document *)
    node                : xmlNodePtr;			(* The current node *)

    nb_variables_unused : cint;		(* unused (hash table) *)
    max_variables_unused: cint;		(* unused (hash table) *)
    varHash             : xmlHashTablePtr;		(* Hash table of defined variables *)

    nb_types            : cint;			(* number of defined types *)
    max_types           : cint;			(* max number of types *)
    types               : xmlXPathTypePtr;		(* Array of defined types *)

    nb_funcs_unused     : cint;		(* unused (hash table) *)
    max_funcs_unused    : cint;		(* unused (hash table) *)
    funcHash            : xmlHashTablePtr;		(* Hash table of defined funcs *)

    nb_axis             : cint;			(* number of defined axis *)
    max_axis            : cint;			(* max number of axis *)
    axis                : xmlXPathAxisPtr;		(* Array of defined axis *)

    (* the namespace nodes of the context node *)
    namespaces          : xmlNsPtrPtr;		(* Array of namespaces *)
    nsNr                : cint;				(* number of namespace in scope *)
    user                : pointer;				(* function to free *)

    (* extra variables *)
    contextSize         : cint;			(* the context size *)
    proximityPosition   : cint;		(* the proximity position *)

    (* extra stuff for XPointer *)
    xptr                : cint;				(* is this an XPointer context? *)
    here                : xmlNodePtr;			(* for here() *)
    origin              : xmlNodePtr;			(* for origin() *)

    (* the set of namespace declarations in scope for the expression *)
    nsHash              : xmlHashTablePtr;		(* The namespaces hash table *)
    varLookupFunc       : xmlXPathVariableLookupFunc;(* variable lookup func *)
    varLookupData       : pointer;		(* variable lookup data *)

    (* Possibility to link in an extra item *)
    extra               : pointer;                        (* needed for XSLT *)

    (* The function name and URI when calling a function *)
    _function           : xmlCharPtr;
    functionURI         : xmlCharPtr;

    (* function lookup function and data *)
    funcLookupFunc      : xmlXPathFuncLookupFunc;(* function lookup func *)
    funcLookupData      : pointer;		(* function lookup data *)

    (* temporary namespace lists kept for walking the namespace axis *)
    tmpNsList           : xmlNsPtr;		(* Array of namespaces *)
    tmpNsNr             : cint;			(* number of namespaces in scope *)

    (* error reporting mechanism *)
    userData            : pointer;                     (* user specific data block *)
    error               : xmlStructuredErrorFunc;       (* the callback in case of errors *)
    lastError           : xmlError;			(* the last error *)
    debugNode           : xmlNodePtr;		(* the source node XSLT *)

    (* dictionary *)
    dict                : xmlDictPtr;			(* dictionary if any *)

    flags               : cint;				(* flags to control compilation *)

    (* Cache for reusal of XPath objects *)
    cache               : pointer;

    (* Resource limits *)
    opLimit             : culong;
    opCount             : culong;
    depth               : cint;
    maxDepth            : cint;
    maxParserDepth      : cint;
  end;

(*
 * The structure of a compiled expression form is not public.
 *)
  xmlXPathCompExpr = record end;

(**
 * xmlXPathParserContext:
 *
 * An XPath parser context. It contains pure parsing informations,
 * an xmlXPathContext, and the stack of objects.
 *)
  xmlXPathParserContext = record
    cur           : xmlCharPtr;			(* the current AnsiChar being parsed *)
    base          : xmlCharPtr;			(* the full expression *)

    error         : cint;				(* error code *)

    context       : xmlXPathContextPtr;	(* the evaluation context *)
    value         : xmlXPathObjectPtr;	(* the current value *)
    valueNr       : cint;	(* number of values stacked *)
    valueMax      : cint;	(* max number of values stacked *)
    valueTab      : xmlXPathObjectPtrPtr;	(* stack of values *)

    comp          : xmlXPathCompExprPtr;		(* the precompiled expression *)
    xptr          : cint;				(* it this an XPointer expression *)
    ancestor      : xmlNodePtr;	(* used for walking preceding axis *)

    valueFrame    : cint;        (* used to limit Pop on the stack *)
  end;
{$ENDIF}

{$IFDEF FUNCTION}
(************************************************************************
 *									*
 *			Public API					*
 *									*
 ************************************************************************)

procedure xmlXPathFreeObject(obj: xmlXPathObjectPtr); EXTDECL; external xml2lib;
function xmlXPathNodeSetCreate(val: xmlNodePtr): xmlNodeSetPtr; EXTDECL; external xml2lib;
procedure xmlXPathFreeNodeSetList(obj: xmlXPathObjectPtr); EXTDECL; external xml2lib;
procedure xmlXPathFreeNodeSet(obj: xmlNodeSetPtr); EXTDECL; external xml2lib;
function xmlXPathObjectCopy(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
function xmlXPathCmpNodes(node1, node2: xmlNodePtr): cint; EXTDECL; external xml2lib;

(**
 * Conversion functions to basic types.
 *)
function xmlXPathCastNumberToBoolean(val: cdouble): cint; EXTDECL; external xml2lib;
function xmlXPathCastStringToBoolean(val: xmlCharPtr): cint; EXTDECL; external xml2lib;
function xmlXPathCastNodeSetToBoolean(ns: xmlNodeSetPtr): cint; EXTDECL; external xml2lib;
function xmlXPathCastToBoolean(ns: xmlXPathObjectPtr): cint; EXTDECL; external xml2lib;

function xmlXPathCastBooleanToNumber(val: cint): cdouble; EXTDECL; external xml2lib;
function xmlXPathCastStringToNumber(val: xmlCharPtr): cdouble; EXTDECL; external xml2lib;
function xmlXPathCastNodeToNumber(val: xmlNodePtr): cdouble; EXTDECL; external xml2lib;
function xmlXPathCastNodeSetToNumber(val: xmlNodeSetPtr): cdouble; EXTDECL; external xml2lib;
function xmlXPathCastToNumber(val: xmlXPathObjectPtr): cdouble; EXTDECL; external xml2lib;

function xmlXPathCastBooleanToString(val: cint): xmlCharPtr; EXTDECL; external xml2lib;
function xmlXPathCastNumberToString(val: cdouble): xmlCharPtr; EXTDECL; external xml2lib;
function xmlXPathCastNodeToString(val: xmlNodePtr): xmlCharPtr; EXTDECL; external xml2lib;
function xmlXPathCastNodeSetToString(val: xmlNodeSetPtr): xmlCharPtr; EXTDECL; external xml2lib;
function xmlXPathCastToString(val: xmlXPathObjectPtr): xmlCharPtr; EXTDECL; external xml2lib;

function xmlXPathConvertBoolean(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
function xmlXPathConvertNumber(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
function xmlXPathConvertString(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;

(**
 * Context handling.
 *)
function xmlXPathNewContext(doc: xmlDocPtr): xmlXPathContextPtr; EXTDECL; external xml2lib;
procedure xmlXPathFreeContext(ctxt: xmlXPathContextPtr); EXTDECL; external xml2lib;
function xmlXPathContextSetCache(ctxt: xmlXPathContextPtr; active, value, options: cint): cint; EXTDECL; external xml2lib;

(**
 * Evaluation functions.
 *)
function xmlXPathOrderDocElems(doc: xmlDocPtr): clong; EXTDECL; external xml2lib;
function xmlXPathSetContextNode(node: xmlNodePtr; ctx: xmlXPathContextPtr): cint; EXTDECL; external xml2lib;
function xmlXPathNodeEval(node: xmlNodePtr; const str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
function xmlXPathEval(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
function xmlXPathEvalExpression(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
function xmlXPathEvalPredicate(ctxt: xmlXPathContextPtr; res: xmlXPathObjectPtr): cint; EXTDECL; external xml2lib;

(**
 * Separate compilation/evaluation entry points.
 *)
function xmlXPathCompile(str: xmlCharPtr): xmlXPathCompExprPtr; EXTDECL; external xml2lib;
function xmlXPathCtxtCompile(ctxt: xmlXPathContextPtr; str: xmlCharPtr): xmlXPathCompExprPtr; EXTDECL; external xml2lib;
function xmlXPathCompiledEval(comp: xmlXPathCompExprPtr; ctxt: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL; external xml2lib;
function xmlXPathCompiledEvalToBoolean(comp: xmlXPathCompExprPtr; ctxt: xmlXPathContextPtr): cint; EXTDECL; external xml2lib;
procedure xmlXPathFreeCompExpr(comp: xmlXPathCompExprPtr); EXTDECL; external xml2lib;
{$ENDIF}

{$IFDEF FUNCTIONVAR}
(************************************************************************
 *									*
 *			Public API					*
 *									*
 ************************************************************************)

  xmlXPathFreeObject: procedure(obj: xmlXPathObjectPtr); EXTDECL;
  xmlXPathNodeSetCreate: function(val: xmlNodePtr): xmlNodeSetPtr; EXTDECL;
  xmlXPathFreeNodeSetList: procedure(obj: xmlXPathObjectPtr); EXTDECL;
  xmlXPathFreeNodeSet: procedure(obj: xmlNodeSetPtr); EXTDECL;
  xmlXPathObjectCopy: function(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL;
  xmlXPathCmpNodes: function(node1, node2: xmlNodePtr): cint; EXTDECL;

(**
 * Conversion functions to basic types.
 *)
  xmlXPathCastNumberToBoolean: function(val: cdouble): cint; EXTDECL;
  xmlXPathCastStringToBoolean: function(val: xmlCharPtr): cint; EXTDECL;
  xmlXPathCastNodeSetToBoolean: function(ns: xmlNodeSetPtr): cint; EXTDECL;
  xmlXPathCastToBoolean: function(ns: xmlXPathObjectPtr): cint; EXTDECL;

  xmlXPathCastBooleanToNumber: function(val: cint): cdouble; EXTDECL;
  xmlXPathCastStringToNumber: function(val: xmlCharPtr): cdouble; EXTDECL;
  xmlXPathCastNodeToNumber: function(val: xmlNodePtr): cdouble; EXTDECL;
  xmlXPathCastNodeSetToNumber: function(val: xmlNodeSetPtr): cdouble; EXTDECL;
  xmlXPathCastToNumber: function(val: xmlXPathObjectPtr): cdouble; EXTDECL;

  xmlXPathCastBooleanToString: function(val: cint): xmlCharPtr; EXTDECL;
  xmlXPathCastNumberToString: function(val: cdouble): xmlCharPtr; EXTDECL;
  xmlXPathCastNodeToString: function(val: xmlNodePtr): xmlCharPtr; EXTDECL;
  xmlXPathCastNodeSetToString: function(val: xmlNodeSetPtr): xmlCharPtr; EXTDECL;
  xmlXPathCastToString: function(val: xmlXPathObjectPtr): xmlCharPtr; EXTDECL;

  xmlXPathConvertBoolean: function(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL;
  xmlXPathConvertNumber: function(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL;
  xmlXPathConvertString: function(val: xmlXPathObjectPtr): xmlXPathObjectPtr; EXTDECL;

(**
 * Context handling.
 *)
  xmlXPathNewContext: function(doc: xmlDocPtr): xmlXPathContextPtr; EXTDECL;
  xmlXPathFreeContext: procedure(ctxt: xmlXPathContextPtr); EXTDECL;
  xmlXPathContextSetCache: function(ctxt: xmlXPathContextPtr; active, value, options: cint): cint; EXTDECL;

(**
 * Evaluation functions.
 *)
  xmlXPathOrderDocElems: function(doc: xmlDocPtr): clong; EXTDECL;
  xmlXPathSetContextNode: function(node: xmlNodePtr; ctx: xmlXPathContextPtr): cint; EXTDECL;
  xmlXPathNodeEval: function(node: xmlNodePtr; const str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL;
  xmlXPathEval: function(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL;
  xmlXPathEvalExpression: function(str: xmlCharPtr; ctx: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL;
  xmlXPathEvalPredicate: function(ctxt: xmlXPathContextPtr; res: xmlXPathObjectPtr): cint; EXTDECL;

(**
 * Separate compilation/evaluation entry points.
 *)
  xmlXPathCompile: function(str: xmlCharPtr): xmlXPathCompExprPtr; EXTDECL;
  xmlXPathCtxtCompile: function(ctxt: xmlXPathContextPtr; str: xmlCharPtr): xmlXPathCompExprPtr; EXTDECL;
  xmlXPathCompiledEval: function(comp: xmlXPathCompExprPtr; ctxt: xmlXPathContextPtr): xmlXPathObjectPtr; EXTDECL;
  xmlXPathCompiledEvalToBoolean: function(comp: xmlXPathCompExprPtr; ctxt: xmlXPathContextPtr): cint; EXTDECL;
  xmlXPathFreeCompExpr: procedure(comp: xmlXPathCompExprPtr); EXTDECL;
{$ENDIF}

{$IFDEF EXTVAR}
(**
 * Objects and Nodesets handling
 *)

{$IFNDEF NO_EXTERNAL_VARS}
var
  xmlXPathNAN: cdouble; cvar; external;
  xmlXPathPINF: cdouble; cvar; external;
  xmlXPathNINF: cdouble; cvar; external;
{$ENDIF}

{$ENDIF}

{$IFDEF MACRO}
(* These macros may later turn into functions *)
(**
 * xmlXPathNodeSetGetLength:
 * @ns:  a node-set
 *
 * Implement a functionality similar to the DOM NodeList.length.
 *
 * Returns the number of nodes in the node-set.
 *)
function xmlXPathNodeSetGetLength(ns: xmlNodeSetPtr): cint;

(**
 * xmlXPathNodeSetItem:
 * @ns:  a node-set
 * @index:  index of a node in the set
 *
 * Implements a functionality similar to the DOM NodeList.item().
 *
 * Returns the xmlNodePtr at the given @index in @ns or NULL if
 *         @index is out of range (0 to length-1)
 *)
function xmlXPathNodeSetItem(ns: xmlNodeSetPtr; index: cint): xmlNodePtr;

(**
 * xmlXPathNodeSetIsEmpty:
 * @ns: a node-set
 *
 * Checks whether @ns is empty or not.
 *
 * Returns %TRUE if @ns is an empty node-set.
 *)
function xmlXPathNodeSetIsEmpty(ns: xmlNodeSetPtr): boolean;
{$ENDIF}

{$ENDIF} (* LIBXML_XPATH_ENABLED *)

{$if defined(LIBXML_XPATH_ENABLED) or defined(LIBXML_SCHEMAS_ENABLED)}
{$IFDEF FUNCTIONVAR}
  xmlXPathInit: procedure; EXTDECL;
  xmlXPathIsNaN: function(val: cdouble): cint; EXTDECL;
  xmlXPathIsInf: function(val: cdouble): cint; EXTDECL;
{$ENDIF}
{$ENDIF} (* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED*)