config.c

开源备份软件源码 AMANDA, the Advanced Maryland Automatic Network Disk Archiver, is a backup system that a

#include "conffile.h"


SWIGINTERNINLINE SV *
SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
{    
  SV *obj = sv_newmortal();
  sv_setiv(obj, (IV) value);
  return obj;
}


SWIGINTERNINLINE SV *
SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
{    
  return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
}


#include <limits.h>
#ifndef LLONG_MIN
# define LLONG_MIN	LONG_LONG_MIN
#endif
#ifndef LLONG_MAX
# define LLONG_MAX	LONG_LONG_MAX
#endif
#ifndef ULLONG_MAX
# define ULLONG_MAX	ULONG_LONG_MAX
#endif


SWIGINTERN int
SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
{
  if (SvNIOK(obj)) {
    if (val) *val = SvNV(obj);
    return SWIG_OK;
  } else if (SvIOK(obj)) {
    if (val) *val = (double) SvIV(obj);
    return SWIG_AddCast(SWIG_OK);
  } else {
    const char *nptr = SvPV(obj, PL_na);
    if (nptr) {
      char *endptr;
      double v = strtod(nptr, &endptr);
      if (errno == ERANGE) {
	errno = 0;
	return SWIG_OverflowError;
      } else {
	if (*endptr == '\0') {
	  if (val) *val = v;
	  return SWIG_Str2NumCast(SWIG_OK);
	}
      }
    }
  }
  return SWIG_TypeError;
}


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx = floor(x);
   double cx = ceil(x);
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
{
  if (SvIOK(obj)) {
    if (val) *val = SvIV(obj);
    return SWIG_OK;
  } else {
    int dispatch = 0;
    const char *nptr = SvPV(obj, PL_na);
    if (nptr) {
      char *endptr;
      long v = strtol(nptr, &endptr,0);
      if (errno == ERANGE) {
	errno = 0;
	return SWIG_OverflowError;
      } else {
	if (*endptr == '\0') {
	  if (val) *val = v;
	  return SWIG_Str2NumCast(SWIG_OK);
	}
      }
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (int)(v);
    }
  }  
  return res;
}


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
{
  if (SvPOK(obj)) {
    STRLEN len = 0;
    char *cstr = SvPV(obj, len); 
    size_t size = len + 1;
    if (cptr)  {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      }
    }
    if (psize) *psize = size;
    return SWIG_OK;
  } else {
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      char* vptr = 0; 
      if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = vptr;
	if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}





SWIGINTERNINLINE SV *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  SV *obj = sv_newmortal();
  if (carray) {
    if (size && (carray[size - 1] == 0)) {
      sv_setpv(obj, carray);
    } else {
      char *tmp = (char *)malloc((size + 1)*sizeof(char));
      memcpy(tmp, carray, size);
      tmp[size] = 0;
      sv_setpv(obj, tmp);
      free((char*)tmp);
    }
  } else {
    sv_setsv(obj, &PL_sv_undef);
  }
  return obj;
}


SWIGINTERNINLINE SV * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


    char *get_config_name(void) { return config_name; }
    char *get_config_dir(void) { return config_dir; }
    char *get_config_filename(void) { return config_filename; }

#ifdef PERL_OBJECT
#define MAGIC_CLASS _wrap_Amanda::Config_var::
class _wrap_Amanda::Config_var : public CPerlObj {
public:
#else
#define MAGIC_CLASS
#endif
SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
    MAGIC_PPERL
    croak("Value is read-only.");
    return 0;
}
SWIGCLASS_STATIC int _wrap_debug_amandad_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_amandad""' of type '""int""'");
    }
    debug_amandad = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_amandad_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_amandad)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_amidxtaped_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_amidxtaped""' of type '""int""'");
    }
    debug_amidxtaped = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_amidxtaped_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_amidxtaped)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_amindexd_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_amindexd""' of type '""int""'");
    }
    debug_amindexd = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_amindexd_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_amindexd)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_amrecover_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_amrecover""' of type '""int""'");
    }
    debug_amrecover = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_amrecover_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_amrecover)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_auth_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_auth""' of type '""int""'");
    }
    debug_auth = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_auth_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_auth)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_event_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_event""' of type '""int""'");
    }
    debug_event = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_event_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_event)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_holding_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_holding""' of type '""int""'");
    }
    debug_holding = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_holding_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_holding)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_protocol_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_protocol""' of type '""int""'");
    }
    debug_protocol = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_protocol_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_protocol)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_planner_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_planner""' of type '""int""'");
    }
    debug_planner = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_planner_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_planner)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_driver_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_driver""' of type '""int""'");
    }
    debug_driver = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_driver_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_driver)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_dumper_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_dumper""' of type '""int""'");
    }
    debug_dumper = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_dumper_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_dumper)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_chunker_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {