
- Regarding the slirptypes.c array

	static Reserved_Opaque_Type Reserved_Opaque_Types[]

  /* In principle this list could be sorted by SLtype value, in order */
  /* to speed traversals with bsearch.  However, since SLtype values  */
  /* may change in new releases of S-Lang that would be fragile.  So, */
  /* instead we ordered by expected frequency of use for each SLtype. */

  Also, it must be kept in sync with the _define_reserved_opaque block()
  of definitions w/in slirpmaps.sl.

- slang_abi_mismatch():  since slirp requires 1.4.9 or greater, and slang1
  is nearly finished, it is sufficient to merely check slang1 vs. slang2.
  when slang2 abi incompatible releases emerge i will try to convince JED
  to include something like slang_abi_version for users to distinguish.

- S-Lang is statically linked into slirpsh, historically to avoid multiple
  defines (mainly on Mac OS/X) which result from its inclusion of slprepr.c;
  this file was bundled so as to add the necessary 2-3 lines of code which 
  enable callbacks, but since the switch to a custom file loader this
  approach is no longer necessary.

- Random thoughts on vectorization:

	- Should it be permitted only for scalar function args?

	- EITHER

		ALL input vectors must be of equal length
	  OR 
		call loop iterates for length of shortest vector

	  In either case, however, it should be legal to intersperse
	  scalar args with vectors in a call to a vectorized func.

	- See opengl folder for comments on why simply vectorizing funcs like

			glVertex3f()

	  is probably not enough for OpenGL, since additional state may be
	  interspersed, by other calls, such as glColor3f(), while iterating
	  through the "vertex loop"

	- Possible approaches:

		#argmap(in, vec=[1,3]) (double *, int, double *)
		#end

		#argmap(in) (double *VECTORIZE, int i, double *VECTORIZE)
		#end

		#vectorize(which=[1,3]) (double *, int, double *)
		#end
		(essentially synonymous with the first, but cleaner)

	- Look at Doug's comments on how PDL vectorizes funcs for Perl
	  UPDATE:

	  Have reviewed the document, but not finished yet.  It was useful
	  to remind me that I should think about how to handle collapsing
	  over multi-dimensional arrays.  For example, given

		a = Double_Type[3,5]
		a[0,*] = [1,2,3,4,5]
		a[1,*] = 2*[1,2,3,4,5]
		a[2,*] = 3*[1,2,3,4,5]

	  then
		sum(a)	= 90
		sum(a,0) = [6, 12, 18, 24, 30]
		sum(a,1) = [15, 30, 45]

- Named argmaps:  it might be useful to add a name="" qualifier, so that

     #argmap(in, name="dv_i_dv") (double *VECTORIZE, int i, double *VECTORIZE)

  could be copied/applied to other mappings by name, such as

   #copy dv_i_dv {float *, int i, float *}
