1DGD 1.0.a0 2 3Differences with LPmud 3.1.2: 4 5Language: 6 7 - No keywords "protected", "public" and "status". 8 - Mappings, as in the mappings package that I made for LPmud, with one 9 difference: there is no m_delete(), and the normal way to remove an 10 index/value pair from a mapping is to set the value to 0. 11 - Typechecking is more strict. As in LPmud 3.1.2, functions are not 12 typechecked if they have no declared type, but it is possible to enforce 13 typechecking in all objects. 14 - call_other() does not require a cast. If the type is not clear from the 15 context, a cast is recommended. 16 - Types such as int**, string***** are possible. 17 - Initializers are not supported. 18 - Indexing out of range is not allowed on arrays and strings. Negative 19 indices can be used to offset from the end of the array/string (-1 last, 20 -2 last but one, etc). 21 - Indexed string assignments such as foo = "bar"; foo[0] = 'B'; are possible. 22 - The zero size array and zero size mapping are not globally shared, and 23 comparisions such as array == ({ }) will fail. 24 - It is illegal to declare any functions, function prototypes or variables 25 before inheriting. 26 - Inheritance is completely different. There are two kinds of inheritance, 27 virtual and labeled. 28 Virtual inheritance is the default. If A is inherited by B and C, and D 29 inherits B and C, then the variables of A are in D only once. It is illegal 30 to inherit two different functions with the same name, unless function F1 is 31 inherited in the object that defines function F2, or if at least one of 32 F1 and F2 is private. It is illegal to inherit two different variables 33 with the same name, unless at least one of them is private. It is 34 illegal to redeclare a non-private variable. Private functions are 35 private in the program that defines them, and cannot be used from inherited 36 objects. Private functions do not mask inherited functions, except in 37 the program in which they are defined. It is illegal to inherit two 38 different instances from an object. 39 Labeled inheritance uses the syntax inherit label "file"; Functions in 40 labeled inherited objects can be accessed with label::function(); 41 Variables in labeled inherited objects cannot be accessed from the 42 current program at all. Functions and variables need not be unique 43 between labeled inherited objects. It is possible to inherit the same 44 object with labeled inheritance twice; the different instances will not 45 share their variables. 46 - There is an object that is automatically (virtually) inherited in all other 47 objects, called the auto object for short. The auto object is shared 48 even between virtual inherits and labeled inherits. 49 - Predefined functions are called kfuns (kernel functions); the kfuns and 50 the non-private functions declared in the auto object together are called 51 efuns. Kfuns are assumed to be static functions inherited in the auto 52 object, with the added limitation that they cannot be called with 53 this_object()->kfun(). All static functions declared in the auto object 54 share this limitation. 55 - There is no class_specifier inherit "file"; This did not work in LPmud 3.1.2 56 anyhow. 57 - Function prototypes are always inherited together with the function. 58 - Function calls are typechecked if the called function is typechecked. It 59 is illegal to call a non-varargs function with the wrong number of 60 arguments from a typechecked function, even if the called function is 61 not typechecked itself. 62 - Kfuns are not treated differently from other inherited functions, so 63 destruct(this_object(), this_object()); will not cause a compile-time 64 error in an untypechecked function. 65 - Inherited functions may be redeclared with a different prototype. If 66 an inherited function is redeclared with a prototype only, and the function 67 itself is not declared in the same program, then all calls to the function 68 from that program will call an undefined function, which will result in a 69 runtime error. 70 - If object A declares function F, and B has only a prototype for function 71 F, calls to F from B will call function F in A if A and B are inherited 72 in the same object. 73 - It is illegal to inherit a function and a prototype for the same function 74 if the prototypes do not match. 75 - A call to an undeclared function from an untypechecked function implicitly 76 declares a prototype for the undeclared function that matches anything. 77 - this_object()->function(); can be used to call static functions, but not 78 private ones. 79 - foo->bar(gnu); is merely an alias for call_other(foo, bar, gnu); It is 80 therefore possible to redefine call_other() entirely. 81 - lock(expr); will evaluate expr without regard of execution cost, and with 82 extra space on the function call stack. It can only be used by the auto 83 object to ensure that execution does not halt inside a critical function. 84 - Any kfun can be redefined, just as ordinary inherited functions can. 85 catch() and lock() are not considered to be kfuns (they are not true 86 functions because catch(foo, bar) does not "call catch with two arguments"). 87 88Compiler: 89 90 - The built-in preprocessor conforms to the ANSI standard, except for the 91 following: 92 - No trigraphs. 93 - Successive string constants are not concatenated (use the + operator 94 instead). 95 - The suffixes U and L are not allowed on integer constants. 96 - No floating point constants. 97 - There is a standard include file which is included automatically. 98 - All #pragma directives are ignored. 99 - All integer constants may be in decimal (starting with 1-9), octal (starting 100 with 0), hexadecimal (starting with 0x) or a character constant 'x'. The 101 only escaped characters that are translated into something else in 102 character constants and string constants are \t and \n. 103 - The compiler is two-pass. In the first pass, the function is typechecked 104 and a parse tree is constructed. Constant folding and removal of dead 105 code is done. In the second pass, code for a virtual stackmachine is 106 generated. Jumps to jumps are optimized. Optionally, the second pass 107 may generate C code (not yet implemented). 108 109Interpreter: 110 111 - The interpreter has only 32 instructions. Kfuns are not part of the 112 interpreter proper. 113 - Objects are pure programs. They do not have inventories, environments, 114 are not alive, do not have actions (all of this can be simulated). 115 - Pathnames without a leading slash are considered to be relative to the 116 directory of the current object (i.e. /foo for the object compiled from 117 /foo/bar.c). 118 - create() is called if a function in an object is called for the first 119 time. It is not called if an object is loaded because it is inherited. 120 If it is desired that reset(0) is called instead, add the following to 121 the auto object: 122 123 void reset(int arg) { } 124 125 nomask void create() 126 { 127 reset(0); 128 } 129 130 - reset() is never called by the driver. Both reset on reference and reset 131 after a fixed period are easily simulated. 132 - clean_up() is never called by the driver. 133 - Text typed by a user is passed on by calling receive_message(text) in the 134 interactive object. The kfun send_message(text) can be used in interactive 135 objects to send text back to the user. 136 - There is no "master object" as in LPmud 3.1.2, but a "driver object" 137 instead (there is nothing masterly about it in DGD). It is used only to 138 translate pathnames for #include and inherit, and to supply the object 139 that is used for interactive connections. It does not inherit the 140 auto object, unless this is done explicitly. 141 - There is no shadowing. 142 - The default state of an object is swapped out. Strings and arrays are 143 only shared inside objects. If an array is exported from one object to 144 another, it will become a different array as soon as the object is swapped 145 out (this is guaranteed never to happen during execution). 146 - Self-referential datastructures will be deallocated when no more outside 147 references exist, because they do not belong in any object. 148 149Kfuns: DGD has about half of the kfuns of LPmud 3.1.2: 150 - No kfuns such as environment(), this_player(), add_action(). Simulate them 151 if you want them. 152 - There is no exec(), heart_beat(), wizlist() (simulate them). 153 - No parse_command(). It cannot be simulated, so people might want to port 154 it to DGD, but it will never become part of "pure" DGD. 155 - No alist kfuns. I prefer mappings, even if alists are more powerful. 156 - All file kfuns are unprotected. To get either native or compat mode 157 security, make the proper redefinitions in the auto object. 158 - The built-in editor uses a temporary file and is very close to ex. 159 - call_other() is typechecked if the called function is typechecked. Calling 160 a function that does not exist results in an error if the call has 161 arguments (I still have to think about this). 162 - There are no optional flag arguments to any kfun. 163 164DGD 1.0.a1 165 166 - ALLOCA() and AFREE() have replaced some instances of ALLOC() and FREE(), 167 and be used to allocate memory with alloca(), if available on the host. 168 - Mappings are now partially hashed. If a mapping grows by assigning to 169 an index/value that doesn't exist yet, the index/value pair is stored in 170 a hash table. Mappings are converted to sorted arrays of index/value 171 pairs when swapped out. 172 - Fixed some bugs in the compiler, interpreter and kfuns. 173 - Changed the way line numbers are stored. The interpreter no longer 174 maintains the current line number at runtime. 175 - Added int-only versions of some kfuns to speed up integer arithmetic in 176 typechecked programs. Typechecked functions are now typechecked at runtime 177 as well, to ensure that integer arguments are really integers. 178 179DGD 1.0.a2 180 181 - Better dead code removal. 182 - Mixed return values are cast to int if needed. 183 - Lvalues as function arguments are now handled properly. 184 - Fixed a problem with (exp1, exp2) in aggregates and function arguments. 185 - More untypechecked expressions are optimized. 186 - String constants are marked as such. 187 - Driver object has been enabled. 188 - It is now illegal to call any function with too many arguments, even if the 189 function has class vararg. 190 - I removed the error on call_other() to a non-existing function. 191 - When an object is cloned, or a function is called in it for the first time, 192 create() in the object will be called. 193 - Added config file which is read on startup. 194 - All ANSI escape sequences are now recognized in string constants and 195 character constants. Fixed a bug with #arg in macros. 196 - Created proper main loop that reads input and calls receive_message() for 197 the associated objects. 198 - Created (single user) comm package. DGD now works as a regular game driver. 199 - Overview of functions called by the gamedriver (can be static): 200 In the driver object: 201 * void initialize() 202 Initialize the mudlib. Called once at program startup. 203 * string path_ed_read(object, string) 204 Path translation for editor read. 205 * string path_ed_write(object, string) 206 Path translation for editor write. 207 * string path_object(object, string) 208 Object path translation (for find_object, clone_object, etc). 209 * string path_inherit(string, string) 210 Inherit file name translation. 211 * string path_include(string, string) 212 Include file name translation. 213 * object compile_object(string) 214 Called if the given argument could not be compiled. The driver 215 object can return an object that will be renamed to the wanted 216 object. The returned object may be a clone, and will remain 217 a clone (i.e. may not itself be cloned), even with the new name. 218 Modelled after "virtual objects" in MudOS, the American LPmud brand. 219 * object connect() 220 * void log_error(string, string, string, int) 221 Log a runtime error. 222 * string compile_log(string) 223 Return the name of the file to which compile time errormessages 224 should be appended. 225 In the user object: 226 * void open() 227 LPmud: login 228 * void close() 229 Called if the user connection to the mud is closed. 230 * void receive_message(string) 231 Called for user input. 232 In an object that uses the editor() kfun: 233 * void receive_message(string) 234 Called for editor output. 235 - Overview of the kfuns added: 236 * varargs mixed call_other(mixed, string, ...); 237 * object this_object(); 238 * varargs object previous_object(int); 239 Return the previous object n+1 steps back in the call_other chain. 240 * object clone_object(string); 241 * void destruct_object(object); 242 LPmud: destruct() 243 * string object_name(object); 244 LPmud: file_name() 245 * object find_object(string); 246 * string function_object(string, object); 247 LPmud: function_exists() 248 * object this_user(); 249 LPmud: this_player(1); 250 * string query_ip_number(object); 251 * object *users(); 252 * int strlen(string); 253 * mixed *allocate(int); 254 * int sizeof(mixed *); 255 * mixed *map_indices(mapping); 256 LPmud + mappings: m_indices() 257 * mixed *map_values(mapping); 258 LPmud + mappings: m_values() 259 * int map_sizeof(mapping); 260 LPmud + mappings: m_sizeof() 261 * int intp(mixed); 262 * int stringp(mixed); 263 * int objectp(mixed); 264 * int arrayp(mixed); 265 LPmud: pointerp() 266 * int mappingp(mixed); 267 * void error(string); 268 Cause an error. 269 * void send_message(string); 270 Send a message to the current object (should be interactive user), 271 messages from the user will call receive_message() in the object. 272 * int time(); 273 * varargs void call_out(string, int, ...); 274 * int remove_call_out(string); 275 * void shutdown(); 276 277 * void editor(string); 278 Handle an editor command, such as "e file", "%s/foo/bar/g", "x". 279 If no editor instance exists for the current object, it will be 280 created; editor output will call receive_message() in the object. 281 * string query_editor(object); 282 Return the editor status of the object ("command", "input" or 0). 283 * void save_object(string); 284 LPmud: save_object() without .o tagged on. 285 * int restore_object(string); 286 LPmud: restore_object() without .o tagged on. 287 * varargs string read_file(string, int, int); 288 LPmud: read_bytes() 289 * int rename_file(string, string); 290 LPmud: rename() (limited, will not rename directories if the 291 host doesn't support this) 292 * int remove_file(string); 293 LPmud: rm() 294 * varargs void write_file(string, string, int); 295 LPmud: write_bytes(), will append if third argument is omitted. 296 * int make_dir(string); 297 LPmud: mkdir() 298 * int remove_dir(string); 299 LPmud: rmdir() 300 * mixed **get_dir(string); 301 Get file info using get_dir(file), directory info using 302 get_dir(dir + "/" + pattern), the pattern can have ? * [a-z]. 303 The return value has this form: 304 ({ ({ names }), ({ mod times }), ({ sizes }) }) 305 This is almost compatible with MudOS, except that directories have 306 size -2 (non-existing files and special files are not included). 307 308 * varargs string crypt(string, string); 309 * string ctime(int); 310 * string *explode(string, string); 311 * string implode(string*, string); 312 * int random(int); 313 * varargs int sscanf(string, string, ...); 314 As in LPmud, but also handles %*s (skip assignment), %s%d and %%. 315 316DGD 1.0.a3 317 318 - Replaced objkey with separate fields in both objects and values. Structure 319 alignment on sun4 systems caused the size of a value to be 12 bytes, where 320 it should have been 8. It should now be 8 bytes on any host (as long as 321 uindex is an unsigned short, and pointers use 4 bytes). 322 - Redeclaring an inherited function with different parameters is now allowed 323 (runtime typechecking will handle calls from inherited objects to the new 324 function), but the return type still has to match. 325 - Fixed a bug with the return type of an implicit prototype, which should 326 read as mixed, when used. 327 - Some checks to see if the result of path_file() was NULL were missing. 328 - Removed time_interval from the configuration parameters. If I'm going to 329 support call_out intervals of less then a second, I'll do it in a different 330 way. 331 - The simulated rename() erroneously removed the destination if it existed. 332 - Some checks for destructed this_object() in kfuns removed. Either the 333 error is caused from path_object(), or there was not real reason to block 334 the kfun (file I/O). Doing a call_other() from a destructed object is still 335 illegal. 336 - Special files are no longer excluded from a get_dir() listing. 337 - Fixed some bugs in the compiler, where functions from different inherited 338 objects were confused. 339 - The type of the objcnt field in the value struct has been changed into 340 Int, to save space on hosts that have 64-bit longs. 341 - Replaced all variables called "index" by "idx". index() is a function like 342 strchr() on some systems. Sigh. 343 - Fixed a bad bug in integer comparisions. 344 - The call_outs configuration parameter now specifies the maximum number of 345 call_outs in all objects together, rather than per object. 346 - The maximum execution cost is now set to the appropriate value at runtime 347 (25% for call_outs), rather than once at initialisation. 348 - call_out() and remove_call_out() now work. The gamedriver is fully 349 functional for a single user. 350 - DGD now automatically generates a file called "limits.h" in the first 351 include directory, which describes the sizes of datatypes and resources. 352 - Fixed a problem with dumping function call traces of destructed objects. 353 - Fixed several bugs in get_dir() and path_resolve(). 354 - Fixed a bug which occurred if a variable was defined with a name that had 355 been used in an inherited object. 356 - Destructing a destructed object gives an error, rather than a fatal error. 357 - call_other() from a destructed object no longer results in an error, but 358 is simply ignored, like in LPmud. 359 360DGD 1.0.a4 361 362 - TCP/IP support added. 363 - Reduced the amount of runtime stack checking, by computing in advance (an 364 estimate of) the maximum stack depth of a function, which is checked when 365 the function is called. This takes two bytes extra per function. 366 - Indexed string assignments will not make a copy of the string, if the string 367 is not a constant and has reference count 1. 368 - Fixed several bugs in the interpreted code generator. 369 - Added LPC->C code generator. 370 - Cleaned up Makefiles and including files a little bit (still far from 371 perfect). 372 373DGD 1.0.a5 374 375 - Removed some redundant code from restore_string(). 376 - this_user() was not always 0 in call_outs. 377 - call_other() to a function with the wrong number of arguments does not cause 378 an error, even if the function is typechecked. This was already so for 379 version 1.0.a3, but slipped from the log. 380 - Fixed some typecasting errors in str_range() and arr_range(). 381 - Instances of an object on the stack were not properly wiped out when the 382 object was destructed. 383 - Fixed a bug in the C code generator, which didn't remove errorcontexts 384 properly. 385 - catch() within lock() no longer turns off the lock. If used by the driver 386 object, code within catch() will run with the execution cost reset. 387 initialize() in the driver object will no longer be called with a lock. 388 - Fixed a bug in remove_call_out, which could instead remove a similar 389 call_out in an object that was already destructed. 390 - It is now possible to redefine an inherited typechecked function as 391 untypechecked. 392 - Fixed a bad bug which caused the wrong inherited object to be used as the 393 program in a function call. 394 - map_sort() will now remove index/value pairs with the value set to 0. 395 - Check exec cost if a creator function is about to be called. This prevents 396 half-initialized objects due to exec cost problems. 397 - Fixed a bug in the < <= > >= operators on strings. 398 - Max exec cost in call_outs is now 1/2 instead of 1/4. 399 - Fixed a bad memory leak in array.c . 400 - Exchanged the place in the array returned by get_dir() of the file sizes 401 and the file mod times; it is now ({ names, sizes, times }). It used to be 402 different for compatibility with MudOS, but their doc turned out to be 403 faulty. :) 404 - Changed comm.c to handle INTR and DEL in telnet. 405 - Fixed a bug in restore_object(), which would get stuck in an infinite loop 406 when restoring an object without saveable variables. 407 - Swapping enabled. 408 - Fixed a bug that caused a bad program index in a function call to be 409 generated. 410 - Fixed a problem having to do with a full input buffer in comm.c . 411 - Fixed a bug in save_object and restore_object, where the offset of variables 412 in inherited objects was not properly calculated. 413 - Fixed a memory leak in the generation of prototypes by calling undefined 414 functions (only in untypechecked objects). 415 - String hash table sizes are now powers of two. They used to be primes, 416 which is fairly pointless in this implementation. 417 - Divided allocated memory into 'static' and 'dynamic' memory. Static memory 418 is used for things which need to be kept when everything is swapped out, 419 and dynamic memory is used for the rest. 420 - Fixed a bug with escape sequences in the preprocessor, and a related bug in 421 the parser. 422 - this_user() is now set during the call to open() in the user object. 423 - Fixed bugs in the C code generated for catch() and ?:. 424 - Inheritance with a label no longer specifies that a different type of 425 inheritance is required (!). Functions may now be inherited more than once, 426 as long as the inheriting object redefines them. A label can still be used 427 to specify which inherited instance of a function is to be called. 428 - Negative indexing has been removed. Sorry, but I added them without 429 considering the arr[0 .. x-1], with x = 0 problem. (If only indices 430 started at 1 instead of 0...) 431 - Fixed a memory leak in mappings with destructed objects for indices/values. 432 - Fixed a bug with destructed objects as arguments to call_outs. 433 - Fixed a cleanup problem in case an object could not be compiled. 434 - New kfuns: 435 * get_exec_cost() 436 Return the allowed execution cost that is remaining. 437 * varargs int *status(object) 438 Return status information. The 'fields' of the returned array are 439 described in the automatically generated include file "status.h". 440 * void swapout() 441 Swap out all objects. 442 443DGD 1.0.a6 444 445 - Fixed a problem in kfun/debug.c in case RUSAGE was defined, but DEBUG was 446 not. 447 - Included size of tables in O_PROGSIZE, as given by the status() kfun. 448 - Fixed an overflow problem in integer case ranges. 449 - Renamed config option "reserved_stack" to "reserved_cstack", and added 450 "reserved_vstack". 451 - Both the renaming of and the renaming to the auto object and the driver 452 object is now illegal. 453 - Repeated call_others to the same function are now faster on average. 454 - The control blocks of precompiled objects are swapped out no longer. 455 - Fixed a bug in the editor substitute command, which could mess up if 456 substitutions occurred and didn't occur on alternate lines. 457 - Fixed a possible memory leak in restore_array and restore_mapping, in 458 case the save file was faulty. 459 - Fixed a bug with global integer variables as lvalue arguments to sscanf() 460 in typechecked functions. 461 - Improved some compiler error messages. 462 - A new prototype for an inherited function won't replace the inherited 463 function anymore, if the prototypes are identical. 464 - Function calls with too few or too many arguments no longer cause runtime 465 errors. It caught a lot of errors, but also broke some code which 466 shouldn't have. 467 - Fixed a bug in inheritance, which could fail if two inherited objects 468 defined the same function, and a third was unloaded. 469 - Fixed a bug in calls to functions for which an undefined prototype was 470 inherited, but which were redefined. 471 - Changed _time, _ctime, _opendir, _readdir, _closedir and _alarm into 472 P{_*} to make it work on HP systems. 473 - Telnet GA is now only sent after a (possibly empty) prompt, and not 474 after any finished output. 475 - Made BEL, BS, HT, LF, VT, FF and CR host-independent. Moved the adding 476 of CR before LF back into comm.c (was in host/unix/connect.c in version 477 1.0.a5). 478 - State dumps: 479 swapout() and shutdown() now take a numeric argument. If non-zero, 480 a state dump is created on the file specified by the dump_file config 481 parameter. A state dump file can be used on startup (by specifying it 482 as the 2nd argument) to restore from. After a successful restore, 483 driver->restored() is called, rather than driver->initialize(). User 484 objects and editor objects are not restored as such, and the driver 485 object should deal with them in restored(). This can be done by 486 registering those objects, just before the state dump occurs. 487 - Ellipsis can now be used to declare a function with arbitrary numbers 488 of arguments. Example: 489 490 varargs string sprintf(string format, mixed args...); 491 492 args will have type mixed*, and will be an array with the additional 493 arguments. Ellipsis can also be used in a call, to push all elements 494 of an array on the stack as arguments: 495 496 call_other("/some/thing", "foo", array_with_arguments...); 497 498 - Replaced time_t with long everywhere to make things portable. If a time_t 499 doesn't fit in a long on a particular host, it will have to be truncated. 500 - Speeded up remove_call_out(). Removing a short-term call_out is now 501 reasonably fast. 502 - Added find_call_out(). I previously left it out because I considered 503 using it bad programming practice. I still think so, but it might be 504 useful in some rare cases, and the current implementation is fairly fast. 505 - All of x[y .. z], x[y ..], x[.. y] and x[..] are now possible, with the 506 obvious meanings. 507 - The swapfile and editor tmpfiles are now removed on a shutdown. 508 - Fixed a bug in the compiler, which would not always cast the result of 509 a function call to int when this was needed. 510 - Errors inside a catch are now logged on stderr as well. 511 - Fixed a problem which occurred when a catch was used in a conditional 512 context in LPC->C code. 513 - Fixed a problem in the compiler, which could produce a bad symbol table 514 for the auto object (which fortunately isn't normally used). 515 - If a clash between inherited functions occurs, only the clashing functions 516 will be listed, rather than all functions that are inherited more than 517 once. 518 - Better removal of unused call_out slots in objects. 519 - sscanf("foobar","foo%s") will result in an error. 520 - New kfun: call_trace(). It returns the call trace as an array (see the 521 doc for specifics). 522 - driver->log_error() is now called (locked) with two arguments, the error 523 string and a flag which indicates if the error is caught. It should make 524 use of call_trace(). The driver itself no longer logs runtime errors. 525 - If an object is inherited that itself inherits an object that has been 526 destructed, call driver->recompile(obj). The driver object must destruct 527 the object to force it to be recompiled, if this is desired. 528 - A missing #endif would not always give an error. 529 - Using a void value when typechecking now gives the error "void value not 530 ignored" always. 531 - Added mapping - array and mapping & array. 532 - Functions with a declared non-void type must return a value. 533 - Variables could erroneously be redeclared as private in the same object. 534 - Redeclaration of an inherited function or variable will now give the 535 inherited object in the errormessage. 536 537DGD 1.0.a7 538 539 - Fixed a bug with saving large numbers in arrays and mappings. 540 - Improved memory allocation in case sizeof(long) > 4. Also improved 541 efficiency for the case that DEBUG is not defined. 542 - String hash tables are no longer cleared before being deleted. Some hash 543 tables used by the compiler which were previously statically allocated are 544 now dynamically allocated. 545 - The >> and << operators now shift unsigned values, so the result is 546 identical on all hosts. 547 - Fixed a memory leak in i_index() and i_index_lvalue(). 548 - Comm.c can now deal with ^Z as well. 549 - Cleaned up the inheritance logic in control.c, and removed some bugs. 550 - Fixed several bugs in the restoring of object names. 551 - Fixed some code in switch_str(), which would only work properly for the 552 auto object and driver object. 553 - Replaced longs by Ints in the editor, to save space on hosts with 554 sizeof(long) > 4. 555 - Fixed a bug in c_tst() and c_not(). 556 - Changed the alarm/timeout interface. co_call() now calls P_timeout() 557 to determine if an alarm timed out; co_timeout() has been removed. 558 - main() is now in local.c, and should call dgd_main(argc, argv). 559 - All occurrances of fprintf(stderr, ...) replaced with P_message(...) . 560 - path_object() (call_other, clone_object, find_object) from the auto 561 object will no longer call the driver object to translate the path. 562 - Fixed yet another problem in the C code generated for catch(). 563 - Added function name comments to generated C code. 564 - The class specifier private no longer implies static, for variables. 565 This means that private variables can be saved with save_object(), and 566 restored with restore_object(). To get the old behaviour, use both 567 static and private. 568 - A new kfun is added, dump_state(). swapout() and shutdown() no longer 569 do a state dump through a flag argument; dump_state() should be used 570 instead. dump_state(1) will create an incremental dump on top of an 571 old one. 572 - Fixed a possible memory leak in sscanf(). 573 - Fixed a bug in src/host/unix/connect.c which could hang the driver. 574 - Made IAC GA optional. The client must request it with IAC DONT TELOPT_SGA, 575 which the driver will respond to with IAC WONT TELOPT_SGA. I badly 576 underestimated the number of faulty clients, and even plain telnets could 577 not handle it. 578 - Editor marks and secondary buffers were not cleared in between edits. 579 - In the editor, changing a line into nothing could cause a crash. 580 - Added a float type. Fairly useless for muds, but not for other 581 applications. Everything has been adapted (save_object, sscanf), but 582 apart from floatp no kfuns have been added yet. Four new builtin kfuns, 583 ADD1, ADD1_INT, SUB1, SUB1_INT have been added. 584 The float type has 1 sign bit, 11 exponent bits and 36 mantissa bits. 585 The format is basically a truncated IEEE double, with a few alterations: 586 exponent 0x7fff is illegal, and there is no gradual underflow. 587 - Fixed various minor bugs in the compiler. Also made runtime typechecking 588 more strict, and improved optimisation. 589 - The dataspace of destructed objects that are not freed for some reason 590 is now deleted right away. 591 - The object argument has been removed from driver->path_ed_read(), 592 driver->path_ed_write() and driver->path_object(). 593 - intp(), floatp(), stringp(), objectp(), arrayp() and mappingp() have 594 been replaced with a single kfun, typeof(). 595 - The swapfile is not created before sectors are actually written to it. 596 - A float.h file is now created on startup. 597 - Added 2nd swapout measure for last five minutes. 598 - Renamed config parameter swap_sector to sector_size. 599 - Added some kfuns: fabs(), floor(), ceil(), fmod(), frexp(), ldexp(), modf(). 600 - Floats (both global and local) are initialized to 0.0, rather than integer 0. 601 - Added time of compilation to control block struct. 602 - Callouts have been changed: call_out() now returns an integer > 0, which 603 must be given as an argument to remove_call_out() to remove it. The kfun 604 find_call_out() no longer exists. status(obj) gives a list of all callouts 605 in an object. 606 - Renamed port_number to telnet_port, added binary_port (dummy, for now). 607 - Reorganized status() and limits.h . 608 - Fixed several bugs in the handling of callouts, which could result in random 609 memory trashing. 610 - Fixed some bugs in control.c for sizeof(int) == 2. 611 - Fixed a bug in the swapping of large mappings. 612 - Some more editor bugs fixed. 613 - In the editor, use of | is restricted to inside global commands. 614 - editor() no longer sends output to receive_message() in the editor object, 615 but returns it as a string. 616 - The optimizer has been made a separate part of the compiler. 617 - dump_state() changed again: it will now sync the swapfile, append some 618 tables at the end, and move it to a dump file. Afterwards, the driver will 619 read from the dump file to reconstruct the swap file at low priority. 620 Incremental dumps no longer exist. 621 - The swapfile was not always created before a dump was made, resulting in 622 a fatal error. 623 - float.h and float.c have been renamed to xfloat.h and xfloat.c, respectively. 624 - The maximum stack depth of a function call with one argument was not 625 computed correctly. 626 - Multiple inheritance of the same file in different ways could, in some 627 cases, lead to invalid fcall and variable offsets. 628 - Fixed a bug that caused spurious stack overflow errors. 629 - Fixed a problem with expressions of the form (a) ? (b, c) : d. 630 - Dead code is now silently thrown away, instead of resulting in a 631 "statement not reached" error. 632 - Changed #include "float.h" to #include "xfloat.h" in generated C code. 633 - Fixed a bug in the optimizer which mangled sscanf() assigned value checks. 634 - The replies to DO TELOPT_SGA and DONT TELOPT_SGA were accidentally reversed. 635 - Lexical errors were repeated for each rescanning of the input. 636 - Some improvements in the typechecking for mixed... . 637 - Enabled binary port. 638 - Fixed a bug with # define foo "gnu.h" \n # include foo 639 - Some bugs in binary connections fixed. 640 - Fixed a bad bug in comm.c which could hang the driver. 641 - Fixed a newly introduced lexical scanner problem. 642 - get_dir("/a/b") returned "a/b" as the name of the file, instead of "b". 643 - Oops, several private variables with the same name would each be saved with 644 save_object(). Private for variables made to imply static again. 645 - Filename matching in get_dir() made more efficient (thank you, Aedil). 646 - Fixed a bug in && and || used as standalone expressions. 647 - Dump files now include a kfun table. This enables the driver to restore 648 a dump file that was made by a driver version with fewer kfuns. As long 649 as no kfuns are removed and the interpreter itself is not changed, dump 650 files can be used with future driver versions. 651 - Let (x, 0) match any type but float in situations where 0 would. 652 - The command line restore file argument is taken to be relative to the 653 current directory at the time, rather than relative to the mudlib directory. 654 - Makefiles brought up to date. 655 - (int) 0.0 yielded a wrong value. 656 - Max execution cost is no longer halved during a callout. 657 658DGD 1.0.8 659 660 - Fixed a problem with catch(x, y) and lock(x, y). 661 - Fixed file descriptor leak in swap.c. 662 - Fixed a bug in swap.c which could cause confusion between sectors just 663 after a state dump. 664 - Removed "*** State dumped." message after a state dump. 665 - Fixed a bug in the editor which could result in an infinite loop. 666 - Changed the default return value of float functions to 0.0. 667 - SunOS 4.x appears to have a problem: sometimes an alarm will interrupt 668 a read or write on a file, even though this is supposed to be impossible 669 and SV_INTERRUPT is not set. As a workaround, a new timeout handler is 670 provided that doesn't use alarms. 671 - Fixed a bug in the C code generated for ++ and -- of non-integer variables. 672 - Using memcmp() in str_cmp() was unwise, because the lexical ordering of 673 characters may differ per host, and on a NeXT memcmp() is buggy. Replaced 674 with explicit code that compares unsigned characters. This may invalidate 675 old dump files for hosts with signed character compare in memcmp() ! 676 - If the swap file cannot be renamed to the dump file, attempt to copy it 677 instead. 678 - Cleaned up host.h a bit. GENERIC_* no longer uses alloca() to make it 679 more generic. 680 - Fixed a bug in the editor which in extremely rare cases might wipe out 681 a line. 682 - Added newline-in-input optimisation as per Dark's networking package. 683 - Made it impossible for the editor to read a directory. 684 - A file can only be removed or renamed if the host system permits write 685 access. 686 - Avoided some typecast warnings. 687 - Fixed the following bug: int i, string s; i = 2; s = s + i; 688 This used to give the integer value 2 to s. Now s gets the value "02". 689 As a corollary, casting from int/float to string and from string to 690 int/float is now possible. 691 - Fixed a bug which occurred if a function for which an implicit undefined 692 prototype was created was defined as private in the same object. 693 - Fixed a bug that prevented restoring a state dump made by a driver with 694 fewer builtin kfuns. Unfortunately, the bugfix affects state dumps too, 695 and old state dumps can no longer be used. (!) 696 - Added a summand operator to transparently compute expressions of the form 697 698 x1[a .. b] + x2[.. c] + x3[d ..] + x4 + .. + xn[..] 699 700 without intermediate results, as suggested by Aedil. 701 - Discarded the 'a' in the version number; DGD is beyond the alpha stage. 702 - call_trace() now also includes the function arguments. It is the 703 responsibility of the mudlib programmer to make sure that this doesn't 704 cause security problems (this also applies to status(obj)[O_CALLOUTS]). 705 - Fixed a bug which in some cases prevented proper removal of unreachable code. 706 - Fixed an optimisation which was skipped in conjunction with the summand 707 operator. 708 - Fixed a bug which caused <digits>. to be rejected as a valid floating point 709 constant. 710 711DGD 1.0.9 712 713 - call_trace() could give incorrect arguments for varargs functions. 714 - Fixed a bug which could occur for strval[i] = intval. 715 - Attempt to use telnet linemode. This makes *BSD telnet usable, let's hope 716 nothing else breaks. 717 - Fixed a bug in code generated for switch statements which only have a 718 default entry with break statement. 719 - Fixed an overflow problem in the array/mapping sort compare function. 720 - DGD will now compile without warnings using gcc 2.4.5 -ansi -pedantic. 721 - Fixed a bug in telnet subnegotiations. 722 - Fixed some other ANSI C pointer problems. 723 - The driver can now call static functions in the auto object. 724 - Found a crasher in str.c::str_put() that had eluded me for quite a while. 725 - Undid the static function patch (dumpfile incompatibility and other 726 problems). 727 - Made state dumps for which the whole swapfile was copied in one go more 728 efficient. 729 - 'make a.out' will now always relink a.out. This fixes a dependency problem. 730 - Global commands in the editor would crash with a bad regular expression. 731 - Widened the size limits for arrays and mappings somewhat. 732 - The precompiler will accept an optional 3rd argument, the output file. 733 This file will be removed if an error occurs during precompiling (fixing 734 another dependency problem). 735 - Turned off type errors for ?: . In case of a type conflict, the result 736 type is mixed. 737 - Extended status() array with some limits, also in status.h (needed for 738 continuous muds). 739 - Added array | array (A + (B - A)) and array ^ array ((A - B) + (B - A)). 740 - String and array reference counts are now 4 bytes, instead of 2. 741 - Fixed a bug that could remove code with a case label inside. 742 - Translate std include file to a local filename before using it. 743 - Removed spurious path_file() from path_object(). 744 - Added path_unfile() to translate a filename in host format back to DGD 745 format. 746 - Fixed a problem regarding mapping aggregates with identical indices; 747 calling error() from within qsort() might leave the mapping in an 748 inconsistant state. 749 - Changed YYDEPTH into YYMAXDEPTH in config.h; this should work for a wider 750 range of yaccs. 751 752DGD 1.1 753 754 - Fixed a bug that caused precompiled kfun calls to be wrong if kfuns were 755 added since the last state dump. 756 - The type of (expr1 ? void : expr2) and (expr1 ? expr2 : void) is now always 757 void. 758 - Fixed another bug in switch statements with only a default label inside. 759 - Made sure that mappings are compacted before the size is checked. 760 - Fixed a bug that might occur while restoring object filenames in a state 761 dump. 762 - DUMPFILE COMPATIBILITY ABANDONED. All following pre-1.1 versions won't be 763 dumpfile compatible with 1.0.9 and probably not with eachother, either. 764 I'll make a dumpfile converter for 1.0.9->1.1. 765 - The evaluation order of array and mapping aggregates is now left to right, 766 because this is more intuitive. From now on I'll consider the evalution 767 order of aggregates and function arguments to be fixed, rather than 768 undefined. 769 - Added list of directly inherited objects to the control block. 770 - Won't cause a fatal error on too small dynamic chunk anymore (just allocate 771 the larger chunk). 772 - Some Mac compatibility fixes. 773 - Added T_RESERVED type for add-on packages. 774 - Fixed character initializer tables. 775 - Added keyword "atomic". 776 - Got rid of C_LOCAL. 777 - More Mac compatibility fixes. 778 - Merged fcontrol.h with comp/control.h. 779 - Removed "atomic" again. One way or another, multitasking will wreak 780 havoc with DGD's concept of data being local to objects (which is very 781 important for efficient swapping). Maybe in 2.0. 782 - Reduced memory usage, at the cost of slightly slower string and array 783 deletes. 784 - Speeded up swapping of objects with a tangle of arrays and mappings. 785 - Arrays that are shared between objects are now made unique in each object 786 immediately after execution has completed, rather than at the moment when 787 one of the objects is swapped out. 788 - Fixed some remaining ANSI C incompatible prototypes <-> function 789 declarations in the editor. 790 - Fixed some bugs in the array exporting code. 791 - And some more. 792 - And some in the memory reduction changes as well. 793 - get_dir(foo) will always treat foo as a pattern, even if there is a file 794 with that name. 795 - Generate a compile-time error for functions larger than 64K. Programs can 796 now be larger than 64K. 797 - Compile-time checking for too many string constants or function calls. 798 The number of arrays and string values in an object can be larger than 799 65535. Replaced longs by Uints in swapping functions. Extended ref 800 counts to Uint for swapped-out data. 801 - Binary connections don't buffer anymore. send_message() returns 1 if the 802 write succeeded (always 1 for telnet connections), and 0 if the write 803 failed. 804 - Fixed a bug in the compiler that was exposed by the changes in the code 805 generator. 806 - Inheriting a renamed clone could cause trouble. 807 - send_message() now returns the number of bytes written (1 for echo on/off) 808 or 0 in case of an error. 809 - Fixed a bug introduced in get_dir() in the latest rewrite. 810 - Temporarily disabled new export code to track down bugs. 811 - Fixed a tiny destructive bug in the swapping code, recently introduced. 812 - 0.0 == 0 was 0, is now 1 (!0.0 already was that). For all other value 813 combinations, integers and floats remain different. 814 - Re-enabled export code. 815 - Allow any binary port value (telnet port remains >= 1024). 816 - Function_object() won't find a static function in a different object anymore 817 (because it cannot be called). 818 - Smarter selection of objects for swapping. 819 - Rebuilt the main loop so continuous exec cost errors during callouts don't 820 result in user command starvation. 821 - Ignore NUL characters in telnet input. 822 - Fixed another array exporting bug. 823 - foo() = bar; could crash the system. 824 - An incomplete recovery from a syntax error during compilation of a switch 825 statement could result in a crash. 826 - Discarded I_PUSH_FLOAT2 and I_CALL_AFUNC in favor of I_CALL_IKFUNC and 827 I_CALL_IDFUNC (needed for object upgrading). 828 - Change of the version numbering scheme: rather than 1.0.9.24, the current 829 version is 1.0.10. The next major release is still 1.1. 830 - Made value stack and call stack dynamically expandible. 831 - Fixed several stack depth miscalculation bugs. 832 - Added a cleanup function to the error context, used mainly to clean up 833 the value stack in case of an error. 834 - (int) "12a" now results in an error, as does (float) of the same. 835 - Renamed "exec cost" to "ticks". 836 - Replaced lock() with the following language construct: 837 838 rlimits (stack; ticks) { 839 /* statements */ 840 } 841 842 This will execute code with reduced or increased stack depth and ticks. 843 There are two new driver calls to handle it: at compile time, for each 844 rlimits construct, driver->compile_rlimits(objectname) is called. If this 845 function returns non-zero, the rlimits is allowed without futher ado. If 846 it returns 0, then at runtime there will be an additional check, 847 driver->runtime_rlimits(obj, stack, ticks). If zero is returned from this 848 function, an error results. This allows fast execution of rlimits 849 constructs in trusted code. For precompiled code, the return value is 850 always assumed to be 1 (!). 851 By default, there are no resource limits. Also, driver->log_error() is 852 called without resource limits. 853 -1 can be used in rlimits to signify that a resource should be unlimited. 854 - Removed call_stack, value_stack, reserved_cstack, reserved_vstack and 855 exec_cost from the config file. 856 - Replaced max execution cost with remaining stack depth and remaining ticks 857 in the array returned by status(). 858 - Removed kfun get_exec_cost(). 859 - Replaced driver->compile_log() with driver->compile_error(file, line, err). 860 By default, DGD now writes nothing to stderr at all. 861 - Renamed driver->log_error() to driver->runtime_error(). 862 - Fixed a bug in the new error cleanup code. 863 - Fixed some rlimits bugs in the C code generator. 864 - Fixed a nasty bug in the code generated for sscanf(). 865 - And another one, and another one in the error cleanup code as well. 866 - Made it possible to use ( ) in inherit string expressions. 867 - Fixed a bug in the C code generator; no check was made to see if the stack 868 had been reallocated after a kfun- or function call. 869 - Fixed a memory leak in get_dir(), also introduced in the latest rewrite. 870 - Renamed all p_* prototype headers to pt_* in an attempt to avoid conflicts 871 with existing library functions on some machines. 872 - Binary connections: if send_message() cannot send a string in one go, it 873 puts the remainder in a buffer which is emptied as soon as possible. When 874 all data is sent, message_done() is called in the user object (but only if 875 the output could not be sent all at once). Using send_message() while 876 previous output is still unfinished will flush the buffer, and prevent 877 message_done() from being called. 878 Binary connections have 64K buffers which are allocated statically, so 879 the static chunk should be large enough (70K or so). 880 - Run callouts less often if they take more than half of the available time. 881 May be useful for muds on extremely heavily loaded hosts. 882 - After runtime_error() was called, no resource limits would be set. 883 - Renamed path_ed_read() and path_ed_write() to path_read() and path_write(), 884 respectively. 885 - When the last reference to a program is removed, call 886 driver->remove_program(objname). The call is done with rlimits -1; -1 and 887 errors will be caught and ignored. 888 - Removed driver->path_object() and driver->compile_object(). 889 - Added kfun compile_object(name): compile the named object, which must not 890 already exist. 891 - clone_object() now takes a (master) object as an argument. 892 - find_object() no longer calls driver->path_object() to translate a path. 893 - call_other() now calls driver->call_object() to translate a string to an 894 object. 895 - Added list of precompiled objects to status(). 896 - Increased the number of different sized large free chunks the static memory 897 manager can handle. 898 - In connect.c, calls to accept() will now only be done if the controlling 899 socket was marked for reading by select(). 900 - The object free list wasn't properly maintained anymore. 901 - A cloned object erroneously didn't have its creator function called right 902 away. 903 - Replaced driver->path_inherit() by driver->inherit_program(), which must 904 return an object (which may be compiled inside the function). 905 - driver->inherit_program() was accidentally called when implicitly inheriting 906 the auto object, too. 907 - Added '^' to filename pattern matching (as in csh). 908 - Fixed a problem with precompiling objects that inherited the auto object. 909 - When restoring from a state dump, callouts in objects no longer need to 910 be patched. 911 - Added precompiled objects to the dumpfile (though nothing is done with them 912 yet on restore). 913 - 1.1 DUMPFILE FORMAT REACHED. Up to the next major release, version 1.1, 914 the dumpfile format will not change. 915 - Made ticks a more reasonable measure. In many cases it just reflects what 916 I think something should take -- or what I want to make expensive. 917 Currently, the editor still takes no ticks. 918 - The object table wasn't properly prepared before including it in a state 919 dump. 920 - catch { stmts } is now allowed as a statement. 921 - Fixed some bugs in the new catch code. 922 - Fixed a long-standing but never before discovered problem with destructed 923 objects as mapping indices. 924 - The driver object can inherit the auto object again, and the auto object 925 can use the rlimits statement without limitations. 926 - If an error is caught internally, the proper error handler is called again. 927 - Ported DGD to Windows 95/NT. Left to do: starting by double-clicking a 928 config file, program icons. 929 - Disallowed #include from the config file, which would cause a crash. 930 - Precompiler brought up to date with latest change in error handling. 931 - Send IAC GA to all users with a prompt, not just the current user. 932 - Swapping in an object with more than 127 inherits might result in a crash. 933 - Precompiling still didn't work for objects with more than one level of 934 inheritance. 935 - Error recovery was incomplete in case of an error in sscanf() or in 936 user->close(). 937 - Win32 version can now be started by double-clicking the config file. 938 - Fixed a nasty error context bug. 939 - Fixed a rare bug in string swapping. 940 - user->close() now takes an integer argument, 1 if the connection is closed 941 from the mudlib, 0 if it's due to linkdeath. 942 - Made statedumps more efficient. 943 - The static chunk size can now be 0, which has the effect of never causing 944 an automatic swapout, at the cost of more memory fragmentation. 945 - Made sure ctime() works, even if the host implementation cannot handle 946 "negative" times. 947 - Fixed a problem in the new statedump code, which might occur with frequent 948 statedumps. 949 - The priority queue for to be swapped-out objects now works better. 950 - Merged in Mac compatibility fixes. 951 - Discontinued support for MINIX_68K and ATARI_ST. 952 - Fixed a bug in inherited function calls with very large function tables. 953 - Fixed a bug which could result in connections being closed immediately, 954 often occurring if connections were being opened and closed at a rapid 955 rate. 956 - Process termination is now done through driver->interrupt(). This 957 function must exist and should minimally consist of 958 959 void interrupt() { shutdown(); } 960 961 - Fixed a problem with %% in a sscanf format string. 962 - Fixed a potential crash if the stack array created in call_trace() was 963 too big. 964 - call_other(obj, "foo\0bar") could be used to call the function foo. 965 - Binary connections now have output buffering in the user object, instead 966 of a 64K static buffer. User objects that are buffering will not 967 normally be swapped out. The input buffer size for a binary connection 968 has been increased to 8K. 969 - Made often-used objects less likely to be swapped out during a lull in 970 activity. 971 - With global typechecking, a function without declared type has type void. 972 - Fixed some bugs in new output buffer handling. 973 - During precompilation, inherit paths without a leading slash are now 974 considered to be relative to the current directory, rather than absolute. 975 - C code generated for >>= and <<= operators made more portable. 976 - Disambiguated results of division and remainder operations. 977 - No more core dumps for errors in the configuration phase. 978 - PC version: don't exit program immediately on a configuration error when 979 started without an argument. 980 - Fixed a problem in precompiled code generated for catch { }. 981 - Catch { code; } is now optionally followed by : { caught; }. 982 - Functions without declared type were accidentally untypechecked, even with 983 global typechecking enabled. 984 - Made hashtables faster in some cases. 985 - PC version: don't ask for confirmation if the program is stopped from the 986 outside and was started with an argument, making it easier to run it as 987 a service on NT. 988 - Fixed a bug that made it possible to access files outside the mudlib 989 directory on Win32. 990 - Fixed a rare problem with arrays as mapping indices. 991 - If the time was set back during callout processing, it was possible for 992 the next callout never to be started. 993 - Fixed a bad memory fragmentation problem in case a block of memory was 994 allocated that was larger than the dynamic chunk. 995 - DUMPFILE FORMAT CHANGED AGAIN. This unfortunately became necessary because 996 of missing information for dumped precompiled objects. When the dumpfile 997 format stabilizes again, it will be marked in this file. 998 - restore_object() now does typechecking, if global typechecking is enabled. 999 - Faster code with global typechecking. 1000 - Re-introduced keyword "atomic". 1001 - Extended precompiled function index from 2 to 3 bytes. 1002 - Accept binary connections more quickly. 1003 - Optimize generated code a little further, particularly generated C code. 1004 - Fixed possibly bad code generated for breaking out of a catch. 1005 - Fixed a problem with ellipsis in calls to functions without prototype. 1006 - Improved dead code removal. 1007 - Tweaked the last tweaks in generated C code optimization. 1008 - Bugfix in C code generated for ?:. 1009 - Attempt to avoid Linux bug in socket writes. 1010 - Generate better C code for calls to builtin kfuns. 1011 - Generate summand operators in more cases. Also fixed a crashing bug in 1012 case all operands of a summand are 0. 1013 - Fixed a compiler bug which sometimes rejected x..x case label ranges. 1014 - Generate summand operators in even more cases, where array aggregates 1015 are now also included. 1016 - Added 2nd argument to driver->remove_program(), the compile time of the 1017 object. 1018 - Cleaned up comm.c a bit. 1019 - Made sector independent of uindex. 1020 - String constants are no longer shared between control block and dataspace 1021 when swapped out. 1022 - Objects can be recompiled before being destructed if they are not inherited. 1023 This has the effect of upgrading the object and all clones to the new 1024 program. Variables with the same name and type (private and static don't 1025 matter) are preserved in the upgraded object; all other variables are 1026 initialized to 0. 1027 - Brought dump_function() up to date. 1028 - Fixed a nasty bug in the runtime support for precompiled code. 1029 - Some fixes for the order of events in the main loop, and telnet buffer 1030 flushing in comm.c. 1031 - Several bugs fixed in the recompiling code. 1032 - And some related ones. 1033 - And some more. 1034 - Array swapping and exporting made faster. 1035 - When an object is destructed, remove callouts immediately from the callout 1036 table. 1037 - Dumpfiles from different platforms are now converted at boot time. 1038 - Fixed a bug in restoring the swap header. 1039 - Generate a trace.h include file for call_trace() on startup. 1040 - Brought precompilation up to date with latest changes. 1041 - General code cleanup. 1042 - Fixed a nasty crasher in endthread() with the help of Sieni@Muhveli. 1043 - Fixed a problem with destructed objects as mapping indices. 1044 - Optimized communications handling and get_dir(). 1045 - Fixed memory leak in generated C code. 1046 - Made the maximum string size the same on all hosts and removed 1047 MAX_ARRAY_SIZE and MAX_MAPPING_SIZE from limits.h (status()[ST_ARRAYSIZE] 1048 should be used). 1049 - If select() is interrupted, make sure that all socket read flags are zero. 1050 - DUMPFILE FORMAT STABLE AGAIN, and it had better not change before 1.1... 1051 - Added 3rd argument to runtime_error(), ticks left, and removed ST_ASTACKDEPTH 1052 and ST_ATICKS. 1053 - Patterns in get_dir() accidentally matched almost anything. 1054 - Several mapping problems fixed. 1055 - Added kfun previous_program(). 1056 - The start time was not restored properly. 1057 - Made callouts more accurate when time() is used for timing, at the cost of 1058 an extra system call for each new callout. 1059 - Fixed a bug in restoring a sector map that didn't fit in one sector. 1060 - Fixed an ancient bug in #if expressions. 1061 - Can't use \0 in kfun file name argument anymore. 1062 - Let status(obj) give updated information about objects recompiled during the 1063 current thread. 1064 - Make more of an effort to buffer telnet output if all of it could not be 1065 sent right away, making sure that no telnet escape sequences are sent only 1066 partially. 1067 - Fixed a bug occurring when objects are upgraded and destructed in the 1068 same thread. 1069 - __FILE__ did not include a leading /. 1070 - Some other upgrade-related bugs fixed. 1071 - Fixed bug which would occur with foo() { return catch("bar"); } 1072 - Setting a variable didn't work in the editor. 1073 - Initial Mac port completed. 1074 - Split up comm initialization in two parts, one for general initialization 1075 and one to start listening on the ports. 1076 - Fixed a bad bug in the code generated for a return out of a catch { }. 1077 Unfortunately, the fix affects the code generated for all catches, making 1078 older state dump files INCOMPATIBLE. It is possible to convert an old 1079 dumpfile if all objects in it are upgraded, and if the objects that perform 1080 the upgrade have no catch or are precompiled. 1081 - return val; was typechecked only at compile time, not at runtime. 1082 - Fixed some bugs in the Mac port. 1083 - Make sure all connections are closed as soon as it is known that the 1084 system is shutting down, instead of waiting until after a state dump. 1085 - Fixed a loss-of-variable bug in upgrading while restoring state. 1086 - Enabled edit menu in Mac port. 1087 - Precompiled objects now replace existing objects silently, rather than 1088 causing an upgrade. The object replaced must have the same inherit, 1089 string, function definition, variable definition and function call tables. 1090 NOTE: the dumpfile format was slightly changed, but state dumps that do 1091 not contain precompiled objects are unaffected. 1092 - Added a new status(obj) field, the "index" of the master object (the 1093 object itself unless it's a clone). This is a unique ID, and will help 1094 distinguishing different issues of the same object, and linking clones 1095 to a particular issue. 1096 - Added third argument to driver->remove_program(), the "index" of the 1097 object. 1098 - Made DGD compile on SunOS 5.5, too. 1099 - Fixed a bug in precompiled code generated for sscanf(). 1100 - Fixed a stack depth miscalculation bug in the optimizer. 1101 - Removed >= 1024 limitation on telnet_port (makes no sense on non-unix 1102 machines). 1103 - Error messages in restore_object() were accidentally too terse. 1104 - Improved some other error messages. 1105 - Using more than 7 indirection stars now results in an error. 1106 - Optimize `1 && a' and `0 || a' to `!!a', rather than `a'. 1107 - Fixed a bug in upgrading an old clone after doing a recompile on the object 1108 earlier in the same thread. 1109 - Corrected some floating point rounding errors. 1110 - The return value of a redirectable function was not properly checked in 1111 a call from an untypechecked function. 1112 - Added mapping subranges. 1113 - Made dealing with destructed objects in arrays and mappings faster. 1114 - Prevent the compiler from attempting to compile foo.c directories. 1115 - Fixed a bug in multi-phase upgrading of an old clone. 1116 - Perform swapout, state dump and shutdown immediately upon completion of 1117 the thread in which they are initiated. 1118 - Worked around the latest Visual C++ bugs. 1119 - Changed the meaning of O_DATASIZE in status(obj): this now returns the 1120 number of variables, rather than the assumed amount of space they take. 1121 - Deal with the auto object possibly being upgraded while inherited. 1122 - Fixed a <very> rare bug that might occur when objects are used as mapping 1123 indices. 1124 - Made map_sizeof() a cheaper operation. 1125 - PC version: enabled the edit menu. 1126 1127 DGD 1.2 1128 1129 - Added swapfile compression. 1130 - Fixed a stack depth miscalculation bug. 1131 - Generate recognizable function names for precompiled functions. 1132 - Speeded up a few functions highlighted by gprof. 1133 - Removed some old compatibility code from the editor. 1134 - Increased max string length in status() to 65535. 1135 - Increased max editor output string length to 65535. 1136 - Made DGD restartable. 1137 - Fixed a line range bug in editor global commands. 1138 - Fixed a bug/typo in object upgrading. 1139 - Fixed a bug in exporting mappings. 1140 - Made compression a bit faster. 1141 - Fixed the exporting bug fix. 1142 - Use SO_OOBINLINE on sockets if the host supports it. 1143 - Clear update field in all objects after a restore. 1144 - Compensated for a bug in ctime() on some unices. 1145 - Removed many references to global variables. 1146 - Removed some code from the upgrading procedure that was unreachable. 1147 - Improved Mac edit menu. 1148 - Avoid swapping in needlessly while writing partial sectors. 1149 - Zero unused sector parts to make swapfiles more compressible. 1150 - Sped up sector allocation and removal, and fixed a bug introduced in the 1151 partial sector write patch. 1152 - The wrong stack depth was passed on to driver->runtime_error() if the 1153 the server used an internal catch. 1154 - Added a new kfun, block_input(). 1155 - Fixed a leftover bug in the swapping changes that made reclaiming of freed 1156 sectors unlikely, and a crash possible just after a successful state dump 1157 had been made. 1158 - Read_file() was returning 0 in an error situation, and also when it 1159 should return "". 1160 - Fixed a memory leak introduced in the global variable rewrite. 1161 - Made editor code reentrant. 1162 - Callouts with a delay of 0 seconds are now executed as soon as possible. 1163 - Sort callouts in status(obj) by handle rather than by delay, as no actual 1164 calling order for same-delay callouts can be guaranteed. 1165 - Deal more efficiently with blocked connections. Also don't close a 1166 connection while there is still input to process. 1167 - Optimize indexing the value returned by kernel functions: status()[i], 1168 status(obj)[i], call_trace()[i]. 1169 - The value of integer arguments in precompiled functions would not always 1170 be given correctly in call_trace(). 1171 - String range problems at compile time now result in a proper compile-time 1172 error again. 1173 - Make a = ({ "asd" }); a[0][1] |= 7; work correctly again. 1174 - Fixed a severe bug in the code generator that could, under some 1175 circumstances, lead to else statements also being executed when only 1176 the if statement should have been. 1177 - Fixed a bad bug in global float variable initialisation, reported by 1178 Azhrarn@Flat Earth. 1179 - In case of an error during inheritance, the name of the relevant object 1180 was not properly saved. 1181 - Compensate for the latest (post 5.0) Visual C++ problem. 1182 - Partial parse_string implementation. Currently only does lexical scanning, 1183 and returns an array of tokens. Only Unix makefiles have been adjusted yet. 1184 - Fixed some Mac compilation problems for various compilers. 1185 - Replaced some FREE,ALLOC pairs with REALLOC. 1186 - Completed parse_string implementation on all platforms. 1187 - Fixed a bug that prevented any restore from dump file. 1188 - Fixed a bug in REALLOC. 1189 - And some more. 1190 - Fixed two (crashing) bugs in parse_string. 1191 - And a third. 1192 - New kfuns: query_ip_name(), send_datagram() (at present for Unix only). 1193 - DGD ported to BeOS. 1194 - Fixed a crashing bug in alternative parse tree handling. 1195 - Get the precompiler to compile again (after the last kfun additions). 1196 - Fixed a bug in parse_string() that prevented proper compression of the 1197 shift/reduce parser, and could also lead to strings being erroneously 1198 rejected. 1199 - Let status() report the proper program size, even if the object is swapped 1200 out and compressed. 1201 - Increased max number of function parameters + local variables to 255. 1202 - Fixed a stack depth miscalculation bug for untypechecked code. 1203 - Generate a proper compile-time error if a string constant is indexed by 1204 an integer that is out of range. 1205 - Allow datagrams of length 0. 1206 - Ported query_ip_name() and send_datagram() to Mac and Win32. 1207 - Improved tick counting and check for overflows in parse_string(). 1208 - Max number of function parameters + local variables reduced to 127, the 1209 interpreter cannot actually handle more than that many. 1210 - Removed static variables from all over. Only the unix versions will 1211 compile at present. 1212 - Code cleanup made assignments slightly faster, at the cost of somewhat slower 1213 swapping. 1214 - Fixed a bug that could cause wrong assignments to indexed arrays in sscanf(). 1215 - Avoided the nasty gethostbyname() problem on Windows 95. 1216 - Fixed a compiler typechecking bug for (mixed - array). 1217 - Fixed a crashing bug that occurs when an object has more callouts than 1218 the maximum array size. 1219 - Fixed a spurious inherited function clash in multiple inheritance. 1220 - Added private inheritance. 1221 - Avoided the use of gethostbyname() on BeOS for similar reasons as on Win95. 1222 - Non-unix versions compile again. 1223 - Fixed a float testing bug in precompiled code. 1224 - Fixed a bug in array exporting, introduced in the last assignment/swapping 1225 rewrite. 1226 - Fixed the bug in the fix. 1227 - Added the constant `nil'. If typechecking is 0 or 1 (in the config file), 1228 nil has the value 0. If typechecking has the value 2, nil is distinct from 1229 integer zero. 1230 String, object, array and mapping variables are initialized to nil. Using 1231 call_other() to call a non-existant function returns nil. Variables holding 1232 an object become nil after the object has been destructed. Indexing a 1233 mapping with a non-existant index results in nil, and nil must be assigned 1234 to delete an index:value pair; assigning 0 has the same effect only when 1235 0 and nil are the same. 1236 - allocate() now allocates an array of nil values. New kfuns allocate_int() 1237 and allocate_float() explicitly allocate arrays of those respective values. 1238 - In a further bit of type matching cleanup, integer 0 and floating point 0.0 1239 no longer test as equal. 1240 - Merged T_NIL with T_INVALID internally. 1241 - It is now possible to use varargs in a parameter list to specify that only 1242 the following parameters are optional: 1243 1244 void foo(int a, varargs string b, object c) 1245 { 1246 } 1247 1248 In typechecking mode 2, this is the only way that varargs can be used. It 1249 is an error to call a function with too many or too few arguments, even when 1250 using call_other() (typechecking mode 2 only). 1251 Varargs is implied for the last parameter when using ellipsis, and need no 1252 longer be specified explicitly. 1253 - Changed over kfuns to the new varargs system. 1254 - Removed some kfun argument count checks that have become superfluous. 1255 - New variables in upgraded objects were initialized with integer 0 rather 1256 than nil. 1257 - Let send_message() and message_done() behave in the same way for telnet and 1258 binary connections. send_message() now never returns -1. 1259 - Allow callouts with millisecond delays (floating point delay argument). 1260 - Process a for loop in the same order in codegenc.c as in codegeni.c (body 1261 first, then condition), to ensure that tables are generated in the same 1262 order by both. 1263 - Math functions implemented. 1264 - New kfun millitime (was added before, but not mentioned in the log). 1265 - Made behaviour of << and >> uniform on all platforms: no negative shift 1266 allowed, shifts >= 32 make the result 0. 1267 - Check that a switch doesn't contain more than 32767 cases, and a function 1268 doesn't need more than 32767 values on the stack. 1269 - Put automatic object swapping, accidentally left out in the callout rewrite, 1270 back in. NOTE: one out of every swap_fragment objects is now swapped out 1271 at the end of each thread, rather than each second. This means that to get 1272 the same memory usage, the swap_fragment parameter should get a 1273 considerably larger value. 1274 - Simplified the automatic object swapping; too much was happening at the 1275 end of each thread, especially with many objects in memory. 1276 - Show which function is actually being called with too many or too few 1277 arguments. 1278 - Fixed a bug which could mess up the callout table when making a state dump. 1279 - Fixed a bug in the configuration phase which mysteriously escaped notice 1280 until now. 1281 - Guard against too deep recursion in the editor. 1282 - When upgrading, don't wipe out variables that change type to mixed. 1283 - Make extra-sure that sockets under Windows and BeOS are non-blocking. 1284 - Fix a bug in calling LPC code from the string parser. 1285 - parse_string() traversed alternatives even when it didn't have to. 1286 - String case labels with embedded NUL characters were not compared properly. 1287 - Fixed a tricky bug in swapping out mappings with object indices that have 1288 been destructed and replaced by a new version with the same object index, 1289 that had eluded me for a long time. 1290 - Return value of remove_call_out() was incorrect if callout didn't exist or 1291 had millisecond delay. 1292 - Slightly better indexing of mapping with string. 1293 - Removed recursion limit on catch and rlimits. 1294 - Fixed a file descriptor leak in P_readdir() for Windows. 1295 - Fixed a crash in the first uncaught error. Whoops. 1296 - Last batch of changes before atomic. 1297 - There is no need to use static, nomask or atomic in prototypes anymore. 1298 However, if any of these are specified, they must also be present in the 1299 actual function declaration. 1300 - Partial implementation of atomic functions. 1301 - Forbid file changes in atomically executed code. 1302 - Fixed a slew of bugs in atomic functions. 1303 - In case of an error in atomic code, call driver->atomic_error() with the 1304 full stack trace. Everything will be undone later, except for all use of 1305 send_message() by the driver object. 1306 - ctime() didn't give the proper weekday for times > 0x7fffffff. 1307 - If there is no more input on a connection, make sure there is no pending 1308 output before closing it. 1309 - Temporarily disable compile_object(), clone_object(), destruct_object(), 1310 call_out() and remove_call_out() from within atomic code, making atomic safe 1311 to use. 1312 - Connections with pending output that failed in a write would never get 1313 closed. 1314 - Newly added mixed variables would get the value of the old variable in the 1315 same slot during upgrading. 1316 - Adjust precompiler to latest changes in callout interface. 1317 - Get DGD on BeOS to compile again. 1318 - Fix a bug in name lookup which could hang the server. 1319 - Use a Windows font that displays properly on foreign language systems. 1320 - Only commit changes to a previous plane if there <is> a previous plane. 1321 - Fixed a bug in atomic code when swapout is involved. 1322 - The editor now shows characters in range 0x80 - 0x9f normally. 1323 - Fixed some more bugs in the name lookup code. 1324 - Encapsulate creation of values with macros, making it easier to extend the 1325 value struct. 1326 - String constants for string switches were generated in the wrong order. 1327 - Completed callout undo (atomic functions). 1328 - Fixed a reference counting bug in callout undo. 1329 - Replaced many direct object references with indirect ones. 1330 - Fixed yet another bug in the name lookup code. 1331 - Fixed a old and very rare bug in mapping addition. 1332 - New kfuns hash_crc16(), hash_md5(). 1333 - Fix a recently-introduced bug in clone upgrading. 1334 - Fix a bug in callouts with more than 3 extra arguments, introduced with 1335 callout undo. 1336 - Fixed a bug in compiling an object that redefined a privately inherited 1337 function. 1338 - Prevent a crash when space for the restoring of a huge save file cannot be 1339 allocated on the stack. 1340 - Fixed two more bugs in atomic commit code. 1341 - Allow the internal state machines for parse_string() to become larger than 1342 before. 1343 - Fixed the Windows quit/interrupt bug. 1344 - Fixed a bug that was introduced into parse_string(). 1345 - Undid an overeager optimization in parse_string(). 1346 - Fixed a string accounting bug in atomic code. 1347 - Fixed several hard-to-trigger bugs in object upgrading. 1348 - Fixed another private inheritance bug. 1349 - Completed object undo (atomic functions). 1350 WARNING: before starting to use 1.1.97 with a statedump from a previous 1351 version, make sure there are no un-upgraded clones left in the statedump. 1352 This can be done by rebooting an additional time with the previous driver 1353 version, and immediately shutting down again with a statedump. 1354 - Fixed an object undo bug. 1355 - Completed comm undo -- and the implementation of atomic functions. 1356 - Fixed a bug in users(). 1357 - Made the type of a variable that holds the number of simultaneous users 1358 configurable. 1359 - Let the DNS thread be started only once, even for several driver process 1360 runs. 1361 - Fixed some more comm bugs. 1362 - Fixed a bug that could lead to random stack overflow errors. 1363 - Made room for another type of special object. 1364 - Made maximum sizes of strings more configurable. 1365 - Allow any string as an argument to error(). 1366 - Fixed some leftover short string holdouts. 1367 - Got precompiling to work again; add global variable and function names to 1368 generated C output. 1369 - Make sure the error context is cleared at the proper time. 1370 - Fixed another object undo bug. 1371 - Completed the string accounting bug fix; the earlier fix was only partial. 1372 - Fixed the above for the case of multi-level atomic calls. 1373 - Fixed a restore-time bug involving upgraded objects. 1374 - Fixed a bug in removing dataspaces. 1375 - Allow only one simultaneous new editor instance per thread. 1376 - Fixed a bug where a connection would hang if there was pending output while 1377 the connection was lost. 1378 - Remove the swapfile before creating it, to make sure that two drivers 1379 attempting to use the same swapfile won't mess it up for both of them. 1380 - Fixed yet another object undo bug. 1381 - Undid some telnet input processing modifications, since any change in this 1382 code will only further confuse client programs. 1383 - Fixed a bug in atomic commit for exported arrays. 1384 - Fixed a bug in restoring a parser state machine. 1385 - Fixed a reference counting problem in the atomic array code. 1386 - Fixed a bug which could cause an infinite loop in flushing socket output. 1387 - The arguments of callouts were not properly committed to the base plane. 1388 - Removed some global variable dependencies from swapping and exporting. 1389 - Make sure that there is room for a new object when compiling. 1390 - Callouts were not properly committed to planes above the base plane, either. 1391 - Made the number of swap sectors to be reconstructed in the main loop 1392 configurable. 1393 - Exported arrays could be committed to the wrong plane. 1394 - Inheritance of objects that inherit destructed objects was not always 1395 checked at the right time. 1396 - Make sure that a disconnected socket with pending output is closed. 1397 - Fixed an object undo bug that could happen if an object was created and 1398 destructed on the same discarded plane. 1399 - Fixed a minor memory leak in comm.c. 1400 - Runtime_error() would erroneously not be called on an error during mudlib 1401 initialization. 1402 - Got the precompiler to work again. 1403 - Got the editor to work properly on MacOS and Windows. 1404 - Changed some fatal errors into configuration errors. 1405 - Do not allow a restart after a fatal error. 1406 - Removed support for stand-alone compilations of editor and lexical scanner. 1407 - Implemented DGD runtime extension interface. 1408 - Fixed another tricky bug that could commit arrays to the wrong plane. 1409 - Even trickier than I thought. 1410 - Make sure the return value of an atomic function is on the proper plane. 1411 - Better fix for the above. 1412 - Rebuild the swapfile slowly, even if there is no socket and/or callout 1413 activity. 1414 - Fixed the quit/interrupt problem on BeOS. 1415 - Finally fixed the DST time-jumping problem on Windows. 1416 - Get the Mac version to compile with OLDROUTINENAMES=0. 1417 - Some more Mac fixes. 1418 - If an IP name query for an IP number failed once, it would erroneously not 1419 be re-requested as long as it was still in the cache. 1420 - Start with fixed window size on Windows. 1421 - Fixed a bug in committing plane n, and then discarding plane n-1. 1422 - Fixed a memory leak in committing a mapping that has been reduced in size. 1423 - Fixed the comm code, which erroneously assumed that nothing new would be 1424 sent on a connection after the connection object was destructed. 1425 1426DGD 1.3 1427 1428 - Destructed objects in arrays were not always dealt with properly after the 1429 introduction of atomic functions. 1430 - Replacing interpreted objects with precompiled ones at restore time failed 1431 to work properly. 1432 - remove_call_out() would not always return the correct remaining time. 1433 - Destructing and then recompiling an object within the same thread could lead 1434 to trouble. 1435 - Return the correct time in the per-object list of callouts, also. 1436 - Fixed a typo in dgd_ext.h. 1437 - Forked off sdata.c from data.c. 1438 - Fixed a hanging-connection bug in comm.c. 1439 - Fixed another typo in dgd_ext.h, in the same macro. 1440 - Don't allow "..." as a path component in Windows. 1441 - Removed more global variables. 1442 - Fixed a bug in recompiling an object that indirectly inherits a privately 1443 inherited other object. 1444 - Fixed a find_object() bug in atomic code. 1445 - Fixed a bug that caused swap sectors to be freed at the wrong moment during 1446 a restore. 1447 - Inheriting an object both privately and non-privately could prevent 1448 functions from being found. 1449 - Under some circumstances, the call to message_done() would be delayed until 1450 the next callout, or until more user input was received. 1451 - Unix: make sure that a debugger won't interfere with the name lookup process. 1452 - Fixed a crashing bug in the compiler for a switch that contains only a 1453 default label. 1454 - Arrays saved with save_object() should save object values as nil, not 0. 1455 - Fixed the too-many-callouts check, which has been completely wrong since the 1456 introduction of atomic functions. 1457 - Fixed some more bugs in callouts, such as a possible crash when removing a 1458 callout with millisecond delay. 1459 - Fixed a tricky left-over version of the aforementioned bug. 1460 - Fixed the above fix. 1461 - Show a proper errormessage if precompiling fails. 1462 - Made a minor change to the code optimizer, in preparation for light-weight 1463 objects. 1464 - Partial implementation of light-weight objects. 1465 - More helpful errormessages when casting a string to float or int fails. 1466 - %f in a sscanf format strimg would match the empty string. 1467 - Fixed a bug in the pow() function. 1468 - Using new_object() on a light-weight object will now return a copy. 1469 - Lightweight objects can now be upgraded. 1470 - DGD now has fully automatic garbage collection. swapout() can still be 1471 used to reduce memory usage after a peak, or to track down memory leaks. 1472 - Fixed a bug in calculating line numbers in a stack trace. 1473 - Fixed a stack depth miscalculation bug for subranges. 1474 - Fixed some bugs in the extension interface. 1475 - Fixed a bug in array list maintenance. 1476 - Fixed a precompiled object restoring bug. 1477 - Added light-weight objects to the extension interface, and fixed some bugs. 1478 - Fixed a minor bug in restoring the parser state machine. 1479 - The wrong data was used for save_object() and restore_object() in 1480 lightweight objects. 1481 - Upgrading a lightweight object went wrong if the number of variables was 1482 increased or reduced. 1483 - Added an optional second argument to compile_object(), a string to compile 1484 the object from. 1485 - The error message for using a negative delay in a callout was wrong. 1486 - Whitespace in a grammar is now given precedence based on its position in 1487 that grammar. Previously, it always behaved as if it was the first token 1488 rule defined. 1489 - Grammars may now contain a "nomatch" token rule. 1490 - The editor could erroneously allocate dynamic instead of static memory. 1491 - Static creator functions were not called in clones or light-weight objects. 1492 - Removed even more global variables. 1493 - And yet more. 1494 - Fixed a spurious pause that would occur if the first callout started after a 1495 cold boot had a delay of 0. 1496 - Fixed a memory leak for when an error occurred during configuration. 1497 - Fixed a problem with repeatedly adding and removing callouts in atomically 1498 executed code. 1499 - Reversed most of the changes of 1.2.33 and 1.2.34, which are going to be 1500 part of a different product line. 1501 - Garbage collection made less aggressive. 1502 - Fixed several bugs in error handling. 1503 - A better fix for errors in atomic code, in combination with multi-level 1504 catches. 1505 - Fixed a bug in upgrading light-weight objects. 1506 - DGD can now listen on multiple ports (currently Unix and Windows only). 1507 - Fixed a config file reading bug that could occur if the server was restarted. 1508 - Add arrays of telnet ports and binary ports to status(). 1509 - Include the server name with the version number. 1510 - Fixed a bug in saving/restoring variables in an object that privately 1511 inherited another. 1512 - Prevent code from being erroneously optimized away in rare cases. 1513 - Fixed a bug in copying light-weight objects. 1514 - Fixed a memory leak in upgrading light-weight objects. 1515 - Preserve the right values on the stack when new_object() is called. 1516 - Fixed a memory leak when the master object of a light-weight object is 1517 destructed. 1518 - Avoid recursion when deleting a deep tree of arrays/mappings/LWOs. 1519 - Avoid recursion while saving to swap, also. 1520 - Fixed a bug in handling some regular expressions. 1521 - Measure ticks differently in parse_string(), taking the innermost loop into 1522 account. 1523 - Fixed several bugs which could, in rare cases, cause nil to turn up in 1524 mappings that had been accessed from atomically executed code. 1525 - Fixed a bug in error recovery for compiling switch statements. 1526 - Fixed a bug that could occur when upgrading an interpreted object to 1527 precompiled. 1528 - Floating point multiplication is now a little faster. 1529 - Implemented hash_crc32(), hash_sha1(), asn_add(), asn_sub(), asn_mult(), 1530 asn_div() and asn_mod(). 1531 - Fixed some bugs, and implemented asn_cmp(). 1532 - Fixed more bugs, and implemented asn_pow(). 1533 - Fixed an annoying bug in multiplication. 1534 - Implemented asn_lshift(), asn_rshift(), asn_and(), asn_or() and asn_xor(). 1535 - Implemented tick accounting for ASN functions. 1536 - Implemented encrypt() and decrypt(). 1537 - Fixed a bug with catch and atomic in precompiled code. 1538 - Fixed a recursion problem for an error in runtime_error(). 1539 - Dumpfile format slightly changed; old dumpfiles are converted automatically. 1540 - Better fix for the callout pause problem. 1541 - Even mappings without modifications can now have a hashtable; some bugs 1542 fixed for deleting mapping elements in atomic code. 1543 - Fixed a bug in the above. 1544 - And another one. 1545 - ... and yet another. 1546 - And (ugh) another. 1547 - And the (hopefully) last one. 1548 - Allow allocation of blocks up to 1G in size. 1549 - Allow more than array_size callouts per object, for compatibility with 1550 DGD/MP. 1551 - Fixed a bug that could cause a crash during the atomic commit phase. 1552 - Added a version string to the start of the state dump. 1553 - New config file parameter: dump_interval, the expected time between two 1554 statedumps. Rebuilding the swapfile is paced to this interval. 1555 - New kfun: call_touch(). 1556 - call_touch() now also works on light-weight objects. 1557 - Light-weight objects restored from the state dump were not converted 1558 properly, causing spurious driver::touch() calls. 1559 - Fixed a bug in object upgrading, introduced with call_touch(). 1560 - New kfun: datagram_challenge(), which replaces the return-TRUE-from-open() 1561 way of enabling datagram channels. Multiple datagrams are now buffered per 1562 channel. 1563 - Config file change. ({ 6047, 6048 }) for ports changed to a mapping in 1564 which the address must also be specified: ([ "*":6047, "localhost":6048 ]) 1565 - While restoring a callout, not all appropriate fields were zeroed. 1566 - Don't look for further connections when no new ones can be accepted. 1567 - Prepare the name lookup thread for running again after exiting (Windows). 1568 - A few more fixes to get restarting (not just on Windows) to work. 1569 - Two callouts started during the same thread will now always be executed in 1570 the proper order if the first has a delay N (milli)seconds larger than the 1571 second, even if DGD is delayed for more than N (milli)seconds between the 1572 first and the second callout (DGD/MP compatibility). 1573 - Make sure that a callout handle is not truncated to 16 bits before an 1574 attempt is made to remove it. 1575 - Include system files before DGD files on Windows. 1576 - Rather than causing an error, let the callout and precompiled object lists 1577 returned by status() be nil if they would not fit in an array. 1578 - The swapout callback function in the DGD extension interface is no longer 1579 used. 1580 - Call_touch() didn't work very well in atomic code. 1581 - Moved the O_PENDIO flag into the user struct as CF_OUTPUT. 1582 - O_LWOBJ is now a proper object flag. 1583 - Made sure that destructing the driver object in atomic code does not lead 1584 to trouble. 1585 - Fixed a problem with driver->recompile() in multi-level atomic code. 1586 - Input blocking didn't work properly as of the previous release, and input 1587 blocking for binary connections never worked at all. 1588 - Properly keep track of light-weight objects (bug introduced in last LWO 1589 change). 1590 - Fixed various bugs in asn_* kfuns and made the bit string functions more 1591 easily usable. 1592 - Added IPv6 support for unix. 1593 - Got namelookup to work properly again on Windows and BeOS. 1594 - IPv6 now works on Windows (XP SP1 and later). 1595 - Get DGD to work on Windows machines that don't have IPv6, too. 1596 - Changed default platform to DARWIN. 1597 - Fixed a bug in fmod(), and changed the behaviour for integer modulus with 1598 a negative second argument (the sign is now ignored). 1599 - Regular expressions now work properly in a grammar string larger than 64K. 1600 - Fixed 2 bugs in the code optimizer. 1601 - The error "Non-numeric value in indexed string assignment" occurred in an 1602 inconsistent state. 1603 - Implemented object types: object "/path/to/obj" obj; 1604 - Implemented <- as an instanceof operator: obj <- "/path/to/obj" 1605 The second argument must be a string constant. -> and <- have the same 1606 priority. 1607 - Check parameters with the called, not the calling, frame. 1608 - Fixed a string reference problem during compilation. 1609 - Disallow (int) " 123", but allow sscanf(" 123", "%f", f), making both 1610 operations consistent for int and float. 1611 - Fixed a problem in object type function argument checking that could lead 1612 to a crash. 1613 - And another one in a similar situation. 1614 - Fixed a compile-time check for the number of arguments, wrong since the 1615 introduction of object types. 1616 - Don't disconnect if destructing a connection object is prevented by an error 1617 in close(). 1618 - Perform inheritance checks only for objects compiled in 1619 driver->inherit_program() itself, not in functions called therefrom. 1620 - On Windows, random(n) would never be > 32767. 1621 - Make swapout(), dump_state() and shutdown() local to the atomic context. 1622 - Get the precompiler to work again. 1623 - Fixed a prototype conversion bug in the extension interface. 1624 - Fixed a bug in comparing function prototypes that include object types. 1625 - Forbid having undefined private functions. 1626 - Add a list of undefined functions to status(obj). 1627 - the program name in the undefined functions mapping was missing a leading 1628 slash. 1629 - Introduced hash_string() as a replacement for crypt(), hash_md5() and 1630 hash_sha1(). 1631 - Reverse the key & message arguments for encrypt() and decrypt(), to make 1632 it easier to extend those functions in the future. 1633 - Fixed a bug in the undefined function code introduced when backported from 1634 DGD/MP. 1635 - Fixed a code optimizer bug. 1636 - Do not force structure alignment through a #define, but handle it 1637 automatically. 1638 - Let the ordinary errorhandler deal with errors in remove_program(). 1639 - Fixed a bug in the listing of undefined private functions. 1640 - Fixed a bug that could lead to trouble when an object was destructed and 1641 recreated immediately after a restore from statedump. 1642 - Fixed a serious bug in errorhandling when accepting a new connection. 1643 - find_object("/too/long/name") no longer causes an error, but returns nil. 1644 - Various reference count issues corrected for light-weight objects. 1645 - Properly restore object types from a statedump. 1646 - Include private inheritance information in precompiled objects. 1647 - Fixed some refcount problems. 1648 - Let parse_string() call LPC functions in left-to-right order. 1649 - Check parser-constructed arrays for imports. 1650 - Speed up the exporting process a little. 1651 - Finally tracked down a very old bug in array importing that could lead to 1652 memory corruption. 1653 - Only seek on files when needed. 1654 - The sector size may now be decreased as well as increased. 1655 - Line numbers were incorrect when object types were involved. 1656 - Handle 64 bit time_t. 1657 - Have an error occur for a bad offset in read_file/write_file. 1658 - Allow a static function in the auto object to be masked by a prototype 1659 declaration. 1660 - Fixed a case where the callout timestamp was not updated properly. 1661 - Fixed a case where code was incorrectly optimized away. 1662 - Fixed a bug which could cause a crash if status(obj) was used on an object 1663 immediately after recompiling it. 1664 - Prevent a system time fluke from making the uptime negative. 1665 - Disallow a dynamic_chunk size of 0. 1666 - Various problems in the extension interface and documentation fixed. 1667 - Allow multiple source arguments for compile_object(), to get around the 1668 maximum string length limitation. The object will be compiled from the 1669 concatenated source strings. 1670 - Improved errorhandling in the extension interface. 1671 - In the driver object, replace path_include() by include_file(), which can 1672 return either a path or an array of strings for the include file itself. 1673 - Prevent a spurious "Mapping too large to grow" error. 1674 - Initialize variables which may be used before set each time they come into 1675 scope. 1676 - Handle atomic status properly in precompiled code with a catch. 1677 - Update the statedump format for svalues. 1678 - Removed some MP changes that have no purpose here. 1679 - Variables from newly inherited objects were not handled properly 1680 during upgrades. 1681 - Fixed a bug in object type handling in ?:. 1682 - Forbid running a precompiled object with a different typechecking level than 1683 it was compiled with. 1684 - Fixed an editor path bug inadvertedly introduced a few patches ago. 1685 - Allow multiple add-on packages to register their extra kfuns. 1686 - Fixed a swapping bug that occurred with small cache sizes. 1687 - Fixed a bug in restoring objects with class variables. 1688 - The limit of 60 seconds delay for millisecond callouts has been removed. 1689 - Instead of immediately copying the entire state dump when restoring, rebuild 1690 the swap file gradually. This allows for fast rebooting. 1691 - Fixed another class variable retrieval bug, introduced in the previous 1692 patch. 1693 - Get swap_fragment = 0 to work. 1694 - Fixed a bug in creating multiple statedumps in rapid succession. 1695 - Fixed another swap_fragment = 0 bug. 1696 - Don't hang in an infinite loop when a datagram challenge is met with an 1697 improper response. 1698 - Fixed a bug in initialized variable handling. 1699 - Fixed another such bug, in the precompiler. 1700 - Properly deal with just-destructed objects after a statedump. 1701 - Don't report objects being swapped out with swap_fragment = 0. 1702 - Fixed a bug with restoring interpreted objects that are precompiled in the 1703 driver. 1704 - Avoid spurious memory fragmentation warnings. 1705 - Some 64 bit issues fixed. 1706 - Fix the datagram challenge bug for Windows and BeOS, too. 1707 - Fixed a bug that caused the swapfile to be rebuilt much too quickly after 1708 a statedump. 1709 - Fixed a bug in upgrading directly after a statedump. 1710 - Limit the sector size to a 2 byte value. 1711 - Fixed some compilation warnings under Sun Studio. 1712 - More type information is saved in statedumps. 1713 - Callout due time code rewritten. 1714 - Get long-term integer callouts to work properly again. 1715 - During an object upgrade, only change the update field if there are clones 1716 and/or light-weight objects. 1717 - Removed hash_md5() and hash_sha1() for newly compiled objects. hash_string() 1718 should be used instead. 1719 - Allow unused kfuns to be reclaimed, using a debugger. 1720 - Fix a problem with precompiled objects, when restoring interpreted versions. 1721 - Automatically handle platforms with unsigned characters. 1722 - Removed everything from the extension interface that won't be supported in 1723 DGD/MP. 1724 - Include a table of inherited variable types in the control block, for 1725 faster object creation. 1726 - With bugfix in the above. 1727 - And another one. 1728 - Fixed a crash which could occur after the creation of an object is rolled 1729 back. 1730 - Work around an IPv6 name lookup problem on Linux. 1731 - Display IPv6 IP numbers properly. 1732 - Bring non-unix platforms up to date. 1733 1734DGD 1.4 1735 1736 - The instanceof operator '<-' now returns -1 for private inheritance. 1737 - Compress the table of inherited objects. 1738 - Prevent inheritance table overflow. 1739 - Properly restore unconverted control blocks from statedumps made by 1.3.2 1740 or later. 1741 - Handle more string constants in parse_string() grammars. 1742 - Work around a cygwin compilation problem. 1743 - Prevent a crash when attempting to read a too-large chunk from a file. 1744 - Stop generating instructions I_PUSH_ZERO and I_PUSH_ONE, allowing them to 1745 be recycled in the future. 1746 - Kfuns now have a version number, to simplify upgrading. 1747 - Allow ({ a, b }) = array; to facilitate returning multiple values from a 1748 function. 1749 - Generate the proper references to inherited global variables, which could 1750 be wrong since 1.3.2. 1751 - Removed support for platforms MacOS (pre-OSX) and BeOS. 1752 - Remove character filtering for telnet connections. 1753 - Code released under GNU AGPL. 1754