news

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

	  created an array with a single element, the boolean constant F.
	  Such empty arrays can be used when constructing other arrays,
	  even if the other array elements have incompatible types.  For
	  example,

		["foo", "bar", []]

	  constructs a two-element string array, but

		["foo", "bar", [T]]

	  results in an error because the types "string" and "boolean"
	  are incompatible.

	- A bug introduced in the last release in which the completion of
	  an "await" statement could lead to $value not being set has been
	  fixed.

	- A backward-compatibility bug in reading Glish datasets/SDS's
	  written with old versions of Glish has been fixed.


26Jul93:
	- 2.3.2 release.

	- Fixed slow memory leak in sending events.

	- A number of minor tweaks to keep cfront-derived C++ compilers happy.


21Jul93:
	- 2.3.1 release.

	- New "activate" and "deactivate" statements can be used to
	  control whether the body of a "whenever" statement is active
	  (i.e., whether it's executed when its corresponding event
	  comes in).

	- Four new built-in functions support the activate/deactivate
	  statements:

		whenever_stmts(agent)
			returns a record listing the event names and
			"whenever" statements indices corresponding to
			the given agent.

		active_agents()
			returns a record array listing all of the currently
			active agents.

		current_whenever()
			returns the index of the currently-executing (or
			most recently-executed) "whenever" statement.  Here
			"executing" refers to executing the *body* of
			the "whenever" statement.

		last_whenever_executed()
			returns the index of the last executed whenever
			statement, where "executed" refers to the statement
			as a whole and not to its body.

	- Each host now runs at most one copy of the Glish daemon glishd.
	  glishd listens on TCP port 9991 for connections from Glish
	  interpreters.  When it receives one it opens a socket connection
	  which the interpreter uses to communicate with the daemon by
	  sending it events, much as before.  Each daemon can support
	  multiple interpreters at the same time.  If an interpreter finds
	  that no daemon is presently running on a remote host then it
	  creates one using rsh as before.  The daemon does not, however,
	  exit when the interpreter does, but instead persists.  This means
	  that you may find encounter a daemon owned by someone else running
	  on a machine you want to use.  For the present the assumption is
	  that this is not a major problem; but conceivably you might need
	  the daemon to be running with your uid and not some other persons.
	  For now what you do is tell the daemon to exit using the
	  "tell_glishd" program (see below).  In the future we may have to
	  make the daemon setuid-root so it can change its uid as needed.

	- The Glish interpreter probes each remote daemon every five seconds
	  by sending it a "probe" event.  If the daemon does not reply to
	  this event within the next five seconds, the interpreter deems
	  network connectivity lost, issues a warning, and generates a
	  "connection_lost" event for the global "system" agent (see next
	  item).  If the daemon subsequently replies to a later probe, the
	  interpreter reports this fact and generates a "connection_restored"
	  event.  If the daemon dies or is killed using tell_glishd, the
	  interpreter generates a "daemon_terminated" event.

	- A new agent record, "system", manages information about the
	  general environment in which a script runs.  "system" presently
	  has two information fields:

		system.version
			The version number of the Glish interpreter.
		
		system.is_script_client
			True if this script is a client of another script,
			false otherwise.

	  "system" also generates the following events:

		system->connection_lost
			Indicates that connectivity to a remote host has
			been lost.  The event value names the host.

		system->connection_restored
			Indicates that connectivity to a remote host has
			been recovered.  The event value names the host.

		system->daemon_terminated
			Indicates that Glish daemon on a remote host has
			died.  Again, the event vlue names the host.

	  You can set up "whenever"'s for these events just like for those
	  generated by any other agent.

	  If you find you'd like other "system" events, let me know; in
	  general they're not hard to add.

	- The "version" global has been removed, since it's now subsumed
	  by "system.version".

	- Glish now supports an "include" directive for including the
	  contents of a source file:

		include "foo.g"

	  includes the contents of the file "foo.g".  There's no limit
	  on the nesting-depth.

	- When running Glish interactively, you can now create clients and
	  execute "whenever" statements.  You also can execute scripts by
	  "include"'ing them.

	- You can now use the "==" and "!=" operators to compare non-numeric,
	  non-string values.  Two such values compare as equal if they refer
	  to exactly the same entity.  For example,

		a := [b=1, c=2]
		d := [b=1, c=2]
		e := ref a
		print a == a, a == d, a == e

	  prints T, F, T.

	- Glish now allows only one filename on the command line (since
	  the "include" directive can be used to access multiple sources).
	  Because of this change, you no longer need the special "--"
	  argument to delimit the end of source filenames and the beginning
	  of script arguments.  Instead, every argument save the first is
	  treated as a script argument.  "--" is still allowed, though, for
	  backward compatibility.

	- A new program (not a Glish client), tell_glishd, is available for
	  controlling the Glish daemon on a given host.  Presently all you
	  can do with tell_glishd is kill the daemon running on a given
	  host.  You do so using:

		tell_glishd -k [host]

	  As indicated, "host" is optional; it defaults to the local host.


03Jun93:
	- 2.2.2 release.

	- Fixed deadlock problems when using multiple point-to-point links.

	- Local point-to-point links no longer use named pipes, but
	  Unix-domain sockets instead.

	- Fixed bug in which a broken link was treated by the sink
	  side as a "terminate" event.

	- Added file version.h for tracking version number.


20May93:
	- 2.2.1 release; Client::FD_Change virtual function was
	  completely broken.


19May93:
	- 2.2 release.

	- Assignment (":=") is now an expression instead of a statement,
	  so you can string multiple assignments together like in C:

		a := b := 1

	- Compound assignments such as "x +:= 1" are now supported.

	- "local" statements can include initializations:

		local x := 5

	- You can use a Glish script as a client in another Glish script:

		c := client("glish myscript.g")

	  There's a new, associated global variable called "script", which
	  is either boolean "F" if the script is running independently,
	  or an agent that can be used to send and receive events from the
	  script if being run as a script client.

	- An "opaque" type is available for client data (SDS's) that are
	  uninterpreted by Glish (it just provides a mechanism for conveying
	  them between clients).

	- The division operator now always converts its operands to
	  Glish "double" values and yields a double value.

	- The Client class has a new virtual member function, Client::FD_Change,
	  that you can redefine when deriving from Client to receive
	  notification of when a Client's input sources change.

	- The manual includes a new chapter, "Changes Between Glish Releases",
	  summarizing this information and providing pointers to fuller
	  descriptions in the Glish user manual.

	- Some portability tweaks for HP/UX.


21Jan93:
	- 2.1 release.

	- User documentation is now available in doc/User-Doc.ps.

	- An "ind(x)" function has been added which returns the
	  indicies corresponding to an array value.  For example,

		ind("hello, how are you?")

	  returns [1 2 3 4], since the argument has four elements.


13Jan93:
	- Records can now be indexed in the same manner as arrays, i.e.,
	  with integer or boolean arrays.  For example,

		r := [a=1, b=2]
		r[1] := 5
		r[2] := "hi"
		print r

	  prints "[a=5, b=hi]".  You also can add fields to a record:

		r := [=]	# create an empty array
		r[1] := 5
		r[2] := "hi"
		print r

	  prints "[*1=5, *2=hi]", where "*1" and "*2" are internal names
	  for the new record fields just created.

	  This style of record access allows you to create what are
	  effectively arrays of records, functions, or agents, without
	  the restriction (and type-checking) that every element of the
	  array has the same type.

	- Added BSD-style copyright notice to sources.


01Dec92:
	- PostScript for a 15-page paper describing Glish is now available in
	  glish/doc/USENIX-93.ps.  The paper will appear in the proceedings
	  of the 1993 Winter USENIX conference.

	- Glish now supports "link" and "unlink" directives for creating
	  and suspending point-to-point connections between Glish clients.
	  Events sent point-to-point are *not* seen by the sequencer;
	  they do not trigger "whenever"'s.  The "link" syntax looks like:

		link a->b to c->d

	  This causes all of a's "b" events to go directly to c, which
	  will see them as "d" events.  You can also use:

		link a->b to c->*

	  which passes the event along without changing its name (i.e.,
	  it's still called "b").  The "unlink" directive looks the same:

		unlink a->b to c->d

	  suspends the point-to-point connection, so a's "b" events will
	  now be seen by the sequencer and trigger any corresponding
	  "whenever"'s.  Doing another "link" reactivates the link.

	- The Client library has undergone several user-visible changes:

	  An "void Unrecognized()" member function has been added; it *must*
	  be called by a client that does not recognize a particular event.

	  "int ReadFD()" has been replaced by routines oriented towards
	  use of select().  "void AddInputMask( fd_set* mask )" is passed
	  an fd_set mask used by select() and adds to it those bits
	  corresponding to the Client's input sources.  You then can use
	  "int HasClientInput( fd_set* mask )" to determine whether a
	  mask returned by select() indicates that the client has pending
	  input (i.e., one or more events has arrived).  The function returns
	  true or false.

	  A new version of NextEvent() is available; it is passed an fd_set*
	  mask which it uses to determine from where to read the next event.

	  "int WriteFD()" has been removed.

	- Communication between the sequencer and processes running on
	  the same host is now done using pipes, a substantial performance
	  win.

	- When creating clients or shell tasks an optional input= argument
	  can be used to set up the program's standard input.  For example,

		shell("wc", input=1:10)

	  will run the "wc" command on the numbers from 1 to 10, one on
	  each line.

	- shell clients now write their output to a pty if available, so
	  it is line-buffered.

	- The default "glish.init" file now resides in $(ISTKPLACE)/lib/
	  instead of $(ISTKPLACE)/glish/.

	- The "loop" keyword has been replaced with "next" ("continue" can
	  also be used, for die-hard C hackers).

	- The glish interpreter now prints non-string array values with []'s
	  around them.

	- The predefined family of "relay" functions now treat a "destination
	  event name" of '*' to mean "use the same name as that the source
	  generated".


01Oct92:
	- A number of new predefined functions are available: is_function(),
	  is_agent(), and is_numeric() return true if their argument is
	  a function, and agent, or a numeric type, respectively.  abs()
	  returns the absolute value of its numeric argument.  len() is
	  an alias for length().  rep() takes two arguments, a "value" and
	  a "count", and returns an array of "count" copies of "value".
	  For example, rep(5,3) is [5, 5, 5].