Appendix E

This chapter describes how the compiler and interpreter handle errors. A list of errors is provided.

Errors and Error Recovery

When the TADS Compiler detects a syntax or other error in your source file, it attempts to skip ahead to the end of the offending program section. Unfortunately, because the program has a problem, TADS sometimes becomes confused and issues several spurious error messages that are all really due to the original error.

When compiling code, such as inside a method, TADS will try to skip the statement that caused the error; it simply looks for the semicolon that ends the statement. This strategy is most likely to backfire when the error was due to a missing semicolon in the first place.

When compiling an object definition outside of code, TADS will skip the entire object that caused the error. Again, it skips ahead to the next semicolon. If program code intervenes, this often results in more errors; these errors are generally of the form “Expected object or function definition.” You can normally ignore such errors when several of them occur consecutively, and look only at the first error which started the trouble, since the subsequent errors may be part of the compiler’s attempts to recover from the original error. Once an object or function definition does show up, TADS will normally stop complaining.

Classes of Errors

TADS has four classes of errors. TADS recovers from errors based on their class.

A fatal error is one from which the compiler is totally unable to recover; these are generally due to missing files or lack of memory. TADS cannot continue operating after a fatal error, so it terminates.

A compile-time error results when the compiler detects a problem with your source code, such as a syntax error, or an undefined symbol. TADS attempts to recover from these errors by skipping the section of code that had the error. When a compile-time error is found in your source code, even though the compiler will continue to process your game, you won’t be able to run the game until you have fixed the error.

A warning is generated when the compiler detects a questionable construct and wishes to bring it to your attention. Warnings do not otherwise affect compilation; they are produced purely for your information. You should carefully check each warning message to ensure that it’s not justified before choosing to ignore it.

A run-time error is produced when your program, while it’s running, does something illegal, such as adding two objects together; these errors cannot be detected during compilation, because they depend on the state of your program as it runs. If you have compiled your program with source-level debugging information, TADS will automatically produce a symbolic trace showing the function or method that was executing when the error occurred, as well as the function or method that called it, and so forth. When debugging information is not present, TADS will only be able to show the error message, and won’t be able to provide any information on where it occurred. After a run-time error has occurred, TADS will attempt to continue executing your game by dropping what it was doing when the error occurred and returning to the player command line.

Error Listing

This section lists the errors that TADS generates. In addition, we explain the conditions that give rise to the errors, and what steps to take to fix them.

To make it easier for you to find information on an error in this book, all TADS errors and warning messages are numbered. When TADS displays an error, it will preface the message with a code such as “TADS-382”; you can use the number in this error code to find the description of the error in the numerically sorted listing in this section.

TADS-1: fatal: out of memory

The program has run out of memory. Even though TADS uses a virtual memory subsystem that allows your game to exceed available memory by swapping portions of memory to a disk file, TADS allocates a certain amount of memory that cannot be swapped to disk. As TADS executes, it extends the size of the virtual object cache, and also allocates fixed (unswapped) memory. It is possible for the cache to grow so large that additional fixed memory cannot be allocated; when this happens, TADS runs out of memory and can’t continue. When this error occurs, the TADS compiler will display a message indicating the size of the virtual object cache; you should re-run the compiler with a smaller setting for the -m (cache size limit) option. See appendix C of this manual for details.

TADS-2: fatal: error seeking in file

An operating system error occurred seeking in a file. This usually indicates an internal problem with TADS.

TADS-3: fatal: error reading from file

An operating system error occurred reading from a file. This usually indicates an internal problem with TADS.

TADS-4: fatal: no more page slots

The virtual memory subsystem does not have any more space for allocating internal tables to track virtual memory objects. The internal limits are high enough that this error should never occur.

TADS-5: attempting to reallocate a locked object

This error indicates an internal problem with TADS.

TADS-6: fatal: swapfile limit reached - out of virtual memory

The limit you specified with the -ts option for the size of the swap file has been reached. You should raise or remove this limit.

TADS-7: fatal: error writing file

An operating system error has occurred writing a file. This usually indicates that the disk is full. You should try to make more space available by deleting files if possible, or by using another disk with more space available.

TADS-8: fatal: exceeded swap page table limit

The compiler has reached its internal limit for memory to track objects swapped out to disk. This limit is high enough that this error should never occur.

TADS-9: requested client object number already in use

This error indicates an internal problem with TADS.

TADS-10: fatal: client mapping table is full

The compiler has reached an internal limit. This limit is high enough that this error should never occur.

TADS-11: fatal: no memory, even after swapping/garbage collection

The virtual object cache is full or too fragmented to allocate needed memory. The most likely problem is that the cache is too small; increasing the size of the cache (specified with the -m compiler and run-time options) should alleviate this problem.

Note that it is possible to get this error message if you have an extremely large object in your game. If this happens it's best to split the code for the object into two objects, then set the second to be an instantiation of the former’s class. (ie: have the second object inherit the code from the first.) To take a practical example, let's say the code for the basic thing class object gets too big. You can always move a lot of your code into the item class, which inherits from thing.

TADS-12: fatal: no memory to resize (expand) an object

The virtual object cache is full. See error 11 above.

TADS-13: unable to open swap file

The swap file cannot be created. This could mean that the filename is invalid, or the indicated device (volume) or directory does not exist, or that the disk is full or write-protected.

TADS-14: can't get a new object header

The virtual memory subsystem has run out of memory. See error 11 above.

TADS-15: mcm cannot find object to load (internal error)

This error indicates an internal problem with TADS.

TADS-16: attempting to free a locked object (internal error)

This error indicates an internal problem with TADS.

TADS-100: invalid token

Your source file contains a character that TADS does not recognize. It's a good idea to search for spurious control characters, for example.

TADS-101: end of file while scanning string

Your source file ends within a quoted string. This usually indicates that you left out the closing quote of a string somewhere in the file.

TADS-102: symbol too long - truncated to "xxx"

The indicated symbol is too long. Processing can continue, but TADS will only pay attention to the truncated version.

TADS-103: fatal: no space in local symbol table

The local symbol table is full. You can increase the amount of space available for local symbols with the -ml compiler option; see appendix C.

TADS-104: invalid preprocessor (#) directive

You have specified an invalid preprocessor directive. When a pound sign (#) occurs in the first column of your source file, the compiler expects a valid preprocessing directive (such as include) to follow.

TADS-105: no filename in #include directive

You have specified a #include directive with no filename. The filename must occur on the same line as the #include directive, and must be enclosed in double quotes or angle brackets.

TADS-106: invalid #include syntax

The #include directive must be followed on the same line by a filename enclosed in double quotes or angle brackets. The # character must also be the first character on the line - it cannot be preceded by a space character.

TADS-107: can't find included file "xxx"

The compiler could not open the specified include file. Check to make sure that the file is in one of the directories specified with the -i compiler options (see appendix C).

TADS-108: no matching delimiter in #include filename

The filename of a #include directive was not properly terminated with a double quote or right angle bracket.

TADS-109: fatal: out of space for symbol table expansion

The symbol table is too large. Since the symbol table is stored in the virtual object cache, this generally indicates that the compiler is out of cache memory.

TADS-110: input line is too long

Your input file contains a line that is too long. The compiler can handle extremely long lines (up to about 16,000 characters). Break the long line into two or more lines.

TADS-111: warning: file "xxx" already included; #include ignored

The specified file has already been included and will not be included again. This warning is most often issued when using pre-compiled header files (see appendix C), and is almost always harmless.

TADS-112: unknown pragma (ignored)

TADS-113: unexpected #else

TADS-114: unexpected #endif

TADS-115: unexpected #elif

TADS-116: #if nesting too deep

TADS-117: #define symbol already defined -- redefinition ignored

TADS-118: warning: symbol not defined in #undef

TADS-119: missing #endif

TADS-120: macros nested too deeply

TADS-121: invalid argument for defined() preprocessor operator

TADS-122: #if is not implemented

TADS-123: #elif is not implemented

TADS-124: Error directive: "xxx"

TADS-200: operation is too big for undo log

A single run-time operation has exceeded the size of the undo log. The undo log will be discarded, since it can no longer be used to roll back game state.

TADS-201: no more undo information

No more undo information is available in the undo log. This means that you have applied all undo information, and cannot undo any more turns.

TADS-202: incomplete undo (no previous savepoint)

While attempting to roll back to a savepoint, the undo log ran out of information. This means that a turn may be partially undone.

TADS-300: expected "token"

The compiler requires the specified token. Insert the required token.

TADS-301: expected a symbol

The compiler requires a symbol in this context, and found something else.

TADS-302: expected a property name

The compiler requires a property name in this context, and found something else.

TADS-303: expected an operand

The compiler requires an operand in an expression, and found something else.

TADS-304: expected a comma or closing paren (in arg list)

Your program has a syntax error in an argument list; variables must be separated by commas, and the argument list must be terminated with a right parenthesis.

TADS-305: fatal: no space for new parse node

The compiler is out of space parsing an expression. This can sometimes happen with very long strings, especially those that contain embedded expressions. Use the compiler’s -mp switch to increase the amount of space available for expression parsing.

TADS-306: expected object name

The compiler requires an object name in this context.

TADS-307: redefining symbol as external function

You have declared a symbol as an external function when it already has been declared as another type.

TADS-308: redefining symbol as function

You have declared a symbol as a function when it already has been declared as another type.

TADS-309: can't use "class" with function/external function

You have specified the class keyword in a function or external function declaration, which is not allowed (because it makes no sense).

TADS-310: unary operator required

Your expression requires a unary operator (that is, an operator which takes a single operand, such as - or not).

TADS-311: binary operator required

Your expression requires a binary operator (that is, an operator which takes two operands, such as * or and).

TADS-312: invalid binary operator

You have specified an invalid binary operator.

TADS-313: invalid assignment

You have used an invalid expression on the left hand side of an assignment operator (:=). You can only assign values to local variables, properties, and list elements. It is invalid, for example, to assign a value to an expression such as (1+1).

TADS-314: variable name required

The compiler requires a variable name in this context.

TADS-315: comma or semicolon required in local list

Variables declared in a local statement must be separated by commas, and the list must be terminated by a semicolon.

TADS-316: right brace required (eof before end of group)

Your source file is missing the right brace to close a statement block.

TADS-317: 'break' without 'while'

The break statement can only occur within a while, for, do, or case statement. Your source file contains a break statement that is not associated with one of these statements.

TADS-318: 'continue' without 'while'

The continue statement can only occur within a while, for, or do statement.

TADS-319: 'else' without 'if'

Your source file contains an else that is not associated with an if statement. Note that TADS version 1 ignored a semicolon between a closing brace and an else keyword; in version 2, the semicolon is considered a null statement which terminates the if statement. If your program compiled correctly with TADS version 1 but encounters error 319 with TADS version 2, you should specify the -1e compiler option, which will cause the compiler to adopt the behavior of version 1 with respect to this construct. See appendix C for details.

TADS-320: warning: possible use of '=' where ':=' intended

The compiler has detected a statement which it suspects is an assignment that has been accidentally miscoded with “=” (which is the relational equality comparison operator) instead of “:=” (the assignment operator). The compiler is almost always right in these situations; you should check the statement to ensure that you coded what you really meant.

TADS-321: unexpected end of file

The compiler has encountered the end of your source file when it thought it had more work to do. This could mean that you have left off the semicolon terminating an object definition, or a right brace terminating a function.

TADS-322: general syntax error

The compiler has detected an ill-formed statement.

TADS-323: invalid operand type

One of the operands in an expression is not suitable for the operator. This usually means that a constant in the expression is of the wrong type.

TADS-324: fatal: can't expand local symbol table

The compiler cannot allocate space for a new local symbol table. You should specify a larger value with the compiler’s -ml option (see appendix C).

TADS-325: fatal: can't expand argument symbol table

The compiler cannot allocate space for a new argument symbol table. You should specify a larger value with the compiler’s -ml option (see appendix C).

TADS-326: redefining a function which is already defined

You are attempting to define a function twice.

TADS-327: 'case' or 'default' not in switch block

You have coded a case or default label outside of a switch statement.

TADS-328: constant required in switch case value

The values in case labels must be constants. You have specified a non-constant expression as a case label.

TADS-329: label required for 'goto'

You have omitted the label of a goto statement, or the symbol specified is something other than a label.

TADS-330: 'goto' label never defined

A label used in a goto statement is not defined within the function or method in which the goto statement occurred. The goto statement can only be used with labels within the same function or method as the goto statement itself.

TADS-331: too many superclasses for object

You have specified too many superclasses in an object definition.

TADS-332: redefining symbol as object

You are attempting to define a symbol as an object, but you have already defined the symbol as something else.

TADS-333: property being redefined in object

You are attempting to define a symbol as an object, but the symbol has already been used as a property.

TADS-334: invalid property value

The value specified for a property’s initial value in an object definition is not valid.

TADS-335: invalid vocabulary property value

The value specified for a vocabulary property is invalid. You can only use single-quoted strings for vocabulary properties.

TADS-336: invalid template property value (need string)

The value specified for a template is invalid. You can only use a single-quoted string for a template property.

TADS-337: template base property name too long

The base name of a template property value is too long. Since these values must be appended to the strings do, verDo, io, and verIo, the resulting symbols will be up to five characters longer than the property value itself.

TADS-338: too many templates (internal compiler limit)

You have defined an object with too many templates.

TADS-339: invalid value for compound word (string required)

You have specified something other than a single-quoted string in a compoundWord definition.

TADS-340: invalid value for format string (string required)

You have specified something other than a single-quoted string in a formatString definition.

TADS-341: invalid value for synonym (string required)

You have specified something other than a single-quoted string in a synonym definition.

TADS-342: undefined symbol

You have referenced a symbol which has not been defined.

TADS-343: invalid value for specialWords list (string required)

You have specified something other than a single-quoted string in a specialWords list.

TADS-344: "self" is not valid in this context

TADS-345: warning: possible unterminated string

TADS-346: 'replace'/'modify' not allowed with external function

TADS-347: 'modify' not allowed with function; ignored

TADS-348: 'modify'/'replace' ignored with forward declaration

TADS-349: 'modify' can only be used with a defined object

TADS-350: warning: replacing specialWords (please use 'replace')

TADS-351: nil allowed only with modify specialWords

TADS-353: 'local' is only allowed at the beginning of a block

Local statements must appear at the very top of a block of code. You can't precede a local statement by anything except another local statement.

TADS-354: implied verifier '"xxx"' is not a property

TADS-355: invalid command template flag

TADS-356: flags are not allowed with old file formats

TADS-357: warning: operator '&' interpreted as unary in list.

The meaning of this error is explained in detail in the section of C-style operators.

TADS-358: warning: possibly incorrect assignment

The meaning of this error is explained in detail in the section of C-style operators.

TADS-359: speculative evaluation failed

TADS-400: object cannot grow any bigger - code too big

The object is too large. This is unlikely to occur, since the limit on the size of an object is very high; however, if it does, you can break the object up into two or more objects, with the first object inheriting from the second.

TADS-401: no more temporary labels/fixups (internal compiler limit)

The compiler has run out of space during code generation. You should reduce the complexity of your code (for example, reduce the nesting of loops and conditional statements).

TADS-402: (internal error) label never set

This error indicates an internal problem with TADS.

TADS-403: invalid datatype for list element

A list element is of an invalid type.

TADS-404: fatal: too many debugger source line records (internal limit)

Your source program has generated too many debugger source line records. This is an internal TADS limit; the limit is high enough that this error should never occur.

TADS-450: vocabulary being redefined for object

You have defined a vocabulary word more than once for a particular object.

TADS-451: fatal: too many vocabulary word relations (internal limit)

TADS-452: same verb defined for two objects

The parser generates a warning if you use the same vocabulary word as a verb property for multiple objects. If you define the same vocabulary word as a verb multiple times, the parser will arbitrarily use one of the deepverb definitions, and ignore the others; if you weren’t aware you were re-using a verb, it could be difficult to track down why your verb handlers were never being called. This warning flags this situation for you.

TADS-500: location of object "xxx" is not an object

This is a warning. In most cases, you want an object’s location property to refer directly to another object, since this allows the compiler to generate a matching contents property automatically. Under certain conditions, you may intentionally use a method for a location value. When you have intentionally coded something other than an object for a location value, you can add the property locationOK = true to the object, which will suppress this warning message.

TADS-501: contents of object "xxx" is not list

You should almost never code a contents property for an object, since the compiler automatically sets up these properties.

TADS-502: overflow trying to build contents list

A contents property list has grown too long. This is an internal limit; move some of the contents of the object somewhere else.

TADS-503: required object "xxx" not found

The specified object has not been defined in your game, but the TADS compiler requires you to define it.

TADS-504: warning - object "xxx" not found

The specified object has not been defined by your game. This is not an error, because the object is not required by TADS; however, TADS generates this warning in case you thought you had declared this object.

TADS-505: too many built-in functions (internal error)

This indicates an internal problem with TADS.

TADS-600: unable to open game for writing

The game binary file could not be created. This could mean that the name is invalid, or the device (volume) or directory is invalid or does not exist, or that the disk is full or write-protected.

TADS-601: error writing to game file

An operating system error occurred writing to the game file. This usually means that the disk is full.

TADS-602: too many sc's for writing in fiowrt

This indicates an internal problem with TADS.

TADS-603: undefined function "xxx"

The specified function was called or declared, but never defined.

TADS-604: undefined object "xxx"

The specified object was referenced, but never defined.

TADS-605: undefined symbols found

One or more undefined symbols was found in your program.

TADS-606: unable to open game for reading

The game binary file couldn’t be opened. This could mean that the file does not exist, or that the filename is invalid, or that the device (volume) or directory is invalid or does not exist.

TADS-607: error reading game file

An operating system error has occurred reading the game file. This could mean that the file has been corrupted.

TADS-608: file has invalid header - not a TADS game file

The specified binary game file is not a TADS game file. This could mean that you have specified the incorrect file, or that the file has become corrupted.

TADS-609: unknown resource type in .gam file

The game file contains invalid data. This could mean that the file has become corrupted. It’s also possible to see this error when playing a game built for multimedia TADS using an older TADS runtime that doesn’t support the new features.

TADS-610: unknown object type in OBJ resource

The game file contains invalid data. This could mean that the file has become corrupted.

TADS-611: file saved by different (incompatible) version

The game file or save file was created by an incompatible version of TADS or of the game. You should either use the version of the TADS run-time that matches the version used to compile the game, or you should recompile the game with a compiler that matches your run-time.

TADS-612: error loading object on demand

An object could not be loaded. This could mean that the game file is corrupted, or that the disk file has become unavailable (for example, you have removed the floppy on which the game file was stored from the disk drive). It can also happen if you recompile a game file while a runtime is being used to play the same file.

TADS-613: object too big for load region (internal error)

This indicates an internal problem with TADS.

TADS-614: did not expect external function

This indicates an internal problem with TADS.

TADS-615: compiler cannot write this file version

TADS-617: resource file "xxx" has an invalid header

Displays the name of an invalid external resource file if there are problems loading it.

TADS-990: user requested cancel of current operation

You have cancelled compilation of your game, such as by clicking the “cancel” button on the Macintosh compiler.

TADS-1001: stack overflow

Run-time stack space has been exceeded. This usually means that your program has gone into infinite recursion - that is, a function is calling itself repeatedly and looping forever. If you're absolutely certain that your code does not go into an infinite loop you can increase the size of the run-time stack by using the -ms run-time parameter (see appendix D).

TADS-1002: heap overflow

Run-time heap space has been exceeded. You can increase the size of the run-time heap with the -mh option (see appendix D).

TADS-1003: numeric value required

A run-time operation that requires a numeric value was invoked with some other type of value.

TADS-1004: stack underflow

Too many elements have been removed from the run-time stack. This usually indicates that you have called a function with an invalid number of arguments.

TADS-1005: logical value required

A run-time operation that requires a logical value true or nil was invoked with some other type of value.

TADS-1006: invalid datatypes for magnitude comparison

A magnitude comparision operator (>, <, >=, or <=) was called with something other than a number or string.

TADS-1007: string value required

A run-time operation that requires a string value was invoked with some other type of value.

TADS-1008: invalid datatypes for binary '+' operator

The binary “+” operator works only on strings, lists, and numbers.

TADS-1009: invalid datatypes for binary '-' operator

The binary “-” operator works only on lists and numbers.

TADS-1010: object value required

A run-time operation that requires an object value was invoked with some other type of value. A very common way to produce this error is to try and call a method that doesn't exist. For example, if you check to see if ( Me.location = startroom ) and Me is actually in nil, then you'll see the 1010 error.

TADS-1011: function pointer required

A run-time operation that requires a function pointer value was invoked with some other type of value.

TADS-1012: property pointer value required

A run-time operation that requires a property pointer value was invoked with some other type of value.

TADS-1013: 'exit' statement executed

If this error occurs, it indicates an internal problem with TADS. It can also mean you put an exit call in a place where it shouldn't be.

TADS-1014: 'abort' statement executed

If this error occurs, it indicates an internal problem with TADS. It can also mean you put an abort call in a place where it shouldn't be.

TADS-1015: 'askdo' statement executed

If this error occurs, it indicates an internal problem with TADS.

TADS-1016: 'askio' executed; preposition is object #n

If this error occurs, it indicates an internal problem with TADS.

TADS-1017: 'quit' executed

If this error occurs, it indicates an internal problem with TADS.

TADS-1018: 'reset' executed

If this error occurs, it indicates an internal problem with TADS.

TADS-1020: list value required

A run-time operation that requires a list value was invoked with some other type of value.

TADS-1021: index value too low (must be >= 1)

The value of a list index operation was below 1.

TADS-1022: index value too high (must be <= length(list))

The value of a list index operation was higher than the number of elements in the list.

TADS-1023: invalid type for built-in function

Your program called a built-in function with the incorrect type of arguments.

TADS-1024: invalid value for built-in function "xxx"

Your program called a built-in function with the incorrect type of arguments.

TADS-1025: wrong number of arguments to built-in

Your program called a built-in function with the incorrect number of arguments.

TADS-1026: wrong number of arguments to user function

Your program called one of its own functions or methods with the incorrect number of arguments.

TADS-1027: string/list not allowed for fuse/daemon arg

The parameter to a fuse or daemon (specified in a setdaemon() or setfuse() call) cannot be a string or a list.

TADS-1028: internal error in setfuse/setdaemon/notify

This indicates an internal problem with TADS.

TADS-1029: too many fuses

You have attempted to register too many fuses simultaneously. The limit is 100.

TADS-1030: too many daemons

You have attempted to register too many daemons simultaneously. The limit is 100.

TADS-1031: too many notifiers

You have attempted to register too many notifiers simultaneously. The limit is 200.

TADS-1032: fuse not found in remfuse

You have tried to remove a fuse that is not active. No longer used as of TADS 2.0.13 - you can remove an inactive fuse.

TADS-1033: daemon not found in remdaemon

You have tried to remove a daemon that is not active. No longer used as of TADS 2.0.13 - you can remove an inactive daemon.

TADS-1034: notifier not found in unnotify

You have tried to remove a notifier that is not active. No longer used as of TADS 2.0.13 - you can remove an inactive notifier.

TADS-1035: internal error in remfuse/remdaemon/unnotify

This indicates an internal problem with TADS.

TADS-1036: load-on-demand loop: property not being set (internal)

This indicates an internal problem with TADS.

TADS-1037: undefined object "xxx" in class list

This indicates that a superclass object has not been defined.

TADS-1038: c-string conversion overflows buffer (internal limit)

This indicates an internal problem with TADS.

TADS-1039: invalid opcode (internal error)

This indicates an internal problem with TADS, or a corrupted game file.

TADS-1040: property evaluated for non-existent object

You have attempted to take a property of an object which has not been defined. This probably means that you are attempting to execute a game with compiler errors.

TADS-1041: unable to load external function "xxx"

The specified external function (user exit) is not available, because it has not been added to the game with the proper resource compiler (or other appropriate operating system-dependent mechanism). See appendix F for information on writing external functions.

TADS-1042: error executing external function "xxx"

The specified external function cannot be executed. See appendix F for information on writing external functions.

TADS-1043: circular synonym

You have declared a synonym which refers to another synonym which refers to the original synonym.

TADS-1044: divide by zero

You can't divide anything by zero. Not possible

TADS-1045: only objects allocated with 'new' can be deleted

You can't delete an object that wasn't created on the fly as a dynamic object.

TADS-1046: invalid superclass for 'new'

TADS-1047: fatal: out of space in parser stack

TADS-1048: invalid file handle

TADS-1500: invalid command-line usage

You have specified invalid command line arguments. This error will always be accompanied with an informational message describing the proper command line arguments.

TADS-1501: error opening input file

The debugger could not open the specified input file.

TADS-1502: game not compiled for debugging - use -ds option

You must use the -ds option when compiling your game if you wish to use it with the debugger.

TADS-1503: unable to create error logging file

You may have specified an invalid filepath or folder as the output file for the error log.

TADS-1504: parse pool + local sizes too large - total cannot exceed value

You have tried to specify a parse pool and local symbol table size that exceeds the value permitted.

TADS-1505: stack size too large - cannot exceed value

You have tried to specify a stack size larger than the maximum value that TADS allows.

TADS-1506: error creating string capture file

You may have specified an invalid filepath or folder as the output file for the string capture function.

TADS-2001: error setting breakpoint: unknown symbol

You have attempted to set a breakpoint on a non-existent symbol.

TADS-2001: I'm afraid I can't do that, Dave

The pod bay doors could not be opened. Check the AE-35 unit for a possible malfunction.

TADS-2002: error setting breakpoint: symbol is not a property

The specified symbol is not a property.

TADS-2003: error setting breakpoint: symbol is not a function

The specified symbol is not a function.

TADS-2004: error setting breakpoint: property not defined in object

The specified property is not defined in the specified object.

TADS-2005: error setting breakpoint: property is not code

The specified property is not code, but some other type of value. Breakpoints can only be set in executable code.

TADS-2006: error: breakpoint is already set at this location

You have attempted to set more than one breakpoint at the same location.

TADS-2007: error setting breakpoint: breakpoint not at line

You have attempted to set a breakpoint somewhere other than at a code location associated with a source line.

TADS-2008: too many breakpoints

The debugger cannot set any more breakpoints. You must remove one or more breakpoints before additional breakpoints can be set.

TADS-2009: breakpoint was not set

The breakpoint could not be set as requested.

TADS-2010: too many symbols in eval expression (internal limit)

You have specified an excessively complex expression. Simplify the expression.

TADS-2011: unable to find source file "xxx"

The specified source file cannot be opened.

TADS-2012: assignment to local is illegal in watch expression

You cannot make an assignment to a local variable within a watch expression.

TADS-2013: inactive frame (expression value not available)

The specified frame can not be accessed because it is no longer active. The value of the expression can not be obtained.

TADS-2014: too many watch expressions

You must remove one or more watch expressions before setting additional watch expressions.

TADS-2015: watch expression not set

The requested watch expression could not be set.

TADS-2016: extraneous text after end of command

Your command has extra text past the end that the debugger did not understand.

TADS-2017: error setting breakpoint: symbol is not an object

The specified symbol is not an object.

TADS-2018: debugger is inactive (program running)

TADS-2019: breakpoint is already used

TADS-2020: speculative evaluation failed (runtime)