[OpenSPARC-T2-SAM] / sam-t2 / devtools / v9 / share / swig / 1.3.26 / python / pystrbase.swg

//
// Use the macro SWIG_PRESERVE_CARRAY_SIZE if you prefer to preserve
// the size of char arrays, ie
//  ------------------------------------------
//       C Side             =>   Python Side
//  ------------------------------------------
//   char name[5] = "hola"  =>   'hola\0'
//
// the default behaviour is 
//
//   char name[5] = "hola"  =>   'hola'
//
//
//#define SWIG_PRESERVE_CARRAY_SIZE

/* ------------------------------------------------------------
 *  String typemaps for type Char (char or wchar_t)
 * ------------------------------------------------------------ */

%define %typemap_pystring(Char,
			  SWIG_AsCharPtr,
			  SWIG_AsCharPtrAndSize,
			  SWIG_FromCharPtr,
			  SWIG_AsNewCharPtr,
			  SWIG_AsCharArray,
			  SWIG_FromCharArray)
/* in */

%typemap(in,fragment=#SWIG_AsCharPtr)
  Char *, Char const*, Char *const, Char const *const
  "if (!SWIG_AsCharPtr($input, (Char**)&$1)) {SWIG_arg_fail($argnum);SWIG_fail;}";

%typemap(in,fragment=#SWIG_AsCharPtr) 
  Char const*&, Char *const&, Char const *const & 
{
  $*ltype temp;
  if (!SWIG_AsCharPtr($input, (Char**)&temp)) {SWIG_arg_fail($argnum);SWIG_fail;}
  $1 = &temp;
}    

/* out */

%typemap(out,fragment=#SWIG_FromCharPtr)
  Char *, Char const*, Char *const, Char const *const
  "$result = SWIG_FromCharPtr($1);";

%typemap(out,fragment=#SWIG_FromCharPtr)
  Char *const &, Char const* &, Char const *const &
  "$result = SWIG_FromCharPtr(*$1);";

/* varin */

%typemap(varin,fragment=#SWIG_AsNewCharPtr) Char *
{
  Char *cptr = 0;
  if (!SWIG_AsNewCharPtr($input, &cptr)) {
    SWIG_append_errmsg("C/C++ variable '$name'");
    return 1;
  }
  if ($1) SWIG_delete_array($1);
  $1 = cptr;
}

%typemap(varin,fragment=#SWIG_AsNewCharPtr,
	 warning="451:Setting const Char * variable may leak memory") 
  const Char *
{
  Char *cptr;
  if (!SWIG_AsNewCharPtr($input, &cptr)) {    
    SWIG_append_errmsg("C/C++ variable '$name'");
    return 1;
  }
  $1 = cptr;
}

/* varout */

%typemap(varout,fragment=#SWIG_FromCharPtr)
  Char*, Char const*, Char *const, Char const *const
  "$result = SWIG_FromCharPtr($1);";

/* constant */

%typemap(constcode,fragment=#SWIG_FromCharPtr)
  Char *, Char const*, Char * const, Char const* const
  "PyDict_SetItemString(d,\"$symname\", SWIG_FromCharPtr($value));";

/* directorin */

%typemap(directorin,fragment=#SWIG_FromCharPtr)
  Char *, Char const*, Char *const, Char const *const, 
  Char const *&, Char *const &, Char const *const &
  "$input = SWIG_FromCharPtr($1_name);"; 

/* directorout */

%typemap(directorout,fragment=#SWIG_AsCharPtr)
  Char *, Char const*, Char *const, Char const* const
  "if (!$input || !SWIG_AsCharPtr($input, (Char**) &$result)) {
      Swig::DirectorTypeMismatchException(\"Error converting Python object into Char*\");
   }";

%typemap(directorout,fragment=#SWIG_AsCharPtr)
  Char const *&, Char *const &, Char const *const &
{ 
  Char* temp;
  if (!$input || !SWIG_AsCharPtr($input, &temp)) {
    Swig::DirectorTypeMismatchException("Error converting Python object into Char*");
  }
  $result = ($1_ltype) &temp;
}

/* typecheck */

%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING,
	 fragment=#SWIG_AsCharPtr) 
  Char *, Char const*, Char *const, Char const *const, 
  Char const*&, Char *const&, Char const *const & 
 "$1 = SWIG_AsCharPtr($input, (Char **)(0));";

/* throws */

%typemap(throws,fragment=#SWIG_FromCharPtr)
  Char *, Char const*, Char * const, Char const* const
{
  PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharPtr($1));
  SWIG_fail;
}


/* ------------------------------------------------------------
 *  Unknown size const Character array Char[ANY] handling
 * ------------------------------------------------------------ */

%apply Char* { Char [] };
%apply const Char* { const Char [] };

%typemap(varin,warning="462:Unable to set variable of type Char []") Char []
{
  PyErr_SetString(PyExc_AttributeError, "C/C++ variable '$name' is read-only");
  return 1;
}


/* ------------------------------------------------------------
 *  Fix size Character array Char[ANY] handling
 * ------------------------------------------------------------ */

/*  memberin and globalin typemaps  */

%typemap(memberin) Char [ANY]
{
  if ($input) memcpy($1,$input,$1_dim0*sizeof(Char));
  else memset($1,0,$1_dim0*sizeof(Char));
}

%typemap(globalin) Char [ANY]
{
  if ($input) memcpy($1,$input,$1_dim0*sizeof(Char));
  else memset($1,0,$1_dim0*sizeof(Char));
}

/* in */

%typemap(in,fragment=#SWIG_AsCharArray)
  Char [ANY] (Char temp[$1_dim0]), 
  const Char [ANY](Char temp[$1_dim0])
{  
  if (!SWIG_AsCharArray($input, temp, $1_dim0)) {SWIG_arg_fail($argnum);SWIG_fail;}
  $1 = temp;
}

%typemap(in,fragment=#SWIG_AsCharArray) const Char (&)[ANY] (Char temp[$1_dim0])
{  
  if (!SWIG_AsCharArray($input, temp, $1_dim0)) {SWIG_arg_fail($argnum);SWIG_fail;}
  $1 = &temp;
}

%typemap(out,fragment=#SWIG_FromCharArray)
  Char [ANY], const Char[ANY] 
{
  size_t size = $1_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
  while (size && ($1[size - 1] == '\0')) --size;
%#endif
  $result = SWIG_FromCharArray($1, size);
}

/* varin */

%typemap(varin,fragment=#SWIG_AsCharArray) Char [ANY]
{
  if (!SWIG_AsCharArray($input, $1, $1_dim0)) {
    SWIG_append_errmsg("C/C++ variable '$name'");
    return 1;
  }
}

/* varout */

%typemap(varout,fragment=#SWIG_FromCharArray)
  Char [ANY], const Char [ANY] 
{
  size_t size = $1_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
  while (size && ($1[size - 1] == '\0')) --size;
%#endif
  $result = SWIG_FromCharArray($1, size);
}

/* constants */

%typemap(constcode,fragment=#SWIG_FromCharArray)
  Char [ANY], const Char [ANY]
{
  size_t size = $value_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
  while (size && ($value[size - 1] == '\0')) --size;
%#endif
  PyDict_SetItemString(d,"$symname", SWIG_FromCharArray($value,size));
}

/* directorin */

%typemap(directorin,fragment=#SWIG_FromCharArray)
  Char [ANY], const Char [ANY] 
{
  size_t size = $1_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
  while (size && ($1_name[size - 1] == '\0')) --size;
%#endif
  $input = SWIG_FromCharArray($1_name, size);
}

/* directorout */

%typemap(directorout,fragment=#SWIG_AsCharArray)
  Char [ANY], const Char [ANY] (Char temp[$result_dim0])
{ 
  if (!$input || !SWIG_AsCharArray($input, temp, $result_dim0)) {
    Swig::DirectorTypeMismatchException("Error converting Python object into Char[$result_dim0]");
  }
  $result = temp;
}

/* typecheck */

%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING,
	 fragment=#SWIG_AsCharArray)  
  Char [ANY], const Char[ANY]
  "$1 = SWIG_AsCharArray($input, (Char *)0, $1_dim0);";

/* throws */

%typemap(throws,fragment=#SWIG_FromCharArray)
  Char [ANY], const Char[ANY]
{
  size_t size = $1_dim0;
%#ifndef SWIG_PRESERVE_CARRAY_SIZE
  while (size && ($1[size - 1] == '\0')) --size;
%#endif
  PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharArray($1, size));
  SWIG_fail;
}

/* -------------------------------------------------------------------
 * --- Really fix size Char arrays, including '\0'chars at the end ---
 * ------------------------------------------------------------------- */

%typemap(varout,fragment=#SWIG_FromCharArray)
  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
{
  size_t size = $1_dim0;
  $result = SWIG_FromCharArray($1, size);
}

%typemap(out,fragment=#SWIG_FromCharArray)
  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
{
  size_t size = $1_dim0;
  $result = SWIG_FromCharArray($1, size);
}

%typemap(constcode,fragment=#SWIG_FromCharArray)
  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
{
  size_t size = $value_dim0;
  PyDict_SetItemString(d,"$symname", SWIG_FromCharArray($value,size));
}

%typemap(directorin,fragment=#SWIG_FromCharArray)
  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
{
  size_t size = $1_dim0;
  $input = SWIG_FromCharArray($1_name, size);
}

%typemap(throws,fragment=#SWIG_FromCharArray)
  Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
{
  size_t size = $1_dim0;
  PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharArray($1, size));
  SWIG_fail;
}

/* ------------------------------------------------------------
 * --- String & length ---
 * ------------------------------------------------------------ */

/* Here len doesn't include the '0' terminator */
%typemap(in, fragment=#SWIG_AsCharPtrAndSize) 
  (Char *STRING, int LENGTH) (Char *buf, size_t size)
{
  SWIG_AsCharPtrAndSize($input, &buf, &size);
  if (SWIG_arg_fail($argnum)) SWIG_fail;
  $1 = ($1_ltype) buf;
  $2 = ($2_ltype) size - 1;
}

/* Here size includes the '0' terminator */
%typemap(in,fragment=#SWIG_AsCharPtrAndSize)
  (Char *STRING, int SIZE) (Char *buf, size_t size)
{
  SWIG_AsCharPtrAndSize($input, &buf, &size);
  if (SWIG_arg_fail($argnum)) SWIG_fail;
  $1 = ($1_ltype) buf;
  $2 = ($2_ltype) size;
}

%enddef
Commit	Line	Data
920dae64 AT	1	//
	2	// Use the macro SWIG_PRESERVE_CARRAY_SIZE if you prefer to preserve
	3	// the size of char arrays, ie
	4	// ------------------------------------------
	5	// C Side => Python Side
	6	// ------------------------------------------
	7	// char name[5] = "hola" => 'hola\0'
	8	//
	9	// the default behaviour is
	10	//
	11	// char name[5] = "hola" => 'hola'
	12	//
	13	//
	14	//#define SWIG_PRESERVE_CARRAY_SIZE
	15
	16	/* ------------------------------------------------------------
	17	* String typemaps for type Char (char or wchar_t)
	18	* ------------------------------------------------------------ */
	19
	20	%define %typemap_pystring(Char,
	21	SWIG_AsCharPtr,
	22	SWIG_AsCharPtrAndSize,
	23	SWIG_FromCharPtr,
	24	SWIG_AsNewCharPtr,
	25	SWIG_AsCharArray,
	26	SWIG_FromCharArray)
	27	/* in */
	28
	29	%typemap(in,fragment=#SWIG_AsCharPtr)
	30	Char , Char const, Char const, Char const const
	31	"if (!SWIG_AsCharPtr($input, (Char**)&$1)) {SWIG_arg_fail($argnum);SWIG_fail;}";
	32
	33	%typemap(in,fragment=#SWIG_AsCharPtr)
	34	Char const&, Char const&, Char const *const &
	35	{
	36	$*ltype temp;
	37	if (!SWIG_AsCharPtr($input, (Char**)&temp)) {SWIG_arg_fail($argnum);SWIG_fail;}
	38	$1 = &temp;
	39	}
	40
	41	/* out */
	42
	43	%typemap(out,fragment=#SWIG_FromCharPtr)
	44	Char , Char const, Char const, Char const const
	45	"$result = SWIG_FromCharPtr($1);";
	46
	47	%typemap(out,fragment=#SWIG_FromCharPtr)
	48	Char const &, Char const &, Char const *const &
	49	"$result = SWIG_FromCharPtr(*$1);";
	50
	51	/* varin */
	52
	53	%typemap(varin,fragment=#SWIG_AsNewCharPtr) Char *
	54	{
	55	Char *cptr = 0;
	56	if (!SWIG_AsNewCharPtr($input, &cptr)) {
	57	SWIG_append_errmsg("C/C++ variable '$name'");
	58	return 1;
	59	}
	60	if ($1) SWIG_delete_array($1);
	61	$1 = cptr;
	62	}
	63
	64	%typemap(varin,fragment=#SWIG_AsNewCharPtr,
65	warning="451:Setting const Char * variable may leak memory")
66	const Char *
67	{
68	Char *cptr;
69	if (!SWIG_AsNewCharPtr($input, &cptr)) {
70	SWIG_append_errmsg("C/C++ variable '$name'");
71	return 1;
72	}
73	$1 = cptr;
74	}
75
76	/* varout */
77
78	%typemap(varout,fragment=#SWIG_FromCharPtr)
79	Char, Char const, Char const, Char const const
80	"$result = SWIG_FromCharPtr($1);";
81
82	/* constant */
83
84	%typemap(constcode,fragment=#SWIG_FromCharPtr)
85	Char , Char const, Char * const, Char const* const
86	"PyDict_SetItemString(d,\"$symname\", SWIG_FromCharPtr($value));";
87
88	/* directorin */
89
90	%typemap(directorin,fragment=#SWIG_FromCharPtr)
91	Char , Char const, Char const, Char const const,
92	Char const &, Char const &, Char const *const &
93	"$input = SWIG_FromCharPtr($1_name);";
94
95	/* directorout */
96
97	%typemap(directorout,fragment=#SWIG_AsCharPtr)
98	Char , Char const, Char const, Char const const
99	"if (!$input \|\| !SWIG_AsCharPtr($input, (Char**) &$result)) {
100	Swig::DirectorTypeMismatchException(\"Error converting Python object into Char*\");
101	}";
102
103	%typemap(directorout,fragment=#SWIG_AsCharPtr)
104	Char const &, Char const &, Char const *const &
105	{
106	Char* temp;
107	if (!$input \|\| !SWIG_AsCharPtr($input, &temp)) {
108	Swig::DirectorTypeMismatchException("Error converting Python object into Char*");
109	}
110	$result = ($1_ltype) &temp;
111	}
112
113	/* typecheck */
114
115	%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING,
116	fragment=#SWIG_AsCharPtr)
117	Char , Char const, Char const, Char const const,
118	Char const&, Char const&, Char const *const &
119	"$1 = SWIG_AsCharPtr($input, (Char **)(0));";
120
121	/* throws */
122
123	%typemap(throws,fragment=#SWIG_FromCharPtr)
124	Char , Char const, Char * const, Char const* const
125	{
126	PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharPtr($1));
127	SWIG_fail;
128	}
129
130
131	/* ------------------------------------------------------------
132	* Unknown size const Character array Char[ANY] handling
133	* ------------------------------------------------------------ */
134
135	%apply Char* { Char [] };
136	%apply const Char* { const Char [] };
137
138	%typemap(varin,warning="462:Unable to set variable of type Char []") Char []
139	{
140	PyErr_SetString(PyExc_AttributeError, "C/C++ variable '$name' is read-only");
141	return 1;
142	}
143
144
145	/* ------------------------------------------------------------
146	* Fix size Character array Char[ANY] handling
147	* ------------------------------------------------------------ */
148
149	/* memberin and globalin typemaps */
150
151	%typemap(memberin) Char [ANY]
152	{
153	if ($input) memcpy($1,$input,$1_dim0*sizeof(Char));
154	else memset($1,0,$1_dim0*sizeof(Char));
155	}
156
157	%typemap(globalin) Char [ANY]
158	{
159	if ($input) memcpy($1,$input,$1_dim0*sizeof(Char));
160	else memset($1,0,$1_dim0*sizeof(Char));
161	}
162
163	/* in */
164
165	%typemap(in,fragment=#SWIG_AsCharArray)
166	Char [ANY] (Char temp[$1_dim0]),
167	const Char [ANY](Char temp[$1_dim0])
168	{
169	if (!SWIG_AsCharArray($input, temp, $1_dim0)) {SWIG_arg_fail($argnum);SWIG_fail;}
170	$1 = temp;
171	}
172
173	%typemap(in,fragment=#SWIG_AsCharArray) const Char (&)[ANY] (Char temp[$1_dim0])
174	{
175	if (!SWIG_AsCharArray($input, temp, $1_dim0)) {SWIG_arg_fail($argnum);SWIG_fail;}
176	$1 = &temp;
177	}
178
179	%typemap(out,fragment=#SWIG_FromCharArray)
180	Char [ANY], const Char[ANY]
181	{
182	size_t size = $1_dim0;
183	%#ifndef SWIG_PRESERVE_CARRAY_SIZE
184	while (size && ($1[size - 1] == '\0')) --size;
185	%#endif
186	$result = SWIG_FromCharArray($1, size);
187	}
188
189	/* varin */
190
191	%typemap(varin,fragment=#SWIG_AsCharArray) Char [ANY]
192	{
193	if (!SWIG_AsCharArray($input, $1, $1_dim0)) {
194	SWIG_append_errmsg("C/C++ variable '$name'");
195	return 1;
196	}
197	}
198
199	/* varout */
200
201	%typemap(varout,fragment=#SWIG_FromCharArray)
202	Char [ANY], const Char [ANY]
203	{
204	size_t size = $1_dim0;
205	%#ifndef SWIG_PRESERVE_CARRAY_SIZE
206	while (size && ($1[size - 1] == '\0')) --size;
207	%#endif
208	$result = SWIG_FromCharArray($1, size);
209	}
210
211	/* constants */
212
213	%typemap(constcode,fragment=#SWIG_FromCharArray)
214	Char [ANY], const Char [ANY]
215	{
216	size_t size = $value_dim0;
217	%#ifndef SWIG_PRESERVE_CARRAY_SIZE
218	while (size && ($value[size - 1] == '\0')) --size;
219	%#endif
220	PyDict_SetItemString(d,"$symname", SWIG_FromCharArray($value,size));
221	}
222
223	/* directorin */
224
225	%typemap(directorin,fragment=#SWIG_FromCharArray)
226	Char [ANY], const Char [ANY]
227	{
228	size_t size = $1_dim0;
229	%#ifndef SWIG_PRESERVE_CARRAY_SIZE
230	while (size && ($1_name[size - 1] == '\0')) --size;
231	%#endif
232	$input = SWIG_FromCharArray($1_name, size);
233	}
234
235	/* directorout */
236
237	%typemap(directorout,fragment=#SWIG_AsCharArray)
238	Char [ANY], const Char [ANY] (Char temp[$result_dim0])
239	{
240	if (!$input \|\| !SWIG_AsCharArray($input, temp, $result_dim0)) {
241	Swig::DirectorTypeMismatchException("Error converting Python object into Char[$result_dim0]");
242	}
243	$result = temp;
244	}
245
246	/* typecheck */
247
248	%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING,
249	fragment=#SWIG_AsCharArray)
250	Char [ANY], const Char[ANY]
251	"$1 = SWIG_AsCharArray($input, (Char *)0, $1_dim0);";
252
253	/* throws */
254
255	%typemap(throws,fragment=#SWIG_FromCharArray)
256	Char [ANY], const Char[ANY]
257	{
258	size_t size = $1_dim0;
259	%#ifndef SWIG_PRESERVE_CARRAY_SIZE
260	while (size && ($1[size - 1] == '\0')) --size;
261	%#endif
262	PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharArray($1, size));
263	SWIG_fail;
264	}
265
266	/* -------------------------------------------------------------------
267	* --- Really fix size Char arrays, including '\0'chars at the end ---
268	* ------------------------------------------------------------------- */
269
270	%typemap(varout,fragment=#SWIG_FromCharArray)
271	Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
272	{
273	size_t size = $1_dim0;
274	$result = SWIG_FromCharArray($1, size);
275	}
276
277	%typemap(out,fragment=#SWIG_FromCharArray)
278	Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
279	{
280	size_t size = $1_dim0;
281	$result = SWIG_FromCharArray($1, size);
282	}
283
284	%typemap(constcode,fragment=#SWIG_FromCharArray)
285	Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
286	{
287	size_t size = $value_dim0;
288	PyDict_SetItemString(d,"$symname", SWIG_FromCharArray($value,size));
289	}
290
291	%typemap(directorin,fragment=#SWIG_FromCharArray)
292	Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
293	{
294	size_t size = $1_dim0;
295	$input = SWIG_FromCharArray($1_name, size);
296	}
297
298	%typemap(throws,fragment=#SWIG_FromCharArray)
299	Char FIXSIZE[ANY], const Char FIXSIZE[ANY]
300	{
301	size_t size = $1_dim0;
302	PyErr_SetObject(PyExc_RuntimeError, SWIG_FromCharArray($1, size));
303	SWIG_fail;
304	}
305
306	/* ------------------------------------------------------------
307	* --- String & length ---
308	* ------------------------------------------------------------ */
309
310	/* Here len doesn't include the '0' terminator */
311	%typemap(in, fragment=#SWIG_AsCharPtrAndSize)
312	(Char STRING, int LENGTH) (Char buf, size_t size)
313	{
314	SWIG_AsCharPtrAndSize($input, &buf, &size);
315	if (SWIG_arg_fail($argnum)) SWIG_fail;
316	$1 = ($1_ltype) buf;
317	$2 = ($2_ltype) size - 1;
318	}
319
320	/* Here size includes the '0' terminator */
321	%typemap(in,fragment=#SWIG_AsCharPtrAndSize)
322	(Char STRING, int SIZE) (Char buf, size_t size)
323	{
324	SWIG_AsCharPtrAndSize($input, &buf, &size);
325	if (SWIG_arg_fail($argnum)) SWIG_fail;
326	$1 = ($1_ltype) buf;
327	$2 = ($2_ltype) size;
328	}
329
330	%enddef