news

This Source-Navigator, an IDE for C/C++/Fortran/Java/Tcl/PHP/Python and a host of other languages.

$Header: /cvsroot/sourcenav/src/snavigator/demo/c++_demo/NEWS,v 1.1.1.1 2002/04/18 23:35:10 mdejong Exp $

Glish changes
=============

10Mar95:
	- 2.5.0 release.  You must recompile and relink your present
	  Glish clients.  To build Glish 2.5, you need flex 2.4.6 or higher
	  (current is 2.4.7), which you can get from ftp.ee.lbl.gov.  The
	  Glish installation has changed considerably - see README.

	- Glish now runs under SunOS, IRIX, HP-UX, Solaris, and AIX.

	- Included in the Glish distribution is a "contrib/" directory
	  containing contributed (but not supported) Glish clients.
	  Presently, contrib/ includes a Glish <-> Tcl/TK interface,
	  a Glish <-> Perl 5.0 interface, and a (fledgling) Glish <-> EPICS
	  interface.

	- Four new types have been added: byte (unsigned integer in the
	  range 0 .. 255), short, complex, and dcomplex (double-precision
	  complex).  The first two were contributed by Chris Saltmarsh,
	  the last two by Darrell Schiebel.  To create a byte or short
	  value, use as_byte(x) or as_short(x) for some integer x.
	  dcomplex constants are specified using the same notation as in S:

		5 + 3i
		6-2.93i
		3.14i

	  all specify double-precision complex constants.  To create a
	  single-precision complex value, use as_complex(x).  The function
	  complex(r,i) returns a complex/dcomplex value whose real parts are
	  taken from the vector 'r' and imaginary parts from 'i'.  The four
	  new types are all "numeric" and support the usual numeric operations
	  (with the complex operators patterned after S).  Type promotion
	  is now ordered as: bool, byte, short, integer, float, double,
	  complex, dcomplex, except that mixing double with complex promotes
	  to dcomplex.  The real part of an imaginary value is retrieved
	  using the real(z) function, and the imaginary part using imag(z).

	- A general framework of "attributes" associated with a value has
	  been contributed by Darrell Schiebel.  A value's attributes are
	  accessed using the "::" operator.  For example,

		a::foo := 1:3

	  assigns [1, 2, 3] to a's "foo" attribute (regardless of a's type).
	  Then executing

		a::bar := a::foo * 2

	  would assign [2, 4, 6] to a's "bar" attribute.  A value's attributes
	  are themselves a record value (whose elements might also have
	  attributes).  To assign all of a value's attributes:

		a:: := [foo=1:3, bar=(1:3)*2]

	  and to access the record directly, just use the expression "a::".
	  When values with attributes are operated on, the attributes of the
	  operand (if a unary operator) or the longer operand (binary operator)
	  are propagated to the result.

	- Using these attributes, Darrell has also added multi-dimensional
	  arrays (Darrell's been busy!).  In Glish, all values are
	  intrinsically one-dimensional arrays (which are now referred to
	  as "vectors").  This underlying vector however can be intrepreted
	  as a multi-dimensional array by associating a "shape" attribute
	  with the value.  Thus,

		a := 1:9
		a::shape := [3,3]

	  associates with a's vector a shape of a 3x3 array.  Printing 'a'
	  at this point yields:

		[[1:3,]
		    1 4 7
		    2 5 8
		    3 6 9]

	  The first row reports the portion of the array being printed.

	  Arrays are created using the array() function, which takes
	  as its first argument a value whose vector is used for the
	  initial array elements, and whose remaining values give the
	  dimensions of the array.  For example, we could have created 'a'
	  using:

		a := array(1:9,3,3)

	  As discussed above concerning propagation of attributes, operating
	  on arrays preserves their dimensionality.  Arrays of different
	  shape but the same number of elements can be mixed in operations;
	  the result has the shape of the lefthand operand.

	  Arrays can be indexed in several ways.  As before, a boolean index
	  serves as a mask for selecting array elements.  Arrays can also
	  be indexed using multiple subscripts:

		a[2,1]

	  yields 2,

		a[1:2,2:3]

	  yields

		[[1:2,]
		    4 7
		    5 8]

	  while

		a[2:3,]

	  yields

		[[1:2,]
		    2 5 8
		    3 6 9]

	  and

		a[,1:2]

	  yields

		[[1:3,]
		    1 4
		    2 5
		    3 6]

	  Arrays can also be indexed using another array with as many
	  columns as 'a' has dimensions.  This operation is referred to
	  as a "pick".  Each row in the index array specifies a single
	  element from 'a'.  For example, given

		d := array([1,2,2,3],2,2)

	  then a[d] selects a[1,2] and a[2,3], yielding [4, 8].

	- Glish now supports "subreferences" to portions of arrays.  For
	  example,

		a := [1, 3, 5, 7, 9, 11, 13]
		b := ref a[[2, 6]]

	  associates 'b' with the 2nd and 6th element of 'a'.  This association
	  lasts until either 'a' or 'b' is assigned to.  Assigning to elements
	  of 'a' or 'b', though, preserves the connection.  For example,

		b[2] := 14

	  changes the value of 'a' to [1, 3, 5, 7, 9, 14, 13].  Subreferences
	  also work with multi-dimensional arrays.  Subreferences were
	  contributed by Darrell Schiebel.

	- Glish is now configured using an autoconf-generated "configure"
	  script.  This means to build Glish, you go to the top level
	  directory and type "./configure".  The script then generates
	  Makefile (from Makefile.in) and config.h (from config.h.in)
	  files, which contain all of the system dependencies for your
	  environment.  The SDS library has not yet been converted to
	  autoconf, nor has the new editline library (see below), though
	  they use it for minor configuration issues such as which C compiler
	  to use.

	- When run interactively, Glish now uses the "editline" library
	  written by Simmule Turner and Rich Salz, and integrated into
	  Glish by Darrell Schiebel.  Editline lets you do emacs-style
	  line editing on the text you type to the Glish interpreter,
	  similar to "tcsh".  If for some reason you don't want to use
	  editline (or it doesn't built for your system), you can turn
	  off its use by undefining USE_EDITLINE in glish/input.h.

	- The new prod(...) function returns the scalar product of its
	  arguments, analogous to the existing sum(...) function.  (DS)

	- The new missing() function returns a boolean vector which is T
	  if the corresponding argument (numbered from left to right) was
	  missing in the present call to the function (and thus took on
	  its default value), or F if the argument was explicitly passed. (DS)

	- In conjunction with this missing() function, you can now omit
	  positional arguments in function calls.  E.g., foo(1,,,5).

	- The length() function now returns a vector of the lengths
	  of its arguments.  So length(1:5, 2:20) returns [5, 19]. (DS)

	- rep() can now be called with non-scalar arguments. (DS)

	- min(), max(), and range() are now correctly documented to operate
	  on an arbitrary number of arguments.

	- The sync(c) function can be called to synchronize the Glish
	  script's execution with that of client 'c'.  The call does not
	  return until client 'c' has processed all events/requests previously
	  sent to it.

	- The sort(x) function returns the vector x sorted into ascending
	  order.  x's type must be either numeric or string.  (This function
	  is written entirely in Glish, by the way.)

	- sort_pair(x,y) rearranges the elements of y to reflect the order
	  of the elements of x (x and y must have the same length).  For
	  example, sort_pair([3,1,2], "a b c") returns "b c a", since "b"
	  was paired with the smallest element of [3,1,2], "c" with the
	  second smallest, and "a" with the largest.

	- order(x) returns the indices of the sorted elements of x.  So,
	  for example, x[order(x)] == sort(x).

	- The precedence of the val/ref/const operators has been changed.
	  It used to be very low, and now is very high (equivalent to the
	  '!' operator).  This fixes a bug in grouping
		val a := 5
	  as
		val (a := 5)

	- The "glish.init" startup Glish script is now compiled into the
	  Glish interpreter, and no longer needs to be located at run-time.
	  Related to this, the $glish_init environment variable is no longer
	  used to locate an alternative glish.init file at run-time.

	- The SDS library has been heavily modified, courtesy of Chris
	  Saltmarsh and Todd Satogata.  The main changes are improved
	  buffering and bug fixes.

	- A new member function, Client::Error(const char* msg), is available
	  for Glish clients to post an "error" event.  There is also a version
	  that formats its message using a single string argument,
	  Client::Error(const char* fmt, const char* arg).  Eventually these
	  routines will correctly indicate errors for request/reply events,
	  but at present they don't.

	- Client::AddInputMask now returns the number of new input fd's
	  it added to the mask.

	- Client::HasSequencerConnection() is deprecated; use
	  Client::HasInterpreterConnection() instead.

	- A new member function Client::PostEvent(const char* event_name,
	  const char* event_fmt, const char* arg1, conts char* arg2), posts
	  an event with the given name and a printf-format taking two
	  string arguments.

	- A new member function Client::ReplyPending() returns true if the
	  client has a request/reply pending and false otherwise.

	- You can now call Client::PostEvent with a nil Value pointer for the
	  event's value, if you know the value will be ignored.

	- The GlishEvent class has been spruced up a bit, and now supports
	  a member function IsRequest() which returns true if the event was
	  a request and false otherwise.

	- If a Glish client is fired up standalone (from a shell instead
	  of via Glish), by default it now considers itself to not have
	  any event source.  Calls to NextEvent() will return nil, and
	  calls to PostEvent() will simply discard the posted events.  To
	  force the client to use stdin as its event source and stdout
	  as its event sink, run it with "-glish" as the first argument.

	- The "bool" C++ type has been changed to "glish_bool" to avoid
	  conflicts with ANSI C++, which has a builtin "bool" type.  A
	  number of Value and Client member functions that used to have
	  bool operands now have int operands instead.

	- The abbreviations of "true" and "false" for "glish_true" and
	  "glish_false" have been removed, due to conflict with ANSI C++.

	- Value::FieldVal( const char field[], charptr& val ) is now
	  correctly typed as FieldVal( const char field[], char*& val ),
	  reflecting the fact that the caller should delete val when
	  done with it.

	- The C language Glish client interface is no longer supported.

	- Glish now builds with flex 2.4.7.

	- A bug was fixed in using boolean values in arithmetic operations.

	- A bug was fixed in recognizing "established" events from clients
	  running on the same host as the Glish interpreter.

	- Some minor memory leaks have been fixed.


23Aug93:
	- 2.4.1 release.  If you relink a Glish client to the libglish.a
	  of this release, then you *must* also recompile any of the
	  client's sources that create Client objects (because they've
	  changed in size).

	- A new overview paper, "Glish: A Software Bus for High-Level
	  Control", is available in doc/ICALEPCS-93.ps.  It is slanted
	  towards using Glish for accelerator control (rather than as
	  a general software bus).

	- Glish now has a mechanism for synchronous request/reply events:

		result := request a->b( 1:10 )

	  sends a "b" event to "a" with value 1:10 and then waits for "a" to
	  reply.  The value of a's reply is stored in "result".  Note that
	  "request" is a new keyword, which may cause incompatibilities
	  (syntax errors) with existing scripts that have variables with
	  that name.

	  "a" must be a Glish client (not a user agent such as a subsequence).
	  The client responds to a request using the Client::Reply member
	  function (it is up to the client to know which of the different
	  events it receives correspond to request/reply).  Glish generates
	  a warning if the client first generates any other event (i.e., by
	  using Client::PostEvent) or if Client::Reply is used when a request
	  is not pending.  Presently, when a request/reply is active no other
	  events are read by the Glish interpreter until the reply is received;
	  perhaps this will change in the future, as we understand request/
	  reply usage better.  Another possible future change is the addition
	  of a timeout.

	  See the Glish User Manual for details.

	- The "event-send" statement now takes an optional "send" keyword.
	  That is, you can write

		foo->bar( args )

	  instead as

		send foo->bar( args )

	  The belief is that using "send" will lead to more readable scripts,
	  and the plan is to gradually phase in "send" as a mandatory keyword.

	- A new member function
	
		int Client::HasEventSource()

	  returns true if a Glish client has *any* input source (either
	  a connection to the Glish interpreter, or by reading from stdin),
	  and false if it has no input source (due to using -noglish).

	- The "[]" expression now creates a truly empty array; previously it