return (PRO_TK_BAD_INPUTS);    error = procbl_get_location_pnt ((Prohandle)p_harness->harness,         location_id, pnt);    TEST_CALL_REPORT("procbl_get_location_pnt",        "ProCblHarnessLocationPntGet",(ProError)error, 0);    if (error != PRODEV_NO_ERROR)        return (PRO_TK_GENERAL_ERROR);    return (PRO_TK_NO_ERROR);}    /*---------------------------------------------------------------------------*\    Functions to manage spools.\*---------------------------------------------------------------------------*//*---------------------------------------------------------------------------*\  Function : ProCblAssemblySpoolsGet  Purpose  : Collect spools in specified assembly\*---------------------------------------------------------------------------*/ProError ProCblAssemblySpoolsGet (    ProAssembly    asm_mdl,     /* In : assembly's handle*/    ProCblSpool    **p_spool,   /* Out: pointer on array of spool's handle's                                       to init.Function allocate memory for                                       this argument, use ProArrayFree to free                                       it.*/    int            *num_spools) /* Out: number of retrieved spools*/{    int error, i;    ProError status;    PRODEV_Name *spool_names;    if (asm_mdl == NULL || p_spool == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_get_assy_spools ((Prohandle)asm_mdl, &spool_names);    TEST_CALL_REPORT("procbl_get_assy_spools",            "ProCblAssemblySpoolsGe",(ProError)error, 0);    if(error == PRODEV_INVALID_INPUT)        return (PRO_TK_E_NOT_FOUND);    if(error == PRODEV_GENERAL_ERROR)       return (PRO_TK_BAD_INPUTS);    if (num_spools)            *num_spools = error;    status = ProArrayAlloc (error, sizeof(ProCblSpool), 1,        (ProArray*)p_spool);     for( i=0; i<error; i++)    {        status = ProCblSpoolInit (asm_mdl,spool_names[i], &(*p_spool)[i]);    }    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolInit  Purpose  : Initializes spool structure\*---------------------------------------------------------------------------*/ProError ProCblSpoolInit (    ProAssembly    asm_mdl,     /* In : assembly's handle*/    ProName        w_name,      /* In : spool name*/    ProCblSpool    *p_spool)    /* Out: handle of spool to init*/{    if (asm_mdl == NULL || p_spool == NULL)        return (PRO_TK_BAD_INPUTS);    p_spool->owner = asm_mdl;    ProUtilWstrcpy (p_spool->name, w_name);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolNameGet  Purpose  : returns spool name\*---------------------------------------------------------------------------*/ProError ProCblSpoolNameGet (    ProCblSpool    *p_spool,    /* In: handle of spool to init*/    ProName        w_name)      /* Out: spool name*/{    ProUtilWstrcpy(w_name, p_spool->name);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolCreate  Purpose  : Creates new spool\*---------------------------------------------------------------------------*/ProError ProCblSpoolCreate (    ProAssembly assy,                  /* In : assembly's handle*/    ProName     w_name,                /* In : harness name*/    Procbl_cable_type cable_type,      /* In : cable type */    Procbl_sheath_type sheath_type,    /* In : bundle type */    ProCblSpool  *p_spool)             /* Out :user's memory */{    ProError status;    int error;    if (assy == NULL || p_spool == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_create_spool ((Prohandle)assy, w_name, cable_type,         sheath_type);    TEST_CALL_REPORT("procbl_create_spool",              "ProCblSpoolCreate",(ProError)error, 0);    if (error == PRODEV_INVALID_INPUT)        return (PRO_TK_E_FOUND);    if (error == PRODEV_GENERAL_ERROR)        return (PRO_TK_GENERAL_ERROR);    status = ProCblSpoolInit (assy, w_name, p_spool);    if (status != PRO_TK_NO_ERROR)        return (PRO_TK_GENERAL_ERROR);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolParametersGet  Purpose  : Retrieves parameters of specified spool\*---------------------------------------------------------------------------*/ProError ProCblSpoolParametersGet (    ProCblSpool *p_spool,             /* In : spool's handle*/    ProCblParameterInfo **p_param,    /* Out: ProArray */    int *param_num)                   /* Out: params num */{    int error;    if (p_spool == NULL || p_param == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_get_spool_params ((Prohandle)p_spool->owner,        p_spool->name, p_param);    TEST_CALL_REPORT("procbl_get_spool_params",           "ProCblSpoolParametersGet",(ProError)error, 0);    if (error == PRODEV_INVALID_INPUT)        return (PRO_TK_E_NOT_FOUND);    if (error == PRODEV_GENERAL_ERROR)        return (PRO_TK_GENERAL_ERROR);    *param_num = error;    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolParameterGet  Purpose  : Retrieves one parameter of specified spool\*---------------------------------------------------------------------------*/ProError ProCblSpoolParameterGet (    ProCblSpool *p_spool,            /* In : spool's handle*/    ProName w_param_name,            /* In : parametr name */    ProCblParameterInfo *p_param)    /* Out: user's memory */{    int error;    if (p_spool == NULL || p_param == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_get_spool_param ((Prohandle)p_spool->owner,        p_spool->name, w_param_name, p_param);    TEST_CALL_REPORT("procbl_get_spool_param ",             "ProCblSpoolParameterGet",(ProError)error, 0);    if (error == PRODEV_INVALID_INPUT)        return (PRO_TK_E_NOT_FOUND);    if (error == PRODEV_GENERAL_ERROR)        return (PRO_TK_GENERAL_ERROR);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolParametersSet  Purpose  : Set parameters for specified spool\*---------------------------------------------------------------------------*/ProError ProCblSpoolParametersSet (    ProCblSpool         *p_spool,/* In : spool*/    ProCblParameterInfo *p_param,/* In : the array of parameters*/    int                  n_param)/* In : the number of parameters*/{    int error;    if (p_spool == NULL || p_param == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_set_spool_params ((Prohandle)p_spool->owner,        p_spool->name, n_param, p_param);    TEST_CALL_REPORT("procbl_set_spool_params",             "ProCblSpoolParametersSet",(ProError)error, 0);    if (error == PRODEV_INVALID_INPUT)        return (PRO_TK_E_NOT_FOUND);    if (error == PRODEV_GENERAL_ERROR)        return (PRO_TK_GENERAL_ERROR);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolParameterDelete  Purpose  : Deletes parameter in specified spool\*---------------------------------------------------------------------------*/ProError ProCblSpoolParameterDelete (    ProCblSpool *p_spool,       /* In : spool*/    ProName   param_name)       /* In : param name*/{    int error;    if (p_spool == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_delete_spool_param ((Prohandle)p_spool->owner,        p_spool->name, param_name);    TEST_CALL_REPORT("procbl_delete_spool_param",           "ProCblSpoolParameterDelete",(ProError)error, 0);    if (error == PRODEV_INVALID_INPUT)        return (PRO_TK_E_NOT_FOUND);    if (error == PRODEV_GENERAL_ERROR)        return (PRO_TK_GENERAL_ERROR);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolFromLogicalGet  Purpose  : Return list of imported, but not created spools\*---------------------------------------------------------------------------*/ProError ProCblSpoolFromLogicalGet (    ProAssembly assy,             /* In: assemlbly */    ProName     **p_w_name,       /* Out:  ProArray of spool names*/    int         *num_spool)       /* Out: number of spools */{    ProError status;    int error, i;    PRODEV_Name *p_spool_names;    if (assy == NULL || num_spool == NULL || p_w_name == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_get_spools_from_logical ((Prohandle)assy,        &p_spool_names);    TEST_CALL_REPORT("procbl_get_spools_from_logical",                 "ProCblSpoolFromLogicalGet",(ProError)error, 0);                                   if (error == PRODEV_INVALID_INPUT)        return (PRO_TK_E_NOT_FOUND);    if (error == PRODEV_GENERAL_ERROR)        return (PRO_TK_GENERAL_ERROR);    *num_spool = error;    status = ProArrayAlloc (0, sizeof (ProName), 1, (ProArray*)p_w_name);    if (status != PRO_TK_NO_ERROR)        return (PRO_TK_GENERAL_ERROR);    for (i = 0; i < *num_spool; i++)        status = ProArrayObjectAdd ((ProArray*)p_w_name, PRO_VALUE_UNUSED,            1, p_spool_names[i]);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblSpoolFromLogicalCreate  Purpose  : creates spools from logical\*---------------------------------------------------------------------------*/ProError ProCblSpoolFromLogicalCreate (    ProAssembly assy,                /* In: assembly's hndle*/    ProName    *p_w_name,            /* In: spool_names */    int        spool_num,            /* In: spool num */    ProCblSpool   **p_spools)        /* Out: ProArray of spools                                        user must free memory by ProArrayFree*/{    PRODEV_Name *p_spool_names;    int error, i;    ProError status;      if (assy == NULL || p_w_name == NULL || p_spools == NULL)        return (PRO_TK_BAD_INPUTS);    status = ProArrayAlloc (0, sizeof (PRODEV_Name), 1,         (ProArray*)&p_spool_names);    if (status != PRO_TK_NO_ERROR)        return (PRO_TK_GENERAL_ERROR);    for (i = 0; i < spool_num; i++)        status = ProArrayObjectAdd ((ProArray*)&p_spool_names,             PRO_VALUE_UNUSED, 1, p_w_name[i]);    error = procbl_create_spools_from_logical ((Prohandle)assy,        spool_num, p_spool_names);    TEST_CALL_REPORT("procbl_create_spools_from_logical",                 "ProCblSpoolFromLogicalCreate",(ProError)error, 0);    status = ProArrayFree ((ProArray*)&p_spool_names);    if (error == PRODEV_INVALID_INPUT)        return (PRO_TK_E_FOUND);    if (error == PRODEV_GENERAL_ERROR)        return (PRO_TK_GENERAL_ERROR);    status = ProArrayAlloc (spool_num, sizeof (ProCblSpool), 1,        (ProArray*)p_spools);    for (i = 0; i < spool_num; i++)    {        status = ProCblSpoolInit (assy, p_w_name[i], &(*p_spools)[i]);    }        return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\    Functions to route cables.\*---------------------------------------------------------------------------*//*---------------------------------------------------------------------------*\  Function : ProCblRoutingStart  Purpose  : Initializes routing procedure\*---------------------------------------------------------------------------*/ProError ProCblRoutingStart (    ProCblCable    *p_cables,       /* In: ProArray of cables to route */    void      **p_cable_route_data) /* Out: The cable routing data required for                          subsequent function calls to route cables                          through locations. The function allocates                          the space for this argument. */{    int error;    PRODEV_Name *cable_names;    int cable_num, i;    if (p_cables == NULL || p_cable_route_data == NULL)        return (PRO_TK_BAD_INPUTS);    ProArraySizeGet ((ProArray)p_cables, &cable_num);    ProArrayAlloc (cable_num, sizeof (PRODEV_Name), 1, (ProArray*)&cable_names);    for (i = 0; i < cable_num; i++)        ProCblCableNameGet (&p_cables[i], cable_names[i]);        error = procbl_routing_start ((Prohandle)p_cables[0].p_owner->owner,        (Prohandle)p_cables[0].p_owner->harness, cable_names, cable_num,        p_cable_route_data);    TEST_CALL_REPORT("procbl_routing_start",              "ProCblRoutingStart",(ProError)error, 0);    ProArrayFree ((ProArray*)&cable_names);    if (error != PRODEV_NO_ERROR)        return (PRO_TK_GENERAL_ERROR);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblRouteThruLocation  Purpose  : Finds or creates the location, and routes cables through it\*---------------------------------------------------------------------------*/ProError ProCblRouteThruLocation (    void      *p_cable_route_data, /* In: routing data */    ProCblLocRef  *ref,            /* In: referances */    int **r_location_ids,          /* Out: The location identifiers.                                      The function allocates the space for                                      this argument, and reuse it*/    int *num_locs)                 /* Out: The number of locations. */{    int error;    if (p_cable_route_data == NULL || ref == NULL || r_location_ids == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_route_thru_location (p_cable_route_data, ref,        r_location_ids, num_locs);    TEST_CALL_REPORT("procbl_route_thru_location",               "ProCblRouteThruLocation",(ProError)error, 0);    if (error != PRODEV_NO_ERROR)        return (PRO_TK_GENERAL_ERROR);    return (PRO_TK_NO_ERROR);}/*---------------------------------------------------------------------------*\  Function : ProCblRoutingEnd  Purpose  : Ends the cable routing\*---------------------------------------------------------------------------*/ProError ProCblRoutingEnd (    void      **p_cable_route_data)   /* In: The address of the cable                                          routing data */{    int error;        if (p_cable_route_data == NULL)        return (PRO_TK_BAD_INPUTS);    error = procbl_routing_end (p_cable_route_data);    TEST_CALL_REPORT("procbl_routing_end",              "ProCblRoutingEnd",(ProError)error, 0);    if (error != PRODEV_NO_ERROR)        return (PRO_TK_GENERAL_ERROR);    return (PRO_TK_NO_ERROR);}