Examples/ruby/variables/index.html - third_party/swig - Git at Google

 <html>
 <head>
 <title>SWIG:Examples:ruby:variables</title>
 </head>

 <body bgcolor="#ffffff">

 <tt>SWIG/Examples/ruby/variables/</tt>
 <hr>

 <H2>Wrapping C Global Variables</H2>

 <p>
 When a C global variable appears in an interface file, SWIG tries to
 wrap it using a technique known as "variable linking."  The idea is
 pretty simple---we try to create a Ruby variable (actually module method) that
 magically retrieves or updates the value of the underlying C variable when it is
 accessed.  Click <a href="example.i">here</a> to see a SWIG interface with some variable
 declarations in it.

 <h2>Manipulating Variables from Ruby</h2>

 Before going any further, it is important to understand some important
 differences between C and Ruby variables.  In C, a variable is
 simply a name that refers to a specific location in memory.  For
 example, when you declare a global variable '<tt>double a</tt>' you
 know that somewhere in memory, 8 bytes have been set aside to hold a
 <tt>double</tt> and that <tt>a</tt> is bound to this location for the
 life of the program.  In Ruby, variable creation is nothing more
 than a naming operation.  For example, when you say '<tt>a = 3</tt>',
 'a' becomes a name that refers to some object '3'.  Later on, if you say
 '<tt>a = 7.5</tt>, the name 'a' is bound to an entirely different object
 containing the value '7.5' (the contents of the original object are not
 changed).  The end result of this is that a variable in Ruby can refer
 to a virtually unlimited number of different objects (memory locations)
 over the lifetime of a program.

 <p>
 Because of Ruby's somewhat unusual variable assignment semantics, it is not
 possible to directly link a C global variable into an equivalent Ruby variable.
 Instead, all C global variables are accessed as attributes of the module.
 For example, if you had a global variable

 <blockquote>
 <pre>
 double foo;
 </pre>
 </blockquote>

 it will be accessed in the Ruby module as <tt>Example.foo</tt>. Click
 <a href="runme.rb">here</a> to see a script that updates and prints
 out the values of the variables using this technique.

 <h2>Key points</h2>

 <ul>
 <li>When a global variable has the type "<tt>char *</tt>", SWIG manages it as a character
 string.   However, whenever the value of such a variable is set from Ruby, the old
 value is destroyed using <tt>free()</tt>.
 <li><tt>signed char</tt> and <tt>unsigned char</tt> are handled as small 8-bit integers.
 <li>String array variables such as '<tt>char name[256]</tt>' are managed as Ruby strings, but
 when setting the value, the result is truncated to the maximum length of the array.  Furthermore, the string is assumed to be null-terminated.
 <li>When structures and classes are used as global variables, they are mapped into pointers.
 Getting the "value" returns a pointer to the global variable.  Setting the value of a structure results in a memory copy from a pointer to the global.
 </ul>

 <h2>Creating read-only variables</h2>

 The <tt>%immutable</tt> and <tt>%mutable</tt> directives can be used to
 specify a collection of read-only variables.  For example:

 <blockquote>
 <pre>
 %immutable;
 int    status;
 double blah;
 ...
 %mutable;
 </pre>
 </blockquote>

 The <tt>%immutable</tt> directive remains in effect until it is explicitly disabled
 using the <tt>%mutable</tt> directive.

 <h2>Comments</h2>
 <ul>
 <li>Management of global variables is one of the most problematic aspects
 of C/C++ wrapping because the scripting interface and resulting memory management
 is much trickier than simply creating a wrapper function.
 </ul>

 </body>
 </html>
 <hr>
	<html>
	<head>
	<title>SWIG:Examples:ruby:variables</title>
	</head>

	<body bgcolor="#ffffff">

	<tt>SWIG/Examples/ruby/variables/</tt>
	<hr>

	<H2>Wrapping C Global Variables</H2>

	<p>
	When a C global variable appears in an interface file, SWIG tries to
	wrap it using a technique known as "variable linking." The idea is
	pretty simple---we try to create a Ruby variable (actually module method) that
	magically retrieves or updates the value of the underlying C variable when it is
	accessed. Click <a href="example.i">here</a> to see a SWIG interface with some variable
	declarations in it.

	<h2>Manipulating Variables from Ruby</h2>

	Before going any further, it is important to understand some important
	differences between C and Ruby variables. In C, a variable is
	simply a name that refers to a specific location in memory. For
	example, when you declare a global variable '<tt>double a</tt>' you
	know that somewhere in memory, 8 bytes have been set aside to hold a
	<tt>double</tt> and that <tt>a</tt> is bound to this location for the
	life of the program. In Ruby, variable creation is nothing more
	than a naming operation. For example, when you say '<tt>a = 3</tt>',
	'a' becomes a name that refers to some object '3'. Later on, if you say
	'<tt>a = 7.5</tt>, the name 'a' is bound to an entirely different object
	containing the value '7.5' (the contents of the original object are not
	changed). The end result of this is that a variable in Ruby can refer
	to a virtually unlimited number of different objects (memory locations)
	over the lifetime of a program.

	<p>
	Because of Ruby's somewhat unusual variable assignment semantics, it is not
	possible to directly link a C global variable into an equivalent Ruby variable.
	Instead, all C global variables are accessed as attributes of the module.
	For example, if you had a global variable

	<blockquote>
	<pre>
	double foo;
	</pre>
	</blockquote>

	it will be accessed in the Ruby module as <tt>Example.foo</tt>. Click
	<a href="runme.rb">here</a> to see a script that updates and prints
	out the values of the variables using this technique.

	<h2>Key points</h2>

	<ul>
	<li>When a global variable has the type "<tt>char *</tt>", SWIG manages it as a character
	string. However, whenever the value of such a variable is set from Ruby, the old
	value is destroyed using <tt>free()</tt>.
	<li><tt>signed char</tt> and <tt>unsigned char</tt> are handled as small 8-bit integers.
	<li>String array variables such as '<tt>char name[256]</tt>' are managed as Ruby strings, but
	when setting the value, the result is truncated to the maximum length of the array. Furthermore, the string is assumed to be null-terminated.
	<li>When structures and classes are used as global variables, they are mapped into pointers.
	Getting the "value" returns a pointer to the global variable. Setting the value of a structure results in a memory copy from a pointer to the global.
	</ul>

	<h2>Creating read-only variables</h2>

	The <tt>%immutable</tt> and <tt>%mutable</tt> directives can be used to
	specify a collection of read-only variables. For example:

	<blockquote>
	<pre>
	%immutable;
	int status;
	double blah;
	...
	%mutable;
	</pre>
	</blockquote>

	The <tt>%immutable</tt> directive remains in effect until it is explicitly disabled
	using the <tt>%mutable</tt> directive.

	<h2>Comments</h2>
	<ul>
	<li>Management of global variables is one of the most problematic aspects
	of C/C++ wrapping because the scripting interface and resulting memory management
	is much trickier than simply creating a wrapper function.
	</ul>

	</body>
	</html>
	<hr>