TADS 3 Change History

Changes for 06/01/2002

Fixed a problem in the Vector intrinsic class that caused interpreter crashes under certain circumstances. (The exact conditions were not entirely predictable, because the problem had to do with an interaction between the Vector class, the garbage collector, and the undo mechanism, and only occurred when garbage collection was triggered after certain operations in the Vector class.)
Added a status line to Workbench for Windows. The status line is optional; it can be displayed or hidden, as desired, using the "View" menu. When displayed, the status line shows whether or not the program being debugged is running, and shows the line and column number of the current cursor position when a source file window is active.
Fixed a problem in Workbench that prevented parts of the window layout from being saved in the project configuration file when the main Workbench application window was closed while the program being debugged was still running.

Changes for 05/19/2002

The DOS text-mode interpreter now supports setting text colors. Text colors can be set through HTML, as follows:
- The <FONT COLOR=xxx BGCOLOR=yyy> tag can be used to set the and background colors of the text. The basic set of HTML colors is recognized, although the effective set of available colors is limited to the eight ANSI colors that DOS character mode can display: white, black, red, green, blue, yellow, cyan, and magenta. Hex RGB values (for example, <FONT COLOR='#C080E0'> are accepted, but these are simply mapped to the nearest available color from the ANSI set. Note that if a FONT tag specifies both COLOR and BGCOLOR, the text will be displayed exactly as specified; if the FONT tag specifies only COLOR, then the background color will be inherited from the enclosing text, and ultimately from the <BODY> color if no enclosing text has a specific background color.
- The <BODY> tag can be used to set the foreground and background color of the window. The TEXT attribute sets the foreground text color, and the BGCOLOR attribute sets the background color of the window. The background color affects the entire window, just as in the HTML interpreters, so the entire window will be redisplayed in its new color whenever a <BODY BGCOLOR=xxx> tag is displayed.
- The parameterized color names (TEXT, BGCOLOR, STATUSTEXT, STATUSBG) are accepted and map to the current settings of those colors, as set by the TRCOLOR program.
The new system information code SysInfoTextColors can be used to determine the level of color support available on the platform. The return value is a code indicating the level of support:
- SysInfoTxcNone - no color support
- SysInfoTxcParam - parameterized color names only
- SysInfoTxcAnsiFg - The eight ANSI colors are available for text, but there is no capability to set the background color
- SysInfoTxcAnsiFgBg - the ANSI colors are available for text and background colors (this is the code the DOS interpreter returns)
- SysInfoTxcRGB - full RGB text color support is available (this is the code the Windows HTML interpreter returns)
The new system information code SysInfoTextHilite can be used to determine whether or not text highlighting is available. This returns true if a distinctive appearance for <B> text is available, nil if not. The HTML interpreters return true for this; the text-only interpreters generally return true, unless running in "plain" ASCII mode or with a terminal or display device that cannot render anything special for highlighted text.

Changes for 05/05/2002

Fixed a problem in Workbench for Windows with libraries (.tl files) found via the library search path. In some cases, the files within a library could not be opened; in addition, the library itself was not always properly scanned on opening the project, so no files within the library were visible in the Project window. Libraries found via the search path should work properly now.
Workbench for Windows now uses small (8x8-pixel) icons in the left margin of debugger source windows when the selected source window font is smaller than the standard (16x16-pixel) icons. (These are the icons that show the location of the current line, breakpoints, and so on during a debugging session.) This allows more lines to be displayed vertically in a source window when a small font is selected.
When quitting out of Workbench, if a build is still running, the Workbench displays a dialog indicating that Workbench is waiting for the build to complete. In the past, there was no way to force Workbench to exit if the build process had become stuck. Now, the "waiting for build" dialog offers an "Abort" button; clicking this button will forcibly terminate the build, allowing Workbench to terminate immediately. This button is useful when the build process becomes stuck (which ideally should never happen, but has happened at times due to compiler bugs). The build process should not normally be aborted forcibly unless the build appears stuck, because forcibly terminating a process on Windows can occasionally cause Windows to become unstable.
Fixed a compiler bug that made it possible for the linking step to get stuck in an infinite loop if the data associated with a particular "grammar" production became too large. This should no longer occur.
Fixed a debugger bug that caused sporadic crashes when running games in Workbench.
Added new systemInfo() codes for MNG display:
- SysInfoMng - can the system display MNG images?
- SysInfoMngTrans - can the system display MNG's with transparency?
- SysInfoMngAlpha - can the system display MNG's with alpha channels (i.e., partial transparency)?

Changes for 04/28/2002

Renamed numerous macros in the system and adv3 header files to achieve more consistency in the naming scheme. Here's a table of the changes. (Sorry this isn't a Perl script or something.)

Old Name	New Name
BIGNUM_SIGN	BignumSign
BIGNUM_EXP	BignumExp
BIGNUM_EXP_SIGN	BignumExpSign
BIGNUM_LEADING_ZERO	BignumLeadingZero
BIGNUM_POINT	BignumPoint
BIGNUM_COMMAS	BignumCommas
BIGNUM_POS_SPACE	BignumPosSpace
BIGNUM_EUROSTYLE	BignumEuroStyle
TYPE_NIL	TypeNil
TYPE_TRUE	TypeTrue
TYPE_OBJECT	TypeObject
TYPE_PROP	TypeProp
TYPE_INT	TypeInt
TYPE_SSTRING	TypeSString
TYPE_DSTRING	TypeDString
TYPE_LIST	TypeList
TYPE_CODE	TypeCode
TYPE_FUNCPTR	TypeFuncPtr
TYPE_NATIVE_CODE	TypeNativeCode
TYPE_ENUM	TypeEnum
PROPDEF_ANY	PropDefAny
PROPDEF_DIRECTLY	PropDefDirectly
PROPDEF_INHERITS	PropDefInherits
PROPDEF_GET_CLASS	PropDefGetClass
STR_HTML_KEEP_SPACES	HtmlifyKeepSpaces
STR_HTML_KEEP_NEWLINES	HtmlifyKeepNewlines
STR_HTML_KEEP_TABS	HtmlifyKeepTabs
STR_HTML_KEEP_WHITESPACE	HtmlifyKeepWhitespace
T3DBG_CHECK	T3DebugCheck
T3DBG_BREAK	T3DebugBreak
OBJ_INSTANCES	ObjInstances
OBJ_CLASSES	ObjClasses
OBJ_ALL	ObjAll
REPLACE_ONCE	ReplaceOnce
REPLACE_ALL	ReplaceAll
GETTIME_DATE_AND_TIME	GetTimeDateAndTime
GETTIME_TICKS	GetTimeTicks
INEVT_KEY	InEvtKey
INEVT_TIMEOUT	InEvtTimeout
INEVT_HREF	InEvtHref
INEVT_NOTIMEOUT	InEvtNotimeout
INEVT_EOF	InEvtEof
INEVT_LINE	InEvtLine
INEVT_END_QUIET_SCRIPT	InEvtEndQuietScript
INDLG_OK	InDlgOk
INDLG_OKCANCEL	InDlgOkcancel
INDLG_YESNO	InDlgYesNo
INDLG_YESNOCANCEL	InDlgYesNoCancel
INDLG_ICON_NONE	InDlgIconNone
INDLG_ICON_WARNING	InDlgIconWarning
INDLG_ICON_INFO	InDlgIconInfo
INDLG_ICON_QUESTION	InDlgIconQuestion
INDLG_ICON_ERROR	InDlgIconError
INDLG_LBL_OK	InDlgLblOk
INDLG_LBL_CANCEL	InDlgLblCancel
INDLG_LBL_YES	InDlgLblYes
INDLG_LBL_NO	InDlgLblNo
INFILE_OPEN	InFileOpen
INFILE_SAVE	InFileSave
INFILE_SUCCESS	InFileSuccess
INFILE_FAILURE	InFileFailure
INFILE_CANCEL	InFileCancel
FILETYPE_LOG	FileTypeLog
FILETYPE_DATA	FileTypeData
FILETYPE_CMD	FileTypeCmd
FILETYPE_TEXT	FileTypeText
FILETYPE_BIN	FileTypeBin
FILETYPE_UNKNOWN	FileTypeUnknown
FILETYPE_T3IMAGE	FileTypeT3Image
FILETYPE_T3SAVE	FileTypeT3Save
SYSINFO_VERSION	SysInfoVersion
SYSINFO_OS_NAME	SysInfoOsName
SYSINFO_HTML	SysInfoHtml
SYSINFO_JPEG	SysInfoJpeg
SYSINFO_PNG	SysInfoPng
SYSINFO_WAV	SysInfoWav
SYSINFO_MIDI	SysInfoMidi
SYSINFO_WAV_MIDI_OVL	SysInfoWavMidiOvl
SYSINFO_WAV_OVL	SysInfoWavOvl
SYSINFO_PREF_IMAGES	SysInfoPrefImages
SYSINFO_PREF_SOUNDS	SysInfoPrefSounds
SYSINFO_PREF_MUSIC	SysInfoPrefMusic
SYSINFO_PREF_LINKS	SysInfoPrefLinks
SYSINFO_MPEG	SysInfoMpeg
SYSINFO_MPEG1	SysInfoMpeg1
SYSINFO_MPEG2	SysInfoMpeg2
SYSINFO_MPEG3	SysInfoMpeg3
SYSINFO_HTML_MODE	SysInfoHtmlMode
SYSINFO_LINKS_HTTP	SysInfoLinksHttp
SYSINFO_LINKS_FTP	SysInfoLinksFtp
SYSINFO_LINKS_NEWS	SysInfoLinksNews
SYSINFO_LINKS_MAILTO	SysInfoLinksMailto
SYSINFO_LINKS_TELNET	SysInfoLinksTelnet
SYSINFO_PNG_TRANS	SysInfoPngTrans
SYSINFO_PNG_ALPHA	SysInfoPngAlpha
STATMODE_NORMAL	StatModeNormal
STATMODE_STATUS	StatModeStatus
SCRFILE_QUIET	ScriptFileQuiet
SCRFILE_NONSTOP	ScriptFileNonstop
CHARSET_DISPLAY	CharsetDisplay
CHARSET_FILE	CharsetFile
firstPerson	FirstPerson
secondPerson	SecondPerson
thirdPerson	ThirdPerson
spellIntTeenHundreds	SpellIntTeenHundreds
spellIntAndTens	SpellIntAndTens
spellIntCommas	SpellIntCommas
Logical	logical
LogicalRank	logicalRank
LogicalRankOrd	logicalRankOrd
Dangerous	dangerous
NonObvious	nonObvious
IllogicalNow	illogicalNow
Illogical	illogical
Inaccessible	inaccessible
DefaultReport	defaultReport
MainReport	mainReport
ReportBefore	reportBefore
ReportAfter	reportAfter
ReportFailure	reportFailure
IsNonDefaultReport	gIsNonDefaultReport
SingleDobj	singleDobj
SingleIobj	singleIobj
DobjList	dobjList
IobjList	iobjList
NumberPhrase	singleNumber
TopicPhrase	singleTopic
LiteralPhrase	singleLiteral
DirPhrase	singleDir

Added Phil Lewis's new Adv3 Reference Help to Workbench for Windows. This new Windows Help file is a reference to the classes in the adv3 library; Phil created it for his own use but has graciously offered it for inclusion in the Author's Kit distribution. Phil says the reference isn't complete, but it has a wealth of information all the same. The Adv3 Help can be reached from the "TADS 3 Library" item on the Workbench "Help" menu.
The compiler can now search for source files using a user-specified list of directories. This allows makefiles (.t3m files) to specify source files using only relative filename paths, eliminating any dependency in a makefile on the local system's directory structure and thus allowing the project to be easily used on other systems. The compiler searches for its files by looking in the following locations, in order:
- The current working directory (for Workbench users, this is the directory containing the .t3m file for the project).
- The directories specified with "-Fs" compiler options, in the order of the options.
- The directories specified with the new "user library" mechanism.
- The "system library" directory. This is the special directory containing the compiler's own libraries. This directory varies by system, but it is normally set up automatically when TADS is installed and requires no user action to configure.
The "user library" list is specified using a system-dependent mechanism:
- For the DOS/Windows command-line compiler (i.e., run from a command prompt), set the environment variable TADSLIB to a list of directories, separated by semicolons (";").
- For Workbench for Windows, enter the list of directories in the "Libraries" page of the Workbench preferences dialog, reachable from the "Options" item on the "View" menu.
- The mechanisms for other systems are yet to be determined, but in all likelihood Unix will use the same TADSLIB environment variable as the DOS version.
Workbench for Windows has a new option to automatically load the most recent project when Workbench is started. To set the start-up mode, use the "Start-Up" page of the Workbench preferences dialog, reachable from the "Options" item on the "View" menu.
Added the new systemInfo() code SysInfoOgg, which senses whether or not the interpreter supports Ogg Vorbis audio playback.
Changed inputEvent() so that it accepts a nil timeout argument value, for consistency with inputLine(). A nil value for the timeout is equivalent to omitting the timeout argument entirely: it indicates that the input should be allowed to proceed indefinitely.
The compiler now stores preprocessor symbol (macro) definitions with the debugger records of the compiled program, when compiling for source-level debugging (i.e., using the "-d" compiler command-line option). The debugger uses the preprocessor symbols when parsing expressions during the debugging session, so it is now possible to interactively evaluate expressions involving macros. Note that the compiler keeps debugging records for a macro only if the macro (1) is never undefined (using #undef) or redefined with a different expansion within a given module, and (2) has the exact same expansion in every module in which it is defined; these restrictions mean that only macros with consistent "global" meanings across the entire program are visible in the debugger.
Fixed a problem in Workbench for Windows that caused an incorrect name to be stored for the game's initial source file when creating a new project.
Fixed a compiler problem that caused the compiler to crash when confronted with a constant index expression where the indexed value was not a list (e.g., 1[1]).
Fixed a problem in the Windows HTML interpreter that prevented interrupted command lines from continuing correctly. When a command line input was interrupted by a timeout, the command line that was under construction when the timeout occurred was not properly restored for further editing. This has been corrected.
Fixed a problem in the VM that caused the VM to crash under rare circumstances. The problem was particularly likely to occur when stepping through large amounts of code with the debugger.
Fixed a problem in the character map compiler (mkchrtab) that generated corrupted character map files when the source file had duplicated display mapping entries.
The distributions (including the installer kits and the source code distribution) now include a full set of character mapping files that should cover most users on most platforms. For a listing of the included codings, see charmap/README.txt. (The full set adds only about 25k to the compressed distribution files, which seems a small cost for the simplicity of having an essentially universal set of mappings available with the default install.)
The Windows Author's Kit installer now associates .t3m files with Workbench, so that double-clicking on a .t3m file from Windows Explorer will open the file in Workbench. (The 4/7/2002 version still set the association for .t3c files instead, despite Workbench's switch to .t3c files for storing project configuration information.)
Fixed a problem that caused the compiler to display the incorrect text for invalid tokens in certain error messages related to 'grammar' statement syntax.

Changes for 04/07/2002

Workbench for Windows now uses the compiler makefile (.t3m) file format to store its project information. This means that a Workbench project file can be used directly as a compiler makefile, using the compiler's "-f" option. For the moment, Workbench is still capable of loading
Workbench on Windows now monitors for Ctrl+Break, and breaks into the debugger when this key combination is detected. This allows easily breaking into the debugger if the .t3 program enters an infinite loop.
The 'replace' and 'modify' keywords can now be used to change 'grammar' definitions. Refer to the Grammar Rules documentation for details.
A grammar production object can now be declared without creating any rules associated with the production. The new syntax is simply "grammar production_name;" (that is, a "grammar" statement that simply ends after the name of the production). This can be useful for libraries that want to define rules that refer to productions for which the library itself provides no rules, so that games based on the library can fill in the grammar definitions for the productions. In the past, if a production was referenced as a subproduction from one or more rules but had no rules of its own defined, the linker generated an error, because it is likely in such cases that the rules referring to the undeclared production were misspelled and meant to refer to a declared production; this new syntax gives the author a way to tell the compiler explicitly that a production name was used intentionally, even if the production has no rules.
Added new syntax that allows multiple part-of-speech properties (such as "noun" or "adjective") to be used as a single token matcher in a grammar rule. The new syntax uses a list of properties in angle brackets: <noun adjective plural>. When this syntax is used, an input token matching any of the part-of-speech properties in the list matches the rule token position.
Moved the "build configuration" information that was formerly stored in object (.t3o) files into the symbol (.t3s) files instead. The compiler uses the build configuration data stored in these files to determine if recompilation of a given source file is necessitated by build configuration changes since the last time the file was compiled. In the past, when the information was stored in the object files, the compiler unnecessarily regenerated symbol files repeatedly when compilations failed due to syntax errors, because compilation didn't get far enough to store the build data. Moving the information to the symbol files allows the compiler to skip symbol table generation when a previous compilation generated a valid symbol file for a given module. This saves time in the build-edit-build cycle when a program is initially compiled and contains syntax errors.
Added two new pseudo-variable keywords: targetobj and definingobj. These pseudo-variables are similar to self and targetobj, in that they act like read-only variables (i.e., you cannot assign values to them), and they are automatically maintained by the interpreter to keep track of the current method context. targetobj returns the "original target object" of the current method; this is the object that was targeted by the method call that reached the current method. The target object is set each time a method is called normally or via delegated, and remains the same as methods are invoked via inherited. definingobj is the object that defines the currently executing method; this is normally simply the object where the method was actually defined in the program's source code.
Removed the getMethodDefiner() intrinsic function from the "tads-gen" function set. This function has been replaced by the new pseudo-variable definingobj.
Changed the interface of the Object.propInherited() intrinsic class method. The method now takes an additional argument (positionally the second argument in the new interface) giving the original target object of the call. In cases where the caller wishes to know if the currently active method can inherit a base class method, the value for the new argument should simply be targetobj.
Changed the way inherited behaves after delegated is used. In the past, the inheritance mechanism tried to find the defining object of the method with the inherited operator in the inheritance tree of "self". After delegated, the defining object is normally not related by inheritance to "self", so the old search pattern normally failed to find any inherited instance of the method. Now, the interpreter keeps track internally of the "original target" object in addition to the "self" object; the original target is always the target of the last explicit method call or the target of the most recent delegated operator. The inherited operator uses the original target object as the starting point of the inheritance tree search, rather than "self"; this allows inherited to find methods inherited from base classes of the delegatee when appropriate.
Fixed a compiler bug that caused incorrect code to be generated for statements like this: if (constant_expr && non_constant_expr) - that is, an "if" whose condition expression consists of a constant expression (i.e., an expression whose value can be determined at compile-time) and a non-constant expression joined by the "&&" operator. The code that the compiler generated caused unpredictable results at run-time, and was able to crash the interpreter in some cases. This has been corrected.
Increased the standard VM stack size to 4096 stack slots (from 1024).
Expanded the compiler's maximum symbol length to 80 characters, to accomodate the longer symbols generated by the new treatment of production match object tagged names as actual compiler symbols.
Fixed a problem that caused a sporadic interpreter crash when using restartGame(). This crash occurred only rarely, and was related to memory management during program re-initialization. This should no longer occur.
Fixed a problem with restoreGame() that caused modifications to intrinsic classes to be lost in some cases. This problem occurred rarely, and should no longer occur.
Changed the character mapping input file format slightly. The "unicode_to_local" keyword has been renamed to "display_mappings", and has a slightly different effect: in the "display_mappings" section, each character mapping gives the Unicode expansion of a Unicode code point; that is, each mapping specifies a set of Unicode characters to substitute for the Unicode character being mapped. The expansion is then further translated automatically by the character mapper to the local character set. Each expansion must map to characters defined in the one-to-one mapping section (i.e., the set of mappings before the "display_mappings" keyword). Note in particular that an expansion cannot map to characters that are themselves further expanded. The purpose of this change is to allow the interpreter to perform expansion mappings - that is, mappings that can translate one Unicode character to several display characters - while still in the Unicode domain, and hence to perform operations such as word-wrapping on the expansions. The console output formatter uses this to properly word-wrap lines with expanded display mappings.

Changes for 03/16/2002

Fixed script-reading mode in the interpreter. Past versions did not correctly read input scripts (using the command-line interpreter's "-i" option, for example).
Added the new input event code INEVT_END_QUIET_SCRIPT, which is described in the documentation for the inputLineTimeout intrinsic function.
Added a couple of small usabilty enhancements to Workbench for Windows:
- Pushing the Return/Enter key when keyboard focus is in the Project window opens the selected module in a source file window, if a module is selected. This allows easier keyboard navigation of the Project file list.
- Double-clicking on a module in the Project window now moves keyboard focus to the newly-opened source file window. In the past, focus stayed on the Project window, so context-sensitive commands (such as "Find") did not apply to the newly-opened source window until manually clicking on the window to activate it.
Fixed a bug in mkchrtab (the character map compiler) that caused incorrect mappings in some compiled mapping files having display (from_unicode_to_local) mappings that expanded to more than one byte.
Fixed a problem in the Windows interpreter that made it incompatible with Windows 95. The interpreter should once again be compatible with Windows 95.

Changes for 03/10/2002

Added the new method removeElement() to the Vector intrinsic class. This new method removes an element by value, modifying the vector in-place.
Added the new method forEachWord() to the Dictionary intrinsic class. This new method provides a way of enumerating all of the entries in a Dictionary object.
Added information to the LICENSE.TXT file making it clear that derived versions of the library are permitted with few restrictions.
The "!" operator can now take an object reference as its operand; when applied to a non-nil object reference, "!" yields nil. This means that constructs such as "if (!obj)" are now treated as equivalent to "if (obj == nil)"; such constructs formerly generated a run-time error. In addition, property ID's, single-quoted strings, lists, and function pointers can all be used as operands of "!", and "!" applied to any of these types yields nil.
Fixed a compiler bug that caused the compiler to crash in some cases when confronted with an empty pair of parentheses within a grammar rule, such as grammar myProd: ('mytoken' ()).
Fixed a compiler bug that caused the compiler to crash in some cases when given a method definition with no code body and the end of the object immediately following.
Fixed a compiler bug that caused incorrect code generation for an 'if' with a constant controlling expression that evaluated to true and no 'else' clause. In such cases, the true branch of the 'if' was not generated; this has been corrected.
The project file extension for Workbench for Windows is now ".t3c" (it was formerly ".tdc", the same as it was for the TADS 2 Workbench). The extension has been changed to allow the Windows desktop to launch the appropriate version of Workbench when the user double-clicks a project file from the desktop and both TADS 2 and ADS 3 Workbench versions are installed.
Fixed a problem in the VM that caused repeated "terminate game" dialogs to appear in Workbench for Windows when the user attempted to compile the game after the debugger intercepted a run-time error.
Fixed a problem in the character map compiler (mkchrtab) that caused invalid map files to be generated if the source file had more than one symmetric (bidirectional) mapping assigned to the same Unicode code point. The character map compiler now generates a warning when these collisions occur, and generates valid map files even when collisions are present by ignoring redundant mappings.

Changes for 02/17/2002

The compiler now shows a summary count of warnings and errors at the end of the compiler console output when either count is non-zero, to make it more obvious that messages were generated during the compilation. If many modules are included in a compilation, the status messages that the compiler generates as it works through the module list can make it easy to miss an error or warning mixed in among all the status messages. The new summary at the end of the compilation should make it easier to notice when something requires attention. No summary counts are displayed when there are no warnings or errors; this is intended to make it even easier to notice when something is wrong, since authors will not be accustomed to seeing a summary count at all when everything is well.
The Iterator intrinsic class has the new methods getCurVal() and getCurKey(), which return the value and key of the current element of the iteration, respectively. For indexed collections, the "key" is the index of the current element.
LookupTable.forEach() no longer passes the key argument to the callback. If the key is desired, use the new method forEachAssoc() instead. This allows LookupTable to be used more interchangeably with other Collection subclasses, since its forEach() method has the same interface as the corresponding method of other Collection subclasses.
LookupTable, List, and Vector now have the additional method forEachAssoc(func), which calls func(key,val) for each element of the collection. For List and Vector, the "key" is the index of the element; for LookupTable, it is the key for the entry.
The Array intrinsic class has been deleted; Vector should be used instead. The Array class was too similar to the Vector class to justify its existence as a separate type, so the functionality of Array and Vector are now combined into the single Vector class.
When a Vector is used as the left-hand side of a '+' or '-' operation, in the past, the VM modified the left-hand side Vector object directly. This has been changed so that a new Vector is created, and the original left-hand Vector is left unchanged. The old behavior was confusing in that it gave the '+' and '-' operators side effects, which is inconsistent with the behavior of the operators in other situations.
A new Vector method, appendAll(), allows appending the individual elements of a List or Vector to another Vector in-place (i.e., without creating a new Vector object, as the '+' operator does).
The Vector methods getUnique() and subset() now return a new Vector to store the result of the operation. In the past, these methods modified the original Vector in place.
In the past, when a Vector was used as the right-hand side of a '+' operator whose left-hand side was a List or Vector, the List or Vector on the right was the single new element concatenated to the left-hand collection. This was inconsistent with the handling of List values; a List value concatenates its elements individually when used as the right-hand side of a '+' operator. For consistency, Vector now concatenates its elements individually when used on the right side of a '+' operator. Similarly, Vector values now subtract their elements from the left-hand side collection when used as the right-hand side of a '-' operator, also for consistency with the List type's behavior.
Fixed a problem in the VM that caused the VM to lose track of intrinsic class modifiers after a RESTORE operation. Intrinsic class modifiers will now properly survive RESTORE operations.

Changes for 02/09/2002

Changed inputLineTimeout so that it accepts a nil timeout argument value. A nil value for the timeout is equivalent to omitting the timeout argument entirely: it indicates that the input should be allowed to proceed indefinitely.
Improved inputLineTimeout's interaction with the OS layer so that the portable code can handle complete non-implementation of input-with-timeout by the OS layer.
Changed getTime(GETTIME_TICKS) so that the function always chooses the zero point of the system clock as the time of the first call to the function. This reduces the likelihood that a game will encounter a roll-over of the system clock, which could lead to confusion in interpreting time differences and the ordering of events.
Changed the names of two methods in the LookupTable intrinsic class. The method formerly called countBuckets() is now getBucketCount(), and the method formerly called countEntries() is now getEntryCount(). These names match the names as given in the documentation, but the header file (lookup.h) had the old names.
Added the compiler option "-clean", which causes the compiler to skip ordinary compilation and instead simply remove all derived files that the compilation would have produced; in particular, this removes the symbol (.t3s), object (.t3o), and image (.t3) files that the compilation would have produced.
Added the compiler option "-Pi", which causes the compiler to skip ordinary compilation and instead write to the standard output a list of files included with #include directives throughout the program. The compiler runs the normal preprocessing, and shows only files included in conditional compilation sections that are selected in the compilation (in other words, the list does not include any files included from within the false branches of #if or other conditional compilation directives). In the generated list, the files are listed one file per line, and each line specifying a file consists of the characters "#include", followed by a single space, followed by the name of the included file, followed by a newline sequence. The name of the included file is not enclosed in any quote marks or other delimiters. This format is intended to simplify automatic processing of the list by clearly marking each line in the output that names an included file. Note that the list of included files might include a given file more than once, because each file is listed as it's included, and it is possible to include a given file more than once.
When the compiler is run with the "-P" option (which writes the preprocessed version of the source to standard output), the compiler now prefixes the generated source with the directive #charset "utf8" to indicate the character set of the preprocessed source.
Added a compiler warning message when the preprocessor finds a line that ends with a backslash followed by whitespace. While this format is legal (because it could be useful in defining a macro that is later "stringized"), it is highly unusual. Since trailing spaces are not usually visible in a text editor, the programmer might not be aware of their presence; and since the presence of the trailing spaces materially changes the meaning of the program, the compiler warns about them. Note that the warning can be suppressed by adding a comment at the end of the line; this doesn't change the meaning of the program but does make the spaces visually evident in a text editor, so the compiler recognizes that the warning is not necessary in this case.
Fixed a VM problem that caused the garbage collector to incorrectly delete intrinsic class objects under certain unusual circumstances. When an intrinsic class is used implicitly but never specifically declared in the compiled program, the VM creates an object to represent the intrinsic class during the initial program load. In the past, it was possible for the garbage collector to regard such an object as unreachable even though it is always reachable via the native code implementing its corresponding intrinsic class. This problem sometimes led to VM crashes. The problem should no longer occur.
Fixed a compiler problem that caused incorrect compilation for a grammar rule specified with an alternation (two or more sub-rules, each separated by an "|" symbol) and an empty final sub-rule. In such cases, the compiler incorrectly generated two copies of the empty sub-rule, leading to two match objects being created at run-time each time the empty sub-rule was matched. This has been corrected.
Changed inherited so that it searches for the next inherited definition of the property as though the currently active method (and any overriding definitions) had simply never been defined. This makes inherited work roughly the same way as the inheritNext method that was formerly defined in the MixIn class in the adventure game library (adv3).
Added a new Object method, propInherited, which determines if a method is inherited, using the new rules of the inherited operator. This provides functionality equivalent to the canInheritNext method formerly defined in the MixIn class in the adventure game library.

Changes for 01/13/2002

The compiler can now read "library" files, which are lists of source files to be included in the compilation. Library files can be used to simplify compiler command lines and makefiles when including sets of source files that usually act as a group, such as the standard adventure library sources.
Workbench can now show library files in the project window. You can add a library file to the project window's source file list in the same way as you can add a source file; the library shows its contained source files as a subtree. Each source file within a library is shown with a checkbox, indicating whether or not the file is included in compilations; if you want to exclude a file within a library from compilation, click on the checkbox to remove the checkmark. The checkbox settings are stored with the project and don't affect the library itself, so you can use the same library in a different project, and include and exclude different sets of files.
The debugger no longer uses a RuntimeError exception to terminate the program being debugged. In the past, when the user terminated the running program using the debugger "Stop" button, or by starting a new compilation of the program while the program was still running, the debugger attempted to terminate the program by throwing a RuntimeError with system error code 2390. This approach wasn't completely reliable, because it allowed the running program to catch the exception and keep running; programs sometimes inadvertantly caught the error as part of an inclusive "catch" handler, causing strange interactions with the debugger user interface. The debugger now halts the program by telling the VM not to execute any more program instructions, which guarantees that the program stops immediately. This new approach should be much more robust and should avoid the strange effects that sometimes occurred with the old mechanism.
Fixed a problem in the compiler that caused the compiler to hang when given a makefile (a .t3m file) that didn't end with a newline character.
Fixed a compiler problem that generated an incorrect set of grammar rule patterns for grammars involving nested alternatives (i.e., parenthesized "|" expressions). In the past, the compiler incorrectly generated multiple copies of the top-level expressions in such rules, leading to run-time generation of multiple redundant matches for these expressions. This has been corrected; the compiler now generates only one copy of each top-level rule in an alternation.
Fixed an interpreter problem that caused the interpreter to crash when an HTML <TITLE> tag was displayed.
Fixed a problem in the debugger that caused memory leaks and other incorrect behavior when the user attempted to run the program, but the program had not been compiled (or had not been compiled with debugging information).
When Workbench needs to find a source file during program tracing in the debugger, it now scans the project list to find the file. In the past, the debugger used only the source path to find files, leading to annoying interactive requests to locate files that were in plain view in the project window.

Changes for 01/05/2002

Added the new intrinsic functions inputLineTimeout(), which allows reading a line of text with an optional timeout. This function can be used to combine command-line input with real-time effects, because it allows a command line to be interrupted if the command is not completed before a real-time interval elapses.
Fixed a problem in the Dictionary class: the isWordDefinedTrunc() method used the wrong truncation length in its comparison - it required the string to be matched to be at least one character longer than the dictionary's truncation length. It now uses the correct truncation length.

Changes for 12/30/2001

The compiler now parses a delegated expression so that the object expression is taken to exclude function or method calls. That is, if parentheses follow the expression giving the target object of the delegation, these are taken to give the argument list of the delegation call itself, rather than of the expression giving the target object value. This change makes delegated syntactically parallel to inherited in that the target property can be omitted from the expression, in which case the delegation target property is the same as the property being evaluated in the caller. (If a function or method call is desired in the object expression itself, this can be easily accomplished by enclosing the entire object expression in parentheses.)
Workbench now stores its project configuration files so that the absolute file system path to "system" files is not stored; instead, system files are flagged as system files, and their locations are stored relative to the system directory. A "system" file is simply a file that is stored in the Workbench install directory or any of its subdirectories; the system directory is the directory containing the Workbench program executable. This change makes project configurations more readily moveable from one system to another, because it eliminates any dependency in the project configuration on the particular directory in which Workbench is installed.
The compiler now treats the symbol and object path options as overriding all module source paths, even when the filenames are given with "absolute" (as opposed to relative) path names.

Changes for 12/23/2001

Added a checksum to the saved game format. This allows the interpreter to validate a saved state file, to ensure the file wasn't corrupted (such as by a text-mode ftp transfer), before attempting to load the file.
Fixed a problem in the Vector intrinsic class that prevented two equivalent vectors from comparing equal.
Fixed a compiler problem that caused the compiler to crash in some cases when a symbol was redefined from function to another type.
Fixed a compiler problem that caused incorrect initialization of Dictionary objects in the image file in certain cases when preinitialization ran (i.e., when compiling with the -d option).

Changes for 12/09/2001

The compiler now accepts URL-style portable path names in #include directives, and in fact prefers them. Refer to the preprocessor chapter for details.
Added a new method, createClone, to the TadsObject intrinsic class. This method returns a newly-created object that is an identical copy of the original object.

Changes for 12/02/2001

Changed the tokenizer interface (in tok.t) to return a list of token elements, rather than parallel value/type lists. Each token element in the token list is a sublist, consisting of the following values:
- [1] = token value, as set by the matched rule
- [2] = token type enum, as set by the matched rule
- [3] = original source text matched by the rule that matched the token
The tok.h header defines macros that extract these elements of a token; these should be used rather than direct list elements to make your code more readable. The macros are getTokVal(tok), getTokType(tok), and getTokOrig(tok). So, if lst is a variable containing the result of calling Tokenizer.tokenize(), and you want to retrieve the type enum for the third token, you'd write getTokType(lst[3]).
Changed the tokenizer's rule specifications for greater power and symmetry in creating rules:
- The "flags" entry has been eliminated. The functionality of the only flag that was defined, TOKFLAG_SKIP, has been replaced with the improved behavior of the rule processor. Since the processor method's interface is now powerful enough to subsume the functionality of the "skip" flag, the special case embodied in the flag is no longer needed.
- The processor method (element [3] in the sublist defining a rule) has a new interface. In the past, this method took a text match and returned a token value. This interface meant that a given rule was limited to generating exactly one token. The new interface takes three arguments, and returns no value:
```
    self.(processorProp)(txt, typ, toks)
  
```
  txt is the text that matched the rule (this is the same as the lone argument to the old interface). typ is the token type from the rule (i.e., element [2] of the sublist defining the rule). toks is a Vector containing the token list under construction. The method must append the appropriate set of tokens to the Vector in toks. The method is not required to append any tokens; the rule in the default tokenizer rule set that matches whitespace, for example, doesn't generate any tokens, since whitespace characters have no significance other than separating tokens in the default rule set. The rule is also allowed to generate more than one token; this is useful for rules that generate certain tokens types only if they immediately follow particular text patterns. Note that the processor method is not required to use the typ value given, since each new token the method adds to the result Vector can be of whatever type is appropriate; the type information is included so that a single processor method can be re-used for similar types of processing that produce different token types.
Changed the intrinsic GrammarProd.parseTokens() method to accept tokens in the new format returned by the tokenizer. The method now takes only two arguments, not three: the second argument that formerly gave the token type list has been eliminated, since each element of the token list now includes the type information along with the token value information.
Changed the Dictionary and GrammarProd intrinsic classes to use case-sensitive matching exclusively. Case sensitivity in the past was inconsistent; all functions are now case-sensitive for consistency.
The template inheritance mechanism is somewhat altered from its first implementation. The 'inherited' keyword can now go anywhere a template; the inherited token lists are treated as substitutions for 'inherited' at the point at which it appears in the list. Furthermore, the compiler now treats each template involving inheritance as a macro defining all possible inherited templates; when a template is used, it is matched based on the entire expansion of the template, not on the partial superclass template. The net effect is that a template definition involving an 'inherited' token is identical to the implied set of fully expanded template definitions.
The -Fs option can now be used to specify a search path for source files, rather than a single path for all sources as it did in the past. Multiple -Fs options can be specified; each one adds one directory to the source search path. When a source file name is specified in "relative" form (as defined by local filename conventions), the compiler first looks for the file in the working directory, then searches the directories specified with -Fs options, in the order in which the options were specified. The compiler uses the first instance of the file it finds.
The compiler automatically adds the system-dependent default system library directory to the source search path. This directory is always searched after all directories specified by the user with -Fs options. In effect, the compiler adds an extra -Fs option for the default system library directory after all user-specified -Fs options. This allows library sources (such as reflect.t or gameinfo.t) to be included in a build configuration (in a .t3m file, for example) without any path information; the compiler will automatically find these system files using the implied -Fs setting.
The compiler's default system library and include directories are now system-dependent. On DOS and Windows systems, the default system header and library directories are the same as the compiler executable's directory (this is the main directory where the TADS 3 tools are installed). Check your platform-specific release notes for details on the locations of these directories on other platforms.
Fixed a problem that allowed objects to be deleted by the garbage collector when they were referenced as superclasses of other objects. This caused unpredictable behavior, including interpreter crashes.
Fixed a problem that affected the results of t3GetStackTrace() in the non-debug interpreter when a run-time error occurred. In such cases, the stack trace incorrectly omitted the innermost level, where the error actually occurred. This has been corrected.
Fixed a compiler problem that sometimes caused the compiler to crash after attempting a link that involved unresolved external symbol references.
Fixed a GrammarProd parsing problem that caused incorrect token index information to be returned in certain cases involving productions with no tokens.

Changes for 11/17/2001

Extended the object template syntax to allow template inheritance. A template definition can now include the keyword "inherited" as its final token; this indicates that the template "inherits" the templates of its class's superclasses.
The compiler now detects and reports circular class definitions (that is, class definitions where the class being defined is a subclass of one or more its purported superclasses). In the past, the compiler did not detect such definitions and could get stuck in infinite loops or unbounded recursion when they were made.
Fixed a compiler problem that sometimes caused crashes when an actual parameter list in a macro expansion was not properly terminated (with a closing parenthesis) in the source file.
Fixed a problem that affected a few Vector methods by incorrectly returning an empty vector. This affected the appendUnique, getUnique, and mapAll methods.
Fixed a compiler problem that caused a modified intrinsic class to show a spurious extra property in its getPropList() result list. This property had an undefined type (type code 16).
Fixed a problem in the Vector class that caused unpredictable results, including crashes, when adding a large list to a vector.
Fixed a problem in the debugger that caused unpredictable results, including crashes, when interrupting the program in mid-statement in certain circumstances. The problem occurred sporadically in such cases when the garbage collector happened to run while the debugger had control, but didn't appear until after returning control to the program. This problem only manifested itself rarely, but could cause crashes when it did appear.
Fixed a compiler problem that caused incorrect code to be generated for calls to operator new where the actual parameters included one or more "..." expressions (i.e., expanded variable argument lists). This affected the calling end, not the receiving end. The problem caused the caller to send one fewer argument than it should have.
Fixed a problem in the output formatter that caused log files to be generated without proper line wrapping in the HTML version of the interpreter.
Changed the output formatter so that <BANNER> contents (everything from a <BANNER> tag to the corresponding </BANNER> close tag) are not included in the output log. The contents of a banner are not logically part of the main text stream so are not appropriate for inclusion in a log file. This ensures that HTML-based status lines and other special display effects do not interfere with the log file contents.

Changes for 10/21/2001

Fixed a problem that made it impossible to use anonymous functions that referenced "self" or properties of "self" within property values defined as simple value expressions (as opposed to methods).
Changed the compiler to allow using short-form anonymous functions (i.e., using the "{args: }" notation, rather than the "new function" notation) as list elements without enclosing the functions in parentheses. In the past, the compiler considered an open brace at the start of a list element expression as an error; this was an heuristic intended to catch unterminated list expressions, but its utility as a diagnostic tool was not sufficient to justify the superfluous syntax requirement it imposed for this case.

Changes for 10/07/2001

Added special character sequences '\{' and '\}'. These are used to group a set of output formatter setting changes: any changes to the formatter settings made after a '\{' sequence are undone at the corresponding '\}' sequence. In particular, the following state changes are affected:
- \H+
- \H-
- \H
These new sequences can be used to isolate a run of text from the enclosing text's formatter settings, so that the text within the '\{ \}' pair doesn't have to worry about the enclosing settings and has no effect on the enclosing settings. This can be useful, for example, if a run of text wants to output an HTML-significant character, but doesn't know if it will be called with HTML interpretation turned on or off. In such cases, the text can turn HTML interpretation off within the brackets without affecting its caller: "\{\H-&\}" would display an ampersand, regardless of whether HTML mode was in effect before the text was displayed, but will have no effect on subsequent text's HTML mode.
Fixed problems in several intrinsic classes related to saving and restoring. These bugs caused crashes in some cases when restoring saved positions.
Changes the restartGame() behavior slightly. The function invoked after the restart is now passed the original command line arguments to the program; the arguments are passed as a list in the second parameter to the function. This allows the function to invoke the normal main program entrypoint as though the program were being started normally.
If a saved position file is found to be corrupted in the course of being restored, the interpreter will now force an exit. There is no way for the program to retain control in such cases. If a saved position file is corrupted, the partially restored machine state at the point at which the corruption is detected must be considered invalid, so the VM cannot safely pass control back to the program. In such cases, the VM terminates the program to avoid the high likelihood that the program would crash the VM due to the program's partially corrupted internal state.
Fixed some problems in the "undo" mechanism that caused unpredictable behavior (including VM crashes) under some circumstances.
Fixed a problem in the debugger that caused, in some cases, the incorrect error code to be reported in the RuntimeError object representing a VM exception. This only occurred when the program was being run in the debugger, and only then when certain types of expressions were evaluated. This has been corrected.

Changes for 09/30/2001

Changed the symbol file format to allow inclusion of intrinsic function and intrinsic class registration lists. This is an internal change only; its purpose is to make the compiler more flexible in correlating the internal linkage identifiers of intrinsics across object modules to eliminate the possibility of certain confusing linking errors. In the past, it was necessary to keep intrinsic definitions in a consistent order across separately compiled modules, which was problematic for library developers and especially for library extension developers. Adding the information to the symbol files allows the compiler to build an intrinsic identifier list globally across modules to ensure a consistent ordering, even when the individual modules have conflicting orderings. This change should not be visible to users except to the extent that it eliminates certain errors relating to intrinsic class and intrinsic function inclusion order.

Changes for 09/09/2001

Added a new function to the "tads-io" function set: flushOutput(), which immediately flushes text output to the display and updates the window, if possible.
Fixed a compiler bug that caused incorrect code to be generated for implicit constructors for classes with multiple superclasses. This code generation error did not manifest itself frequently, but when it did show up caused problems ranging from data value corruption to interpreter crashes.
The debugger now includes an ampersand prefix when displaying property pointer values.

Changes for 08/26/2001

Added new syntax that provides a short-hand notation for defining a group of properties with similar names and parameters: the new "propertyset" syntax.
Added a new keyword, "targetprop", a pseudo-variable that evaluates to the current target property pointer. The target property is the property that was invoked to reach the current method; this new pseudo-variable complements "self" with information on the property being evaluated in the current "self" object. The "targetprop" keyword can only be used in contexts where "self" is valid.
The "inherited" and "delegated" keywords can be used with new syntax that omits the target property. If the target property is omitted, then the current target property is implied. The target property can be omitted from any of the previously-allowed forms of the "inherited" and "delegated" expressions, as shown here ("delegated" syntax is parallel to "inherited", so only "inherited" is shown):
- inherited is equivalent to inherited.targetprop
- inherited(arguments) is equivalent to inherited.targetprop(arguments)
- inherited superclass_name is equivalent to inherited superclass_name.targetprop
- inherited superclass_name(arguments) is equivalent to inherited superclass_name.targetprop(arguments)
Added a new library module, reflect.t, that provides higher-level reflection services. This module is optional, but if it is included, the _main.t module uses reflection to show stack trace listings for unhandled runtime exceptions.
Added t3GetStackTrace() to the 't3vm' intrinsic function set. This function returns information on the call stack.
The RuntimeException object defined in _main.t now stores a stack trace (in the form returned by t3GetStackTrace()) in its stack_ property. The VM no longer stores an explicit stringized form of the stack trace when setting the exception message, since the new stack trace format is more powerful.
Fixed a bug in the TadsObject intrinsic class that sometimes caused a given property to appear more than once in the getPropList() method's returned list. Any given property now appears at most once in the result list.
The TadsObject intrinsic class now supports createInstance() as a static method on the intrinsic class. The expression TadsObject.createInstance() returns a new instance of TadsObject, which is the same as defining an object statically like so: "myobj: object;" - that is, using the "object" keyword rather than a superclass list.
Fixed a bug in the getPropList() method when called on any intrinsic class object (e.g., Object, TadsObject, BigNumber). In the past, this method returned a list of all of the methods that were valid on instances of the intrinsic class, not the methods that were necessarily valid on the intrinsic class object itself. This method now returns a list consisting only of the "static" methods of the intrinsic class, which is to say the methods that can be called directly on the intrinsic class object itself.
Fixed a bug in the Object intrinsic class's propType() method. When the property in question was undefined, the method returned TYPE_NIL, whereas it should have returned nil. The method now returns nil for these cases, as documented.
Fixed a bug in the compiler that caused incorrect code generation when a variable argument list parameter variable was referenced from within an anonymous function within the function or method with the variable argumetn list parameter.
The compiler now specifially flags code using '=' to define a method. Since this was valid TADS 2 syntax, and has been gratuitously changed in TADS 3, users are likely to use the old syntax accidentally, especially while transitioning to the new language. The compiler catches these cases so that it can generate specific and clear error messages; this should help ease the transition to the new syntax by spelling out plainly the new syntax requirement.

Changes for 08/12/2001

Fixed a compiler problem that caused incorrect code to be generated for expressions of the form obj.(prop)(args), where prop is a property of self whose value is a property pointer. An expressions of this form is equivalent to the form obj.(self.prop)(args), but the compiler in the past incorrectly interpreted this as equivalent to obj.prop(args) - that is, rather than evaluating (self.prop) and then calling the property of obj given by the resulting property pointer value with the given argument list args, the compiler generated code that called the property prop of obj with arguments args. This has been corrected - the compiler now correctly interprets obj.(prop)(args) as equivalent to obj.(self.prop)(args).
Fixed a compiler problem that caused incorrect code to be generated for delegated expressions involving variable argument lists.
Fixed a compiler problem that caused a spurious warning under certain circumstances. If a property was used only in an address expression ("&prop") in a module, and no object ever defined a value for the property, a call to the property in a separate module incorrectly generated a warning indicating a call to a possibly undefined property name. This warning was spurious because the use of the property name in an address expression is enough to definitively establish the symbol as a property.
Fixed an output formatter problem that caused the text-mode interpreter to hang (in an infinite loop internally) in response to certain "&" entities in HTML mode.
Fixed a problem in the GrammarProd intrinsic class that caused productions that matched zero tokens to indicate invalid token index values for firstTokenIndex and lastTokenIndex. These now always indicate zero in such case, to indicate that the production is associated with no tokens.

Changes for 08/05/2001

Added file safety level checking to the File intrinsic class. The initial implementation of File did not check the safety level set in the user preferences; the File class now correctly checks to ensure each open-file operation is allowed by the user's safety level settings. On a safety level violation, the "open" functions throw the new exception FileSafetyException.
Text files can now be opened in FileAccessReadWriteKeep and FileAccessReadWriteTrunc modes. In the past, only "data" and "raw" files could be opened in read/write modes, which made it impossible to append to an existing text file.

Changes for 07/22/2001

Fixed a problem with using 'modify' with intrinsic classes. In the past, if more than one 'modify' statement was applied to an intrinsic class, only the last of the 'modify' statements was actually taken into account at run-time. This has been corrected.
Fixed a compiler bug: the compiler did not report an error if a 'replace' statement replaced an object but did not specify a superclass list for the new object. The compiler misinterpreted such a statement as a new anonymous object definition. This has been corrected; the compiler now flags the missing superclass list as an error.

Changes for 07/16/2001

Fixed a problem in the List class that could cause an object to be improperly deleted by the garbage collector under certain obscure circumstances. (In particular, if an object was being assigned to a list element, and the garbage collector ran in the course of the creation of the new list for the result of the assignment, the object on the right-hand side of the assignment was lost if not otherwise referenced.)
Fixed a problem that occurred with propDefined(prop, PROPDEF_GET_CLASS) when the property of interest was an intrinsic method (i.e., a TYPE_NATIVE_CODE value). In these cases, the return value of the method was an invalid value, which caused problems if used, including interpreter crashes. In such cases, propDefined() now properly returns the intrinsic class object where the intrinsic method is defined.
Extended the object template mechanism to allow class-specific templates to be defined.
Extended the firstObj() and nextObj() intrinsic functions to take a new flags argument, which allows the caller to specify whether to enumerate instances only, classes only, or both.
Changed the TadsObject class to allow use of the new operator with no arguments. In the past, at least one argument (giving the immediate superclass of the new object) was required; now a new TadsObject with no arguments is understood to create a base TadsObject.
Added the File intrinsic class, which provides a new interface to external file input/output. This replaces the file-related functions in the "tads-io" intrinsic function set, which have been removed. Specifically, the following functions have been removed:
- fileClose
- fileGetPos
- fileOpen
- fileRead
- fileSeek
- fileSeekEnd
- fileWrite
Important note: This change is not upwardly compatible. All existing code must be recompiled for this change, and any code using the fileXxx functions must be modified to use the new File intrinsic class. The necessary code changes are relatively straightforward, since the names of the new File methods are similar to those of the old functions.
The compiler now generates an implicit constructor for each object or class that inherits from multiple base classes and does not provide an explicit constructor. The implicit constructor simply invokes each base class's constructor, in the same order in which the base classes are listed in the superclass list.
Added grouped sub-alternatives to rules in the grammar statement. This allows portions of an alternative in a rule definition to be grouped for alternation; for example, a rule can be defined as "('take' | 'get' | 'pick' 'up') nounList->lst_", which is more concise than flattening out the grouped alternation manually.
Added the #ifempty and #ifnempty variable-arguments expansion operators, which allow conditional expansion in a varargs macro depending on whether or not the varargs part is empty.
Added the -P option to t3make: this preprocesses the source file, writing the expanded results on standard output. When -P is specified, no compilation or linking is performed, so no object or image files are created.
Added new String intrinsic class methods: startsWith(), endsWith(), and mapToByteArray.
Added a feature to the substr() method of the String intrinsic class: if the starting index (the first argument) is negative, it indicates an offset from the end of the string: -1 is the last character of the string, -2 the second-to-last, and so on.
Added a new function to the "tads-io" function set: getLocalCharSet, which returns the name of one of the active local character sets on the current system.
Added new functionality to the "tads-io" function set for files. Files can now be opened in "raw" mode, which allows reading and writing byte arrays. Bytes written to and read from a file in raw mode are not translated or modified in any way; this mode offers direct access to external files, for purposes such as manipulating files in formats defined by other applications. The fileRead() and fileWrite() functions in this mode take ByteArray arguments.
Added new functionality to the "tads-io" function set: the fileOpen() routine can now take an object of intrinsic class CharacterSet instead of a character set name. If you've already instantiated a CharacterSet object for other reasons, it is more efficient to re-use the same object by reference in this manner than to pass the name of the character set to fileOpen(), since fileOpen() has to create another mapping object when given only a character set name.
Added the new CharacterSet intrinsic class.
Added the new ByteArray intrinsic class.
In the Object intrinsic class, method formerly known as isClass() has been renamed to ofKind(). x.ofKind(y) returns true if x is an instance or subclass or y. In addition, this method has been changed so that x.ofKind(x) returns true for any x.
Added a built-in character set mapping for ISO 8859-1 (Latin-1). This character set is in widespread use because of its status as the default HTTP character set, and has an especially simple mapping to Unicode, so it seemed worthwhile to add as a built-in set not requiring an external mapping file. The assigned name of the set is "iso-8859-1".
Changed the compiler's former -r option to -a, and the former -rl to -al. (The -a option forces recompilation of all involved modules even when not out of date with respect to the source files, and -al forces relinking even when the image file isn't out of date with respect to the object files; these options effectively override the compiler's normal dependency analysis for cases when the automatic analysis is incorrect for some reason.) This change is gratuitous and cosmetic, but makes the compiler's option names more closely resemble that of traditional "make" programs.
Fixed a compiler bug: the compiler reported a spurious "symbol already defined" warning when a particular grammar production had rules defined in multiple modules. This has been corrected.
Fixed a preprocessor bug: if the argument of a #message was missing its closing right parenthesis, the preprocessor got stuck in an infinite loop. This has been corrected.
Fixed a bug in the Vector intrinsic class (and, by inheritance, in the Array intrinsic class): if the insertAt method was called on an empty vector, a crash occurred. This has been corrected.
Fixed a compiler bug that caused the compiler to crash if confronted with a foreach statement in the absence of the definition of the Collection and Iterator classes. This has been corrected; the compiler now generates the appropriate error message and recovers gracefully.
Fixed a problem with the grammar production object that caused new match tree objects to bypass constructors on creation. The match tree constructors are now invoked as for any other object instantiation.
Fixed a problem in the debugger that prevented the debugger from taking control on a run-time exception being thrown when another run-time exception had previously occurred at the same place twice in a row with no intervening debugger activity.
Fixed a problem that caused the debugger to crash under some unusual conditions when an entry in the local-variables window was selected and later automatically removed due to an execution context change.
Improved the robustness of the debugger when the program being debugged caused a stack-overflow exception.
Updated the calc.t example to the new GrammarProd.parseTokens() interface.
Fixed a bug that caused comparisons of any two function pointers to yield unequal, even for equivalent function pointers. This bug had numerous subtle manifestations; for example, a function pointer key in a LookupTable could never be found, since a test for equality to the key would never succeed.
Fixed a compiler bug that caused the incorrect error message to be reported when a replace/modify of an extern object was out of order in a link (the message reported that a function rather than object was involved).
Removed a spurious warning that was generated when a dictionary was imported from multiple symbol files.
Fixed a bug in the GrammarProd intrinsic class that caused "*" tokens in subproductions to be misinterpreted. In the past, the "*" token only worked properly in top-level productions (i.e., a production on which parseTokens() was called); this has been corrected so that "*" works properly at any level.

Changes for 05/05/2001

Incompatible intrinsic class API change: The return value of the parseTokens() method in the GrammarProd intrinsic class has been changed. In the past, this method returned a list, each of whose elements was a sublist of two elements. Each sublist described one successful match tree; the first element of each sublist was the number of tokens matched, and the second was the root object of the match tree. The 4/29/2001 version added the firstTokenIndex and lastTokenIndex properties to the match objects; since the number of tokens matched in a tree can be inferred from the firstTokenIndex and lastTokenIndex values, the token counts in the return sublists were redundant. Therefore, to simplify the API, the sublists have been eliminated, and parseTokens() now returns simply a list of match tree root objects. To obtain the token count for a match, simply calculate (match.lastTokenIndex - match.firstTokenIndex - 1), where match is the root object in the match tree. Since the root object in a tree encompasses the entire match, its token range necessarily encompasses the range of tokens for the entire match.
Added variable-argument macros.
Fixed a problem in the GrammarProd intrinsic class that prevented a rule from being matched when it ended with the special '*' token and was used as a subproduction in another rule. This now works correctly.
Fixed a problem in the compiler that caused a spurious warning message indicating that a dictionary symbol had been imported multiple times. This warning was generated whenever the dictionary was declared in more than one source file but not in all source files; each file that did not declare the dictionary displayed the warning. This has been corrected.
Added the delegated keyword, which allows delegating a method call to an unrelated object.
Added the getMethodDefiner() intrinsic function, which returns the object that defines the currently executing method.
Changed the default name of the ASCII character set mapping to "us-ascii" for better readability. The old name ("asc7dflt") is still accepted, but is now obsolescent and should not be used in new code. All of the #charset directives in the system headers provided with the compiler have been updated to use the new "us-ascii" name.

Changes for 04/29/2001

Fixed a problem in the GrammarProd intrinsic class that caused incorrect results to be returned with productions that matched exactly zero tokens.
Extended the grammar syntax to allow the "->" notation to be used with literal tokens. In the past, the arrow was only allowed with symbol-match tokens (subproductions and token classes), but it is often desirable to be able to retrieve the matching token even for a literal match. There are two cases in particular where a literal's matching token is needed to reconstruct the original input: when the literal is matched with truncation; and when a production has several alternatives with different literals.
Modified the GrammarProd intrinsic class so that each match object now includes more direct information on the tokens involved in the match. The parser now sets the firstTokenIndex and lastTokenIndex properties of each match object to indicate the index of the first token and of the last token, respectively, that are involved in matching the rule corresponding to the match object. This is a simple range, so all of the tokens from the first to the last, inclusive, constitute the match's original text. In addition, the parser sets the tokenList property of each match tree item to the original token list passed into parseTokens() (this doesn't take up nearly as much memory as it might at first appear, since all of the match objects reference a single shared copy of the token list). The exported properties firstTokenIndex, lastTokenIndex, and tokenList are defined in gramprod.h.
The compiler now creates a dictionary entry in the default dictionary, if one is defined, for each literal string that appears in a "grammar" statement's rule list. If no default dictionary is defined when a "grammar" statement is encountered, the statement's literals are not entered into any dictionary. Each literal string is associated with the production object and the property "miscVocab". Since these strings are now stored in the dictionary, it is simple to determine if a word is defined in any context; without the grammar literal dictionary entries, it was not possible to determine if a given string, when entered by a user at run-time, was known in the context of a grammar literal.
The "grammar" syntax has been extended to allow a "tag" to be associated with each "grammar" statement. To specify a tag, specify any symbol or number in parentheses after the production name. For example:
```
    grammar nounPhrase(1): adjective->adj_ : object ;
```
The tag's only purpose is to provide an identifying name for the new "grammarInfo" method, described below.
The compiler now automatically creates a method for each grammar match object that makes it possible to traverse match trees without knowing their internal structure in advance. The new method is called "grammarInfo," and it returns a list. The list's first element is a string giving the name of the production, with the optional tag (see above) enclosed in parentheses after the production's symbolic name. Each subsequent element is the value of a property appearing after an arrow ("->") in the production's rule list.
Modified the grammar production matching algorithm so that [badness] matches are examined as a group rather than individually. In particular, when a number of [badness] alternatives arise simultaneously, the parser had in the past examined only one such alternative at a time once determining that no better matches were available. Now, all [badness] alternatives with the lowest badness value are examined in parallel. This is important in some cases for the same reasons that parallel consideration of regular alternatives is necessary.
Fixed a compiler problem that caused spurious "variable assigned but not used" warnings in certain situations. In particular, if a local variable was defined in a nested scope within a method, and the variable was used only within the lexical confines of an anonymous function within the nested scope, the compiler did not correctly mark the variable as having been used and thus incorrectly reported the warning. This problem did not affect code generation; its only effect was the unnecessary warning.
Enhanced the Dictionary intrinsic class's findWord() and findWordTrunc() methods so that the property argument in each can be omitted or specified as nil, in which case all objects with vocabulary matching given text, for any part-of-speech property, will be returned.
Fixed a debugger problem that caused a crash in some obscure cases involving opening a file during a debugger session when the debugger had never taken control since the beginning of program execution, and a similar problem that occurred when the VM threw a run-time error exception under similar circumstances.

Changes for 04/15/2001

A new mechanism allows capturing calls to undefined methods and properties. When a call is made to an undefined method, the VM now calls a new property, propNotDefined(), on the target object. The new method receives as arguments the the undefined property ID and the arguments to the original method call. If propNotDefined is itself not defined, the VM simply returns nil for the undefined method call, as it did in the past.
Added some new regular expression features:
- Character classes can now be combined with '|', as in <upper|digit> (matches any upper-case letter or any digit).
- Character classes can now be complemented with '^', as in <^upper> (matches anything except upper-case letters).
- Added some named character expressions, which look similar to character-class expressions, and which can be combined with character-class expressions via '|': <upper|star> matches any upper-case letter or an asterisk.
Renamed the t23run.exe executable to simply tr32.exe, so the combined TADS 2+3 interpreter is now the default interpreter. The separate interpreters are now called t2r32.exe (for TADS 2) and t3run.exe (for TADS 3). For the most part, users will not need to run the version-specific interpreters at all; the only time these should be needed is when bundling a game into an executable, in which case it is desirable for the sake of minimizing file sizes to include only the version of the interpreter actually needed.

Changes for 3/28/2001

The object definition syntax has been extended to allow an object's property list to be enclosed in braces. Refer to the Object Definitions documentation for details.
The object definition syntax now provides "nested" objects. A nested object is an anonymous object defined in-line within another object, with a property of the enclosing object initialized with a reference to the nested object; this syntax is convenient for defining certain types of small helper objects.
The language now has a static property initialization syntax, which allows a property to be initialized with a non-constant value computed at compile-time.
Changed the behavior of the '+' property. The new behavior is much simpler than the previous behavior: if an object is defined with N plus signs, its '+' property is initialized to the most recent object defined with N-1 plus signs. Explicitly setting the '+' property in an object list is now irrelevant. Refer to the documentation for details.
Changed the default filename suffix for image files to ".t3" (it was formerly ".t3x") to make image filenames somewhat more friendly looking.
Added the new executable "t23run" - this is a 32-bit console-mode combined TADS 2 and TADS 3 interpreter. You can use this single application to run games compiled for TADS 2 or TADS 3. This version of the interpreter is not designed for bundling single-file games for distribution, since this would unnecessarily increase the size of bundled games; use the appropriate single-version interpreter executable for bundling.
Added the new executable "html23" - this is a combined TADS 2 and TADS 3 version of the HTML interpreter.
For anyone interested in porting the combined command-line interpreter on another platform, the code that implements this should be easily portable to other command-line operating systems. See the target 't23run.exe' in win32/makefile.vc5; you can find the source code for the main program entrypoint in vmcl23.cpp. For systems that don't use Unix-style command lines, the command line code itself won't be portable, but portable code for sensing the engine version needed to run a given game file can be found in vmmain.cpp.
Fixed a bug that caused problems with certain "reflection" methods when the program used modify to extend the TadsObject intrinsic class. If the program modified TadsObject, then traversed the object tree (using the getSuperclassList() method), or used the propDefined() method, the behavior was incorrect, and could lead to VM crashes. This has been corrected.
Added documentation on the #charset directive and using source files encoded in Unicode UCS-2.
Added a #charset "asc7dflt" directive to each system source and header file included with the compiler distribution. This directive ensures that the compiler interprets the contents of the system files correctly, in case the user wants to specify a default character set for the compilation with the -cs compiler option.
The compiler now accepts Unicode character 0x2028 ("line separator") as equivalent to a newline in source files that use of the Unicode encodings the compiler accepts (UCS-2 big-endian, UCS-2 little-endian, or UTF-8).
In text mode, the fileRead() function now properly translates input characters according to the character set selected when the file was opened. (In the past, the character set was ignored, and the characters from the file were not properly translated to Unicode.) In addition, the fileRead() function accepts Unicode character 0x2028 (the Unicode line separator character) as equivalent to a newline (but note that, as always, the text returned from readLine() represents each end-of-line with a single '\n' character, regardless of the type of line termination in the underlying file).

Changes for February 24, 2001

Added the t3AllocProp() intrinsic function, which allocates a new property ID.
Added the Object.getPropList() method, which returns a list of properties directly defined by an object.
Added the Object.getPropParams(prop) method, which returns information on the parameters taken by a property or method.
Added the getFuncParams(funcptr) intrinsic function, which returns information ont he parameters taken by a function.

Changes for February 10, 2001

The new property statement allows a program to explicitly declare property symbols. This is optional, but can be useful in certain cases in library code.
Added the LookupTable intrinsic class, which implements a general-purpose associative array type. A LookupTable is similar to a Vector, but whereas a Vector can use only integers as indices, a Hashtable can use any value as an index.
Added the new t3GetGlobalSymbols() intrinsic function, which provides programmatic access to the compile-time names of objects, properties, functions, intrinsic classes, and enumerators.
The preprocessor now treats square brackets ("[ ]") and braces ("{ }") as grouping symbols when parsing macro arguments. In the past, only parentheses were counted. This allows list constants and anonymous functions to be used more easily as macro arguments.
In _main.t, added a new function, initAfterLoad(). The main program entrypoint in _main.t (function _main()) calls this new routine to perform initialization. This routine sets up the default display function, performs pre-initialization if necessary, then performs regular load-time initialization. All of these operations were previously carried out in _main(); the reason they've been separated into a new function is to allow the same operations to be called after a restartGame operation. Since a restartGame effectively re-loads the image file and starts the game over from scratch, the same initialization that _main() performs at initial load must be performed immediately after a restart; this function makes this common code easy to re-use.
Added a new method to the TadsObject intrinsic class: createInstance(), which creates an instance of the object. This method passes its arguments to the new object's constructor, if any, and returns a reference to the new object.
Added execAfterMe to ModuleExecObject in _main.t. User code can initialize this property in a given ModuleExecObject instance to contain a list of other ModuleExecObject instances that are to be initialized after the given instance; this is analogous to the execBeforeMe list, but allows an object to specify things that are to come after it. It is sometimes desirable to be able to specify initialization order dependencies by specifying what must follow rather than what must precede initialization of a given object, and this new property provides the flexibility to specify order dependencies either way.
A makefile for DJGPP (the definitive port of Gnu C/C++ for MS-DOS) is now included in the source distribution. This makefile can be used to create a 32-bit version of the interpreter that will run on MS-DOS on PC's with 386 or later processors.
Fixed a VM problem that caused modification of the root intrinsic object (i.e., modify Object) to fail. In the past, the VM simply failed to execute code added to the root intrinsic object with modify. This has been corrected; code added to Object is now properly inherited from the other intrinsic classes.
The String and List intrinsic classes can now be extended with the modify mechanism. In the past, the VM did not correctly handle code extensions to the String and List intrinsic classes.
Fixed a compiler bug that caused incorrect code generation when adding a constant zero value to a local variable which, at run-time, ends up containing a vector, list, or other non-integer value.
The Vector intrinsic class can now be used with the foreach keyword to loop over the elements in a vector. (In previous versions, the Vector class incorrectly omitted support for foreach.)
The "Frames" version of the documentation should now work correctly with Netscape and other browsers that had trouble with past versions. (The frames page had some ill-formed HTML, which some browsers rejected, but this page has now been corrected.)
Changed the text of the VM error message that results from applying an index to a type that cannot be indexed (nil[3], for example). In the past, the message read "invalid type for indexing - value cannot be index," which incorrectly signified that there was something wrong with the index value, when in fact the value being indexed was the problem. The message has been changed to read "invalid index operation - this type of value cannot be indexed."
Fixed a problem in the Vector intrinsic class that caused a vector's data to be corrupted by certain operations that should have, but did not, increase the internal storage space allocated for the Vector object.
Fixed a compiler problem with object templates. The compiler did not properly parse object templates that included list tokens; this has been corrected.
Fixed a bug in the rand() intrinsic function. In the past, this function crashed the interpreter if the argument was a list with no elements. This has been corrected; the function now returns nil when the argument is a list with no elements.
Fixed a problem with the Vector intrinsic class that caused pre-initialized data to be loaded incorrectly.
Corrected the documentation (the expressions chapter) to reflect the correct precedence of the "[]" and "." operators, which should be above the unary operators.
Added four new methods to the List intrinsic class: prepend(val), which inserts a new value at the start of a list; insertAt(index, val1, val2, ...), which inserts one or more values into a list at a given position; removeElementAt(index), which deletes the element at the given index; and removeRange(startIndex, endIndex), which removes the elements in the given range of indices.
Added a new method to the Vector intrinsic class: prepend(val), which inserts a new value at the start of a vector.
It is no longer legal to apply the unary "&" operator to an object symbol. In the past, "&objectName" was the same as simply "objectName"; this is no longer legal. "&objectName" was never a meaningful construct, since an object symbol yields a reference to the object to begin with, but past versions of the compiler accepted it without complaint and treated it as equivalent to the unadorned object symbol; the compiler now rejects this construct.
It is no longer legal to apply the unary "&" operator to a function name symbol. In the past, "&functionName" yielded a reference to the function. This has been changed so that the function name used by itself yields a reference to the function, just as an object name does.
Because the "&" operator can no longer be used with any symbol types other than properties, there is no longer a warning when using the operator with an otherwise undefined symbol name. "&symbol" now unambiguously defines the symbol as a property name.
Fixed a compiler bug that caused a spurious warning message when compiling certain types of expressions involving property pointers. The warning did not affect code generation, but it was incorrect and has been removed.

Changes for version 3.0.2 (September 27, 2000)

Fixed a compiler problem that caused the compiler to go into an infinite loop (and therefore freeze up) when confronted with a 'switch' statement containing code before the first 'case' or 'default' label. This has been corrected; the compiler now reports an error (such code is unreachable) and continues with the compilation.
Fixed a minor compiler problem that generated a spurious warning message in a certain situation. Specifically, if none of a 'switch' statement's 'case' labels led to code paths that could reach the next statement after the 'switch' (for example, if every code path reachable from a 'case' label led to a 'return' statement), but the 'switch' had no 'default' label, the compiler generated the warning message "unreachable statement" at the next executable statement after the 'switch'. This warning was incorrect because, in most cases, it is not safe to assume that every possible value of a switch's controlling expression is included in the list of explicit cases, hence the next statement following a 'switch' with no 'default' is reachable any time the controlling expression's value is not in the list of explicit 'case' labels. Note that this problem merely caused the spurious warning and did not affect code generation.

Changes for June 24, 2000

Fixed a compiler problem with try/catch statements. The compiler did not correctly generate handlers for any catch block past the first for a given try statement; this has been corrected.

Changes for version 3.0.1 (June 17, 2000)

The meaning of the syntax x.y and &y have changed slightly, in a way that will be transparent to most code. In the past, if y was a local variable, then x.y evaluated the local, then called the method on x specified by the property pointer value in the local; &y simply generated a compilation error because a local's address cannot be evaluated. This behavior has changed. Now, x.y and &y both ignore the local definition of y and interpreter y as a property name. This change is important because it allows code to refer to a property explicitly, even when a local of the same name has been defined in the code block. For example:
```
   myObject: object
     obj = nil
     setObj(obj) { self.obj = obj; }
   ;
```
In the past, the code above would have had to use a different name for the formal parameter variable obj, because it would not have been able to refer to the property of the same name. With the new interpretation, the code can distinguish between the local and the property by referring to the property explicitly using self.obj.
Note that it is still simple to obtain the old behavior of evaluating the local variable and calling a method via the resulting property pointer. To do this, simply enclose the local in parentheses: x.(y).

Changes for 5/21/2000

Add a new Vector intrinsic class, a subclass of Array that combines the reference semantics of an Array with the dynamic sizing capabilities of a List. Vector is substantially more efficient than List when constructing a collection iteratively.
Added some new List methods: sort, append, appendUnique.
Added new Array methods: sort, appendUnique.
Added an error message translation mechanism, which allows non-English versions of the interpreter's and compiler's error messages to be substituted at run-time. Messages can be loaded from an external file, so there is no need to recompile the system to switch languages. (At the moment, of course, only an English set of messages actually comes with the system, but it is hoped that a few translated versions will be contributed so that more languages will be supported "out of the box" in the future.)
Fixed a bug that reversed the order of arguments in calls to anonymous functions while running in the debugger.

Changes for 5/11/2000

Changed the name of the say function in the "tads-io" intrinsic function set to tadsSay. This allows the library to define its own higher-level function called say; since user code should almost always call the library's function rather than the low-level direct console output function, it is desirable to give the library version the shorter, more convenient name.
Added the appendUnique() method to the List and Array intrinsic classes.

Changes for 4/24/2000

Fixed a bug in the compiler that caused lost properties on objects under certain very complicated circumstances (the problem occurred when dictionaries and other objects were defined in a particular order).

Changes for 4/22/2000

Added the foreach statement.
Added the Collection and Iterator classes. List and Array are now subclasses of Collection, so these classes can create Iterator objects to visit their elements.
The Windows HTML interpreter now supports PNG transparency (this is a generic change to the Windows HTML renderer that will also be in HTML TADS 2.5.4). Note that only simple transparency is supported; full alpha blending is still not supported. PNG transparency now has its own systemInfo() capability code, SYSINFO_PNG_TRANS.

Changes for 4/16/2000

Fixed a bug that caused a compiler crash when a source file was completely empty (or contained only comments).
Fixed a bug that caused a compiler crash in certain situations involving multiple initializers in a single 'local' statement.

Changes since 3.0.0

Added the htmlify() method to the String class. This method converts any HTML markup-significant characters in the string to their HTML equivalents; in particular, it converts an ampersand ("&") to "&" and a less-than sign ("<") to "<", and can also optionally quote spaces, tabs, and newlines to ensure display fidelity for these whitespace characters as well.
Added a shortest-match modifier to the regular expression closure operators ("*", "+", and "?"). This feature provides precise control over how matches are allocated in expressions involving multiple closures.
Added the non-capturing modifier to the regular expression group syntax; this allows a parenthesized group to be omitted from the counted groups.
Added look-ahead assertions to the regular expression syntax.
Added the regular expression interval operator, which provides a compact notation for specifying a specific number of repetitions of a sub-expression.
Renamed a few list methods and array methods, and expanded both sets for greater consistency and more complete functionality:
- indexOf
- indexWhich
- valWhich
- lastIndexOf
- lastIndexWhich
- lastValWhich
- countOf
- countWhich
- mapAll
- applyAll (arrays only)
- forEach
- getUnique
When the default start-up module (_main.t) is automatically included in a build, _main.t is linked in first. It was formerly linked in last, which didn't allow 'modify' or 'replace' to be used with objects defined in the module.
When running under the debugger, RuntimeError exceptions now include stack trace information (with source line information) in the exceptionMessage string associated with the exception object. This makes it easier to track down where a run-time error occurred. Note that this information is available only when running under the debugger, because this is the only time the system has access to the necessary source line information.
Added a "character map library" mechanism to the stand-alone interpreter. This new feature allows a set of character map (.tcm) files to be bundled with a stand-alone game, eliminating the need to distribute separate .tcm files with a stand-alone game. (Having to distribute .tcm files seemed to defeat the purpose of building a stand-alone executable. The new bundling feature still allows users with localizations that aren't included in the standard character map set to add their own .tcm files, but it makes character mappings entirely invisible for most users.)
Added CP1250.TCM (a character set mapping for the Windows Eastern/Central European code page), CP850.TCM (DOS OEM Latin 1), and CP852.TCM (DOS OEM Latin 2) to the default character map set for Windows.

Changes since 03/30/2000

Slightly changed the InitObject mechanism. The class formerly known as InitObject is now called PreinitObject, and a new class InitObject has been added. The new InitObject does the same thing that PreinitObject does, but does it at regular program start-up rather than pre-initialization. This change makes the pre-initialization and regular initialization mechanisms work the same way. In addition, to make this mechanism more generic, both InitObject and PreinitObject now descend from a base class called ModuleExecObject; this class should be usable as the base class for other types of modular execution objects, such as perhaps a post-restore initializer sequence, a command parsing initializer sequence, and so on. Refer to the library pre-initialization documentation for details.
Added the -r option to the interpreter, allowing games to be restored directly from the command. The saved state files now include information on the image file that created them, so if you're restoring a game, you don't have to specify the image file; this particular feature also allows double-clicking on a saved state from the desktop to start the interpreter, load the image file, and restore the saved state.
The GrammarProd intrinsic class's parseTokens() method now includes truncated matches to dictionary words (according to the dictionary's truncation length setting) in its structural analysis. The method also includes truncated matches (again, using the dictionary setting) for literal tokens in the grammar. If you don't want to allow truncated matches, simply change the dictionary's truncation length setting to zero.

Changes since 03/26/2000

Added a new library pre-initialization mechanism based on "initialization objects" rather than a simple preinit() method. This new mechanism should be especially useful for library developers, since new initialization objects can be plugged in without touching any library or user code
It is now possible to extend intrinsic classes with user-defined methods.

Changes since 03/21/2000

The method-based API to certain functions that were formerly implemented as intrinsics is now official. The trailing underscores on the interim method names have been removed, and the corresponding functions have been removed from the intrinsic function sets.
- getSuperclassList() is now Object.getSuperclassList()
- isClass() is now Object.isClass()
- propDefined() is now Object.propDefined()
- propType() is now Object.propType()
- length() is now List.length() and String.length()
- sublist() is now List.sublist()
- intersect() is now List.intersect()
- car() and cdr() are now List.car() and List.cdr()
- substr() is now String.substr()
- toUpper() is now String.toUpper()
- toLower() is now String.toLower()
- find() is now List.find() and String.find()
- toUnicode() is now String.toUnicode()
This change will, of course, necessitate recompiling all code, and will require changing code that calls any of the functions that have been migrated to methods. The sample code included in the distribution has been updated to reflect the changes, and the documentation has also been updated.
Renamed the getSize() method in the Array class to length(), for consistency with List and String.
Added the 'is in' and 'not in' operators. See the "is in" and "not in" expressions section.
The debugger now has "program arguments" settings. You can access these settings via a dialog, which you can open using the "Program Arguments" item on the "Debug" menu. You can use the program arguments to control script file reading, output logging, and the argument string that is passed to your program's "_main()" entrypoint procedure.
Added several new regular expression features: <Case> and <NoCase>, <Alpha>, <Upper>, <Lower>, <Digit>, <AlphaNum>, <Space>, <Punct>. Refer to the new regular expressions section of the documentation for details.
Enhanced the regular expression parser to detect and remove cycles in compiled patterns. It is possible (pretty easy, actually) to introduce "infinite loops" into a pattern; the easiest way to do this is to put a zero-or-more closure inside another closure, as in "(.*)+" (this has an infinite loop because the expression in parentheses can match zero characters, and that match can be repeated any number of times), but much more complex and subtle types of cycles are possible and can be inadvertantly constructed. Eliminating the infinitely repeating zero-length matches obviously doesn't change the meaning of the expression, since one repetition of a zero-length match is as good as a million, so the regular expression matcher simply detects and removes these loops and then carries on as normal.
Updated StartI3.t and StartA3.t (the starter games in the Workbench kit) to work with _main.t, so you don't have to compile them with -nodef. (This also has the benefit of making the files a whole lot simpler.) Also updated them to use method calls rather than intrinsic function calls where appropriate.
Updated the sample files to use the standard _main.t startup and new property functions.

Changes since 03/12/2000

Added default display methods, which allow string display to be routed through a method of the active "self" object in effect each time a string is displayed and each time an expression embedded in a string via the << >> syntax is displayed. This powerful new feature allows for per-object output filtering, and allows for "stateful" filtering (in that the filtering function is a method of the object that initiated the filtering, and can therefore look at properties of "self" to perform its work).
Added the "short form" anonymous function syntax, which is much more compact than the long form, but can only be used to define functions that consist solely of a single expression.
Added the subset() and applyAll() methods to the array and list intrinsic classes.
Added documentation for the List intrinsic class.
Added the -cs interpreter option, which allows the user to specify a character set to use for the display and keyboard. Refer to the new interpreter section in the documentation.
As mentioned above, there is a new section on the interpreter in the documentation.
The TADS 3 HTML interpreter and debugger for Windows now use a separate registry key for storing their preference settings. In addition, the TADS 3 debugger's global preferences file is now called HTMLTDB3.TDC. These changes should allow TADS 2 and TADS 3 installations to co-exist independently on a single system, without affecting one another's stored configuration settings.
Anonymous function objects are now represented by their own intrinsic class. This is a mostly internal change, but does have the benefit of enabling the debugger to display the type of an anonymous function object (before, the debugger only knew that they were objects).
Made some internal changes to the way anonymous function context objects are implemented to make them more efficient. (In particular, context objects are now arrays, not TADS objects; array index lookup is faster than TADS object property lookup.)
Moved the code to Visual C++ 6 (which involved no changes, not surprisingly, although the new C++ compiler caught a few dubious constructs and generated helpful warnings, all of which have been cleaned up).