sasa_c_f90.c

Go to the documentation of this file.

/* ---------------------------------------------------- */
/* Copyright 2006-2010, CERFACS, Toulouse, France. */
/* Copyright 2006-2010, Centre National de la Recherche Scientifique, Paris, France. */
/* All rights reserved. Use is subject to OASIS4 license terms. */
/* ---------------------------------------------------- */
/*
   file sasa_c_f90.c
   C source file for sasa
*/


#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include "sasa_c_f90.h"
#include "sasa_c_xml.h"

/*
 
  !DESCRIPTION:
 
   This files gathers the c routines called by the fortran that extract the 
   xml informations. 
   The extraction is done using the 'xpath' technics. 
   3 types of extractions are given: 
   - the extraction of the number of elements,
   - the extraction of the attributes,
   - the extraction of the elements (could be char, int or double).
   A convertion routine is also given to convert char to parameter integers.

         <stdio.h>
         <string.h>
         <stdlib.h>
         "sasa_c_f90.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
   ??.??.??   P. Bourcier  Creation of sasa_c_read_file and sasa_c_close
   30.01.04   D. Declat    Creation of all the generic routines that extract
                             the attributes, the numbers and the elements
   14.01.08   I.Henderson  Replaced generic routines that extract the
                           attributes, elements and number of elements with
                           modified versions that can process an arbitrary
                           (rather than fixed) number of XPath nodes and 
                           support >99 elements (e.g. 100 transients).
                           New functions are: sasa_c_get_number,
                           sasa_c_get_attribute, sasa_c_get_element_c,
                           sasa_c_get_element_i, sasa_c_get_element_d,
                           sasa_c_build_xpath_str.
   22.03.10   JM Epitalon  Simultaneous access to multiple documents :
                           sasa_c_read_file() returns a pointer to doc tree

    Not yet implemented :  Assume that all XML elements refer to a default namespace:
                           add prefix "default:" to every XML elements 
                           when building XPaths
 
//EOP

 ----------------------------------------------------------------------
  $Id: sasa_c_f90.c 3246 2011-06-23 12:43:21Z coquart $
  $Author: coquart $
 ---------------------------------------------------------------------- */


/* Size of buffer for xpath strings */
#define XPATH_STR_LEN_MAX (1023)

#define PSMILE_UNDEF (-280177)

/* Whether an XPath starts with "/", "//" or a nodename */
typedef enum
{
    XPATH_START_INVALID = -1,

    XPATH_START_FIRST,
  XPATH_START_CHILD_OF_ROOT_NODE = XPATH_START_FIRST,
  XPATH_START_DESCENDANT_OF_ROOT_NODE,
  XPATH_START_CHILD_OF_CURRENT_NODE,
    XPATH_START_LAST = XPATH_START_CHILD_OF_CURRENT_NODE,

    XPATH_START_COUNT

} XPathStartType;


/* XML node types (elements, attributes...) */
typedef enum
{
    XPATH_NODE_TYPE_INVALID = -1,

    XPATH_NODE_TYPE_FIRST,
  XPATH_NODE_TYPE_ELEMENT = XPATH_NODE_TYPE_FIRST,
  XPATH_NODE_TYPE_ATTRIBUTE,
    XPATH_NODE_TYPE_LAST = XPATH_NODE_TYPE_ATTRIBUTE,

    XPATH_NODE_TYPE_COUNT

} XPathNodeType;


/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */


static int sasa_c_get_number(      int *, int, size_t, ... );
static int sasa_c_get_attribute(   char *, int *, int, size_t, ... );
static int sasa_c_get_element_c(   char *, int *, int, size_t, ... );
static int sasa_c_get_element_i(   int *, int, size_t, ... );
static int sasa_c_get_element_d(   double *, int, size_t, ... );
static int sasa_c_build_xpath_str( char *, XPathStartType, XPathNodeType,
                                   size_t, va_list );


/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */

int
__sasa_c_convert_char2int  (char *charcode, int len_charcode)
{
    struct pair
    {
        char *keyword;
        int code;
    };
    struct pair *p_pair;
    int nb_pairs;
    int result;

    size_t len = len_charcode;

#ifdef DEBUG
    (void)printf("sasa_c_convert_char2int : charcode: %s\n", charcode);
    (void)printf("sasa_c_convert_char2int : len_charcode: %d\n", len);
#endif

    result = -280177;

/*************************************************************************

   List of keywords (in XML element attributes) and their corresponding value in OASIS4
   ====================================================================================
     
    first    = 1;
    second   = 2;
    third    = 3;
    fourth   = 4;

    not_spawn = 1;
    spawn     = 2;

    false    = 0;
    true     = 1;

    meters   = 3000;
    bar      = 3001;
    millibar = 3002;
    decibar  = 3003;
    atmosphere  = 3004;
    pascal   = 3005;
    hPa      = 3006;
    unitless = 3007;

    degrees_east    = 3008;
    degrees_north   = 3009;

    single   = 3500;
    vector   = 3501;
    bundle   = 3502;

    mean     = 3530;
    max      = 3531;
    min      = 3532;
    median   = 3533;
    variance = 3534;
    integral = 3535;
    average  = 3536;
    wgt_ave  = 3537;
    subgrid_ave = 3538;

    file     = 3810;
    component_name   = 3800;

    mpp_ascii   = 3821;
    mpp_ieee32  = 3822;
    mpp_native  = 3823;
    mpp_netcdf  = 3824;

    taverage   = 3600;
    accumul    = 3601;
    tmin       = 3602;
    tmax       = 3603;

    up     = 1;
    down   = 2;

    PRISM_reglonlatvrt     = 0;
    PRISM_irrlonlat_regvrt = 1;
    PRISM_irrlonlatvrt     = 2;
    PRISM_irrlonlat_sigmavrt = 3;
    PRISM_reglonlat_sigmavrt = 4;
    PRISM_unstructlonlat_regvrt = 5;
    PRISM_unstructlonlat_sigmavrt = 6;
    PRISM_unstructlonlatvrt     = 7;
    PRISM_gridless              = 8;
    PRISM_gaussreduced_regvrt   = 9;
    PRISM_gaussreduced_sigmavrt = 10;

    xs:real    = 4;
    xs:double  = 5;
    xs:string  = 1;
    xs:integer = 2;
    xs:nonPositiveInteger = 2;
    xs:negativeInteger    = 2;
    xs:positiveInteger    = 2;

    smooth   = 3685;
    raw      = 3686;

    sinus    = 3680;
    cosinus  = 3681;
    log      = 3682;

    time_nneighbour = 3604;
    time_linear     = 3605;

    conserv_global    = 3675;

    global    = 3711;
    local     = 3710;

    iosingle    = 3825;
    parallel    = 3826;
    distributed = 3827;

    latitude  = 3648;
    latlon    = 3647;

    approximate  = 3657;
    precise      = 3658;

    novalue    = 3643;
    tneighbour = 3644;
    nneighbour = 3645;
    vneighbour = 3646;


    gradient   = 3660;
    sixteen    = -280177;
    fracarea   = 3665;
    destarea   = 3666;
    none       = -1;
    " "        = -280177;

    on     = 1;
    off    = 0;

*****************************************************************************/

    /* Sort keywords by length */
    /* ----------------------- */
    
    switch (len)
    {
    case 2:
    {
        static struct pair tab2[] = { {"up", 1}, {"on", 1} };
        p_pair = tab2;
        nb_pairs = 2;
        break;
    }   
    case 3:
    {
        static struct pair tab3[] = {
            {"bar", 3001}, {"hPa", 3006}, {"max", 3531}, {"min", 3532}, {"raw", 3686}, {"log", 3682}, {"off", 0}
        };
        p_pair = tab3;
        nb_pairs = 7;
        break;
    }   
    case 4:
    {
        static struct pair tab4[] = {
            {"true", 1}, {"mean", 3530}, {"file", 3810}, {"tmin", 3602}, {"tmax", 3603}, {"down", 2}, {"none", -1},
        };
        p_pair = tab4;
        nb_pairs = 7;
        break;
    }   
        break;
    case 5:
    {
        static struct pair tab5[] = {
            {"first", 1}, {"third", 3}, {"spawn", 2}, {"false", 0}, {"sinus", 3680}, {"local", 3710},
        };

        p_pair = tab5;
        nb_pairs = 6;
        break;
    }   
    case 6:
    {
        static struct pair tab6[] = {
            {"second", 2}, {"fourth", 4}, {"meters", 3000}, {"pascal", 3005}, {"single", 3500}, {"vector", 3501},
            {"bundle", 3502}, {"median", 3533}, {"smooth", 3685}, {"global", 3711}, {"latlon", 3647},
        };
        p_pair = tab6;
        nb_pairs = 11;
        break;
    }   
    case 7:
    {
        static struct pair tab7[] = {
            {"decibar", 3003}, {"average", 3536}, {"wgt_ave", 3537}, {"accumul", 3601}, {"xs:real", 4}, {"cosinus", 3681}, 
            {"precise", 3658}, {"novalue", 3643}, {"sixteen", -280177},
        };
        p_pair = tab7;
        nb_pairs = 9;
        break;
    }   
    case 8:
    {
        static struct pair tab8[] = {
            {"millibar", 3002}, {"unitless", 3007}, {"variance", 3534}, {"integral", 3535}, {"taverage", 3600}, {"iosingle", 3825},
            {"parallel", 3826}, {"latitude", 3648}, {"gradient", 3660}, {"fracarea", 3665}, {"destarea", 3666},
        };
        p_pair = tab8;
        nb_pairs = 11;
        break;
    }   
    case 9:
    {
        static struct pair tab9[] = {
            {"not_spawn", 1}, {"mpp_ascii", 3821}, {"xs:double", 5}, {"xs:string", 1},
        };
        p_pair = tab9;
        nb_pairs = 4;
        break;
    }   
    case 10:
    {
        static struct pair tab10[] = {
            {"atmosphere", 3004}, {"mpp_ieee32", 3822}, {"mpp_native", 3823}, {"mpp_netcdf", 3824}, {"xs:integer", 2},
            {"tneighbour", 3644}, {"nneighbour", 3645}, {"vneighbour", 3646},
        };
        p_pair = tab10;
        nb_pairs = 8;
        break;
    }   
    case 11:
    {
        static struct pair tab11[] = {
            {"subgrid_ave", 3538}, {"time_linear", 3605}, {"distributed", 3827}, {"approximate", 3657},
        };
        p_pair = tab11;
        nb_pairs = 4;
        break;
    }   
    case 12:
        /* One single choice : {"degrees_east", 3008}, */
        result = 3008;
        nb_pairs = 0;
        break;
    case 13:
        /* One single choice : {"degrees_north", 3009}, */
        result = 3009;
        nb_pairs = 0;
        break;
    case 14:
    {
        static struct pair tab14[] = {
            {"component_name", 3800}, {"PRISM_gridless", 8}, {"conserv_global", 3675},
        };
        p_pair = tab14;
        nb_pairs = 3;
        break;
    }   
    case 15:
        /* One single choice : {"time_nneighbour", 3604}, */
        result = 3004;
        nb_pairs = 0;
        break;
    case 16:
    {
        static struct pair tab16[] = {
            {"PRISM_reglonlatvrt", 0}, {"PRISM_irrlonlatvrt", 2}, {"xs:negativeInteger", 2}, {"xs:positiveInteger", 2},
        };
        p_pair = tab16;
        nb_pairs = 4;
        break;
    }   
    case 17:
        /* One single choice : {"xs:nonPositiveInteger", 2}, */
        result = 2;
        nb_pairs = 0;
        break;
    case 18:
        /* One single choice : {"PRISM_irrlonlat_regvrt", 1}, */
        result = 1;
        nb_pairs = 0;
        break;
    case 19:
        /* One single choice : {"PRISM_unstructlonlatvrt", 7}, */
        result = 7;
        nb_pairs = 0;
        break;
    case 20:
    {
        static struct pair tab20[] = {
            {"PRISM_irrlonlat_sigmavrt", 3}, {"PRISM_reglonlat_sigmavrt", 4},
        };
        p_pair = tab20;
        nb_pairs = 2;
        break;
    }   
    case 21:
        /* One single choice : {"PRISM_gaussreduced_regvrt", 9}, */
        result = 9;
        nb_pairs = 0;
        break;
    case 22:
    {
        static struct pair tab22[] = {
            {"PRISM_unstructlonlat_regvrt", 5}, {"PRISM_gaussreduced_sigmavrt", 10},
        };
        p_pair = tab22;
        nb_pairs = 2;
        break;
    }   
    case 23:
        /* One single choice : {"PRISM_unstructlonlat_sigmavrt", 6}, */
        result = 6;
        nb_pairs = 0;
        break;
    
    default:
        /* no match */
        result = -280177;
        nb_pairs = 0;
        break;
    
    } /* end switch (len) */

   /* Compare keywords with given character string */

    /* For all keywords of length 'len' */
    while (nb_pairs -- > 0 && result == -280177)
    {
        /* if keyword matches */
        if (strncmp(charcode, p_pair->keyword, len) == 0)
            result = p_pair->code;
        else
            /* test next keyword */
            p_pair += 1;
    }

    /* if not empty string */
    if (! (charcode[0] == ' '))
    {
        /* if no match */
        if (result == -280177)
        {
            printf("\n");
            printf("sasa_c_convert_char2int : There is no corresponding parameter to char %s\n",charcode);
        }
    }

#ifdef DEBUG
    (void)printf("sasa_c_convert_char2int : result code : %d\n",result);
    (void)printf("--------------------------------------------------\n");
#endif

    return (result);
}

/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */

/*

//BOP

  !ROUTINE: sasa_c_read_file

  !DESCRIPTION:

   Open an XML file and load its content (the XML tree) into memory.
   Return a handle to the XML content, that must be susequently 
   passed as a parameter to querying functions.

  !INPUT PARAMETERS:
  
   xml_file_name = Pointer to Fortran string containing the file name

   len_file_name = length of file name
   
   len_declared  = length of Fortran string containing the file name
                   (unused)
   
  !OUTPUT PARAMETERS:

   returned    = handle to XML document tree of open file (positive integer)

  !FILES USED:

         <stdlib.h>
         <stdio.h>
         "sasa_c_f90.h"
         "sasa_c_xml.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
  ??.??.??    P. Bourcier  Creation
  22.03.10    JM Epitalon  Simultaneous access to multiple documents

//EOP

 ----------------------------------------------------------------------
  $Id
  $Author
 ----------------------------------------------------------------------
*/
int sasa_c_read_file  (char *xml_file_name,
               int  *len_file_name,
               int len_declared)
{
  int doc;
/*   Variant : int doc=EXIT_SUCCESS;  */

  char *file_name;

  file_name = (char *) calloc(*len_file_name+1, sizeof(char));
  strncpy(file_name,xml_file_name,*len_file_name);
  file_name[*len_file_name] = 0;

#ifdef DEBUG
  (void)printf("sasa_c_read_file : open file : %s\n", file_name);
#endif

  doc = sasaOpenXml ((const char*)file_name);

  free(file_name);

  return(doc);

}


/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */


/*

//BOP

  !ROUTINE: sasa_c_get_number

  !INTERFACE:

  !INPUT PARAMETERS:
  
   num_doc     = Handle to document tree as returned by sasa_c_read_file()

   nodes_count = Number of nodes in the given XPath *including* the element
                 that we're looking for.

   ...         = The XPath, expressed as a variable length list of triplets
                 describing each node in the path.  The triplets take the form: 

                   char *nodeName, int nodeNameLen, int nodeNum

                   E.g. the arguments:   "prismcomponent", 14, 0,
                                         "transient", 9, 5,
                                         "intent", 6, 0

                   represent the XPath:  prismcomponent/transient[5]/intent
   
  !OUTPUT PARAMETERS:

   xml_number  = Number of instances of the element referenced by the given
                 XPath.

   rc          = Return code
               = EXIT_SUCCESS (0) : No error
               = EXIT_FAILURE (1) : Error building XPath

  !DESCRIPTION:

   Get the number of instances of the XML element specified by the given XPath 
   in the given open XML document (e.g. SMIOC, SCC, ...).

  !FILES USED:

         <stdarg.h>
         <stdlib.h>
         <stdio.h>
         "sasa_c_f90.h"
         "sasa_c_xml.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
  14.01.08    I.Henderson  created
  22.03.10    JM Epitalon  Simultaneous access to multiple documents

//EOP

 ----------------------------------------------------------------------
  $Id
  $Author
 ----------------------------------------------------------------------
*/
static int sasa_c_get_number( int    *xml_number,
                              int    num_doc,
                              size_t nodes_count,
                              ... )
{
  va_list nodes;
  int     rc=EXIT_SUCCESS;  /* return code */
  char    xpath_str[ XPATH_STR_LEN_MAX + 1 ];
  int     xpath_str_len;
  int     number;
 
  ASSERT( xml_number != NULL );
  ASSERT( nodes_count > 0 );

  va_start( nodes, nodes_count );

  /* Build the xpath string (-1 to get number of parent nodes) */
  xpath_str_len = sasa_c_build_xpath_str(  
    xpath_str,
    XPATH_START_CHILD_OF_CURRENT_NODE,
    XPATH_NODE_TYPE_ELEMENT,
    nodes_count - 1,
    nodes );

  va_end( nodes );

  if ( xpath_str_len > 0 )
  {
#ifdef DEBUG
    printf("sasa_c_get_number (level %d) : xpath input : %s\n",
      nodes_count, xpath_str);
    fflush(stdout);
#endif
    /* get the number with xpath input */
    rc=getXmlNodeCount (num_doc, xpath_str, &number);
    /* if returned value is EXIT_FOUND or EXIT_NOTFOUND */
    if (rc != EXIT_FAILURE)
       rc = EXIT_SUCCESS;

    *xml_number=number;

#ifdef DEBUG
    printf("sasa_c_get_number (level %d) : number : %d\n",
      nodes_count, *xml_number);
    puts("--------------------------------------------------------");
#endif
  }
  else
  {
    rc = EXIT_FAILURE;

#ifdef DEBUG
    printf("sasa_c_get_number (level %d) : ERROR : building xpath string\n",
      nodes_count );
    printf("sasa_c_get_number (level %d) : return code %d\n",
      nodes_count, xpath_str_len );
    puts("--------------------------------------------------------");
#endif
  }

  return (rc);

} /* sasa_c_get_number */  


/*

//BOP

  !ROUTINE: sasa_c_get_attribute

  !INTERFACE:

  !INPUT PARAMETERS:

   num_doc     = Handle to document tree as returned by sasa_c_read_file()

   parent_nodes_count = Number of nodes in the given XPath *excluding* the
                        attribute that we're looking for.

   ...         = The XPath, expressed as a variable length list of triplets
                 describing each node in the path.  The triplets take the form: 

                 char *nodeName, int nodeNameLen, int nodeNum

                 E.g. the arguments:   "prismcomponent", 14, 0,
                                       "transient", 9, 5,
                                       "local_name", 10, (0)

                 represent the XPath:  //prismcomponent/transient[5]/@local_name

                 Note that the '0' at the end of the "local_name" triplet is
                 ignored and can therefore be omitted: XML attributes can't
                 have multiple instances.
   
  !OUTPUT PARAMETERS:

   xml_attribute = The value of the attribute referenced by the XPath,
                   expressed as a string.

   xml_attribute_length = The length of the xml_attribute string.

   rc          = Return code
               = EXIT_SUCCESS (0) : No error
               = EXIT_FAILURE (1) : Error building XPath

  !DESCRIPTION:

   Get the value of the XML attribute specified by the given XPath 
   in the given open XML document (e.g. SMIOC, SCC, ...).

  !FILES USED:

         <stdarg.h>
         <stdlib.h>
         <string.h>
         <stdio.h>
         "sasa_c_f90.h"
         "sasa_c_xml.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
  14.01.08    I.Henderson  created
  22.03.10    JM Epitalon  Simultaneous access to multiple documents

//EOP

 ----------------------------------------------------------------------
  $Id
  $Author
 ----------------------------------------------------------------------
*/
static int sasa_c_get_attribute( char    *xml_attribute,
                                 int     *xml_attribute_length,
                                 int     num_doc,
                                 size_t  parent_nodes_count,
                                 ... )
{
  va_list nodes;
  int     rc=EXIT_SUCCESS;  /* return code */
  char    xpath_str[ XPATH_STR_LEN_MAX + 1 ];
  int     xpath_str_len;
  char    *att=NULL;

  ASSERT( xml_attribute != NULL );
  ASSERT( xml_attribute_length != NULL );
  ASSERT( parent_nodes_count >= 0 );
  
  va_start( nodes, parent_nodes_count );

  /* Build the xpath string */
  xpath_str_len = sasa_c_build_xpath_str(  
    xpath_str,
    XPATH_START_DESCENDANT_OF_ROOT_NODE,
    XPATH_NODE_TYPE_ATTRIBUTE,
    parent_nodes_count,
    nodes );

  va_end( nodes );


#ifdef DEBUG
    printf("sasa_c_get_attribute (level %d) : xpath input : %s\n",
      parent_nodes_count, xpath_str); 
#endif

  if ( xpath_str_len > 0 )
  {
    /* get the attribute with xpath input */
    rc = getXmlInfo(num_doc, xpath_str, &att);
    if (rc == EXIT_FOUND)
      {
        (void)strcpy (xml_attribute, (const char*)att );
        /* since the string passed to Fortran is blank-terminated,
          the Fortran procedure can use the trim_len */
        *xml_attribute_length = strlen(xml_attribute);
        xml_attribute[strlen (xml_attribute)]=' '; /* the '\0' */
        rc = EXIT_SUCCESS;

#ifdef DEBUG
    printf("sasa_c_get_attribute (level %d) : xml_attribute : %s\n",
      parent_nodes_count, att);
#endif
      }
    else if (rc == EXIT_NOTFOUND)
      {
        int i;
        for(i=0;i < 256; i++) *(xml_attribute+i)=' ';
        *xml_attribute_length = 0;
        rc = EXIT_SUCCESS;
#ifdef DEBUG
    printf("sasa_c_get_attribute (level %d) : not found\n",
      parent_nodes_count);
#endif
      }
    if (att != NULL) free ((void*)att); 
  }
  else
  {
    rc = EXIT_FAILURE;

#ifdef DEBUG
    printf("sasa_c_get_attribute (level %d) : ERROR : building xpath string\n",
      parent_nodes_count );
    printf("sasa_c_get_attribute (level %d) : return code %d\n",
      parent_nodes_count, xpath_str_len );
#endif
  }

#ifdef DEBUG
  puts("--------------------------------------------------------");
#endif

  return (rc);

} /* sasa_c_get_attribute */  


/*

//BOP

  !ROUTINE: sasa_c_get_element_c

  !INTERFACE:

  !INPUT PARAMETERS:

   num_doc         = Handle to document tree as returned by sasa_c_read_file()

   parent_nodes_count = Number of nodes in the given XPath *excluding* the
                        element that we're looking for.
                      = or if equal -1, XPath is given litteraly, as a Fortran character tring

   ...         = The XPath
                 
                 - if parent_nodes_count >= 0, the XPath is expressed as a variable length list
                   of triplets describing each node in the path.  The triplets take the form: 

                   char *nodeName, int nodeNameLen, int nodeNum

                   E.g. the arguments:   "prismcomponent", 14, 0,
                                         "transient", 9, 5,
                                         "transient_standard_name", 23, 0
                      represent the XPath: 
                      //prismcomponent/transient[5]/transient_standard_name
                      
                 - if parent_nodes_count == -1, the XPath is expressed as a Fortran character tring
   
  !OUTPUT PARAMETERS:

   xml_element = The value of the element referenced by the XPath,
                 expressed as a character string.

   xml_element_length = The length of the xml_element string.

   rc          = Return code
               = EXIT_SUCCESS (0) : No error
               = EXIT_FAILURE (1) : Error building XPath

  !DESCRIPTION:

   Get the string value of the XML element specified by the given XPath 
   in the given open XML document (e.g. SMIOC, SCC, ...).
   Note: sasa_c_get_element_c - c = character string.
   
   XPath is specified in either of two ways :
     - the list of nodes of the XPath
     - the character string of the XPath

  !FILES USED:

         <stdarg.h>
         <stdlib.h>
         <string.h>
         <stdio.h>
         "sasa_c_f90.h"
         "sasa_c_xml.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
  14.01.08    I.Henderson  created
  22.03.10    JM Epitalon  Simultaneous access to multiple documents
  30.07.10    JM Epitalon  Add second interface where XPath is given litteraly
//EOP

 ----------------------------------------------------------------------
  $Id
  $Author
 ----------------------------------------------------------------------
*/
static int sasa_c_get_element_c( char   *xml_element,
                                 int    *xml_element_length,
                                 int    num_doc,
                                 size_t parent_nodes_count,
                                 ... )
{
  va_list nodes;
  int     rc=EXIT_SUCCESS;  /* return code */
  char    xpath_str[ XPATH_STR_LEN_MAX + 1 ];
  int     xpath_str_len;
  char    *elt=NULL;

  ASSERT( xml_element != NULL );
  ASSERT( xml_element_length != NULL );

  va_start( nodes, parent_nodes_count );

  if (parent_nodes_count == (size_t)(-1))
  {
    /* xpath string is given */
    const char *given_xpath = va_arg( nodes, char * ); 
    int given_xpath_len = va_arg( nodes, int ); 
    
    xpath_str_len = (XPATH_STR_LEN_MAX < given_xpath_len) ? XPATH_STR_LEN_MAX : given_xpath_len ;
    strncpy (xpath_str, given_xpath, xpath_str_len);
    xpath_str[xpath_str_len] = 0;
  }
  else
  {
    /* Build the xpath string */
    xpath_str_len = sasa_c_build_xpath_str(
        xpath_str,
        XPATH_START_DESCENDANT_OF_ROOT_NODE,
        XPATH_NODE_TYPE_ELEMENT,
        parent_nodes_count,
        nodes );
  }

  va_end( nodes );

  if ( xpath_str_len > 0 )
  {
#ifdef DEBUG
    printf("sasa_c_get_element_c (level %d) : xpath input : %s\n",
      parent_nodes_count, xpath_str);
#endif
    /* get the string with xpath input */
    rc=getXmlInfo (num_doc, xpath_str, &elt);
    if (rc == EXIT_FOUND)
      {
        int length = 0;
        
        if (elt != NULL)
        {
          /* copy all characters except non-printing ones */
          char *target = xml_element;
          char *source; 
          for (source = elt; *source != 0; source += 1)
          {
            /* Filter out non-printing characters (like new-line) */
            if (*source >= 0x20 && *source < 0x7F)
            {
                *target++ = *source;
                length += 1;
            }
          }
        }
        else
        {
          length = 0;
        }
#ifdef DEBUG
        xml_element[length] = 0;
        printf("sasa_c_get_element_c (level %d) : xml_element : %s\n",
           parent_nodes_count, xml_element);
#endif
        *xml_element_length = length;
        xml_element[length]=' '; /* the '\0' */
        rc = EXIT_SUCCESS;
      }
    else if (rc == EXIT_NOTFOUND)
      {
#ifdef DEBUG
        printf("sasa_c_get_element_c (level %d) : element NOT found\n",
           parent_nodes_count);
#endif
        xml_element[0] = ' ';
        *xml_element_length = 0;
        rc = EXIT_SUCCESS;
      }
    if (elt != NULL) free ((void*)elt); 
#ifdef DEBUG
    puts("--------------------------------------------------------");
#endif

  }
  else
  {
    rc = EXIT_FAILURE;

#ifdef DEBUG
    printf("sasa_c_get_element_c (level %d) : ERROR : building xpath string\n",
      parent_nodes_count );
    printf("sasa_c_get_element_c (level %d) : return code %d\n",
      parent_nodes_count, xpath_str_len );
    puts("--------------------------------------------------------");
#endif
  }

  return (rc);

} /* sasa_c_get_element_c */  


/*

//BOP

  !ROUTINE: sasa_c_get_element_i

  !INTERFACE:

  !INPUT PARAMETERS:

   num_doc         = Handle to document tree as returned by sasa_c_read_file()

   parent_nodes_count = Number of nodes in the given XPath *excluding* the
                        element that we're looking for.

   parent_nodes_count = Number of nodes in the given XPath *excluding* the
                        element that we're looking for.
                      = or if equal -1, XPath is given litteraly, as a Fortran character tring

   ...         = The XPath
                 
                 - if parent_nodes_count >= 0, the XPath is expressed as a variable length list
                   of triplets describing each node in the path.  The triplets take the form: 

                   char *nodeName, int nodeNameLen, int nodeNum

                   E.g. the arguments:   "prismcomponent", 14, 0,
                                         "transient", 9, 5,
                                         "transient_standard_name", 23, 0
                      represent the XPath: 
                      //prismcomponent/transient[5]/transient_standard_name
                      
                 - if parent_nodes_count == -1, the XPath is expressed as a Fortran character tring
   
  !OUTPUT PARAMETERS:

   xml_element = The value of the element referenced by the XPath,
                 expressed as an integer.

   rc          = Return code
               = EXIT_SUCCESS (0) : No error
               = EXIT_FAILURE (1) : Error building XPath

  !DESCRIPTION:

   Get the integer value of the XML element specified by the given XPath 
   in the given open XML document (e.g. SMIOC, SCC, ...).
   Note: sasa_c_get_element_i - i = integer.

   XPath is specified in either of two ways :
     - the list of nodes of the XPath
     - the character string of the XPath
  
  !FILES USED:

         <stdarg.h>
         <stdlib.h>
         <stdio.h>
         "sasa_c_f90.h"
         "sasa_c_xml.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
  14.01.08    I.Henderson  created
  22.03.10    JM Epitalon  Simultaneous access to multiple documents
  30.07.10    JM Epitalon  Add second interface where XPath is given litteraly

//EOP

 ----------------------------------------------------------------------
  $Id
  $Author
 ----------------------------------------------------------------------
*/
static int sasa_c_get_element_i( int    *xml_element,
                                 int    num_doc,
                                 size_t parent_nodes_count,
                                 ... )
{
  va_list nodes;
  int     rc=EXIT_SUCCESS;  /* return code */
  char    xpath_str[ XPATH_STR_LEN_MAX + 1 ];
  int     xpath_str_len;
  char    *elt=NULL;
  
  ASSERT( xml_element != NULL );

  va_start( nodes, parent_nodes_count );

  if (parent_nodes_count == (size_t)(-1))
  {
    /* xpath string is given */
    const char *given_xpath = va_arg( nodes, char * ); 
    int given_xpath_len = va_arg( nodes, int ); 
    
    xpath_str_len = (XPATH_STR_LEN_MAX < given_xpath_len) ? XPATH_STR_LEN_MAX : given_xpath_len ;
    strncpy (xpath_str, given_xpath, xpath_str_len);
    xpath_str[xpath_str_len] = 0;
  }
  else
  {
    /* Build the xpath string */
    xpath_str_len = sasa_c_build_xpath_str(
        xpath_str,
        XPATH_START_DESCENDANT_OF_ROOT_NODE,
        XPATH_NODE_TYPE_ELEMENT,
        parent_nodes_count,
        nodes );
  }

  va_end( nodes );

  if ( xpath_str_len > 0 )
  {
    /* get the integer with xpath input */
    rc=getXmlInfo (num_doc, xpath_str, &elt);
    if (rc == EXIT_FOUND) 
      {
        *xml_element = atoi(elt);
        rc = EXIT_SUCCESS;
      }
    else if (rc == EXIT_NOTFOUND)
      {
        *xml_element = PSMILE_UNDEF;
        rc = EXIT_SUCCESS;
      }    
    free ((void*)elt); 

#ifdef DEBUG
    printf("sasa_c_get_element_i (level %d) : xpath input : %s\n",
      parent_nodes_count, xpath_str);
    printf("sasa_c_get_element_i (level %d) : xml_element : %d\n",
      parent_nodes_count, *xml_element);
    puts("--------------------------------------------------------");
#endif
  }
  else
  {
    rc = EXIT_FAILURE;

#ifdef DEBUG
    printf("sasa_c_get_element_i (level %d) : ERROR : building xpath string\n",
      parent_nodes_count );
    printf("sasa_c_get_element_i (level %d) : return code %d\n",
      parent_nodes_count, xpath_str_len );
    puts("--------------------------------------------------------");
#endif
  }

  return (rc);

} /* sasa_c_get_element_i */  


/*

//BOP

  !ROUTINE: sasa_c_get_element_d

  !INTERFACE:

  !INPUT PARAMETERS:

   num_doc         = Handle to document tree as returned by sasa_c_read_file()

   parent_nodes_count = Number of nodes in the given XPath *excluding* the
                        element that we're looking for.

   ...         = The XPath, expressed as a variable length list of triplets
                 describing each node in the path.  The triplets take the form: 

                 char *nodeName, int nodeNameLen, int nodeNum

                 E.g. the arguments:   "prismcomponent", 14, 0,
                                       "transient", 9, 5
                                       "physics", 7, 0,
                                       "valid_min", 9, 0
                 represent the XPath: 

                   //prismcomponent/transient[5]/physics/valid_min
   
  !OUTPUT PARAMETERS:

   xml_element = The value of the element referenced by the XPath,
                 expressed as a double.

   rc          = Return code
               = EXIT_SUCCESS (0) : No error
               = EXIT_FAILURE (1) : Error building XPath

  !DESCRIPTION:

   Get the double value of the XML element specified by the given XPath 
   in the given open XML document (e.g. SMIOC, SCC, ...).
   Note: sasa_c_get_element_d - d = double.

  !FILES USED:

         <stdarg.h>
         <stdlib.h>
         <stdio.h>
         "sasa_c_f90.h"
         "sasa_c_xml.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
  14.01.08    I.Henderson  created
  22.03.10    JM Epitalon  Simultaneous access to multiple documents

//EOP

 ----------------------------------------------------------------------
  $Id
  $Author
 ----------------------------------------------------------------------
*/
static int sasa_c_get_element_d( double *xml_element,
                                 int    num_doc,
                                 size_t parent_nodes_count,
                                 ... )
{
  va_list nodes;
  int     rc=EXIT_SUCCESS;  /* return code */
  char    xpath_str[ XPATH_STR_LEN_MAX + 1 ];
  int     xpath_str_len;
  char    *elt=NULL;

  ASSERT( xml_element != NULL );
  ASSERT( parent_nodes_count >= 0 );

  va_start( nodes, parent_nodes_count );

  /* Build the xpath string */
  xpath_str_len = sasa_c_build_xpath_str(  
    xpath_str,
    XPATH_START_DESCENDANT_OF_ROOT_NODE,
    XPATH_NODE_TYPE_ELEMENT,
    parent_nodes_count,
    nodes );

  va_end( nodes );

  if ( xpath_str_len > 0 )
  {
    /* get the double with xpath input */
    rc=getXmlInfo (num_doc, xpath_str, &elt);
    if (rc == EXIT_FOUND) 
      {
        sscanf(elt,"%lf",xml_element);
        rc = EXIT_SUCCESS;
      }
    else if (rc == EXIT_NOTFOUND)
      {
        *xml_element = PSMILE_UNDEF;
        rc = EXIT_SUCCESS;
      }    
    free ((void*)elt); 

#ifdef DEBUG
    printf("sasa_c_get_element_d (level %d) : xpath input : %s\n",
      parent_nodes_count, xpath_str);
    printf("sasa_c_get_element_d (level %d) : xml_element : %lf\n",
      parent_nodes_count, *xml_element);
    puts("--------------------------------------------------------");
#endif
  }
  else
  {
    rc = EXIT_FAILURE;

#ifdef DEBUG
    printf("sasa_c_get_element_d (level %d) : ERROR : building xpath string\n",
      parent_nodes_count );
    printf("sasa_c_get_element_d (level %d) : return code %d\n",
      parent_nodes_count, xpath_str_len );
    puts("--------------------------------------------------------");
#endif
  }

  return (rc);

} /* sasa_c_get_element_d */  


/*

//BOP

  !ROUTINE: sasa_c_build_xpath_str

  !INTERFACE:

  !INPUT PARAMETERS:

   xpath_start_type = A constant indicating how the XPath string should start
                      e.g. "//" - see XPathStartType enum for options.

   xpath_target_node_type = A constant indicating the type of the "target" node
                            referenced by the XPath (i.e. whether it's an
                            attribute or element).

   parent_nodes_count = Number of nodes in the given XPath *excluding* the
                        node (attribute or element) that we're looking for.

   xpath_nodes = The XPath, expressed as a variable length list of triplets
                 describing each node in the path.  The triplets take the form: 

                 char *nodeName, int nodeNameLen, int nodeNum

                 E.g. the arguments:   "prismcomponent", 14, 0,
                                       "transient", 9, 5
                                       "intent", 6, 0

                 represent the XPath: //prismcomponent/transient[5]/intent
   
  !OUTPUT PARAMETERS:

   xpath_str = The XPath, expressed as a character string. It is the caller's
               responsibility to ensure that this buffer is big enough to hold
               the XPath string.

               Note: sasa_c_build_xpath_str uses the C standard library 
               function sprintf().  To make sasa_c_build_xpath_str safe from
               the risk of buffer overflows, snprintf() could be used instead.
               snprintf() was part of the recent C99 standard and therefore
               may not be available on all platforms where OASIS is built. 
               This, combined with the fact that XPaths are not
               user-specified, makes me think that sprintf() is acceptable
               providing a large buffer is used. 

   return value = The length of the xpath_str or -1 if an error occurred.

  !DESCRIPTION:

   Builds a character string representation of the given XPath.
   Add prefix "default:" to all XML elements included in the XPath

  !FILES USED:

         <stdarg.h>
         <string.h>
         <stdio.h>
         "sasa_c_f90.h"

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
  14.01.08    I.Henderson  created

//EOP

 ----------------------------------------------------------------------
  $Id
  $Author
 ----------------------------------------------------------------------
*/
static int sasa_c_build_xpath_str( char           *xpath_str,
                                   XPathStartType xpath_start_type,
                                   XPathNodeType  xpath_target_node_type,
                                   size_t         parent_nodes_count,
                                   va_list        xpath_nodes )
{
  size_t elements_loop;
  int    xpath_str_len, chars_count;
  char   format_str[ 32 ];

  ASSERT( xpath_str != NULL );
  ASSERT( xpath_start_type >= XPATH_START_FIRST
       && xpath_start_type <= XPATH_START_LAST );
  ASSERT( xpath_target_node_type >= XPATH_NODE_TYPE_FIRST
       && xpath_target_node_type <= XPATH_NODE_TYPE_LAST );
  ASSERT( parent_nodes_count >= 0 );


  /* Start the XPath string appropriately */
  switch ( xpath_start_type )
  {
    case XPATH_START_CHILD_OF_ROOT_NODE:
    {
      strcpy( xpath_str, "/" );
    }
    break;
    case XPATH_START_DESCENDANT_OF_ROOT_NODE:
    {
      strcpy( xpath_str, "//" );
    }
    break;
    case XPATH_START_CHILD_OF_CURRENT_NODE:
    {
      xpath_str[ 0 ] = '\0';
    }
    break;
    default:
    {
      ASSERT( 0 );
    }
    break;
  }
  xpath_str_len = chars_count = strlen( xpath_str );


  /* Add successive parent elements to the XPath string */
  elements_loop = 0;
  while ( elements_loop < parent_nodes_count && chars_count != -1 )
  {
    const char *element_name = va_arg( xpath_nodes, char * ); 
    int element_name_len = va_arg( xpath_nodes, int ); 
    int element_count = va_arg( xpath_nodes, int ); 

    /* Since Fortran strings aren't null-terminated, we must copy an exact
    number of chars from element_name (given by element_name_len) to the
    xpath input string - e.g. we must use %.9s instead of %s for "transient". */
    if ( element_count == 0 )
    {
      sprintf( format_str, "%%.%ds/", element_name_len );
      chars_count = sprintf( xpath_str + xpath_str_len, format_str,
                             element_name );
    }
    else
    {
      sprintf( format_str, "%%.%ds[%%d]/", element_name_len );
      chars_count = sprintf( xpath_str + xpath_str_len, format_str,
                             element_name, element_count );
    }

    xpath_str_len += chars_count;
    elements_loop++;
  }


  /* Finally, add the element or attribute we want to the end of the xpath */
  if ( chars_count != -1 )
  {
    switch ( xpath_target_node_type )
    {
      case XPATH_NODE_TYPE_ATTRIBUTE:
      {
        const char *attribute_name = va_arg( xpath_nodes, char * ); 
        int attribute_name_len = va_arg( xpath_nodes, int ); 
        /* Ignore the last value in the node triplet (if any) -
        there can only be one instance of an attribute. */

        sprintf( format_str, "@%%.%ds", attribute_name_len );
        chars_count = sprintf( xpath_str + xpath_str_len, format_str,
                              attribute_name );
      }
      break;
      case XPATH_NODE_TYPE_ELEMENT:
      {
        const char *element_name = va_arg( xpath_nodes, char * ); 
        int element_name_len = va_arg( xpath_nodes, int ); 
        int element_count = va_arg( xpath_nodes, int ); 

        if ( element_count == 0 )
        {
          sprintf( format_str, "%%.%ds", element_name_len );
          chars_count = sprintf( xpath_str + xpath_str_len, format_str,
                                element_name );
        }
        else
        {
          sprintf( format_str, "%%.%ds[%%d]", element_name_len );
          chars_count = sprintf( xpath_str + xpath_str_len, format_str,
                                element_name, element_count );
        }
      }
      break;
      default:
      {
        ASSERT( 0 );
      }
      break;
    }

    xpath_str_len += chars_count;
  }

  return ( chars_count != -1 ? xpath_str_len : chars_count );

} /* sasa_c_build_xpath_str */


/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */

/*

//BOP

  !ROUTINE: sasa_c_close

  !DESCRIPTION:

   Close an XML file and free memory form its content (the XML tree).

  !INPUT PARAMETERS:
  
   num_doc  =  handle to XML document tree of open file (positive integer)

  !OUTPUT PARAMETERS:

   returned    = handle to XML document tree of open file (positive integer)

  !FILES USED:

  !REVISION HISTORY:

    Date      Programmer   Description
  ----------  ----------   -----------
  ??.??.??    P. Bourcier  Creation
  22.03.10    JM Epitalon  Simultaneous access to multiple documents

//EOP

 ----------------------------------------------------------------------
  $Id
  $Author
 ----------------------------------------------------------------------
*/
int
sasa_c_close  (int *num_doc)
{

  return (sasaCloseXml (*num_doc));

}


/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */
/*                      Fortran interface                      */
/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */

int sasa_c_convert_char2int  (char *charcode, int len_charcode) 
{
  int result;
  char *name;

  name = (char *) calloc(len_charcode+1, sizeof(char));
  strncpy(name,charcode,len_charcode);

  result = __sasa_c_convert_char2int  (name, len_charcode);

  free(name);

  return(result);
}

/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */

int sasa_c_get_number_1st_level ( int  *num_doc,
                  char *firstlevel, 
                  int  *xml_number,
                  int  len_firstlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number, *num_doc, 1,
    firstlevel, len_firstlevel, 0 );

  return(result);
}


int sasa_c_get_number_2nd_level  (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel,
                  int  *xml_number, 
                  int  len_firstlevel,
                  int  len_secondlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number, *num_doc, 2,
    firstlevel,  len_firstlevel,  *firstno,
    secondlevel, len_secondlevel, 0 );

  return(result);
}


int sasa_c_get_number_3rd_level  (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel,
                  int  *secondno, 
                  char *thirdlevel,
                  int  *xml_number, 
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number, *num_doc, 3,
    firstlevel,  len_firstlevel,  *firstno,
    secondlevel, len_secondlevel, *secondno,
    thirdlevel,  len_thirdlevel,  0 );

  return(result);
}


int sasa_c_get_number_4th_level  (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel, 
                  int  *secondno, 
                  char *thirdlevel, 
                  int  *thirdno, 
                  char *fourthlevel, 
                  int  *xml_number,
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel,
                  int  len_fourthlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number, *num_doc, 4,
    firstlevel,  len_firstlevel,  *firstno,
    secondlevel, len_secondlevel, *secondno,
    thirdlevel,  len_thirdlevel,  *thirdno,
    fourthlevel, len_fourthlevel, 0 );

  return(result);
}


int sasa_c_get_number_5th_level  (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel, 
                  int  *secondno, 
                  char *thirdlevel, 
                  int  *thirdno, 
                  char *fourthlevel, 
                  int  *fourthno, 
                  char *fifthlevel, 
                  int  *xml_number,
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel,
                  int  len_fourthlevel,
                  int  len_fifthlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number, *num_doc, 5,
    firstlevel,  len_firstlevel,  *firstno,
    secondlevel, len_secondlevel, *secondno,
    thirdlevel,  len_thirdlevel,  *thirdno,
    fourthlevel, len_fourthlevel, *fourthno,
    fifthlevel,  len_fifthlevel,  0 );

  return(result);
}


int sasa_c_get_number_6th_level  (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel, 
                  int  *secondno, 
                  char *thirdlevel, 
                  int  *thirdno, 
                  char *fourthlevel, 
                  int  *fourthno, 
                  char *fifthlevel, 
                  int  *fifthno, 
                  char *sixthlevel, 
                  int  *xml_number,
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel,
                  int  len_fourthlevel,
                  int  len_fifthlevel,
                  int  len_sixthlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number, *num_doc, 6,
    firstlevel,  len_firstlevel,  *firstno,
    secondlevel, len_secondlevel, *secondno,
    thirdlevel,  len_thirdlevel,  *thirdno,
    fourthlevel, len_fourthlevel, *fourthno,
    fifthlevel,  len_fifthlevel,  *fifthno,
    sixthlevel,  len_sixthlevel,  0 );

  return(result);
}


int sasa_c_get_number_7th_level  (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel, 
                  int  *secondno, 
                  char *thirdlevel, 
                  int  *thirdno, 
                  char *fourthlevel, 
                  int  *fourthno, 
                  char *fifthlevel, 
                  int  *fifthno, 
                  char *sixthlevel, 
                  int  *sixthno, 
                  char *seventhlevel, 
                  int  *xml_number,
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel,
                  int  len_fourthlevel,
                  int  len_fifthlevel,
                  int  len_sixthlevel,
                  int  len_seventhlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number,   *num_doc,  7,
    firstlevel,   len_firstlevel,   *firstno,
    secondlevel,  len_secondlevel,  *secondno,
    thirdlevel,   len_thirdlevel,   *thirdno,
    fourthlevel,  len_fourthlevel,  *fourthno,
    fifthlevel,   len_fifthlevel,   *fifthno,
    sixthlevel,   len_sixthlevel,   *sixthno,
    seventhlevel, len_seventhlevel, 0 );

  return(result);
}


int sasa_c_get_number_8th_level  (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel, 
                  int  *secondno, 
                  char *thirdlevel, 
                  int  *thirdno, 
                  char *fourthlevel, 
                  int  *fourthno, 
                  char *fifthlevel, 
                  int  *fifthno, 
                  char *sixthlevel, 
                  int  *sixthno, 
                  char *seventhlevel, 
                  int  *seventhno, 
                  char *eighthlevel, 
                  int  *xml_number,
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel,
                  int  len_fourthlevel,
                  int  len_fifthlevel,
                  int  len_sixthlevel,
                  int  len_seventhlevel,
                  int  len_eighthlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number,   *num_doc,  8,
    firstlevel,   len_firstlevel,   *firstno,
    secondlevel,  len_secondlevel,  *secondno,
    thirdlevel,   len_thirdlevel,   *thirdno,
    fourthlevel,  len_fourthlevel,  *fourthno,
    fifthlevel,   len_fifthlevel,   *fifthno,
    sixthlevel,   len_sixthlevel,   *sixthno,
    seventhlevel, len_seventhlevel, *seventhno,
    eighthlevel,  len_eighthlevel,  0 );

  return(result);
}


int sasa_c_get_number_9th_level  (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel, 
                  int  *secondno, 
                  char *thirdlevel, 
                  int  *thirdno, 
                  char *fourthlevel, 
                  int  *fourthno, 
                  char *fifthlevel, 
                  int  *fifthno, 
                  char *sixthlevel, 
                  int  *sixthno, 
                  char *seventhlevel, 
                  int  *seventhno, 
                  char *eighthlevel, 
                  int  *eighthno, 
                  char *ninthlevel, 
                  int  *xml_number,
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel,
                  int  len_fourthlevel,
                  int  len_fifthlevel,
                  int  len_sixthlevel,
                  int  len_seventhlevel,
                  int  len_eighthlevel,
                  int  len_ninthlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number,   *num_doc,  9,
    firstlevel,   len_firstlevel,   *firstno,
    secondlevel,  len_secondlevel,  *secondno,
    thirdlevel,   len_thirdlevel,   *thirdno,
    fourthlevel,  len_fourthlevel,  *fourthno,
    fifthlevel,   len_fifthlevel,   *fifthno,
    sixthlevel,   len_sixthlevel,   *sixthno,
    seventhlevel, len_seventhlevel, *seventhno,
    eighthlevel,  len_eighthlevel,  *eighthno,
    ninthlevel,   len_ninthlevel,   0 );

  return(result);
}

int sasa_c_get_number_10th_level (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel, 
                  int  *secondno, 
                  char *thirdlevel, 
                  int  *thirdno, 
                  char *fourthlevel, 
                  int  *fourthno, 
                  char *fifthlevel, 
                  int  *fifthno, 
                  char *sixthlevel, 
                  int  *sixthno, 
                  char *seventhlevel, 
                  int  *seventhno, 
                  char *eighthlevel, 
                  int  *eighthno, 
                  char *ninthlevel,
                  int  *ninthno, 
                  char *tenthlevel, 
                  int  *xml_number,
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel,
                  int  len_fourthlevel,
                  int  len_fifthlevel,
                  int  len_sixthlevel,
                  int  len_seventhlevel,
                  int  len_eighthlevel,
                  int  len_ninthlevel,
                  int  len_tenthlevel)
{
  int result;

  result = sasa_c_get_number(
    xml_number,   *num_doc,  10,
    firstlevel,   len_firstlevel,   *firstno,
    secondlevel,  len_secondlevel,  *secondno,
    thirdlevel,   len_thirdlevel,   *thirdno,
    fourthlevel,  len_fourthlevel,  *fourthno,
    fifthlevel,   len_fifthlevel,   *fifthno,
    sixthlevel,   len_sixthlevel,   *sixthno,
    seventhlevel, len_seventhlevel, *seventhno,
    eighthlevel,  len_eighthlevel,  *eighthno,
    ninthlevel,   len_ninthlevel,   *ninthno,
    tenthlevel,   len_tenthlevel,   0 );

  return(result);
}

int sasa_c_get_number_11th_level (int  *num_doc,
                  char *firstlevel, 
                  int  *firstno, 
                  char *secondlevel, 
                  int  *secondno, 
                  char *thirdlevel, 
                  int  *thirdno, 
                  char *fourthlevel, 
                  int  *fourthno, 
                  char *fifthlevel, 
                  int  *fifthno, 
                  char *sixthlevel, 
                  int  *sixthno, 
                  char *seventhlevel, 
                  int  *seventhno, 
                  char *eighthlevel, 
                  int  *eighthno, 
                  char *ninthlevel,
                  int  *ninthno, 
                  char *tenthlevel,
                  int  *tenthno, 
                  char *elethlevel, 
                  int  *xml_number,
                  int  len_firstlevel,
                  int  len_secondlevel,
                  int  len_thirdlevel,
                  int  len_fourthlevel,
                  int  len_fifthlevel,
                  int  len_sixthlevel,
                  int  len_seventhlevel,
                  int  len_eighthlevel,
                  int  len_ninthlevel,
                  int  len_tenthlevel,
                  int  len_elethlevel )
{
  int result;

  result = sasa_c_get_number(
    xml_number,   *num_doc,  11,
    firstlevel,   len_firstlevel,   *firstno,
    secondlevel,  len_secondlevel,  *secondno,
    thirdlevel,   len_thirdlevel,   *thirdno,
    fourthlevel,  len_fourthlevel,  *fourthno,
    fifthlevel,   len_fifthlevel,   *fifthno,
    sixthlevel,   len_sixthlevel,   *sixthno,
    seventhlevel, len_seventhlevel, *seventhno,
    eighthlevel,  len_eighthlevel,  *eighthno,
    ninthlevel,   len_ninthlevel,   *ninthno,
    tenthlevel,   len_tenthlevel,   *tenthno,
    elethlevel,   len_elethlevel,   0 );

  return(result);
}

/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */

int sasa_c_get_attri_1st_level  (int  *num_doc,
                 char *firstlevel, 
                 int  *firstno, 
                 char *attribute,
                 char *xml_attribute,
                 int  *xml_attribute_length,
                 int  len_firstlevel,
                 int  len_attribute,
                 int  len_xml_attribute)
{
  int result;

  result = sasa_c_get_attribute(
    xml_attribute, xml_attribute_length, *num_doc, 1,
    firstlevel,    len_firstlevel,       *firstno,
    attribute,     len_attribute );

  return(result);
}


int sasa_c_get_attri_2nd_level  (int  *num_doc,
                 char *firstlevel, 
                 int  *firstno, 
                 char *secondlevel, 
                 int  *secondno, 
                 char *attribute,
                 char *xml_attribute,
                 int  *xml_attribute_length,
                 int  len_firstlevel,
                 int  len_secondlevel,
                 int  len_attribute,
                 int  len_xml_attribute)
{
  int result;

  result = sasa_c_get_attribute(
    xml_attribute, xml_attribute_length, *num_doc, 2,
    firstlevel,    len_firstlevel,       *firstno,
    secondlevel,   len_secondlevel,      *secondno,
    attribute,     len_attribute );

  return(result);
}


int sasa_c_get_attri_3rd_level  (int  *num_doc,
                 char *firstlevel, 
                 int  *firstno, 
                 char *secondlevel, 
                 int  *secondno, 
                 char *thirdlevel, 
                 int  *thirdno, 
                 char *attribute,
                 char *xml_attribute,
                 int  *xml_attribute_length,
                 int  len_firstlevel,
                 int  len_secondlevel,
                 int  len_thirdlevel,
                 int  len_attribute,
                 int  len_xml_attribute)
{
  int result;

  result = sasa_c_get_attribute(
    xml_attribute, xml_attribute_length, *num_doc, 3,
    firstlevel,    len_firstlevel,       *firstno,
    secondlevel,   len_secondlevel,      *secondno,
    thirdlevel,    len_thirdlevel,       *thirdno,
    attribute,     len_attribute );

  return(result);
}


int sasa_c_get_attri_4th_level  (int  *num_doc,
                 char *firstlevel, 
                 int  *firstno, 
                 char *secondlevel, 
                 int  *secondno, 
                 char *thirdlevel, 
                 int  *thirdno, 
                 char *fourthlevel, 
                 int  *fourthno, 
                 char *attribute,
                 char *xml_attribute,
                 int  *xml_attribute_length,
                 int  len_firstlevel,
                 int  len_secondlevel,
                 int  len_thirdlevel,
                 int  len_fourthlevel,
                 int  len_attribute,
                 int  len_xml_attribute)
{
  int result;

  result = sasa_c_get_attribute(
    xml_attribute, xml_attribute_length, *num_doc, 4,
    firstlevel,    len_firstlevel,       *firstno,
    secondlevel,   len_secondlevel,      *secondno,
    thirdlevel,    len_thirdlevel,       *thirdno,
    fourthlevel,   len_fourthlevel,      *fourthno,
    attribute,     len_attribute );

  return(result);
}


int sasa_c_get_attri_5th_level  (int  *num_doc,
                 char *firstlevel, 
                 int  *firstno, 
                 char *secondlevel, 
                 int  *secondno, 
                 char *thirdlevel, 
                 int  *thirdno, 
                 char *fourthlevel, 
                 int  *fourthno, 
                 char *fifthlevel, 
                 int  *fifthno, 
                 char *attribute,
                 char *xml_attribute,
                 int  *xml_attribute_length,
                 int  len_firstlevel,
                 int  len_secondlevel,
                 int  len_thirdlevel,
                 int  len_fourthlevel,
                 int  len_fifthlevel,
                 int  len_attribute,
                 int  len_xml_attribute)
{
  int result;

  result = sasa_c_get_attribute(
    xml_attribute, xml_attribute_length, *num_doc, 5,
    firstlevel,    len_firstlevel,       *firstno,
    secondlevel,   len_secondlevel,      *secondno,
    thirdlevel,    len_thirdlevel,       *thirdno,
    fourthlevel,   len_fourthlevel,      *fourthno,
    fifthlevel,    len_fifthlevel,       *fifthno,
    attribute,     len_attribute );

  return(result);
}


int sasa_c_get_attri_6th_level  (int  *num_doc,
                 char *firstlevel, 
                 int  *firstno, 
                 char *secondlevel, 
                 int  *secondno, 
                 char *thirdlevel, 
                 int  *thirdno, 
                 char *fourthlevel, 
                 int  *fourthno, 
                 char *fifthlevel, 
                 int  *fifthno, 
                 char *sixthlevel, 
                 int  *sixthno, 
                 char *attribute, 
                 char *xml_attribute,
                 int  *xml_attribute_length,
                 int  len_firstlevel,
                 int  len_secondlevel,
                 int  len_thirdlevel,
                 int  len_fourthlevel,
                 int  len_fifthlevel,
                 int  len_sixthlevel,
                 int  len_attribute,
                 int  len_xml_attribute)
{
  int result;

  result = sasa_c_get_attribute(
    xml_attribute, xml_attribute_length, *num_doc, 6,
    firstlevel,    len_firstlevel,       *firstno,
    secondlevel,   len_secondlevel,      *secondno,
    thirdlevel,    len_thirdlevel,       *thirdno,
    fourthlevel,   len_fourthlevel,      *fourthno,
    fifthlevel,    len_fifthlevel,       *fifthno,
    sixthlevel,    len_sixthlevel,       *sixthno, 
    attribute,     len_attribute );

  return(result);
}


int sasa_c_get_attri_8th_level  (int  *num_doc,
                 char *firstlevel, 
                 int  *firstno, 
                 char *secondlevel, 
                 int  *secondno, 
                 char *thirdlevel, 
                 int  *thirdno, 
                 char *fourthlevel, 
                 int  *fourthno, 
                 char *fifthlevel, 
                 int  *fifthno, 
                 char *sixthlevel, 
                 int  *sixthno, 
                 char *seventhlevel, 
                 int  *seventhno, 
                 char *eighthlevel, 
                 int  *eighthno, 
                 char *attribute, 
                 char *xml_attribute,
                 int  *xml_attribute_length,
                 int  len_firstlevel,
                 int  len_secondlevel,
                 int  len_thirdlevel,
                 int  len_fourthlevel,
                 int  len_fifthlevel,
                 int  len_sixthlevel,
                 int  len_seventhlevel,
                 int  len_eighthlevel,
                 int  len_attribute,
                 int  len_xml_attribute)
{
  int result;

  result = sasa_c_get_attribute(
    xml_attribute, xml_attribute_length, *num_doc, 8,
    firstlevel,    len_firstlevel,       *firstno,
    secondlevel,   len_secondlevel,      *secondno,
    thirdlevel,    len_thirdlevel,       *thirdno,
    fourthlevel,   len_fourthlevel,      *fourthno,
    fifthlevel,    len_fifthlevel,       *fifthno,
    sixthlevel,    len_sixthlevel,       *sixthno, 
    seventhlevel,  len_seventhlevel,     *seventhno, 
    eighthlevel,   len_eighthlevel,      *eighthno, 
    attribute,     len_attribute );

  return(result);
}


int sasa_c_get_attri_10th_level  (int  *num_doc,
                 char *firstlevel, 
                 int  *firstno, 
                 char *secondlevel, 
                 int  *secondno, 
                 char *thirdlevel, 
                 int  *thirdno, 
                 char *fourthlevel, 
                 int  *fourthno, 
                 char *fifthlevel, 
                 int  *fifthno, 
                 char *sixthlevel, 
                 int  *sixthno, 
                 char *seventhlevel, 
                 int  *seventhno, 
                 char *eighthlevel, 
                 int  *eighthno, 
                 char *ninthlevel, 
                 int  *ninthno,
                 char *tenthlevel, 
                 int  *tenthno,
                 char *attribute, 
                 char *xml_attribute,
                 int  *xml_attribute_length,
                 int  len_firstlevel,
                 int  len_secondlevel,
                 int  len_thirdlevel,
                 int  len_fourthlevel,
                 int  len_fifthlevel,
                 int  len_sixthlevel,
                 int  len_seventhlevel,
                 int  len_eighthlevel,
                 int  len_ninthlevel,
                 int  len_tenthlevel,
                 int  len_attribute,
                 int  len_xml_attribute)
{
  int result;

  result = sasa_c_get_attribute(
    xml_attribute, xml_attribute_length, *num_doc, 10,
    firstlevel,    len_firstlevel,       *firstno,
    secondlevel,   len_secondlevel,      *secondno,
    thirdlevel,    len_thirdlevel,       *thirdno,
    fourthlevel,   len_fourthlevel,      *fourthno,
    fifthlevel,    len_fifthlevel,       *fifthno,
    sixthlevel,    len_sixthlevel,       *sixthno, 
    seventhlevel,  len_seventhlevel,     *seventhno, 
    eighthlevel,   len_eighthlevel,      *eighthno, 
    ninthlevel,    len_ninthlevel,       *ninthno, 
    tenthlevel,    len_tenthlevel,       *tenthno, 
    attribute,     len_attribute );

  return(result);
}

/* - = - = - = - = - = - = - = - = - = - = - = - = - = - = - = */

int sasa_c_get_element_xpath_c  (int  *num_doc,
                 char *xpath, 
                 char *xml_element,
                 int  *xml_element_length,
                 int  len_xpath,
                 int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element, xml_element_length, *num_doc, -1,
    xpath, len_xpath);

  return(result);
}


int sasa_c_get_element_1st_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element, xml_element_length, *num_doc, 1,
    firstlevel,  len_firstlevel,     *firstno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_xpath_i  (int  *num_doc,
                 char *xpath, 
                 int  *xml_element,
                 int  len_xpath)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element, *num_doc, -1, xpath, len_xpath);

  return(result);
}


int sasa_c_get_element_1st_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element, *num_doc, 1,
    firstlevel,  len_firstlevel,     *firstno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_1st_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element, *num_doc, 1,
    firstlevel,  len_firstlevel,     *firstno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_2nd_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element, xml_element_length, *num_doc, 2,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_2nd_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element, *num_doc, 2,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_2nd_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element, *num_doc, 2,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_3rd_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element, xml_element_length, *num_doc, 3,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_3rd_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element, *num_doc, 3,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_3rd_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element, *num_doc, 3,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_4th_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element, xml_element_length, *num_doc, 4,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_4th_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element, *num_doc, 4,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_4th_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element, *num_doc, 4,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_5th_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element, xml_element_length, *num_doc, 5,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    fifthlevel,  len_fifthlevel,     *fifthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_5th_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element, *num_doc, 5,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    fifthlevel,  len_fifthlevel,     *fifthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_5th_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element, *num_doc, 5,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    fifthlevel,  len_fifthlevel,     *fifthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_6th_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element, xml_element_length, *num_doc, 6,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    fifthlevel,  len_fifthlevel,     *fifthno, 
    sixthlevel,  len_sixthlevel,     *sixthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_6th_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element, *num_doc, 6,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    fifthlevel,  len_fifthlevel,     *fifthno, 
    sixthlevel,  len_sixthlevel,     *sixthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_6th_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element, *num_doc, 6,
    firstlevel,  len_firstlevel,     *firstno, 
    secondlevel, len_secondlevel,    *secondno, 
    thirdlevel,  len_thirdlevel,     *thirdno, 
    fourthlevel, len_fourthlevel,    *fourthno, 
    fifthlevel,  len_fifthlevel,     *fifthno, 
    sixthlevel,  len_sixthlevel,     *sixthno, 
    element,     len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_7th_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element,  xml_element_length, *num_doc, 7,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    element,      len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_7th_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element,  *num_doc, 7,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    element,      len_element,        *elementno );

  return(result);
}

int sasa_c_get_element_7th_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno,
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element,  *num_doc, 7,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    element,      len_element,        *elementno );

  return(result);
}

int sasa_c_get_element_8th_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element,  xml_element_length, *num_doc, 8,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    element,      len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_8th_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element,  *num_doc, 8,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    element,      len_element,        *elementno );

  return(result);
}

int sasa_c_get_element_8th_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno,
                     char *seventhlevel, 
                     int  *seventhno,
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element,  *num_doc, 8,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    element,      len_element,        *elementno );

  return(result);
}

int sasa_c_get_element_9th_level_c  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *ninthlevel, 
                     int  *ninthno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_ninthlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element,  xml_element_length, *num_doc, 9,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    ninthlevel,   len_ninthlevel,     *ninthno, 
    element,      len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_9th_level_i  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *ninthlevel, 
                     int  *ninthno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_ninthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element,  *num_doc, 9,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    ninthlevel,   len_ninthlevel,     *ninthno, 
    element,      len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_9th_level_d  (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *ninthlevel, 
                     int  *ninthno, 
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_ninthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element,  *num_doc, 9,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    ninthlevel,   len_ninthlevel,     *ninthno, 
    element,      len_element,        *elementno );

  return(result);
}

int sasa_c_get_element_10th_level_c (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *ninthlevel, 
                     int  *ninthno,
                     char *tenthlevel, 
                     int  *tenthno, 
                     char *element, 
                     int  *elementno,
                     char *xml_element,
                     int  *xml_element_length,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_ninthlevel,
                     int  len_tenthlevel,
                     int  len_element,
                     int  len_xml_element)
{
  int result;

  result = sasa_c_get_element_c(
    xml_element,  xml_element_length, *num_doc, 10,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    ninthlevel,   len_ninthlevel,     *ninthno, 
    tenthlevel,   len_tenthlevel,     *tenthno, 
    element,      len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_10th_level_i (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *ninthlevel, 
                     int  *ninthno,
                     char *tenthlevel, 
                     int  *tenthno, 
                     char *element, 
                     int  *elementno,
                     int  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_ninthlevel,
                     int  len_tenthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_i(
    xml_element,  *num_doc, 10,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    ninthlevel,   len_ninthlevel,     *ninthno, 
    tenthlevel,   len_tenthlevel,     *tenthno, 
    element,      len_element,        *elementno );

  return(result);
}


int sasa_c_get_element_10th_level_d (int  *num_doc,
                     char *firstlevel, 
                     int  *firstno, 
                     char *secondlevel, 
                     int  *secondno, 
                     char *thirdlevel, 
                     int  *thirdno, 
                     char *fourthlevel, 
                     int  *fourthno, 
                     char *fifthlevel, 
                     int  *fifthno, 
                     char *sixthlevel, 
                     int  *sixthno, 
                     char *seventhlevel, 
                     int  *seventhno, 
                     char *eighthlevel, 
                     int  *eighthno, 
                     char *ninthlevel, 
                     int  *ninthno,
                     char *tenthlevel, 
                     int  *tenthno,
                     char *element, 
                     int  *elementno,
                     double  *xml_element,
                     int  len_firstlevel,
                     int  len_secondlevel,
                     int  len_thirdlevel,
                     int  len_fourthlevel,
                     int  len_fifthlevel,
                     int  len_sixthlevel,
                     int  len_seventhlevel,
                     int  len_eighthlevel,
                     int  len_ninthlevel,
                     int  len_tenthlevel,
                     int  len_element)
{
  int result;

  result = sasa_c_get_element_d(
    xml_element,  *num_doc, 10,
    firstlevel,   len_firstlevel,     *firstno, 
    secondlevel,  len_secondlevel,    *secondno, 
    thirdlevel,   len_thirdlevel,     *thirdno, 
    fourthlevel,  len_fourthlevel,    *fourthno, 
    fifthlevel,   len_fifthlevel,     *fifthno, 
    sixthlevel,   len_sixthlevel,     *sixthno, 
    seventhlevel, len_seventhlevel,   *seventhno, 
    eighthlevel,  len_eighthlevel,    *eighthno, 
    ninthlevel,   len_ninthlevel,     *ninthno, 
    tenthlevel,   len_tenthlevel,     *tenthno, 
    element,      len_element,        *elementno );

  return(result);
}