~javier-lopez/ubuntu/quantal/cdo/sru-1023329

« back to all changes in this revision

Viewing changes to libcdi/interfaces/ruby/cdilib_wrap.c

Committer: Bazaar Package Importer
Author(s): Alastair McKinstry
Date: 2010-09-22 15:58:09 UTC
mfrom: (1.2.3 upstream)
Revision ID: james.westby@ubuntu.com-20100922155809-u1d3vlmlqj02uxjt

Tags: 1.4.6.dfsg.1-1

New upstream release.

files added:
cdo.settings.in

config/compile

config/ltmain.sh

libcdi

libcdi/AUTHORS

libcdi/COPYING

libcdi/ChangeLog

libcdi/INSTALL

libcdi/Makefile.am

libcdi/Makefile.in

libcdi/NEWS

libcdi/README

libcdi/acinclude.m4

libcdi/aclocal.m4

libcdi/app

libcdi/app/Makefile.am

libcdi/app/Makefile.in

libcdi/app/cdi.c

libcdi/app/createtable.c

libcdi/app/printinfo.h

libcdi/cdi.settings.in

libcdi/config

libcdi/config/compile

libcdi/config/config.guess

libcdi/config/config.sub

libcdi/config/default

libcdi/config/depcomp

libcdi/config/install-sh

libcdi/config/ltmain.sh

libcdi/config/missing

libcdi/config/mkinstalldirs

libcdi/configure

libcdi/configure.ac

libcdi/doc

libcdi/examples

libcdi/examples/Makefile.am

libcdi/examples/Makefile.in

libcdi/examples/cdi_copy.c

libcdi/examples/cdi_read.c

libcdi/examples/cdi_read_f2003.f90

libcdi/examples/cdi_write.c

libcdi/examples/cdi_write_f2003.f90

libcdi/interfaces

libcdi/interfaces/CdiInfo.cpp

libcdi/interfaces/Makefile.am

libcdi/interfaces/Makefile.in

libcdi/interfaces/cdi.cpp

libcdi/interfaces/cdi.hpp

libcdi/interfaces/cdilib.i

libcdi/interfaces/cdiobj.i

libcdi/interfaces/python

libcdi/interfaces/python/cdilib_wrap.c

libcdi/interfaces/python/cdiobj_wrap.cpp

libcdi/interfaces/python/testLib.py

libcdi/interfaces/python/testObj.py

libcdi/interfaces/ruby

libcdi/interfaces/ruby/cdilib_wrap.c

libcdi/interfaces/ruby/cdiobj_wrap.cpp

libcdi/interfaces/ruby/testLib.rb

libcdi/interfaces/ruby/testObj.rb

libcdi/m4

libcdi/m4/acx_options.m4

libcdi/m4/acx_sl_mod_suffix.m4

libcdi/m4/libtool.m4

libcdi/m4/ltoptions.m4

libcdi/m4/ltsugar.m4

libcdi/m4/ltversion.m4

libcdi/m4/lt~obsolete.m4

libcdi/src

libcdi/src/Makefile.am

libcdi/src/Makefile.in

libcdi/src/basetime.c

libcdi/src/basetime.h

libcdi/src/binary.c

libcdi/src/binary.h

libcdi/src/calendar.c

libcdi/src/calendar.h

libcdi/src/cdf.c

libcdi/src/cdf.h

libcdi/src/cdf_int.c

libcdi/src/cdf_int.h

libcdi/src/cdi.h

libcdi/src/cdi.inc

libcdi/src/cdiFortran.c

libcdi/src/cdi_error.c

libcdi/src/cdi_limits.h

libcdi/src/cdi_util.c

libcdi/src/cfortran.doc

libcdi/src/cfortran.h

libcdi/src/cgribex.h

libcdi/src/cgribexlib.c

libcdi/src/config.h.in

libcdi/src/datetime.h

libcdi/src/dmemory.c

libcdi/src/dmemory.h

libcdi/src/dtypes.h

libcdi/src/error.c

libcdi/src/error.h

libcdi/src/extra.h

libcdi/src/extralib.c

libcdi/src/file.c

libcdi/src/file.h

libcdi/src/gaussgrid.c

libcdi/src/gaussgrid.h

libcdi/src/gribapi.c

libcdi/src/gribapi.h

libcdi/src/grid.c

libcdi/src/grid.h

libcdi/src/ieg.h

libcdi/src/ieglib.c

libcdi/src/institution.c

libcdi/src/make_cdilib

libcdi/src/mo_cdi.f90

libcdi/src/model.c

libcdi/src/service.h

libcdi/src/servicelib.c

libcdi/src/stream.c

libcdi/src/stream_cdf.c

libcdi/src/stream_cdf.h

libcdi/src/stream_cgribex.c

libcdi/src/stream_cgribex.h

libcdi/src/stream_ext.c

libcdi/src/stream_ext.h

libcdi/src/stream_grb.c

libcdi/src/stream_grb.h

libcdi/src/stream_gribapi.c

libcdi/src/stream_gribapi.h

libcdi/src/stream_history.c

libcdi/src/stream_ieg.c

libcdi/src/stream_ieg.h

libcdi/src/stream_int.c

libcdi/src/stream_int.h

libcdi/src/stream_record.c

libcdi/src/stream_srv.c

libcdi/src/stream_srv.h

libcdi/src/stream_var.c

libcdi/src/swap.c

libcdi/src/swap.h

libcdi/src/table.c

libcdi/src/table.h

libcdi/src/tablepar.h

libcdi/src/taxis.c

libcdi/src/taxis.h

libcdi/src/timebase.c

libcdi/src/timebase.h

libcdi/src/tsteps.c

libcdi/src/util.c

libcdi/src/varscan.c

libcdi/src/varscan.h

libcdi/src/version.c

libcdi/src/vlist.c

libcdi/src/vlist.h

libcdi/src/vlist_att.c

libcdi/src/vlist_var.c

libcdi/src/zaxis.c

libcdi/tests

libcdi/tests/Makefile.am

libcdi/tests/Makefile.in

libcdi/tests/test_grib.c

libcdi/tests/test_grib.sh

m4/acx_options.m4

m4/libtool.m4

m4/ltoptions.m4

m4/ltsugar.m4

m4/ltversion.m4

m4/lt~obsolete.m4

src/IFS2ICON.c

src/Ydayarith.c

files removed:
m4/ac_fc_freeform.m4

m4/ac_lang_program_fortran.m4

m4/acx_c_package.m4

m4/acx_fc_library_ldflags.m4

m4/acx_lang_c_check_include.m4

m4/acx_lang_check_include.m4

m4/acx_lang_fortran_check_include.m4

m4/acx_lang_package.m4

m4/acx_m4_generate_subsets.m4

m4/acx_option_search_libs.m4

m4/asx_tr_arg.m4

m4/asx_unset.m4

src/cdi.h

src/cdilib.c

files modified:
ChangeLog

Makefile.am

Makefile.in

NEWS

OPERATORS

acinclude.m4

aclocal.m4

cdo.spec

config/config.guess

config/config.sub

config/default

config/depcomp

config/install-sh

config/missing

configure

configure.ac

contrib/Makefile.am

contrib/Makefile.in

contrib/makecompl.rb

debian/changelog

debian/control

src/Arith.c

src/Arithc.c

src/Arithdays.c

src/Arithlat.c

src/CDItest.c

src/Cat.c

src/Change.c

src/Change_e5slm.c

src/Cloudlayer.c

src/Command.c

src/Comp.c

src/Compc.c

src/Complextorect.c

src/Cond.c

src/Cond2.c

src/Condc.c

src/Consecstat.c

src/Copy.c

src/Deltime.c

src/Detrend.c

src/Diff.c

src/EOFs.c

src/EcaIndices.c

src/Echam5ini.c

src/Enlarge.c

src/Enlargegrid.c

src/Ensstat.c

src/Eofcoeff.c

src/Exprf.c

src/Filedes.c

src/Fillmiss.c

src/Filter.c

src/Fldrms.c

src/Fldstat.c

src/Fldstat2.c

src/Fourier.c

src/Gather.c

src/Gengrid.c

src/Gradsdes.c

src/Gridboxstat.c

src/Gridcell.c

src/Harmonic.c

src/Hi.c

src/Histogram.c

src/Importamsr.c

src/Importbinary.c

src/Importcmsaf.c

src/Importobs.c

src/Info.c

src/Input.c

src/Intgrid.c

src/Intgridtraj.c

src/Intlevel.c

src/Intntime.c

src/Inttime.c

src/Intyear.c

src/Invert.c

src/Invertlev.c

src/Log.c

src/Makefile.am

src/Makefile.in

src/Maskbox.c

src/Mastrfu.c

src/Math.c

src/Merge.c

src/Mergegrid.c

src/Mergetime.c

src/Merstat.c

src/Monarith.c

src/Mrotuv.c

src/Mrotuvb.c

src/Ninfo.c

src/Nmltest.c

src/Output.c

src/Outputgmt.c

src/Pinfo.c

src/Pressure.c

src/Regres.c

src/Remap.c

src/Remapeta.c

src/Replace.c

src/Replacevalues.c

src/Rotuv.c

src/Runpctl.c

src/Runstat.c

src/Scatter.c

src/Seascount.c

src/Seaspctl.c

src/Seasstat.c

src/Selbox.c

src/Select.c

src/Seloperator.c

src/Selrec.c

src/Seltime.c

src/Selvar.c

src/Set.c

src/Setbox.c

src/Setgatt.c

src/Setgrid.c

src/Sethalo.c

src/Setmiss.c

src/Setrcaname.c

src/Settime.c

src/Setzaxis.c

src/Showinfo.c

src/Sinfo.c

src/Smooth9.c

src/Sort.c

src/Sorttimestamp.c

src/Specinfo.c

src/Spectral.c

src/Spectrum.c

src/Split.c

src/Splitrec.c

src/Splitsel.c

src/Splittime.c

src/Splityear.c

src/Subtrend.c

src/Templates.c

src/Test.c

src/Tests.c

src/Timcount.c

src/Timpctl.c

src/Timselpctl.c

src/Timselstat.c

src/Timsort.c

src/Timstat.c

src/Timstat2.c

src/Timstat3.c

src/Tinfo.c

src/Tocomplex.c

src/Transpose.c

src/Trend.c

src/Trms.c

src/Tstepcount.c

src/Vardup.c

src/Vargen.c

src/Varrms.c

src/Vertint.c

src/Vertstat.c

src/Vertwind.c

src/Wct.c

src/Wind.c

src/Writegrid.c

src/Writerandom.c

src/Ydaypctl.c

src/Ydaystat.c

src/Ydrunpctl.c

src/Ydrunstat.c

src/Yhourstat.c

src/Ymonarith.c

src/Ymonpctl.c

src/Ymonstat.c

src/Yseaspctl.c

src/Yseasstat.c

src/Zonstat.c

src/cdo.c

src/cdo.h

src/cdo_int.h

src/cdo_vlist.c

src/cdotest.c

src/color.c

src/config.h.in

src/ecacore.c

src/ecautil.c

src/ecautil.h

src/exception.c

src/expr.c

src/field.c

src/field.h

src/field2.c

src/fieldc.c

src/fieldmem.c

src/fieldmer.c

src/fieldzon.c

src/fouriertrans.c

src/functs.h

src/gradsdeslib.c

src/grid.c

src/grid.h

src/grid_gme.c

src/grid_lcc.c

src/griddes.c

src/griddes.h

src/griddes_h5.c

src/griddes_nc.c

src/hetaeta.c

src/history.c

src/institution.c

src/interpol.c

src/job.c

src/juldate.c

src/list.c

src/modules.c

src/namelist.c

src/namelist.h

src/normal.c

src/operator_help.h

src/percentiles.c

src/percentiles.h

src/pipe.c

src/printinfo.h

src/process.c

src/pstream.c

src/pthread_debug.c

src/remap.h

src/remaplib.c

src/specspace.c

src/statistic.c

src/statistic.h

src/table.c

src/userlog.c

src/util.c

src/util.h

src/zaxis.c

Show diffs side-by-side

added added

removed removed

libcdi/interfaces/ruby/cdilib_wrap.c

/* ----------------------------------------------------------------------------

* This file was automatically generated by SWIG (http://www.swig.org).

* Version 1.3.36

* This file is not intended to be easily readable and contains a number of

* coding conventions designed to improve portability and efficiency. Do not make

* changes to this file unless you know what you are doing--modify the SWIG

* interface file instead.

* ----------------------------------------------------------------------------- */

#define SWIGRUBY

/* -----------------------------------------------------------------------------

* This section contains generic SWIG labels for method/variable

* declarations/attributes, and other compiler dependent labels.

* ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */

#ifndef SWIGTEMPLATEDISAMBIGUATOR

# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)

# define SWIGTEMPLATEDISAMBIGUATOR template

# elif defined(__HP_aCC)

/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */

/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */

# define SWIGTEMPLATEDISAMBIGUATOR template

# else

# define SWIGTEMPLATEDISAMBIGUATOR

# endif

#endif

/* inline attribute */

#ifndef SWIGINLINE

# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))

# define SWIGINLINE inline

# else

# define SWIGINLINE

# endif

#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */

#ifndef SWIGUNUSED

# if defined(__GNUC__)

# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))

# define SWIGUNUSED __attribute__ ((__unused__))

# else

# define SWIGUNUSED

# endif

# elif defined(__ICC)

# define SWIGUNUSED __attribute__ ((__unused__))

# else

# define SWIGUNUSED

# endif

#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505

# if defined(_MSC_VER)

# pragma warning(disable : 4505) /* unreferenced local function has been removed */

# endif

#endif

#ifndef SWIGUNUSEDPARM

# ifdef __cplusplus

# define SWIGUNUSEDPARM(p)

# else

# define SWIGUNUSEDPARM(p) p SWIGUNUSED

# endif

#endif

/* internal SWIG method */

#ifndef SWIGINTERN

# define SWIGINTERN static SWIGUNUSED

#endif

/* internal inline SWIG method */

#ifndef SWIGINTERNINLINE

# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE

#endif

/* exporting methods */

#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)

# ifndef GCC_HASCLASSVISIBILITY

# define GCC_HASCLASSVISIBILITY

# endif

#endif

#ifndef SWIGEXPORT

# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

# if defined(STATIC_LINKED)

# define SWIGEXPORT

# else

# define SWIGEXPORT __declspec(dllexport)

# endif

# else

# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)

# define SWIGEXPORT __attribute__ ((visibility("default")))

# else

# define SWIGEXPORT

# endif

#endif

100

101

/* calling conventions for Windows */

102

#ifndef SWIGSTDCALL

103

# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

104

# define SWIGSTDCALL __stdcall

105

# else

106

# define SWIGSTDCALL

107

# endif

108

#endif

109

110

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */

111

#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)

112

# define _CRT_SECURE_NO_DEPRECATE

113

#endif

114

115

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */

116

#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)

117

# define _SCL_SECURE_NO_DEPRECATE

118

#endif

119

120

121

/* -----------------------------------------------------------------------------

122

* This section contains generic SWIG labels for method/variable

123

* declarations/attributes, and other compiler dependent labels.

124

* ----------------------------------------------------------------------------- */

125

126

/* template workaround for compilers that cannot correctly implement the C++ standard */

127

#ifndef SWIGTEMPLATEDISAMBIGUATOR

128

# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)

129

# define SWIGTEMPLATEDISAMBIGUATOR template

130

# elif defined(__HP_aCC)

131

/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */

132

/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */

133

# define SWIGTEMPLATEDISAMBIGUATOR template

134

# else

135

# define SWIGTEMPLATEDISAMBIGUATOR

136

# endif

137

#endif

138

139

/* inline attribute */

140

#ifndef SWIGINLINE

141

# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))

142

# define SWIGINLINE inline

143

# else

144

# define SWIGINLINE

145

# endif

146

#endif

147

148

/* attribute recognised by some compilers to avoid 'unused' warnings */

149

#ifndef SWIGUNUSED

150

# if defined(__GNUC__)

151

# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))

152

# define SWIGUNUSED __attribute__ ((__unused__))

153

# else

154

# define SWIGUNUSED

155

# endif

156

# elif defined(__ICC)

157

# define SWIGUNUSED __attribute__ ((__unused__))

158

# else

159

# define SWIGUNUSED

160

# endif

161

#endif

162

163

#ifndef SWIG_MSC_UNSUPPRESS_4505

164

# if defined(_MSC_VER)

165

# pragma warning(disable : 4505) /* unreferenced local function has been removed */

166

# endif

167

#endif

168

169

#ifndef SWIGUNUSEDPARM

170

# ifdef __cplusplus

171

# define SWIGUNUSEDPARM(p)

172

# else

173

# define SWIGUNUSEDPARM(p) p SWIGUNUSED

174

# endif

175

#endif

176

177

/* internal SWIG method */

178

#ifndef SWIGINTERN

179

# define SWIGINTERN static SWIGUNUSED

180

#endif

181

182

/* internal inline SWIG method */

183

#ifndef SWIGINTERNINLINE

184

# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE

185

#endif

186

187

/* exporting methods */

188

#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)

189

# ifndef GCC_HASCLASSVISIBILITY

190

# define GCC_HASCLASSVISIBILITY

191

# endif

192

#endif

193

194

#ifndef SWIGEXPORT

195

# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

196

# if defined(STATIC_LINKED)

197

# define SWIGEXPORT

198

# else

199

# define SWIGEXPORT __declspec(dllexport)

200

# endif

201

# else

202

# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)

203

# define SWIGEXPORT __attribute__ ((visibility("default")))

204

# else

205

# define SWIGEXPORT

206

# endif

207

# endif

208

#endif

209

210

/* calling conventions for Windows */

211

#ifndef SWIGSTDCALL

212

# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)

213

# define SWIGSTDCALL __stdcall

214

# else

215

# define SWIGSTDCALL

216

# endif

217

#endif

218

219

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */

220

#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)

221

# define _CRT_SECURE_NO_DEPRECATE

222

#endif

223

224

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */

225

#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)

226

# define _SCL_SECURE_NO_DEPRECATE

227

#endif

228

229

230

/* -----------------------------------------------------------------------------

231

* swigrun.swg

232

233

* This file contains generic CAPI SWIG runtime support for pointer

234

* type checking.

235

* ----------------------------------------------------------------------------- */

236

237

/* This should only be incremented when either the layout of swig_type_info changes,

238

or for whatever reason, the runtime changes incompatibly */

239

#define SWIG_RUNTIME_VERSION "4"

240

241

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */

242

#ifdef SWIG_TYPE_TABLE

243

# define SWIG_QUOTE_STRING(x) #x

244

# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)

245

# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)

246

#else

247

# define SWIG_TYPE_TABLE_NAME

248

#endif

249

250

251

You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for

252

creating a static or dynamic library from the swig runtime code.

253

In 99.9% of the cases, swig just needs to declare them as 'static'.

254

255

But only do this if is strictly necessary, ie, if you have problems

256

with your compiler or so.

257

258

259

#ifndef SWIGRUNTIME

260

# define SWIGRUNTIME SWIGINTERN

261

#endif

262

263

#ifndef SWIGRUNTIMEINLINE

264

# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE

265

#endif

266

267

/* Generic buffer size */

268

#ifndef SWIG_BUFFER_SIZE

269

# define SWIG_BUFFER_SIZE 1024

270

#endif

271

272

/* Flags for pointer conversions */

273

#define SWIG_POINTER_DISOWN 0x1

274

#define SWIG_CAST_NEW_MEMORY 0x2

275

276

/* Flags for new pointer objects */

277

#define SWIG_POINTER_OWN 0x1

278

279

280

281

Flags/methods for returning states.

282

283

The swig conversion methods, as ConvertPtr, return and integer

284

that tells if the conversion was successful or not. And if not,

285

an error code can be returned (see swigerrors.swg for the codes).

286

287

Use the following macros/flags to set or process the returning

288

states.

289

290

In old swig versions, you usually write code as:

291

292

if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {

293

// success code

294

} else {

295

//fail code

296

}

297

298

Now you can be more explicit as:

299

300

int res = SWIG_ConvertPtr(obj,vptr,ty.flags);

301

if (SWIG_IsOK(res)) {

302

// success code

303

} else {

304

// fail code

305

}

306

307

that seems to be the same, but now you can also do

308

309

Type *ptr;

310

int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);

311

if (SWIG_IsOK(res)) {

312

// success code

313

if (SWIG_IsNewObj(res) {

314

...

315

delete *ptr;

316

} else {

317

...

318

}

319

} else {

320

// fail code

321

}

322

323

I.e., now SWIG_ConvertPtr can return new objects and you can

324

identify the case and take care of the deallocation. Of course that

325

requires also to SWIG_ConvertPtr to return new result values, as

326

327

int SWIG_ConvertPtr(obj, ptr,...) {

328

if (<obj is ok>) {

329

if (<need new object>) {

330

*ptr = <ptr to new allocated object>;

331

return SWIG_NEWOBJ;

332

} else {

333

*ptr = <ptr to old object>;

334

return SWIG_OLDOBJ;

335

}

336

} else {

337

return SWIG_BADOBJ;

338

}

339

}

340

341

Of course, returning the plain '0(success)/-1(fail)' still works, but you can be

342

more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the

343

swig errors code.

344

345

Finally, if the SWIG_CASTRANK_MODE is enabled, the result code

346

allows to return the 'cast rank', for example, if you have this

347

348

int food(double)

349

int fooi(int);

350

351

and you call

352

353

food(1) // cast rank '1' (1 -> 1.0)

354

fooi(1) // cast rank '0'

355

356

just use the SWIG_AddCast()/SWIG_CheckState()

357

358

359

360

#define SWIG_OK (0)

361

#define SWIG_ERROR (-1)

362

#define SWIG_IsOK(r) (r >= 0)

363

#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)

364

365

/* The CastRankLimit says how many bits are used for the cast rank */

366

#define SWIG_CASTRANKLIMIT (1 << 8)

367

/* The NewMask denotes the object was created (using new/malloc) */

368

#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)

369

/* The TmpMask is for in/out typemaps that use temporal objects */

370

#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)

371

/* Simple returning values */

372

#define SWIG_BADOBJ (SWIG_ERROR)

373

#define SWIG_OLDOBJ (SWIG_OK)

374

#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)

375

#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)

376

/* Check, add and del mask methods */

377

#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)

378

#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)

379

#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))

380

#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)

381

#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)

382

#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

383

384

385

/* Cast-Rank Mode */

386

#if defined(SWIG_CASTRANK_MODE)

387

# ifndef SWIG_TypeRank

388

# define SWIG_TypeRank unsigned long

389

# endif

390

# ifndef SWIG_MAXCASTRANK /* Default cast allowed */

391

# define SWIG_MAXCASTRANK (2)

392

# endif

393

# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)

394

# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)

395

SWIGINTERNINLINE int SWIG_AddCast(int r) {

396

return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;

397

}

398

SWIGINTERNINLINE int SWIG_CheckState(int r) {

399

return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;

400

}

401

#else /* no cast-rank mode */

402

# define SWIG_AddCast

403

# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)

404

#endif

405

406

407

408

409

#include <string.h>

410

411

#ifdef __cplusplus

412

extern "C" {

413

#endif

414

415

typedef void *(*swig_converter_func)(void *, int *);

416

typedef struct swig_type_info *(*swig_dycast_func)(void **);

417

418

/* Structure to store information on one type */

419

typedef struct swig_type_info {

420

const char *name; /* mangled name of this type */

421

const char *str; /* human readable name of this type */

422

swig_dycast_func dcast; /* dynamic cast function down a hierarchy */

423

struct swig_cast_info *cast; /* linked list of types that can cast into this type */

424

void *clientdata; /* language specific type data */

425

int owndata; /* flag if the structure owns the clientdata */

426

} swig_type_info;

427

428

/* Structure to store a type and conversion function used for casting */

429

typedef struct swig_cast_info {

430

swig_type_info *type; /* pointer to type that is equivalent to this type */

431

swig_converter_func converter; /* function to cast the void pointers */

432

struct swig_cast_info *next; /* pointer to next cast in linked list */

433

struct swig_cast_info *prev; /* pointer to the previous cast */

434

} swig_cast_info;

435

436

/* Structure used to store module information

437

* Each module generates one structure like this, and the runtime collects

438

* all of these structures and stores them in a circularly linked list.*/

439

typedef struct swig_module_info {

440

swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */

441

size_t size; /* Number of types in this module */

442

struct swig_module_info *next; /* Pointer to next element in circularly linked list */

443

swig_type_info **type_initial; /* Array of initially generated type structures */

444

swig_cast_info **cast_initial; /* Array of initially generated casting structures */

445

void *clientdata; /* Language specific module data */

446

} swig_module_info;

447

448

449

Compare two type names skipping the space characters, therefore

450

"char*" == "char *" and "Class<int>" == "Class<int >", etc.

451

452

Return 0 when the two name types are equivalent, as in

453

strncmp, but skipping ' '.

454

455

SWIGRUNTIME int

456

SWIG_TypeNameComp(const char *f1, const char *l1,

457

const char *f2, const char *l2) {

458

for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {

459

while ((*f1 == ' ') && (f1 != l1)) ++f1;

460

while ((*f2 == ' ') && (f2 != l2)) ++f2;

461

if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;

462

}

463

return (int)((l1 - f1) - (l2 - f2));

464

}

465

466

467

Check type equivalence in a name list like <name1>|<name2>|...

468

Return 0 if not equal, 1 if equal

469

470

SWIGRUNTIME int

471

SWIG_TypeEquiv(const char *nb, const char *tb) {

472

int equiv = 0;

473

const char* te = tb + strlen(tb);

474

const char* ne = nb;

475

while (!equiv && *ne) {

476

for (nb = ne; *ne; ++ne) {

477

if (*ne == '|') break;

478

}

479

equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;

480

if (*ne) ++ne;

481

}

482

return equiv;

483

}

484

485

486

Check type equivalence in a name list like <name1>|<name2>|...

487

Return 0 if equal, -1 if nb < tb, 1 if nb > tb

488

489

SWIGRUNTIME int

490

SWIG_TypeCompare(const char *nb, const char *tb) {

491

int equiv = 0;

492

const char* te = tb + strlen(tb);

493

const char* ne = nb;

494

while (!equiv && *ne) {

495

for (nb = ne; *ne; ++ne) {

496

if (*ne == '|') break;

497

}

498

equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;

499

if (*ne) ++ne;

500

}

501

return equiv;

502

}

503

504

505

/* think of this as a c++ template<> or a scheme macro */

506

#define SWIG_TypeCheck_Template(comparison, ty) \

507

if (ty) { \

508

swig_cast_info *iter = ty->cast; \

509

while (iter) { \

510

if (comparison) { \

511

if (iter == ty->cast) return iter; \

512

/* Move iter to the top of the linked list */ \

513

iter->prev->next = iter->next; \

514

if (iter->next) \

515

iter->next->prev = iter->prev; \

516

iter->next = ty->cast; \

517

iter->prev = 0; \

518

if (ty->cast) ty->cast->prev = iter; \

519

ty->cast = iter; \

520

return iter; \

521

} \

522

iter = iter->next; \

523

} \

524

} \

525

return 0

526

527

528

Check the typename

529

530

SWIGRUNTIME swig_cast_info *

531

SWIG_TypeCheck(const char *c, swig_type_info *ty) {

532

SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);

533

}

534

535

/* Same as previous function, except strcmp is replaced with a pointer comparison */

536

SWIGRUNTIME swig_cast_info *

537

SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {

538

SWIG_TypeCheck_Template(iter->type == from, into);

539

}

540

541

542

Cast a pointer up an inheritance hierarchy

543

544

SWIGRUNTIMEINLINE void *

545

SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {

546

return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);

547

}

548

549

550

Dynamic pointer casting. Down an inheritance hierarchy

551

552

SWIGRUNTIME swig_type_info *

553

SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {

554

swig_type_info *lastty = ty;

555

if (!ty || !ty->dcast) return ty;

556

while (ty && (ty->dcast)) {

557

ty = (*ty->dcast)(ptr);

558

if (ty) lastty = ty;

559

}

560

return lastty;

561

}

562

563

564

Return the name associated with this type

565

566

SWIGRUNTIMEINLINE const char *

567

SWIG_TypeName(const swig_type_info *ty) {

568

return ty->name;

569

}

570

571

572

Return the pretty name associated with this type,

573

that is an unmangled type name in a form presentable to the user.

574

575

SWIGRUNTIME const char *

576

SWIG_TypePrettyName(const swig_type_info *type) {

577

/* The "str" field contains the equivalent pretty names of the

578

type, separated by vertical-bar characters. We choose

579

to print the last name, as it is often (?) the most

580

specific. */

581

if (!type) return NULL;

582

if (type->str != NULL) {

583

const char *last_name = type->str;

584

const char *s;

585

for (s = type->str; *s; s++)

586

if (*s == '|') last_name = s+1;

587

return last_name;

588

}

589

else

590

return type->name;

591

}

592

593

594

Set the clientdata field for a type

595

596

SWIGRUNTIME void

597

SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {

598

swig_cast_info *cast = ti->cast;

599

/* if (ti->clientdata == clientdata) return; */

600

ti->clientdata = clientdata;

601

602

while (cast) {

603

if (!cast->converter) {

604

swig_type_info *tc = cast->type;

605

if (!tc->clientdata) {

606

SWIG_TypeClientData(tc, clientdata);

607

}

608

}

609

cast = cast->next;

610

}

611

}

612

SWIGRUNTIME void

613

SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {

614

SWIG_TypeClientData(ti, clientdata);

615

ti->owndata = 1;

616

}

617

618

619

Search for a swig_type_info structure only by mangled name

620

Search is a O(log #types)

621

622

We start searching at module start, and finish searching when start == end.

623

Note: if start == end at the beginning of the function, we go all the way around

624

the circular list.

625

626

SWIGRUNTIME swig_type_info *

627

SWIG_MangledTypeQueryModule(swig_module_info *start,

628

swig_module_info *end,

629

const char *name) {

630

swig_module_info *iter = start;

631

do {

632

if (iter->size) {

633

634

635

do {

636

/* since l+r >= 0, we can (>> 1) instead (/ 2) */

637

638

const char *iname = iter->types[i]->name;

639

if (iname) {

640

641

if (compare == 0) {

642

return iter->types[i];

643

} else if (compare < 0) {

644

if (i) {

645

r = i - 1;

646

} else {

647

break;

648

}

649

} else if (compare > 0) {

650

l = i + 1;

651

}

652

} else {

653

break; /* should never happen */

654

}

655

} while (l <= r);

656

}

657

iter = iter->next;

658

} while (iter != end);

659

return 0;

660

}

661

662

663

Search for a swig_type_info structure for either a mangled name or a human readable name.

664

It first searches the mangled names of the types, which is a O(log #types)

665

If a type is not found it then searches the human readable names, which is O(#types).

666

667

We start searching at module start, and finish searching when start == end.

668

Note: if start == end at the beginning of the function, we go all the way around

669

the circular list.

670

671

SWIGRUNTIME swig_type_info *

672

SWIG_TypeQueryModule(swig_module_info *start,

673

swig_module_info *end,

674

const char *name) {

675

/* STEP 1: Search the name field using binary search */

676

swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);

677

if (ret) {

678

return ret;

679

} else {

680

/* STEP 2: If the type hasn't been found, do a complete search

681

of the str field (the human readable name) */

682

swig_module_info *iter = start;

683

do {

684

685

for (; i < iter->size; ++i) {

686

if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))

687

return iter->types[i];

688

}

689

iter = iter->next;

690

} while (iter != end);

691

}

692

693

/* neither found a match */

694

return 0;

695

}

696

697

698

Pack binary data into a string

699

700

SWIGRUNTIME char *

701

SWIG_PackData(char *c, void *ptr, size_t sz) {

702

static const char hex[17] = "0123456789abcdef";

703

704

705

for (; u != eu; ++u) {

706

707

*(c++) = hex[(uu & 0xf0) >> 4];

708

*(c++) = hex[uu & 0xf];

709

}

710

return c;

711

}

712

713

714

Unpack binary data from a string

715

716

SWIGRUNTIME const char *

717

SWIG_UnpackData(const char *c, void *ptr, size_t sz) {

718

719

720

for (; u != eu; ++u) {

721

722

723

if ((d >= '0') && (d <= '9'))

724

uu = ((d - '0') << 4);

725

else if ((d >= 'a') && (d <= 'f'))

726

uu = ((d - ('a'-10)) << 4);

727

else

728

return (char *) 0;

729

d = *(c++);

730

if ((d >= '0') && (d <= '9'))

731

uu |= (d - '0');

732

else if ((d >= 'a') && (d <= 'f'))

733

uu |= (d - ('a'-10));

734

else

735

return (char *) 0;

736

*u = uu;

737

}

738

return c;

739

}

740

741

742

Pack 'void *' into a string buffer.

743

744

SWIGRUNTIME char *

745

SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {

746

char *r = buff;

747

if ((2*sizeof(void *) + 2) > bsz) return 0;

748

*(r++) = '_';

749

r = SWIG_PackData(r,&ptr,sizeof(void *));

750

if (strlen(name) + 1 > (bsz - (r - buff))) return 0;

751

strcpy(r,name);

752

return buff;

753

}

754

755

SWIGRUNTIME const char *

756

SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {

757

if (*c != '_') {

758

if (strcmp(c,"NULL") == 0) {

759

*ptr = (void *) 0;

760

return name;

761

} else {

762

return 0;

763

}

764

}

765

return SWIG_UnpackData(++c,ptr,sizeof(void *));

766

}

767

768

SWIGRUNTIME char *

769

SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {

770

char *r = buff;

771

size_t lname = (name ? strlen(name) : 0);

772

if ((2*sz + 2 + lname) > bsz) return 0;

773

*(r++) = '_';

774

r = SWIG_PackData(r,ptr,sz);

775

if (lname) {

776

strncpy(r,name,lname+1);

777

} else {

778

*r = 0;

779

}

780

return buff;

781

}

782

783

SWIGRUNTIME const char *

784

SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {

785

if (*c != '_') {

786

if (strcmp(c,"NULL") == 0) {

787

memset(ptr,0,sz);

788

return name;

789

} else {

790

return 0;

791

}

792

}

793

return SWIG_UnpackData(++c,ptr,sz);

794

}

795

796

#ifdef __cplusplus

797

}

798

#endif

799

800

/* Errors in SWIG */

801

#define SWIG_UnknownError -1

802

#define SWIG_IOError -2

803

#define SWIG_RuntimeError -3

804

#define SWIG_IndexError -4

805

#define SWIG_TypeError -5

806

#define SWIG_DivisionByZero -6

807

#define SWIG_OverflowError -7

808

#define SWIG_SyntaxError -8

809

#define SWIG_ValueError -9

810

#define SWIG_SystemError -10

811

#define SWIG_AttributeError -11

812

#define SWIG_MemoryError -12

813

#define SWIG_NullReferenceError -13

814

815

816

817

#include <ruby.h>

818

819

/* Remove global macros defined in Ruby's win32.h */

820

#ifdef write

821

# undef write

822

#endif

823

#ifdef read

824

# undef read

825

#endif

826

827

828

/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */

829

#ifndef NUM2LL

830

#define NUM2LL(x) NUM2LONG((x))

831

#endif

832

#ifndef LL2NUM

833

#define LL2NUM(x) INT2NUM((long) (x))

834

#endif

835

#ifndef ULL2NUM

836

#define ULL2NUM(x) UINT2NUM((unsigned long) (x))

837

#endif

838

839

/* Ruby 1.7 doesn't (yet) define NUM2ULL() */

840

#ifndef NUM2ULL

841

#ifdef HAVE_LONG_LONG

842

#define NUM2ULL(x) rb_num2ull((x))

843

#else

844

#define NUM2ULL(x) NUM2ULONG(x)

845

#endif

846

#endif

847

848

/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */

849

/* Define these for older versions so we can just write code the new way */

850

#ifndef RSTRING_LEN

851

# define RSTRING_LEN(x) RSTRING(x)->len

852

#endif

853

#ifndef RSTRING_PTR

854

# define RSTRING_PTR(x) RSTRING(x)->ptr

855

#endif

856

#ifndef RSTRING_END

857

# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))

858

#endif

859

#ifndef RARRAY_LEN

860

# define RARRAY_LEN(x) RARRAY(x)->len

861

#endif

862

#ifndef RARRAY_PTR

863

# define RARRAY_PTR(x) RARRAY(x)->ptr

864

#endif

865

#ifndef RFLOAT_VALUE

866

# define RFLOAT_VALUE(x) RFLOAT(x)->value

867

#endif

868

#ifndef DOUBLE2NUM

869

# define DOUBLE2NUM(x) rb_float_new(x)

870

#endif

871

#ifndef RHASH_TBL

872

# define RHASH_TBL(x) (RHASH(x)->tbl)

873

#endif

874

#ifndef RHASH_ITER_LEV

875

# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)

876

#endif

877

#ifndef RHASH_IFNONE

878

# define RHASH_IFNONE(x) (RHASH(x)->ifnone)

879

#endif

880

#ifndef RHASH_SIZE

881

# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)

882

#endif

883

#ifndef RHASH_EMPTY_P

884

# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)

885

#endif

886

#ifndef RSTRUCT_LEN

887

# define RSTRUCT_LEN(x) RSTRUCT(x)->len

888

#endif

889

#ifndef RSTRUCT_PTR

890

# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr

891

#endif

892

893

894

895

896

* Need to be very careful about how these macros are defined, especially

897

* when compiling C++ code or C code with an ANSI C compiler.

898

899

* VALUEFUNC(f) is a macro used to typecast a C function that implements

900

* a Ruby method so that it can be passed as an argument to API functions

901

* like rb_define_method() and rb_define_singleton_method().

902

903

* VOIDFUNC(f) is a macro used to typecast a C function that implements

904

* either the "mark" or "free" stuff for a Ruby Data object, so that it

905

* can be passed as an argument to API functions like Data_Wrap_Struct()

906

* and Data_Make_Struct().

907

908

909

#ifdef __cplusplus

910

# ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */

911

# define PROTECTFUNC(f) ((VALUE (*)()) f)

912

# define VALUEFUNC(f) ((VALUE (*)()) f)

913

# define VOIDFUNC(f) ((void (*)()) f)

914

# else

915

# ifndef ANYARGS /* These definitions should work for Ruby 1.6 */

916

# define PROTECTFUNC(f) ((VALUE (*)()) f)

917

# define VALUEFUNC(f) ((VALUE (*)()) f)

918

# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)

919

# else /* These definitions should work for Ruby 1.7+ */

920

# define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)

921

# define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)

922

# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)

923

# endif

924

# endif

925

#else

926

# define VALUEFUNC(f) (f)

927

# define VOIDFUNC(f) (f)

928

#endif

929

930

/* Don't use for expressions have side effect */

931

#ifndef RB_STRING_VALUE

932

#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))

933

#endif

934

#ifndef StringValue

935

#define StringValue(s) RB_STRING_VALUE(s)

936

#endif

937

#ifndef StringValuePtr

938

#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))

939

#endif

940

#ifndef StringValueLen

941

#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))

942

#endif

943

#ifndef SafeStringValue

944

#define SafeStringValue(v) do {\

945

StringValue(v);\

946

rb_check_safe_str(v);\

947

} while (0)

948

#endif

949

950

#ifndef HAVE_RB_DEFINE_ALLOC_FUNC

951

#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)

952

#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")

953

#endif

954

955

static VALUE _mSWIG = Qnil;

956

957

/* -----------------------------------------------------------------------------

958

* error manipulation

959

* ----------------------------------------------------------------------------- */

960

961

962

/* Define some additional error types */

963

#define SWIG_ObjectPreviouslyDeletedError -100

964

965

966

/* Define custom exceptions for errors that do not map to existing Ruby

967

exceptions. Note this only works for C++ since a global cannot be

968

initialized by a funtion in C. For C, fallback to rb_eRuntimeError.*/

969

970

SWIGINTERN VALUE

971

getNullReferenceError(void) {

972

static int init = 0;

973

static VALUE rb_eNullReferenceError ;

974

if (!init) {

975

init = 1;

976

rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);

977

}

978

return rb_eNullReferenceError;

979

}

980

981

SWIGINTERN VALUE

982

getObjectPreviouslyDeletedError(void) {

983

static int init = 0;

984

static VALUE rb_eObjectPreviouslyDeleted ;

985

if (!init) {

986

init = 1;

987

rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);

988

}

989

return rb_eObjectPreviouslyDeleted;

990

}

991

992

993

SWIGINTERN VALUE

994

SWIG_Ruby_ErrorType(int SWIG_code) {

995

VALUE type;

996

switch (SWIG_code) {

997

case SWIG_MemoryError:

998

type = rb_eNoMemError;

999

break;

1000

case SWIG_IOError:

1001

type = rb_eIOError;

1002

break;

1003

case SWIG_RuntimeError:

1004

type = rb_eRuntimeError;

1005

break;

1006

case SWIG_IndexError:

1007

type = rb_eIndexError;

1008

break;

1009

case SWIG_TypeError:

1010

type = rb_eTypeError;

1011

break;

1012

case SWIG_DivisionByZero:

1013

type = rb_eZeroDivError;

1014

break;

1015

case SWIG_OverflowError:

1016

type = rb_eRangeError;

1017

break;

1018

case SWIG_SyntaxError:

1019

type = rb_eSyntaxError;

1020

break;

1021

case SWIG_ValueError:

1022

type = rb_eArgError;

1023

break;

1024

case SWIG_SystemError:

1025

type = rb_eFatal;

1026

break;

1027

case SWIG_AttributeError:

1028

type = rb_eRuntimeError;

1029

break;

1030

case SWIG_NullReferenceError:

1031

type = getNullReferenceError();

1032

break;

1033

case SWIG_ObjectPreviouslyDeletedError:

1034

type = getObjectPreviouslyDeletedError();

1035

break;

1036

case SWIG_UnknownError:

1037

type = rb_eRuntimeError;

1038

break;

1039

default:

1040

type = rb_eRuntimeError;

1041

}

1042

return type;

1043

}

1044

1045

1046

/* This function is called when a user inputs a wrong argument to

1047

a method.

1048

1049

SWIGINTERN

1050

const char* Ruby_Format_TypeError( const char* msg,

1051

const char* type,

1052

const char* name,

1053

const int argn,

1054

VALUE input )

1055

{

1056

char buf[128];

1057

VALUE str;

1058

VALUE asStr;

1059

if ( msg && *msg )

1060

{

1061

str = rb_str_new2(msg);

1062

}

1063

else

1064

{

1065

str = rb_str_new(NULL, 0);

1066

}

1067

1068

str = rb_str_cat2( str, "Expected argument " );

1069

sprintf( buf, "%d of type ", argn-1 );

1070

str = rb_str_cat2( str, buf );

1071

str = rb_str_cat2( str, type );

1072

str = rb_str_cat2( str, ", but got " );

1073

str = rb_str_cat2( str, rb_obj_classname(input) );

1074

str = rb_str_cat2( str, " " );

1075

asStr = rb_inspect(input);

1076

if ( RSTRING_LEN(asStr) > 30 )

1077

{

1078

str = rb_str_cat( str, StringValuePtr(asStr), 30 );

1079

str = rb_str_cat2( str, "..." );

1080

}

1081

else

1082

{

1083

str = rb_str_append( str, asStr );

1084

}

1085

1086

if ( name )

1087

{

1088

str = rb_str_cat2( str, "\n\tin SWIG method '" );

1089

str = rb_str_cat2( str, name );

1090

str = rb_str_cat2( str, "'" );

1091

}

1092

1093

return StringValuePtr( str );

1094

}

1095

1096

/* This function is called when an overloaded method fails */

1097

SWIGINTERN

1098

void Ruby_Format_OverloadedError(

1099

const int argc,

1100

const int maxargs,

1101

const char* method,

1102

const char* prototypes

1103

)

1104

{

1105

const char* msg = "Wrong # of arguments";

1106

if ( argc <= maxargs ) msg = "Wrong arguments";

1107

rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"

1108

"Possible C/C++ prototypes are:\n%s",

1109

msg, method, prototypes);

1110

}

1111

1112

/* -----------------------------------------------------------------------------

1113

* See the LICENSE file for information on copyright, usage and redistribution

1114

* of SWIG, and the README file for authors - http://www.swig.org/release.html.

1115

1116

* rubytracking.swg

1117

1118

* This file contains support for tracking mappings from

1119

* Ruby objects to C++ objects. This functionality is needed

1120

* to implement mark functions for Ruby's mark and sweep

1121

* garbage collector.

1122

* ----------------------------------------------------------------------------- */

1123

1124

#ifdef __cplusplus

1125

extern "C" {

1126

#endif

1127

1128

/* Ruby 1.8 actually assumes the first case. */

1129

#if SIZEOF_VOIDP == SIZEOF_LONG

1130

# define SWIG2NUM(v) LONG2NUM((unsigned long)v)

1131

# define NUM2SWIG(x) (unsigned long)NUM2LONG(x)

1132

#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG

1133

# define SWIG2NUM(v) LL2NUM((unsigned long long)v)

1134

# define NUM2SWIG(x) (unsigned long long)NUM2LL(x)

1135

#else

1136

# error sizeof(void*) is not the same as long or long long

1137

#endif

1138

1139

1140

/* Global Ruby hash table to store Trackings from C/C++

1141

structs to Ruby Objects.

1142

1143

static VALUE swig_ruby_trackings = Qnil;

1144

1145

/* Global variable that stores a reference to the ruby

1146

hash table delete function. */

1147

static ID swig_ruby_hash_delete;

1148

1149

/* Setup a Ruby hash table to store Trackings */

1150

SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {

1151

/* Create a ruby hash table to store Trackings from C++

1152

objects to Ruby objects. */

1153

1154

/* Try to see if some other .so has already created a

1155

tracking hash table, which we keep hidden in an instance var

1156

in the SWIG module.

1157

This is done to allow multiple DSOs to share the same

1158

tracking table.

1159

1160

ID trackings_id = rb_intern( "@__trackings__" );

1161

VALUE verbose = rb_gv_get("VERBOSE");

1162

rb_gv_set("VERBOSE", Qfalse);

1163

swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );

1164

rb_gv_set("VERBOSE", verbose);

1165

1166

/* No, it hasn't. Create one ourselves */

1167

if ( swig_ruby_trackings == Qnil )

1168

{

1169

swig_ruby_trackings = rb_hash_new();

1170

rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );

1171

}

1172

1173

/* Now store a reference to the hash table delete function

1174

so that we only have to look it up once.*/

1175

swig_ruby_hash_delete = rb_intern("delete");

1176

}

1177

1178

/* Get a Ruby number to reference a pointer */

1179

SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {

1180

/* We cast the pointer to an unsigned long

1181

and then store a reference to it using

1182

a Ruby number object. */

1183

1184

/* Convert the pointer to a Ruby number */

1185

return SWIG2NUM(ptr);

1186

}

1187

1188

/* Get a Ruby number to reference an object */

1189

SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {

1190

/* We cast the object to an unsigned long

1191

and then store a reference to it using

1192

a Ruby number object. */

1193

1194

/* Convert the Object to a Ruby number */

1195

return SWIG2NUM(object);

1196

}

1197

1198

/* Get a Ruby object from a previously stored reference */

1199

SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {

1200

/* The provided Ruby number object is a reference

1201

to the Ruby object we want.*/

1202

1203

/* Convert the Ruby number to a Ruby object */

1204

return NUM2SWIG(reference);

1205

}

1206

1207

/* Add a Tracking from a C/C++ struct to a Ruby object */

1208

SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {

1209

/* In a Ruby hash table we store the pointer and

1210

the associated Ruby object. The trick here is

1211

that we cannot store the Ruby object directly - if

1212

we do then it cannot be garbage collected. So

1213

instead we typecast it as a unsigned long and

1214

convert it to a Ruby number object.*/

1215

1216

/* Get a reference to the pointer as a Ruby number */

1217

VALUE key = SWIG_RubyPtrToReference(ptr);

1218

1219

/* Get a reference to the Ruby object as a Ruby number */

1220

VALUE value = SWIG_RubyObjectToReference(object);

1221

1222

/* Store the mapping to the global hash table. */

1223

rb_hash_aset(swig_ruby_trackings, key, value);

1224

}

1225

1226

/* Get the Ruby object that owns the specified C/C++ struct */

1227

SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {

1228

/* Get a reference to the pointer as a Ruby number */

1229

VALUE key = SWIG_RubyPtrToReference(ptr);

1230

1231

/* Now lookup the value stored in the global hash table */

1232

VALUE value = rb_hash_aref(swig_ruby_trackings, key);

1233

1234

if (value == Qnil) {

1235

/* No object exists - return nil. */

1236

return Qnil;

1237

}

1238

else {

1239

/* Convert this value to Ruby object */

1240

return SWIG_RubyReferenceToObject(value);

1241

}

1242

}

1243

1244

/* Remove a Tracking from a C/C++ struct to a Ruby object. It

1245

is very important to remove objects once they are destroyed

1246

since the same memory address may be reused later to create

1247

a new object. */

1248

SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {

1249

/* Get a reference to the pointer as a Ruby number */

1250

VALUE key = SWIG_RubyPtrToReference(ptr);

1251

1252

/* Delete the object from the hash table by calling Ruby's

1253

do this we need to call the Hash.delete method.*/

1254

rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);

1255

}

1256

1257

/* This is a helper method that unlinks a Ruby object from its

1258

underlying C++ object. This is needed if the lifetime of the

1259

Ruby object is longer than the C++ object */

1260

SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {

1261

VALUE object = SWIG_RubyInstanceFor(ptr);

1262

1263

if (object != Qnil) {

1264

DATA_PTR(object) = 0;

1265

}

1266

}

1267

1268

1269

#ifdef __cplusplus

1270

}

1271

#endif

1272

1273

/* -----------------------------------------------------------------------------

1274

* Ruby API portion that goes into the runtime

1275

* ----------------------------------------------------------------------------- */

1276

1277

#ifdef __cplusplus

1278

extern "C" {

1279

#endif

1280

1281

SWIGINTERN VALUE

1282

SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {

1283

if (NIL_P(target)) {

1284

target = o;

1285

} else {

1286

if (TYPE(target) != T_ARRAY) {

1287

VALUE o2 = target;

1288

target = rb_ary_new();

1289

rb_ary_push(target, o2);

1290

}

1291

rb_ary_push(target, o);

1292

}

1293

return target;

1294

}

1295

1296

/* For ruby1.8.4 and earlier. */

1297

#ifndef RUBY_INIT_STACK

1298

RUBY_EXTERN void Init_stack(VALUE* addr);

1299

# define RUBY_INIT_STACK \

1300

VALUE variable_in_this_stack_frame; \

1301

Init_stack(&variable_in_this_stack_frame);

1302

#endif

1303

1304

1305

#ifdef __cplusplus

1306

}

1307

#endif

1308

1309

1310

/* -----------------------------------------------------------------------------

1311

* See the LICENSE file for information on copyright, usage and redistribution

1312

* of SWIG, and the README file for authors - http://www.swig.org/release.html.

1313

1314

* rubyrun.swg

1315

1316

* This file contains the runtime support for Ruby modules

1317

* and includes code for managing global variables and pointer

1318

* type checking.

1319

* ----------------------------------------------------------------------------- */

1320

1321

/* For backward compatibility only */

1322

#define SWIG_POINTER_EXCEPTION 0

1323

1324

/* for raw pointers */

1325

#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)

1326

#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)

1327

#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)

1328

#define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)

1329

#define swig_owntype ruby_owntype

1330

1331

/* for raw packed data */

1332

#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)

1333

#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)

1334

1335

/* for class or struct pointers */

1336

#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)

1337

#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)

1338

1339

/* for C or C++ function pointers */

1340

#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)

1341

#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)

1342

1343

/* for C++ member pointers, ie, member methods */

1344

#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)

1345

#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)

1346

1347

1348

/* Runtime API */

1349

1350

#define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule()

1351

#define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)

1352

1353

1354

/* Error manipulation */

1355

1356

#define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)

1357

#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg)

1358

#define SWIG_fail goto fail

1359

1360

1361

/* Ruby-specific SWIG API */

1362

1363

#define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()

1364

#define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)

1365

#define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty)

1366

#define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)

1367

#define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)

1368

1369

#include "assert.h"

1370

1371

/* -----------------------------------------------------------------------------

1372

* pointers/data manipulation

1373

* ----------------------------------------------------------------------------- */

1374

1375

#ifdef __cplusplus

1376

extern "C" {

1377

#endif

1378

1379

typedef struct {

1380

VALUE klass;

1381

VALUE mImpl;

1382

void (*mark)(void *);

1383

void (*destroy)(void *);

1384

int trackObjects;

1385

} swig_class;

1386

1387

1388

/* Global pointer used to keep some internal SWIG stuff */

1389

static VALUE _cSWIG_Pointer = Qnil;

1390

static VALUE swig_runtime_data_type_pointer = Qnil;

1391

1392

/* Global IDs used to keep some internal SWIG stuff */

1393

static ID swig_arity_id = 0;

1394

static ID swig_call_id = 0;

1395

1396

1397

If your swig extension is to be run within an embedded ruby and has

1398

director callbacks, you should set -DRUBY_EMBEDDED during compilation.

1399

This will reset ruby's stack frame on each entry point from the main

1400

program the first time a virtual director function is invoked (in a

1401

non-recursive way).

1402

If this is not done, you run the risk of Ruby trashing the stack.

1403

1404

1405

#ifdef RUBY_EMBEDDED

1406

1407

# define SWIG_INIT_STACK \

1408

if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \

1409

++swig_virtual_calls;

1410

# define SWIG_RELEASE_STACK --swig_virtual_calls;

1411

# define Ruby_DirectorTypeMismatchException(x) \

1412

rb_raise( rb_eTypeError, x ); return c_result;

1413

1414

static unsigned int swig_virtual_calls = 0;

1415

1416

#else /* normal non-embedded extension */

1417

1418

# define SWIG_INIT_STACK

1419

# define SWIG_RELEASE_STACK

1420

# define Ruby_DirectorTypeMismatchException(x) \

1421

throw Swig::DirectorTypeMismatchException( x );

1422

1423

#endif /* RUBY_EMBEDDED */

1424

1425

1426

SWIGRUNTIME VALUE

1427

getExceptionClass(void) {

1428

static int init = 0;

1429

static VALUE rubyExceptionClass ;

1430

if (!init) {

1431

init = 1;

1432

rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));

1433

}

1434

return rubyExceptionClass;

1435

}

1436

1437

/* This code checks to see if the Ruby object being raised as part

1438

of an exception inherits from the Ruby class Exception. If so,

1439

the object is simply returned. If not, then a new Ruby exception

1440

object is created and that will be returned to Ruby.*/

1441

SWIGRUNTIME VALUE

1442

SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {

1443

VALUE exceptionClass = getExceptionClass();

1444

if (rb_obj_is_kind_of(obj, exceptionClass)) {

1445

return obj;

1446

} else {

1447

return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));

1448

}

1449

}

1450

1451

/* Initialize Ruby runtime support */

1452

SWIGRUNTIME void

1453

SWIG_Ruby_InitRuntime(void)

1454

{

1455

if (_mSWIG == Qnil) {

1456

_mSWIG = rb_define_module("SWIG");

1457

swig_call_id = rb_intern("call");

1458

swig_arity_id = rb_intern("arity");

1459

}

1460

}

1461

1462

/* Define Ruby class for C type */

1463

SWIGRUNTIME void

1464

SWIG_Ruby_define_class(swig_type_info *type)

1465

{

1466

VALUE klass;

1467

char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);

1468

sprintf(klass_name, "TYPE%s", type->name);

1469

if (NIL_P(_cSWIG_Pointer)) {

1470

_cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);

1471

rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");

1472

}

1473

klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);

1474

free((void *) klass_name);

1475

}

1476

1477

/* Create a new pointer object */

1478

SWIGRUNTIME VALUE

1479

SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)

1480

{

1481

int own = flags & SWIG_POINTER_OWN;

1482

int track;

1483

char *klass_name;

1484

swig_class *sklass;

1485

VALUE klass;

1486

VALUE obj;

1487

1488

if (!ptr)

1489

return Qnil;

1490

1491

if (type->clientdata) {

1492

sklass = (swig_class *) type->clientdata;

1493

1494

/* Are we tracking this class and have we already returned this Ruby object? */

1495

track = sklass->trackObjects;

1496

if (track) {

1497

obj = SWIG_RubyInstanceFor(ptr);

1498

1499

/* Check the object's type and make sure it has the correct type.

1500

It might not in cases where methods do things like

1501

downcast methods. */

1502

if (obj != Qnil) {

1503

VALUE value = rb_iv_get(obj, "@__swigtype__");

1504

char* type_name = RSTRING_PTR(value);

1505

1506

if (strcmp(type->name, type_name) == 0) {

1507

return obj;

1508

}

1509

}

1510

}

1511

1512

/* Create a new Ruby object */

1513

obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),

1514

( own ? VOIDFUNC(sklass->destroy) :

1515

(track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )

1516

), ptr);

1517

1518

/* If tracking is on for this class then track this object. */

1519

if (track) {

1520

SWIG_RubyAddTracking(ptr, obj);

1521

}

1522

} else {

1523

klass_name = (char *) malloc(4 + strlen(type->name) + 1);

1524

sprintf(klass_name, "TYPE%s", type->name);

1525

klass = rb_const_get(_mSWIG, rb_intern(klass_name));

1526

free((void *) klass_name);

1527

obj = Data_Wrap_Struct(klass, 0, 0, ptr);

1528

}

1529

rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));

1530

1531

return obj;

1532

}

1533

1534

/* Create a new class instance (always owned) */

1535

SWIGRUNTIME VALUE

1536

SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)

1537

{

1538

VALUE obj;

1539

swig_class *sklass = (swig_class *) type->clientdata;

1540

obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);

1541

rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));

1542

return obj;

1543

}

1544

1545

/* Get type mangle from class name */

1546

SWIGRUNTIMEINLINE char *

1547

SWIG_Ruby_MangleStr(VALUE obj)

1548

{

1549

VALUE stype = rb_iv_get(obj, "@__swigtype__");

1550

return StringValuePtr(stype);

1551

}

1552

1553

/* Acquire a pointer value */

1554

typedef void (*ruby_owntype)(void*);

1555

1556

SWIGRUNTIME ruby_owntype

1557

SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {

1558

if (obj) {

1559

ruby_owntype oldown = RDATA(obj)->dfree;

1560

RDATA(obj)->dfree = own;

1561

return oldown;

1562

} else {

1563

return 0;

1564

}

1565

}

1566

1567

/* Convert a pointer value */

1568

SWIGRUNTIME int

1569

SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)

1570

{

1571

char *c;

1572

swig_cast_info *tc;

1573

void *vptr = 0;

1574

1575

/* Grab the pointer */

1576

if (NIL_P(obj)) {

1577

*ptr = 0;

1578

return SWIG_OK;

1579

} else {

1580

if (TYPE(obj) != T_DATA) {

1581

return SWIG_ERROR;

1582

}

1583

Data_Get_Struct(obj, void, vptr);

1584

}

1585

1586

if (own) *own = RDATA(obj)->dfree;

1587

1588

/* Check to see if the input object is giving up ownership

1589

of the underlying C struct or C++ object. If so then we

1590

need to reset the destructor since the Ruby object no

1591

longer owns the underlying C++ object.*/

1592

if (flags & SWIG_POINTER_DISOWN) {

1593

/* Is tracking on for this class? */

1594

int track = 0;

1595

if (ty && ty->clientdata) {

1596

swig_class *sklass = (swig_class *) ty->clientdata;

1597

track = sklass->trackObjects;

1598

}

1599

1600

if (track) {

1601

/* We are tracking objects for this class. Thus we change the destructor

1602

* to SWIG_RubyRemoveTracking. This allows us to

1603

* remove the mapping from the C++ to Ruby object

1604

* when the Ruby object is garbage collected. If we don't

1605

* do this, then it is possible we will return a reference

1606

* to a Ruby object that no longer exists thereby crashing Ruby. */

1607

RDATA(obj)->dfree = SWIG_RubyRemoveTracking;

1608

} else {

1609

RDATA(obj)->dfree = 0;

1610

}

1611

}

1612

1613

/* Do type-checking if type info was provided */

1614

if (ty) {

1615

if (ty->clientdata) {

1616

if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {

1617

if (vptr == 0) {

1618

/* The object has already been deleted */

1619

return SWIG_ObjectPreviouslyDeletedError;

1620

}

1621

*ptr = vptr;

1622

return SWIG_OK;

1623

}

1624

}

1625

if ((c = SWIG_MangleStr(obj)) == NULL) {

1626

return SWIG_ERROR;

1627

}

1628

tc = SWIG_TypeCheck(c, ty);

1629

if (!tc) {

1630

return SWIG_ERROR;

1631

} else {

1632

int newmemory = 0;

1633

*ptr = SWIG_TypeCast(tc, vptr, &newmemory);

1634

assert(!newmemory); /* newmemory handling not yet implemented */

1635

}

1636

} else {

1637

*ptr = vptr;

1638

}

1639

1640

return SWIG_OK;

1641

}

1642

1643

/* Check convert */

1644

SWIGRUNTIMEINLINE int

1645

SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)

1646

{

1647

char *c = SWIG_MangleStr(obj);

1648

if (!c) return 0;

1649

return SWIG_TypeCheck(c,ty) != 0;

1650

}

1651

1652

SWIGRUNTIME VALUE

1653

SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {

1654

char result[1024];

1655

char *r = result;

1656

if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;

1657

*(r++) = '_';

1658

r = SWIG_PackData(r, ptr, sz);

1659

strcpy(r, type->name);

1660

return rb_str_new2(result);

1661

}

1662

1663

/* Convert a packed value value */

1664

SWIGRUNTIME int

1665

SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {

1666

swig_cast_info *tc;

1667

const char *c;

1668

1669

if (TYPE(obj) != T_STRING) goto type_error;

1670

c = StringValuePtr(obj);

1671

/* Pointer values must start with leading underscore */

1672

if (*c != '_') goto type_error;

1673

c++;

1674

c = SWIG_UnpackData(c, ptr, sz);

1675

if (ty) {

1676

tc = SWIG_TypeCheck(c, ty);

1677

if (!tc) goto type_error;

1678

}

1679

return SWIG_OK;

1680

1681

type_error:

1682

return SWIG_ERROR;

1683

}

1684

1685

SWIGRUNTIME swig_module_info *

1686

SWIG_Ruby_GetModule(void)

1687

{

1688

VALUE pointer;

1689

swig_module_info *ret = 0;

1690

VALUE verbose = rb_gv_get("VERBOSE");

1691

1692

/* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */

1693

rb_gv_set("VERBOSE", Qfalse);

1694

1695

/* first check if pointer already created */

1696

pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);

1697

if (pointer != Qnil) {

1698

Data_Get_Struct(pointer, swig_module_info, ret);

1699

}

1700

1701

/* reinstate warnings */

1702

rb_gv_set("VERBOSE", verbose);

1703

return ret;

1704

}

1705

1706

SWIGRUNTIME void

1707

SWIG_Ruby_SetModule(swig_module_info *pointer)

1708

{

1709

/* register a new class */

1710

VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);

1711

/* create and store the structure pointer to a global variable */

1712

swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);

1713

rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);

1714

}

1715

1716

/* This function can be used to check whether a proc or method or similarly

1717

callable function has been passed. Usually used in a %typecheck, like:

1718

1719

%typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {

1720

$result = SWIG_Ruby_isCallable( $input );

1721

}

1722

1723

SWIGINTERN

1724

int SWIG_Ruby_isCallable( VALUE proc )

1725

{

1726

if ( rb_respond_to( proc, swig_call_id ) == Qtrue )

1727

return 1;

1728

return 0;

1729

}

1730

1731

/* This function can be used to check the arity (number of arguments)

1732

a proc or method can take. Usually used in a %typecheck.

1733

Valid arities will be that equal to minimal or those < 0

1734

which indicate a variable number of parameters at the end.

1735

1736

SWIGINTERN

1737

int SWIG_Ruby_arity( VALUE proc, int minimal )

1738

{

1739

if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )

1740

{

1741

VALUE num = rb_funcall( proc, swig_arity_id, 0 );

1742

int arity = NUM2INT(num);

1743

if ( arity < 0 && (arity+1) < -minimal ) return 1;

1744

if ( arity == minimal ) return 1;

1745

return 1;

1746

}

1747

return 0;

1748

}

1749

1750

1751

#ifdef __cplusplus

1752

}

1753

#endif

1754

1755

1756

1757

#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)

1758

1759

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else

1760

1761

1762

1763

/* -------- TYPES TABLE (BEGIN) -------- */

1764

1765

#define SWIGTYPE_p_char swig_types[0]

1766

#define SWIGTYPE_p_double swig_types[1]

1767

#define SWIGTYPE_p_float swig_types[2]

1768

#define SWIGTYPE_p_int swig_types[3]

1769

#define SWIGTYPE_p_off_t swig_types[4]

1770

static swig_type_info *swig_types[6];

1771

static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};

1772

#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)

1773

#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

1774

1775

/* -------- TYPES TABLE (END) -------- */

1776

1777

#define SWIG_init Init_CdiLib

1778

#define SWIG_name "CdiLib"

1779

1780

static VALUE mCdiLib;

1781

1782

#define SWIG_RUBY_THREAD_BEGIN_BLOCK

1783

#define SWIG_RUBY_THREAD_END_BLOCK

1784

1785

1786

#define SWIGVERSION 0x010336

1787

#define SWIG_VERSION SWIGVERSION

1788

1789

1790

#define SWIG_as_voidptr(a) (void *)((const void *)(a))

1791

#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))

1792

1793

1794

#include "cdi.h"

1795

1796

1797

#include <limits.h>

1798

#if !defined(SWIG_NO_LLONG_MAX)

1799

# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)

1800

# define LLONG_MAX __LONG_LONG_MAX__

1801

# define LLONG_MIN (-LLONG_MAX - 1LL)

1802

# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)

1803

# endif

1804

#endif

1805

1806

1807

#define SWIG_From_long LONG2NUM

1808

1809

1810

SWIGINTERNINLINE VALUE

1811

SWIG_From_int (int value)

1812

{

1813

return SWIG_From_long (value);

1814

}

1815

1816

1817

SWIGINTERN VALUE

1818

SWIG_ruby_failed(void)

1819

{

1820

return Qnil;

1821

}

1822

1823

1824

/*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/

1825

SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)

1826

{

1827

VALUE obj = args[0];

1828

VALUE type = TYPE(obj);

1829

long *res = (long *)(args[1]);

1830

*res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);

1831

return obj;

1832

}

1833

/*@SWIG@*/

1834

1835

SWIGINTERN int

1836

SWIG_AsVal_long (VALUE obj, long* val)

1837

{

1838

VALUE type = TYPE(obj);

1839

if ((type == T_FIXNUM) || (type == T_BIGNUM)) {

1840

long v;

1841

VALUE a[2];

1842

a[0] = obj;

1843

a[1] = (VALUE)(&v);

1844

if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {

1845

if (val) *val = v;

1846

return SWIG_OK;

1847

}

1848

}

1849

return SWIG_TypeError;

1850

}

1851

1852

1853

SWIGINTERN int

1854

SWIG_AsVal_int (VALUE obj, int *val)

1855

{

1856

long v;

1857

int res = SWIG_AsVal_long (obj, &v);

1858

if (SWIG_IsOK(res)) {

1859

if ((v < INT_MIN || v > INT_MAX)) {

1860

return SWIG_OverflowError;

1861

} else {

1862

if (val) *val = (int)(v);

1863

}

1864

}

1865

return res;

1866

}

1867

1868

1869

SWIGINTERN swig_type_info*

1870

SWIG_pchar_descriptor(void)

1871

{

1872

static int init = 0;

1873

static swig_type_info* info = 0;

1874

if (!init) {

1875

info = SWIG_TypeQuery("_p_char");

1876

init = 1;

1877

}

1878

return info;

1879

}

1880

1881

1882

SWIGINTERNINLINE VALUE

1883

SWIG_FromCharPtrAndSize(const char* carray, size_t size)

1884

{

1885

if (carray) {

1886

if (size > LONG_MAX) {

1887

swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();

1888

return pchar_descriptor ?

1889

SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : Qnil;

1890

} else {

1891

return rb_str_new(carray, (long)(size));

1892

}

1893

} else {

1894

return Qnil;

1895

}

1896

}

1897

1898

1899

SWIGINTERNINLINE VALUE

1900

SWIG_FromCharPtr(const char *cptr)

1901

{

1902

return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));

1903

}

1904

1905

1906

/*@SWIG:/usr/share/swig1.3/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/

1907

SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)

1908

{

1909

VALUE obj = args[0];

1910

VALUE type = TYPE(obj);

1911

double *res = (double *)(args[1]);

1912

*res = (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj)));

1913

return obj;

1914

}

1915

/*@SWIG@*/

1916

1917

SWIGINTERN int

1918

SWIG_AsVal_double (VALUE obj, double *val)

1919

{

1920

VALUE type = TYPE(obj);

1921

if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {

1922

double v;

1923

VALUE a[2];

1924

a[0] = obj;

1925

a[1] = (VALUE)(&v);

1926

if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {

1927

if (val) *val = v;

1928

return SWIG_OK;

1929

}

1930

}

1931

return SWIG_TypeError;

1932

}

1933

1934

1935

#define SWIG_From_double rb_float_new

1936

1937

1938

SWIGINTERN int

1939

SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)

1940

{

1941

if (TYPE(obj) == T_STRING) {

1942

#if defined(StringValuePtr)

1943

char *cstr = StringValuePtr(obj);

1944

#else

1945

char *cstr = STR2CSTR(obj);

1946

#endif

1947

size_t size = RSTRING_LEN(obj) + 1;

1948

if (cptr) {

1949

if (alloc) {

1950

if (*alloc == SWIG_NEWOBJ) {

1951

*cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));

1952

} else {

1953

*cptr = cstr;

1954

*alloc = SWIG_OLDOBJ;

1955

}

1956

}

1957

}

1958

if (psize) *psize = size;

1959

return SWIG_OK;

1960

} else {

1961

swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();

1962

if (pchar_descriptor) {

1963

void* vptr = 0;

1964

if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {

1965

if (cptr) *cptr = (char *)vptr;

1966

if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;

1967

if (alloc) *alloc = SWIG_OLDOBJ;

1968

return SWIG_OK;

1969

}

1970

}

1971

}

1972

return SWIG_TypeError;

1973

}

1974

1975

1976

1977

1978

SWIGINTERN VALUE

1979

_wrap_cdiStringError(int argc, VALUE *argv, VALUE self) {

1980

int arg1 ;

1981

int val1 ;

1982

int ecode1 = 0 ;

1983

char *result = 0 ;

1984

VALUE vresult = Qnil;

1985

1986

if ((argc < 1) || (argc > 1)) {

1987

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

1988

}

1989

ecode1 = SWIG_AsVal_int(argv[0], &val1);

1990

if (!SWIG_IsOK(ecode1)) {

1991

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiStringError", 1, argv[0] ));

1992

}

1993

arg1 = (int)(val1);

1994

result = (char *)cdiStringError(arg1);

1995

vresult = SWIG_FromCharPtr((const char *)result);

1996

return vresult;

1997

fail:

1998

return Qnil;

1999

}

2000

2001

2002

SWIGINTERN VALUE

2003

_wrap_cdiDebug(int argc, VALUE *argv, VALUE self) {

2004

int arg1 ;

2005

int val1 ;

2006

int ecode1 = 0 ;

2007

2008

if ((argc < 1) || (argc > 1)) {

2009

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2010

}

2011

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2012

if (!SWIG_IsOK(ecode1)) {

2013

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","cdiDebug", 1, argv[0] ));

2014

}

2015

arg1 = (int)(val1);

2016

cdiDebug(arg1);

2017

return Qnil;

2018

fail:

2019

return Qnil;

2020

}

2021

2022

2023

SWIGINTERN VALUE

2024

_wrap_cdiLibraryVersion(int argc, VALUE *argv, VALUE self) {

2025

char *result = 0 ;

2026

VALUE vresult = Qnil;

2027

2028

if ((argc < 0) || (argc > 0)) {

2029

rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;

2030

}

2031

result = (char *)cdiLibraryVersion();

2032

vresult = SWIG_FromCharPtr((const char *)result);

2033

return vresult;

2034

fail:

2035

return Qnil;

2036

}

2037

2038

2039

SWIGINTERN VALUE

2040

_wrap_cdiPrintVersion(int argc, VALUE *argv, VALUE self) {

2041

if ((argc < 0) || (argc > 0)) {

2042

rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;

2043

}

2044

cdiPrintVersion();

2045

return Qnil;

2046

fail:

2047

return Qnil;

2048

}

2049

2050

2051

SWIGINTERN VALUE

2052

_wrap_cdiDefMissval(int argc, VALUE *argv, VALUE self) {

2053

double arg1 ;

2054

double val1 ;

2055

int ecode1 = 0 ;

2056

2057

if ((argc < 1) || (argc > 1)) {

2058

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2059

}

2060

ecode1 = SWIG_AsVal_double(argv[0], &val1);

2061

if (!SWIG_IsOK(ecode1)) {

2062

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "double","cdiDefMissval", 1, argv[0] ));

2063

}

2064

arg1 = (double)(val1);

2065

cdiDefMissval(arg1);

2066

return Qnil;

2067

fail:

2068

return Qnil;

2069

}

2070

2071

2072

SWIGINTERN VALUE

2073

_wrap_cdiInqMissval(int argc, VALUE *argv, VALUE self) {

2074

double result;

2075

VALUE vresult = Qnil;

2076

2077

if ((argc < 0) || (argc > 0)) {

2078

rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;

2079

}

2080

result = (double)cdiInqMissval();

2081

vresult = SWIG_From_double((double)(result));

2082

return vresult;

2083

fail:

2084

return Qnil;

2085

}

2086

2087

2088

SWIGINTERN VALUE

2089

_wrap_cdiDefGlobal(int argc, VALUE *argv, VALUE self) {

2090

char *arg1 = (char *) 0 ;

2091

int arg2 ;

2092

int res1 ;

2093

char *buf1 = 0 ;

2094

int alloc1 = 0 ;

2095

int val2 ;

2096

int ecode2 = 0 ;

2097

2098

if ((argc < 2) || (argc > 2)) {

2099

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

2100

}

2101

res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);

2102

if (!SWIG_IsOK(res1)) {

2103

SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","cdiDefGlobal", 1, argv[0] ));

2104

}

2105

arg1 = (char *)(buf1);

2106

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2107

if (!SWIG_IsOK(ecode2)) {

2108

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","cdiDefGlobal", 2, argv[1] ));

2109

}

2110

arg2 = (int)(val2);

2111

cdiDefGlobal((char const *)arg1,arg2);

2112

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

2113

return Qnil;

2114

fail:

2115

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

2116

return Qnil;

2117

}

2118

2119

2120

SWIGINTERN VALUE

2121

_wrap_streamOpenRead(int argc, VALUE *argv, VALUE self) {

2122

char *arg1 = (char *) 0 ;

2123

int res1 ;

2124

char *buf1 = 0 ;

2125

int alloc1 = 0 ;

2126

int result;

2127

VALUE vresult = Qnil;

2128

2129

if ((argc < 1) || (argc > 1)) {

2130

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2131

}

2132

res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);

2133

if (!SWIG_IsOK(res1)) {

2134

SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenRead", 1, argv[0] ));

2135

}

2136

arg1 = (char *)(buf1);

2137

result = (int)streamOpenRead((char const *)arg1);

2138

vresult = SWIG_From_int((int)(result));

2139

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

2140

return vresult;

2141

fail:

2142

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

2143

return Qnil;

2144

}

2145

2146

2147

SWIGINTERN VALUE

2148

_wrap_streamOpenWrite(int argc, VALUE *argv, VALUE self) {

2149

char *arg1 = (char *) 0 ;

2150

int arg2 ;

2151

int res1 ;

2152

char *buf1 = 0 ;

2153

int alloc1 = 0 ;

2154

int val2 ;

2155

int ecode2 = 0 ;

2156

int result;

2157

VALUE vresult = Qnil;

2158

2159

if ((argc < 2) || (argc > 2)) {

2160

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

2161

}

2162

res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);

2163

if (!SWIG_IsOK(res1)) {

2164

SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenWrite", 1, argv[0] ));

2165

}

2166

arg1 = (char *)(buf1);

2167

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2168

if (!SWIG_IsOK(ecode2)) {

2169

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamOpenWrite", 2, argv[1] ));

2170

}

2171

arg2 = (int)(val2);

2172

result = (int)streamOpenWrite((char const *)arg1,arg2);

2173

vresult = SWIG_From_int((int)(result));

2174

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

2175

return vresult;

2176

fail:

2177

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

2178

return Qnil;

2179

}

2180

2181

2182

SWIGINTERN VALUE

2183

_wrap_streamOpenAppend(int argc, VALUE *argv, VALUE self) {

2184

char *arg1 = (char *) 0 ;

2185

int res1 ;

2186

char *buf1 = 0 ;

2187

int alloc1 = 0 ;

2188

int result;

2189

VALUE vresult = Qnil;

2190

2191

if ((argc < 1) || (argc > 1)) {

2192

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2193

}

2194

res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);

2195

if (!SWIG_IsOK(res1)) {

2196

SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","streamOpenAppend", 1, argv[0] ));

2197

}

2198

arg1 = (char *)(buf1);

2199

result = (int)streamOpenAppend((char const *)arg1);

2200

vresult = SWIG_From_int((int)(result));

2201

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

2202

return vresult;

2203

fail:

2204

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

2205

return Qnil;

2206

}

2207

2208

2209

SWIGINTERN VALUE

2210

_wrap_streamClose(int argc, VALUE *argv, VALUE self) {

2211

int arg1 ;

2212

int val1 ;

2213

int ecode1 = 0 ;

2214

2215

if ((argc < 1) || (argc > 1)) {

2216

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2217

}

2218

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2219

if (!SWIG_IsOK(ecode1)) {

2220

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamClose", 1, argv[0] ));

2221

}

2222

arg1 = (int)(val1);

2223

streamClose(arg1);

2224

return Qnil;

2225

fail:

2226

return Qnil;

2227

}

2228

2229

2230

SWIGINTERN VALUE

2231

_wrap_streamSync(int argc, VALUE *argv, VALUE self) {

2232

int arg1 ;

2233

int val1 ;

2234

int ecode1 = 0 ;

2235

2236

if ((argc < 1) || (argc > 1)) {

2237

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2238

}

2239

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2240

if (!SWIG_IsOK(ecode1)) {

2241

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamSync", 1, argv[0] ));

2242

}

2243

arg1 = (int)(val1);

2244

streamSync(arg1);

2245

return Qnil;

2246

fail:

2247

return Qnil;

2248

}

2249

2250

2251

SWIGINTERN VALUE

2252

_wrap_streamDefVlist(int argc, VALUE *argv, VALUE self) {

2253

int arg1 ;

2254

int arg2 ;

2255

int val1 ;

2256

int ecode1 = 0 ;

2257

int val2 ;

2258

int ecode2 = 0 ;

2259

2260

if ((argc < 2) || (argc > 2)) {

2261

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

2262

}

2263

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2264

if (!SWIG_IsOK(ecode1)) {

2265

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefVlist", 1, argv[0] ));

2266

}

2267

arg1 = (int)(val1);

2268

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2269

if (!SWIG_IsOK(ecode2)) {

2270

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefVlist", 2, argv[1] ));

2271

}

2272

arg2 = (int)(val2);

2273

streamDefVlist(arg1,arg2);

2274

return Qnil;

2275

fail:

2276

return Qnil;

2277

}

2278

2279

2280

SWIGINTERN VALUE

2281

_wrap_streamInqVlist(int argc, VALUE *argv, VALUE self) {

2282

int arg1 ;

2283

int val1 ;

2284

int ecode1 = 0 ;

2285

int result;

2286

VALUE vresult = Qnil;

2287

2288

if ((argc < 1) || (argc > 1)) {

2289

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2290

}

2291

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2292

if (!SWIG_IsOK(ecode1)) {

2293

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqVlist", 1, argv[0] ));

2294

}

2295

arg1 = (int)(val1);

2296

result = (int)streamInqVlist(arg1);

2297

vresult = SWIG_From_int((int)(result));

2298

return vresult;

2299

fail:

2300

return Qnil;

2301

}

2302

2303

2304

SWIGINTERN VALUE

2305

_wrap_streamInqFiletype(int argc, VALUE *argv, VALUE self) {

2306

int arg1 ;

2307

int val1 ;

2308

int ecode1 = 0 ;

2309

int result;

2310

VALUE vresult = Qnil;

2311

2312

if ((argc < 1) || (argc > 1)) {

2313

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2314

}

2315

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2316

if (!SWIG_IsOK(ecode1)) {

2317

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqFiletype", 1, argv[0] ));

2318

}

2319

arg1 = (int)(val1);

2320

result = (int)streamInqFiletype(arg1);

2321

vresult = SWIG_From_int((int)(result));

2322

return vresult;

2323

fail:

2324

return Qnil;

2325

}

2326

2327

2328

SWIGINTERN VALUE

2329

_wrap_streamDefByteorder(int argc, VALUE *argv, VALUE self) {

2330

int arg1 ;

2331

int arg2 ;

2332

int val1 ;

2333

int ecode1 = 0 ;

2334

int val2 ;

2335

int ecode2 = 0 ;

2336

2337

if ((argc < 2) || (argc > 2)) {

2338

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

2339

}

2340

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2341

if (!SWIG_IsOK(ecode1)) {

2342

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefByteorder", 1, argv[0] ));

2343

}

2344

arg1 = (int)(val1);

2345

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2346

if (!SWIG_IsOK(ecode2)) {

2347

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefByteorder", 2, argv[1] ));

2348

}

2349

arg2 = (int)(val2);

2350

streamDefByteorder(arg1,arg2);

2351

return Qnil;

2352

fail:

2353

return Qnil;

2354

}

2355

2356

2357

SWIGINTERN VALUE

2358

_wrap_streamInqByteorder(int argc, VALUE *argv, VALUE self) {

2359

int arg1 ;

2360

int val1 ;

2361

int ecode1 = 0 ;

2362

int result;

2363

VALUE vresult = Qnil;

2364

2365

if ((argc < 1) || (argc > 1)) {

2366

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2367

}

2368

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2369

if (!SWIG_IsOK(ecode1)) {

2370

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqByteorder", 1, argv[0] ));

2371

}

2372

arg1 = (int)(val1);

2373

result = (int)streamInqByteorder(arg1);

2374

vresult = SWIG_From_int((int)(result));

2375

return vresult;

2376

fail:

2377

return Qnil;

2378

}

2379

2380

2381

SWIGINTERN VALUE

2382

_wrap_streamDefZtype(int argc, VALUE *argv, VALUE self) {

2383

int arg1 ;

2384

int arg2 ;

2385

int val1 ;

2386

int ecode1 = 0 ;

2387

int val2 ;

2388

int ecode2 = 0 ;

2389

2390

if ((argc < 2) || (argc > 2)) {

2391

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

2392

}

2393

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2394

if (!SWIG_IsOK(ecode1)) {

2395

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefZtype", 1, argv[0] ));

2396

}

2397

arg1 = (int)(val1);

2398

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2399

if (!SWIG_IsOK(ecode2)) {

2400

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefZtype", 2, argv[1] ));

2401

}

2402

arg2 = (int)(val2);

2403

streamDefZtype(arg1,arg2);

2404

return Qnil;

2405

fail:

2406

return Qnil;

2407

}

2408

2409

2410

SWIGINTERN VALUE

2411

_wrap_streamDefZlevel(int argc, VALUE *argv, VALUE self) {

2412

int arg1 ;

2413

int arg2 ;

2414

int val1 ;

2415

int ecode1 = 0 ;

2416

int val2 ;

2417

int ecode2 = 0 ;

2418

2419

if ((argc < 2) || (argc > 2)) {

2420

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

2421

}

2422

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2423

if (!SWIG_IsOK(ecode1)) {

2424

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefZlevel", 1, argv[0] ));

2425

}

2426

arg1 = (int)(val1);

2427

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2428

if (!SWIG_IsOK(ecode2)) {

2429

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefZlevel", 2, argv[1] ));

2430

}

2431

arg2 = (int)(val2);

2432

streamDefZlevel(arg1,arg2);

2433

return Qnil;

2434

fail:

2435

return Qnil;

2436

}

2437

2438

2439

SWIGINTERN VALUE

2440

_wrap_streamInqZtype(int argc, VALUE *argv, VALUE self) {

2441

int arg1 ;

2442

int val1 ;

2443

int ecode1 = 0 ;

2444

int result;

2445

VALUE vresult = Qnil;

2446

2447

if ((argc < 1) || (argc > 1)) {

2448

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2449

}

2450

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2451

if (!SWIG_IsOK(ecode1)) {

2452

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqZtype", 1, argv[0] ));

2453

}

2454

arg1 = (int)(val1);

2455

result = (int)streamInqZtype(arg1);

2456

vresult = SWIG_From_int((int)(result));

2457

return vresult;

2458

fail:

2459

return Qnil;

2460

}

2461

2462

2463

SWIGINTERN VALUE

2464

_wrap_streamInqZlevel(int argc, VALUE *argv, VALUE self) {

2465

int arg1 ;

2466

int val1 ;

2467

int ecode1 = 0 ;

2468

int result;

2469

VALUE vresult = Qnil;

2470

2471

if ((argc < 1) || (argc > 1)) {

2472

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2473

}

2474

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2475

if (!SWIG_IsOK(ecode1)) {

2476

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqZlevel", 1, argv[0] ));

2477

}

2478

arg1 = (int)(val1);

2479

result = (int)streamInqZlevel(arg1);

2480

vresult = SWIG_From_int((int)(result));

2481

return vresult;

2482

fail:

2483

return Qnil;

2484

}

2485

2486

2487

SWIGINTERN VALUE

2488

_wrap_streamDefTimestep(int argc, VALUE *argv, VALUE self) {

2489

int arg1 ;

2490

int arg2 ;

2491

int val1 ;

2492

int ecode1 = 0 ;

2493

int val2 ;

2494

int ecode2 = 0 ;

2495

int result;

2496

VALUE vresult = Qnil;

2497

2498

if ((argc < 2) || (argc > 2)) {

2499

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

2500

}

2501

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2502

if (!SWIG_IsOK(ecode1)) {

2503

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefTimestep", 1, argv[0] ));

2504

}

2505

arg1 = (int)(val1);

2506

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2507

if (!SWIG_IsOK(ecode2)) {

2508

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefTimestep", 2, argv[1] ));

2509

}

2510

arg2 = (int)(val2);

2511

result = (int)streamDefTimestep(arg1,arg2);

2512

vresult = SWIG_From_int((int)(result));

2513

return vresult;

2514

fail:

2515

return Qnil;

2516

}

2517

2518

2519

SWIGINTERN VALUE

2520

_wrap_streamInqTimestep(int argc, VALUE *argv, VALUE self) {

2521

int arg1 ;

2522

int arg2 ;

2523

int val1 ;

2524

int ecode1 = 0 ;

2525

int val2 ;

2526

int ecode2 = 0 ;

2527

int result;

2528

VALUE vresult = Qnil;

2529

2530

if ((argc < 2) || (argc > 2)) {

2531

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

2532

}

2533

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2534

if (!SWIG_IsOK(ecode1)) {

2535

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqTimestep", 1, argv[0] ));

2536

}

2537

arg1 = (int)(val1);

2538

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2539

if (!SWIG_IsOK(ecode2)) {

2540

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamInqTimestep", 2, argv[1] ));

2541

}

2542

arg2 = (int)(val2);

2543

result = (int)streamInqTimestep(arg1,arg2);

2544

vresult = SWIG_From_int((int)(result));

2545

return vresult;

2546

fail:

2547

return Qnil;

2548

}

2549

2550

2551

SWIGINTERN VALUE

2552

_wrap_streamFilename(int argc, VALUE *argv, VALUE self) {

2553

int arg1 ;

2554

int val1 ;

2555

int ecode1 = 0 ;

2556

char *result = 0 ;

2557

VALUE vresult = Qnil;

2558

2559

if ((argc < 1) || (argc > 1)) {

2560

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2561

}

2562

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2563

if (!SWIG_IsOK(ecode1)) {

2564

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamFilename", 1, argv[0] ));

2565

}

2566

arg1 = (int)(val1);

2567

result = (char *)streamFilename(arg1);

2568

vresult = SWIG_FromCharPtr((const char *)result);

2569

return vresult;

2570

fail:

2571

return Qnil;

2572

}

2573

2574

2575

SWIGINTERN VALUE

2576

_wrap_streamFilesuffix(int argc, VALUE *argv, VALUE self) {

2577

int arg1 ;

2578

int val1 ;

2579

int ecode1 = 0 ;

2580

char *result = 0 ;

2581

VALUE vresult = Qnil;

2582

2583

if ((argc < 1) || (argc > 1)) {

2584

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2585

}

2586

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2587

if (!SWIG_IsOK(ecode1)) {

2588

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamFilesuffix", 1, argv[0] ));

2589

}

2590

arg1 = (int)(val1);

2591

result = (char *)streamFilesuffix(arg1);

2592

vresult = SWIG_FromCharPtr((const char *)result);

2593

return vresult;

2594

fail:

2595

return Qnil;

2596

}

2597

2598

2599

SWIGINTERN VALUE

2600

_wrap_streamNtsteps(int argc, VALUE *argv, VALUE self) {

2601

int arg1 ;

2602

int val1 ;

2603

int ecode1 = 0 ;

2604

int result;

2605

VALUE vresult = Qnil;

2606

2607

if ((argc < 1) || (argc > 1)) {

2608

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2609

}

2610

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2611

if (!SWIG_IsOK(ecode1)) {

2612

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamNtsteps", 1, argv[0] ));

2613

}

2614

arg1 = (int)(val1);

2615

result = (int)streamNtsteps(arg1);

2616

vresult = SWIG_From_int((int)(result));

2617

return vresult;

2618

fail:

2619

return Qnil;

2620

}

2621

2622

2623

SWIGINTERN VALUE

2624

_wrap_streamNvals(int argc, VALUE *argv, VALUE self) {

2625

int arg1 ;

2626

int val1 ;

2627

int ecode1 = 0 ;

2628

off_t result;

2629

VALUE vresult = Qnil;

2630

2631

if ((argc < 1) || (argc > 1)) {

2632

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

2633

}

2634

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2635

if (!SWIG_IsOK(ecode1)) {

2636

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamNvals", 1, argv[0] ));

2637

}

2638

arg1 = (int)(val1);

2639

result = streamNvals(arg1);

2640

vresult = SWIG_NewPointerObj((off_t *)memcpy((off_t *)malloc(sizeof(off_t)),&result,sizeof(off_t)), SWIGTYPE_p_off_t, SWIG_POINTER_OWN | 0 );

2641

return vresult;

2642

fail:

2643

return Qnil;

2644

}

2645

2646

2647

SWIGINTERN VALUE

2648

_wrap_streamReadVar(int argc, VALUE *argv, VALUE self) {

2649

int arg1 ;

2650

int arg2 ;

2651

double *arg3 = (double *) 0 ;

2652

int *arg4 = (int *) 0 ;

2653

int val1 ;

2654

int ecode1 = 0 ;

2655

int val2 ;

2656

int ecode2 = 0 ;

2657

void *argp3 = 0 ;

2658

int res3 = 0 ;

2659

void *argp4 = 0 ;

2660

int res4 = 0 ;

2661

2662

if ((argc < 4) || (argc > 4)) {

2663

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

2664

}

2665

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2666

if (!SWIG_IsOK(ecode1)) {

2667

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVar", 1, argv[0] ));

2668

}

2669

arg1 = (int)(val1);

2670

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2671

if (!SWIG_IsOK(ecode2)) {

2672

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVar", 2, argv[1] ));

2673

}

2674

arg2 = (int)(val2);

2675

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );

2676

if (!SWIG_IsOK(res3)) {

2677

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","streamReadVar", 3, argv[2] ));

2678

}

2679

arg3 = (double *)(argp3);

2680

res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );

2681

if (!SWIG_IsOK(res4)) {

2682

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","streamReadVar", 4, argv[3] ));

2683

}

2684

arg4 = (int *)(argp4);

2685

streamReadVar(arg1,arg2,arg3,arg4);

2686

return Qnil;

2687

fail:

2688

return Qnil;

2689

}

2690

2691

2692

SWIGINTERN VALUE

2693

_wrap_streamWriteVar(int argc, VALUE *argv, VALUE self) {

2694

int arg1 ;

2695

int arg2 ;

2696

double *arg3 = (double *) 0 ;

2697

int arg4 ;

2698

int val1 ;

2699

int ecode1 = 0 ;

2700

int val2 ;

2701

int ecode2 = 0 ;

2702

void *argp3 = 0 ;

2703

int res3 = 0 ;

2704

int val4 ;

2705

int ecode4 = 0 ;

2706

2707

if ((argc < 4) || (argc > 4)) {

2708

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

2709

}

2710

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2711

if (!SWIG_IsOK(ecode1)) {

2712

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVar", 1, argv[0] ));

2713

}

2714

arg1 = (int)(val1);

2715

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2716

if (!SWIG_IsOK(ecode2)) {

2717

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVar", 2, argv[1] ));

2718

}

2719

arg2 = (int)(val2);

2720

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );

2721

if (!SWIG_IsOK(res3)) {

2722

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","streamWriteVar", 3, argv[2] ));

2723

}

2724

arg3 = (double *)(argp3);

2725

ecode4 = SWIG_AsVal_int(argv[3], &val4);

2726

if (!SWIG_IsOK(ecode4)) {

2727

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","streamWriteVar", 4, argv[3] ));

2728

}

2729

arg4 = (int)(val4);

2730

streamWriteVar(arg1,arg2,(double const *)arg3,arg4);

2731

return Qnil;

2732

fail:

2733

return Qnil;

2734

}

2735

2736

2737

SWIGINTERN VALUE

2738

_wrap_streamReadVarSlice(int argc, VALUE *argv, VALUE self) {

2739

int arg1 ;

2740

int arg2 ;

2741

int arg3 ;

2742

double *arg4 = (double *) 0 ;

2743

int *arg5 = (int *) 0 ;

2744

int val1 ;

2745

int ecode1 = 0 ;

2746

int val2 ;

2747

int ecode2 = 0 ;

2748

int val3 ;

2749

int ecode3 = 0 ;

2750

void *argp4 = 0 ;

2751

int res4 = 0 ;

2752

void *argp5 = 0 ;

2753

int res5 = 0 ;

2754

2755

if ((argc < 5) || (argc > 5)) {

2756

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

2757

}

2758

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2759

if (!SWIG_IsOK(ecode1)) {

2760

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 1, argv[0] ));

2761

}

2762

arg1 = (int)(val1);

2763

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2764

if (!SWIG_IsOK(ecode2)) {

2765

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 2, argv[1] ));

2766

}

2767

arg2 = (int)(val2);

2768

ecode3 = SWIG_AsVal_int(argv[2], &val3);

2769

if (!SWIG_IsOK(ecode3)) {

2770

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamReadVarSlice", 3, argv[2] ));

2771

}

2772

arg3 = (int)(val3);

2773

res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );

2774

if (!SWIG_IsOK(res4)) {

2775

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","streamReadVarSlice", 4, argv[3] ));

2776

}

2777

arg4 = (double *)(argp4);

2778

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );

2779

if (!SWIG_IsOK(res5)) {

2780

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","streamReadVarSlice", 5, argv[4] ));

2781

}

2782

arg5 = (int *)(argp5);

2783

streamReadVarSlice(arg1,arg2,arg3,arg4,arg5);

2784

return Qnil;

2785

fail:

2786

return Qnil;

2787

}

2788

2789

2790

SWIGINTERN VALUE

2791

_wrap_streamWriteVarSlice(int argc, VALUE *argv, VALUE self) {

2792

int arg1 ;

2793

int arg2 ;

2794

int arg3 ;

2795

double *arg4 = (double *) 0 ;

2796

int arg5 ;

2797

int val1 ;

2798

int ecode1 = 0 ;

2799

int val2 ;

2800

int ecode2 = 0 ;

2801

int val3 ;

2802

int ecode3 = 0 ;

2803

void *argp4 = 0 ;

2804

int res4 = 0 ;

2805

int val5 ;

2806

int ecode5 = 0 ;

2807

2808

if ((argc < 5) || (argc > 5)) {

2809

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

2810

}

2811

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2812

if (!SWIG_IsOK(ecode1)) {

2813

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 1, argv[0] ));

2814

}

2815

arg1 = (int)(val1);

2816

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2817

if (!SWIG_IsOK(ecode2)) {

2818

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 2, argv[1] ));

2819

}

2820

arg2 = (int)(val2);

2821

ecode3 = SWIG_AsVal_int(argv[2], &val3);

2822

if (!SWIG_IsOK(ecode3)) {

2823

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 3, argv[2] ));

2824

}

2825

arg3 = (int)(val3);

2826

res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );

2827

if (!SWIG_IsOK(res4)) {

2828

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double const *","streamWriteVarSlice", 4, argv[3] ));

2829

}

2830

arg4 = (double *)(argp4);

2831

ecode5 = SWIG_AsVal_int(argv[4], &val5);

2832

if (!SWIG_IsOK(ecode5)) {

2833

SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","streamWriteVarSlice", 5, argv[4] ));

2834

}

2835

arg5 = (int)(val5);

2836

streamWriteVarSlice(arg1,arg2,arg3,(double const *)arg4,arg5);

2837

return Qnil;

2838

fail:

2839

return Qnil;

2840

}

2841

2842

2843

SWIGINTERN VALUE

2844

_wrap_streamInqRecord(int argc, VALUE *argv, VALUE self) {

2845

int arg1 ;

2846

int *arg2 = (int *) 0 ;

2847

int *arg3 = (int *) 0 ;

2848

int val1 ;

2849

int ecode1 = 0 ;

2850

void *argp2 = 0 ;

2851

int res2 = 0 ;

2852

void *argp3 = 0 ;

2853

int res3 = 0 ;

2854

2855

if ((argc < 3) || (argc > 3)) {

2856

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

2857

}

2858

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2859

if (!SWIG_IsOK(ecode1)) {

2860

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqRecord", 1, argv[0] ));

2861

}

2862

arg1 = (int)(val1);

2863

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );

2864

if (!SWIG_IsOK(res2)) {

2865

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","streamInqRecord", 2, argv[1] ));

2866

}

2867

arg2 = (int *)(argp2);

2868

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );

2869

if (!SWIG_IsOK(res3)) {

2870

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","streamInqRecord", 3, argv[2] ));

2871

}

2872

arg3 = (int *)(argp3);

2873

streamInqRecord(arg1,arg2,arg3);

2874

return Qnil;

2875

fail:

2876

return Qnil;

2877

}

2878

2879

2880

SWIGINTERN VALUE

2881

_wrap_streamDefRecord(int argc, VALUE *argv, VALUE self) {

2882

int arg1 ;

2883

int arg2 ;

2884

int arg3 ;

2885

int val1 ;

2886

int ecode1 = 0 ;

2887

int val2 ;

2888

int ecode2 = 0 ;

2889

int val3 ;

2890

int ecode3 = 0 ;

2891

2892

if ((argc < 3) || (argc > 3)) {

2893

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

2894

}

2895

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2896

if (!SWIG_IsOK(ecode1)) {

2897

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefRecord", 1, argv[0] ));

2898

}

2899

arg1 = (int)(val1);

2900

ecode2 = SWIG_AsVal_int(argv[1], &val2);

2901

if (!SWIG_IsOK(ecode2)) {

2902

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefRecord", 2, argv[1] ));

2903

}

2904

arg2 = (int)(val2);

2905

ecode3 = SWIG_AsVal_int(argv[2], &val3);

2906

if (!SWIG_IsOK(ecode3)) {

2907

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamDefRecord", 3, argv[2] ));

2908

}

2909

arg3 = (int)(val3);

2910

streamDefRecord(arg1,arg2,arg3);

2911

return Qnil;

2912

fail:

2913

return Qnil;

2914

}

2915

2916

2917

SWIGINTERN VALUE

2918

_wrap_streamReadRecord(int argc, VALUE *argv, VALUE self) {

2919

int arg1 ;

2920

double *arg2 = (double *) 0 ;

2921

int *arg3 = (int *) 0 ;

2922

int val1 ;

2923

int ecode1 = 0 ;

2924

void *argp2 = 0 ;

2925

int res2 = 0 ;

2926

void *argp3 = 0 ;

2927

int res3 = 0 ;

2928

2929

if ((argc < 3) || (argc > 3)) {

2930

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

2931

}

2932

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2933

if (!SWIG_IsOK(ecode1)) {

2934

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamReadRecord", 1, argv[0] ));

2935

}

2936

arg1 = (int)(val1);

2937

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

2938

if (!SWIG_IsOK(res2)) {

2939

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","streamReadRecord", 2, argv[1] ));

2940

}

2941

arg2 = (double *)(argp2);

2942

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );

2943

if (!SWIG_IsOK(res3)) {

2944

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","streamReadRecord", 3, argv[2] ));

2945

}

2946

arg3 = (int *)(argp3);

2947

streamReadRecord(arg1,arg2,arg3);

2948

return Qnil;

2949

fail:

2950

return Qnil;

2951

}

2952

2953

2954

SWIGINTERN VALUE

2955

_wrap_streamWriteRecord(int argc, VALUE *argv, VALUE self) {

2956

int arg1 ;

2957

double *arg2 = (double *) 0 ;

2958

int arg3 ;

2959

int val1 ;

2960

int ecode1 = 0 ;

2961

void *argp2 = 0 ;

2962

int res2 = 0 ;

2963

int val3 ;

2964

int ecode3 = 0 ;

2965

2966

if ((argc < 3) || (argc > 3)) {

2967

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

2968

}

2969

ecode1 = SWIG_AsVal_int(argv[0], &val1);

2970

if (!SWIG_IsOK(ecode1)) {

2971

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamWriteRecord", 1, argv[0] ));

2972

}

2973

arg1 = (int)(val1);

2974

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

2975

if (!SWIG_IsOK(res2)) {

2976

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","streamWriteRecord", 2, argv[1] ));

2977

}

2978

arg2 = (double *)(argp2);

2979

ecode3 = SWIG_AsVal_int(argv[2], &val3);

2980

if (!SWIG_IsOK(ecode3)) {

2981

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","streamWriteRecord", 3, argv[2] ));

2982

}

2983

arg3 = (int)(val3);

2984

streamWriteRecord(arg1,(double const *)arg2,arg3);

2985

return Qnil;

2986

fail:

2987

return Qnil;

2988

}

2989

2990

2991

SWIGINTERN VALUE

2992

_wrap_streamCopyRecord(int argc, VALUE *argv, VALUE self) {

2993

int arg1 ;

2994

int arg2 ;

2995

int val1 ;

2996

int ecode1 = 0 ;

2997

int val2 ;

2998

int ecode2 = 0 ;

2999

3000

if ((argc < 2) || (argc > 2)) {

3001

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3002

}

3003

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3004

if (!SWIG_IsOK(ecode1)) {

3005

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamCopyRecord", 1, argv[0] ));

3006

}

3007

arg1 = (int)(val1);

3008

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3009

if (!SWIG_IsOK(ecode2)) {

3010

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamCopyRecord", 2, argv[1] ));

3011

}

3012

arg2 = (int)(val2);

3013

streamCopyRecord(arg1,arg2);

3014

return Qnil;

3015

fail:

3016

return Qnil;

3017

}

3018

3019

3020

SWIGINTERN VALUE

3021

_wrap_streamInqGinfo(int argc, VALUE *argv, VALUE self) {

3022

int arg1 ;

3023

int *arg2 = (int *) 0 ;

3024

float *arg3 = (float *) 0 ;

3025

int val1 ;

3026

int ecode1 = 0 ;

3027

void *argp2 = 0 ;

3028

int res2 = 0 ;

3029

void *argp3 = 0 ;

3030

int res3 = 0 ;

3031

3032

if ((argc < 3) || (argc > 3)) {

3033

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

3034

}

3035

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3036

if (!SWIG_IsOK(ecode1)) {

3037

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqGinfo", 1, argv[0] ));

3038

}

3039

arg1 = (int)(val1);

3040

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );

3041

if (!SWIG_IsOK(res2)) {

3042

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","streamInqGinfo", 2, argv[1] ));

3043

}

3044

arg2 = (int *)(argp2);

3045

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_float, 0 | 0 );

3046

if (!SWIG_IsOK(res3)) {

3047

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float *","streamInqGinfo", 3, argv[2] ));

3048

}

3049

arg3 = (float *)(argp3);

3050

streamInqGinfo(arg1,arg2,arg3);

3051

return Qnil;

3052

fail:

3053

return Qnil;

3054

}

3055

3056

3057

SWIGINTERN VALUE

3058

_wrap_vlistCreate(int argc, VALUE *argv, VALUE self) {

3059

int result;

3060

VALUE vresult = Qnil;

3061

3062

if ((argc < 0) || (argc > 0)) {

3063

rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;

3064

}

3065

result = (int)vlistCreate();

3066

vresult = SWIG_From_int((int)(result));

3067

return vresult;

3068

fail:

3069

return Qnil;

3070

}

3071

3072

3073

SWIGINTERN VALUE

3074

_wrap_vlistDestroy(int argc, VALUE *argv, VALUE self) {

3075

int arg1 ;

3076

int val1 ;

3077

int ecode1 = 0 ;

3078

3079

if ((argc < 1) || (argc > 1)) {

3080

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3081

}

3082

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3083

if (!SWIG_IsOK(ecode1)) {

3084

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDestroy", 1, argv[0] ));

3085

}

3086

arg1 = (int)(val1);

3087

vlistDestroy(arg1);

3088

return Qnil;

3089

fail:

3090

return Qnil;

3091

}

3092

3093

3094

SWIGINTERN VALUE

3095

_wrap_vlistDuplicate(int argc, VALUE *argv, VALUE self) {

3096

int arg1 ;

3097

int val1 ;

3098

int ecode1 = 0 ;

3099

int result;

3100

VALUE vresult = Qnil;

3101

3102

if ((argc < 1) || (argc > 1)) {

3103

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3104

}

3105

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3106

if (!SWIG_IsOK(ecode1)) {

3107

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDuplicate", 1, argv[0] ));

3108

}

3109

arg1 = (int)(val1);

3110

result = (int)vlistDuplicate(arg1);

3111

vresult = SWIG_From_int((int)(result));

3112

return vresult;

3113

fail:

3114

return Qnil;

3115

}

3116

3117

3118

SWIGINTERN VALUE

3119

_wrap_vlistCopy(int argc, VALUE *argv, VALUE self) {

3120

int arg1 ;

3121

int arg2 ;

3122

int val1 ;

3123

int ecode1 = 0 ;

3124

int val2 ;

3125

int ecode2 = 0 ;

3126

3127

if ((argc < 2) || (argc > 2)) {

3128

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3129

}

3130

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3131

if (!SWIG_IsOK(ecode1)) {

3132

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCopy", 1, argv[0] ));

3133

}

3134

arg1 = (int)(val1);

3135

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3136

if (!SWIG_IsOK(ecode2)) {

3137

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCopy", 2, argv[1] ));

3138

}

3139

arg2 = (int)(val2);

3140

vlistCopy(arg1,arg2);

3141

return Qnil;

3142

fail:

3143

return Qnil;

3144

}

3145

3146

3147

SWIGINTERN VALUE

3148

_wrap_vlistCopyFlag(int argc, VALUE *argv, VALUE self) {

3149

int arg1 ;

3150

int arg2 ;

3151

int val1 ;

3152

int ecode1 = 0 ;

3153

int val2 ;

3154

int ecode2 = 0 ;

3155

3156

if ((argc < 2) || (argc > 2)) {

3157

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3158

}

3159

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3160

if (!SWIG_IsOK(ecode1)) {

3161

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCopyFlag", 1, argv[0] ));

3162

}

3163

arg1 = (int)(val1);

3164

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3165

if (!SWIG_IsOK(ecode2)) {

3166

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCopyFlag", 2, argv[1] ));

3167

}

3168

arg2 = (int)(val2);

3169

vlistCopyFlag(arg1,arg2);

3170

return Qnil;

3171

fail:

3172

return Qnil;

3173

}

3174

3175

3176

SWIGINTERN VALUE

3177

_wrap_vlistClearFlag(int argc, VALUE *argv, VALUE self) {

3178

int arg1 ;

3179

int val1 ;

3180

int ecode1 = 0 ;

3181

3182

if ((argc < 1) || (argc > 1)) {

3183

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3184

}

3185

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3186

if (!SWIG_IsOK(ecode1)) {

3187

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistClearFlag", 1, argv[0] ));

3188

}

3189

arg1 = (int)(val1);

3190

vlistClearFlag(arg1);

3191

return Qnil;

3192

fail:

3193

return Qnil;

3194

}

3195

3196

3197

SWIGINTERN VALUE

3198

_wrap_vlistCat(int argc, VALUE *argv, VALUE self) {

3199

int arg1 ;

3200

int arg2 ;

3201

int val1 ;

3202

int ecode1 = 0 ;

3203

int val2 ;

3204

int ecode2 = 0 ;

3205

3206

if ((argc < 2) || (argc > 2)) {

3207

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3208

}

3209

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3210

if (!SWIG_IsOK(ecode1)) {

3211

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistCat", 1, argv[0] ));

3212

}

3213

arg1 = (int)(val1);

3214

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3215

if (!SWIG_IsOK(ecode2)) {

3216

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistCat", 2, argv[1] ));

3217

}

3218

arg2 = (int)(val2);

3219

vlistCat(arg1,arg2);

3220

return Qnil;

3221

fail:

3222

return Qnil;

3223

}

3224

3225

3226

SWIGINTERN VALUE

3227

_wrap_vlistMerge(int argc, VALUE *argv, VALUE self) {

3228

int arg1 ;

3229

int arg2 ;

3230

int val1 ;

3231

int ecode1 = 0 ;

3232

int val2 ;

3233

int ecode2 = 0 ;

3234

3235

if ((argc < 2) || (argc > 2)) {

3236

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3237

}

3238

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3239

if (!SWIG_IsOK(ecode1)) {

3240

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMerge", 1, argv[0] ));

3241

}

3242

arg1 = (int)(val1);

3243

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3244

if (!SWIG_IsOK(ecode2)) {

3245

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMerge", 2, argv[1] ));

3246

}

3247

arg2 = (int)(val2);

3248

vlistMerge(arg1,arg2);

3249

return Qnil;

3250

fail:

3251

return Qnil;

3252

}

3253

3254

3255

SWIGINTERN VALUE

3256

_wrap_vlistPrint(int argc, VALUE *argv, VALUE self) {

3257

int arg1 ;

3258

int val1 ;

3259

int ecode1 = 0 ;

3260

3261

if ((argc < 1) || (argc > 1)) {

3262

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3263

}

3264

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3265

if (!SWIG_IsOK(ecode1)) {

3266

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistPrint", 1, argv[0] ));

3267

}

3268

arg1 = (int)(val1);

3269

vlistPrint(arg1);

3270

return Qnil;

3271

fail:

3272

return Qnil;

3273

}

3274

3275

3276

SWIGINTERN VALUE

3277

_wrap_vlistNvars(int argc, VALUE *argv, VALUE self) {

3278

int arg1 ;

3279

int val1 ;

3280

int ecode1 = 0 ;

3281

int result;

3282

VALUE vresult = Qnil;

3283

3284

if ((argc < 1) || (argc > 1)) {

3285

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3286

}

3287

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3288

if (!SWIG_IsOK(ecode1)) {

3289

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNvars", 1, argv[0] ));

3290

}

3291

arg1 = (int)(val1);

3292

result = (int)vlistNvars(arg1);

3293

vresult = SWIG_From_int((int)(result));

3294

return vresult;

3295

fail:

3296

return Qnil;

3297

}

3298

3299

3300

SWIGINTERN VALUE

3301

_wrap_vlistNgrids(int argc, VALUE *argv, VALUE self) {

3302

int arg1 ;

3303

int val1 ;

3304

int ecode1 = 0 ;

3305

int result;

3306

VALUE vresult = Qnil;

3307

3308

if ((argc < 1) || (argc > 1)) {

3309

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3310

}

3311

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3312

if (!SWIG_IsOK(ecode1)) {

3313

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNgrids", 1, argv[0] ));

3314

}

3315

arg1 = (int)(val1);

3316

result = (int)vlistNgrids(arg1);

3317

vresult = SWIG_From_int((int)(result));

3318

return vresult;

3319

fail:

3320

return Qnil;

3321

}

3322

3323

3324

SWIGINTERN VALUE

3325

_wrap_vlistNzaxis(int argc, VALUE *argv, VALUE self) {

3326

int arg1 ;

3327

int val1 ;

3328

int ecode1 = 0 ;

3329

int result;

3330

VALUE vresult = Qnil;

3331

3332

if ((argc < 1) || (argc > 1)) {

3333

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3334

}

3335

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3336

if (!SWIG_IsOK(ecode1)) {

3337

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNzaxis", 1, argv[0] ));

3338

}

3339

arg1 = (int)(val1);

3340

result = (int)vlistNzaxis(arg1);

3341

vresult = SWIG_From_int((int)(result));

3342

return vresult;

3343

fail:

3344

return Qnil;

3345

}

3346

3347

3348

SWIGINTERN VALUE

3349

_wrap_vlistDefNtsteps(int argc, VALUE *argv, VALUE self) {

3350

int arg1 ;

3351

int arg2 ;

3352

int val1 ;

3353

int ecode1 = 0 ;

3354

int val2 ;

3355

int ecode2 = 0 ;

3356

3357

if ((argc < 2) || (argc > 2)) {

3358

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3359

}

3360

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3361

if (!SWIG_IsOK(ecode1)) {

3362

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefNtsteps", 1, argv[0] ));

3363

}

3364

arg1 = (int)(val1);

3365

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3366

if (!SWIG_IsOK(ecode2)) {

3367

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefNtsteps", 2, argv[1] ));

3368

}

3369

arg2 = (int)(val2);

3370

vlistDefNtsteps(arg1,arg2);

3371

return Qnil;

3372

fail:

3373

return Qnil;

3374

}

3375

3376

3377

SWIGINTERN VALUE

3378

_wrap_vlistNtsteps(int argc, VALUE *argv, VALUE self) {

3379

int arg1 ;

3380

int val1 ;

3381

int ecode1 = 0 ;

3382

int result;

3383

VALUE vresult = Qnil;

3384

3385

if ((argc < 1) || (argc > 1)) {

3386

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3387

}

3388

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3389

if (!SWIG_IsOK(ecode1)) {

3390

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNtsteps", 1, argv[0] ));

3391

}

3392

arg1 = (int)(val1);

3393

result = (int)vlistNtsteps(arg1);

3394

vresult = SWIG_From_int((int)(result));

3395

return vresult;

3396

fail:

3397

return Qnil;

3398

}

3399

3400

3401

SWIGINTERN VALUE

3402

_wrap_vlistGridsizeMax(int argc, VALUE *argv, VALUE self) {

3403

int arg1 ;

3404

int val1 ;

3405

int ecode1 = 0 ;

3406

int result;

3407

VALUE vresult = Qnil;

3408

3409

if ((argc < 1) || (argc > 1)) {

3410

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3411

}

3412

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3413

if (!SWIG_IsOK(ecode1)) {

3414

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGridsizeMax", 1, argv[0] ));

3415

}

3416

arg1 = (int)(val1);

3417

result = (int)vlistGridsizeMax(arg1);

3418

vresult = SWIG_From_int((int)(result));

3419

return vresult;

3420

fail:

3421

return Qnil;

3422

}

3423

3424

3425

SWIGINTERN VALUE

3426

_wrap_vlistGrid(int argc, VALUE *argv, VALUE self) {

3427

int arg1 ;

3428

int arg2 ;

3429

int val1 ;

3430

int ecode1 = 0 ;

3431

int val2 ;

3432

int ecode2 = 0 ;

3433

int result;

3434

VALUE vresult = Qnil;

3435

3436

if ((argc < 2) || (argc > 2)) {

3437

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3438

}

3439

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3440

if (!SWIG_IsOK(ecode1)) {

3441

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGrid", 1, argv[0] ));

3442

}

3443

arg1 = (int)(val1);

3444

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3445

if (!SWIG_IsOK(ecode2)) {

3446

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistGrid", 2, argv[1] ));

3447

}

3448

arg2 = (int)(val2);

3449

result = (int)vlistGrid(arg1,arg2);

3450

vresult = SWIG_From_int((int)(result));

3451

return vresult;

3452

fail:

3453

return Qnil;

3454

}

3455

3456

3457

SWIGINTERN VALUE

3458

_wrap_vlistGridIndex(int argc, VALUE *argv, VALUE self) {

3459

int arg1 ;

3460

int arg2 ;

3461

int val1 ;

3462

int ecode1 = 0 ;

3463

int val2 ;

3464

int ecode2 = 0 ;

3465

int result;

3466

VALUE vresult = Qnil;

3467

3468

if ((argc < 2) || (argc > 2)) {

3469

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3470

}

3471

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3472

if (!SWIG_IsOK(ecode1)) {

3473

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistGridIndex", 1, argv[0] ));

3474

}

3475

arg1 = (int)(val1);

3476

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3477

if (!SWIG_IsOK(ecode2)) {

3478

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistGridIndex", 2, argv[1] ));

3479

}

3480

arg2 = (int)(val2);

3481

result = (int)vlistGridIndex(arg1,arg2);

3482

vresult = SWIG_From_int((int)(result));

3483

return vresult;

3484

fail:

3485

return Qnil;

3486

}

3487

3488

3489

SWIGINTERN VALUE

3490

_wrap_vlistChangeGridIndex(int argc, VALUE *argv, VALUE self) {

3491

int arg1 ;

3492

int arg2 ;

3493

int arg3 ;

3494

int val1 ;

3495

int ecode1 = 0 ;

3496

int val2 ;

3497

int ecode2 = 0 ;

3498

int val3 ;

3499

int ecode3 = 0 ;

3500

3501

if ((argc < 3) || (argc > 3)) {

3502

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

3503

}

3504

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3505

if (!SWIG_IsOK(ecode1)) {

3506

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 1, argv[0] ));

3507

}

3508

arg1 = (int)(val1);

3509

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3510

if (!SWIG_IsOK(ecode2)) {

3511

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 2, argv[1] ));

3512

}

3513

arg2 = (int)(val2);

3514

ecode3 = SWIG_AsVal_int(argv[2], &val3);

3515

if (!SWIG_IsOK(ecode3)) {

3516

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeGridIndex", 3, argv[2] ));

3517

}

3518

arg3 = (int)(val3);

3519

vlistChangeGridIndex(arg1,arg2,arg3);

3520

return Qnil;

3521

fail:

3522

return Qnil;

3523

}

3524

3525

3526

SWIGINTERN VALUE

3527

_wrap_vlistChangeGrid(int argc, VALUE *argv, VALUE self) {

3528

int arg1 ;

3529

int arg2 ;

3530

int arg3 ;

3531

int val1 ;

3532

int ecode1 = 0 ;

3533

int val2 ;

3534

int ecode2 = 0 ;

3535

int val3 ;

3536

int ecode3 = 0 ;

3537

3538

if ((argc < 3) || (argc > 3)) {

3539

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

3540

}

3541

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3542

if (!SWIG_IsOK(ecode1)) {

3543

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 1, argv[0] ));

3544

}

3545

arg1 = (int)(val1);

3546

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3547

if (!SWIG_IsOK(ecode2)) {

3548

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 2, argv[1] ));

3549

}

3550

arg2 = (int)(val2);

3551

ecode3 = SWIG_AsVal_int(argv[2], &val3);

3552

if (!SWIG_IsOK(ecode3)) {

3553

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeGrid", 3, argv[2] ));

3554

}

3555

arg3 = (int)(val3);

3556

vlistChangeGrid(arg1,arg2,arg3);

3557

return Qnil;

3558

fail:

3559

return Qnil;

3560

}

3561

3562

3563

SWIGINTERN VALUE

3564

_wrap_vlistZaxis(int argc, VALUE *argv, VALUE self) {

3565

int arg1 ;

3566

int arg2 ;

3567

int val1 ;

3568

int ecode1 = 0 ;

3569

int val2 ;

3570

int ecode2 = 0 ;

3571

int result;

3572

VALUE vresult = Qnil;

3573

3574

if ((argc < 2) || (argc > 2)) {

3575

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3576

}

3577

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3578

if (!SWIG_IsOK(ecode1)) {

3579

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistZaxis", 1, argv[0] ));

3580

}

3581

arg1 = (int)(val1);

3582

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3583

if (!SWIG_IsOK(ecode2)) {

3584

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistZaxis", 2, argv[1] ));

3585

}

3586

arg2 = (int)(val2);

3587

result = (int)vlistZaxis(arg1,arg2);

3588

vresult = SWIG_From_int((int)(result));

3589

return vresult;

3590

fail:

3591

return Qnil;

3592

}

3593

3594

3595

SWIGINTERN VALUE

3596

_wrap_vlistZaxisIndex(int argc, VALUE *argv, VALUE self) {

3597

int arg1 ;

3598

int arg2 ;

3599

int val1 ;

3600

int ecode1 = 0 ;

3601

int val2 ;

3602

int ecode2 = 0 ;

3603

int result;

3604

VALUE vresult = Qnil;

3605

3606

if ((argc < 2) || (argc > 2)) {

3607

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3608

}

3609

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3610

if (!SWIG_IsOK(ecode1)) {

3611

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistZaxisIndex", 1, argv[0] ));

3612

}

3613

arg1 = (int)(val1);

3614

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3615

if (!SWIG_IsOK(ecode2)) {

3616

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistZaxisIndex", 2, argv[1] ));

3617

}

3618

arg2 = (int)(val2);

3619

result = (int)vlistZaxisIndex(arg1,arg2);

3620

vresult = SWIG_From_int((int)(result));

3621

return vresult;

3622

fail:

3623

return Qnil;

3624

}

3625

3626

3627

SWIGINTERN VALUE

3628

_wrap_vlistChangeZaxisIndex(int argc, VALUE *argv, VALUE self) {

3629

int arg1 ;

3630

int arg2 ;

3631

int arg3 ;

3632

int val1 ;

3633

int ecode1 = 0 ;

3634

int val2 ;

3635

int ecode2 = 0 ;

3636

int val3 ;

3637

int ecode3 = 0 ;

3638

3639

if ((argc < 3) || (argc > 3)) {

3640

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

3641

}

3642

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3643

if (!SWIG_IsOK(ecode1)) {

3644

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 1, argv[0] ));

3645

}

3646

arg1 = (int)(val1);

3647

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3648

if (!SWIG_IsOK(ecode2)) {

3649

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 2, argv[1] ));

3650

}

3651

arg2 = (int)(val2);

3652

ecode3 = SWIG_AsVal_int(argv[2], &val3);

3653

if (!SWIG_IsOK(ecode3)) {

3654

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeZaxisIndex", 3, argv[2] ));

3655

}

3656

arg3 = (int)(val3);

3657

vlistChangeZaxisIndex(arg1,arg2,arg3);

3658

return Qnil;

3659

fail:

3660

return Qnil;

3661

}

3662

3663

3664

SWIGINTERN VALUE

3665

_wrap_vlistChangeZaxis(int argc, VALUE *argv, VALUE self) {

3666

int arg1 ;

3667

int arg2 ;

3668

int arg3 ;

3669

int val1 ;

3670

int ecode1 = 0 ;

3671

int val2 ;

3672

int ecode2 = 0 ;

3673

int val3 ;

3674

int ecode3 = 0 ;

3675

3676

if ((argc < 3) || (argc > 3)) {

3677

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

3678

}

3679

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3680

if (!SWIG_IsOK(ecode1)) {

3681

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 1, argv[0] ));

3682

}

3683

arg1 = (int)(val1);

3684

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3685

if (!SWIG_IsOK(ecode2)) {

3686

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 2, argv[1] ));

3687

}

3688

arg2 = (int)(val2);

3689

ecode3 = SWIG_AsVal_int(argv[2], &val3);

3690

if (!SWIG_IsOK(ecode3)) {

3691

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeZaxis", 3, argv[2] ));

3692

}

3693

arg3 = (int)(val3);

3694

vlistChangeZaxis(arg1,arg2,arg3);

3695

return Qnil;

3696

fail:

3697

return Qnil;

3698

}

3699

3700

3701

SWIGINTERN VALUE

3702

_wrap_vlistNrecs(int argc, VALUE *argv, VALUE self) {

3703

int arg1 ;

3704

int val1 ;

3705

int ecode1 = 0 ;

3706

int result;

3707

VALUE vresult = Qnil;

3708

3709

if ((argc < 1) || (argc > 1)) {

3710

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3711

}

3712

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3713

if (!SWIG_IsOK(ecode1)) {

3714

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistNrecs", 1, argv[0] ));

3715

}

3716

arg1 = (int)(val1);

3717

result = (int)vlistNrecs(arg1);

3718

vresult = SWIG_From_int((int)(result));

3719

return vresult;

3720

fail:

3721

return Qnil;

3722

}

3723

3724

3725

SWIGINTERN VALUE

3726

_wrap_vlistDefTaxis(int argc, VALUE *argv, VALUE self) {

3727

int arg1 ;

3728

int arg2 ;

3729

int val1 ;

3730

int ecode1 = 0 ;

3731

int val2 ;

3732

int ecode2 = 0 ;

3733

3734

if ((argc < 2) || (argc > 2)) {

3735

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3736

}

3737

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3738

if (!SWIG_IsOK(ecode1)) {

3739

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefTaxis", 1, argv[0] ));

3740

}

3741

arg1 = (int)(val1);

3742

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3743

if (!SWIG_IsOK(ecode2)) {

3744

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefTaxis", 2, argv[1] ));

3745

}

3746

arg2 = (int)(val2);

3747

vlistDefTaxis(arg1,arg2);

3748

return Qnil;

3749

fail:

3750

return Qnil;

3751

}

3752

3753

3754

SWIGINTERN VALUE

3755

_wrap_vlistInqTaxis(int argc, VALUE *argv, VALUE self) {

3756

int arg1 ;

3757

int val1 ;

3758

int ecode1 = 0 ;

3759

int result;

3760

VALUE vresult = Qnil;

3761

3762

if ((argc < 1) || (argc > 1)) {

3763

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3764

}

3765

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3766

if (!SWIG_IsOK(ecode1)) {

3767

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqTaxis", 1, argv[0] ));

3768

}

3769

arg1 = (int)(val1);

3770

result = (int)vlistInqTaxis(arg1);

3771

vresult = SWIG_From_int((int)(result));

3772

return vresult;

3773

fail:

3774

return Qnil;

3775

}

3776

3777

3778

SWIGINTERN VALUE

3779

_wrap_vlistDefTable(int argc, VALUE *argv, VALUE self) {

3780

int arg1 ;

3781

int arg2 ;

3782

int val1 ;

3783

int ecode1 = 0 ;

3784

int val2 ;

3785

int ecode2 = 0 ;

3786

3787

if ((argc < 2) || (argc > 2)) {

3788

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3789

}

3790

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3791

if (!SWIG_IsOK(ecode1)) {

3792

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefTable", 1, argv[0] ));

3793

}

3794

arg1 = (int)(val1);

3795

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3796

if (!SWIG_IsOK(ecode2)) {

3797

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefTable", 2, argv[1] ));

3798

}

3799

arg2 = (int)(val2);

3800

vlistDefTable(arg1,arg2);

3801

return Qnil;

3802

fail:

3803

return Qnil;

3804

}

3805

3806

3807

SWIGINTERN VALUE

3808

_wrap_vlistInqTable(int argc, VALUE *argv, VALUE self) {

3809

int arg1 ;

3810

int val1 ;

3811

int ecode1 = 0 ;

3812

int result;

3813

VALUE vresult = Qnil;

3814

3815

if ((argc < 1) || (argc > 1)) {

3816

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3817

}

3818

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3819

if (!SWIG_IsOK(ecode1)) {

3820

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqTable", 1, argv[0] ));

3821

}

3822

arg1 = (int)(val1);

3823

result = (int)vlistInqTable(arg1);

3824

vresult = SWIG_From_int((int)(result));

3825

return vresult;

3826

fail:

3827

return Qnil;

3828

}

3829

3830

3831

SWIGINTERN VALUE

3832

_wrap_vlistDefInstitut(int argc, VALUE *argv, VALUE self) {

3833

int arg1 ;

3834

int arg2 ;

3835

int val1 ;

3836

int ecode1 = 0 ;

3837

int val2 ;

3838

int ecode2 = 0 ;

3839

3840

if ((argc < 2) || (argc > 2)) {

3841

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3842

}

3843

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3844

if (!SWIG_IsOK(ecode1)) {

3845

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefInstitut", 1, argv[0] ));

3846

}

3847

arg1 = (int)(val1);

3848

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3849

if (!SWIG_IsOK(ecode2)) {

3850

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefInstitut", 2, argv[1] ));

3851

}

3852

arg2 = (int)(val2);

3853

vlistDefInstitut(arg1,arg2);

3854

return Qnil;

3855

fail:

3856

return Qnil;

3857

}

3858

3859

3860

SWIGINTERN VALUE

3861

_wrap_vlistInqInstitut(int argc, VALUE *argv, VALUE self) {

3862

int arg1 ;

3863

int val1 ;

3864

int ecode1 = 0 ;

3865

int result;

3866

VALUE vresult = Qnil;

3867

3868

if ((argc < 1) || (argc > 1)) {

3869

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3870

}

3871

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3872

if (!SWIG_IsOK(ecode1)) {

3873

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqInstitut", 1, argv[0] ));

3874

}

3875

arg1 = (int)(val1);

3876

result = (int)vlistInqInstitut(arg1);

3877

vresult = SWIG_From_int((int)(result));

3878

return vresult;

3879

fail:

3880

return Qnil;

3881

}

3882

3883

3884

SWIGINTERN VALUE

3885

_wrap_vlistDefModel(int argc, VALUE *argv, VALUE self) {

3886

int arg1 ;

3887

int arg2 ;

3888

int val1 ;

3889

int ecode1 = 0 ;

3890

int val2 ;

3891

int ecode2 = 0 ;

3892

3893

if ((argc < 2) || (argc > 2)) {

3894

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

3895

}

3896

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3897

if (!SWIG_IsOK(ecode1)) {

3898

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefModel", 1, argv[0] ));

3899

}

3900

arg1 = (int)(val1);

3901

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3902

if (!SWIG_IsOK(ecode2)) {

3903

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefModel", 2, argv[1] ));

3904

}

3905

arg2 = (int)(val2);

3906

vlistDefModel(arg1,arg2);

3907

return Qnil;

3908

fail:

3909

return Qnil;

3910

}

3911

3912

3913

SWIGINTERN VALUE

3914

_wrap_vlistInqModel(int argc, VALUE *argv, VALUE self) {

3915

int arg1 ;

3916

int val1 ;

3917

int ecode1 = 0 ;

3918

int result;

3919

VALUE vresult = Qnil;

3920

3921

if ((argc < 1) || (argc > 1)) {

3922

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

3923

}

3924

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3925

if (!SWIG_IsOK(ecode1)) {

3926

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqModel", 1, argv[0] ));

3927

}

3928

arg1 = (int)(val1);

3929

result = (int)vlistInqModel(arg1);

3930

vresult = SWIG_From_int((int)(result));

3931

return vresult;

3932

fail:

3933

return Qnil;

3934

}

3935

3936

3937

SWIGINTERN VALUE

3938

_wrap_vlistDefVar(int argc, VALUE *argv, VALUE self) {

3939

int arg1 ;

3940

int arg2 ;

3941

int arg3 ;

3942

int arg4 ;

3943

int val1 ;

3944

int ecode1 = 0 ;

3945

int val2 ;

3946

int ecode2 = 0 ;

3947

int val3 ;

3948

int ecode3 = 0 ;

3949

int val4 ;

3950

int ecode4 = 0 ;

3951

int result;

3952

VALUE vresult = Qnil;

3953

3954

if ((argc < 4) || (argc > 4)) {

3955

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

3956

}

3957

ecode1 = SWIG_AsVal_int(argv[0], &val1);

3958

if (!SWIG_IsOK(ecode1)) {

3959

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVar", 1, argv[0] ));

3960

}

3961

arg1 = (int)(val1);

3962

ecode2 = SWIG_AsVal_int(argv[1], &val2);

3963

if (!SWIG_IsOK(ecode2)) {

3964

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVar", 2, argv[1] ));

3965

}

3966

arg2 = (int)(val2);

3967

ecode3 = SWIG_AsVal_int(argv[2], &val3);

3968

if (!SWIG_IsOK(ecode3)) {

3969

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVar", 3, argv[2] ));

3970

}

3971

arg3 = (int)(val3);

3972

ecode4 = SWIG_AsVal_int(argv[3], &val4);

3973

if (!SWIG_IsOK(ecode4)) {

3974

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefVar", 4, argv[3] ));

3975

}

3976

arg4 = (int)(val4);

3977

result = (int)vlistDefVar(arg1,arg2,arg3,arg4);

3978

vresult = SWIG_From_int((int)(result));

3979

return vresult;

3980

fail:

3981

return Qnil;

3982

}

3983

3984

3985

SWIGINTERN VALUE

3986

_wrap_vlistChangeVarGrid(int argc, VALUE *argv, VALUE self) {

3987

int arg1 ;

3988

int arg2 ;

3989

int arg3 ;

3990

int val1 ;

3991

int ecode1 = 0 ;

3992

int val2 ;

3993

int ecode2 = 0 ;

3994

int val3 ;

3995

int ecode3 = 0 ;

3996

3997

if ((argc < 3) || (argc > 3)) {

3998

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

3999

}

4000

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4001

if (!SWIG_IsOK(ecode1)) {

4002

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 1, argv[0] ));

4003

}

4004

arg1 = (int)(val1);

4005

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4006

if (!SWIG_IsOK(ecode2)) {

4007

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 2, argv[1] ));

4008

}

4009

arg2 = (int)(val2);

4010

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4011

if (!SWIG_IsOK(ecode3)) {

4012

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeVarGrid", 3, argv[2] ));

4013

}

4014

arg3 = (int)(val3);

4015

vlistChangeVarGrid(arg1,arg2,arg3);

4016

return Qnil;

4017

fail:

4018

return Qnil;

4019

}

4020

4021

4022

SWIGINTERN VALUE

4023

_wrap_vlistChangeVarZaxis(int argc, VALUE *argv, VALUE self) {

4024

int arg1 ;

4025

int arg2 ;

4026

int arg3 ;

4027

int val1 ;

4028

int ecode1 = 0 ;

4029

int val2 ;

4030

int ecode2 = 0 ;

4031

int val3 ;

4032

int ecode3 = 0 ;

4033

4034

if ((argc < 3) || (argc > 3)) {

4035

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4036

}

4037

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4038

if (!SWIG_IsOK(ecode1)) {

4039

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 1, argv[0] ));

4040

}

4041

arg1 = (int)(val1);

4042

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4043

if (!SWIG_IsOK(ecode2)) {

4044

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 2, argv[1] ));

4045

}

4046

arg2 = (int)(val2);

4047

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4048

if (!SWIG_IsOK(ecode3)) {

4049

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistChangeVarZaxis", 3, argv[2] ));

4050

}

4051

arg3 = (int)(val3);

4052

vlistChangeVarZaxis(arg1,arg2,arg3);

4053

return Qnil;

4054

fail:

4055

return Qnil;

4056

}

4057

4058

4059

SWIGINTERN VALUE

4060

_wrap_vlistInqVar(int argc, VALUE *argv, VALUE self) {

4061

int arg1 ;

4062

int arg2 ;

4063

int *arg3 = (int *) 0 ;

4064

int *arg4 = (int *) 0 ;

4065

int *arg5 = (int *) 0 ;

4066

int val1 ;

4067

int ecode1 = 0 ;

4068

int val2 ;

4069

int ecode2 = 0 ;

4070

void *argp3 = 0 ;

4071

int res3 = 0 ;

4072

void *argp4 = 0 ;

4073

int res4 = 0 ;

4074

void *argp5 = 0 ;

4075

int res5 = 0 ;

4076

4077

if ((argc < 5) || (argc > 5)) {

4078

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

4079

}

4080

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4081

if (!SWIG_IsOK(ecode1)) {

4082

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVar", 1, argv[0] ));

4083

}

4084

arg1 = (int)(val1);

4085

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4086

if (!SWIG_IsOK(ecode2)) {

4087

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVar", 2, argv[1] ));

4088

}

4089

arg2 = (int)(val2);

4090

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );

4091

if (!SWIG_IsOK(res3)) {

4092

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","vlistInqVar", 3, argv[2] ));

4093

}

4094

arg3 = (int *)(argp3);

4095

res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_int, 0 | 0 );

4096

if (!SWIG_IsOK(res4)) {

4097

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","vlistInqVar", 4, argv[3] ));

4098

}

4099

arg4 = (int *)(argp4);

4100

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );

4101

if (!SWIG_IsOK(res5)) {

4102

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","vlistInqVar", 5, argv[4] ));

4103

}

4104

arg5 = (int *)(argp5);

4105

vlistInqVar(arg1,arg2,arg3,arg4,arg5);

4106

return Qnil;

4107

fail:

4108

return Qnil;

4109

}

4110

4111

4112

SWIGINTERN VALUE

4113

_wrap_vlistInqVarGrid(int argc, VALUE *argv, VALUE self) {

4114

int arg1 ;

4115

int arg2 ;

4116

int val1 ;

4117

int ecode1 = 0 ;

4118

int val2 ;

4119

int ecode2 = 0 ;

4120

int result;

4121

VALUE vresult = Qnil;

4122

4123

if ((argc < 2) || (argc > 2)) {

4124

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4125

}

4126

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4127

if (!SWIG_IsOK(ecode1)) {

4128

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarGrid", 1, argv[0] ));

4129

}

4130

arg1 = (int)(val1);

4131

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4132

if (!SWIG_IsOK(ecode2)) {

4133

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarGrid", 2, argv[1] ));

4134

}

4135

arg2 = (int)(val2);

4136

result = (int)vlistInqVarGrid(arg1,arg2);

4137

vresult = SWIG_From_int((int)(result));

4138

return vresult;

4139

fail:

4140

return Qnil;

4141

}

4142

4143

4144

SWIGINTERN VALUE

4145

_wrap_vlistInqVarZaxis(int argc, VALUE *argv, VALUE self) {

4146

int arg1 ;

4147

int arg2 ;

4148

int val1 ;

4149

int ecode1 = 0 ;

4150

int val2 ;

4151

int ecode2 = 0 ;

4152

int result;

4153

VALUE vresult = Qnil;

4154

4155

if ((argc < 2) || (argc > 2)) {

4156

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4157

}

4158

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4159

if (!SWIG_IsOK(ecode1)) {

4160

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarZaxis", 1, argv[0] ));

4161

}

4162

arg1 = (int)(val1);

4163

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4164

if (!SWIG_IsOK(ecode2)) {

4165

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarZaxis", 2, argv[1] ));

4166

}

4167

arg2 = (int)(val2);

4168

result = (int)vlistInqVarZaxis(arg1,arg2);

4169

vresult = SWIG_From_int((int)(result));

4170

return vresult;

4171

fail:

4172

return Qnil;

4173

}

4174

4175

4176

SWIGINTERN VALUE

4177

_wrap_vlistInqVarTime(int argc, VALUE *argv, VALUE self) {

4178

int arg1 ;

4179

int arg2 ;

4180

int val1 ;

4181

int ecode1 = 0 ;

4182

int val2 ;

4183

int ecode2 = 0 ;

4184

int result;

4185

VALUE vresult = Qnil;

4186

4187

if ((argc < 2) || (argc > 2)) {

4188

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4189

}

4190

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4191

if (!SWIG_IsOK(ecode1)) {

4192

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTime", 1, argv[0] ));

4193

}

4194

arg1 = (int)(val1);

4195

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4196

if (!SWIG_IsOK(ecode2)) {

4197

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTime", 2, argv[1] ));

4198

}

4199

arg2 = (int)(val2);

4200

result = (int)vlistInqVarTime(arg1,arg2);

4201

vresult = SWIG_From_int((int)(result));

4202

return vresult;

4203

fail:

4204

return Qnil;

4205

}

4206

4207

4208

SWIGINTERN VALUE

4209

_wrap_vlistDefVarZtype(int argc, VALUE *argv, VALUE self) {

4210

int arg1 ;

4211

int arg2 ;

4212

int arg3 ;

4213

int val1 ;

4214

int ecode1 = 0 ;

4215

int val2 ;

4216

int ecode2 = 0 ;

4217

int val3 ;

4218

int ecode3 = 0 ;

4219

4220

if ((argc < 3) || (argc > 3)) {

4221

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4222

}

4223

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4224

if (!SWIG_IsOK(ecode1)) {

4225

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarZtype", 1, argv[0] ));

4226

}

4227

arg1 = (int)(val1);

4228

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4229

if (!SWIG_IsOK(ecode2)) {

4230

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarZtype", 2, argv[1] ));

4231

}

4232

arg2 = (int)(val2);

4233

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4234

if (!SWIG_IsOK(ecode3)) {

4235

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarZtype", 3, argv[2] ));

4236

}

4237

arg3 = (int)(val3);

4238

vlistDefVarZtype(arg1,arg2,arg3);

4239

return Qnil;

4240

fail:

4241

return Qnil;

4242

}

4243

4244

4245

SWIGINTERN VALUE

4246

_wrap_vlistInqVarZtype(int argc, VALUE *argv, VALUE self) {

4247

int arg1 ;

4248

int arg2 ;

4249

int val1 ;

4250

int ecode1 = 0 ;

4251

int val2 ;

4252

int ecode2 = 0 ;

4253

int result;

4254

VALUE vresult = Qnil;

4255

4256

if ((argc < 2) || (argc > 2)) {

4257

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4258

}

4259

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4260

if (!SWIG_IsOK(ecode1)) {

4261

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarZtype", 1, argv[0] ));

4262

}

4263

arg1 = (int)(val1);

4264

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4265

if (!SWIG_IsOK(ecode2)) {

4266

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarZtype", 2, argv[1] ));

4267

}

4268

arg2 = (int)(val2);

4269

result = (int)vlistInqVarZtype(arg1,arg2);

4270

vresult = SWIG_From_int((int)(result));

4271

return vresult;

4272

fail:

4273

return Qnil;

4274

}

4275

4276

4277

SWIGINTERN VALUE

4278

_wrap_vlistDefVarZlevel(int argc, VALUE *argv, VALUE self) {

4279

int arg1 ;

4280

int arg2 ;

4281

int arg3 ;

4282

int val1 ;

4283

int ecode1 = 0 ;

4284

int val2 ;

4285

int ecode2 = 0 ;

4286

int val3 ;

4287

int ecode3 = 0 ;

4288

4289

if ((argc < 3) || (argc > 3)) {

4290

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4291

}

4292

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4293

if (!SWIG_IsOK(ecode1)) {

4294

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarZlevel", 1, argv[0] ));

4295

}

4296

arg1 = (int)(val1);

4297

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4298

if (!SWIG_IsOK(ecode2)) {

4299

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarZlevel", 2, argv[1] ));

4300

}

4301

arg2 = (int)(val2);

4302

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4303

if (!SWIG_IsOK(ecode3)) {

4304

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarZlevel", 3, argv[2] ));

4305

}

4306

arg3 = (int)(val3);

4307

vlistDefVarZlevel(arg1,arg2,arg3);

4308

return Qnil;

4309

fail:

4310

return Qnil;

4311

}

4312

4313

4314

SWIGINTERN VALUE

4315

_wrap_vlistInqVarZlevel(int argc, VALUE *argv, VALUE self) {

4316

int arg1 ;

4317

int arg2 ;

4318

int val1 ;

4319

int ecode1 = 0 ;

4320

int val2 ;

4321

int ecode2 = 0 ;

4322

int result;

4323

VALUE vresult = Qnil;

4324

4325

if ((argc < 2) || (argc > 2)) {

4326

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4327

}

4328

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4329

if (!SWIG_IsOK(ecode1)) {

4330

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarZlevel", 1, argv[0] ));

4331

}

4332

arg1 = (int)(val1);

4333

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4334

if (!SWIG_IsOK(ecode2)) {

4335

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarZlevel", 2, argv[1] ));

4336

}

4337

arg2 = (int)(val2);

4338

result = (int)vlistInqVarZlevel(arg1,arg2);

4339

vresult = SWIG_From_int((int)(result));

4340

return vresult;

4341

fail:

4342

return Qnil;

4343

}

4344

4345

4346

SWIGINTERN VALUE

4347

_wrap_vlistDefVarCode(int argc, VALUE *argv, VALUE self) {

4348

int arg1 ;

4349

int arg2 ;

4350

int arg3 ;

4351

int val1 ;

4352

int ecode1 = 0 ;

4353

int val2 ;

4354

int ecode2 = 0 ;

4355

int val3 ;

4356

int ecode3 = 0 ;

4357

4358

if ((argc < 3) || (argc > 3)) {

4359

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4360

}

4361

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4362

if (!SWIG_IsOK(ecode1)) {

4363

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 1, argv[0] ));

4364

}

4365

arg1 = (int)(val1);

4366

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4367

if (!SWIG_IsOK(ecode2)) {

4368

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 2, argv[1] ));

4369

}

4370

arg2 = (int)(val2);

4371

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4372

if (!SWIG_IsOK(ecode3)) {

4373

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarCode", 3, argv[2] ));

4374

}

4375

arg3 = (int)(val3);

4376

vlistDefVarCode(arg1,arg2,arg3);

4377

return Qnil;

4378

fail:

4379

return Qnil;

4380

}

4381

4382

4383

SWIGINTERN VALUE

4384

_wrap_vlistInqVarCode(int argc, VALUE *argv, VALUE self) {

4385

int arg1 ;

4386

int arg2 ;

4387

int val1 ;

4388

int ecode1 = 0 ;

4389

int val2 ;

4390

int ecode2 = 0 ;

4391

int result;

4392

VALUE vresult = Qnil;

4393

4394

if ((argc < 2) || (argc > 2)) {

4395

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4396

}

4397

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4398

if (!SWIG_IsOK(ecode1)) {

4399

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarCode", 1, argv[0] ));

4400

}

4401

arg1 = (int)(val1);

4402

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4403

if (!SWIG_IsOK(ecode2)) {

4404

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarCode", 2, argv[1] ));

4405

}

4406

arg2 = (int)(val2);

4407

result = (int)vlistInqVarCode(arg1,arg2);

4408

vresult = SWIG_From_int((int)(result));

4409

return vresult;

4410

fail:

4411

return Qnil;

4412

}

4413

4414

4415

SWIGINTERN VALUE

4416

_wrap_vlistDefVarDatatype(int argc, VALUE *argv, VALUE self) {

4417

int arg1 ;

4418

int arg2 ;

4419

int arg3 ;

4420

int val1 ;

4421

int ecode1 = 0 ;

4422

int val2 ;

4423

int ecode2 = 0 ;

4424

int val3 ;

4425

int ecode3 = 0 ;

4426

4427

if ((argc < 3) || (argc > 3)) {

4428

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4429

}

4430

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4431

if (!SWIG_IsOK(ecode1)) {

4432

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 1, argv[0] ));

4433

}

4434

arg1 = (int)(val1);

4435

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4436

if (!SWIG_IsOK(ecode2)) {

4437

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 2, argv[1] ));

4438

}

4439

arg2 = (int)(val2);

4440

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4441

if (!SWIG_IsOK(ecode3)) {

4442

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarDatatype", 3, argv[2] ));

4443

}

4444

arg3 = (int)(val3);

4445

vlistDefVarDatatype(arg1,arg2,arg3);

4446

return Qnil;

4447

fail:

4448

return Qnil;

4449

}

4450

4451

4452

SWIGINTERN VALUE

4453

_wrap_vlistInqVarDatatype(int argc, VALUE *argv, VALUE self) {

4454

int arg1 ;

4455

int arg2 ;

4456

int val1 ;

4457

int ecode1 = 0 ;

4458

int val2 ;

4459

int ecode2 = 0 ;

4460

int result;

4461

VALUE vresult = Qnil;

4462

4463

if ((argc < 2) || (argc > 2)) {

4464

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4465

}

4466

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4467

if (!SWIG_IsOK(ecode1)) {

4468

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarDatatype", 1, argv[0] ));

4469

}

4470

arg1 = (int)(val1);

4471

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4472

if (!SWIG_IsOK(ecode2)) {

4473

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarDatatype", 2, argv[1] ));

4474

}

4475

arg2 = (int)(val2);

4476

result = (int)vlistInqVarDatatype(arg1,arg2);

4477

vresult = SWIG_From_int((int)(result));

4478

return vresult;

4479

fail:

4480

return Qnil;

4481

}

4482

4483

4484

SWIGINTERN VALUE

4485

_wrap_vlistDefVarInstitut(int argc, VALUE *argv, VALUE self) {

4486

int arg1 ;

4487

int arg2 ;

4488

int arg3 ;

4489

int val1 ;

4490

int ecode1 = 0 ;

4491

int val2 ;

4492

int ecode2 = 0 ;

4493

int val3 ;

4494

int ecode3 = 0 ;

4495

4496

if ((argc < 3) || (argc > 3)) {

4497

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4498

}

4499

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4500

if (!SWIG_IsOK(ecode1)) {

4501

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 1, argv[0] ));

4502

}

4503

arg1 = (int)(val1);

4504

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4505

if (!SWIG_IsOK(ecode2)) {

4506

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 2, argv[1] ));

4507

}

4508

arg2 = (int)(val2);

4509

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4510

if (!SWIG_IsOK(ecode3)) {

4511

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarInstitut", 3, argv[2] ));

4512

}

4513

arg3 = (int)(val3);

4514

vlistDefVarInstitut(arg1,arg2,arg3);

4515

return Qnil;

4516

fail:

4517

return Qnil;

4518

}

4519

4520

4521

SWIGINTERN VALUE

4522

_wrap_vlistInqVarInstitut(int argc, VALUE *argv, VALUE self) {

4523

int arg1 ;

4524

int arg2 ;

4525

int val1 ;

4526

int ecode1 = 0 ;

4527

int val2 ;

4528

int ecode2 = 0 ;

4529

int result;

4530

VALUE vresult = Qnil;

4531

4532

if ((argc < 2) || (argc > 2)) {

4533

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4534

}

4535

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4536

if (!SWIG_IsOK(ecode1)) {

4537

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarInstitut", 1, argv[0] ));

4538

}

4539

arg1 = (int)(val1);

4540

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4541

if (!SWIG_IsOK(ecode2)) {

4542

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarInstitut", 2, argv[1] ));

4543

}

4544

arg2 = (int)(val2);

4545

result = (int)vlistInqVarInstitut(arg1,arg2);

4546

vresult = SWIG_From_int((int)(result));

4547

return vresult;

4548

fail:

4549

return Qnil;

4550

}

4551

4552

4553

SWIGINTERN VALUE

4554

_wrap_vlistDefVarModel(int argc, VALUE *argv, VALUE self) {

4555

int arg1 ;

4556

int arg2 ;

4557

int arg3 ;

4558

int val1 ;

4559

int ecode1 = 0 ;

4560

int val2 ;

4561

int ecode2 = 0 ;

4562

int val3 ;

4563

int ecode3 = 0 ;

4564

4565

if ((argc < 3) || (argc > 3)) {

4566

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4567

}

4568

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4569

if (!SWIG_IsOK(ecode1)) {

4570

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 1, argv[0] ));

4571

}

4572

arg1 = (int)(val1);

4573

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4574

if (!SWIG_IsOK(ecode2)) {

4575

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 2, argv[1] ));

4576

}

4577

arg2 = (int)(val2);

4578

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4579

if (!SWIG_IsOK(ecode3)) {

4580

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarModel", 3, argv[2] ));

4581

}

4582

arg3 = (int)(val3);

4583

vlistDefVarModel(arg1,arg2,arg3);

4584

return Qnil;

4585

fail:

4586

return Qnil;

4587

}

4588

4589

4590

SWIGINTERN VALUE

4591

_wrap_vlistInqVarModel(int argc, VALUE *argv, VALUE self) {

4592

int arg1 ;

4593

int arg2 ;

4594

int val1 ;

4595

int ecode1 = 0 ;

4596

int val2 ;

4597

int ecode2 = 0 ;

4598

int result;

4599

VALUE vresult = Qnil;

4600

4601

if ((argc < 2) || (argc > 2)) {

4602

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4603

}

4604

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4605

if (!SWIG_IsOK(ecode1)) {

4606

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarModel", 1, argv[0] ));

4607

}

4608

arg1 = (int)(val1);

4609

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4610

if (!SWIG_IsOK(ecode2)) {

4611

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarModel", 2, argv[1] ));

4612

}

4613

arg2 = (int)(val2);

4614

result = (int)vlistInqVarModel(arg1,arg2);

4615

vresult = SWIG_From_int((int)(result));

4616

return vresult;

4617

fail:

4618

return Qnil;

4619

}

4620

4621

4622

SWIGINTERN VALUE

4623

_wrap_vlistDefVarTable(int argc, VALUE *argv, VALUE self) {

4624

int arg1 ;

4625

int arg2 ;

4626

int arg3 ;

4627

int val1 ;

4628

int ecode1 = 0 ;

4629

int val2 ;

4630

int ecode2 = 0 ;

4631

int val3 ;

4632

int ecode3 = 0 ;

4633

4634

if ((argc < 3) || (argc > 3)) {

4635

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4636

}

4637

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4638

if (!SWIG_IsOK(ecode1)) {

4639

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 1, argv[0] ));

4640

}

4641

arg1 = (int)(val1);

4642

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4643

if (!SWIG_IsOK(ecode2)) {

4644

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 2, argv[1] ));

4645

}

4646

arg2 = (int)(val2);

4647

ecode3 = SWIG_AsVal_int(argv[2], &val3);

4648

if (!SWIG_IsOK(ecode3)) {

4649

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTable", 3, argv[2] ));

4650

}

4651

arg3 = (int)(val3);

4652

vlistDefVarTable(arg1,arg2,arg3);

4653

return Qnil;

4654

fail:

4655

return Qnil;

4656

}

4657

4658

4659

SWIGINTERN VALUE

4660

_wrap_vlistInqVarTable(int argc, VALUE *argv, VALUE self) {

4661

int arg1 ;

4662

int arg2 ;

4663

int val1 ;

4664

int ecode1 = 0 ;

4665

int val2 ;

4666

int ecode2 = 0 ;

4667

int result;

4668

VALUE vresult = Qnil;

4669

4670

if ((argc < 2) || (argc > 2)) {

4671

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

4672

}

4673

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4674

if (!SWIG_IsOK(ecode1)) {

4675

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTable", 1, argv[0] ));

4676

}

4677

arg1 = (int)(val1);

4678

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4679

if (!SWIG_IsOK(ecode2)) {

4680

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTable", 2, argv[1] ));

4681

}

4682

arg2 = (int)(val2);

4683

result = (int)vlistInqVarTable(arg1,arg2);

4684

vresult = SWIG_From_int((int)(result));

4685

return vresult;

4686

fail:

4687

return Qnil;

4688

}

4689

4690

4691

SWIGINTERN VALUE

4692

_wrap_vlistDefVarName(int argc, VALUE *argv, VALUE self) {

4693

int arg1 ;

4694

int arg2 ;

4695

char *arg3 = (char *) 0 ;

4696

int val1 ;

4697

int ecode1 = 0 ;

4698

int val2 ;

4699

int ecode2 = 0 ;

4700

int res3 ;

4701

char *buf3 = 0 ;

4702

int alloc3 = 0 ;

4703

4704

if ((argc < 3) || (argc > 3)) {

4705

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4706

}

4707

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4708

if (!SWIG_IsOK(ecode1)) {

4709

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarName", 1, argv[0] ));

4710

}

4711

arg1 = (int)(val1);

4712

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4713

if (!SWIG_IsOK(ecode2)) {

4714

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarName", 2, argv[1] ));

4715

}

4716

arg2 = (int)(val2);

4717

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

4718

if (!SWIG_IsOK(res3)) {

4719

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarName", 3, argv[2] ));

4720

}

4721

arg3 = (char *)(buf3);

4722

vlistDefVarName(arg1,arg2,(char const *)arg3);

4723

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4724

return Qnil;

4725

fail:

4726

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4727

return Qnil;

4728

}

4729

4730

4731

SWIGINTERN VALUE

4732

_wrap_vlistInqVarName(int argc, VALUE *argv, VALUE self) {

4733

int arg1 ;

4734

int arg2 ;

4735

char *arg3 = (char *) 0 ;

4736

int val1 ;

4737

int ecode1 = 0 ;

4738

int val2 ;

4739

int ecode2 = 0 ;

4740

int res3 ;

4741

char *buf3 = 0 ;

4742

int alloc3 = 0 ;

4743

4744

if ((argc < 3) || (argc > 3)) {

4745

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4746

}

4747

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4748

if (!SWIG_IsOK(ecode1)) {

4749

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarName", 1, argv[0] ));

4750

}

4751

arg1 = (int)(val1);

4752

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4753

if (!SWIG_IsOK(ecode2)) {

4754

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarName", 2, argv[1] ));

4755

}

4756

arg2 = (int)(val2);

4757

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

4758

if (!SWIG_IsOK(res3)) {

4759

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarName", 3, argv[2] ));

4760

}

4761

arg3 = (char *)(buf3);

4762

vlistInqVarName(arg1,arg2,arg3);

4763

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4764

return Qnil;

4765

fail:

4766

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4767

return Qnil;

4768

}

4769

4770

4771

SWIGINTERN VALUE

4772

_wrap_vlistDefVarLongname(int argc, VALUE *argv, VALUE self) {

4773

int arg1 ;

4774

int arg2 ;

4775

char *arg3 = (char *) 0 ;

4776

int val1 ;

4777

int ecode1 = 0 ;

4778

int val2 ;

4779

int ecode2 = 0 ;

4780

int res3 ;

4781

char *buf3 = 0 ;

4782

int alloc3 = 0 ;

4783

4784

if ((argc < 3) || (argc > 3)) {

4785

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4786

}

4787

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4788

if (!SWIG_IsOK(ecode1)) {

4789

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarLongname", 1, argv[0] ));

4790

}

4791

arg1 = (int)(val1);

4792

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4793

if (!SWIG_IsOK(ecode2)) {

4794

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarLongname", 2, argv[1] ));

4795

}

4796

arg2 = (int)(val2);

4797

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

4798

if (!SWIG_IsOK(res3)) {

4799

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarLongname", 3, argv[2] ));

4800

}

4801

arg3 = (char *)(buf3);

4802

vlistDefVarLongname(arg1,arg2,(char const *)arg3);

4803

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4804

return Qnil;

4805

fail:

4806

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4807

return Qnil;

4808

}

4809

4810

4811

SWIGINTERN VALUE

4812

_wrap_vlistDefVarStdname(int argc, VALUE *argv, VALUE self) {

4813

int arg1 ;

4814

int arg2 ;

4815

char *arg3 = (char *) 0 ;

4816

int val1 ;

4817

int ecode1 = 0 ;

4818

int val2 ;

4819

int ecode2 = 0 ;

4820

int res3 ;

4821

char *buf3 = 0 ;

4822

int alloc3 = 0 ;

4823

4824

if ((argc < 3) || (argc > 3)) {

4825

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4826

}

4827

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4828

if (!SWIG_IsOK(ecode1)) {

4829

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarStdname", 1, argv[0] ));

4830

}

4831

arg1 = (int)(val1);

4832

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4833

if (!SWIG_IsOK(ecode2)) {

4834

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarStdname", 2, argv[1] ));

4835

}

4836

arg2 = (int)(val2);

4837

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

4838

if (!SWIG_IsOK(res3)) {

4839

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarStdname", 3, argv[2] ));

4840

}

4841

arg3 = (char *)(buf3);

4842

vlistDefVarStdname(arg1,arg2,(char const *)arg3);

4843

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4844

return Qnil;

4845

fail:

4846

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4847

return Qnil;

4848

}

4849

4850

4851

SWIGINTERN VALUE

4852

_wrap_vlistInqVarLongname(int argc, VALUE *argv, VALUE self) {

4853

int arg1 ;

4854

int arg2 ;

4855

char *arg3 = (char *) 0 ;

4856

int val1 ;

4857

int ecode1 = 0 ;

4858

int val2 ;

4859

int ecode2 = 0 ;

4860

int res3 ;

4861

char *buf3 = 0 ;

4862

int alloc3 = 0 ;

4863

4864

if ((argc < 3) || (argc > 3)) {

4865

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4866

}

4867

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4868

if (!SWIG_IsOK(ecode1)) {

4869

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarLongname", 1, argv[0] ));

4870

}

4871

arg1 = (int)(val1);

4872

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4873

if (!SWIG_IsOK(ecode2)) {

4874

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarLongname", 2, argv[1] ));

4875

}

4876

arg2 = (int)(val2);

4877

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

4878

if (!SWIG_IsOK(res3)) {

4879

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarLongname", 3, argv[2] ));

4880

}

4881

arg3 = (char *)(buf3);

4882

vlistInqVarLongname(arg1,arg2,arg3);

4883

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4884

return Qnil;

4885

fail:

4886

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4887

return Qnil;

4888

}

4889

4890

4891

SWIGINTERN VALUE

4892

_wrap_vlistInqVarStdname(int argc, VALUE *argv, VALUE self) {

4893

int arg1 ;

4894

int arg2 ;

4895

char *arg3 = (char *) 0 ;

4896

int val1 ;

4897

int ecode1 = 0 ;

4898

int val2 ;

4899

int ecode2 = 0 ;

4900

int res3 ;

4901

char *buf3 = 0 ;

4902

int alloc3 = 0 ;

4903

4904

if ((argc < 3) || (argc > 3)) {

4905

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4906

}

4907

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4908

if (!SWIG_IsOK(ecode1)) {

4909

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarStdname", 1, argv[0] ));

4910

}

4911

arg1 = (int)(val1);

4912

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4913

if (!SWIG_IsOK(ecode2)) {

4914

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarStdname", 2, argv[1] ));

4915

}

4916

arg2 = (int)(val2);

4917

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

4918

if (!SWIG_IsOK(res3)) {

4919

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarStdname", 3, argv[2] ));

4920

}

4921

arg3 = (char *)(buf3);

4922

vlistInqVarStdname(arg1,arg2,arg3);

4923

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4924

return Qnil;

4925

fail:

4926

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4927

return Qnil;

4928

}

4929

4930

4931

SWIGINTERN VALUE

4932

_wrap_vlistDefVarUnits(int argc, VALUE *argv, VALUE self) {

4933

int arg1 ;

4934

int arg2 ;

4935

char *arg3 = (char *) 0 ;

4936

int val1 ;

4937

int ecode1 = 0 ;

4938

int val2 ;

4939

int ecode2 = 0 ;

4940

int res3 ;

4941

char *buf3 = 0 ;

4942

int alloc3 = 0 ;

4943

4944

if ((argc < 3) || (argc > 3)) {

4945

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4946

}

4947

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4948

if (!SWIG_IsOK(ecode1)) {

4949

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarUnits", 1, argv[0] ));

4950

}

4951

arg1 = (int)(val1);

4952

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4953

if (!SWIG_IsOK(ecode2)) {

4954

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarUnits", 2, argv[1] ));

4955

}

4956

arg2 = (int)(val2);

4957

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

4958

if (!SWIG_IsOK(res3)) {

4959

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefVarUnits", 3, argv[2] ));

4960

}

4961

arg3 = (char *)(buf3);

4962

vlistDefVarUnits(arg1,arg2,(char const *)arg3);

4963

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4964

return Qnil;

4965

fail:

4966

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

4967

return Qnil;

4968

}

4969

4970

4971

SWIGINTERN VALUE

4972

_wrap_vlistInqVarUnits(int argc, VALUE *argv, VALUE self) {

4973

int arg1 ;

4974

int arg2 ;

4975

char *arg3 = (char *) 0 ;

4976

int val1 ;

4977

int ecode1 = 0 ;

4978

int val2 ;

4979

int ecode2 = 0 ;

4980

int res3 ;

4981

char *buf3 = 0 ;

4982

int alloc3 = 0 ;

4983

4984

if ((argc < 3) || (argc > 3)) {

4985

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

4986

}

4987

ecode1 = SWIG_AsVal_int(argv[0], &val1);

4988

if (!SWIG_IsOK(ecode1)) {

4989

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarUnits", 1, argv[0] ));

4990

}

4991

arg1 = (int)(val1);

4992

ecode2 = SWIG_AsVal_int(argv[1], &val2);

4993

if (!SWIG_IsOK(ecode2)) {

4994

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarUnits", 2, argv[1] ));

4995

}

4996

arg2 = (int)(val2);

4997

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

4998

if (!SWIG_IsOK(res3)) {

4999

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","vlistInqVarUnits", 3, argv[2] ));

5000

}

5001

arg3 = (char *)(buf3);

5002

vlistInqVarUnits(arg1,arg2,arg3);

5003

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

5004

return Qnil;

5005

fail:

5006

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

5007

return Qnil;

5008

}

5009

5010

5011

SWIGINTERN VALUE

5012

_wrap_vlistDefVarMissval(int argc, VALUE *argv, VALUE self) {

5013

int arg1 ;

5014

int arg2 ;

5015

double arg3 ;

5016

int val1 ;

5017

int ecode1 = 0 ;

5018

int val2 ;

5019

int ecode2 = 0 ;

5020

double val3 ;

5021

int ecode3 = 0 ;

5022

5023

if ((argc < 3) || (argc > 3)) {

5024

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5025

}

5026

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5027

if (!SWIG_IsOK(ecode1)) {

5028

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarMissval", 1, argv[0] ));

5029

}

5030

arg1 = (int)(val1);

5031

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5032

if (!SWIG_IsOK(ecode2)) {

5033

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarMissval", 2, argv[1] ));

5034

}

5035

arg2 = (int)(val2);

5036

ecode3 = SWIG_AsVal_double(argv[2], &val3);

5037

if (!SWIG_IsOK(ecode3)) {

5038

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarMissval", 3, argv[2] ));

5039

}

5040

arg3 = (double)(val3);

5041

vlistDefVarMissval(arg1,arg2,arg3);

5042

return Qnil;

5043

fail:

5044

return Qnil;

5045

}

5046

5047

5048

SWIGINTERN VALUE

5049

_wrap_vlistInqVarMissval(int argc, VALUE *argv, VALUE self) {

5050

int arg1 ;

5051

int arg2 ;

5052

int val1 ;

5053

int ecode1 = 0 ;

5054

int val2 ;

5055

int ecode2 = 0 ;

5056

double result;

5057

VALUE vresult = Qnil;

5058

5059

if ((argc < 2) || (argc > 2)) {

5060

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5061

}

5062

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5063

if (!SWIG_IsOK(ecode1)) {

5064

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarMissval", 1, argv[0] ));

5065

}

5066

arg1 = (int)(val1);

5067

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5068

if (!SWIG_IsOK(ecode2)) {

5069

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarMissval", 2, argv[1] ));

5070

}

5071

arg2 = (int)(val2);

5072

result = (double)vlistInqVarMissval(arg1,arg2);

5073

vresult = SWIG_From_double((double)(result));

5074

return vresult;

5075

fail:

5076

return Qnil;

5077

}

5078

5079

5080

SWIGINTERN VALUE

5081

_wrap_vlistDefVarScalefactor(int argc, VALUE *argv, VALUE self) {

5082

int arg1 ;

5083

int arg2 ;

5084

double arg3 ;

5085

int val1 ;

5086

int ecode1 = 0 ;

5087

int val2 ;

5088

int ecode2 = 0 ;

5089

double val3 ;

5090

int ecode3 = 0 ;

5091

5092

if ((argc < 3) || (argc > 3)) {

5093

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5094

}

5095

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5096

if (!SWIG_IsOK(ecode1)) {

5097

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarScalefactor", 1, argv[0] ));

5098

}

5099

arg1 = (int)(val1);

5100

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5101

if (!SWIG_IsOK(ecode2)) {

5102

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarScalefactor", 2, argv[1] ));

5103

}

5104

arg2 = (int)(val2);

5105

ecode3 = SWIG_AsVal_double(argv[2], &val3);

5106

if (!SWIG_IsOK(ecode3)) {

5107

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarScalefactor", 3, argv[2] ));

5108

}

5109

arg3 = (double)(val3);

5110

vlistDefVarScalefactor(arg1,arg2,arg3);

5111

return Qnil;

5112

fail:

5113

return Qnil;

5114

}

5115

5116

5117

SWIGINTERN VALUE

5118

_wrap_vlistInqVarScalefactor(int argc, VALUE *argv, VALUE self) {

5119

int arg1 ;

5120

int arg2 ;

5121

int val1 ;

5122

int ecode1 = 0 ;

5123

int val2 ;

5124

int ecode2 = 0 ;

5125

double result;

5126

VALUE vresult = Qnil;

5127

5128

if ((argc < 2) || (argc > 2)) {

5129

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5130

}

5131

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5132

if (!SWIG_IsOK(ecode1)) {

5133

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarScalefactor", 1, argv[0] ));

5134

}

5135

arg1 = (int)(val1);

5136

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5137

if (!SWIG_IsOK(ecode2)) {

5138

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarScalefactor", 2, argv[1] ));

5139

}

5140

arg2 = (int)(val2);

5141

result = (double)vlistInqVarScalefactor(arg1,arg2);

5142

vresult = SWIG_From_double((double)(result));

5143

return vresult;

5144

fail:

5145

return Qnil;

5146

}

5147

5148

5149

SWIGINTERN VALUE

5150

_wrap_vlistDefVarAddoffset(int argc, VALUE *argv, VALUE self) {

5151

int arg1 ;

5152

int arg2 ;

5153

double arg3 ;

5154

int val1 ;

5155

int ecode1 = 0 ;

5156

int val2 ;

5157

int ecode2 = 0 ;

5158

double val3 ;

5159

int ecode3 = 0 ;

5160

5161

if ((argc < 3) || (argc > 3)) {

5162

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5163

}

5164

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5165

if (!SWIG_IsOK(ecode1)) {

5166

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarAddoffset", 1, argv[0] ));

5167

}

5168

arg1 = (int)(val1);

5169

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5170

if (!SWIG_IsOK(ecode2)) {

5171

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarAddoffset", 2, argv[1] ));

5172

}

5173

arg2 = (int)(val2);

5174

ecode3 = SWIG_AsVal_double(argv[2], &val3);

5175

if (!SWIG_IsOK(ecode3)) {

5176

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","vlistDefVarAddoffset", 3, argv[2] ));

5177

}

5178

arg3 = (double)(val3);

5179

vlistDefVarAddoffset(arg1,arg2,arg3);

5180

return Qnil;

5181

fail:

5182

return Qnil;

5183

}

5184

5185

5186

SWIGINTERN VALUE

5187

_wrap_vlistInqVarAddoffset(int argc, VALUE *argv, VALUE self) {

5188

int arg1 ;

5189

int arg2 ;

5190

int val1 ;

5191

int ecode1 = 0 ;

5192

int val2 ;

5193

int ecode2 = 0 ;

5194

double result;

5195

VALUE vresult = Qnil;

5196

5197

if ((argc < 2) || (argc > 2)) {

5198

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5199

}

5200

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5201

if (!SWIG_IsOK(ecode1)) {

5202

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarAddoffset", 1, argv[0] ));

5203

}

5204

arg1 = (int)(val1);

5205

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5206

if (!SWIG_IsOK(ecode2)) {

5207

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarAddoffset", 2, argv[1] ));

5208

}

5209

arg2 = (int)(val2);

5210

result = (double)vlistInqVarAddoffset(arg1,arg2);

5211

vresult = SWIG_From_double((double)(result));

5212

return vresult;

5213

fail:

5214

return Qnil;

5215

}

5216

5217

5218

SWIGINTERN VALUE

5219

_wrap_vlistDefVarTimave(int argc, VALUE *argv, VALUE self) {

5220

int arg1 ;

5221

int arg2 ;

5222

int arg3 ;

5223

int val1 ;

5224

int ecode1 = 0 ;

5225

int val2 ;

5226

int ecode2 = 0 ;

5227

int val3 ;

5228

int ecode3 = 0 ;

5229

5230

if ((argc < 3) || (argc > 3)) {

5231

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5232

}

5233

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5234

if (!SWIG_IsOK(ecode1)) {

5235

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 1, argv[0] ));

5236

}

5237

arg1 = (int)(val1);

5238

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5239

if (!SWIG_IsOK(ecode2)) {

5240

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 2, argv[1] ));

5241

}

5242

arg2 = (int)(val2);

5243

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5244

if (!SWIG_IsOK(ecode3)) {

5245

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTimave", 3, argv[2] ));

5246

}

5247

arg3 = (int)(val3);

5248

vlistDefVarTimave(arg1,arg2,arg3);

5249

return Qnil;

5250

fail:

5251

return Qnil;

5252

}

5253

5254

5255

SWIGINTERN VALUE

5256

_wrap_vlistInqVarTimave(int argc, VALUE *argv, VALUE self) {

5257

int arg1 ;

5258

int arg2 ;

5259

int val1 ;

5260

int ecode1 = 0 ;

5261

int val2 ;

5262

int ecode2 = 0 ;

5263

int result;

5264

VALUE vresult = Qnil;

5265

5266

if ((argc < 2) || (argc > 2)) {

5267

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5268

}

5269

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5270

if (!SWIG_IsOK(ecode1)) {

5271

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTimave", 1, argv[0] ));

5272

}

5273

arg1 = (int)(val1);

5274

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5275

if (!SWIG_IsOK(ecode2)) {

5276

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTimave", 2, argv[1] ));

5277

}

5278

arg2 = (int)(val2);

5279

result = (int)vlistInqVarTimave(arg1,arg2);

5280

vresult = SWIG_From_int((int)(result));

5281

return vresult;

5282

fail:

5283

return Qnil;

5284

}

5285

5286

5287

SWIGINTERN VALUE

5288

_wrap_vlistDefVarTimaccu(int argc, VALUE *argv, VALUE self) {

5289

int arg1 ;

5290

int arg2 ;

5291

int arg3 ;

5292

int val1 ;

5293

int ecode1 = 0 ;

5294

int val2 ;

5295

int ecode2 = 0 ;

5296

int val3 ;

5297

int ecode3 = 0 ;

5298

5299

if ((argc < 3) || (argc > 3)) {

5300

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5301

}

5302

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5303

if (!SWIG_IsOK(ecode1)) {

5304

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefVarTimaccu", 1, argv[0] ));

5305

}

5306

arg1 = (int)(val1);

5307

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5308

if (!SWIG_IsOK(ecode2)) {

5309

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefVarTimaccu", 2, argv[1] ));

5310

}

5311

arg2 = (int)(val2);

5312

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5313

if (!SWIG_IsOK(ecode3)) {

5314

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefVarTimaccu", 3, argv[2] ));

5315

}

5316

arg3 = (int)(val3);

5317

vlistDefVarTimaccu(arg1,arg2,arg3);

5318

return Qnil;

5319

fail:

5320

return Qnil;

5321

}

5322

5323

5324

SWIGINTERN VALUE

5325

_wrap_vlistInqVarTimaccu(int argc, VALUE *argv, VALUE self) {

5326

int arg1 ;

5327

int arg2 ;

5328

int val1 ;

5329

int ecode1 = 0 ;

5330

int val2 ;

5331

int ecode2 = 0 ;

5332

int result;

5333

VALUE vresult = Qnil;

5334

5335

if ((argc < 2) || (argc > 2)) {

5336

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5337

}

5338

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5339

if (!SWIG_IsOK(ecode1)) {

5340

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarTimaccu", 1, argv[0] ));

5341

}

5342

arg1 = (int)(val1);

5343

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5344

if (!SWIG_IsOK(ecode2)) {

5345

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarTimaccu", 2, argv[1] ));

5346

}

5347

arg2 = (int)(val2);

5348

result = (int)vlistInqVarTimaccu(arg1,arg2);

5349

vresult = SWIG_From_int((int)(result));

5350

return vresult;

5351

fail:

5352

return Qnil;

5353

}

5354

5355

5356

SWIGINTERN VALUE

5357

_wrap_vlistInqVarSize(int argc, VALUE *argv, VALUE self) {

5358

int arg1 ;

5359

int arg2 ;

5360

int val1 ;

5361

int ecode1 = 0 ;

5362

int val2 ;

5363

int ecode2 = 0 ;

5364

int result;

5365

VALUE vresult = Qnil;

5366

5367

if ((argc < 2) || (argc > 2)) {

5368

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5369

}

5370

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5371

if (!SWIG_IsOK(ecode1)) {

5372

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarSize", 1, argv[0] ));

5373

}

5374

arg1 = (int)(val1);

5375

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5376

if (!SWIG_IsOK(ecode2)) {

5377

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarSize", 2, argv[1] ));

5378

}

5379

arg2 = (int)(val2);

5380

result = (int)vlistInqVarSize(arg1,arg2);

5381

vresult = SWIG_From_int((int)(result));

5382

return vresult;

5383

fail:

5384

return Qnil;

5385

}

5386

5387

5388

SWIGINTERN VALUE

5389

_wrap_vlistInqVarID(int argc, VALUE *argv, VALUE self) {

5390

int arg1 ;

5391

int arg2 ;

5392

int val1 ;

5393

int ecode1 = 0 ;

5394

int val2 ;

5395

int ecode2 = 0 ;

5396

int result;

5397

VALUE vresult = Qnil;

5398

5399

if ((argc < 2) || (argc > 2)) {

5400

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5401

}

5402

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5403

if (!SWIG_IsOK(ecode1)) {

5404

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqVarID", 1, argv[0] ));

5405

}

5406

arg1 = (int)(val1);

5407

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5408

if (!SWIG_IsOK(ecode2)) {

5409

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqVarID", 2, argv[1] ));

5410

}

5411

arg2 = (int)(val2);

5412

result = (int)vlistInqVarID(arg1,arg2);

5413

vresult = SWIG_From_int((int)(result));

5414

return vresult;

5415

fail:

5416

return Qnil;

5417

}

5418

5419

5420

SWIGINTERN VALUE

5421

_wrap_vlistDefIndex(int argc, VALUE *argv, VALUE self) {

5422

int arg1 ;

5423

int arg2 ;

5424

int arg3 ;

5425

int arg4 ;

5426

int val1 ;

5427

int ecode1 = 0 ;

5428

int val2 ;

5429

int ecode2 = 0 ;

5430

int val3 ;

5431

int ecode3 = 0 ;

5432

int val4 ;

5433

int ecode4 = 0 ;

5434

5435

if ((argc < 4) || (argc > 4)) {

5436

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

5437

}

5438

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5439

if (!SWIG_IsOK(ecode1)) {

5440

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefIndex", 1, argv[0] ));

5441

}

5442

arg1 = (int)(val1);

5443

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5444

if (!SWIG_IsOK(ecode2)) {

5445

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefIndex", 2, argv[1] ));

5446

}

5447

arg2 = (int)(val2);

5448

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5449

if (!SWIG_IsOK(ecode3)) {

5450

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefIndex", 3, argv[2] ));

5451

}

5452

arg3 = (int)(val3);

5453

ecode4 = SWIG_AsVal_int(argv[3], &val4);

5454

if (!SWIG_IsOK(ecode4)) {

5455

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefIndex", 4, argv[3] ));

5456

}

5457

arg4 = (int)(val4);

5458

vlistDefIndex(arg1,arg2,arg3,arg4);

5459

return Qnil;

5460

fail:

5461

return Qnil;

5462

}

5463

5464

5465

SWIGINTERN VALUE

5466

_wrap_vlistInqIndex(int argc, VALUE *argv, VALUE self) {

5467

int arg1 ;

5468

int arg2 ;

5469

int arg3 ;

5470

int val1 ;

5471

int ecode1 = 0 ;

5472

int val2 ;

5473

int ecode2 = 0 ;

5474

int val3 ;

5475

int ecode3 = 0 ;

5476

int result;

5477

VALUE vresult = Qnil;

5478

5479

if ((argc < 3) || (argc > 3)) {

5480

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5481

}

5482

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5483

if (!SWIG_IsOK(ecode1)) {

5484

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqIndex", 1, argv[0] ));

5485

}

5486

arg1 = (int)(val1);

5487

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5488

if (!SWIG_IsOK(ecode2)) {

5489

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqIndex", 2, argv[1] ));

5490

}

5491

arg2 = (int)(val2);

5492

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5493

if (!SWIG_IsOK(ecode3)) {

5494

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistInqIndex", 3, argv[2] ));

5495

}

5496

arg3 = (int)(val3);

5497

result = (int)vlistInqIndex(arg1,arg2,arg3);

5498

vresult = SWIG_From_int((int)(result));

5499

return vresult;

5500

fail:

5501

return Qnil;

5502

}

5503

5504

5505

SWIGINTERN VALUE

5506

_wrap_vlistDefFlag(int argc, VALUE *argv, VALUE self) {

5507

int arg1 ;

5508

int arg2 ;

5509

int arg3 ;

5510

int arg4 ;

5511

int val1 ;

5512

int ecode1 = 0 ;

5513

int val2 ;

5514

int ecode2 = 0 ;

5515

int val3 ;

5516

int ecode3 = 0 ;

5517

int val4 ;

5518

int ecode4 = 0 ;

5519

5520

if ((argc < 4) || (argc > 4)) {

5521

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

5522

}

5523

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5524

if (!SWIG_IsOK(ecode1)) {

5525

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefFlag", 1, argv[0] ));

5526

}

5527

arg1 = (int)(val1);

5528

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5529

if (!SWIG_IsOK(ecode2)) {

5530

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefFlag", 2, argv[1] ));

5531

}

5532

arg2 = (int)(val2);

5533

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5534

if (!SWIG_IsOK(ecode3)) {

5535

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistDefFlag", 3, argv[2] ));

5536

}

5537

arg3 = (int)(val3);

5538

ecode4 = SWIG_AsVal_int(argv[3], &val4);

5539

if (!SWIG_IsOK(ecode4)) {

5540

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefFlag", 4, argv[3] ));

5541

}

5542

arg4 = (int)(val4);

5543

vlistDefFlag(arg1,arg2,arg3,arg4);

5544

return Qnil;

5545

fail:

5546

return Qnil;

5547

}

5548

5549

5550

SWIGINTERN VALUE

5551

_wrap_vlistInqFlag(int argc, VALUE *argv, VALUE self) {

5552

int arg1 ;

5553

int arg2 ;

5554

int arg3 ;

5555

int val1 ;

5556

int ecode1 = 0 ;

5557

int val2 ;

5558

int ecode2 = 0 ;

5559

int val3 ;

5560

int ecode3 = 0 ;

5561

int result;

5562

VALUE vresult = Qnil;

5563

5564

if ((argc < 3) || (argc > 3)) {

5565

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5566

}

5567

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5568

if (!SWIG_IsOK(ecode1)) {

5569

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqFlag", 1, argv[0] ));

5570

}

5571

arg1 = (int)(val1);

5572

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5573

if (!SWIG_IsOK(ecode2)) {

5574

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqFlag", 2, argv[1] ));

5575

}

5576

arg2 = (int)(val2);

5577

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5578

if (!SWIG_IsOK(ecode3)) {

5579

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistInqFlag", 3, argv[2] ));

5580

}

5581

arg3 = (int)(val3);

5582

result = (int)vlistInqFlag(arg1,arg2,arg3);

5583

vresult = SWIG_From_int((int)(result));

5584

return vresult;

5585

fail:

5586

return Qnil;

5587

}

5588

5589

5590

SWIGINTERN VALUE

5591

_wrap_vlistFindVar(int argc, VALUE *argv, VALUE self) {

5592

int arg1 ;

5593

int arg2 ;

5594

int val1 ;

5595

int ecode1 = 0 ;

5596

int val2 ;

5597

int ecode2 = 0 ;

5598

int result;

5599

VALUE vresult = Qnil;

5600

5601

if ((argc < 2) || (argc > 2)) {

5602

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5603

}

5604

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5605

if (!SWIG_IsOK(ecode1)) {

5606

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistFindVar", 1, argv[0] ));

5607

}

5608

arg1 = (int)(val1);

5609

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5610

if (!SWIG_IsOK(ecode2)) {

5611

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistFindVar", 2, argv[1] ));

5612

}

5613

arg2 = (int)(val2);

5614

result = (int)vlistFindVar(arg1,arg2);

5615

vresult = SWIG_From_int((int)(result));

5616

return vresult;

5617

fail:

5618

return Qnil;

5619

}

5620

5621

5622

SWIGINTERN VALUE

5623

_wrap_vlistFindLevel(int argc, VALUE *argv, VALUE self) {

5624

int arg1 ;

5625

int arg2 ;

5626

int arg3 ;

5627

int val1 ;

5628

int ecode1 = 0 ;

5629

int val2 ;

5630

int ecode2 = 0 ;

5631

int val3 ;

5632

int ecode3 = 0 ;

5633

int result;

5634

VALUE vresult = Qnil;

5635

5636

if ((argc < 3) || (argc > 3)) {

5637

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5638

}

5639

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5640

if (!SWIG_IsOK(ecode1)) {

5641

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistFindLevel", 1, argv[0] ));

5642

}

5643

arg1 = (int)(val1);

5644

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5645

if (!SWIG_IsOK(ecode2)) {

5646

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistFindLevel", 2, argv[1] ));

5647

}

5648

arg2 = (int)(val2);

5649

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5650

if (!SWIG_IsOK(ecode3)) {

5651

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistFindLevel", 3, argv[2] ));

5652

}

5653

arg3 = (int)(val3);

5654

result = (int)vlistFindLevel(arg1,arg2,arg3);

5655

vresult = SWIG_From_int((int)(result));

5656

return vresult;

5657

fail:

5658

return Qnil;

5659

}

5660

5661

5662

SWIGINTERN VALUE

5663

_wrap_vlistMergedVar(int argc, VALUE *argv, VALUE self) {

5664

int arg1 ;

5665

int arg2 ;

5666

int val1 ;

5667

int ecode1 = 0 ;

5668

int val2 ;

5669

int ecode2 = 0 ;

5670

int result;

5671

VALUE vresult = Qnil;

5672

5673

if ((argc < 2) || (argc > 2)) {

5674

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

5675

}

5676

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5677

if (!SWIG_IsOK(ecode1)) {

5678

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMergedVar", 1, argv[0] ));

5679

}

5680

arg1 = (int)(val1);

5681

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5682

if (!SWIG_IsOK(ecode2)) {

5683

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMergedVar", 2, argv[1] ));

5684

}

5685

arg2 = (int)(val2);

5686

result = (int)vlistMergedVar(arg1,arg2);

5687

vresult = SWIG_From_int((int)(result));

5688

return vresult;

5689

fail:

5690

return Qnil;

5691

}

5692

5693

5694

SWIGINTERN VALUE

5695

_wrap_vlistMergedLevel(int argc, VALUE *argv, VALUE self) {

5696

int arg1 ;

5697

int arg2 ;

5698

int arg3 ;

5699

int val1 ;

5700

int ecode1 = 0 ;

5701

int val2 ;

5702

int ecode2 = 0 ;

5703

int val3 ;

5704

int ecode3 = 0 ;

5705

int result;

5706

VALUE vresult = Qnil;

5707

5708

if ((argc < 3) || (argc > 3)) {

5709

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5710

}

5711

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5712

if (!SWIG_IsOK(ecode1)) {

5713

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 1, argv[0] ));

5714

}

5715

arg1 = (int)(val1);

5716

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5717

if (!SWIG_IsOK(ecode2)) {

5718

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 2, argv[1] ));

5719

}

5720

arg2 = (int)(val2);

5721

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5722

if (!SWIG_IsOK(ecode3)) {

5723

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistMergedLevel", 3, argv[2] ));

5724

}

5725

arg3 = (int)(val3);

5726

result = (int)vlistMergedLevel(arg1,arg2,arg3);

5727

vresult = SWIG_From_int((int)(result));

5728

return vresult;

5729

fail:

5730

return Qnil;

5731

}

5732

5733

5734

SWIGINTERN VALUE

5735

_wrap_vlistInqNatts(int argc, VALUE *argv, VALUE self) {

5736

int arg1 ;

5737

int arg2 ;

5738

int *arg3 = (int *) 0 ;

5739

int val1 ;

5740

int ecode1 = 0 ;

5741

int val2 ;

5742

int ecode2 = 0 ;

5743

void *argp3 = 0 ;

5744

int res3 = 0 ;

5745

int result;

5746

VALUE vresult = Qnil;

5747

5748

if ((argc < 3) || (argc > 3)) {

5749

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5750

}

5751

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5752

if (!SWIG_IsOK(ecode1)) {

5753

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqNatts", 1, argv[0] ));

5754

}

5755

arg1 = (int)(val1);

5756

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5757

if (!SWIG_IsOK(ecode2)) {

5758

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqNatts", 2, argv[1] ));

5759

}

5760

arg2 = (int)(val2);

5761

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );

5762

if (!SWIG_IsOK(res3)) {

5763

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","vlistInqNatts", 3, argv[2] ));

5764

}

5765

arg3 = (int *)(argp3);

5766

result = (int)vlistInqNatts(arg1,arg2,arg3);

5767

vresult = SWIG_From_int((int)(result));

5768

return vresult;

5769

fail:

5770

return Qnil;

5771

}

5772

5773

5774

SWIGINTERN VALUE

5775

_wrap_vlistInqAtt(int argc, VALUE *argv, VALUE self) {

5776

int arg1 ;

5777

int arg2 ;

5778

int arg3 ;

5779

char *arg4 = (char *) 0 ;

5780

int *arg5 = (int *) 0 ;

5781

int *arg6 = (int *) 0 ;

5782

int val1 ;

5783

int ecode1 = 0 ;

5784

int val2 ;

5785

int ecode2 = 0 ;

5786

int val3 ;

5787

int ecode3 = 0 ;

5788

int res4 ;

5789

char *buf4 = 0 ;

5790

int alloc4 = 0 ;

5791

void *argp5 = 0 ;

5792

int res5 = 0 ;

5793

void *argp6 = 0 ;

5794

int res6 = 0 ;

5795

int result;

5796

VALUE vresult = Qnil;

5797

5798

if ((argc < 6) || (argc > 6)) {

5799

rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;

5800

}

5801

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5802

if (!SWIG_IsOK(ecode1)) {

5803

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqAtt", 1, argv[0] ));

5804

}

5805

arg1 = (int)(val1);

5806

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5807

if (!SWIG_IsOK(ecode2)) {

5808

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqAtt", 2, argv[1] ));

5809

}

5810

arg2 = (int)(val2);

5811

ecode3 = SWIG_AsVal_int(argv[2], &val3);

5812

if (!SWIG_IsOK(ecode3)) {

5813

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","vlistInqAtt", 3, argv[2] ));

5814

}

5815

arg3 = (int)(val3);

5816

res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);

5817

if (!SWIG_IsOK(res4)) {

5818

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","vlistInqAtt", 4, argv[3] ));

5819

}

5820

arg4 = (char *)(buf4);

5821

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );

5822

if (!SWIG_IsOK(res5)) {

5823

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","vlistInqAtt", 5, argv[4] ));

5824

}

5825

arg5 = (int *)(argp5);

5826

res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_int, 0 | 0 );

5827

if (!SWIG_IsOK(res6)) {

5828

SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "int *","vlistInqAtt", 6, argv[5] ));

5829

}

5830

arg6 = (int *)(argp6);

5831

result = (int)vlistInqAtt(arg1,arg2,arg3,arg4,arg5,arg6);

5832

vresult = SWIG_From_int((int)(result));

5833

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

5834

return vresult;

5835

fail:

5836

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

5837

return Qnil;

5838

}

5839

5840

5841

SWIGINTERN VALUE

5842

_wrap_vlistDelAtt(int argc, VALUE *argv, VALUE self) {

5843

int arg1 ;

5844

int arg2 ;

5845

char *arg3 = (char *) 0 ;

5846

int val1 ;

5847

int ecode1 = 0 ;

5848

int val2 ;

5849

int ecode2 = 0 ;

5850

int res3 ;

5851

char *buf3 = 0 ;

5852

int alloc3 = 0 ;

5853

int result;

5854

VALUE vresult = Qnil;

5855

5856

if ((argc < 3) || (argc > 3)) {

5857

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

5858

}

5859

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5860

if (!SWIG_IsOK(ecode1)) {

5861

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDelAtt", 1, argv[0] ));

5862

}

5863

arg1 = (int)(val1);

5864

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5865

if (!SWIG_IsOK(ecode2)) {

5866

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDelAtt", 2, argv[1] ));

5867

}

5868

arg2 = (int)(val2);

5869

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

5870

if (!SWIG_IsOK(res3)) {

5871

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDelAtt", 3, argv[2] ));

5872

}

5873

arg3 = (char *)(buf3);

5874

result = (int)vlistDelAtt(arg1,arg2,(char const *)arg3);

5875

vresult = SWIG_From_int((int)(result));

5876

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

5877

return vresult;

5878

fail:

5879

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

5880

return Qnil;

5881

}

5882

5883

5884

SWIGINTERN VALUE

5885

_wrap_vlistDefAttInt(int argc, VALUE *argv, VALUE self) {

5886

int arg1 ;

5887

int arg2 ;

5888

char *arg3 = (char *) 0 ;

5889

int arg4 ;

5890

int *arg5 = (int *) 0 ;

5891

int val1 ;

5892

int ecode1 = 0 ;

5893

int val2 ;

5894

int ecode2 = 0 ;

5895

int res3 ;

5896

char *buf3 = 0 ;

5897

int alloc3 = 0 ;

5898

int val4 ;

5899

int ecode4 = 0 ;

5900

void *argp5 = 0 ;

5901

int res5 = 0 ;

5902

int result;

5903

VALUE vresult = Qnil;

5904

5905

if ((argc < 5) || (argc > 5)) {

5906

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

5907

}

5908

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5909

if (!SWIG_IsOK(ecode1)) {

5910

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefAttInt", 1, argv[0] ));

5911

}

5912

arg1 = (int)(val1);

5913

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5914

if (!SWIG_IsOK(ecode2)) {

5915

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefAttInt", 2, argv[1] ));

5916

}

5917

arg2 = (int)(val2);

5918

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

5919

if (!SWIG_IsOK(res3)) {

5920

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefAttInt", 3, argv[2] ));

5921

}

5922

arg3 = (char *)(buf3);

5923

ecode4 = SWIG_AsVal_int(argv[3], &val4);

5924

if (!SWIG_IsOK(ecode4)) {

5925

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefAttInt", 4, argv[3] ));

5926

}

5927

arg4 = (int)(val4);

5928

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );

5929

if (!SWIG_IsOK(res5)) {

5930

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int const *","vlistDefAttInt", 5, argv[4] ));

5931

}

5932

arg5 = (int *)(argp5);

5933

result = (int)vlistDefAttInt(arg1,arg2,(char const *)arg3,arg4,(int const *)arg5);

5934

vresult = SWIG_From_int((int)(result));

5935

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

5936

return vresult;

5937

fail:

5938

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

5939

return Qnil;

5940

}

5941

5942

5943

SWIGINTERN VALUE

5944

_wrap_vlistDefAttFlt(int argc, VALUE *argv, VALUE self) {

5945

int arg1 ;

5946

int arg2 ;

5947

char *arg3 = (char *) 0 ;

5948

int arg4 ;

5949

double *arg5 = (double *) 0 ;

5950

int val1 ;

5951

int ecode1 = 0 ;

5952

int val2 ;

5953

int ecode2 = 0 ;

5954

int res3 ;

5955

char *buf3 = 0 ;

5956

int alloc3 = 0 ;

5957

int val4 ;

5958

int ecode4 = 0 ;

5959

void *argp5 = 0 ;

5960

int res5 = 0 ;

5961

int result;

5962

VALUE vresult = Qnil;

5963

5964

if ((argc < 5) || (argc > 5)) {

5965

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

5966

}

5967

ecode1 = SWIG_AsVal_int(argv[0], &val1);

5968

if (!SWIG_IsOK(ecode1)) {

5969

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefAttFlt", 1, argv[0] ));

5970

}

5971

arg1 = (int)(val1);

5972

ecode2 = SWIG_AsVal_int(argv[1], &val2);

5973

if (!SWIG_IsOK(ecode2)) {

5974

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefAttFlt", 2, argv[1] ));

5975

}

5976

arg2 = (int)(val2);

5977

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

5978

if (!SWIG_IsOK(res3)) {

5979

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefAttFlt", 3, argv[2] ));

5980

}

5981

arg3 = (char *)(buf3);

5982

ecode4 = SWIG_AsVal_int(argv[3], &val4);

5983

if (!SWIG_IsOK(ecode4)) {

5984

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefAttFlt", 4, argv[3] ));

5985

}

5986

arg4 = (int)(val4);

5987

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );

5988

if (!SWIG_IsOK(res5)) {

5989

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double const *","vlistDefAttFlt", 5, argv[4] ));

5990

}

5991

arg5 = (double *)(argp5);

5992

result = (int)vlistDefAttFlt(arg1,arg2,(char const *)arg3,arg4,(double const *)arg5);

5993

vresult = SWIG_From_int((int)(result));

5994

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

5995

return vresult;

5996

fail:

5997

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

5998

return Qnil;

5999

}

6000

6001

6002

SWIGINTERN VALUE

6003

_wrap_vlistDefAttTxt(int argc, VALUE *argv, VALUE self) {

6004

int arg1 ;

6005

int arg2 ;

6006

char *arg3 = (char *) 0 ;

6007

int arg4 ;

6008

char *arg5 = (char *) 0 ;

6009

int val1 ;

6010

int ecode1 = 0 ;

6011

int val2 ;

6012

int ecode2 = 0 ;

6013

int res3 ;

6014

char *buf3 = 0 ;

6015

int alloc3 = 0 ;

6016

int val4 ;

6017

int ecode4 = 0 ;

6018

int res5 ;

6019

char *buf5 = 0 ;

6020

int alloc5 = 0 ;

6021

int result;

6022

VALUE vresult = Qnil;

6023

6024

if ((argc < 5) || (argc > 5)) {

6025

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

6026

}

6027

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6028

if (!SWIG_IsOK(ecode1)) {

6029

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistDefAttTxt", 1, argv[0] ));

6030

}

6031

arg1 = (int)(val1);

6032

ecode2 = SWIG_AsVal_int(argv[1], &val2);

6033

if (!SWIG_IsOK(ecode2)) {

6034

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistDefAttTxt", 2, argv[1] ));

6035

}

6036

arg2 = (int)(val2);

6037

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

6038

if (!SWIG_IsOK(res3)) {

6039

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistDefAttTxt", 3, argv[2] ));

6040

}

6041

arg3 = (char *)(buf3);

6042

ecode4 = SWIG_AsVal_int(argv[3], &val4);

6043

if (!SWIG_IsOK(ecode4)) {

6044

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistDefAttTxt", 4, argv[3] ));

6045

}

6046

arg4 = (int)(val4);

6047

res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);

6048

if (!SWIG_IsOK(res5)) {

6049

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","vlistDefAttTxt", 5, argv[4] ));

6050

}

6051

arg5 = (char *)(buf5);

6052

result = (int)vlistDefAttTxt(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);

6053

vresult = SWIG_From_int((int)(result));

6054

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

6055

if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);

6056

return vresult;

6057

fail:

6058

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

6059

if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);

6060

return Qnil;

6061

}

6062

6063

6064

SWIGINTERN VALUE

6065

_wrap_vlistInqAttInt(int argc, VALUE *argv, VALUE self) {

6066

int arg1 ;

6067

int arg2 ;

6068

char *arg3 = (char *) 0 ;

6069

int arg4 ;

6070

int *arg5 = (int *) 0 ;

6071

int val1 ;

6072

int ecode1 = 0 ;

6073

int val2 ;

6074

int ecode2 = 0 ;

6075

int res3 ;

6076

char *buf3 = 0 ;

6077

int alloc3 = 0 ;

6078

int val4 ;

6079

int ecode4 = 0 ;

6080

void *argp5 = 0 ;

6081

int res5 = 0 ;

6082

int result;

6083

VALUE vresult = Qnil;

6084

6085

if ((argc < 5) || (argc > 5)) {

6086

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

6087

}

6088

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6089

if (!SWIG_IsOK(ecode1)) {

6090

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqAttInt", 1, argv[0] ));

6091

}

6092

arg1 = (int)(val1);

6093

ecode2 = SWIG_AsVal_int(argv[1], &val2);

6094

if (!SWIG_IsOK(ecode2)) {

6095

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqAttInt", 2, argv[1] ));

6096

}

6097

arg2 = (int)(val2);

6098

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

6099

if (!SWIG_IsOK(res3)) {

6100

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistInqAttInt", 3, argv[2] ));

6101

}

6102

arg3 = (char *)(buf3);

6103

ecode4 = SWIG_AsVal_int(argv[3], &val4);

6104

if (!SWIG_IsOK(ecode4)) {

6105

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistInqAttInt", 4, argv[3] ));

6106

}

6107

arg4 = (int)(val4);

6108

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_int, 0 | 0 );

6109

if (!SWIG_IsOK(res5)) {

6110

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int *","vlistInqAttInt", 5, argv[4] ));

6111

}

6112

arg5 = (int *)(argp5);

6113

result = (int)vlistInqAttInt(arg1,arg2,(char const *)arg3,arg4,arg5);

6114

vresult = SWIG_From_int((int)(result));

6115

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

6116

return vresult;

6117

fail:

6118

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

6119

return Qnil;

6120

}

6121

6122

6123

SWIGINTERN VALUE

6124

_wrap_vlistInqAttFlt(int argc, VALUE *argv, VALUE self) {

6125

int arg1 ;

6126

int arg2 ;

6127

char *arg3 = (char *) 0 ;

6128

int arg4 ;

6129

double *arg5 = (double *) 0 ;

6130

int val1 ;

6131

int ecode1 = 0 ;

6132

int val2 ;

6133

int ecode2 = 0 ;

6134

int res3 ;

6135

char *buf3 = 0 ;

6136

int alloc3 = 0 ;

6137

int val4 ;

6138

int ecode4 = 0 ;

6139

void *argp5 = 0 ;

6140

int res5 = 0 ;

6141

int result;

6142

VALUE vresult = Qnil;

6143

6144

if ((argc < 5) || (argc > 5)) {

6145

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

6146

}

6147

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6148

if (!SWIG_IsOK(ecode1)) {

6149

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqAttFlt", 1, argv[0] ));

6150

}

6151

arg1 = (int)(val1);

6152

ecode2 = SWIG_AsVal_int(argv[1], &val2);

6153

if (!SWIG_IsOK(ecode2)) {

6154

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqAttFlt", 2, argv[1] ));

6155

}

6156

arg2 = (int)(val2);

6157

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

6158

if (!SWIG_IsOK(res3)) {

6159

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistInqAttFlt", 3, argv[2] ));

6160

}

6161

arg3 = (char *)(buf3);

6162

ecode4 = SWIG_AsVal_int(argv[3], &val4);

6163

if (!SWIG_IsOK(ecode4)) {

6164

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistInqAttFlt", 4, argv[3] ));

6165

}

6166

arg4 = (int)(val4);

6167

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );

6168

if (!SWIG_IsOK(res5)) {

6169

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double *","vlistInqAttFlt", 5, argv[4] ));

6170

}

6171

arg5 = (double *)(argp5);

6172

result = (int)vlistInqAttFlt(arg1,arg2,(char const *)arg3,arg4,arg5);

6173

vresult = SWIG_From_int((int)(result));

6174

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

6175

return vresult;

6176

fail:

6177

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

6178

return Qnil;

6179

}

6180

6181

6182

SWIGINTERN VALUE

6183

_wrap_vlistInqAttTxt(int argc, VALUE *argv, VALUE self) {

6184

int arg1 ;

6185

int arg2 ;

6186

char *arg3 = (char *) 0 ;

6187

int arg4 ;

6188

char *arg5 = (char *) 0 ;

6189

int val1 ;

6190

int ecode1 = 0 ;

6191

int val2 ;

6192

int ecode2 = 0 ;

6193

int res3 ;

6194

char *buf3 = 0 ;

6195

int alloc3 = 0 ;

6196

int val4 ;

6197

int ecode4 = 0 ;

6198

int res5 ;

6199

char *buf5 = 0 ;

6200

int alloc5 = 0 ;

6201

int result;

6202

VALUE vresult = Qnil;

6203

6204

if ((argc < 5) || (argc > 5)) {

6205

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

6206

}

6207

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6208

if (!SWIG_IsOK(ecode1)) {

6209

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","vlistInqAttTxt", 1, argv[0] ));

6210

}

6211

arg1 = (int)(val1);

6212

ecode2 = SWIG_AsVal_int(argv[1], &val2);

6213

if (!SWIG_IsOK(ecode2)) {

6214

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vlistInqAttTxt", 2, argv[1] ));

6215

}

6216

arg2 = (int)(val2);

6217

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

6218

if (!SWIG_IsOK(res3)) {

6219

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","vlistInqAttTxt", 3, argv[2] ));

6220

}

6221

arg3 = (char *)(buf3);

6222

ecode4 = SWIG_AsVal_int(argv[3], &val4);

6223

if (!SWIG_IsOK(ecode4)) {

6224

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","vlistInqAttTxt", 4, argv[3] ));

6225

}

6226

arg4 = (int)(val4);

6227

res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);

6228

if (!SWIG_IsOK(res5)) {

6229

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char *","vlistInqAttTxt", 5, argv[4] ));

6230

}

6231

arg5 = (char *)(buf5);

6232

result = (int)vlistInqAttTxt(arg1,arg2,(char const *)arg3,arg4,arg5);

6233

vresult = SWIG_From_int((int)(result));

6234

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

6235

if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);

6236

return vresult;

6237

fail:

6238

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

6239

if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);

6240

return Qnil;

6241

}

6242

6243

6244

SWIGINTERN VALUE

6245

_wrap_gridName(int argc, VALUE *argv, VALUE self) {

6246

int arg1 ;

6247

char *arg2 = (char *) 0 ;

6248

int val1 ;

6249

int ecode1 = 0 ;

6250

int res2 ;

6251

char *buf2 = 0 ;

6252

int alloc2 = 0 ;

6253

6254

if ((argc < 2) || (argc > 2)) {

6255

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6256

}

6257

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6258

if (!SWIG_IsOK(ecode1)) {

6259

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridName", 1, argv[0] ));

6260

}

6261

arg1 = (int)(val1);

6262

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

6263

if (!SWIG_IsOK(res2)) {

6264

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridName", 2, argv[1] ));

6265

}

6266

arg2 = (char *)(buf2);

6267

gridName(arg1,arg2);

6268

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6269

return Qnil;

6270

fail:

6271

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6272

return Qnil;

6273

}

6274

6275

6276

SWIGINTERN VALUE

6277

_wrap_gridNamePtr(int argc, VALUE *argv, VALUE self) {

6278

int arg1 ;

6279

int val1 ;

6280

int ecode1 = 0 ;

6281

char *result = 0 ;

6282

VALUE vresult = Qnil;

6283

6284

if ((argc < 1) || (argc > 1)) {

6285

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

6286

}

6287

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6288

if (!SWIG_IsOK(ecode1)) {

6289

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridNamePtr", 1, argv[0] ));

6290

}

6291

arg1 = (int)(val1);

6292

result = (char *)gridNamePtr(arg1);

6293

vresult = SWIG_FromCharPtr((const char *)result);

6294

return vresult;

6295

fail:

6296

return Qnil;

6297

}

6298

6299

6300

SWIGINTERN VALUE

6301

_wrap_gridCompress(int argc, VALUE *argv, VALUE self) {

6302

int arg1 ;

6303

int val1 ;

6304

int ecode1 = 0 ;

6305

6306

if ((argc < 1) || (argc > 1)) {

6307

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

6308

}

6309

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6310

if (!SWIG_IsOK(ecode1)) {

6311

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridCompress", 1, argv[0] ));

6312

}

6313

arg1 = (int)(val1);

6314

gridCompress(arg1);

6315

return Qnil;

6316

fail:

6317

return Qnil;

6318

}

6319

6320

6321

SWIGINTERN VALUE

6322

_wrap_gridDefMask(int argc, VALUE *argv, VALUE self) {

6323

int arg1 ;

6324

int *arg2 = (int *) 0 ;

6325

int val1 ;

6326

int ecode1 = 0 ;

6327

void *argp2 = 0 ;

6328

int res2 = 0 ;

6329

6330

if ((argc < 2) || (argc > 2)) {

6331

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6332

}

6333

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6334

if (!SWIG_IsOK(ecode1)) {

6335

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefMask", 1, argv[0] ));

6336

}

6337

arg1 = (int)(val1);

6338

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );

6339

if (!SWIG_IsOK(res2)) {

6340

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int const *","gridDefMask", 2, argv[1] ));

6341

}

6342

arg2 = (int *)(argp2);

6343

gridDefMask(arg1,(int const *)arg2);

6344

return Qnil;

6345

fail:

6346

return Qnil;

6347

}

6348

6349

6350

SWIGINTERN VALUE

6351

_wrap_gridInqMask(int argc, VALUE *argv, VALUE self) {

6352

int arg1 ;

6353

int *arg2 = (int *) 0 ;

6354

int val1 ;

6355

int ecode1 = 0 ;

6356

void *argp2 = 0 ;

6357

int res2 = 0 ;

6358

int result;

6359

VALUE vresult = Qnil;

6360

6361

if ((argc < 2) || (argc > 2)) {

6362

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6363

}

6364

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6365

if (!SWIG_IsOK(ecode1)) {

6366

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqMask", 1, argv[0] ));

6367

}

6368

arg1 = (int)(val1);

6369

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );

6370

if (!SWIG_IsOK(res2)) {

6371

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","gridInqMask", 2, argv[1] ));

6372

}

6373

arg2 = (int *)(argp2);

6374

result = (int)gridInqMask(arg1,arg2);

6375

vresult = SWIG_From_int((int)(result));

6376

return vresult;

6377

fail:

6378

return Qnil;

6379

}

6380

6381

6382

SWIGINTERN VALUE

6383

_wrap_gridPrint(int argc, VALUE *argv, VALUE self) {

6384

int arg1 ;

6385

int arg2 ;

6386

int val1 ;

6387

int ecode1 = 0 ;

6388

int val2 ;

6389

int ecode2 = 0 ;

6390

6391

if ((argc < 2) || (argc > 2)) {

6392

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6393

}

6394

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6395

if (!SWIG_IsOK(ecode1)) {

6396

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridPrint", 1, argv[0] ));

6397

}

6398

arg1 = (int)(val1);

6399

ecode2 = SWIG_AsVal_int(argv[1], &val2);

6400

if (!SWIG_IsOK(ecode2)) {

6401

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridPrint", 2, argv[1] ));

6402

}

6403

arg2 = (int)(val2);

6404

gridPrint(arg1,arg2);

6405

return Qnil;

6406

fail:

6407

return Qnil;

6408

}

6409

6410

6411

SWIGINTERN VALUE

6412

_wrap_gridSize(int argc, VALUE *argv, VALUE self) {

6413

int result;

6414

VALUE vresult = Qnil;

6415

6416

if ((argc < 0) || (argc > 0)) {

6417

rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;

6418

}

6419

result = (int)gridSize();

6420

vresult = SWIG_From_int((int)(result));

6421

return vresult;

6422

fail:

6423

return Qnil;

6424

}

6425

6426

6427

SWIGINTERN VALUE

6428

_wrap_gridCreate(int argc, VALUE *argv, VALUE self) {

6429

int arg1 ;

6430

int arg2 ;

6431

int val1 ;

6432

int ecode1 = 0 ;

6433

int val2 ;

6434

int ecode2 = 0 ;

6435

int result;

6436

VALUE vresult = Qnil;

6437

6438

if ((argc < 2) || (argc > 2)) {

6439

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6440

}

6441

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6442

if (!SWIG_IsOK(ecode1)) {

6443

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridCreate", 1, argv[0] ));

6444

}

6445

arg1 = (int)(val1);

6446

ecode2 = SWIG_AsVal_int(argv[1], &val2);

6447

if (!SWIG_IsOK(ecode2)) {

6448

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridCreate", 2, argv[1] ));

6449

}

6450

arg2 = (int)(val2);

6451

result = (int)gridCreate(arg1,arg2);

6452

vresult = SWIG_From_int((int)(result));

6453

return vresult;

6454

fail:

6455

return Qnil;

6456

}

6457

6458

6459

SWIGINTERN VALUE

6460

_wrap_gridDestroy(int argc, VALUE *argv, VALUE self) {

6461

int arg1 ;

6462

int val1 ;

6463

int ecode1 = 0 ;

6464

6465

if ((argc < 1) || (argc > 1)) {

6466

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

6467

}

6468

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6469

if (!SWIG_IsOK(ecode1)) {

6470

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDestroy", 1, argv[0] ));

6471

}

6472

arg1 = (int)(val1);

6473

gridDestroy(arg1);

6474

return Qnil;

6475

fail:

6476

return Qnil;

6477

}

6478

6479

6480

SWIGINTERN VALUE

6481

_wrap_gridDuplicate(int argc, VALUE *argv, VALUE self) {

6482

int arg1 ;

6483

int val1 ;

6484

int ecode1 = 0 ;

6485

int result;

6486

VALUE vresult = Qnil;

6487

6488

if ((argc < 1) || (argc > 1)) {

6489

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

6490

}

6491

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6492

if (!SWIG_IsOK(ecode1)) {

6493

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDuplicate", 1, argv[0] ));

6494

}

6495

arg1 = (int)(val1);

6496

result = (int)gridDuplicate(arg1);

6497

vresult = SWIG_From_int((int)(result));

6498

return vresult;

6499

fail:

6500

return Qnil;

6501

}

6502

6503

6504

SWIGINTERN VALUE

6505

_wrap_gridInqType(int argc, VALUE *argv, VALUE self) {

6506

int arg1 ;

6507

int val1 ;

6508

int ecode1 = 0 ;

6509

int result;

6510

VALUE vresult = Qnil;

6511

6512

if ((argc < 1) || (argc > 1)) {

6513

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

6514

}

6515

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6516

if (!SWIG_IsOK(ecode1)) {

6517

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqType", 1, argv[0] ));

6518

}

6519

arg1 = (int)(val1);

6520

result = (int)gridInqType(arg1);

6521

vresult = SWIG_From_int((int)(result));

6522

return vresult;

6523

fail:

6524

return Qnil;

6525

}

6526

6527

6528

SWIGINTERN VALUE

6529

_wrap_gridInqSize(int argc, VALUE *argv, VALUE self) {

6530

int arg1 ;

6531

int val1 ;

6532

int ecode1 = 0 ;

6533

int result;

6534

VALUE vresult = Qnil;

6535

6536

if ((argc < 1) || (argc > 1)) {

6537

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

6538

}

6539

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6540

if (!SWIG_IsOK(ecode1)) {

6541

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqSize", 1, argv[0] ));

6542

}

6543

arg1 = (int)(val1);

6544

result = (int)gridInqSize(arg1);

6545

vresult = SWIG_From_int((int)(result));

6546

return vresult;

6547

fail:

6548

return Qnil;

6549

}

6550

6551

6552

SWIGINTERN VALUE

6553

_wrap_gridDefXsize(int argc, VALUE *argv, VALUE self) {

6554

int arg1 ;

6555

int arg2 ;

6556

int val1 ;

6557

int ecode1 = 0 ;

6558

int val2 ;

6559

int ecode2 = 0 ;

6560

6561

if ((argc < 2) || (argc > 2)) {

6562

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6563

}

6564

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6565

if (!SWIG_IsOK(ecode1)) {

6566

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXsize", 1, argv[0] ));

6567

}

6568

arg1 = (int)(val1);

6569

ecode2 = SWIG_AsVal_int(argv[1], &val2);

6570

if (!SWIG_IsOK(ecode2)) {

6571

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefXsize", 2, argv[1] ));

6572

}

6573

arg2 = (int)(val2);

6574

gridDefXsize(arg1,arg2);

6575

return Qnil;

6576

fail:

6577

return Qnil;

6578

}

6579

6580

6581

SWIGINTERN VALUE

6582

_wrap_gridInqXsize(int argc, VALUE *argv, VALUE self) {

6583

int arg1 ;

6584

int val1 ;

6585

int ecode1 = 0 ;

6586

int result;

6587

VALUE vresult = Qnil;

6588

6589

if ((argc < 1) || (argc > 1)) {

6590

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

6591

}

6592

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6593

if (!SWIG_IsOK(ecode1)) {

6594

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXsize", 1, argv[0] ));

6595

}

6596

arg1 = (int)(val1);

6597

result = (int)gridInqXsize(arg1);

6598

vresult = SWIG_From_int((int)(result));

6599

return vresult;

6600

fail:

6601

return Qnil;

6602

}

6603

6604

6605

SWIGINTERN VALUE

6606

_wrap_gridDefYsize(int argc, VALUE *argv, VALUE self) {

6607

int arg1 ;

6608

int arg2 ;

6609

int val1 ;

6610

int ecode1 = 0 ;

6611

int val2 ;

6612

int ecode2 = 0 ;

6613

6614

if ((argc < 2) || (argc > 2)) {

6615

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6616

}

6617

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6618

if (!SWIG_IsOK(ecode1)) {

6619

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYsize", 1, argv[0] ));

6620

}

6621

arg1 = (int)(val1);

6622

ecode2 = SWIG_AsVal_int(argv[1], &val2);

6623

if (!SWIG_IsOK(ecode2)) {

6624

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefYsize", 2, argv[1] ));

6625

}

6626

arg2 = (int)(val2);

6627

gridDefYsize(arg1,arg2);

6628

return Qnil;

6629

fail:

6630

return Qnil;

6631

}

6632

6633

6634

SWIGINTERN VALUE

6635

_wrap_gridInqYsize(int argc, VALUE *argv, VALUE self) {

6636

int arg1 ;

6637

int val1 ;

6638

int ecode1 = 0 ;

6639

int result;

6640

VALUE vresult = Qnil;

6641

6642

if ((argc < 1) || (argc > 1)) {

6643

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

6644

}

6645

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6646

if (!SWIG_IsOK(ecode1)) {

6647

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYsize", 1, argv[0] ));

6648

}

6649

arg1 = (int)(val1);

6650

result = (int)gridInqYsize(arg1);

6651

vresult = SWIG_From_int((int)(result));

6652

return vresult;

6653

fail:

6654

return Qnil;

6655

}

6656

6657

6658

SWIGINTERN VALUE

6659

_wrap_gridDefXvals(int argc, VALUE *argv, VALUE self) {

6660

int arg1 ;

6661

double *arg2 = (double *) 0 ;

6662

int val1 ;

6663

int ecode1 = 0 ;

6664

void *argp2 = 0 ;

6665

int res2 = 0 ;

6666

6667

if ((argc < 2) || (argc > 2)) {

6668

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6669

}

6670

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6671

if (!SWIG_IsOK(ecode1)) {

6672

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXvals", 1, argv[0] ));

6673

}

6674

arg1 = (int)(val1);

6675

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

6676

if (!SWIG_IsOK(res2)) {

6677

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefXvals", 2, argv[1] ));

6678

}

6679

arg2 = (double *)(argp2);

6680

gridDefXvals(arg1,(double const *)arg2);

6681

return Qnil;

6682

fail:

6683

return Qnil;

6684

}

6685

6686

6687

SWIGINTERN VALUE

6688

_wrap_gridInqXvals(int argc, VALUE *argv, VALUE self) {

6689

int arg1 ;

6690

double *arg2 = (double *) 0 ;

6691

int val1 ;

6692

int ecode1 = 0 ;

6693

void *argp2 = 0 ;

6694

int res2 = 0 ;

6695

int result;

6696

VALUE vresult = Qnil;

6697

6698

if ((argc < 2) || (argc > 2)) {

6699

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6700

}

6701

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6702

if (!SWIG_IsOK(ecode1)) {

6703

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXvals", 1, argv[0] ));

6704

}

6705

arg1 = (int)(val1);

6706

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

6707

if (!SWIG_IsOK(res2)) {

6708

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqXvals", 2, argv[1] ));

6709

}

6710

arg2 = (double *)(argp2);

6711

result = (int)gridInqXvals(arg1,arg2);

6712

vresult = SWIG_From_int((int)(result));

6713

return vresult;

6714

fail:

6715

return Qnil;

6716

}

6717

6718

6719

SWIGINTERN VALUE

6720

_wrap_gridDefYvals(int argc, VALUE *argv, VALUE self) {

6721

int arg1 ;

6722

double *arg2 = (double *) 0 ;

6723

int val1 ;

6724

int ecode1 = 0 ;

6725

void *argp2 = 0 ;

6726

int res2 = 0 ;

6727

6728

if ((argc < 2) || (argc > 2)) {

6729

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6730

}

6731

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6732

if (!SWIG_IsOK(ecode1)) {

6733

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYvals", 1, argv[0] ));

6734

}

6735

arg1 = (int)(val1);

6736

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

6737

if (!SWIG_IsOK(res2)) {

6738

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefYvals", 2, argv[1] ));

6739

}

6740

arg2 = (double *)(argp2);

6741

gridDefYvals(arg1,(double const *)arg2);

6742

return Qnil;

6743

fail:

6744

return Qnil;

6745

}

6746

6747

6748

SWIGINTERN VALUE

6749

_wrap_gridInqYvals(int argc, VALUE *argv, VALUE self) {

6750

int arg1 ;

6751

double *arg2 = (double *) 0 ;

6752

int val1 ;

6753

int ecode1 = 0 ;

6754

void *argp2 = 0 ;

6755

int res2 = 0 ;

6756

int result;

6757

VALUE vresult = Qnil;

6758

6759

if ((argc < 2) || (argc > 2)) {

6760

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6761

}

6762

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6763

if (!SWIG_IsOK(ecode1)) {

6764

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYvals", 1, argv[0] ));

6765

}

6766

arg1 = (int)(val1);

6767

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

6768

if (!SWIG_IsOK(res2)) {

6769

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqYvals", 2, argv[1] ));

6770

}

6771

arg2 = (double *)(argp2);

6772

result = (int)gridInqYvals(arg1,arg2);

6773

vresult = SWIG_From_int((int)(result));

6774

return vresult;

6775

fail:

6776

return Qnil;

6777

}

6778

6779

6780

SWIGINTERN VALUE

6781

_wrap_gridDefXname(int argc, VALUE *argv, VALUE self) {

6782

int arg1 ;

6783

char *arg2 = (char *) 0 ;

6784

int val1 ;

6785

int ecode1 = 0 ;

6786

int res2 ;

6787

char *buf2 = 0 ;

6788

int alloc2 = 0 ;

6789

6790

if ((argc < 2) || (argc > 2)) {

6791

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6792

}

6793

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6794

if (!SWIG_IsOK(ecode1)) {

6795

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXname", 1, argv[0] ));

6796

}

6797

arg1 = (int)(val1);

6798

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

6799

if (!SWIG_IsOK(res2)) {

6800

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXname", 2, argv[1] ));

6801

}

6802

arg2 = (char *)(buf2);

6803

gridDefXname(arg1,(char const *)arg2);

6804

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6805

return Qnil;

6806

fail:

6807

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6808

return Qnil;

6809

}

6810

6811

6812

SWIGINTERN VALUE

6813

_wrap_gridDefXlongname(int argc, VALUE *argv, VALUE self) {

6814

int arg1 ;

6815

char *arg2 = (char *) 0 ;

6816

int val1 ;

6817

int ecode1 = 0 ;

6818

int res2 ;

6819

char *buf2 = 0 ;

6820

int alloc2 = 0 ;

6821

6822

if ((argc < 2) || (argc > 2)) {

6823

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6824

}

6825

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6826

if (!SWIG_IsOK(ecode1)) {

6827

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXlongname", 1, argv[0] ));

6828

}

6829

arg1 = (int)(val1);

6830

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

6831

if (!SWIG_IsOK(res2)) {

6832

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXlongname", 2, argv[1] ));

6833

}

6834

arg2 = (char *)(buf2);

6835

gridDefXlongname(arg1,(char const *)arg2);

6836

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6837

return Qnil;

6838

fail:

6839

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6840

return Qnil;

6841

}

6842

6843

6844

SWIGINTERN VALUE

6845

_wrap_gridDefXunits(int argc, VALUE *argv, VALUE self) {

6846

int arg1 ;

6847

char *arg2 = (char *) 0 ;

6848

int val1 ;

6849

int ecode1 = 0 ;

6850

int res2 ;

6851

char *buf2 = 0 ;

6852

int alloc2 = 0 ;

6853

6854

if ((argc < 2) || (argc > 2)) {

6855

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6856

}

6857

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6858

if (!SWIG_IsOK(ecode1)) {

6859

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXunits", 1, argv[0] ));

6860

}

6861

arg1 = (int)(val1);

6862

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

6863

if (!SWIG_IsOK(res2)) {

6864

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefXunits", 2, argv[1] ));

6865

}

6866

arg2 = (char *)(buf2);

6867

gridDefXunits(arg1,(char const *)arg2);

6868

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6869

return Qnil;

6870

fail:

6871

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6872

return Qnil;

6873

}

6874

6875

6876

SWIGINTERN VALUE

6877

_wrap_gridDefYname(int argc, VALUE *argv, VALUE self) {

6878

int arg1 ;

6879

char *arg2 = (char *) 0 ;

6880

int val1 ;

6881

int ecode1 = 0 ;

6882

int res2 ;

6883

char *buf2 = 0 ;

6884

int alloc2 = 0 ;

6885

6886

if ((argc < 2) || (argc > 2)) {

6887

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6888

}

6889

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6890

if (!SWIG_IsOK(ecode1)) {

6891

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYname", 1, argv[0] ));

6892

}

6893

arg1 = (int)(val1);

6894

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

6895

if (!SWIG_IsOK(res2)) {

6896

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYname", 2, argv[1] ));

6897

}

6898

arg2 = (char *)(buf2);

6899

gridDefYname(arg1,(char const *)arg2);

6900

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6901

return Qnil;

6902

fail:

6903

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6904

return Qnil;

6905

}

6906

6907

6908

SWIGINTERN VALUE

6909

_wrap_gridDefYlongname(int argc, VALUE *argv, VALUE self) {

6910

int arg1 ;

6911

char *arg2 = (char *) 0 ;

6912

int val1 ;

6913

int ecode1 = 0 ;

6914

int res2 ;

6915

char *buf2 = 0 ;

6916

int alloc2 = 0 ;

6917

6918

if ((argc < 2) || (argc > 2)) {

6919

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6920

}

6921

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6922

if (!SWIG_IsOK(ecode1)) {

6923

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYlongname", 1, argv[0] ));

6924

}

6925

arg1 = (int)(val1);

6926

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

6927

if (!SWIG_IsOK(res2)) {

6928

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYlongname", 2, argv[1] ));

6929

}

6930

arg2 = (char *)(buf2);

6931

gridDefYlongname(arg1,(char const *)arg2);

6932

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6933

return Qnil;

6934

fail:

6935

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6936

return Qnil;

6937

}

6938

6939

6940

SWIGINTERN VALUE

6941

_wrap_gridDefYunits(int argc, VALUE *argv, VALUE self) {

6942

int arg1 ;

6943

char *arg2 = (char *) 0 ;

6944

int val1 ;

6945

int ecode1 = 0 ;

6946

int res2 ;

6947

char *buf2 = 0 ;

6948

int alloc2 = 0 ;

6949

6950

if ((argc < 2) || (argc > 2)) {

6951

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6952

}

6953

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6954

if (!SWIG_IsOK(ecode1)) {

6955

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYunits", 1, argv[0] ));

6956

}

6957

arg1 = (int)(val1);

6958

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

6959

if (!SWIG_IsOK(res2)) {

6960

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","gridDefYunits", 2, argv[1] ));

6961

}

6962

arg2 = (char *)(buf2);

6963

gridDefYunits(arg1,(char const *)arg2);

6964

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6965

return Qnil;

6966

fail:

6967

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6968

return Qnil;

6969

}

6970

6971

6972

SWIGINTERN VALUE

6973

_wrap_gridInqXname(int argc, VALUE *argv, VALUE self) {

6974

int arg1 ;

6975

char *arg2 = (char *) 0 ;

6976

int val1 ;

6977

int ecode1 = 0 ;

6978

int res2 ;

6979

char *buf2 = 0 ;

6980

int alloc2 = 0 ;

6981

6982

if ((argc < 2) || (argc > 2)) {

6983

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

6984

}

6985

ecode1 = SWIG_AsVal_int(argv[0], &val1);

6986

if (!SWIG_IsOK(ecode1)) {

6987

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXname", 1, argv[0] ));

6988

}

6989

arg1 = (int)(val1);

6990

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

6991

if (!SWIG_IsOK(res2)) {

6992

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXname", 2, argv[1] ));

6993

}

6994

arg2 = (char *)(buf2);

6995

gridInqXname(arg1,arg2);

6996

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

6997

return Qnil;

6998

fail:

6999

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7000

return Qnil;

7001

}

7002

7003

7004

SWIGINTERN VALUE

7005

_wrap_gridInqXlongname(int argc, VALUE *argv, VALUE self) {

7006

int arg1 ;

7007

char *arg2 = (char *) 0 ;

7008

int val1 ;

7009

int ecode1 = 0 ;

7010

int res2 ;

7011

char *buf2 = 0 ;

7012

int alloc2 = 0 ;

7013

7014

if ((argc < 2) || (argc > 2)) {

7015

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7016

}

7017

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7018

if (!SWIG_IsOK(ecode1)) {

7019

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXlongname", 1, argv[0] ));

7020

}

7021

arg1 = (int)(val1);

7022

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

7023

if (!SWIG_IsOK(res2)) {

7024

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXlongname", 2, argv[1] ));

7025

}

7026

arg2 = (char *)(buf2);

7027

gridInqXlongname(arg1,arg2);

7028

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7029

return Qnil;

7030

fail:

7031

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7032

return Qnil;

7033

}

7034

7035

7036

SWIGINTERN VALUE

7037

_wrap_gridInqXstdname(int argc, VALUE *argv, VALUE self) {

7038

int arg1 ;

7039

char *arg2 = (char *) 0 ;

7040

int val1 ;

7041

int ecode1 = 0 ;

7042

int res2 ;

7043

char *buf2 = 0 ;

7044

int alloc2 = 0 ;

7045

7046

if ((argc < 2) || (argc > 2)) {

7047

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7048

}

7049

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7050

if (!SWIG_IsOK(ecode1)) {

7051

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXstdname", 1, argv[0] ));

7052

}

7053

arg1 = (int)(val1);

7054

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

7055

if (!SWIG_IsOK(res2)) {

7056

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXstdname", 2, argv[1] ));

7057

}

7058

arg2 = (char *)(buf2);

7059

gridInqXstdname(arg1,arg2);

7060

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7061

return Qnil;

7062

fail:

7063

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7064

return Qnil;

7065

}

7066

7067

7068

SWIGINTERN VALUE

7069

_wrap_gridInqXunits(int argc, VALUE *argv, VALUE self) {

7070

int arg1 ;

7071

char *arg2 = (char *) 0 ;

7072

int val1 ;

7073

int ecode1 = 0 ;

7074

int res2 ;

7075

char *buf2 = 0 ;

7076

int alloc2 = 0 ;

7077

7078

if ((argc < 2) || (argc > 2)) {

7079

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7080

}

7081

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7082

if (!SWIG_IsOK(ecode1)) {

7083

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXunits", 1, argv[0] ));

7084

}

7085

arg1 = (int)(val1);

7086

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

7087

if (!SWIG_IsOK(res2)) {

7088

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqXunits", 2, argv[1] ));

7089

}

7090

arg2 = (char *)(buf2);

7091

gridInqXunits(arg1,arg2);

7092

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7093

return Qnil;

7094

fail:

7095

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7096

return Qnil;

7097

}

7098

7099

7100

SWIGINTERN VALUE

7101

_wrap_gridInqYname(int argc, VALUE *argv, VALUE self) {

7102

int arg1 ;

7103

char *arg2 = (char *) 0 ;

7104

int val1 ;

7105

int ecode1 = 0 ;

7106

int res2 ;

7107

char *buf2 = 0 ;

7108

int alloc2 = 0 ;

7109

7110

if ((argc < 2) || (argc > 2)) {

7111

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7112

}

7113

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7114

if (!SWIG_IsOK(ecode1)) {

7115

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYname", 1, argv[0] ));

7116

}

7117

arg1 = (int)(val1);

7118

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

7119

if (!SWIG_IsOK(res2)) {

7120

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYname", 2, argv[1] ));

7121

}

7122

arg2 = (char *)(buf2);

7123

gridInqYname(arg1,arg2);

7124

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7125

return Qnil;

7126

fail:

7127

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7128

return Qnil;

7129

}

7130

7131

7132

SWIGINTERN VALUE

7133

_wrap_gridInqYlongname(int argc, VALUE *argv, VALUE self) {

7134

int arg1 ;

7135

char *arg2 = (char *) 0 ;

7136

int val1 ;

7137

int ecode1 = 0 ;

7138

int res2 ;

7139

char *buf2 = 0 ;

7140

int alloc2 = 0 ;

7141

7142

if ((argc < 2) || (argc > 2)) {

7143

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7144

}

7145

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7146

if (!SWIG_IsOK(ecode1)) {

7147

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYlongname", 1, argv[0] ));

7148

}

7149

arg1 = (int)(val1);

7150

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

7151

if (!SWIG_IsOK(res2)) {

7152

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYlongname", 2, argv[1] ));

7153

}

7154

arg2 = (char *)(buf2);

7155

gridInqYlongname(arg1,arg2);

7156

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7157

return Qnil;

7158

fail:

7159

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7160

return Qnil;

7161

}

7162

7163

7164

SWIGINTERN VALUE

7165

_wrap_gridInqYstdname(int argc, VALUE *argv, VALUE self) {

7166

int arg1 ;

7167

char *arg2 = (char *) 0 ;

7168

int val1 ;

7169

int ecode1 = 0 ;

7170

int res2 ;

7171

char *buf2 = 0 ;

7172

int alloc2 = 0 ;

7173

7174

if ((argc < 2) || (argc > 2)) {

7175

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7176

}

7177

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7178

if (!SWIG_IsOK(ecode1)) {

7179

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYstdname", 1, argv[0] ));

7180

}

7181

arg1 = (int)(val1);

7182

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

7183

if (!SWIG_IsOK(res2)) {

7184

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYstdname", 2, argv[1] ));

7185

}

7186

arg2 = (char *)(buf2);

7187

gridInqYstdname(arg1,arg2);

7188

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7189

return Qnil;

7190

fail:

7191

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7192

return Qnil;

7193

}

7194

7195

7196

SWIGINTERN VALUE

7197

_wrap_gridInqYunits(int argc, VALUE *argv, VALUE self) {

7198

int arg1 ;

7199

char *arg2 = (char *) 0 ;

7200

int val1 ;

7201

int ecode1 = 0 ;

7202

int res2 ;

7203

char *buf2 = 0 ;

7204

int alloc2 = 0 ;

7205

7206

if ((argc < 2) || (argc > 2)) {

7207

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7208

}

7209

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7210

if (!SWIG_IsOK(ecode1)) {

7211

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYunits", 1, argv[0] ));

7212

}

7213

arg1 = (int)(val1);

7214

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

7215

if (!SWIG_IsOK(res2)) {

7216

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","gridInqYunits", 2, argv[1] ));

7217

}

7218

arg2 = (char *)(buf2);

7219

gridInqYunits(arg1,arg2);

7220

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7221

return Qnil;

7222

fail:

7223

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

7224

return Qnil;

7225

}

7226

7227

7228

SWIGINTERN VALUE

7229

_wrap_gridDefPrec(int argc, VALUE *argv, VALUE self) {

7230

int arg1 ;

7231

int arg2 ;

7232

int val1 ;

7233

int ecode1 = 0 ;

7234

int val2 ;

7235

int ecode2 = 0 ;

7236

7237

if ((argc < 2) || (argc > 2)) {

7238

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7239

}

7240

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7241

if (!SWIG_IsOK(ecode1)) {

7242

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefPrec", 1, argv[0] ));

7243

}

7244

arg1 = (int)(val1);

7245

ecode2 = SWIG_AsVal_int(argv[1], &val2);

7246

if (!SWIG_IsOK(ecode2)) {

7247

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefPrec", 2, argv[1] ));

7248

}

7249

arg2 = (int)(val2);

7250

gridDefPrec(arg1,arg2);

7251

return Qnil;

7252

fail:

7253

return Qnil;

7254

}

7255

7256

7257

SWIGINTERN VALUE

7258

_wrap_gridInqPrec(int argc, VALUE *argv, VALUE self) {

7259

int arg1 ;

7260

int val1 ;

7261

int ecode1 = 0 ;

7262

int result;

7263

VALUE vresult = Qnil;

7264

7265

if ((argc < 1) || (argc > 1)) {

7266

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7267

}

7268

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7269

if (!SWIG_IsOK(ecode1)) {

7270

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqPrec", 1, argv[0] ));

7271

}

7272

arg1 = (int)(val1);

7273

result = (int)gridInqPrec(arg1);

7274

vresult = SWIG_From_int((int)(result));

7275

return vresult;

7276

fail:

7277

return Qnil;

7278

}

7279

7280

7281

SWIGINTERN VALUE

7282

_wrap_gridInqXval(int argc, VALUE *argv, VALUE self) {

7283

int arg1 ;

7284

int arg2 ;

7285

int val1 ;

7286

int ecode1 = 0 ;

7287

int val2 ;

7288

int ecode2 = 0 ;

7289

double result;

7290

VALUE vresult = Qnil;

7291

7292

if ((argc < 2) || (argc > 2)) {

7293

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7294

}

7295

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7296

if (!SWIG_IsOK(ecode1)) {

7297

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXval", 1, argv[0] ));

7298

}

7299

arg1 = (int)(val1);

7300

ecode2 = SWIG_AsVal_int(argv[1], &val2);

7301

if (!SWIG_IsOK(ecode2)) {

7302

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridInqXval", 2, argv[1] ));

7303

}

7304

arg2 = (int)(val2);

7305

result = (double)gridInqXval(arg1,arg2);

7306

vresult = SWIG_From_double((double)(result));

7307

return vresult;

7308

fail:

7309

return Qnil;

7310

}

7311

7312

7313

SWIGINTERN VALUE

7314

_wrap_gridInqYval(int argc, VALUE *argv, VALUE self) {

7315

int arg1 ;

7316

int arg2 ;

7317

int val1 ;

7318

int ecode1 = 0 ;

7319

int val2 ;

7320

int ecode2 = 0 ;

7321

double result;

7322

VALUE vresult = Qnil;

7323

7324

if ((argc < 2) || (argc > 2)) {

7325

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7326

}

7327

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7328

if (!SWIG_IsOK(ecode1)) {

7329

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYval", 1, argv[0] ));

7330

}

7331

arg1 = (int)(val1);

7332

ecode2 = SWIG_AsVal_int(argv[1], &val2);

7333

if (!SWIG_IsOK(ecode2)) {

7334

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridInqYval", 2, argv[1] ));

7335

}

7336

arg2 = (int)(val2);

7337

result = (double)gridInqYval(arg1,arg2);

7338

vresult = SWIG_From_double((double)(result));

7339

return vresult;

7340

fail:

7341

return Qnil;

7342

}

7343

7344

7345

SWIGINTERN VALUE

7346

_wrap_gridInqXinc(int argc, VALUE *argv, VALUE self) {

7347

int arg1 ;

7348

int val1 ;

7349

int ecode1 = 0 ;

7350

double result;

7351

VALUE vresult = Qnil;

7352

7353

if ((argc < 1) || (argc > 1)) {

7354

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7355

}

7356

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7357

if (!SWIG_IsOK(ecode1)) {

7358

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXinc", 1, argv[0] ));

7359

}

7360

arg1 = (int)(val1);

7361

result = (double)gridInqXinc(arg1);

7362

vresult = SWIG_From_double((double)(result));

7363

return vresult;

7364

fail:

7365

return Qnil;

7366

}

7367

7368

7369

SWIGINTERN VALUE

7370

_wrap_gridInqYinc(int argc, VALUE *argv, VALUE self) {

7371

int arg1 ;

7372

int val1 ;

7373

int ecode1 = 0 ;

7374

double result;

7375

VALUE vresult = Qnil;

7376

7377

if ((argc < 1) || (argc > 1)) {

7378

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7379

}

7380

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7381

if (!SWIG_IsOK(ecode1)) {

7382

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYinc", 1, argv[0] ));

7383

}

7384

arg1 = (int)(val1);

7385

result = (double)gridInqYinc(arg1);

7386

vresult = SWIG_From_double((double)(result));

7387

return vresult;

7388

fail:

7389

return Qnil;

7390

}

7391

7392

7393

SWIGINTERN VALUE

7394

_wrap_gridIsCircular(int argc, VALUE *argv, VALUE self) {

7395

int arg1 ;

7396

int val1 ;

7397

int ecode1 = 0 ;

7398

int result;

7399

VALUE vresult = Qnil;

7400

7401

if ((argc < 1) || (argc > 1)) {

7402

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7403

}

7404

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7405

if (!SWIG_IsOK(ecode1)) {

7406

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridIsCircular", 1, argv[0] ));

7407

}

7408

arg1 = (int)(val1);

7409

result = (int)gridIsCircular(arg1);

7410

vresult = SWIG_From_int((int)(result));

7411

return vresult;

7412

fail:

7413

return Qnil;

7414

}

7415

7416

7417

SWIGINTERN VALUE

7418

_wrap_gridIsRotated(int argc, VALUE *argv, VALUE self) {

7419

int arg1 ;

7420

int val1 ;

7421

int ecode1 = 0 ;

7422

int result;

7423

VALUE vresult = Qnil;

7424

7425

if ((argc < 1) || (argc > 1)) {

7426

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7427

}

7428

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7429

if (!SWIG_IsOK(ecode1)) {

7430

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridIsRotated", 1, argv[0] ));

7431

}

7432

arg1 = (int)(val1);

7433

result = (int)gridIsRotated(arg1);

7434

vresult = SWIG_From_int((int)(result));

7435

return vresult;

7436

fail:

7437

return Qnil;

7438

}

7439

7440

7441

SWIGINTERN VALUE

7442

_wrap_gridInqXpole(int argc, VALUE *argv, VALUE self) {

7443

int arg1 ;

7444

int val1 ;

7445

int ecode1 = 0 ;

7446

double result;

7447

VALUE vresult = Qnil;

7448

7449

if ((argc < 1) || (argc > 1)) {

7450

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7451

}

7452

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7453

if (!SWIG_IsOK(ecode1)) {

7454

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXpole", 1, argv[0] ));

7455

}

7456

arg1 = (int)(val1);

7457

result = (double)gridInqXpole(arg1);

7458

vresult = SWIG_From_double((double)(result));

7459

return vresult;

7460

fail:

7461

return Qnil;

7462

}

7463

7464

7465

SWIGINTERN VALUE

7466

_wrap_gridDefXpole(int argc, VALUE *argv, VALUE self) {

7467

int arg1 ;

7468

double arg2 ;

7469

int val1 ;

7470

int ecode1 = 0 ;

7471

double val2 ;

7472

int ecode2 = 0 ;

7473

7474

if ((argc < 2) || (argc > 2)) {

7475

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7476

}

7477

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7478

if (!SWIG_IsOK(ecode1)) {

7479

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXpole", 1, argv[0] ));

7480

}

7481

arg1 = (int)(val1);

7482

ecode2 = SWIG_AsVal_double(argv[1], &val2);

7483

if (!SWIG_IsOK(ecode2)) {

7484

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefXpole", 2, argv[1] ));

7485

}

7486

arg2 = (double)(val2);

7487

gridDefXpole(arg1,arg2);

7488

return Qnil;

7489

fail:

7490

return Qnil;

7491

}

7492

7493

7494

SWIGINTERN VALUE

7495

_wrap_gridInqYpole(int argc, VALUE *argv, VALUE self) {

7496

int arg1 ;

7497

int val1 ;

7498

int ecode1 = 0 ;

7499

double result;

7500

VALUE vresult = Qnil;

7501

7502

if ((argc < 1) || (argc > 1)) {

7503

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7504

}

7505

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7506

if (!SWIG_IsOK(ecode1)) {

7507

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYpole", 1, argv[0] ));

7508

}

7509

arg1 = (int)(val1);

7510

result = (double)gridInqYpole(arg1);

7511

vresult = SWIG_From_double((double)(result));

7512

return vresult;

7513

fail:

7514

return Qnil;

7515

}

7516

7517

7518

SWIGINTERN VALUE

7519

_wrap_gridDefYpole(int argc, VALUE *argv, VALUE self) {

7520

int arg1 ;

7521

double arg2 ;

7522

int val1 ;

7523

int ecode1 = 0 ;

7524

double val2 ;

7525

int ecode2 = 0 ;

7526

7527

if ((argc < 2) || (argc > 2)) {

7528

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7529

}

7530

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7531

if (!SWIG_IsOK(ecode1)) {

7532

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYpole", 1, argv[0] ));

7533

}

7534

arg1 = (int)(val1);

7535

ecode2 = SWIG_AsVal_double(argv[1], &val2);

7536

if (!SWIG_IsOK(ecode2)) {

7537

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefYpole", 2, argv[1] ));

7538

}

7539

arg2 = (double)(val2);

7540

gridDefYpole(arg1,arg2);

7541

return Qnil;

7542

fail:

7543

return Qnil;

7544

}

7545

7546

7547

SWIGINTERN VALUE

7548

_wrap_gridInqAngle(int argc, VALUE *argv, VALUE self) {

7549

int arg1 ;

7550

int val1 ;

7551

int ecode1 = 0 ;

7552

double result;

7553

VALUE vresult = Qnil;

7554

7555

if ((argc < 1) || (argc > 1)) {

7556

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7557

}

7558

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7559

if (!SWIG_IsOK(ecode1)) {

7560

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqAngle", 1, argv[0] ));

7561

}

7562

arg1 = (int)(val1);

7563

result = (double)gridInqAngle(arg1);

7564

vresult = SWIG_From_double((double)(result));

7565

return vresult;

7566

fail:

7567

return Qnil;

7568

}

7569

7570

7571

SWIGINTERN VALUE

7572

_wrap_gridDefAngle(int argc, VALUE *argv, VALUE self) {

7573

int arg1 ;

7574

double arg2 ;

7575

int val1 ;

7576

int ecode1 = 0 ;

7577

double val2 ;

7578

int ecode2 = 0 ;

7579

7580

if ((argc < 2) || (argc > 2)) {

7581

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7582

}

7583

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7584

if (!SWIG_IsOK(ecode1)) {

7585

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefAngle", 1, argv[0] ));

7586

}

7587

arg1 = (int)(val1);

7588

ecode2 = SWIG_AsVal_double(argv[1], &val2);

7589

if (!SWIG_IsOK(ecode2)) {

7590

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefAngle", 2, argv[1] ));

7591

}

7592

arg2 = (double)(val2);

7593

gridDefAngle(arg1,arg2);

7594

return Qnil;

7595

fail:

7596

return Qnil;

7597

}

7598

7599

7600

SWIGINTERN VALUE

7601

_wrap_gridDefTrunc(int argc, VALUE *argv, VALUE self) {

7602

int arg1 ;

7603

int arg2 ;

7604

int val1 ;

7605

int ecode1 = 0 ;

7606

int val2 ;

7607

int ecode2 = 0 ;

7608

7609

if ((argc < 2) || (argc > 2)) {

7610

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7611

}

7612

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7613

if (!SWIG_IsOK(ecode1)) {

7614

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefTrunc", 1, argv[0] ));

7615

}

7616

arg1 = (int)(val1);

7617

ecode2 = SWIG_AsVal_int(argv[1], &val2);

7618

if (!SWIG_IsOK(ecode2)) {

7619

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefTrunc", 2, argv[1] ));

7620

}

7621

arg2 = (int)(val2);

7622

gridDefTrunc(arg1,arg2);

7623

return Qnil;

7624

fail:

7625

return Qnil;

7626

}

7627

7628

7629

SWIGINTERN VALUE

7630

_wrap_gridInqTrunc(int argc, VALUE *argv, VALUE self) {

7631

int arg1 ;

7632

int val1 ;

7633

int ecode1 = 0 ;

7634

int result;

7635

VALUE vresult = Qnil;

7636

7637

if ((argc < 1) || (argc > 1)) {

7638

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7639

}

7640

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7641

if (!SWIG_IsOK(ecode1)) {

7642

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqTrunc", 1, argv[0] ));

7643

}

7644

arg1 = (int)(val1);

7645

result = (int)gridInqTrunc(arg1);

7646

vresult = SWIG_From_int((int)(result));

7647

return vresult;

7648

fail:

7649

return Qnil;

7650

}

7651

7652

7653

SWIGINTERN VALUE

7654

_wrap_gridInqGMEnd(int argc, VALUE *argv, VALUE self) {

7655

int arg1 ;

7656

int val1 ;

7657

int ecode1 = 0 ;

7658

int result;

7659

VALUE vresult = Qnil;

7660

7661

if ((argc < 1) || (argc > 1)) {

7662

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7663

}

7664

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7665

if (!SWIG_IsOK(ecode1)) {

7666

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqGMEnd", 1, argv[0] ));

7667

}

7668

arg1 = (int)(val1);

7669

result = (int)gridInqGMEnd(arg1);

7670

vresult = SWIG_From_int((int)(result));

7671

return vresult;

7672

fail:

7673

return Qnil;

7674

}

7675

7676

7677

SWIGINTERN VALUE

7678

_wrap_gridDefGMEnd(int argc, VALUE *argv, VALUE self) {

7679

int arg1 ;

7680

int arg2 ;

7681

int val1 ;

7682

int ecode1 = 0 ;

7683

int val2 ;

7684

int ecode2 = 0 ;

7685

7686

if ((argc < 2) || (argc > 2)) {

7687

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7688

}

7689

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7690

if (!SWIG_IsOK(ecode1)) {

7691

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefGMEnd", 1, argv[0] ));

7692

}

7693

arg1 = (int)(val1);

7694

ecode2 = SWIG_AsVal_int(argv[1], &val2);

7695

if (!SWIG_IsOK(ecode2)) {

7696

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefGMEnd", 2, argv[1] ));

7697

}

7698

arg2 = (int)(val2);

7699

gridDefGMEnd(arg1,arg2);

7700

return Qnil;

7701

fail:

7702

return Qnil;

7703

}

7704

7705

7706

SWIGINTERN VALUE

7707

_wrap_gridInqGMEni(int argc, VALUE *argv, VALUE self) {

7708

int arg1 ;

7709

int val1 ;

7710

int ecode1 = 0 ;

7711

int result;

7712

VALUE vresult = Qnil;

7713

7714

if ((argc < 1) || (argc > 1)) {

7715

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7716

}

7717

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7718

if (!SWIG_IsOK(ecode1)) {

7719

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqGMEni", 1, argv[0] ));

7720

}

7721

arg1 = (int)(val1);

7722

result = (int)gridInqGMEni(arg1);

7723

vresult = SWIG_From_int((int)(result));

7724

return vresult;

7725

fail:

7726

return Qnil;

7727

}

7728

7729

7730

SWIGINTERN VALUE

7731

_wrap_gridDefGMEni(int argc, VALUE *argv, VALUE self) {

7732

int arg1 ;

7733

int arg2 ;

7734

int val1 ;

7735

int ecode1 = 0 ;

7736

int val2 ;

7737

int ecode2 = 0 ;

7738

7739

if ((argc < 2) || (argc > 2)) {

7740

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7741

}

7742

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7743

if (!SWIG_IsOK(ecode1)) {

7744

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefGMEni", 1, argv[0] ));

7745

}

7746

arg1 = (int)(val1);

7747

ecode2 = SWIG_AsVal_int(argv[1], &val2);

7748

if (!SWIG_IsOK(ecode2)) {

7749

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefGMEni", 2, argv[1] ));

7750

}

7751

arg2 = (int)(val2);

7752

gridDefGMEni(arg1,arg2);

7753

return Qnil;

7754

fail:

7755

return Qnil;

7756

}

7757

7758

7759

SWIGINTERN VALUE

7760

_wrap_gridInqGMEni2(int argc, VALUE *argv, VALUE self) {

7761

int arg1 ;

7762

int val1 ;

7763

int ecode1 = 0 ;

7764

int result;

7765

VALUE vresult = Qnil;

7766

7767

if ((argc < 1) || (argc > 1)) {

7768

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7769

}

7770

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7771

if (!SWIG_IsOK(ecode1)) {

7772

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqGMEni2", 1, argv[0] ));

7773

}

7774

arg1 = (int)(val1);

7775

result = (int)gridInqGMEni2(arg1);

7776

vresult = SWIG_From_int((int)(result));

7777

return vresult;

7778

fail:

7779

return Qnil;

7780

}

7781

7782

7783

SWIGINTERN VALUE

7784

_wrap_gridDefGMEni2(int argc, VALUE *argv, VALUE self) {

7785

int arg1 ;

7786

int arg2 ;

7787

int val1 ;

7788

int ecode1 = 0 ;

7789

int val2 ;

7790

int ecode2 = 0 ;

7791

7792

if ((argc < 2) || (argc > 2)) {

7793

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7794

}

7795

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7796

if (!SWIG_IsOK(ecode1)) {

7797

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefGMEni2", 1, argv[0] ));

7798

}

7799

arg1 = (int)(val1);

7800

ecode2 = SWIG_AsVal_int(argv[1], &val2);

7801

if (!SWIG_IsOK(ecode2)) {

7802

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefGMEni2", 2, argv[1] ));

7803

}

7804

arg2 = (int)(val2);

7805

gridDefGMEni2(arg1,arg2);

7806

return Qnil;

7807

fail:

7808

return Qnil;

7809

}

7810

7811

7812

SWIGINTERN VALUE

7813

_wrap_gridInqGMEni3(int argc, VALUE *argv, VALUE self) {

7814

int arg1 ;

7815

int val1 ;

7816

int ecode1 = 0 ;

7817

int result;

7818

VALUE vresult = Qnil;

7819

7820

if ((argc < 1) || (argc > 1)) {

7821

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

7822

}

7823

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7824

if (!SWIG_IsOK(ecode1)) {

7825

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqGMEni3", 1, argv[0] ));

7826

}

7827

arg1 = (int)(val1);

7828

result = (int)gridInqGMEni3(arg1);

7829

vresult = SWIG_From_int((int)(result));

7830

return vresult;

7831

fail:

7832

return Qnil;

7833

}

7834

7835

7836

SWIGINTERN VALUE

7837

_wrap_gridDefGMEni3(int argc, VALUE *argv, VALUE self) {

7838

int arg1 ;

7839

int arg2 ;

7840

int val1 ;

7841

int ecode1 = 0 ;

7842

int val2 ;

7843

int ecode2 = 0 ;

7844

7845

if ((argc < 2) || (argc > 2)) {

7846

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

7847

}

7848

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7849

if (!SWIG_IsOK(ecode1)) {

7850

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefGMEni3", 1, argv[0] ));

7851

}

7852

arg1 = (int)(val1);

7853

ecode2 = SWIG_AsVal_int(argv[1], &val2);

7854

if (!SWIG_IsOK(ecode2)) {

7855

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefGMEni3", 2, argv[1] ));

7856

}

7857

arg2 = (int)(val2);

7858

gridDefGMEni3(arg1,arg2);

7859

return Qnil;

7860

fail:

7861

return Qnil;

7862

}

7863

7864

7865

SWIGINTERN VALUE

7866

_wrap_gridDefLCC(int argc, VALUE *argv, VALUE self) {

7867

int arg1 ;

7868

double arg2 ;

7869

double arg3 ;

7870

double arg4 ;

7871

double arg5 ;

7872

double arg6 ;

7873

double arg7 ;

7874

double arg8 ;

7875

int arg9 ;

7876

int arg10 ;

7877

int val1 ;

7878

int ecode1 = 0 ;

7879

double val2 ;

7880

int ecode2 = 0 ;

7881

double val3 ;

7882

int ecode3 = 0 ;

7883

double val4 ;

7884

int ecode4 = 0 ;

7885

double val5 ;

7886

int ecode5 = 0 ;

7887

double val6 ;

7888

int ecode6 = 0 ;

7889

double val7 ;

7890

int ecode7 = 0 ;

7891

double val8 ;

7892

int ecode8 = 0 ;

7893

int val9 ;

7894

int ecode9 = 0 ;

7895

int val10 ;

7896

int ecode10 = 0 ;

7897

7898

if ((argc < 10) || (argc > 10)) {

7899

rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;

7900

}

7901

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7902

if (!SWIG_IsOK(ecode1)) {

7903

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefLCC", 1, argv[0] ));

7904

}

7905

arg1 = (int)(val1);

7906

ecode2 = SWIG_AsVal_double(argv[1], &val2);

7907

if (!SWIG_IsOK(ecode2)) {

7908

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefLCC", 2, argv[1] ));

7909

}

7910

arg2 = (double)(val2);

7911

ecode3 = SWIG_AsVal_double(argv[2], &val3);

7912

if (!SWIG_IsOK(ecode3)) {

7913

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefLCC", 3, argv[2] ));

7914

}

7915

arg3 = (double)(val3);

7916

ecode4 = SWIG_AsVal_double(argv[3], &val4);

7917

if (!SWIG_IsOK(ecode4)) {

7918

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefLCC", 4, argv[3] ));

7919

}

7920

arg4 = (double)(val4);

7921

ecode5 = SWIG_AsVal_double(argv[4], &val5);

7922

if (!SWIG_IsOK(ecode5)) {

7923

SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","gridDefLCC", 5, argv[4] ));

7924

}

7925

arg5 = (double)(val5);

7926

ecode6 = SWIG_AsVal_double(argv[5], &val6);

7927

if (!SWIG_IsOK(ecode6)) {

7928

SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","gridDefLCC", 6, argv[5] ));

7929

}

7930

arg6 = (double)(val6);

7931

ecode7 = SWIG_AsVal_double(argv[6], &val7);

7932

if (!SWIG_IsOK(ecode7)) {

7933

SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "double","gridDefLCC", 7, argv[6] ));

7934

}

7935

arg7 = (double)(val7);

7936

ecode8 = SWIG_AsVal_double(argv[7], &val8);

7937

if (!SWIG_IsOK(ecode8)) {

7938

SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "double","gridDefLCC", 8, argv[7] ));

7939

}

7940

arg8 = (double)(val8);

7941

ecode9 = SWIG_AsVal_int(argv[8], &val9);

7942

if (!SWIG_IsOK(ecode9)) {

7943

SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","gridDefLCC", 9, argv[8] ));

7944

}

7945

arg9 = (int)(val9);

7946

ecode10 = SWIG_AsVal_int(argv[9], &val10);

7947

if (!SWIG_IsOK(ecode10)) {

7948

SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","gridDefLCC", 10, argv[9] ));

7949

}

7950

arg10 = (int)(val10);

7951

gridDefLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);

7952

return Qnil;

7953

fail:

7954

return Qnil;

7955

}

7956

7957

7958

SWIGINTERN VALUE

7959

_wrap_gridInqLCC(int argc, VALUE *argv, VALUE self) {

7960

int arg1 ;

7961

double *arg2 = (double *) 0 ;

7962

double *arg3 = (double *) 0 ;

7963

double *arg4 = (double *) 0 ;

7964

double *arg5 = (double *) 0 ;

7965

double *arg6 = (double *) 0 ;

7966

double *arg7 = (double *) 0 ;

7967

double *arg8 = (double *) 0 ;

7968

int *arg9 = (int *) 0 ;

7969

int *arg10 = (int *) 0 ;

7970

int val1 ;

7971

int ecode1 = 0 ;

7972

void *argp2 = 0 ;

7973

int res2 = 0 ;

7974

void *argp3 = 0 ;

7975

int res3 = 0 ;

7976

void *argp4 = 0 ;

7977

int res4 = 0 ;

7978

void *argp5 = 0 ;

7979

int res5 = 0 ;

7980

void *argp6 = 0 ;

7981

int res6 = 0 ;

7982

void *argp7 = 0 ;

7983

int res7 = 0 ;

7984

void *argp8 = 0 ;

7985

int res8 = 0 ;

7986

void *argp9 = 0 ;

7987

int res9 = 0 ;

7988

void *argp10 = 0 ;

7989

int res10 = 0 ;

7990

7991

if ((argc < 10) || (argc > 10)) {

7992

rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;

7993

}

7994

ecode1 = SWIG_AsVal_int(argv[0], &val1);

7995

if (!SWIG_IsOK(ecode1)) {

7996

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqLCC", 1, argv[0] ));

7997

}

7998

arg1 = (int)(val1);

7999

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8000

if (!SWIG_IsOK(res2)) {

8001

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqLCC", 2, argv[1] ));

8002

}

8003

arg2 = (double *)(argp2);

8004

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );

8005

if (!SWIG_IsOK(res3)) {

8006

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqLCC", 3, argv[2] ));

8007

}

8008

arg3 = (double *)(argp3);

8009

res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );

8010

if (!SWIG_IsOK(res4)) {

8011

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqLCC", 4, argv[3] ));

8012

}

8013

arg4 = (double *)(argp4);

8014

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );

8015

if (!SWIG_IsOK(res5)) {

8016

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double *","gridInqLCC", 5, argv[4] ));

8017

}

8018

arg5 = (double *)(argp5);

8019

res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_double, 0 | 0 );

8020

if (!SWIG_IsOK(res6)) {

8021

SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "double *","gridInqLCC", 6, argv[5] ));

8022

}

8023

arg6 = (double *)(argp6);

8024

res7 = SWIG_ConvertPtr(argv[6], &argp7,SWIGTYPE_p_double, 0 | 0 );

8025

if (!SWIG_IsOK(res7)) {

8026

SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "double *","gridInqLCC", 7, argv[6] ));

8027

}

8028

arg7 = (double *)(argp7);

8029

res8 = SWIG_ConvertPtr(argv[7], &argp8,SWIGTYPE_p_double, 0 | 0 );

8030

if (!SWIG_IsOK(res8)) {

8031

SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "double *","gridInqLCC", 8, argv[7] ));

8032

}

8033

arg8 = (double *)(argp8);

8034

res9 = SWIG_ConvertPtr(argv[8], &argp9,SWIGTYPE_p_int, 0 | 0 );

8035

if (!SWIG_IsOK(res9)) {

8036

SWIG_exception_fail(SWIG_ArgError(res9), Ruby_Format_TypeError( "", "int *","gridInqLCC", 9, argv[8] ));

8037

}

8038

arg9 = (int *)(argp9);

8039

res10 = SWIG_ConvertPtr(argv[9], &argp10,SWIGTYPE_p_int, 0 | 0 );

8040

if (!SWIG_IsOK(res10)) {

8041

SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "int *","gridInqLCC", 10, argv[9] ));

8042

}

8043

arg10 = (int *)(argp10);

8044

gridInqLCC(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);

8045

return Qnil;

8046

fail:

8047

return Qnil;

8048

}

8049

8050

8051

SWIGINTERN VALUE

8052

_wrap_gridDefLcc2(int argc, VALUE *argv, VALUE self) {

8053

int arg1 ;

8054

double arg2 ;

8055

double arg3 ;

8056

double arg4 ;

8057

double arg5 ;

8058

double arg6 ;

8059

int val1 ;

8060

int ecode1 = 0 ;

8061

double val2 ;

8062

int ecode2 = 0 ;

8063

double val3 ;

8064

int ecode3 = 0 ;

8065

double val4 ;

8066

int ecode4 = 0 ;

8067

double val5 ;

8068

int ecode5 = 0 ;

8069

double val6 ;

8070

int ecode6 = 0 ;

8071

8072

if ((argc < 6) || (argc > 6)) {

8073

rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;

8074

}

8075

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8076

if (!SWIG_IsOK(ecode1)) {

8077

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefLcc2", 1, argv[0] ));

8078

}

8079

arg1 = (int)(val1);

8080

ecode2 = SWIG_AsVal_double(argv[1], &val2);

8081

if (!SWIG_IsOK(ecode2)) {

8082

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefLcc2", 2, argv[1] ));

8083

}

8084

arg2 = (double)(val2);

8085

ecode3 = SWIG_AsVal_double(argv[2], &val3);

8086

if (!SWIG_IsOK(ecode3)) {

8087

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefLcc2", 3, argv[2] ));

8088

}

8089

arg3 = (double)(val3);

8090

ecode4 = SWIG_AsVal_double(argv[3], &val4);

8091

if (!SWIG_IsOK(ecode4)) {

8092

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefLcc2", 4, argv[3] ));

8093

}

8094

arg4 = (double)(val4);

8095

ecode5 = SWIG_AsVal_double(argv[4], &val5);

8096

if (!SWIG_IsOK(ecode5)) {

8097

SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "double","gridDefLcc2", 5, argv[4] ));

8098

}

8099

arg5 = (double)(val5);

8100

ecode6 = SWIG_AsVal_double(argv[5], &val6);

8101

if (!SWIG_IsOK(ecode6)) {

8102

SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "double","gridDefLcc2", 6, argv[5] ));

8103

}

8104

arg6 = (double)(val6);

8105

gridDefLcc2(arg1,arg2,arg3,arg4,arg5,arg6);

8106

return Qnil;

8107

fail:

8108

return Qnil;

8109

}

8110

8111

8112

SWIGINTERN VALUE

8113

_wrap_gridInqLcc2(int argc, VALUE *argv, VALUE self) {

8114

int arg1 ;

8115

double *arg2 = (double *) 0 ;

8116

double *arg3 = (double *) 0 ;

8117

double *arg4 = (double *) 0 ;

8118

double *arg5 = (double *) 0 ;

8119

double *arg6 = (double *) 0 ;

8120

int val1 ;

8121

int ecode1 = 0 ;

8122

void *argp2 = 0 ;

8123

int res2 = 0 ;

8124

void *argp3 = 0 ;

8125

int res3 = 0 ;

8126

void *argp4 = 0 ;

8127

int res4 = 0 ;

8128

void *argp5 = 0 ;

8129

int res5 = 0 ;

8130

void *argp6 = 0 ;

8131

int res6 = 0 ;

8132

8133

if ((argc < 6) || (argc > 6)) {

8134

rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;

8135

}

8136

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8137

if (!SWIG_IsOK(ecode1)) {

8138

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqLcc2", 1, argv[0] ));

8139

}

8140

arg1 = (int)(val1);

8141

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8142

if (!SWIG_IsOK(res2)) {

8143

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 2, argv[1] ));

8144

}

8145

arg2 = (double *)(argp2);

8146

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );

8147

if (!SWIG_IsOK(res3)) {

8148

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 3, argv[2] ));

8149

}

8150

arg3 = (double *)(argp3);

8151

res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );

8152

if (!SWIG_IsOK(res4)) {

8153

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 4, argv[3] ));

8154

}

8155

arg4 = (double *)(argp4);

8156

res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_double, 0 | 0 );

8157

if (!SWIG_IsOK(res5)) {

8158

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 5, argv[4] ));

8159

}

8160

arg5 = (double *)(argp5);

8161

res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_double, 0 | 0 );

8162

if (!SWIG_IsOK(res6)) {

8163

SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "double *","gridInqLcc2", 6, argv[5] ));

8164

}

8165

arg6 = (double *)(argp6);

8166

gridInqLcc2(arg1,arg2,arg3,arg4,arg5,arg6);

8167

return Qnil;

8168

fail:

8169

return Qnil;

8170

}

8171

8172

8173

SWIGINTERN VALUE

8174

_wrap_gridDefLaea(int argc, VALUE *argv, VALUE self) {

8175

int arg1 ;

8176

double arg2 ;

8177

double arg3 ;

8178

double arg4 ;

8179

int val1 ;

8180

int ecode1 = 0 ;

8181

double val2 ;

8182

int ecode2 = 0 ;

8183

double val3 ;

8184

int ecode3 = 0 ;

8185

double val4 ;

8186

int ecode4 = 0 ;

8187

8188

if ((argc < 4) || (argc > 4)) {

8189

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

8190

}

8191

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8192

if (!SWIG_IsOK(ecode1)) {

8193

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefLaea", 1, argv[0] ));

8194

}

8195

arg1 = (int)(val1);

8196

ecode2 = SWIG_AsVal_double(argv[1], &val2);

8197

if (!SWIG_IsOK(ecode2)) {

8198

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","gridDefLaea", 2, argv[1] ));

8199

}

8200

arg2 = (double)(val2);

8201

ecode3 = SWIG_AsVal_double(argv[2], &val3);

8202

if (!SWIG_IsOK(ecode3)) {

8203

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","gridDefLaea", 3, argv[2] ));

8204

}

8205

arg3 = (double)(val3);

8206

ecode4 = SWIG_AsVal_double(argv[3], &val4);

8207

if (!SWIG_IsOK(ecode4)) {

8208

SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "double","gridDefLaea", 4, argv[3] ));

8209

}

8210

arg4 = (double)(val4);

8211

gridDefLaea(arg1,arg2,arg3,arg4);

8212

return Qnil;

8213

fail:

8214

return Qnil;

8215

}

8216

8217

8218

SWIGINTERN VALUE

8219

_wrap_gridInqLaea(int argc, VALUE *argv, VALUE self) {

8220

int arg1 ;

8221

double *arg2 = (double *) 0 ;

8222

double *arg3 = (double *) 0 ;

8223

double *arg4 = (double *) 0 ;

8224

int val1 ;

8225

int ecode1 = 0 ;

8226

void *argp2 = 0 ;

8227

int res2 = 0 ;

8228

void *argp3 = 0 ;

8229

int res3 = 0 ;

8230

void *argp4 = 0 ;

8231

int res4 = 0 ;

8232

8233

if ((argc < 4) || (argc > 4)) {

8234

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

8235

}

8236

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8237

if (!SWIG_IsOK(ecode1)) {

8238

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqLaea", 1, argv[0] ));

8239

}

8240

arg1 = (int)(val1);

8241

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8242

if (!SWIG_IsOK(res2)) {

8243

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqLaea", 2, argv[1] ));

8244

}

8245

arg2 = (double *)(argp2);

8246

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );

8247

if (!SWIG_IsOK(res3)) {

8248

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double *","gridInqLaea", 3, argv[2] ));

8249

}

8250

arg3 = (double *)(argp3);

8251

res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_double, 0 | 0 );

8252

if (!SWIG_IsOK(res4)) {

8253

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "double *","gridInqLaea", 4, argv[3] ));

8254

}

8255

arg4 = (double *)(argp4);

8256

gridInqLaea(arg1,arg2,arg3,arg4);

8257

return Qnil;

8258

fail:

8259

return Qnil;

8260

}

8261

8262

8263

SWIGINTERN VALUE

8264

_wrap_gridDefArea(int argc, VALUE *argv, VALUE self) {

8265

int arg1 ;

8266

double *arg2 = (double *) 0 ;

8267

int val1 ;

8268

int ecode1 = 0 ;

8269

void *argp2 = 0 ;

8270

int res2 = 0 ;

8271

8272

if ((argc < 2) || (argc > 2)) {

8273

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8274

}

8275

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8276

if (!SWIG_IsOK(ecode1)) {

8277

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefArea", 1, argv[0] ));

8278

}

8279

arg1 = (int)(val1);

8280

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8281

if (!SWIG_IsOK(res2)) {

8282

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefArea", 2, argv[1] ));

8283

}

8284

arg2 = (double *)(argp2);

8285

gridDefArea(arg1,(double const *)arg2);

8286

return Qnil;

8287

fail:

8288

return Qnil;

8289

}

8290

8291

8292

SWIGINTERN VALUE

8293

_wrap_gridInqArea(int argc, VALUE *argv, VALUE self) {

8294

int arg1 ;

8295

double *arg2 = (double *) 0 ;

8296

int val1 ;

8297

int ecode1 = 0 ;

8298

void *argp2 = 0 ;

8299

int res2 = 0 ;

8300

8301

if ((argc < 2) || (argc > 2)) {

8302

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8303

}

8304

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8305

if (!SWIG_IsOK(ecode1)) {

8306

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqArea", 1, argv[0] ));

8307

}

8308

arg1 = (int)(val1);

8309

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8310

if (!SWIG_IsOK(res2)) {

8311

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqArea", 2, argv[1] ));

8312

}

8313

arg2 = (double *)(argp2);

8314

gridInqArea(arg1,arg2);

8315

return Qnil;

8316

fail:

8317

return Qnil;

8318

}

8319

8320

8321

SWIGINTERN VALUE

8322

_wrap_gridHasArea(int argc, VALUE *argv, VALUE self) {

8323

int arg1 ;

8324

int val1 ;

8325

int ecode1 = 0 ;

8326

int result;

8327

VALUE vresult = Qnil;

8328

8329

if ((argc < 1) || (argc > 1)) {

8330

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

8331

}

8332

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8333

if (!SWIG_IsOK(ecode1)) {

8334

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridHasArea", 1, argv[0] ));

8335

}

8336

arg1 = (int)(val1);

8337

result = (int)gridHasArea(arg1);

8338

vresult = SWIG_From_int((int)(result));

8339

return vresult;

8340

fail:

8341

return Qnil;

8342

}

8343

8344

8345

SWIGINTERN VALUE

8346

_wrap_gridDefNvertex(int argc, VALUE *argv, VALUE self) {

8347

int arg1 ;

8348

int arg2 ;

8349

int val1 ;

8350

int ecode1 = 0 ;

8351

int val2 ;

8352

int ecode2 = 0 ;

8353

8354

if ((argc < 2) || (argc > 2)) {

8355

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8356

}

8357

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8358

if (!SWIG_IsOK(ecode1)) {

8359

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefNvertex", 1, argv[0] ));

8360

}

8361

arg1 = (int)(val1);

8362

ecode2 = SWIG_AsVal_int(argv[1], &val2);

8363

if (!SWIG_IsOK(ecode2)) {

8364

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefNvertex", 2, argv[1] ));

8365

}

8366

arg2 = (int)(val2);

8367

gridDefNvertex(arg1,arg2);

8368

return Qnil;

8369

fail:

8370

return Qnil;

8371

}

8372

8373

8374

SWIGINTERN VALUE

8375

_wrap_gridInqNvertex(int argc, VALUE *argv, VALUE self) {

8376

int arg1 ;

8377

int val1 ;

8378

int ecode1 = 0 ;

8379

int result;

8380

VALUE vresult = Qnil;

8381

8382

if ((argc < 1) || (argc > 1)) {

8383

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

8384

}

8385

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8386

if (!SWIG_IsOK(ecode1)) {

8387

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqNvertex", 1, argv[0] ));

8388

}

8389

arg1 = (int)(val1);

8390

result = (int)gridInqNvertex(arg1);

8391

vresult = SWIG_From_int((int)(result));

8392

return vresult;

8393

fail:

8394

return Qnil;

8395

}

8396

8397

8398

SWIGINTERN VALUE

8399

_wrap_gridDefXbounds(int argc, VALUE *argv, VALUE self) {

8400

int arg1 ;

8401

double *arg2 = (double *) 0 ;

8402

int val1 ;

8403

int ecode1 = 0 ;

8404

void *argp2 = 0 ;

8405

int res2 = 0 ;

8406

8407

if ((argc < 2) || (argc > 2)) {

8408

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8409

}

8410

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8411

if (!SWIG_IsOK(ecode1)) {

8412

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefXbounds", 1, argv[0] ));

8413

}

8414

arg1 = (int)(val1);

8415

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8416

if (!SWIG_IsOK(res2)) {

8417

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefXbounds", 2, argv[1] ));

8418

}

8419

arg2 = (double *)(argp2);

8420

gridDefXbounds(arg1,(double const *)arg2);

8421

return Qnil;

8422

fail:

8423

return Qnil;

8424

}

8425

8426

8427

SWIGINTERN VALUE

8428

_wrap_gridInqXbounds(int argc, VALUE *argv, VALUE self) {

8429

int arg1 ;

8430

double *arg2 = (double *) 0 ;

8431

int val1 ;

8432

int ecode1 = 0 ;

8433

void *argp2 = 0 ;

8434

int res2 = 0 ;

8435

int result;

8436

VALUE vresult = Qnil;

8437

8438

if ((argc < 2) || (argc > 2)) {

8439

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8440

}

8441

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8442

if (!SWIG_IsOK(ecode1)) {

8443

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqXbounds", 1, argv[0] ));

8444

}

8445

arg1 = (int)(val1);

8446

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8447

if (!SWIG_IsOK(res2)) {

8448

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqXbounds", 2, argv[1] ));

8449

}

8450

arg2 = (double *)(argp2);

8451

result = (int)gridInqXbounds(arg1,arg2);

8452

vresult = SWIG_From_int((int)(result));

8453

return vresult;

8454

fail:

8455

return Qnil;

8456

}

8457

8458

8459

SWIGINTERN VALUE

8460

_wrap_gridDefYbounds(int argc, VALUE *argv, VALUE self) {

8461

int arg1 ;

8462

double *arg2 = (double *) 0 ;

8463

int val1 ;

8464

int ecode1 = 0 ;

8465

void *argp2 = 0 ;

8466

int res2 = 0 ;

8467

8468

if ((argc < 2) || (argc > 2)) {

8469

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8470

}

8471

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8472

if (!SWIG_IsOK(ecode1)) {

8473

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefYbounds", 1, argv[0] ));

8474

}

8475

arg1 = (int)(val1);

8476

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8477

if (!SWIG_IsOK(res2)) {

8478

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","gridDefYbounds", 2, argv[1] ));

8479

}

8480

arg2 = (double *)(argp2);

8481

gridDefYbounds(arg1,(double const *)arg2);

8482

return Qnil;

8483

fail:

8484

return Qnil;

8485

}

8486

8487

8488

SWIGINTERN VALUE

8489

_wrap_gridInqYbounds(int argc, VALUE *argv, VALUE self) {

8490

int arg1 ;

8491

double *arg2 = (double *) 0 ;

8492

int val1 ;

8493

int ecode1 = 0 ;

8494

void *argp2 = 0 ;

8495

int res2 = 0 ;

8496

int result;

8497

VALUE vresult = Qnil;

8498

8499

if ((argc < 2) || (argc > 2)) {

8500

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8501

}

8502

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8503

if (!SWIG_IsOK(ecode1)) {

8504

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqYbounds", 1, argv[0] ));

8505

}

8506

arg1 = (int)(val1);

8507

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8508

if (!SWIG_IsOK(res2)) {

8509

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","gridInqYbounds", 2, argv[1] ));

8510

}

8511

arg2 = (double *)(argp2);

8512

result = (int)gridInqYbounds(arg1,arg2);

8513

vresult = SWIG_From_int((int)(result));

8514

return vresult;

8515

fail:

8516

return Qnil;

8517

}

8518

8519

8520

SWIGINTERN VALUE

8521

_wrap_gridDefRowlon(int argc, VALUE *argv, VALUE self) {

8522

int arg1 ;

8523

int arg2 ;

8524

int *arg3 = (int *) 0 ;

8525

int val1 ;

8526

int ecode1 = 0 ;

8527

int val2 ;

8528

int ecode2 = 0 ;

8529

void *argp3 = 0 ;

8530

int res3 = 0 ;

8531

8532

if ((argc < 3) || (argc > 3)) {

8533

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

8534

}

8535

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8536

if (!SWIG_IsOK(ecode1)) {

8537

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridDefRowlon", 1, argv[0] ));

8538

}

8539

arg1 = (int)(val1);

8540

ecode2 = SWIG_AsVal_int(argv[1], &val2);

8541

if (!SWIG_IsOK(ecode2)) {

8542

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridDefRowlon", 2, argv[1] ));

8543

}

8544

arg2 = (int)(val2);

8545

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );

8546

if (!SWIG_IsOK(res3)) {

8547

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const *","gridDefRowlon", 3, argv[2] ));

8548

}

8549

arg3 = (int *)(argp3);

8550

gridDefRowlon(arg1,arg2,(int const *)arg3);

8551

return Qnil;

8552

fail:

8553

return Qnil;

8554

}

8555

8556

8557

SWIGINTERN VALUE

8558

_wrap_gridInqRowlon(int argc, VALUE *argv, VALUE self) {

8559

int arg1 ;

8560

int *arg2 = (int *) 0 ;

8561

int val1 ;

8562

int ecode1 = 0 ;

8563

void *argp2 = 0 ;

8564

int res2 = 0 ;

8565

8566

if ((argc < 2) || (argc > 2)) {

8567

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8568

}

8569

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8570

if (!SWIG_IsOK(ecode1)) {

8571

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridInqRowlon", 1, argv[0] ));

8572

}

8573

arg1 = (int)(val1);

8574

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );

8575

if (!SWIG_IsOK(res2)) {

8576

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","gridInqRowlon", 2, argv[1] ));

8577

}

8578

arg2 = (int *)(argp2);

8579

gridInqRowlon(arg1,arg2);

8580

return Qnil;

8581

fail:

8582

return Qnil;

8583

}

8584

8585

8586

SWIGINTERN VALUE

8587

_wrap_gridChangeType(int argc, VALUE *argv, VALUE self) {

8588

int arg1 ;

8589

int arg2 ;

8590

int val1 ;

8591

int ecode1 = 0 ;

8592

int val2 ;

8593

int ecode2 = 0 ;

8594

8595

if ((argc < 2) || (argc > 2)) {

8596

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8597

}

8598

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8599

if (!SWIG_IsOK(ecode1)) {

8600

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","gridChangeType", 1, argv[0] ));

8601

}

8602

arg1 = (int)(val1);

8603

ecode2 = SWIG_AsVal_int(argv[1], &val2);

8604

if (!SWIG_IsOK(ecode2)) {

8605

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","gridChangeType", 2, argv[1] ));

8606

}

8607

arg2 = (int)(val2);

8608

gridChangeType(arg1,arg2);

8609

return Qnil;

8610

fail:

8611

return Qnil;

8612

}

8613

8614

8615

SWIGINTERN VALUE

8616

_wrap_zaxisName(int argc, VALUE *argv, VALUE self) {

8617

int arg1 ;

8618

char *arg2 = (char *) 0 ;

8619

int val1 ;

8620

int ecode1 = 0 ;

8621

int res2 ;

8622

char *buf2 = 0 ;

8623

int alloc2 = 0 ;

8624

8625

if ((argc < 2) || (argc > 2)) {

8626

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8627

}

8628

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8629

if (!SWIG_IsOK(ecode1)) {

8630

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisName", 1, argv[0] ));

8631

}

8632

arg1 = (int)(val1);

8633

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

8634

if (!SWIG_IsOK(res2)) {

8635

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisName", 2, argv[1] ));

8636

}

8637

arg2 = (char *)(buf2);

8638

zaxisName(arg1,arg2);

8639

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

8640

return Qnil;

8641

fail:

8642

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

8643

return Qnil;

8644

}

8645

8646

8647

SWIGINTERN VALUE

8648

_wrap_zaxisCreate(int argc, VALUE *argv, VALUE self) {

8649

int arg1 ;

8650

int arg2 ;

8651

int val1 ;

8652

int ecode1 = 0 ;

8653

int val2 ;

8654

int ecode2 = 0 ;

8655

int result;

8656

VALUE vresult = Qnil;

8657

8658

if ((argc < 2) || (argc > 2)) {

8659

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8660

}

8661

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8662

if (!SWIG_IsOK(ecode1)) {

8663

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisCreate", 1, argv[0] ));

8664

}

8665

arg1 = (int)(val1);

8666

ecode2 = SWIG_AsVal_int(argv[1], &val2);

8667

if (!SWIG_IsOK(ecode2)) {

8668

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisCreate", 2, argv[1] ));

8669

}

8670

arg2 = (int)(val2);

8671

result = (int)zaxisCreate(arg1,arg2);

8672

vresult = SWIG_From_int((int)(result));

8673

return vresult;

8674

fail:

8675

return Qnil;

8676

}

8677

8678

8679

SWIGINTERN VALUE

8680

_wrap_zaxisDestroy(int argc, VALUE *argv, VALUE self) {

8681

int arg1 ;

8682

int val1 ;

8683

int ecode1 = 0 ;

8684

8685

if ((argc < 1) || (argc > 1)) {

8686

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

8687

}

8688

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8689

if (!SWIG_IsOK(ecode1)) {

8690

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDestroy", 1, argv[0] ));

8691

}

8692

arg1 = (int)(val1);

8693

zaxisDestroy(arg1);

8694

return Qnil;

8695

fail:

8696

return Qnil;

8697

}

8698

8699

8700

SWIGINTERN VALUE

8701

_wrap_zaxisInqType(int argc, VALUE *argv, VALUE self) {

8702

int arg1 ;

8703

int val1 ;

8704

int ecode1 = 0 ;

8705

int result;

8706

VALUE vresult = Qnil;

8707

8708

if ((argc < 1) || (argc > 1)) {

8709

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

8710

}

8711

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8712

if (!SWIG_IsOK(ecode1)) {

8713

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqType", 1, argv[0] ));

8714

}

8715

arg1 = (int)(val1);

8716

result = (int)zaxisInqType(arg1);

8717

vresult = SWIG_From_int((int)(result));

8718

return vresult;

8719

fail:

8720

return Qnil;

8721

}

8722

8723

8724

SWIGINTERN VALUE

8725

_wrap_zaxisInqSize(int argc, VALUE *argv, VALUE self) {

8726

int arg1 ;

8727

int val1 ;

8728

int ecode1 = 0 ;

8729

int result;

8730

VALUE vresult = Qnil;

8731

8732

if ((argc < 1) || (argc > 1)) {

8733

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

8734

}

8735

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8736

if (!SWIG_IsOK(ecode1)) {

8737

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqSize", 1, argv[0] ));

8738

}

8739

arg1 = (int)(val1);

8740

result = (int)zaxisInqSize(arg1);

8741

vresult = SWIG_From_int((int)(result));

8742

return vresult;

8743

fail:

8744

return Qnil;

8745

}

8746

8747

8748

SWIGINTERN VALUE

8749

_wrap_zaxisDuplicate(int argc, VALUE *argv, VALUE self) {

8750

int arg1 ;

8751

int val1 ;

8752

int ecode1 = 0 ;

8753

int result;

8754

VALUE vresult = Qnil;

8755

8756

if ((argc < 1) || (argc > 1)) {

8757

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

8758

}

8759

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8760

if (!SWIG_IsOK(ecode1)) {

8761

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDuplicate", 1, argv[0] ));

8762

}

8763

arg1 = (int)(val1);

8764

result = (int)zaxisDuplicate(arg1);

8765

vresult = SWIG_From_int((int)(result));

8766

return vresult;

8767

fail:

8768

return Qnil;

8769

}

8770

8771

8772

SWIGINTERN VALUE

8773

_wrap_zaxisResize(int argc, VALUE *argv, VALUE self) {

8774

int arg1 ;

8775

int arg2 ;

8776

int val1 ;

8777

int ecode1 = 0 ;

8778

int val2 ;

8779

int ecode2 = 0 ;

8780

8781

if ((argc < 2) || (argc > 2)) {

8782

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8783

}

8784

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8785

if (!SWIG_IsOK(ecode1)) {

8786

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisResize", 1, argv[0] ));

8787

}

8788

arg1 = (int)(val1);

8789

ecode2 = SWIG_AsVal_int(argv[1], &val2);

8790

if (!SWIG_IsOK(ecode2)) {

8791

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisResize", 2, argv[1] ));

8792

}

8793

arg2 = (int)(val2);

8794

zaxisResize(arg1,arg2);

8795

return Qnil;

8796

fail:

8797

return Qnil;

8798

}

8799

8800

8801

SWIGINTERN VALUE

8802

_wrap_zaxisPrint(int argc, VALUE *argv, VALUE self) {

8803

int arg1 ;

8804

int val1 ;

8805

int ecode1 = 0 ;

8806

8807

if ((argc < 1) || (argc > 1)) {

8808

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

8809

}

8810

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8811

if (!SWIG_IsOK(ecode1)) {

8812

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisPrint", 1, argv[0] ));

8813

}

8814

arg1 = (int)(val1);

8815

zaxisPrint(arg1);

8816

return Qnil;

8817

fail:

8818

return Qnil;

8819

}

8820

8821

8822

SWIGINTERN VALUE

8823

_wrap_zaxisSize(int argc, VALUE *argv, VALUE self) {

8824

int result;

8825

VALUE vresult = Qnil;

8826

8827

if ((argc < 0) || (argc > 0)) {

8828

rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;

8829

}

8830

result = (int)zaxisSize();

8831

vresult = SWIG_From_int((int)(result));

8832

return vresult;

8833

fail:

8834

return Qnil;

8835

}

8836

8837

8838

SWIGINTERN VALUE

8839

_wrap_zaxisDefLevels(int argc, VALUE *argv, VALUE self) {

8840

int arg1 ;

8841

double *arg2 = (double *) 0 ;

8842

int val1 ;

8843

int ecode1 = 0 ;

8844

void *argp2 = 0 ;

8845

int res2 = 0 ;

8846

8847

if ((argc < 2) || (argc > 2)) {

8848

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8849

}

8850

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8851

if (!SWIG_IsOK(ecode1)) {

8852

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLevels", 1, argv[0] ));

8853

}

8854

arg1 = (int)(val1);

8855

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8856

if (!SWIG_IsOK(res2)) {

8857

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","zaxisDefLevels", 2, argv[1] ));

8858

}

8859

arg2 = (double *)(argp2);

8860

zaxisDefLevels(arg1,(double const *)arg2);

8861

return Qnil;

8862

fail:

8863

return Qnil;

8864

}

8865

8866

8867

SWIGINTERN VALUE

8868

_wrap_zaxisInqLevels(int argc, VALUE *argv, VALUE self) {

8869

int arg1 ;

8870

double *arg2 = (double *) 0 ;

8871

int val1 ;

8872

int ecode1 = 0 ;

8873

void *argp2 = 0 ;

8874

int res2 = 0 ;

8875

8876

if ((argc < 2) || (argc > 2)) {

8877

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8878

}

8879

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8880

if (!SWIG_IsOK(ecode1)) {

8881

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLevels", 1, argv[0] ));

8882

}

8883

arg1 = (int)(val1);

8884

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

8885

if (!SWIG_IsOK(res2)) {

8886

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","zaxisInqLevels", 2, argv[1] ));

8887

}

8888

arg2 = (double *)(argp2);

8889

zaxisInqLevels(arg1,arg2);

8890

return Qnil;

8891

fail:

8892

return Qnil;

8893

}

8894

8895

8896

SWIGINTERN VALUE

8897

_wrap_zaxisDefLevel(int argc, VALUE *argv, VALUE self) {

8898

int arg1 ;

8899

int arg2 ;

8900

double arg3 ;

8901

int val1 ;

8902

int ecode1 = 0 ;

8903

int val2 ;

8904

int ecode2 = 0 ;

8905

double val3 ;

8906

int ecode3 = 0 ;

8907

8908

if ((argc < 3) || (argc > 3)) {

8909

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

8910

}

8911

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8912

if (!SWIG_IsOK(ecode1)) {

8913

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLevel", 1, argv[0] ));

8914

}

8915

arg1 = (int)(val1);

8916

ecode2 = SWIG_AsVal_int(argv[1], &val2);

8917

if (!SWIG_IsOK(ecode2)) {

8918

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefLevel", 2, argv[1] ));

8919

}

8920

arg2 = (int)(val2);

8921

ecode3 = SWIG_AsVal_double(argv[2], &val3);

8922

if (!SWIG_IsOK(ecode3)) {

8923

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "double","zaxisDefLevel", 3, argv[2] ));

8924

}

8925

arg3 = (double)(val3);

8926

zaxisDefLevel(arg1,arg2,arg3);

8927

return Qnil;

8928

fail:

8929

return Qnil;

8930

}

8931

8932

8933

SWIGINTERN VALUE

8934

_wrap_zaxisInqLevel(int argc, VALUE *argv, VALUE self) {

8935

int arg1 ;

8936

int arg2 ;

8937

int val1 ;

8938

int ecode1 = 0 ;

8939

int val2 ;

8940

int ecode2 = 0 ;

8941

double result;

8942

VALUE vresult = Qnil;

8943

8944

if ((argc < 2) || (argc > 2)) {

8945

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8946

}

8947

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8948

if (!SWIG_IsOK(ecode1)) {

8949

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLevel", 1, argv[0] ));

8950

}

8951

arg1 = (int)(val1);

8952

ecode2 = SWIG_AsVal_int(argv[1], &val2);

8953

if (!SWIG_IsOK(ecode2)) {

8954

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqLevel", 2, argv[1] ));

8955

}

8956

arg2 = (int)(val2);

8957

result = (double)zaxisInqLevel(arg1,arg2);

8958

vresult = SWIG_From_double((double)(result));

8959

return vresult;

8960

fail:

8961

return Qnil;

8962

}

8963

8964

8965

SWIGINTERN VALUE

8966

_wrap_zaxisDefName(int argc, VALUE *argv, VALUE self) {

8967

int arg1 ;

8968

char *arg2 = (char *) 0 ;

8969

int val1 ;

8970

int ecode1 = 0 ;

8971

int res2 ;

8972

char *buf2 = 0 ;

8973

int alloc2 = 0 ;

8974

8975

if ((argc < 2) || (argc > 2)) {

8976

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

8977

}

8978

ecode1 = SWIG_AsVal_int(argv[0], &val1);

8979

if (!SWIG_IsOK(ecode1)) {

8980

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefName", 1, argv[0] ));

8981

}

8982

arg1 = (int)(val1);

8983

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

8984

if (!SWIG_IsOK(res2)) {

8985

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefName", 2, argv[1] ));

8986

}

8987

arg2 = (char *)(buf2);

8988

zaxisDefName(arg1,(char const *)arg2);

8989

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

8990

return Qnil;

8991

fail:

8992

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

8993

return Qnil;

8994

}

8995

8996

8997

SWIGINTERN VALUE

8998

_wrap_zaxisDefLongname(int argc, VALUE *argv, VALUE self) {

8999

int arg1 ;

9000

char *arg2 = (char *) 0 ;

9001

int val1 ;

9002

int ecode1 = 0 ;

9003

int res2 ;

9004

char *buf2 = 0 ;

9005

int alloc2 = 0 ;

9006

9007

if ((argc < 2) || (argc > 2)) {

9008

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9009

}

9010

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9011

if (!SWIG_IsOK(ecode1)) {

9012

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLongname", 1, argv[0] ));

9013

}

9014

arg1 = (int)(val1);

9015

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

9016

if (!SWIG_IsOK(res2)) {

9017

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefLongname", 2, argv[1] ));

9018

}

9019

arg2 = (char *)(buf2);

9020

zaxisDefLongname(arg1,(char const *)arg2);

9021

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9022

return Qnil;

9023

fail:

9024

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9025

return Qnil;

9026

}

9027

9028

9029

SWIGINTERN VALUE

9030

_wrap_zaxisDefUnits(int argc, VALUE *argv, VALUE self) {

9031

int arg1 ;

9032

char *arg2 = (char *) 0 ;

9033

int val1 ;

9034

int ecode1 = 0 ;

9035

int res2 ;

9036

char *buf2 = 0 ;

9037

int alloc2 = 0 ;

9038

9039

if ((argc < 2) || (argc > 2)) {

9040

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9041

}

9042

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9043

if (!SWIG_IsOK(ecode1)) {

9044

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefUnits", 1, argv[0] ));

9045

}

9046

arg1 = (int)(val1);

9047

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

9048

if (!SWIG_IsOK(res2)) {

9049

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","zaxisDefUnits", 2, argv[1] ));

9050

}

9051

arg2 = (char *)(buf2);

9052

zaxisDefUnits(arg1,(char const *)arg2);

9053

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9054

return Qnil;

9055

fail:

9056

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9057

return Qnil;

9058

}

9059

9060

9061

SWIGINTERN VALUE

9062

_wrap_zaxisInqName(int argc, VALUE *argv, VALUE self) {

9063

int arg1 ;

9064

char *arg2 = (char *) 0 ;

9065

int val1 ;

9066

int ecode1 = 0 ;

9067

int res2 ;

9068

char *buf2 = 0 ;

9069

int alloc2 = 0 ;

9070

9071

if ((argc < 2) || (argc > 2)) {

9072

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9073

}

9074

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9075

if (!SWIG_IsOK(ecode1)) {

9076

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqName", 1, argv[0] ));

9077

}

9078

arg1 = (int)(val1);

9079

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

9080

if (!SWIG_IsOK(res2)) {

9081

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqName", 2, argv[1] ));

9082

}

9083

arg2 = (char *)(buf2);

9084

zaxisInqName(arg1,arg2);

9085

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9086

return Qnil;

9087

fail:

9088

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9089

return Qnil;

9090

}

9091

9092

9093

SWIGINTERN VALUE

9094

_wrap_zaxisInqLongname(int argc, VALUE *argv, VALUE self) {

9095

int arg1 ;

9096

char *arg2 = (char *) 0 ;

9097

int val1 ;

9098

int ecode1 = 0 ;

9099

int res2 ;

9100

char *buf2 = 0 ;

9101

int alloc2 = 0 ;

9102

9103

if ((argc < 2) || (argc > 2)) {

9104

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9105

}

9106

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9107

if (!SWIG_IsOK(ecode1)) {

9108

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLongname", 1, argv[0] ));

9109

}

9110

arg1 = (int)(val1);

9111

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

9112

if (!SWIG_IsOK(res2)) {

9113

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqLongname", 2, argv[1] ));

9114

}

9115

arg2 = (char *)(buf2);

9116

zaxisInqLongname(arg1,arg2);

9117

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9118

return Qnil;

9119

fail:

9120

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9121

return Qnil;

9122

}

9123

9124

9125

SWIGINTERN VALUE

9126

_wrap_zaxisInqUnits(int argc, VALUE *argv, VALUE self) {

9127

int arg1 ;

9128

char *arg2 = (char *) 0 ;

9129

int val1 ;

9130

int ecode1 = 0 ;

9131

int res2 ;

9132

char *buf2 = 0 ;

9133

int alloc2 = 0 ;

9134

9135

if ((argc < 2) || (argc > 2)) {

9136

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9137

}

9138

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9139

if (!SWIG_IsOK(ecode1)) {

9140

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUnits", 1, argv[0] ));

9141

}

9142

arg1 = (int)(val1);

9143

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

9144

if (!SWIG_IsOK(res2)) {

9145

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","zaxisInqUnits", 2, argv[1] ));

9146

}

9147

arg2 = (char *)(buf2);

9148

zaxisInqUnits(arg1,arg2);

9149

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9150

return Qnil;

9151

fail:

9152

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

9153

return Qnil;

9154

}

9155

9156

9157

SWIGINTERN VALUE

9158

_wrap_zaxisDefPrec(int argc, VALUE *argv, VALUE self) {

9159

int arg1 ;

9160

int arg2 ;

9161

int val1 ;

9162

int ecode1 = 0 ;

9163

int val2 ;

9164

int ecode2 = 0 ;

9165

9166

if ((argc < 2) || (argc > 2)) {

9167

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9168

}

9169

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9170

if (!SWIG_IsOK(ecode1)) {

9171

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefPrec", 1, argv[0] ));

9172

}

9173

arg1 = (int)(val1);

9174

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9175

if (!SWIG_IsOK(ecode2)) {

9176

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefPrec", 2, argv[1] ));

9177

}

9178

arg2 = (int)(val2);

9179

zaxisDefPrec(arg1,arg2);

9180

return Qnil;

9181

fail:

9182

return Qnil;

9183

}

9184

9185

9186

SWIGINTERN VALUE

9187

_wrap_zaxisInqPrec(int argc, VALUE *argv, VALUE self) {

9188

int arg1 ;

9189

int val1 ;

9190

int ecode1 = 0 ;

9191

int result;

9192

VALUE vresult = Qnil;

9193

9194

if ((argc < 1) || (argc > 1)) {

9195

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9196

}

9197

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9198

if (!SWIG_IsOK(ecode1)) {

9199

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqPrec", 1, argv[0] ));

9200

}

9201

arg1 = (int)(val1);

9202

result = (int)zaxisInqPrec(arg1);

9203

vresult = SWIG_From_int((int)(result));

9204

return vresult;

9205

fail:

9206

return Qnil;

9207

}

9208

9209

9210

SWIGINTERN VALUE

9211

_wrap_zaxisDefLtype(int argc, VALUE *argv, VALUE self) {

9212

int arg1 ;

9213

int arg2 ;

9214

int val1 ;

9215

int ecode1 = 0 ;

9216

int val2 ;

9217

int ecode2 = 0 ;

9218

9219

if ((argc < 2) || (argc > 2)) {

9220

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9221

}

9222

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9223

if (!SWIG_IsOK(ecode1)) {

9224

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLtype", 1, argv[0] ));

9225

}

9226

arg1 = (int)(val1);

9227

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9228

if (!SWIG_IsOK(ecode2)) {

9229

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefLtype", 2, argv[1] ));

9230

}

9231

arg2 = (int)(val2);

9232

zaxisDefLtype(arg1,arg2);

9233

return Qnil;

9234

fail:

9235

return Qnil;

9236

}

9237

9238

9239

SWIGINTERN VALUE

9240

_wrap_zaxisInqLtype(int argc, VALUE *argv, VALUE self) {

9241

int arg1 ;

9242

int val1 ;

9243

int ecode1 = 0 ;

9244

int result;

9245

VALUE vresult = Qnil;

9246

9247

if ((argc < 1) || (argc > 1)) {

9248

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9249

}

9250

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9251

if (!SWIG_IsOK(ecode1)) {

9252

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLtype", 1, argv[0] ));

9253

}

9254

arg1 = (int)(val1);

9255

result = (int)zaxisInqLtype(arg1);

9256

vresult = SWIG_From_int((int)(result));

9257

return vresult;

9258

fail:

9259

return Qnil;

9260

}

9261

9262

9263

SWIGINTERN VALUE

9264

_wrap_zaxisInqLevelsPtr(int argc, VALUE *argv, VALUE self) {

9265

int arg1 ;

9266

int val1 ;

9267

int ecode1 = 0 ;

9268

double *result = 0 ;

9269

VALUE vresult = Qnil;

9270

9271

if ((argc < 1) || (argc > 1)) {

9272

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9273

}

9274

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9275

if (!SWIG_IsOK(ecode1)) {

9276

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLevelsPtr", 1, argv[0] ));

9277

}

9278

arg1 = (int)(val1);

9279

result = (double *)zaxisInqLevelsPtr(arg1);

9280

vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );

9281

return vresult;

9282

fail:

9283

return Qnil;

9284

}

9285

9286

9287

SWIGINTERN VALUE

9288

_wrap_zaxisDefVct(int argc, VALUE *argv, VALUE self) {

9289

int arg1 ;

9290

int arg2 ;

9291

double *arg3 = (double *) 0 ;

9292

int val1 ;

9293

int ecode1 = 0 ;

9294

int val2 ;

9295

int ecode2 = 0 ;

9296

void *argp3 = 0 ;

9297

int res3 = 0 ;

9298

9299

if ((argc < 3) || (argc > 3)) {

9300

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

9301

}

9302

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9303

if (!SWIG_IsOK(ecode1)) {

9304

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefVct", 1, argv[0] ));

9305

}

9306

arg1 = (int)(val1);

9307

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9308

if (!SWIG_IsOK(ecode2)) {

9309

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisDefVct", 2, argv[1] ));

9310

}

9311

arg2 = (int)(val2);

9312

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_double, 0 | 0 );

9313

if (!SWIG_IsOK(res3)) {

9314

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","zaxisDefVct", 3, argv[2] ));

9315

}

9316

arg3 = (double *)(argp3);

9317

zaxisDefVct(arg1,arg2,(double const *)arg3);

9318

return Qnil;

9319

fail:

9320

return Qnil;

9321

}

9322

9323

9324

SWIGINTERN VALUE

9325

_wrap_zaxisInqVctSize(int argc, VALUE *argv, VALUE self) {

9326

int arg1 ;

9327

int val1 ;

9328

int ecode1 = 0 ;

9329

int result;

9330

VALUE vresult = Qnil;

9331

9332

if ((argc < 1) || (argc > 1)) {

9333

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9334

}

9335

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9336

if (!SWIG_IsOK(ecode1)) {

9337

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqVctSize", 1, argv[0] ));

9338

}

9339

arg1 = (int)(val1);

9340

result = (int)zaxisInqVctSize(arg1);

9341

vresult = SWIG_From_int((int)(result));

9342

return vresult;

9343

fail:

9344

return Qnil;

9345

}

9346

9347

9348

SWIGINTERN VALUE

9349

_wrap_zaxisInqVctPtr(int argc, VALUE *argv, VALUE self) {

9350

int arg1 ;

9351

int val1 ;

9352

int ecode1 = 0 ;

9353

double *result = 0 ;

9354

VALUE vresult = Qnil;

9355

9356

if ((argc < 1) || (argc > 1)) {

9357

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9358

}

9359

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9360

if (!SWIG_IsOK(ecode1)) {

9361

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqVctPtr", 1, argv[0] ));

9362

}

9363

arg1 = (int)(val1);

9364

result = (double *)zaxisInqVctPtr(arg1);

9365

vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );

9366

return vresult;

9367

fail:

9368

return Qnil;

9369

}

9370

9371

9372

SWIGINTERN VALUE

9373

_wrap_zaxisInqLbounds(int argc, VALUE *argv, VALUE self) {

9374

int arg1 ;

9375

double *arg2 = (double *) 0 ;

9376

int val1 ;

9377

int ecode1 = 0 ;

9378

void *argp2 = 0 ;

9379

int res2 = 0 ;

9380

int result;

9381

VALUE vresult = Qnil;

9382

9383

if ((argc < 2) || (argc > 2)) {

9384

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9385

}

9386

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9387

if (!SWIG_IsOK(ecode1)) {

9388

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLbounds", 1, argv[0] ));

9389

}

9390

arg1 = (int)(val1);

9391

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

9392

if (!SWIG_IsOK(res2)) {

9393

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","zaxisInqLbounds", 2, argv[1] ));

9394

}

9395

arg2 = (double *)(argp2);

9396

result = (int)zaxisInqLbounds(arg1,arg2);

9397

vresult = SWIG_From_int((int)(result));

9398

return vresult;

9399

fail:

9400

return Qnil;

9401

}

9402

9403

9404

SWIGINTERN VALUE

9405

_wrap_zaxisInqUbounds(int argc, VALUE *argv, VALUE self) {

9406

int arg1 ;

9407

double *arg2 = (double *) 0 ;

9408

int val1 ;

9409

int ecode1 = 0 ;

9410

void *argp2 = 0 ;

9411

int res2 = 0 ;

9412

int result;

9413

VALUE vresult = Qnil;

9414

9415

if ((argc < 2) || (argc > 2)) {

9416

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9417

}

9418

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9419

if (!SWIG_IsOK(ecode1)) {

9420

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUbounds", 1, argv[0] ));

9421

}

9422

arg1 = (int)(val1);

9423

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

9424

if (!SWIG_IsOK(res2)) {

9425

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","zaxisInqUbounds", 2, argv[1] ));

9426

}

9427

arg2 = (double *)(argp2);

9428

result = (int)zaxisInqUbounds(arg1,arg2);

9429

vresult = SWIG_From_int((int)(result));

9430

return vresult;

9431

fail:

9432

return Qnil;

9433

}

9434

9435

9436

SWIGINTERN VALUE

9437

_wrap_zaxisInqWeights(int argc, VALUE *argv, VALUE self) {

9438

int arg1 ;

9439

double *arg2 = (double *) 0 ;

9440

int val1 ;

9441

int ecode1 = 0 ;

9442

void *argp2 = 0 ;

9443

int res2 = 0 ;

9444

int result;

9445

VALUE vresult = Qnil;

9446

9447

if ((argc < 2) || (argc > 2)) {

9448

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9449

}

9450

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9451

if (!SWIG_IsOK(ecode1)) {

9452

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqWeights", 1, argv[0] ));

9453

}

9454

arg1 = (int)(val1);

9455

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

9456

if (!SWIG_IsOK(res2)) {

9457

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","zaxisInqWeights", 2, argv[1] ));

9458

}

9459

arg2 = (double *)(argp2);

9460

result = (int)zaxisInqWeights(arg1,arg2);

9461

vresult = SWIG_From_int((int)(result));

9462

return vresult;

9463

fail:

9464

return Qnil;

9465

}

9466

9467

9468

SWIGINTERN VALUE

9469

_wrap_zaxisInqLbound(int argc, VALUE *argv, VALUE self) {

9470

int arg1 ;

9471

int arg2 ;

9472

int val1 ;

9473

int ecode1 = 0 ;

9474

int val2 ;

9475

int ecode2 = 0 ;

9476

double result;

9477

VALUE vresult = Qnil;

9478

9479

if ((argc < 2) || (argc > 2)) {

9480

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9481

}

9482

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9483

if (!SWIG_IsOK(ecode1)) {

9484

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqLbound", 1, argv[0] ));

9485

}

9486

arg1 = (int)(val1);

9487

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9488

if (!SWIG_IsOK(ecode2)) {

9489

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqLbound", 2, argv[1] ));

9490

}

9491

arg2 = (int)(val2);

9492

result = (double)zaxisInqLbound(arg1,arg2);

9493

vresult = SWIG_From_double((double)(result));

9494

return vresult;

9495

fail:

9496

return Qnil;

9497

}

9498

9499

9500

SWIGINTERN VALUE

9501

_wrap_zaxisInqUbound(int argc, VALUE *argv, VALUE self) {

9502

int arg1 ;

9503

int arg2 ;

9504

int val1 ;

9505

int ecode1 = 0 ;

9506

int val2 ;

9507

int ecode2 = 0 ;

9508

double result;

9509

VALUE vresult = Qnil;

9510

9511

if ((argc < 2) || (argc > 2)) {

9512

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9513

}

9514

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9515

if (!SWIG_IsOK(ecode1)) {

9516

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisInqUbound", 1, argv[0] ));

9517

}

9518

arg1 = (int)(val1);

9519

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9520

if (!SWIG_IsOK(ecode2)) {

9521

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisInqUbound", 2, argv[1] ));

9522

}

9523

arg2 = (int)(val2);

9524

result = (double)zaxisInqUbound(arg1,arg2);

9525

vresult = SWIG_From_double((double)(result));

9526

return vresult;

9527

fail:

9528

return Qnil;

9529

}

9530

9531

9532

SWIGINTERN VALUE

9533

_wrap_zaxisDefLbounds(int argc, VALUE *argv, VALUE self) {

9534

int arg1 ;

9535

double *arg2 = (double *) 0 ;

9536

int val1 ;

9537

int ecode1 = 0 ;

9538

void *argp2 = 0 ;

9539

int res2 = 0 ;

9540

9541

if ((argc < 2) || (argc > 2)) {

9542

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9543

}

9544

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9545

if (!SWIG_IsOK(ecode1)) {

9546

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefLbounds", 1, argv[0] ));

9547

}

9548

arg1 = (int)(val1);

9549

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

9550

if (!SWIG_IsOK(res2)) {

9551

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","zaxisDefLbounds", 2, argv[1] ));

9552

}

9553

arg2 = (double *)(argp2);

9554

zaxisDefLbounds(arg1,(double const *)arg2);

9555

return Qnil;

9556

fail:

9557

return Qnil;

9558

}

9559

9560

9561

SWIGINTERN VALUE

9562

_wrap_zaxisDefUbounds(int argc, VALUE *argv, VALUE self) {

9563

int arg1 ;

9564

double *arg2 = (double *) 0 ;

9565

int val1 ;

9566

int ecode1 = 0 ;

9567

void *argp2 = 0 ;

9568

int res2 = 0 ;

9569

9570

if ((argc < 2) || (argc > 2)) {

9571

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9572

}

9573

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9574

if (!SWIG_IsOK(ecode1)) {

9575

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefUbounds", 1, argv[0] ));

9576

}

9577

arg1 = (int)(val1);

9578

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

9579

if (!SWIG_IsOK(res2)) {

9580

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","zaxisDefUbounds", 2, argv[1] ));

9581

}

9582

arg2 = (double *)(argp2);

9583

zaxisDefUbounds(arg1,(double const *)arg2);

9584

return Qnil;

9585

fail:

9586

return Qnil;

9587

}

9588

9589

9590

SWIGINTERN VALUE

9591

_wrap_zaxisDefWeights(int argc, VALUE *argv, VALUE self) {

9592

int arg1 ;

9593

double *arg2 = (double *) 0 ;

9594

int val1 ;

9595

int ecode1 = 0 ;

9596

void *argp2 = 0 ;

9597

int res2 = 0 ;

9598

9599

if ((argc < 2) || (argc > 2)) {

9600

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9601

}

9602

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9603

if (!SWIG_IsOK(ecode1)) {

9604

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisDefWeights", 1, argv[0] ));

9605

}

9606

arg1 = (int)(val1);

9607

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_double, 0 | 0 );

9608

if (!SWIG_IsOK(res2)) {

9609

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double const *","zaxisDefWeights", 2, argv[1] ));

9610

}

9611

arg2 = (double *)(argp2);

9612

zaxisDefWeights(arg1,(double const *)arg2);

9613

return Qnil;

9614

fail:

9615

return Qnil;

9616

}

9617

9618

9619

SWIGINTERN VALUE

9620

_wrap_zaxisChangeType(int argc, VALUE *argv, VALUE self) {

9621

int arg1 ;

9622

int arg2 ;

9623

int val1 ;

9624

int ecode1 = 0 ;

9625

int val2 ;

9626

int ecode2 = 0 ;

9627

9628

if ((argc < 2) || (argc > 2)) {

9629

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9630

}

9631

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9632

if (!SWIG_IsOK(ecode1)) {

9633

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","zaxisChangeType", 1, argv[0] ));

9634

}

9635

arg1 = (int)(val1);

9636

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9637

if (!SWIG_IsOK(ecode2)) {

9638

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","zaxisChangeType", 2, argv[1] ));

9639

}

9640

arg2 = (int)(val2);

9641

zaxisChangeType(arg1,arg2);

9642

return Qnil;

9643

fail:

9644

return Qnil;

9645

}

9646

9647

9648

SWIGINTERN VALUE

9649

_wrap_taxisCreate(int argc, VALUE *argv, VALUE self) {

9650

int arg1 ;

9651

int val1 ;

9652

int ecode1 = 0 ;

9653

int result;

9654

VALUE vresult = Qnil;

9655

9656

if ((argc < 1) || (argc > 1)) {

9657

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9658

}

9659

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9660

if (!SWIG_IsOK(ecode1)) {

9661

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisCreate", 1, argv[0] ));

9662

}

9663

arg1 = (int)(val1);

9664

result = (int)taxisCreate(arg1);

9665

vresult = SWIG_From_int((int)(result));

9666

return vresult;

9667

fail:

9668

return Qnil;

9669

}

9670

9671

9672

SWIGINTERN VALUE

9673

_wrap_taxisDestroy(int argc, VALUE *argv, VALUE self) {

9674

int arg1 ;

9675

int val1 ;

9676

int ecode1 = 0 ;

9677

9678

if ((argc < 1) || (argc > 1)) {

9679

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9680

}

9681

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9682

if (!SWIG_IsOK(ecode1)) {

9683

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDestroy", 1, argv[0] ));

9684

}

9685

arg1 = (int)(val1);

9686

taxisDestroy(arg1);

9687

return Qnil;

9688

fail:

9689

return Qnil;

9690

}

9691

9692

9693

SWIGINTERN VALUE

9694

_wrap_taxisDuplicate(int argc, VALUE *argv, VALUE self) {

9695

int arg1 ;

9696

int val1 ;

9697

int ecode1 = 0 ;

9698

int result;

9699

VALUE vresult = Qnil;

9700

9701

if ((argc < 1) || (argc > 1)) {

9702

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9703

}

9704

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9705

if (!SWIG_IsOK(ecode1)) {

9706

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDuplicate", 1, argv[0] ));

9707

}

9708

arg1 = (int)(val1);

9709

result = (int)taxisDuplicate(arg1);

9710

vresult = SWIG_From_int((int)(result));

9711

return vresult;

9712

fail:

9713

return Qnil;

9714

}

9715

9716

9717

SWIGINTERN VALUE

9718

_wrap_taxisCopyTimestep(int argc, VALUE *argv, VALUE self) {

9719

int arg1 ;

9720

int arg2 ;

9721

int val1 ;

9722

int ecode1 = 0 ;

9723

int val2 ;

9724

int ecode2 = 0 ;

9725

9726

if ((argc < 2) || (argc > 2)) {

9727

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9728

}

9729

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9730

if (!SWIG_IsOK(ecode1)) {

9731

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisCopyTimestep", 1, argv[0] ));

9732

}

9733

arg1 = (int)(val1);

9734

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9735

if (!SWIG_IsOK(ecode2)) {

9736

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisCopyTimestep", 2, argv[1] ));

9737

}

9738

arg2 = (int)(val2);

9739

taxisCopyTimestep(arg1,arg2);

9740

return Qnil;

9741

fail:

9742

return Qnil;

9743

}

9744

9745

9746

SWIGINTERN VALUE

9747

_wrap_taxisDefType(int argc, VALUE *argv, VALUE self) {

9748

int arg1 ;

9749

int arg2 ;

9750

int val1 ;

9751

int ecode1 = 0 ;

9752

int val2 ;

9753

int ecode2 = 0 ;

9754

9755

if ((argc < 2) || (argc > 2)) {

9756

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9757

}

9758

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9759

if (!SWIG_IsOK(ecode1)) {

9760

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefType", 1, argv[0] ));

9761

}

9762

arg1 = (int)(val1);

9763

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9764

if (!SWIG_IsOK(ecode2)) {

9765

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefType", 2, argv[1] ));

9766

}

9767

arg2 = (int)(val2);

9768

taxisDefType(arg1,arg2);

9769

return Qnil;

9770

fail:

9771

return Qnil;

9772

}

9773

9774

9775

SWIGINTERN VALUE

9776

_wrap_taxisDefVdate(int argc, VALUE *argv, VALUE self) {

9777

int arg1 ;

9778

int arg2 ;

9779

int val1 ;

9780

int ecode1 = 0 ;

9781

int val2 ;

9782

int ecode2 = 0 ;

9783

9784

if ((argc < 2) || (argc > 2)) {

9785

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9786

}

9787

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9788

if (!SWIG_IsOK(ecode1)) {

9789

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVdate", 1, argv[0] ));

9790

}

9791

arg1 = (int)(val1);

9792

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9793

if (!SWIG_IsOK(ecode2)) {

9794

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefVdate", 2, argv[1] ));

9795

}

9796

arg2 = (int)(val2);

9797

taxisDefVdate(arg1,arg2);

9798

return Qnil;

9799

fail:

9800

return Qnil;

9801

}

9802

9803

9804

SWIGINTERN VALUE

9805

_wrap_taxisDefVtime(int argc, VALUE *argv, VALUE self) {

9806

int arg1 ;

9807

int arg2 ;

9808

int val1 ;

9809

int ecode1 = 0 ;

9810

int val2 ;

9811

int ecode2 = 0 ;

9812

9813

if ((argc < 2) || (argc > 2)) {

9814

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9815

}

9816

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9817

if (!SWIG_IsOK(ecode1)) {

9818

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVtime", 1, argv[0] ));

9819

}

9820

arg1 = (int)(val1);

9821

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9822

if (!SWIG_IsOK(ecode2)) {

9823

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefVtime", 2, argv[1] ));

9824

}

9825

arg2 = (int)(val2);

9826

taxisDefVtime(arg1,arg2);

9827

return Qnil;

9828

fail:

9829

return Qnil;

9830

}

9831

9832

9833

SWIGINTERN VALUE

9834

_wrap_taxisDefRdate(int argc, VALUE *argv, VALUE self) {

9835

int arg1 ;

9836

int arg2 ;

9837

int val1 ;

9838

int ecode1 = 0 ;

9839

int val2 ;

9840

int ecode2 = 0 ;

9841

9842

if ((argc < 2) || (argc > 2)) {

9843

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9844

}

9845

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9846

if (!SWIG_IsOK(ecode1)) {

9847

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefRdate", 1, argv[0] ));

9848

}

9849

arg1 = (int)(val1);

9850

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9851

if (!SWIG_IsOK(ecode2)) {

9852

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefRdate", 2, argv[1] ));

9853

}

9854

arg2 = (int)(val2);

9855

taxisDefRdate(arg1,arg2);

9856

return Qnil;

9857

fail:

9858

return Qnil;

9859

}

9860

9861

9862

SWIGINTERN VALUE

9863

_wrap_taxisDefRtime(int argc, VALUE *argv, VALUE self) {

9864

int arg1 ;

9865

int arg2 ;

9866

int val1 ;

9867

int ecode1 = 0 ;

9868

int val2 ;

9869

int ecode2 = 0 ;

9870

9871

if ((argc < 2) || (argc > 2)) {

9872

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

9873

}

9874

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9875

if (!SWIG_IsOK(ecode1)) {

9876

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefRtime", 1, argv[0] ));

9877

}

9878

arg1 = (int)(val1);

9879

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9880

if (!SWIG_IsOK(ecode2)) {

9881

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefRtime", 2, argv[1] ));

9882

}

9883

arg2 = (int)(val2);

9884

taxisDefRtime(arg1,arg2);

9885

return Qnil;

9886

fail:

9887

return Qnil;

9888

}

9889

9890

9891

SWIGINTERN VALUE

9892

_wrap_taxisHasBounds(int argc, VALUE *argv, VALUE self) {

9893

int arg1 ;

9894

int val1 ;

9895

int ecode1 = 0 ;

9896

int result;

9897

VALUE vresult = Qnil;

9898

9899

if ((argc < 1) || (argc > 1)) {

9900

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

9901

}

9902

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9903

if (!SWIG_IsOK(ecode1)) {

9904

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisHasBounds", 1, argv[0] ));

9905

}

9906

arg1 = (int)(val1);

9907

result = (int)taxisHasBounds(arg1);

9908

vresult = SWIG_From_int((int)(result));

9909

return vresult;

9910

fail:

9911

return Qnil;

9912

}

9913

9914

9915

SWIGINTERN VALUE

9916

_wrap_taxisDefVdateBounds(int argc, VALUE *argv, VALUE self) {

9917

int arg1 ;

9918

int arg2 ;

9919

int arg3 ;

9920

int val1 ;

9921

int ecode1 = 0 ;

9922

int val2 ;

9923

int ecode2 = 0 ;

9924

int val3 ;

9925

int ecode3 = 0 ;

9926

9927

if ((argc < 3) || (argc > 3)) {

9928

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

9929

}

9930

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9931

if (!SWIG_IsOK(ecode1)) {

9932

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVdateBounds", 1, argv[0] ));

9933

}

9934

arg1 = (int)(val1);

9935

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9936

if (!SWIG_IsOK(ecode2)) {

9937

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefVdateBounds", 2, argv[1] ));

9938

}

9939

arg2 = (int)(val2);

9940

ecode3 = SWIG_AsVal_int(argv[2], &val3);

9941

if (!SWIG_IsOK(ecode3)) {

9942

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","taxisDefVdateBounds", 3, argv[2] ));

9943

}

9944

arg3 = (int)(val3);

9945

taxisDefVdateBounds(arg1,arg2,arg3);

9946

return Qnil;

9947

fail:

9948

return Qnil;

9949

}

9950

9951

9952

SWIGINTERN VALUE

9953

_wrap_taxisDefVtimeBounds(int argc, VALUE *argv, VALUE self) {

9954

int arg1 ;

9955

int arg2 ;

9956

int arg3 ;

9957

int val1 ;

9958

int ecode1 = 0 ;

9959

int val2 ;

9960

int ecode2 = 0 ;

9961

int val3 ;

9962

int ecode3 = 0 ;

9963

9964

if ((argc < 3) || (argc > 3)) {

9965

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

9966

}

9967

ecode1 = SWIG_AsVal_int(argv[0], &val1);

9968

if (!SWIG_IsOK(ecode1)) {

9969

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefVtimeBounds", 1, argv[0] ));

9970

}

9971

arg1 = (int)(val1);

9972

ecode2 = SWIG_AsVal_int(argv[1], &val2);

9973

if (!SWIG_IsOK(ecode2)) {

9974

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefVtimeBounds", 2, argv[1] ));

9975

}

9976

arg2 = (int)(val2);

9977

ecode3 = SWIG_AsVal_int(argv[2], &val3);

9978

if (!SWIG_IsOK(ecode3)) {

9979

SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","taxisDefVtimeBounds", 3, argv[2] ));

9980

}

9981

arg3 = (int)(val3);

9982

taxisDefVtimeBounds(arg1,arg2,arg3);

9983

return Qnil;

9984

fail:

9985

return Qnil;

9986

}

9987

9988

9989

SWIGINTERN VALUE

9990

_wrap_taxisInqVdateBounds(int argc, VALUE *argv, VALUE self) {

9991

int arg1 ;

9992

int *arg2 = (int *) 0 ;

9993

int *arg3 = (int *) 0 ;

9994

int val1 ;

9995

int ecode1 = 0 ;

9996

void *argp2 = 0 ;

9997

int res2 = 0 ;

9998

void *argp3 = 0 ;

9999

int res3 = 0 ;

10000

10001

if ((argc < 3) || (argc > 3)) {

10002

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

10003

}

10004

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10005

if (!SWIG_IsOK(ecode1)) {

10006

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVdateBounds", 1, argv[0] ));

10007

}

10008

arg1 = (int)(val1);

10009

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );

10010

if (!SWIG_IsOK(res2)) {

10011

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","taxisInqVdateBounds", 2, argv[1] ));

10012

}

10013

arg2 = (int *)(argp2);

10014

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );

10015

if (!SWIG_IsOK(res3)) {

10016

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","taxisInqVdateBounds", 3, argv[2] ));

10017

}

10018

arg3 = (int *)(argp3);

10019

taxisInqVdateBounds(arg1,arg2,arg3);

10020

return Qnil;

10021

fail:

10022

return Qnil;

10023

}

10024

10025

10026

SWIGINTERN VALUE

10027

_wrap_taxisInqVtimeBounds(int argc, VALUE *argv, VALUE self) {

10028

int arg1 ;

10029

int *arg2 = (int *) 0 ;

10030

int *arg3 = (int *) 0 ;

10031

int val1 ;

10032

int ecode1 = 0 ;

10033

void *argp2 = 0 ;

10034

int res2 = 0 ;

10035

void *argp3 = 0 ;

10036

int res3 = 0 ;

10037

10038

if ((argc < 3) || (argc > 3)) {

10039

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

10040

}

10041

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10042

if (!SWIG_IsOK(ecode1)) {

10043

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVtimeBounds", 1, argv[0] ));

10044

}

10045

arg1 = (int)(val1);

10046

res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 | 0 );

10047

if (!SWIG_IsOK(res2)) {

10048

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int *","taxisInqVtimeBounds", 2, argv[1] ));

10049

}

10050

arg2 = (int *)(argp2);

10051

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );

10052

if (!SWIG_IsOK(res3)) {

10053

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","taxisInqVtimeBounds", 3, argv[2] ));

10054

}

10055

arg3 = (int *)(argp3);

10056

taxisInqVtimeBounds(arg1,arg2,arg3);

10057

return Qnil;

10058

fail:

10059

return Qnil;

10060

}

10061

10062

10063

SWIGINTERN VALUE

10064

_wrap_taxisDefCalendar(int argc, VALUE *argv, VALUE self) {

10065

int arg1 ;

10066

int arg2 ;

10067

int val1 ;

10068

int ecode1 = 0 ;

10069

int val2 ;

10070

int ecode2 = 0 ;

10071

10072

if ((argc < 2) || (argc > 2)) {

10073

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

10074

}

10075

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10076

if (!SWIG_IsOK(ecode1)) {

10077

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefCalendar", 1, argv[0] ));

10078

}

10079

arg1 = (int)(val1);

10080

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10081

if (!SWIG_IsOK(ecode2)) {

10082

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefCalendar", 2, argv[1] ));

10083

}

10084

arg2 = (int)(val2);

10085

taxisDefCalendar(arg1,arg2);

10086

return Qnil;

10087

fail:

10088

return Qnil;

10089

}

10090

10091

10092

SWIGINTERN VALUE

10093

_wrap_taxisDefTunit(int argc, VALUE *argv, VALUE self) {

10094

int arg1 ;

10095

int arg2 ;

10096

int val1 ;

10097

int ecode1 = 0 ;

10098

int val2 ;

10099

int ecode2 = 0 ;

10100

10101

if ((argc < 2) || (argc > 2)) {

10102

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

10103

}

10104

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10105

if (!SWIG_IsOK(ecode1)) {

10106

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefTunit", 1, argv[0] ));

10107

}

10108

arg1 = (int)(val1);

10109

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10110

if (!SWIG_IsOK(ecode2)) {

10111

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefTunit", 2, argv[1] ));

10112

}

10113

arg2 = (int)(val2);

10114

taxisDefTunit(arg1,arg2);

10115

return Qnil;

10116

fail:

10117

return Qnil;

10118

}

10119

10120

10121

SWIGINTERN VALUE

10122

_wrap_taxisDefNumavg(int argc, VALUE *argv, VALUE self) {

10123

int arg1 ;

10124

int arg2 ;

10125

int val1 ;

10126

int ecode1 = 0 ;

10127

int val2 ;

10128

int ecode2 = 0 ;

10129

10130

if ((argc < 2) || (argc > 2)) {

10131

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

10132

}

10133

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10134

if (!SWIG_IsOK(ecode1)) {

10135

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisDefNumavg", 1, argv[0] ));

10136

}

10137

arg1 = (int)(val1);

10138

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10139

if (!SWIG_IsOK(ecode2)) {

10140

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","taxisDefNumavg", 2, argv[1] ));

10141

}

10142

arg2 = (int)(val2);

10143

taxisDefNumavg(arg1,arg2);

10144

return Qnil;

10145

fail:

10146

return Qnil;

10147

}

10148

10149

10150

SWIGINTERN VALUE

10151

_wrap_taxisInqType(int argc, VALUE *argv, VALUE self) {

10152

int arg1 ;

10153

int val1 ;

10154

int ecode1 = 0 ;

10155

int result;

10156

VALUE vresult = Qnil;

10157

10158

if ((argc < 1) || (argc > 1)) {

10159

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10160

}

10161

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10162

if (!SWIG_IsOK(ecode1)) {

10163

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqType", 1, argv[0] ));

10164

}

10165

arg1 = (int)(val1);

10166

result = (int)taxisInqType(arg1);

10167

vresult = SWIG_From_int((int)(result));

10168

return vresult;

10169

fail:

10170

return Qnil;

10171

}

10172

10173

10174

SWIGINTERN VALUE

10175

_wrap_taxisInqVdate(int argc, VALUE *argv, VALUE self) {

10176

int arg1 ;

10177

int val1 ;

10178

int ecode1 = 0 ;

10179

int result;

10180

VALUE vresult = Qnil;

10181

10182

if ((argc < 1) || (argc > 1)) {

10183

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10184

}

10185

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10186

if (!SWIG_IsOK(ecode1)) {

10187

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVdate", 1, argv[0] ));

10188

}

10189

arg1 = (int)(val1);

10190

result = (int)taxisInqVdate(arg1);

10191

vresult = SWIG_From_int((int)(result));

10192

return vresult;

10193

fail:

10194

return Qnil;

10195

}

10196

10197

10198

SWIGINTERN VALUE

10199

_wrap_taxisInqVtime(int argc, VALUE *argv, VALUE self) {

10200

int arg1 ;

10201

int val1 ;

10202

int ecode1 = 0 ;

10203

int result;

10204

VALUE vresult = Qnil;

10205

10206

if ((argc < 1) || (argc > 1)) {

10207

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10208

}

10209

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10210

if (!SWIG_IsOK(ecode1)) {

10211

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqVtime", 1, argv[0] ));

10212

}

10213

arg1 = (int)(val1);

10214

result = (int)taxisInqVtime(arg1);

10215

vresult = SWIG_From_int((int)(result));

10216

return vresult;

10217

fail:

10218

return Qnil;

10219

}

10220

10221

10222

SWIGINTERN VALUE

10223

_wrap_taxisInqRdate(int argc, VALUE *argv, VALUE self) {

10224

int arg1 ;

10225

int val1 ;

10226

int ecode1 = 0 ;

10227

int result;

10228

VALUE vresult = Qnil;

10229

10230

if ((argc < 1) || (argc > 1)) {

10231

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10232

}

10233

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10234

if (!SWIG_IsOK(ecode1)) {

10235

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqRdate", 1, argv[0] ));

10236

}

10237

arg1 = (int)(val1);

10238

result = (int)taxisInqRdate(arg1);

10239

vresult = SWIG_From_int((int)(result));

10240

return vresult;

10241

fail:

10242

return Qnil;

10243

}

10244

10245

10246

SWIGINTERN VALUE

10247

_wrap_taxisInqRtime(int argc, VALUE *argv, VALUE self) {

10248

int arg1 ;

10249

int val1 ;

10250

int ecode1 = 0 ;

10251

int result;

10252

VALUE vresult = Qnil;

10253

10254

if ((argc < 1) || (argc > 1)) {

10255

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10256

}

10257

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10258

if (!SWIG_IsOK(ecode1)) {

10259

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqRtime", 1, argv[0] ));

10260

}

10261

arg1 = (int)(val1);

10262

result = (int)taxisInqRtime(arg1);

10263

vresult = SWIG_From_int((int)(result));

10264

return vresult;

10265

fail:

10266

return Qnil;

10267

}

10268

10269

10270

SWIGINTERN VALUE

10271

_wrap_taxisInqCalendar(int argc, VALUE *argv, VALUE self) {

10272

int arg1 ;

10273

int val1 ;

10274

int ecode1 = 0 ;

10275

int result;

10276

VALUE vresult = Qnil;

10277

10278

if ((argc < 1) || (argc > 1)) {

10279

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10280

}

10281

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10282

if (!SWIG_IsOK(ecode1)) {

10283

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqCalendar", 1, argv[0] ));

10284

}

10285

arg1 = (int)(val1);

10286

result = (int)taxisInqCalendar(arg1);

10287

vresult = SWIG_From_int((int)(result));

10288

return vresult;

10289

fail:

10290

return Qnil;

10291

}

10292

10293

10294

SWIGINTERN VALUE

10295

_wrap_taxisInqTunit(int argc, VALUE *argv, VALUE self) {

10296

int arg1 ;

10297

int val1 ;

10298

int ecode1 = 0 ;

10299

int result;

10300

VALUE vresult = Qnil;

10301

10302

if ((argc < 1) || (argc > 1)) {

10303

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10304

}

10305

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10306

if (!SWIG_IsOK(ecode1)) {

10307

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqTunit", 1, argv[0] ));

10308

}

10309

arg1 = (int)(val1);

10310

result = (int)taxisInqTunit(arg1);

10311

vresult = SWIG_From_int((int)(result));

10312

return vresult;

10313

fail:

10314

return Qnil;

10315

}

10316

10317

10318

SWIGINTERN VALUE

10319

_wrap_taxisInqNumavg(int argc, VALUE *argv, VALUE self) {

10320

int arg1 ;

10321

int val1 ;

10322

int ecode1 = 0 ;

10323

int result;

10324

VALUE vresult = Qnil;

10325

10326

if ((argc < 1) || (argc > 1)) {

10327

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10328

}

10329

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10330

if (!SWIG_IsOK(ecode1)) {

10331

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","taxisInqNumavg", 1, argv[0] ));

10332

}

10333

arg1 = (int)(val1);

10334

result = (int)taxisInqNumavg(arg1);

10335

vresult = SWIG_From_int((int)(result));

10336

return vresult;

10337

fail:

10338

return Qnil;

10339

}

10340

10341

10342

SWIGINTERN VALUE

10343

_wrap_tunitNamePtr(int argc, VALUE *argv, VALUE self) {

10344

int arg1 ;

10345

int val1 ;

10346

int ecode1 = 0 ;

10347

char *result = 0 ;

10348

VALUE vresult = Qnil;

10349

10350

if ((argc < 1) || (argc > 1)) {

10351

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10352

}

10353

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10354

if (!SWIG_IsOK(ecode1)) {

10355

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tunitNamePtr", 1, argv[0] ));

10356

}

10357

arg1 = (int)(val1);

10358

result = (char *)tunitNamePtr(arg1);

10359

vresult = SWIG_FromCharPtr((const char *)result);

10360

return vresult;

10361

fail:

10362

return Qnil;

10363

}

10364

10365

10366

SWIGINTERN VALUE

10367

_wrap_institutDef(int argc, VALUE *argv, VALUE self) {

10368

int arg1 ;

10369

int arg2 ;

10370

char *arg3 = (char *) 0 ;

10371

char *arg4 = (char *) 0 ;

10372

int val1 ;

10373

int ecode1 = 0 ;

10374

int val2 ;

10375

int ecode2 = 0 ;

10376

int res3 ;

10377

char *buf3 = 0 ;

10378

int alloc3 = 0 ;

10379

int res4 ;

10380

char *buf4 = 0 ;

10381

int alloc4 = 0 ;

10382

int result;

10383

VALUE vresult = Qnil;

10384

10385

if ((argc < 4) || (argc > 4)) {

10386

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

10387

}

10388

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10389

if (!SWIG_IsOK(ecode1)) {

10390

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","institutDef", 1, argv[0] ));

10391

}

10392

arg1 = (int)(val1);

10393

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10394

if (!SWIG_IsOK(ecode2)) {

10395

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","institutDef", 2, argv[1] ));

10396

}

10397

arg2 = (int)(val2);

10398

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

10399

if (!SWIG_IsOK(res3)) {

10400

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","institutDef", 3, argv[2] ));

10401

}

10402

arg3 = (char *)(buf3);

10403

res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);

10404

if (!SWIG_IsOK(res4)) {

10405

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","institutDef", 4, argv[3] ));

10406

}

10407

arg4 = (char *)(buf4);

10408

result = (int)institutDef(arg1,arg2,(char const *)arg3,(char const *)arg4);

10409

vresult = SWIG_From_int((int)(result));

10410

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10411

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

10412

return vresult;

10413

fail:

10414

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10415

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

10416

return Qnil;

10417

}

10418

10419

10420

SWIGINTERN VALUE

10421

_wrap_institutInq(int argc, VALUE *argv, VALUE self) {

10422

int arg1 ;

10423

int arg2 ;

10424

char *arg3 = (char *) 0 ;

10425

char *arg4 = (char *) 0 ;

10426

int val1 ;

10427

int ecode1 = 0 ;

10428

int val2 ;

10429

int ecode2 = 0 ;

10430

int res3 ;

10431

char *buf3 = 0 ;

10432

int alloc3 = 0 ;

10433

int res4 ;

10434

char *buf4 = 0 ;

10435

int alloc4 = 0 ;

10436

int result;

10437

VALUE vresult = Qnil;

10438

10439

if ((argc < 4) || (argc > 4)) {

10440

rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;

10441

}

10442

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10443

if (!SWIG_IsOK(ecode1)) {

10444

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","institutInq", 1, argv[0] ));

10445

}

10446

arg1 = (int)(val1);

10447

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10448

if (!SWIG_IsOK(ecode2)) {

10449

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","institutInq", 2, argv[1] ));

10450

}

10451

arg2 = (int)(val2);

10452

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

10453

if (!SWIG_IsOK(res3)) {

10454

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","institutInq", 3, argv[2] ));

10455

}

10456

arg3 = (char *)(buf3);

10457

res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);

10458

if (!SWIG_IsOK(res4)) {

10459

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","institutInq", 4, argv[3] ));

10460

}

10461

arg4 = (char *)(buf4);

10462

result = (int)institutInq(arg1,arg2,(char const *)arg3,(char const *)arg4);

10463

vresult = SWIG_From_int((int)(result));

10464

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10465

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

10466

return vresult;

10467

fail:

10468

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10469

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

10470

return Qnil;

10471

}

10472

10473

10474

SWIGINTERN VALUE

10475

_wrap_institutInqNumber(int argc, VALUE *argv, VALUE self) {

10476

int result;

10477

VALUE vresult = Qnil;

10478

10479

if ((argc < 0) || (argc > 0)) {

10480

rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;

10481

}

10482

result = (int)institutInqNumber();

10483

vresult = SWIG_From_int((int)(result));

10484

return vresult;

10485

fail:

10486

return Qnil;

10487

}

10488

10489

10490

SWIGINTERN VALUE

10491

_wrap_institutInqCenter(int argc, VALUE *argv, VALUE self) {

10492

int arg1 ;

10493

int val1 ;

10494

int ecode1 = 0 ;

10495

int result;

10496

VALUE vresult = Qnil;

10497

10498

if ((argc < 1) || (argc > 1)) {

10499

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10500

}

10501

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10502

if (!SWIG_IsOK(ecode1)) {

10503

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","institutInqCenter", 1, argv[0] ));

10504

}

10505

arg1 = (int)(val1);

10506

result = (int)institutInqCenter(arg1);

10507

vresult = SWIG_From_int((int)(result));

10508

return vresult;

10509

fail:

10510

return Qnil;

10511

}

10512

10513

10514

SWIGINTERN VALUE

10515

_wrap_institutInqSubcenter(int argc, VALUE *argv, VALUE self) {

10516

int arg1 ;

10517

int val1 ;

10518

int ecode1 = 0 ;

10519

int result;

10520

VALUE vresult = Qnil;

10521

10522

if ((argc < 1) || (argc > 1)) {

10523

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10524

}

10525

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10526

if (!SWIG_IsOK(ecode1)) {

10527

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","institutInqSubcenter", 1, argv[0] ));

10528

}

10529

arg1 = (int)(val1);

10530

result = (int)institutInqSubcenter(arg1);

10531

vresult = SWIG_From_int((int)(result));

10532

return vresult;

10533

fail:

10534

return Qnil;

10535

}

10536

10537

10538

SWIGINTERN VALUE

10539

_wrap_institutInqNamePtr(int argc, VALUE *argv, VALUE self) {

10540

int arg1 ;

10541

int val1 ;

10542

int ecode1 = 0 ;

10543

char *result = 0 ;

10544

VALUE vresult = Qnil;

10545

10546

if ((argc < 1) || (argc > 1)) {

10547

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10548

}

10549

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10550

if (!SWIG_IsOK(ecode1)) {

10551

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","institutInqNamePtr", 1, argv[0] ));

10552

}

10553

arg1 = (int)(val1);

10554

result = (char *)institutInqNamePtr(arg1);

10555

vresult = SWIG_FromCharPtr((const char *)result);

10556

return vresult;

10557

fail:

10558

return Qnil;

10559

}

10560

10561

10562

SWIGINTERN VALUE

10563

_wrap_institutInqLongnamePtr(int argc, VALUE *argv, VALUE self) {

10564

int arg1 ;

10565

int val1 ;

10566

int ecode1 = 0 ;

10567

char *result = 0 ;

10568

VALUE vresult = Qnil;

10569

10570

if ((argc < 1) || (argc > 1)) {

10571

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10572

}

10573

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10574

if (!SWIG_IsOK(ecode1)) {

10575

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","institutInqLongnamePtr", 1, argv[0] ));

10576

}

10577

arg1 = (int)(val1);

10578

result = (char *)institutInqLongnamePtr(arg1);

10579

vresult = SWIG_FromCharPtr((const char *)result);

10580

return vresult;

10581

fail:

10582

return Qnil;

10583

}

10584

10585

10586

SWIGINTERN VALUE

10587

_wrap_modelDef(int argc, VALUE *argv, VALUE self) {

10588

int arg1 ;

10589

int arg2 ;

10590

char *arg3 = (char *) 0 ;

10591

int val1 ;

10592

int ecode1 = 0 ;

10593

int val2 ;

10594

int ecode2 = 0 ;

10595

int res3 ;

10596

char *buf3 = 0 ;

10597

int alloc3 = 0 ;

10598

int result;

10599

VALUE vresult = Qnil;

10600

10601

if ((argc < 3) || (argc > 3)) {

10602

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

10603

}

10604

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10605

if (!SWIG_IsOK(ecode1)) {

10606

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","modelDef", 1, argv[0] ));

10607

}

10608

arg1 = (int)(val1);

10609

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10610

if (!SWIG_IsOK(ecode2)) {

10611

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","modelDef", 2, argv[1] ));

10612

}

10613

arg2 = (int)(val2);

10614

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

10615

if (!SWIG_IsOK(res3)) {

10616

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","modelDef", 3, argv[2] ));

10617

}

10618

arg3 = (char *)(buf3);

10619

result = (int)modelDef(arg1,arg2,(char const *)arg3);

10620

vresult = SWIG_From_int((int)(result));

10621

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10622

return vresult;

10623

fail:

10624

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10625

return Qnil;

10626

}

10627

10628

10629

SWIGINTERN VALUE

10630

_wrap_modelInq(int argc, VALUE *argv, VALUE self) {

10631

int arg1 ;

10632

int arg2 ;

10633

char *arg3 = (char *) 0 ;

10634

int val1 ;

10635

int ecode1 = 0 ;

10636

int val2 ;

10637

int ecode2 = 0 ;

10638

int res3 ;

10639

char *buf3 = 0 ;

10640

int alloc3 = 0 ;

10641

int result;

10642

VALUE vresult = Qnil;

10643

10644

if ((argc < 3) || (argc > 3)) {

10645

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

10646

}

10647

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10648

if (!SWIG_IsOK(ecode1)) {

10649

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","modelInq", 1, argv[0] ));

10650

}

10651

arg1 = (int)(val1);

10652

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10653

if (!SWIG_IsOK(ecode2)) {

10654

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","modelInq", 2, argv[1] ));

10655

}

10656

arg2 = (int)(val2);

10657

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

10658

if (!SWIG_IsOK(res3)) {

10659

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","modelInq", 3, argv[2] ));

10660

}

10661

arg3 = (char *)(buf3);

10662

result = (int)modelInq(arg1,arg2,arg3);

10663

vresult = SWIG_From_int((int)(result));

10664

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10665

return vresult;

10666

fail:

10667

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10668

return Qnil;

10669

}

10670

10671

10672

SWIGINTERN VALUE

10673

_wrap_modelInqInstitut(int argc, VALUE *argv, VALUE self) {

10674

int arg1 ;

10675

int val1 ;

10676

int ecode1 = 0 ;

10677

int result;

10678

VALUE vresult = Qnil;

10679

10680

if ((argc < 1) || (argc > 1)) {

10681

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10682

}

10683

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10684

if (!SWIG_IsOK(ecode1)) {

10685

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","modelInqInstitut", 1, argv[0] ));

10686

}

10687

arg1 = (int)(val1);

10688

result = (int)modelInqInstitut(arg1);

10689

vresult = SWIG_From_int((int)(result));

10690

return vresult;

10691

fail:

10692

return Qnil;

10693

}

10694

10695

10696

SWIGINTERN VALUE

10697

_wrap_modelInqGribID(int argc, VALUE *argv, VALUE self) {

10698

int arg1 ;

10699

int val1 ;

10700

int ecode1 = 0 ;

10701

int result;

10702

VALUE vresult = Qnil;

10703

10704

if ((argc < 1) || (argc > 1)) {

10705

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10706

}

10707

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10708

if (!SWIG_IsOK(ecode1)) {

10709

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","modelInqGribID", 1, argv[0] ));

10710

}

10711

arg1 = (int)(val1);

10712

result = (int)modelInqGribID(arg1);

10713

vresult = SWIG_From_int((int)(result));

10714

return vresult;

10715

fail:

10716

return Qnil;

10717

}

10718

10719

10720

SWIGINTERN VALUE

10721

_wrap_modelInqNamePtr(int argc, VALUE *argv, VALUE self) {

10722

int arg1 ;

10723

int val1 ;

10724

int ecode1 = 0 ;

10725

char *result = 0 ;

10726

VALUE vresult = Qnil;

10727

10728

if ((argc < 1) || (argc > 1)) {

10729

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10730

}

10731

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10732

if (!SWIG_IsOK(ecode1)) {

10733

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","modelInqNamePtr", 1, argv[0] ));

10734

}

10735

arg1 = (int)(val1);

10736

result = (char *)modelInqNamePtr(arg1);

10737

vresult = SWIG_FromCharPtr((const char *)result);

10738

return vresult;

10739

fail:

10740

return Qnil;

10741

}

10742

10743

10744

SWIGINTERN VALUE

10745

_wrap_tableWriteC(int argc, VALUE *argv, VALUE self) {

10746

char *arg1 = (char *) 0 ;

10747

int arg2 ;

10748

int res1 ;

10749

char *buf1 = 0 ;

10750

int alloc1 = 0 ;

10751

int val2 ;

10752

int ecode2 = 0 ;

10753

10754

if ((argc < 2) || (argc > 2)) {

10755

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

10756

}

10757

res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);

10758

if (!SWIG_IsOK(res1)) {

10759

SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","tableWriteC", 1, argv[0] ));

10760

}

10761

arg1 = (char *)(buf1);

10762

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10763

if (!SWIG_IsOK(ecode2)) {

10764

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableWriteC", 2, argv[1] ));

10765

}

10766

arg2 = (int)(val2);

10767

tableWriteC((char const *)arg1,arg2);

10768

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

10769

return Qnil;

10770

fail:

10771

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

10772

return Qnil;

10773

}

10774

10775

10776

SWIGINTERN VALUE

10777

_wrap_tableWrite(int argc, VALUE *argv, VALUE self) {

10778

char *arg1 = (char *) 0 ;

10779

int arg2 ;

10780

int res1 ;

10781

char *buf1 = 0 ;

10782

int alloc1 = 0 ;

10783

int val2 ;

10784

int ecode2 = 0 ;

10785

10786

if ((argc < 2) || (argc > 2)) {

10787

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

10788

}

10789

res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);

10790

if (!SWIG_IsOK(res1)) {

10791

SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","tableWrite", 1, argv[0] ));

10792

}

10793

arg1 = (char *)(buf1);

10794

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10795

if (!SWIG_IsOK(ecode2)) {

10796

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableWrite", 2, argv[1] ));

10797

}

10798

arg2 = (int)(val2);

10799

tableWrite((char const *)arg1,arg2);

10800

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

10801

return Qnil;

10802

fail:

10803

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

10804

return Qnil;

10805

}

10806

10807

10808

SWIGINTERN VALUE

10809

_wrap_tableRead(int argc, VALUE *argv, VALUE self) {

10810

char *arg1 = (char *) 0 ;

10811

int res1 ;

10812

char *buf1 = 0 ;

10813

int alloc1 = 0 ;

10814

int result;

10815

VALUE vresult = Qnil;

10816

10817

if ((argc < 1) || (argc > 1)) {

10818

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10819

}

10820

res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);

10821

if (!SWIG_IsOK(res1)) {

10822

SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","tableRead", 1, argv[0] ));

10823

}

10824

arg1 = (char *)(buf1);

10825

result = (int)tableRead((char const *)arg1);

10826

vresult = SWIG_From_int((int)(result));

10827

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

10828

return vresult;

10829

fail:

10830

if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);

10831

return Qnil;

10832

}

10833

10834

10835

SWIGINTERN VALUE

10836

_wrap_tableDef(int argc, VALUE *argv, VALUE self) {

10837

int arg1 ;

10838

int arg2 ;

10839

char *arg3 = (char *) 0 ;

10840

int val1 ;

10841

int ecode1 = 0 ;

10842

int val2 ;

10843

int ecode2 = 0 ;

10844

int res3 ;

10845

char *buf3 = 0 ;

10846

int alloc3 = 0 ;

10847

int result;

10848

VALUE vresult = Qnil;

10849

10850

if ((argc < 3) || (argc > 3)) {

10851

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

10852

}

10853

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10854

if (!SWIG_IsOK(ecode1)) {

10855

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableDef", 1, argv[0] ));

10856

}

10857

arg1 = (int)(val1);

10858

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10859

if (!SWIG_IsOK(ecode2)) {

10860

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableDef", 2, argv[1] ));

10861

}

10862

arg2 = (int)(val2);

10863

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

10864

if (!SWIG_IsOK(res3)) {

10865

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","tableDef", 3, argv[2] ));

10866

}

10867

arg3 = (char *)(buf3);

10868

result = (int)tableDef(arg1,arg2,(char const *)arg3);

10869

vresult = SWIG_From_int((int)(result));

10870

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10871

return vresult;

10872

fail:

10873

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10874

return Qnil;

10875

}

10876

10877

10878

SWIGINTERN VALUE

10879

_wrap_tableInqNamePtr(int argc, VALUE *argv, VALUE self) {

10880

int arg1 ;

10881

int val1 ;

10882

int ecode1 = 0 ;

10883

char *result = 0 ;

10884

VALUE vresult = Qnil;

10885

10886

if ((argc < 1) || (argc > 1)) {

10887

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

10888

}

10889

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10890

if (!SWIG_IsOK(ecode1)) {

10891

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqNamePtr", 1, argv[0] ));

10892

}

10893

arg1 = (int)(val1);

10894

result = (char *)tableInqNamePtr(arg1);

10895

vresult = SWIG_FromCharPtr((const char *)result);

10896

return vresult;

10897

fail:

10898

return Qnil;

10899

}

10900

10901

10902

SWIGINTERN VALUE

10903

_wrap_tableDefEntry(int argc, VALUE *argv, VALUE self) {

10904

int arg1 ;

10905

int arg2 ;

10906

char *arg3 = (char *) 0 ;

10907

char *arg4 = (char *) 0 ;

10908

char *arg5 = (char *) 0 ;

10909

int val1 ;

10910

int ecode1 = 0 ;

10911

int val2 ;

10912

int ecode2 = 0 ;

10913

int res3 ;

10914

char *buf3 = 0 ;

10915

int alloc3 = 0 ;

10916

int res4 ;

10917

char *buf4 = 0 ;

10918

int alloc4 = 0 ;

10919

int res5 ;

10920

char *buf5 = 0 ;

10921

int alloc5 = 0 ;

10922

10923

if ((argc < 5) || (argc > 5)) {

10924

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

10925

}

10926

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10927

if (!SWIG_IsOK(ecode1)) {

10928

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableDefEntry", 1, argv[0] ));

10929

}

10930

arg1 = (int)(val1);

10931

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10932

if (!SWIG_IsOK(ecode2)) {

10933

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableDefEntry", 2, argv[1] ));

10934

}

10935

arg2 = (int)(val2);

10936

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

10937

if (!SWIG_IsOK(res3)) {

10938

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","tableDefEntry", 3, argv[2] ));

10939

}

10940

arg3 = (char *)(buf3);

10941

res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);

10942

if (!SWIG_IsOK(res4)) {

10943

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","tableDefEntry", 4, argv[3] ));

10944

}

10945

arg4 = (char *)(buf4);

10946

res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);

10947

if (!SWIG_IsOK(res5)) {

10948

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","tableDefEntry", 5, argv[4] ));

10949

}

10950

arg5 = (char *)(buf5);

10951

tableDefEntry(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5);

10952

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10953

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

10954

if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);

10955

return Qnil;

10956

fail:

10957

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

10958

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

10959

if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);

10960

return Qnil;

10961

}

10962

10963

10964

SWIGINTERN VALUE

10965

_wrap_tableInq(int argc, VALUE *argv, VALUE self) {

10966

int arg1 ;

10967

int arg2 ;

10968

char *arg3 = (char *) 0 ;

10969

int val1 ;

10970

int ecode1 = 0 ;

10971

int val2 ;

10972

int ecode2 = 0 ;

10973

int res3 ;

10974

char *buf3 = 0 ;

10975

int alloc3 = 0 ;

10976

int result;

10977

VALUE vresult = Qnil;

10978

10979

if ((argc < 3) || (argc > 3)) {

10980

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

10981

}

10982

ecode1 = SWIG_AsVal_int(argv[0], &val1);

10983

if (!SWIG_IsOK(ecode1)) {

10984

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInq", 1, argv[0] ));

10985

}

10986

arg1 = (int)(val1);

10987

ecode2 = SWIG_AsVal_int(argv[1], &val2);

10988

if (!SWIG_IsOK(ecode2)) {

10989

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInq", 2, argv[1] ));

10990

}

10991

arg2 = (int)(val2);

10992

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

10993

if (!SWIG_IsOK(res3)) {

10994

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","tableInq", 3, argv[2] ));

10995

}

10996

arg3 = (char *)(buf3);

10997

result = (int)tableInq(arg1,arg2,(char const *)arg3);

10998

vresult = SWIG_From_int((int)(result));

10999

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11000

return vresult;

11001

fail:

11002

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11003

return Qnil;

11004

}

11005

11006

11007

SWIGINTERN VALUE

11008

_wrap_tableInqNumber(int argc, VALUE *argv, VALUE self) {

11009

int result;

11010

VALUE vresult = Qnil;

11011

11012

if ((argc < 0) || (argc > 0)) {

11013

rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;

11014

}

11015

result = (int)tableInqNumber();

11016

vresult = SWIG_From_int((int)(result));

11017

return vresult;

11018

fail:

11019

return Qnil;

11020

}

11021

11022

11023

SWIGINTERN VALUE

11024

_wrap_tableInqNum(int argc, VALUE *argv, VALUE self) {

11025

int arg1 ;

11026

int val1 ;

11027

int ecode1 = 0 ;

11028

int result;

11029

VALUE vresult = Qnil;

11030

11031

if ((argc < 1) || (argc > 1)) {

11032

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

11033

}

11034

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11035

if (!SWIG_IsOK(ecode1)) {

11036

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqNum", 1, argv[0] ));

11037

}

11038

arg1 = (int)(val1);

11039

result = (int)tableInqNum(arg1);

11040

vresult = SWIG_From_int((int)(result));

11041

return vresult;

11042

fail:

11043

return Qnil;

11044

}

11045

11046

11047

SWIGINTERN VALUE

11048

_wrap_tableInqModel(int argc, VALUE *argv, VALUE self) {

11049

int arg1 ;

11050

int val1 ;

11051

int ecode1 = 0 ;

11052

int result;

11053

VALUE vresult = Qnil;

11054

11055

if ((argc < 1) || (argc > 1)) {

11056

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

11057

}

11058

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11059

if (!SWIG_IsOK(ecode1)) {

11060

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqModel", 1, argv[0] ));

11061

}

11062

arg1 = (int)(val1);

11063

result = (int)tableInqModel(arg1);

11064

vresult = SWIG_From_int((int)(result));

11065

return vresult;

11066

fail:

11067

return Qnil;

11068

}

11069

11070

11071

SWIGINTERN VALUE

11072

_wrap_tableInqPar(int argc, VALUE *argv, VALUE self) {

11073

int arg1 ;

11074

int arg2 ;

11075

char *arg3 = (char *) 0 ;

11076

char *arg4 = (char *) 0 ;

11077

char *arg5 = (char *) 0 ;

11078

int val1 ;

11079

int ecode1 = 0 ;

11080

int val2 ;

11081

int ecode2 = 0 ;

11082

int res3 ;

11083

char *buf3 = 0 ;

11084

int alloc3 = 0 ;

11085

int res4 ;

11086

char *buf4 = 0 ;

11087

int alloc4 = 0 ;

11088

int res5 ;

11089

char *buf5 = 0 ;

11090

int alloc5 = 0 ;

11091

11092

if ((argc < 5) || (argc > 5)) {

11093

rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;

11094

}

11095

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11096

if (!SWIG_IsOK(ecode1)) {

11097

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqPar", 1, argv[0] ));

11098

}

11099

arg1 = (int)(val1);

11100

ecode2 = SWIG_AsVal_int(argv[1], &val2);

11101

if (!SWIG_IsOK(ecode2)) {

11102

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqPar", 2, argv[1] ));

11103

}

11104

arg2 = (int)(val2);

11105

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

11106

if (!SWIG_IsOK(res3)) {

11107

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","tableInqPar", 3, argv[2] ));

11108

}

11109

arg3 = (char *)(buf3);

11110

res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);

11111

if (!SWIG_IsOK(res4)) {

11112

SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","tableInqPar", 4, argv[3] ));

11113

}

11114

arg4 = (char *)(buf4);

11115

res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);

11116

if (!SWIG_IsOK(res5)) {

11117

SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char *","tableInqPar", 5, argv[4] ));

11118

}

11119

arg5 = (char *)(buf5);

11120

tableInqPar(arg1,arg2,arg3,arg4,arg5);

11121

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11122

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

11123

if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);

11124

return Qnil;

11125

fail:

11126

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11127

if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);

11128

if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);

11129

return Qnil;

11130

}

11131

11132

11133

SWIGINTERN VALUE

11134

_wrap_tableInqParCode(int argc, VALUE *argv, VALUE self) {

11135

int arg1 ;

11136

char *arg2 = (char *) 0 ;

11137

int *arg3 = (int *) 0 ;

11138

int val1 ;

11139

int ecode1 = 0 ;

11140

int res2 ;

11141

char *buf2 = 0 ;

11142

int alloc2 = 0 ;

11143

void *argp3 = 0 ;

11144

int res3 = 0 ;

11145

int result;

11146

VALUE vresult = Qnil;

11147

11148

if ((argc < 3) || (argc > 3)) {

11149

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

11150

}

11151

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11152

if (!SWIG_IsOK(ecode1)) {

11153

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParCode", 1, argv[0] ));

11154

}

11155

arg1 = (int)(val1);

11156

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

11157

if (!SWIG_IsOK(res2)) {

11158

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","tableInqParCode", 2, argv[1] ));

11159

}

11160

arg2 = (char *)(buf2);

11161

res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_int, 0 | 0 );

11162

if (!SWIG_IsOK(res3)) {

11163

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int *","tableInqParCode", 3, argv[2] ));

11164

}

11165

arg3 = (int *)(argp3);

11166

result = (int)tableInqParCode(arg1,arg2,arg3);

11167

vresult = SWIG_From_int((int)(result));

11168

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

11169

return vresult;

11170

fail:

11171

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

11172

return Qnil;

11173

}

11174

11175

11176

SWIGINTERN VALUE

11177

_wrap_tableInqParName(int argc, VALUE *argv, VALUE self) {

11178

int arg1 ;

11179

int arg2 ;

11180

char *arg3 = (char *) 0 ;

11181

int val1 ;

11182

int ecode1 = 0 ;

11183

int val2 ;

11184

int ecode2 = 0 ;

11185

int res3 ;

11186

char *buf3 = 0 ;

11187

int alloc3 = 0 ;

11188

int result;

11189

VALUE vresult = Qnil;

11190

11191

if ((argc < 3) || (argc > 3)) {

11192

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

11193

}

11194

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11195

if (!SWIG_IsOK(ecode1)) {

11196

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParName", 1, argv[0] ));

11197

}

11198

arg1 = (int)(val1);

11199

ecode2 = SWIG_AsVal_int(argv[1], &val2);

11200

if (!SWIG_IsOK(ecode2)) {

11201

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParName", 2, argv[1] ));

11202

}

11203

arg2 = (int)(val2);

11204

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

11205

if (!SWIG_IsOK(res3)) {

11206

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","tableInqParName", 3, argv[2] ));

11207

}

11208

arg3 = (char *)(buf3);

11209

result = (int)tableInqParName(arg1,arg2,arg3);

11210

vresult = SWIG_From_int((int)(result));

11211

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11212

return vresult;

11213

fail:

11214

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11215

return Qnil;

11216

}

11217

11218

11219

SWIGINTERN VALUE

11220

_wrap_tableInqParLongname(int argc, VALUE *argv, VALUE self) {

11221

int arg1 ;

11222

int arg2 ;

11223

char *arg3 = (char *) 0 ;

11224

int val1 ;

11225

int ecode1 = 0 ;

11226

int val2 ;

11227

int ecode2 = 0 ;

11228

int res3 ;

11229

char *buf3 = 0 ;

11230

int alloc3 = 0 ;

11231

int result;

11232

VALUE vresult = Qnil;

11233

11234

if ((argc < 3) || (argc > 3)) {

11235

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

11236

}

11237

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11238

if (!SWIG_IsOK(ecode1)) {

11239

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParLongname", 1, argv[0] ));

11240

}

11241

arg1 = (int)(val1);

11242

ecode2 = SWIG_AsVal_int(argv[1], &val2);

11243

if (!SWIG_IsOK(ecode2)) {

11244

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParLongname", 2, argv[1] ));

11245

}

11246

arg2 = (int)(val2);

11247

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

11248

if (!SWIG_IsOK(res3)) {

11249

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","tableInqParLongname", 3, argv[2] ));

11250

}

11251

arg3 = (char *)(buf3);

11252

result = (int)tableInqParLongname(arg1,arg2,arg3);

11253

vresult = SWIG_From_int((int)(result));

11254

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11255

return vresult;

11256

fail:

11257

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11258

return Qnil;

11259

}

11260

11261

11262

SWIGINTERN VALUE

11263

_wrap_tableInqParUnits(int argc, VALUE *argv, VALUE self) {

11264

int arg1 ;

11265

int arg2 ;

11266

char *arg3 = (char *) 0 ;

11267

int val1 ;

11268

int ecode1 = 0 ;

11269

int val2 ;

11270

int ecode2 = 0 ;

11271

int res3 ;

11272

char *buf3 = 0 ;

11273

int alloc3 = 0 ;

11274

int result;

11275

VALUE vresult = Qnil;

11276

11277

if ((argc < 3) || (argc > 3)) {

11278

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

11279

}

11280

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11281

if (!SWIG_IsOK(ecode1)) {

11282

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParUnits", 1, argv[0] ));

11283

}

11284

arg1 = (int)(val1);

11285

ecode2 = SWIG_AsVal_int(argv[1], &val2);

11286

if (!SWIG_IsOK(ecode2)) {

11287

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParUnits", 2, argv[1] ));

11288

}

11289

arg2 = (int)(val2);

11290

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

11291

if (!SWIG_IsOK(res3)) {

11292

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char *","tableInqParUnits", 3, argv[2] ));

11293

}

11294

arg3 = (char *)(buf3);

11295

result = (int)tableInqParUnits(arg1,arg2,arg3);

11296

vresult = SWIG_From_int((int)(result));

11297

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11298

return vresult;

11299

fail:

11300

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11301

return Qnil;

11302

}

11303

11304

11305

SWIGINTERN VALUE

11306

_wrap_tableInqParNamePtr(int argc, VALUE *argv, VALUE self) {

11307

int arg1 ;

11308

int arg2 ;

11309

int val1 ;

11310

int ecode1 = 0 ;

11311

int val2 ;

11312

int ecode2 = 0 ;

11313

char *result = 0 ;

11314

VALUE vresult = Qnil;

11315

11316

if ((argc < 2) || (argc > 2)) {

11317

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

11318

}

11319

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11320

if (!SWIG_IsOK(ecode1)) {

11321

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParNamePtr", 1, argv[0] ));

11322

}

11323

arg1 = (int)(val1);

11324

ecode2 = SWIG_AsVal_int(argv[1], &val2);

11325

if (!SWIG_IsOK(ecode2)) {

11326

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParNamePtr", 2, argv[1] ));

11327

}

11328

arg2 = (int)(val2);

11329

result = (char *)tableInqParNamePtr(arg1,arg2);

11330

vresult = SWIG_FromCharPtr((const char *)result);

11331

return vresult;

11332

fail:

11333

return Qnil;

11334

}

11335

11336

11337

SWIGINTERN VALUE

11338

_wrap_tableInqParLongnamePtr(int argc, VALUE *argv, VALUE self) {

11339

int arg1 ;

11340

int arg2 ;

11341

int val1 ;

11342

int ecode1 = 0 ;

11343

int val2 ;

11344

int ecode2 = 0 ;

11345

char *result = 0 ;

11346

VALUE vresult = Qnil;

11347

11348

if ((argc < 2) || (argc > 2)) {

11349

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

11350

}

11351

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11352

if (!SWIG_IsOK(ecode1)) {

11353

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParLongnamePtr", 1, argv[0] ));

11354

}

11355

arg1 = (int)(val1);

11356

ecode2 = SWIG_AsVal_int(argv[1], &val2);

11357

if (!SWIG_IsOK(ecode2)) {

11358

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParLongnamePtr", 2, argv[1] ));

11359

}

11360

arg2 = (int)(val2);

11361

result = (char *)tableInqParLongnamePtr(arg1,arg2);

11362

vresult = SWIG_FromCharPtr((const char *)result);

11363

return vresult;

11364

fail:

11365

return Qnil;

11366

}

11367

11368

11369

SWIGINTERN VALUE

11370

_wrap_tableInqParUnitsPtr(int argc, VALUE *argv, VALUE self) {

11371

int arg1 ;

11372

int arg2 ;

11373

int val1 ;

11374

int ecode1 = 0 ;

11375

int val2 ;

11376

int ecode2 = 0 ;

11377

char *result = 0 ;

11378

VALUE vresult = Qnil;

11379

11380

if ((argc < 2) || (argc > 2)) {

11381

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

11382

}

11383

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11384

if (!SWIG_IsOK(ecode1)) {

11385

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","tableInqParUnitsPtr", 1, argv[0] ));

11386

}

11387

arg1 = (int)(val1);

11388

ecode2 = SWIG_AsVal_int(argv[1], &val2);

11389

if (!SWIG_IsOK(ecode2)) {

11390

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","tableInqParUnitsPtr", 2, argv[1] ));

11391

}

11392

arg2 = (int)(val2);

11393

result = (char *)tableInqParUnitsPtr(arg1,arg2);

11394

vresult = SWIG_FromCharPtr((const char *)result);

11395

return vresult;

11396

fail:

11397

return Qnil;

11398

}

11399

11400

11401

SWIGINTERN VALUE

11402

_wrap_streamDefHistory(int argc, VALUE *argv, VALUE self) {

11403

int arg1 ;

11404

int arg2 ;

11405

char *arg3 = (char *) 0 ;

11406

int val1 ;

11407

int ecode1 = 0 ;

11408

int val2 ;

11409

int ecode2 = 0 ;

11410

int res3 ;

11411

char *buf3 = 0 ;

11412

int alloc3 = 0 ;

11413

11414

if ((argc < 3) || (argc > 3)) {

11415

rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;

11416

}

11417

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11418

if (!SWIG_IsOK(ecode1)) {

11419

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamDefHistory", 1, argv[0] ));

11420

}

11421

arg1 = (int)(val1);

11422

ecode2 = SWIG_AsVal_int(argv[1], &val2);

11423

if (!SWIG_IsOK(ecode2)) {

11424

SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","streamDefHistory", 2, argv[1] ));

11425

}

11426

arg2 = (int)(val2);

11427

res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);

11428

if (!SWIG_IsOK(res3)) {

11429

SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","streamDefHistory", 3, argv[2] ));

11430

}

11431

arg3 = (char *)(buf3);

11432

streamDefHistory(arg1,arg2,(char const *)arg3);

11433

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11434

return Qnil;

11435

fail:

11436

if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);

11437

return Qnil;

11438

}

11439

11440

11441

SWIGINTERN VALUE

11442

_wrap_streamInqHistorySize(int argc, VALUE *argv, VALUE self) {

11443

int arg1 ;

11444

int val1 ;

11445

int ecode1 = 0 ;

11446

int result;

11447

VALUE vresult = Qnil;

11448

11449

if ((argc < 1) || (argc > 1)) {

11450

rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;

11451

}

11452

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11453

if (!SWIG_IsOK(ecode1)) {

11454

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqHistorySize", 1, argv[0] ));

11455

}

11456

arg1 = (int)(val1);

11457

result = (int)streamInqHistorySize(arg1);

11458

vresult = SWIG_From_int((int)(result));

11459

return vresult;

11460

fail:

11461

return Qnil;

11462

}

11463

11464

11465

SWIGINTERN VALUE

11466

_wrap_streamInqHistoryString(int argc, VALUE *argv, VALUE self) {

11467

int arg1 ;

11468

char *arg2 = (char *) 0 ;

11469

int val1 ;

11470

int ecode1 = 0 ;

11471

int res2 ;

11472

char *buf2 = 0 ;

11473

int alloc2 = 0 ;

11474

11475

if ((argc < 2) || (argc > 2)) {

11476

rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;

11477

}

11478

ecode1 = SWIG_AsVal_int(argv[0], &val1);

11479

if (!SWIG_IsOK(ecode1)) {

11480

SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","streamInqHistoryString", 1, argv[0] ));

11481

}

11482

arg1 = (int)(val1);

11483

res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);

11484

if (!SWIG_IsOK(res2)) {

11485

SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","streamInqHistoryString", 2, argv[1] ));

11486

}

11487

arg2 = (char *)(buf2);

11488

streamInqHistoryString(arg1,arg2);

11489

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

11490

return Qnil;

11491

fail:

11492

if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);

11493

return Qnil;

11494

}

11495

11496

11497

11498

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

11499

11500

static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};

11501

static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};

11502

static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0};

11503

static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};

11504

static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *", 0, 0, (void*)0, 0};

11505

11506

static swig_type_info *swig_type_initial[] = {

11507

&_swigt__p_char,

11508

&_swigt__p_double,

11509

&_swigt__p_float,

11510

&_swigt__p_int,

11511

&_swigt__p_off_t,

11512

};

11513

11514

static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};

11515

static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};

11516

static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};

11517

static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};

11518

static swig_cast_info _swigc__p_off_t[] = { {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};

11519

11520

static swig_cast_info *swig_cast_initial[] = {

11521

_swigc__p_char,

11522

_swigc__p_double,

11523

_swigc__p_float,

11524

_swigc__p_int,

11525

_swigc__p_off_t,

11526

};

11527

11528

11529

/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

11530

11531

/* -----------------------------------------------------------------------------

11532

* Type initialization:

11533

* This problem is tough by the requirement that no dynamic

11534

* memory is used. Also, since swig_type_info structures store pointers to

11535

* swig_cast_info structures and swig_cast_info structures store pointers back

11536

* to swig_type_info structures, we need some lookup code at initialization.

11537

* The idea is that swig generates all the structures that are needed.

11538

* The runtime then collects these partially filled structures.

11539

* The SWIG_InitializeModule function takes these initial arrays out of

11540

* swig_module, and does all the lookup, filling in the swig_module.types

11541

* array with the correct data and linking the correct swig_cast_info

11542

* structures together.

11543

11544

* The generated swig_type_info structures are assigned staticly to an initial

11545

* array. We just loop through that array, and handle each type individually.

11546

* First we lookup if this type has been already loaded, and if so, use the

11547

* loaded structure instead of the generated one. Then we have to fill in the

11548

* cast linked list. The cast data is initially stored in something like a

11549

* two-dimensional array. Each row corresponds to a type (there are the same

11550

* number of rows as there are in the swig_type_initial array). Each entry in

11551

* a column is one of the swig_cast_info structures for that type.

11552

* The cast_initial array is actually an array of arrays, because each row has

11553

* a variable number of columns. So to actually build the cast linked list,

11554

* we find the array of casts associated with the type, and loop through it

11555

* adding the casts to the list. The one last trick we need to do is making

11556

* sure the type pointer in the swig_cast_info struct is correct.

11557

11558

* First off, we lookup the cast->type name to see if it is already loaded.

11559

* There are three cases to handle:

11560

* 1) If the cast->type has already been loaded AND the type we are adding

11561

* casting info to has not been loaded (it is in this module), THEN we

11562

* replace the cast->type pointer with the type pointer that has already

11563

* been loaded.

11564

* 2) If BOTH types (the one we are adding casting info to, and the

11565

* cast->type) are loaded, THEN the cast info has already been loaded by

11566

* the previous module so we just ignore it.

11567

* 3) Finally, if cast->type has not already been loaded, then we add that

11568

* swig_cast_info to the linked list (because the cast->type) pointer will

11569

* be correct.

11570

* ----------------------------------------------------------------------------- */

11571

11572

#ifdef __cplusplus

11573

extern "C" {

11574

#if 0

11575

} /* c-mode */

11576

#endif

11577

#endif

11578

11579

#if 0

11580

#define SWIGRUNTIME_DEBUG

11581

#endif

11582

11583

11584

SWIGRUNTIME void

11585

SWIG_InitializeModule(void *clientdata) {

11586

size_t i;

11587

swig_module_info *module_head, *iter;

11588

int found, init;

11589

11590

clientdata = clientdata;

11591

11592

/* check to see if the circular list has been setup, if not, set it up */

11593

if (swig_module.next==0) {

11594

/* Initialize the swig_module */

11595

swig_module.type_initial = swig_type_initial;

11596

swig_module.cast_initial = swig_cast_initial;

11597

swig_module.next = &swig_module;

11598

init = 1;

11599

} else {

11600

init = 0;

11601

}

11602

11603

/* Try and load any already created modules */

11604

module_head = SWIG_GetModule(clientdata);

11605

if (!module_head) {

11606

/* This is the first module loaded for this interpreter */

11607

/* so set the swig module into the interpreter */

11608

SWIG_SetModule(clientdata, &swig_module);

11609

module_head = &swig_module;

11610

} else {

11611

/* the interpreter has loaded a SWIG module, but has it loaded this one? */

11612

found=0;

11613

iter=module_head;

11614

do {

11615

if (iter==&swig_module) {

11616

found=1;

11617

break;

11618

}

11619

iter=iter->next;

11620

} while (iter!= module_head);

11621

11622

/* if the is found in the list, then all is done and we may leave */

11623

if (found) return;

11624

/* otherwise we must add out module into the list */

11625

swig_module.next = module_head->next;

11626

module_head->next = &swig_module;

11627

}

11628

11629

/* When multiple interpeters are used, a module could have already been initialized in

11630

a different interpreter, but not yet have a pointer in this interpreter.

11631

In this case, we do not want to continue adding types... everything should be

11632

set up already */

11633

if (init == 0) return;

11634

11635

/* Now work on filling in swig_module.types */

11636

#ifdef SWIGRUNTIME_DEBUG

11637

printf("SWIG_InitializeModule: size %d\n", swig_module.size);

11638

#endif

11639

for (i = 0; i < swig_module.size; ++i) {

11640

swig_type_info *type = 0;

11641

swig_type_info *ret;

11642

swig_cast_info *cast;

11643

11644

#ifdef SWIGRUNTIME_DEBUG

11645

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

11646

#endif

11647

11648

/* if there is another module already loaded */

11649

if (swig_module.next != &swig_module) {

11650

type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);

11651

}

11652

if (type) {

11653

/* Overwrite clientdata field */

11654

#ifdef SWIGRUNTIME_DEBUG

11655

printf("SWIG_InitializeModule: found type %s\n", type->name);

11656

#endif

11657

if (swig_module.type_initial[i]->clientdata) {

11658

type->clientdata = swig_module.type_initial[i]->clientdata;

11659

#ifdef SWIGRUNTIME_DEBUG

11660

printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);

11661

#endif

11662

}

11663

} else {

11664

type = swig_module.type_initial[i];

11665

}

11666

11667

/* Insert casting types */

11668

cast = swig_module.cast_initial[i];

11669

while (cast->type) {

11670

11671

/* Don't need to add information already in the list */

11672

ret = 0;

11673

#ifdef SWIGRUNTIME_DEBUG

11674

printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);

11675

#endif

11676

if (swig_module.next != &swig_module) {

11677

ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);

11678

#ifdef SWIGRUNTIME_DEBUG

11679

if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);

11680

#endif

11681

}

11682

if (ret) {

11683

if (type == swig_module.type_initial[i]) {

11684

#ifdef SWIGRUNTIME_DEBUG

11685

printf("SWIG_InitializeModule: skip old type %s\n", ret->name);

11686

#endif

11687

cast->type = ret;

11688

ret = 0;

11689

} else {

11690

/* Check for casting already in the list */

11691

swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);

11692

#ifdef SWIGRUNTIME_DEBUG

11693

if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);

11694

#endif

11695

if (!ocast) ret = 0;

11696

}

11697

}

11698

11699

if (!ret) {

11700

#ifdef SWIGRUNTIME_DEBUG

11701

printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);

11702

#endif

11703

if (type->cast) {

11704

type->cast->prev = cast;

11705

cast->next = type->cast;

11706

}

11707

type->cast = cast;

11708

}

11709

cast++;

11710

}

11711

/* Set entry in modules->types array equal to the type */

11712

swig_module.types[i] = type;

11713

}

11714

swig_module.types[i] = 0;

11715

11716

#ifdef SWIGRUNTIME_DEBUG

11717

printf("**** SWIG_InitializeModule: Cast List ******\n");

11718

for (i = 0; i < swig_module.size; ++i) {

11719

int j = 0;

11720

swig_cast_info *cast = swig_module.cast_initial[i];

11721

printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);

11722

while (cast->type) {

11723

printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);

11724

cast++;

11725

++j;

11726

}

11727

printf("---- Total casts: %d\n",j);

11728

}

11729

printf("**** SWIG_InitializeModule: Cast List ******\n");

11730

#endif

11731

}

11732

11733

/* This function will propagate the clientdata field of type to

11734

* any new swig_type_info structures that have been added into the list

11735

* of equivalent types. It is like calling

11736

* SWIG_TypeClientData(type, clientdata) a second time.

11737

11738

SWIGRUNTIME void

11739

SWIG_PropagateClientData(void) {

11740

size_t i;

11741

swig_cast_info *equiv;

11742

static int init_run = 0;

11743

11744

if (init_run) return;

11745

init_run = 1;

11746

11747

for (i = 0; i < swig_module.size; i++) {

11748

if (swig_module.types[i]->clientdata) {

11749

equiv = swig_module.types[i]->cast;

11750

while (equiv) {

11751

if (!equiv->converter) {

11752

if (equiv->type && !equiv->type->clientdata)

11753

SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);

11754

}

11755

equiv = equiv->next;

11756

}

11757

}

11758

}

11759

}

11760

11761

#ifdef __cplusplus

11762

#if 0

11763

{ /* c-mode */

11764

#endif

11765

}

11766

#endif

11767

11768

11769

11770

11771

#ifdef __cplusplus

11772

extern "C"

11773

#endif

11774

SWIGEXPORT void Init_CdiLib(void) {

11775

size_t i;

11776

11777

SWIG_InitRuntime();

11778

mCdiLib = rb_define_module("CdiLib");

11779

11780

SWIG_InitializeModule(0);

11781

for (i = 0; i < swig_module.size; i++) {

11782

SWIG_define_class(swig_module.types[i]);

11783

}

11784

11785

SWIG_RubyInitializeTrackings();

11786

rb_define_const(mCdiLib, "CDI_UNDEFID", SWIG_From_int((int)(-1)));

11787

rb_define_const(mCdiLib, "CDI_GLOBAL", SWIG_From_int((int)(-1)));

11788

rb_define_const(mCdiLib, "CDI_BIGENDIAN", SWIG_From_int((int)(0)));

11789

rb_define_const(mCdiLib, "CDI_LITTLEENDIAN", SWIG_From_int((int)(1)));

11790

rb_define_const(mCdiLib, "CDI_NOERR", SWIG_From_int((int)(0)));

11791

rb_define_const(mCdiLib, "CDI_ESYSTEM", SWIG_From_int((int)(-10)));

11792

rb_define_const(mCdiLib, "CDI_EINVAL", SWIG_From_int((int)(-20)));

11793

rb_define_const(mCdiLib, "CDI_EUFTYPE", SWIG_From_int((int)(-21)));

11794

rb_define_const(mCdiLib, "CDI_ELIBNAVAIL", SWIG_From_int((int)(-22)));

11795

rb_define_const(mCdiLib, "CDI_EUFSTRUCT", SWIG_From_int((int)(-23)));

11796

rb_define_const(mCdiLib, "CDI_EUNC4", SWIG_From_int((int)(-24)));

11797

rb_define_const(mCdiLib, "FILETYPE_GRB", SWIG_From_int((int)(1)));

11798

rb_define_const(mCdiLib, "FILETYPE_GRB2", SWIG_From_int((int)(2)));

11799

rb_define_const(mCdiLib, "FILETYPE_NC", SWIG_From_int((int)(3)));

11800

rb_define_const(mCdiLib, "FILETYPE_NC2", SWIG_From_int((int)(4)));

11801

rb_define_const(mCdiLib, "FILETYPE_NC4", SWIG_From_int((int)(5)));

11802

rb_define_const(mCdiLib, "FILETYPE_SRV", SWIG_From_int((int)(6)));

11803

rb_define_const(mCdiLib, "FILETYPE_EXT", SWIG_From_int((int)(7)));

11804

rb_define_const(mCdiLib, "FILETYPE_IEG", SWIG_From_int((int)(8)));

11805

rb_define_const(mCdiLib, "COMPRESS_NONE", SWIG_From_int((int)(0)));

11806

rb_define_const(mCdiLib, "COMPRESS_SZIP", SWIG_From_int((int)(1)));

11807

rb_define_const(mCdiLib, "COMPRESS_GZIP", SWIG_From_int((int)(2)));

11808

rb_define_const(mCdiLib, "COMPRESS_BZIP2", SWIG_From_int((int)(3)));

11809

rb_define_const(mCdiLib, "COMPRESS_ZIP", SWIG_From_int((int)(4)));

11810

rb_define_const(mCdiLib, "DATATYPE_PACK", SWIG_From_int((int)(0)));

11811

rb_define_const(mCdiLib, "DATATYPE_PACK1", SWIG_From_int((int)(1)));

11812

rb_define_const(mCdiLib, "DATATYPE_PACK2", SWIG_From_int((int)(2)));

11813

rb_define_const(mCdiLib, "DATATYPE_PACK3", SWIG_From_int((int)(3)));

11814

rb_define_const(mCdiLib, "DATATYPE_PACK4", SWIG_From_int((int)(4)));

11815

rb_define_const(mCdiLib, "DATATYPE_PACK5", SWIG_From_int((int)(5)));

11816

rb_define_const(mCdiLib, "DATATYPE_PACK6", SWIG_From_int((int)(6)));

11817

rb_define_const(mCdiLib, "DATATYPE_PACK7", SWIG_From_int((int)(7)));

11818

rb_define_const(mCdiLib, "DATATYPE_PACK8", SWIG_From_int((int)(8)));

11819

rb_define_const(mCdiLib, "DATATYPE_PACK9", SWIG_From_int((int)(9)));

11820

rb_define_const(mCdiLib, "DATATYPE_PACK10", SWIG_From_int((int)(10)));

11821

rb_define_const(mCdiLib, "DATATYPE_PACK11", SWIG_From_int((int)(11)));

11822

rb_define_const(mCdiLib, "DATATYPE_PACK12", SWIG_From_int((int)(12)));

11823

rb_define_const(mCdiLib, "DATATYPE_PACK13", SWIG_From_int((int)(13)));

11824

rb_define_const(mCdiLib, "DATATYPE_PACK14", SWIG_From_int((int)(14)));

11825

rb_define_const(mCdiLib, "DATATYPE_PACK15", SWIG_From_int((int)(15)));

11826

rb_define_const(mCdiLib, "DATATYPE_PACK16", SWIG_From_int((int)(16)));

11827

rb_define_const(mCdiLib, "DATATYPE_PACK17", SWIG_From_int((int)(17)));

11828

rb_define_const(mCdiLib, "DATATYPE_PACK18", SWIG_From_int((int)(18)));

11829

rb_define_const(mCdiLib, "DATATYPE_PACK19", SWIG_From_int((int)(19)));

11830

rb_define_const(mCdiLib, "DATATYPE_PACK20", SWIG_From_int((int)(20)));

11831

rb_define_const(mCdiLib, "DATATYPE_PACK21", SWIG_From_int((int)(21)));

11832

rb_define_const(mCdiLib, "DATATYPE_PACK22", SWIG_From_int((int)(22)));

11833

rb_define_const(mCdiLib, "DATATYPE_PACK23", SWIG_From_int((int)(23)));

11834

rb_define_const(mCdiLib, "DATATYPE_PACK24", SWIG_From_int((int)(24)));

11835

rb_define_const(mCdiLib, "DATATYPE_PACK25", SWIG_From_int((int)(25)));

11836

rb_define_const(mCdiLib, "DATATYPE_PACK26", SWIG_From_int((int)(26)));

11837

rb_define_const(mCdiLib, "DATATYPE_PACK27", SWIG_From_int((int)(27)));

11838

rb_define_const(mCdiLib, "DATATYPE_PACK28", SWIG_From_int((int)(28)));

11839

rb_define_const(mCdiLib, "DATATYPE_PACK29", SWIG_From_int((int)(29)));

11840

rb_define_const(mCdiLib, "DATATYPE_PACK30", SWIG_From_int((int)(30)));

11841

rb_define_const(mCdiLib, "DATATYPE_PACK31", SWIG_From_int((int)(31)));

11842

rb_define_const(mCdiLib, "DATATYPE_PACK32", SWIG_From_int((int)(32)));

11843

rb_define_const(mCdiLib, "DATATYPE_FLT32", SWIG_From_int((int)(132)));

11844

rb_define_const(mCdiLib, "DATATYPE_FLT64", SWIG_From_int((int)(164)));

11845

rb_define_const(mCdiLib, "DATATYPE_INT8", SWIG_From_int((int)(208)));

11846

rb_define_const(mCdiLib, "DATATYPE_INT16", SWIG_From_int((int)(216)));

11847

rb_define_const(mCdiLib, "DATATYPE_INT32", SWIG_From_int((int)(232)));

11848

rb_define_const(mCdiLib, "DATATYPE_UINT8", SWIG_From_int((int)(308)));

11849

rb_define_const(mCdiLib, "DATATYPE_UINT16", SWIG_From_int((int)(316)));

11850

rb_define_const(mCdiLib, "DATATYPE_UINT32", SWIG_From_int((int)(332)));

11851

rb_define_const(mCdiLib, "DATATYPE_INT", SWIG_From_int((int)(251)));

11852

rb_define_const(mCdiLib, "DATATYPE_FLT", SWIG_From_int((int)(252)));

11853

rb_define_const(mCdiLib, "DATATYPE_TXT", SWIG_From_int((int)(253)));

11854

rb_define_const(mCdiLib, "GRID_GENERIC", SWIG_From_int((int)(1)));

11855

rb_define_const(mCdiLib, "GRID_GAUSSIAN", SWIG_From_int((int)(2)));

11856

rb_define_const(mCdiLib, "GRID_GAUSSIAN_REDUCED", SWIG_From_int((int)(3)));

11857

rb_define_const(mCdiLib, "GRID_LONLAT", SWIG_From_int((int)(4)));

11858

rb_define_const(mCdiLib, "GRID_SPECTRAL", SWIG_From_int((int)(5)));

11859

rb_define_const(mCdiLib, "GRID_FOURIER", SWIG_From_int((int)(6)));

11860

rb_define_const(mCdiLib, "GRID_GME", SWIG_From_int((int)(7)));

11861

rb_define_const(mCdiLib, "GRID_TRAJECTORY", SWIG_From_int((int)(8)));

11862

rb_define_const(mCdiLib, "GRID_CELL", SWIG_From_int((int)(9)));

11863

rb_define_const(mCdiLib, "GRID_CURVILINEAR", SWIG_From_int((int)(10)));

11864

rb_define_const(mCdiLib, "GRID_LCC", SWIG_From_int((int)(11)));

11865

rb_define_const(mCdiLib, "GRID_LCC2", SWIG_From_int((int)(12)));

11866

rb_define_const(mCdiLib, "GRID_LAEA", SWIG_From_int((int)(13)));

11867

rb_define_const(mCdiLib, "GRID_SINUSOIDAL", SWIG_From_int((int)(14)));

11868

rb_define_const(mCdiLib, "ZAXIS_SURFACE", SWIG_From_int((int)(0)));

11869

rb_define_const(mCdiLib, "ZAXIS_GENERIC", SWIG_From_int((int)(1)));

11870

rb_define_const(mCdiLib, "ZAXIS_HYBRID", SWIG_From_int((int)(2)));

11871

rb_define_const(mCdiLib, "ZAXIS_HYBRID_HALF", SWIG_From_int((int)(3)));

11872

rb_define_const(mCdiLib, "ZAXIS_PRESSURE", SWIG_From_int((int)(4)));

11873

rb_define_const(mCdiLib, "ZAXIS_HEIGHT", SWIG_From_int((int)(5)));

11874

rb_define_const(mCdiLib, "ZAXIS_DEPTH_BELOW_SEA", SWIG_From_int((int)(6)));

11875

rb_define_const(mCdiLib, "ZAXIS_DEPTH_BELOW_LAND", SWIG_From_int((int)(7)));

11876

rb_define_const(mCdiLib, "ZAXIS_ISENTROPIC", SWIG_From_int((int)(8)));

11877

rb_define_const(mCdiLib, "ZAXIS_TRAJECTORY", SWIG_From_int((int)(9)));

11878

rb_define_const(mCdiLib, "ZAXIS_ALTITUDE", SWIG_From_int((int)(10)));

11879

rb_define_const(mCdiLib, "ZAXIS_SIGMA", SWIG_From_int((int)(11)));

11880

rb_define_const(mCdiLib, "ZAXIS_MEANSEA", SWIG_From_int((int)(12)));

11881

rb_define_const(mCdiLib, "TAXIS_ABSOLUTE", SWIG_From_int((int)(1)));

11882

rb_define_const(mCdiLib, "TAXIS_RELATIVE", SWIG_From_int((int)(2)));

11883

rb_define_const(mCdiLib, "TIME_CONSTANT", SWIG_From_int((int)(1)));

11884

rb_define_const(mCdiLib, "TIME_VARIABLE", SWIG_From_int((int)(2)));

11885

rb_define_const(mCdiLib, "TUNIT_SECOND", SWIG_From_int((int)(1)));

11886

rb_define_const(mCdiLib, "TUNIT_MINUTE", SWIG_From_int((int)(2)));

11887

rb_define_const(mCdiLib, "TUNIT_HOUR", SWIG_From_int((int)(3)));

11888

rb_define_const(mCdiLib, "TUNIT_DAY", SWIG_From_int((int)(4)));

11889

rb_define_const(mCdiLib, "TUNIT_MONTH", SWIG_From_int((int)(5)));

11890

rb_define_const(mCdiLib, "TUNIT_YEAR", SWIG_From_int((int)(6)));

11891

rb_define_const(mCdiLib, "TUNIT_QUARTER", SWIG_From_int((int)(7)));

11892

rb_define_const(mCdiLib, "CALENDAR_STANDARD", SWIG_From_int((int)(0)));

11893

rb_define_const(mCdiLib, "CALENDAR_PROLEPTIC", SWIG_From_int((int)(1)));

11894

rb_define_const(mCdiLib, "CALENDAR_360DAYS", SWIG_From_int((int)(2)));

11895

rb_define_const(mCdiLib, "CALENDAR_365DAYS", SWIG_From_int((int)(3)));

11896

rb_define_const(mCdiLib, "CALENDAR_366DAYS", SWIG_From_int((int)(4)));

11897

rb_define_const(mCdiLib, "CALENDAR_NONE", SWIG_From_int((int)(5)));

11898

rb_define_module_function(mCdiLib, "cdiStringError", _wrap_cdiStringError, -1);

11899

rb_define_module_function(mCdiLib, "cdiDebug", _wrap_cdiDebug, -1);

11900

rb_define_module_function(mCdiLib, "cdiLibraryVersion", _wrap_cdiLibraryVersion, -1);

11901

rb_define_module_function(mCdiLib, "cdiPrintVersion", _wrap_cdiPrintVersion, -1);

11902

rb_define_module_function(mCdiLib, "cdiDefMissval", _wrap_cdiDefMissval, -1);

11903

rb_define_module_function(mCdiLib, "cdiInqMissval", _wrap_cdiInqMissval, -1);

11904

rb_define_module_function(mCdiLib, "cdiDefGlobal", _wrap_cdiDefGlobal, -1);

11905

rb_define_module_function(mCdiLib, "streamOpenRead", _wrap_streamOpenRead, -1);

11906

rb_define_module_function(mCdiLib, "streamOpenWrite", _wrap_streamOpenWrite, -1);

11907

rb_define_module_function(mCdiLib, "streamOpenAppend", _wrap_streamOpenAppend, -1);

11908

rb_define_module_function(mCdiLib, "streamClose", _wrap_streamClose, -1);

11909

rb_define_module_function(mCdiLib, "streamSync", _wrap_streamSync, -1);

11910

rb_define_module_function(mCdiLib, "streamDefVlist", _wrap_streamDefVlist, -1);

11911

rb_define_module_function(mCdiLib, "streamInqVlist", _wrap_streamInqVlist, -1);

11912

rb_define_module_function(mCdiLib, "streamInqFiletype", _wrap_streamInqFiletype, -1);

11913

rb_define_module_function(mCdiLib, "streamDefByteorder", _wrap_streamDefByteorder, -1);

11914

rb_define_module_function(mCdiLib, "streamInqByteorder", _wrap_streamInqByteorder, -1);

11915

rb_define_module_function(mCdiLib, "streamDefZtype", _wrap_streamDefZtype, -1);

11916

rb_define_module_function(mCdiLib, "streamDefZlevel", _wrap_streamDefZlevel, -1);

11917

rb_define_module_function(mCdiLib, "streamInqZtype", _wrap_streamInqZtype, -1);

11918

rb_define_module_function(mCdiLib, "streamInqZlevel", _wrap_streamInqZlevel, -1);

11919

rb_define_module_function(mCdiLib, "streamDefTimestep", _wrap_streamDefTimestep, -1);

11920

rb_define_module_function(mCdiLib, "streamInqTimestep", _wrap_streamInqTimestep, -1);

11921

rb_define_module_function(mCdiLib, "streamFilename", _wrap_streamFilename, -1);

11922

rb_define_module_function(mCdiLib, "streamFilesuffix", _wrap_streamFilesuffix, -1);

11923

rb_define_module_function(mCdiLib, "streamNtsteps", _wrap_streamNtsteps, -1);

11924

rb_define_module_function(mCdiLib, "streamNvals", _wrap_streamNvals, -1);

11925

rb_define_module_function(mCdiLib, "streamReadVar", _wrap_streamReadVar, -1);

11926

rb_define_module_function(mCdiLib, "streamWriteVar", _wrap_streamWriteVar, -1);

11927

rb_define_module_function(mCdiLib, "streamReadVarSlice", _wrap_streamReadVarSlice, -1);

11928

rb_define_module_function(mCdiLib, "streamWriteVarSlice", _wrap_streamWriteVarSlice, -1);

11929

rb_define_module_function(mCdiLib, "streamInqRecord", _wrap_streamInqRecord, -1);

11930

rb_define_module_function(mCdiLib, "streamDefRecord", _wrap_streamDefRecord, -1);

11931

rb_define_module_function(mCdiLib, "streamReadRecord", _wrap_streamReadRecord, -1);

11932

rb_define_module_function(mCdiLib, "streamWriteRecord", _wrap_streamWriteRecord, -1);

11933

rb_define_module_function(mCdiLib, "streamCopyRecord", _wrap_streamCopyRecord, -1);

11934

rb_define_module_function(mCdiLib, "streamInqGinfo", _wrap_streamInqGinfo, -1);

11935

rb_define_module_function(mCdiLib, "vlistCreate", _wrap_vlistCreate, -1);

11936

rb_define_module_function(mCdiLib, "vlistDestroy", _wrap_vlistDestroy, -1);

11937

rb_define_module_function(mCdiLib, "vlistDuplicate", _wrap_vlistDuplicate, -1);

11938

rb_define_module_function(mCdiLib, "vlistCopy", _wrap_vlistCopy, -1);

11939

rb_define_module_function(mCdiLib, "vlistCopyFlag", _wrap_vlistCopyFlag, -1);

11940

rb_define_module_function(mCdiLib, "vlistClearFlag", _wrap_vlistClearFlag, -1);

11941

rb_define_module_function(mCdiLib, "vlistCat", _wrap_vlistCat, -1);

11942

rb_define_module_function(mCdiLib, "vlistMerge", _wrap_vlistMerge, -1);

11943

rb_define_module_function(mCdiLib, "vlistPrint", _wrap_vlistPrint, -1);

11944

rb_define_module_function(mCdiLib, "vlistNvars", _wrap_vlistNvars, -1);

11945

rb_define_module_function(mCdiLib, "vlistNgrids", _wrap_vlistNgrids, -1);

11946

rb_define_module_function(mCdiLib, "vlistNzaxis", _wrap_vlistNzaxis, -1);

11947

rb_define_module_function(mCdiLib, "vlistDefNtsteps", _wrap_vlistDefNtsteps, -1);

11948

rb_define_module_function(mCdiLib, "vlistNtsteps", _wrap_vlistNtsteps, -1);

11949

rb_define_module_function(mCdiLib, "vlistGridsizeMax", _wrap_vlistGridsizeMax, -1);

11950

rb_define_module_function(mCdiLib, "vlistGrid", _wrap_vlistGrid, -1);

11951

rb_define_module_function(mCdiLib, "vlistGridIndex", _wrap_vlistGridIndex, -1);

11952

rb_define_module_function(mCdiLib, "vlistChangeGridIndex", _wrap_vlistChangeGridIndex, -1);

11953

rb_define_module_function(mCdiLib, "vlistChangeGrid", _wrap_vlistChangeGrid, -1);

11954

rb_define_module_function(mCdiLib, "vlistZaxis", _wrap_vlistZaxis, -1);

11955

rb_define_module_function(mCdiLib, "vlistZaxisIndex", _wrap_vlistZaxisIndex, -1);

11956

rb_define_module_function(mCdiLib, "vlistChangeZaxisIndex", _wrap_vlistChangeZaxisIndex, -1);

11957

rb_define_module_function(mCdiLib, "vlistChangeZaxis", _wrap_vlistChangeZaxis, -1);

11958

rb_define_module_function(mCdiLib, "vlistNrecs", _wrap_vlistNrecs, -1);

11959

rb_define_module_function(mCdiLib, "vlistDefTaxis", _wrap_vlistDefTaxis, -1);

11960

rb_define_module_function(mCdiLib, "vlistInqTaxis", _wrap_vlistInqTaxis, -1);

11961

rb_define_module_function(mCdiLib, "vlistDefTable", _wrap_vlistDefTable, -1);

11962

rb_define_module_function(mCdiLib, "vlistInqTable", _wrap_vlistInqTable, -1);

11963

rb_define_module_function(mCdiLib, "vlistDefInstitut", _wrap_vlistDefInstitut, -1);

11964

rb_define_module_function(mCdiLib, "vlistInqInstitut", _wrap_vlistInqInstitut, -1);

11965

rb_define_module_function(mCdiLib, "vlistDefModel", _wrap_vlistDefModel, -1);

11966

rb_define_module_function(mCdiLib, "vlistInqModel", _wrap_vlistInqModel, -1);

11967

rb_define_module_function(mCdiLib, "vlistDefVar", _wrap_vlistDefVar, -1);

11968

rb_define_module_function(mCdiLib, "vlistChangeVarGrid", _wrap_vlistChangeVarGrid, -1);

11969

rb_define_module_function(mCdiLib, "vlistChangeVarZaxis", _wrap_vlistChangeVarZaxis, -1);

11970

rb_define_module_function(mCdiLib, "vlistInqVar", _wrap_vlistInqVar, -1);

11971

rb_define_module_function(mCdiLib, "vlistInqVarGrid", _wrap_vlistInqVarGrid, -1);

11972

rb_define_module_function(mCdiLib, "vlistInqVarZaxis", _wrap_vlistInqVarZaxis, -1);

11973

rb_define_module_function(mCdiLib, "vlistInqVarTime", _wrap_vlistInqVarTime, -1);

11974

rb_define_module_function(mCdiLib, "vlistDefVarZtype", _wrap_vlistDefVarZtype, -1);

11975

rb_define_module_function(mCdiLib, "vlistInqVarZtype", _wrap_vlistInqVarZtype, -1);

11976

rb_define_module_function(mCdiLib, "vlistDefVarZlevel", _wrap_vlistDefVarZlevel, -1);

11977

rb_define_module_function(mCdiLib, "vlistInqVarZlevel", _wrap_vlistInqVarZlevel, -1);

11978

rb_define_module_function(mCdiLib, "vlistDefVarCode", _wrap_vlistDefVarCode, -1);

11979

rb_define_module_function(mCdiLib, "vlistInqVarCode", _wrap_vlistInqVarCode, -1);

11980

rb_define_module_function(mCdiLib, "vlistDefVarDatatype", _wrap_vlistDefVarDatatype, -1);

11981

rb_define_module_function(mCdiLib, "vlistInqVarDatatype", _wrap_vlistInqVarDatatype, -1);

11982

rb_define_module_function(mCdiLib, "vlistDefVarInstitut", _wrap_vlistDefVarInstitut, -1);

11983

rb_define_module_function(mCdiLib, "vlistInqVarInstitut", _wrap_vlistInqVarInstitut, -1);

11984

rb_define_module_function(mCdiLib, "vlistDefVarModel", _wrap_vlistDefVarModel, -1);

11985

rb_define_module_function(mCdiLib, "vlistInqVarModel", _wrap_vlistInqVarModel, -1);

11986

rb_define_module_function(mCdiLib, "vlistDefVarTable", _wrap_vlistDefVarTable, -1);

11987

rb_define_module_function(mCdiLib, "vlistInqVarTable", _wrap_vlistInqVarTable, -1);

11988

rb_define_module_function(mCdiLib, "vlistDefVarName", _wrap_vlistDefVarName, -1);

11989

rb_define_module_function(mCdiLib, "vlistInqVarName", _wrap_vlistInqVarName, -1);

11990

rb_define_module_function(mCdiLib, "vlistDefVarLongname", _wrap_vlistDefVarLongname, -1);

11991

rb_define_module_function(mCdiLib, "vlistDefVarStdname", _wrap_vlistDefVarStdname, -1);

11992

rb_define_module_function(mCdiLib, "vlistInqVarLongname", _wrap_vlistInqVarLongname, -1);

11993

rb_define_module_function(mCdiLib, "vlistInqVarStdname", _wrap_vlistInqVarStdname, -1);

11994

rb_define_module_function(mCdiLib, "vlistDefVarUnits", _wrap_vlistDefVarUnits, -1);

11995

rb_define_module_function(mCdiLib, "vlistInqVarUnits", _wrap_vlistInqVarUnits, -1);

11996

rb_define_module_function(mCdiLib, "vlistDefVarMissval", _wrap_vlistDefVarMissval, -1);

11997

rb_define_module_function(mCdiLib, "vlistInqVarMissval", _wrap_vlistInqVarMissval, -1);

11998

rb_define_module_function(mCdiLib, "vlistDefVarScalefactor", _wrap_vlistDefVarScalefactor, -1);

11999

rb_define_module_function(mCdiLib, "vlistInqVarScalefactor", _wrap_vlistInqVarScalefactor, -1);

12000

rb_define_module_function(mCdiLib, "vlistDefVarAddoffset", _wrap_vlistDefVarAddoffset, -1);

12001

rb_define_module_function(mCdiLib, "vlistInqVarAddoffset", _wrap_vlistInqVarAddoffset, -1);

12002

rb_define_module_function(mCdiLib, "vlistDefVarTimave", _wrap_vlistDefVarTimave, -1);

12003

rb_define_module_function(mCdiLib, "vlistInqVarTimave", _wrap_vlistInqVarTimave, -1);

12004

rb_define_module_function(mCdiLib, "vlistDefVarTimaccu", _wrap_vlistDefVarTimaccu, -1);

12005

rb_define_module_function(mCdiLib, "vlistInqVarTimaccu", _wrap_vlistInqVarTimaccu, -1);

12006

rb_define_module_function(mCdiLib, "vlistInqVarSize", _wrap_vlistInqVarSize, -1);

12007

rb_define_module_function(mCdiLib, "vlistInqVarID", _wrap_vlistInqVarID, -1);

12008

rb_define_module_function(mCdiLib, "vlistDefIndex", _wrap_vlistDefIndex, -1);

12009

rb_define_module_function(mCdiLib, "vlistInqIndex", _wrap_vlistInqIndex, -1);

12010

rb_define_module_function(mCdiLib, "vlistDefFlag", _wrap_vlistDefFlag, -1);

12011

rb_define_module_function(mCdiLib, "vlistInqFlag", _wrap_vlistInqFlag, -1);

12012

rb_define_module_function(mCdiLib, "vlistFindVar", _wrap_vlistFindVar, -1);

12013

rb_define_module_function(mCdiLib, "vlistFindLevel", _wrap_vlistFindLevel, -1);

12014

rb_define_module_function(mCdiLib, "vlistMergedVar", _wrap_vlistMergedVar, -1);

12015

rb_define_module_function(mCdiLib, "vlistMergedLevel", _wrap_vlistMergedLevel, -1);

12016

rb_define_module_function(mCdiLib, "vlistInqNatts", _wrap_vlistInqNatts, -1);

12017

rb_define_module_function(mCdiLib, "vlistInqAtt", _wrap_vlistInqAtt, -1);

12018

rb_define_module_function(mCdiLib, "vlistDelAtt", _wrap_vlistDelAtt, -1);

12019

rb_define_module_function(mCdiLib, "vlistDefAttInt", _wrap_vlistDefAttInt, -1);

12020

rb_define_module_function(mCdiLib, "vlistDefAttFlt", _wrap_vlistDefAttFlt, -1);

12021

rb_define_module_function(mCdiLib, "vlistDefAttTxt", _wrap_vlistDefAttTxt, -1);

12022

rb_define_module_function(mCdiLib, "vlistInqAttInt", _wrap_vlistInqAttInt, -1);

12023

rb_define_module_function(mCdiLib, "vlistInqAttFlt", _wrap_vlistInqAttFlt, -1);

12024

rb_define_module_function(mCdiLib, "vlistInqAttTxt", _wrap_vlistInqAttTxt, -1);

12025

rb_define_module_function(mCdiLib, "gridName", _wrap_gridName, -1);

12026

rb_define_module_function(mCdiLib, "gridNamePtr", _wrap_gridNamePtr, -1);

12027

rb_define_module_function(mCdiLib, "gridCompress", _wrap_gridCompress, -1);

12028

rb_define_module_function(mCdiLib, "gridDefMask", _wrap_gridDefMask, -1);

12029

rb_define_module_function(mCdiLib, "gridInqMask", _wrap_gridInqMask, -1);

12030

rb_define_module_function(mCdiLib, "gridPrint", _wrap_gridPrint, -1);

12031

rb_define_module_function(mCdiLib, "gridSize", _wrap_gridSize, -1);

12032

rb_define_module_function(mCdiLib, "gridCreate", _wrap_gridCreate, -1);

12033

rb_define_module_function(mCdiLib, "gridDestroy", _wrap_gridDestroy, -1);

12034

rb_define_module_function(mCdiLib, "gridDuplicate", _wrap_gridDuplicate, -1);

12035

rb_define_module_function(mCdiLib, "gridInqType", _wrap_gridInqType, -1);

12036

rb_define_module_function(mCdiLib, "gridInqSize", _wrap_gridInqSize, -1);

12037

rb_define_module_function(mCdiLib, "gridDefXsize", _wrap_gridDefXsize, -1);

12038

rb_define_module_function(mCdiLib, "gridInqXsize", _wrap_gridInqXsize, -1);

12039

rb_define_module_function(mCdiLib, "gridDefYsize", _wrap_gridDefYsize, -1);

12040

rb_define_module_function(mCdiLib, "gridInqYsize", _wrap_gridInqYsize, -1);

12041

rb_define_module_function(mCdiLib, "gridDefXvals", _wrap_gridDefXvals, -1);

12042

rb_define_module_function(mCdiLib, "gridInqXvals", _wrap_gridInqXvals, -1);

12043

rb_define_module_function(mCdiLib, "gridDefYvals", _wrap_gridDefYvals, -1);

12044

rb_define_module_function(mCdiLib, "gridInqYvals", _wrap_gridInqYvals, -1);

12045

rb_define_module_function(mCdiLib, "gridDefXname", _wrap_gridDefXname, -1);

12046

rb_define_module_function(mCdiLib, "gridDefXlongname", _wrap_gridDefXlongname, -1);

12047

rb_define_module_function(mCdiLib, "gridDefXunits", _wrap_gridDefXunits, -1);

12048

rb_define_module_function(mCdiLib, "gridDefYname", _wrap_gridDefYname, -1);

12049

rb_define_module_function(mCdiLib, "gridDefYlongname", _wrap_gridDefYlongname, -1);

12050

rb_define_module_function(mCdiLib, "gridDefYunits", _wrap_gridDefYunits, -1);

12051

rb_define_module_function(mCdiLib, "gridInqXname", _wrap_gridInqXname, -1);

12052

rb_define_module_function(mCdiLib, "gridInqXlongname", _wrap_gridInqXlongname, -1);

12053

rb_define_module_function(mCdiLib, "gridInqXstdname", _wrap_gridInqXstdname, -1);

12054

rb_define_module_function(mCdiLib, "gridInqXunits", _wrap_gridInqXunits, -1);

12055

rb_define_module_function(mCdiLib, "gridInqYname", _wrap_gridInqYname, -1);

12056

rb_define_module_function(mCdiLib, "gridInqYlongname", _wrap_gridInqYlongname, -1);

12057

rb_define_module_function(mCdiLib, "gridInqYstdname", _wrap_gridInqYstdname, -1);

12058

rb_define_module_function(mCdiLib, "gridInqYunits", _wrap_gridInqYunits, -1);

12059

rb_define_module_function(mCdiLib, "gridDefPrec", _wrap_gridDefPrec, -1);

12060

rb_define_module_function(mCdiLib, "gridInqPrec", _wrap_gridInqPrec, -1);

12061

rb_define_module_function(mCdiLib, "gridInqXval", _wrap_gridInqXval, -1);

12062

rb_define_module_function(mCdiLib, "gridInqYval", _wrap_gridInqYval, -1);

12063

rb_define_module_function(mCdiLib, "gridInqXinc", _wrap_gridInqXinc, -1);

12064

rb_define_module_function(mCdiLib, "gridInqYinc", _wrap_gridInqYinc, -1);

12065

rb_define_module_function(mCdiLib, "gridIsCircular", _wrap_gridIsCircular, -1);

12066

rb_define_module_function(mCdiLib, "gridIsRotated", _wrap_gridIsRotated, -1);

12067

rb_define_module_function(mCdiLib, "gridInqXpole", _wrap_gridInqXpole, -1);

12068

rb_define_module_function(mCdiLib, "gridDefXpole", _wrap_gridDefXpole, -1);

12069

rb_define_module_function(mCdiLib, "gridInqYpole", _wrap_gridInqYpole, -1);

12070

rb_define_module_function(mCdiLib, "gridDefYpole", _wrap_gridDefYpole, -1);

12071

rb_define_module_function(mCdiLib, "gridInqAngle", _wrap_gridInqAngle, -1);

12072

rb_define_module_function(mCdiLib, "gridDefAngle", _wrap_gridDefAngle, -1);

12073

rb_define_module_function(mCdiLib, "gridDefTrunc", _wrap_gridDefTrunc, -1);

12074

rb_define_module_function(mCdiLib, "gridInqTrunc", _wrap_gridInqTrunc, -1);

12075

rb_define_module_function(mCdiLib, "gridInqGMEnd", _wrap_gridInqGMEnd, -1);

12076

rb_define_module_function(mCdiLib, "gridDefGMEnd", _wrap_gridDefGMEnd, -1);

12077

rb_define_module_function(mCdiLib, "gridInqGMEni", _wrap_gridInqGMEni, -1);

12078

rb_define_module_function(mCdiLib, "gridDefGMEni", _wrap_gridDefGMEni, -1);

12079

rb_define_module_function(mCdiLib, "gridInqGMEni2", _wrap_gridInqGMEni2, -1);

12080

rb_define_module_function(mCdiLib, "gridDefGMEni2", _wrap_gridDefGMEni2, -1);

12081

rb_define_module_function(mCdiLib, "gridInqGMEni3", _wrap_gridInqGMEni3, -1);

12082

rb_define_module_function(mCdiLib, "gridDefGMEni3", _wrap_gridDefGMEni3, -1);

12083

rb_define_module_function(mCdiLib, "gridDefLCC", _wrap_gridDefLCC, -1);

12084

rb_define_module_function(mCdiLib, "gridInqLCC", _wrap_gridInqLCC, -1);

12085

rb_define_module_function(mCdiLib, "gridDefLcc2", _wrap_gridDefLcc2, -1);

12086

rb_define_module_function(mCdiLib, "gridInqLcc2", _wrap_gridInqLcc2, -1);

12087

rb_define_module_function(mCdiLib, "gridDefLaea", _wrap_gridDefLaea, -1);

12088

rb_define_module_function(mCdiLib, "gridInqLaea", _wrap_gridInqLaea, -1);

12089

rb_define_module_function(mCdiLib, "gridDefArea", _wrap_gridDefArea, -1);

12090

rb_define_module_function(mCdiLib, "gridInqArea", _wrap_gridInqArea, -1);

12091

rb_define_module_function(mCdiLib, "gridHasArea", _wrap_gridHasArea, -1);

12092

rb_define_module_function(mCdiLib, "gridDefNvertex", _wrap_gridDefNvertex, -1);

12093

rb_define_module_function(mCdiLib, "gridInqNvertex", _wrap_gridInqNvertex, -1);

12094

rb_define_module_function(mCdiLib, "gridDefXbounds", _wrap_gridDefXbounds, -1);

12095

rb_define_module_function(mCdiLib, "gridInqXbounds", _wrap_gridInqXbounds, -1);

12096

rb_define_module_function(mCdiLib, "gridDefYbounds", _wrap_gridDefYbounds, -1);

12097

rb_define_module_function(mCdiLib, "gridInqYbounds", _wrap_gridInqYbounds, -1);

12098

rb_define_module_function(mCdiLib, "gridDefRowlon", _wrap_gridDefRowlon, -1);

12099

rb_define_module_function(mCdiLib, "gridInqRowlon", _wrap_gridInqRowlon, -1);

12100

rb_define_module_function(mCdiLib, "gridChangeType", _wrap_gridChangeType, -1);

12101

rb_define_module_function(mCdiLib, "zaxisName", _wrap_zaxisName, -1);

12102

rb_define_module_function(mCdiLib, "zaxisCreate", _wrap_zaxisCreate, -1);

12103

rb_define_module_function(mCdiLib, "zaxisDestroy", _wrap_zaxisDestroy, -1);

12104

rb_define_module_function(mCdiLib, "zaxisInqType", _wrap_zaxisInqType, -1);

12105

rb_define_module_function(mCdiLib, "zaxisInqSize", _wrap_zaxisInqSize, -1);

12106

rb_define_module_function(mCdiLib, "zaxisDuplicate", _wrap_zaxisDuplicate, -1);

12107

rb_define_module_function(mCdiLib, "zaxisResize", _wrap_zaxisResize, -1);

12108

rb_define_module_function(mCdiLib, "zaxisPrint", _wrap_zaxisPrint, -1);

12109

rb_define_module_function(mCdiLib, "zaxisSize", _wrap_zaxisSize, -1);

12110

rb_define_module_function(mCdiLib, "zaxisDefLevels", _wrap_zaxisDefLevels, -1);

12111

rb_define_module_function(mCdiLib, "zaxisInqLevels", _wrap_zaxisInqLevels, -1);

12112

rb_define_module_function(mCdiLib, "zaxisDefLevel", _wrap_zaxisDefLevel, -1);

12113

rb_define_module_function(mCdiLib, "zaxisInqLevel", _wrap_zaxisInqLevel, -1);

12114

rb_define_module_function(mCdiLib, "zaxisDefName", _wrap_zaxisDefName, -1);

12115

rb_define_module_function(mCdiLib, "zaxisDefLongname", _wrap_zaxisDefLongname, -1);

12116

rb_define_module_function(mCdiLib, "zaxisDefUnits", _wrap_zaxisDefUnits, -1);

12117

rb_define_module_function(mCdiLib, "zaxisInqName", _wrap_zaxisInqName, -1);

12118

rb_define_module_function(mCdiLib, "zaxisInqLongname", _wrap_zaxisInqLongname, -1);

12119

rb_define_module_function(mCdiLib, "zaxisInqUnits", _wrap_zaxisInqUnits, -1);

12120

rb_define_module_function(mCdiLib, "zaxisDefPrec", _wrap_zaxisDefPrec, -1);

12121

rb_define_module_function(mCdiLib, "zaxisInqPrec", _wrap_zaxisInqPrec, -1);

12122

rb_define_module_function(mCdiLib, "zaxisDefLtype", _wrap_zaxisDefLtype, -1);

12123

rb_define_module_function(mCdiLib, "zaxisInqLtype", _wrap_zaxisInqLtype, -1);

12124

rb_define_module_function(mCdiLib, "zaxisInqLevelsPtr", _wrap_zaxisInqLevelsPtr, -1);

12125

rb_define_module_function(mCdiLib, "zaxisDefVct", _wrap_zaxisDefVct, -1);

12126

rb_define_module_function(mCdiLib, "zaxisInqVctSize", _wrap_zaxisInqVctSize, -1);

12127

rb_define_module_function(mCdiLib, "zaxisInqVctPtr", _wrap_zaxisInqVctPtr, -1);

12128

rb_define_module_function(mCdiLib, "zaxisInqLbounds", _wrap_zaxisInqLbounds, -1);

12129

rb_define_module_function(mCdiLib, "zaxisInqUbounds", _wrap_zaxisInqUbounds, -1);

12130

rb_define_module_function(mCdiLib, "zaxisInqWeights", _wrap_zaxisInqWeights, -1);

12131

rb_define_module_function(mCdiLib, "zaxisInqLbound", _wrap_zaxisInqLbound, -1);

12132

rb_define_module_function(mCdiLib, "zaxisInqUbound", _wrap_zaxisInqUbound, -1);

12133

rb_define_module_function(mCdiLib, "zaxisDefLbounds", _wrap_zaxisDefLbounds, -1);

12134

rb_define_module_function(mCdiLib, "zaxisDefUbounds", _wrap_zaxisDefUbounds, -1);

12135

rb_define_module_function(mCdiLib, "zaxisDefWeights", _wrap_zaxisDefWeights, -1);

12136

rb_define_module_function(mCdiLib, "zaxisChangeType", _wrap_zaxisChangeType, -1);

12137

rb_define_module_function(mCdiLib, "taxisCreate", _wrap_taxisCreate, -1);

12138

rb_define_module_function(mCdiLib, "taxisDestroy", _wrap_taxisDestroy, -1);

12139

rb_define_module_function(mCdiLib, "taxisDuplicate", _wrap_taxisDuplicate, -1);

12140

rb_define_module_function(mCdiLib, "taxisCopyTimestep", _wrap_taxisCopyTimestep, -1);

12141

rb_define_module_function(mCdiLib, "taxisDefType", _wrap_taxisDefType, -1);

12142

rb_define_module_function(mCdiLib, "taxisDefVdate", _wrap_taxisDefVdate, -1);

12143

rb_define_module_function(mCdiLib, "taxisDefVtime", _wrap_taxisDefVtime, -1);

12144

rb_define_module_function(mCdiLib, "taxisDefRdate", _wrap_taxisDefRdate, -1);

12145

rb_define_module_function(mCdiLib, "taxisDefRtime", _wrap_taxisDefRtime, -1);

12146

rb_define_module_function(mCdiLib, "taxisHasBounds", _wrap_taxisHasBounds, -1);

12147

rb_define_module_function(mCdiLib, "taxisDefVdateBounds", _wrap_taxisDefVdateBounds, -1);

12148

rb_define_module_function(mCdiLib, "taxisDefVtimeBounds", _wrap_taxisDefVtimeBounds, -1);

12149

rb_define_module_function(mCdiLib, "taxisInqVdateBounds", _wrap_taxisInqVdateBounds, -1);

12150

rb_define_module_function(mCdiLib, "taxisInqVtimeBounds", _wrap_taxisInqVtimeBounds, -1);

12151

rb_define_module_function(mCdiLib, "taxisDefCalendar", _wrap_taxisDefCalendar, -1);

12152

rb_define_module_function(mCdiLib, "taxisDefTunit", _wrap_taxisDefTunit, -1);

12153

rb_define_module_function(mCdiLib, "taxisDefNumavg", _wrap_taxisDefNumavg, -1);

12154

rb_define_module_function(mCdiLib, "taxisInqType", _wrap_taxisInqType, -1);

12155

rb_define_module_function(mCdiLib, "taxisInqVdate", _wrap_taxisInqVdate, -1);

12156

rb_define_module_function(mCdiLib, "taxisInqVtime", _wrap_taxisInqVtime, -1);

12157

rb_define_module_function(mCdiLib, "taxisInqRdate", _wrap_taxisInqRdate, -1);

12158

rb_define_module_function(mCdiLib, "taxisInqRtime", _wrap_taxisInqRtime, -1);

12159

rb_define_module_function(mCdiLib, "taxisInqCalendar", _wrap_taxisInqCalendar, -1);

12160

rb_define_module_function(mCdiLib, "taxisInqTunit", _wrap_taxisInqTunit, -1);

12161

rb_define_module_function(mCdiLib, "taxisInqNumavg", _wrap_taxisInqNumavg, -1);

12162

rb_define_module_function(mCdiLib, "tunitNamePtr", _wrap_tunitNamePtr, -1);

12163

rb_define_module_function(mCdiLib, "institutDef", _wrap_institutDef, -1);

12164

rb_define_module_function(mCdiLib, "institutInq", _wrap_institutInq, -1);

12165

rb_define_module_function(mCdiLib, "institutInqNumber", _wrap_institutInqNumber, -1);

12166

rb_define_module_function(mCdiLib, "institutInqCenter", _wrap_institutInqCenter, -1);

12167

rb_define_module_function(mCdiLib, "institutInqSubcenter", _wrap_institutInqSubcenter, -1);

12168

rb_define_module_function(mCdiLib, "institutInqNamePtr", _wrap_institutInqNamePtr, -1);

12169

rb_define_module_function(mCdiLib, "institutInqLongnamePtr", _wrap_institutInqLongnamePtr, -1);

12170

rb_define_module_function(mCdiLib, "modelDef", _wrap_modelDef, -1);

12171

rb_define_module_function(mCdiLib, "modelInq", _wrap_modelInq, -1);

12172

rb_define_module_function(mCdiLib, "modelInqInstitut", _wrap_modelInqInstitut, -1);

12173

rb_define_module_function(mCdiLib, "modelInqGribID", _wrap_modelInqGribID, -1);

12174

rb_define_module_function(mCdiLib, "modelInqNamePtr", _wrap_modelInqNamePtr, -1);

12175

rb_define_module_function(mCdiLib, "tableWriteC", _wrap_tableWriteC, -1);

12176

rb_define_module_function(mCdiLib, "tableWrite", _wrap_tableWrite, -1);

12177

rb_define_module_function(mCdiLib, "tableRead", _wrap_tableRead, -1);

12178

rb_define_module_function(mCdiLib, "tableDef", _wrap_tableDef, -1);

12179

rb_define_module_function(mCdiLib, "tableInqNamePtr", _wrap_tableInqNamePtr, -1);

12180

rb_define_module_function(mCdiLib, "tableDefEntry", _wrap_tableDefEntry, -1);

12181

rb_define_module_function(mCdiLib, "tableInq", _wrap_tableInq, -1);

12182

rb_define_module_function(mCdiLib, "tableInqNumber", _wrap_tableInqNumber, -1);

12183

rb_define_module_function(mCdiLib, "tableInqNum", _wrap_tableInqNum, -1);

12184

rb_define_module_function(mCdiLib, "tableInqModel", _wrap_tableInqModel, -1);

12185

rb_define_module_function(mCdiLib, "tableInqPar", _wrap_tableInqPar, -1);

12186

rb_define_module_function(mCdiLib, "tableInqParCode", _wrap_tableInqParCode, -1);

12187

rb_define_module_function(mCdiLib, "tableInqParName", _wrap_tableInqParName, -1);

12188

rb_define_module_function(mCdiLib, "tableInqParLongname", _wrap_tableInqParLongname, -1);

12189

rb_define_module_function(mCdiLib, "tableInqParUnits", _wrap_tableInqParUnits, -1);

12190

rb_define_module_function(mCdiLib, "tableInqParNamePtr", _wrap_tableInqParNamePtr, -1);

12191

rb_define_module_function(mCdiLib, "tableInqParLongnamePtr", _wrap_tableInqParLongnamePtr, -1);

12192

rb_define_module_function(mCdiLib, "tableInqParUnitsPtr", _wrap_tableInqParUnitsPtr, -1);

12193

rb_define_module_function(mCdiLib, "streamDefHistory", _wrap_streamDefHistory, -1);

12194

rb_define_module_function(mCdiLib, "streamInqHistorySize", _wrap_streamInqHistorySize, -1);

12195

rb_define_module_function(mCdiLib, "streamInqHistoryString", _wrap_streamInqHistoryString, -1);

12196

}

12197

Older »