1 2014-10-20 version 2.6.1: 2 3 C++ 4 * Added atomicops support for Solaris. 5 * Released memory allocated by InitializeDefaultRepeatedFields() and 6 GetEmptyString(). Some memory sanitizers reported them as memory leaks. 7 8 Java 9 * Updated DynamicMessage.setField() to handle repeated enum values 10 correctly. 11 * Fixed a bug that caused NullPointerException to be thrown when 12 converting manually constructed FileDescriptorProto to 13 FileDescriptor. 14 15 Python 16 * Fixed WhichOneof() to work with de-serialized protobuf messages. 17 * Fixed a missing file problem of Python C++ implementation. 18 19 2014-08-15 version 2.6.0: 20 21 General 22 * Added oneofs(unions) feature. Fields in the same oneof will share 23 memory and at most one field can be set at the same time. Use the 24 oneof keyword to define a oneof like: 25 message SampleMessage { 26 oneof test_oneof { 27 string name = 4; 28 YourMessage sub_message = 9; 29 } 30 } 31 * Files, services, enums, messages, methods and enum values can be marked 32 as deprecated now. 33 * Added Support for list values, including lists of mesaages, when 34 parsing text-formatted protos in C++ and Java. 35 For example: foo: [1, 2, 3] 36 37 C++ 38 * Enhanced customization on TestFormat printing. 39 * Added SwapFields() in reflection API to swap a subset of fields. 40 Added SetAllocatedMessage() in reflection API. 41 * Repeated primitive extensions are now packable. The 42 [packed=true] option only affects serializers. Therefore, it is 43 possible to switch a repeated extension field to packed format 44 without breaking backwards-compatibility. 45 * Various speed optimizations. 46 47 Java 48 * writeTo() method in ByteString can now write a substring to an 49 output stream. Added endWith() method for ByteString. 50 * ByteString and ByteBuffer are now supported in CodedInputStream 51 and CodedOutputStream. 52 * java_generate_equals_and_hash can now be used with the LITE_RUNTIME. 53 54 Python 55 * A new C++-backed extension module (aka "cpp api v2") that replaces the 56 old ("cpp api v1") one. Much faster than the pure Python code. This one 57 resolves many bugs and is recommended for general use over the 58 pure Python when possible. 59 * Descriptors now have enum_types_by_name and extension_types_by_name dict 60 attributes. 61 * Support for Python 3. 62 63 2013-02-27 version 2.5.0: 64 65 General 66 * New notion "import public" that allows a proto file to forward the content 67 it imports to its importers. For example, 68 // foo.proto 69 import public "bar.proto"; 70 import "baz.proto"; 71 72 // qux.proto 73 import "foo.proto"; 74 // Stuff defined in bar.proto may be used in this file, but stuff from 75 // baz.proto may NOT be used without importing it explicitly. 76 This is useful for moving proto files. To move a proto file, just leave 77 a single "import public" in the old proto file. 78 * New enum option "allow_alias" that specifies whether different symbols can 79 be assigned the same numeric value. Default value is "true". Setting it to 80 false causes the compiler to reject enum definitions where multiple symbols 81 have the same numeric value. 82 Note: We plan to flip the default value to "false" in a future release. 83 Projects using enum aliases should set the option to "true" in their .proto 84 files. 85 86 C++ 87 * New generated method set_allocated_foo(Type* foo) for message and string 88 fields. This method allows you to set the field to a pre-allocated object 89 and the containing message takes the ownership of that object. 90 * Added SetAllocatedExtension() and ReleaseExtension() to extensions API. 91 * Custom options are now formatted correctly when descriptors are printed in 92 text format. 93 * Various speed optimizations. 94 95 Java 96 * Comments in proto files are now collected and put into generated code as 97 comments for corresponding classes and data members. 98 * Added Parser to parse directly into messages without a Builder. For 99 example, 100 Foo foo = Foo.PARSER.ParseFrom(input); 101 Using Parser is ~25% faster than using Builder to parse messages. 102 * Added getters/setters to access the underlying ByteString of a string field 103 directly. 104 * ByteString now supports more operations: substring(), prepend(), and 105 append(). The implementation of ByteString uses a binary tree structure 106 to support these operations efficiently. 107 * New method findInitializationErrors() that lists all missing required 108 fields. 109 * Various code size and speed optimizations. 110 111 Python 112 * Added support for dynamic message creation. DescriptorDatabase, 113 DescriptorPool, and MessageFactory work like their C++ couterparts to 114 simplify Descriptor construction from *DescriptorProtos, and MessageFactory 115 provides a message instance from a Descriptor. 116 * Added pickle support for protobuf messages. 117 * Unknown fields are now preserved after parsing. 118 * Fixed bug where custom options were not correctly populated. Custom 119 options can be accessed now. 120 * Added EnumTypeWrapper that provides better accessibility to enum types. 121 * Added ParseMessage(descriptor, bytes) to generate a new Message instance 122 from a descriptor and a byte string. 123 124 2011-05-01 version 2.4.1: 125 126 C++ 127 * Fixed the frendship problem for old compilers to make the library now gcc 3 128 compatible again. 129 * Fixed vcprojects/extract_includes.bat to extract compiler/plugin.h. 130 131 Java 132 * Removed usages of JDK 1.6 only features to make the library now JDK 1.5 133 compatible again. 134 * Fixed a bug about negative enum values. 135 * serialVersionUID is now defined in generated messages for java serializing. 136 * Fixed protoc to use java.lang.Object, which makes "Object" now a valid 137 message name again. 138 139 Python 140 * Experimental C++ implementation now requires C++ protobuf library installed. 141 See the README.txt in the python directory for details. 142 143 2011-02-02 version 2.4.0: 144 145 General 146 * The RPC (cc|java|py)_generic_services default value is now false instead of 147 true. 148 * Custom options can have aggregate types. For example, 149 message MyOption { 150 optional string comment = 1; 151 optional string author = 2; 152 } 153 extend google.protobuf.FieldOptions { 154 optional MyOption myoption = 12345; 155 } 156 This option can now be set as follows: 157 message SomeType { 158 optional int32 field = 1 [(myoption) = { comment:'x' author:'y' }]; 159 } 160 161 C++ 162 * Various speed and code size optimizations. 163 * Added a release_foo() method on string and message fields. 164 * Fixed gzip_output_stream sub-stream handling. 165 166 Java 167 * Builders now maintain sub-builders for sub-messages. Use getFooBuilder() to 168 get the builder for the sub-message "foo". This allows you to repeatedly 169 modify deeply-nested sub-messages without rebuilding them. 170 * Builder.build() no longer invalidates the Builder for generated messages 171 (You may continue to modify it and then build another message). 172 * Code generator will generate efficient equals() and hashCode() 173 implementations if new option java_generate_equals_and_hash is enabled. 174 (Otherwise, reflection-based implementations are used.) 175 * Generated messages now implement Serializable. 176 * Fields with [deprecated=true] will be marked with @Deprecated in Java. 177 * Added lazy conversion of UTF-8 encoded strings to String objects to improve 178 performance. 179 * Various optimizations. 180 * Enum value can be accessed directly, instead of calling getNumber() on the 181 enum member. 182 * For each enum value, an integer constant is also generated with the suffix 183 _VALUE. 184 185 Python 186 * Added an experimental C++ implementation for Python messages via a Python 187 extension. Implementation type is controlled by an environment variable 188 PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION (valid values: "cpp" and "python") 189 The default value is currently "python" but will be changed to "cpp" in 190 future release. 191 * Improved performance on message instantiation significantly. 192 Most of the work on message instantiation is done just once per message 193 class, instead of once per message instance. 194 * Improved performance on text message parsing. 195 * Allow add() to forward keyword arguments to the concrete class. 196 E.g. instead of 197 item = repeated_field.add() 198 item.foo = bar 199 item.baz = quux 200 You can do: 201 repeated_field.add(foo=bar, baz=quux) 202 * Added a sort() interface to the BaseContainer. 203 * Added an extend() method to repeated composite fields. 204 * Added UTF8 debug string support. 205 206 2010-01-08 version 2.3.0: 207 208 General 209 * Parsers for repeated numeric fields now always accept both packed and 210 unpacked input. The [packed=true] option only affects serializers. 211 Therefore, it is possible to switch a field to packed format without 212 breaking backwards-compatibility -- as long as all parties are using 213 protobuf 2.3.0 or above, at least. 214 * The generic RPC service code generated by the C++, Java, and Python 215 generators can be disabled via file options: 216 option cc_generic_services = false; 217 option java_generic_services = false; 218 option py_generic_services = false; 219 This allows plugins to generate alternative code, possibly specific to some 220 particular RPC implementation. 221 222 protoc 223 * Now supports a plugin system for code generators. Plugins can generate 224 code for new languages or inject additional code into the output of other 225 code generators. Plugins are just binaries which accept a protocol buffer 226 on stdin and write a protocol buffer to stdout, so they may be written in 227 any language. See src/google/protobuf/compiler/plugin.proto. 228 **WARNING**: Plugins are experimental. The interface may change in a 229 future version. 230 * If the output location ends in .zip or .jar, protoc will write its output 231 to a zip/jar archive instead of a directory. For example: 232 protoc --java_out=myproto_srcs.jar --python_out=myproto.zip myproto.proto 233 Currently the archive contents are not compressed, though this could change 234 in the future. 235 * inf, -inf, and nan can now be used as default values for float and double 236 fields. 237 238 C++ 239 * Various speed and code size optimizations. 240 * DynamicMessageFactory is now fully thread-safe. 241 * Message::Utf8DebugString() method is like DebugString() but avoids escaping 242 UTF-8 bytes. 243 * Compiled-in message types can now contain dynamic extensions, through use 244 of CodedInputStream::SetExtensionRegistry(). 245 * Now compiles shared libraries (DLLs) by default on Cygwin and MinGW, to 246 match other platforms. Use --disable-shared to avoid this. 247 248 Java 249 * parseDelimitedFrom() and mergeDelimitedFrom() now detect EOF and return 250 false/null instead of throwing an exception. 251 * Fixed some initialization ordering bugs. 252 * Fixes for OpenJDK 7. 253 254 Python 255 * 10-25 times faster than 2.2.0, still pure-Python. 256 * Calling a mutating method on a sub-message always instantiates the message 257 in its parent even if the mutating method doesn't actually mutate anything 258 (e.g. parsing from an empty string). 259 * Expanded descriptors a bit. 260 261 2009-08-11 version 2.2.0: 262 263 C++ 264 * Lite mode: The "optimize_for = LITE_RUNTIME" option causes the compiler 265 to generate code which only depends libprotobuf-lite, which is much smaller 266 than libprotobuf but lacks descriptors, reflection, and some other features. 267 * Fixed bug where Message.Swap(Message) was only implemented for 268 optimize_for_speed. Swap now properly implemented in both modes 269 (Issue 91). 270 * Added RemoveLast and SwapElements(index1, index2) to Reflection 271 interface for repeated elements. 272 * Added Swap(Message) to Reflection interface. 273 * Floating-point literals in generated code that are intended to be 274 single-precision now explicitly have 'f' suffix to avoid pedantic warnings 275 produced by some compilers. 276 * The [deprecated=true] option now causes the C++ code generator to generate 277 a GCC-style deprecation annotation (no-op on other compilers). 278 * google::protobuf::GetEnumDescriptor<SomeGeneratedEnumType>() returns the 279 EnumDescriptor for that type -- useful for templates which cannot call 280 SomeGeneratedEnumType_descriptor(). 281 * Various optimizations and obscure bug fixes. 282 283 Java 284 * Lite mode: The "optimize_for = LITE_RUNTIME" option causes the compiler 285 to generate code which only depends libprotobuf-lite, which is much smaller 286 than libprotobuf but lacks descriptors, reflection, and some other features. 287 * Lots of style cleanups. 288 289 Python 290 * Fixed endianness bug with floats and doubles. 291 * Text format parsing support. 292 * Fix bug with parsing packed repeated fields in embedded messages. 293 * Ability to initialize fields by passing keyword args to constructor. 294 * Support iterators in extend and __setslice__ for containers. 295 296 2009-05-13 version 2.1.0: 297 298 General 299 * Repeated fields of primitive types (types other that string, group, and 300 nested messages) may now use the option [packed = true] to get a more 301 efficient encoding. In the new encoding, the entire list is written 302 as a single byte blob using the "length-delimited" wire type. Within 303 this blob, the individual values are encoded the same way they would 304 be normally except without a tag before each value (thus, they are 305 tightly "packed"). 306 * For each field, the generated code contains an integer constant assigned 307 to the field number. For example, the .proto file: 308 message Foo { optional int bar_baz = 123; } 309 would generate the following constants, all with the integer value 123: 310 C++: Foo::kBarBazFieldNumber 311 Java: Foo.BAR_BAZ_FIELD_NUMBER 312 Python: Foo.BAR_BAZ_FIELD_NUMBER 313 Constants are also generated for extensions, with the same naming scheme. 314 These constants may be used as switch cases. 315 * Updated bundled Google Test to version 1.3.0. Google Test is now bundled 316 in its verbatim form as a nested autoconf package, so you can drop in any 317 other version of Google Test if needed. 318 * optimize_for = SPEED is now the default, by popular demand. Use 319 optimize_for = CODE_SIZE if code size is more important in your app. 320 * It is now an error to define a default value for a repeated field. 321 Previously, this was silently ignored (it had no effect on the generated 322 code). 323 * Fields can now be marked deprecated like: 324 optional int32 foo = 1 [deprecated = true]; 325 Currently this does not have any actual effect, but in the future the code 326 generators may generate deprecation annotations in each language. 327 * Cross-compiling should now be possible using the --with-protoc option to 328 configure. See README.txt for more info. 329 330 protoc 331 * --error_format=msvs option causes errors to be printed in Visual Studio 332 format, which should allow them to be clicked on in the build log to go 333 directly to the error location. 334 * The type name resolver will no longer resolve type names to fields. For 335 example, this now works: 336 message Foo {} 337 message Bar { 338 optional int32 Foo = 1; 339 optional Foo baz = 2; 340 } 341 Previously, the type of "baz" would resolve to "Bar.Foo", and you'd get 342 an error because Bar.Foo is a field, not a type. Now the type of "baz" 343 resolves to the message type Foo. This change is unlikely to make a 344 difference to anyone who follows the Protocol Buffers style guide. 345 346 C++ 347 * Several optimizations, including but not limited to: 348 - Serialization, especially to flat arrays, is 10%-50% faster, possibly 349 more for small objects. 350 - Several descriptor operations which previously required locking no longer 351 do. 352 - Descriptors are now constructed lazily on first use, rather than at 353 process startup time. This should save memory in programs which do not 354 use descriptors or reflection. 355 - UnknownFieldSet completely redesigned to be more efficient (especially in 356 terms of memory usage). 357 - Various optimizations to reduce code size (though the serialization speed 358 optimizations increased code size). 359 * Message interface has method ParseFromBoundedZeroCopyStream() which parses 360 a limited number of bytes from an input stream rather than parsing until 361 EOF. 362 * GzipInputStream and GzipOutputStream support reading/writing gzip- or 363 zlib-compressed streams if zlib is available. 364 (google/protobuf/io/gzip_stream.h) 365 * DescriptorPool::FindAllExtensions() and corresponding 366 DescriptorDatabase::FindAllExtensions() can be used to enumerate all 367 extensions of a given type. 368 * For each enum type Foo, protoc will generate functions: 369 const string& Foo_Name(Foo value); 370 bool Foo_Parse(const string& name, Foo* result); 371 The former returns the name of the enum constant corresponding to the given 372 value while the latter finds the value corresponding to a name. 373 * RepeatedField and RepeatedPtrField now have back-insertion iterators. 374 * String fields now have setters that take a char* and a size, in addition 375 to the existing ones that took char* or const string&. 376 * DescriptorPool::AllowUnknownDependencies() may be used to tell 377 DescriptorPool to create placeholder descriptors for unknown entities 378 referenced in a FileDescriptorProto. This can allow you to parse a .proto 379 file without having access to other .proto files that it imports, for 380 example. 381 * Updated gtest to latest version. The gtest package is now included as a 382 nested autoconf package, so it should be able to drop new versions into the 383 "gtest" subdirectory without modification. 384 385 Java 386 * Fixed bug where Message.mergeFrom(Message) failed to merge extensions. 387 * Message interface has new method toBuilder() which is equivalent to 388 newBuilderForType().mergeFrom(this). 389 * All enums now implement the ProtocolMessageEnum interface. 390 * Setting a field to null now throws NullPointerException. 391 * Fixed tendency for TextFormat's parsing to overflow the stack when 392 parsing large string values. The underlying problem is with Java's 393 regex implementation (which unfortunately uses recursive backtracking 394 rather than building an NFA). Worked around by making use of possesive 395 quantifiers. 396 * Generated service classes now also generate pure interfaces. For a service 397 Foo, Foo.Interface is a pure interface containing all of the service's 398 defined methods. Foo.newReflectiveService() can be called to wrap an 399 instance of this interface in a class that implements the generic 400 RpcService interface, which provides reflection support that is usually 401 needed by RPC server implementations. 402 * RPC interfaces now support blocking operation in addition to non-blocking. 403 The protocol compiler generates separate blocking and non-blocking stubs 404 which operate against separate blocking and non-blocking RPC interfaces. 405 RPC implementations will have to implement the new interfaces in order to 406 support blocking mode. 407 * New I/O methods parseDelimitedFrom(), mergeDelimitedFrom(), and 408 writeDelimitedTo() read and write "delemited" messages from/to a stream, 409 meaning that the message size precedes the data. This way, you can write 410 multiple messages to a stream without having to worry about delimiting 411 them yourself. 412 * Throw a more descriptive exception when build() is double-called. 413 * Add a method to query whether CodedInputStream is at the end of the input 414 stream. 415 * Add a method to reset a CodedInputStream's size counter; useful when 416 reading many messages with the same stream. 417 * equals() and hashCode() now account for unknown fields. 418 419 Python 420 * Added slicing support for repeated scalar fields. Added slice retrieval and 421 removal of repeated composite fields. 422 * Updated RPC interfaces to allow for blocking operation. A client may 423 now pass None for a callback when making an RPC, in which case the 424 call will block until the response is received, and the response 425 object will be returned directly to the caller. This interface change 426 cannot be used in practice until RPC implementations are updated to 427 implement it. 428 * Changes to input_stream.py should make protobuf compatible with appengine. 429 430 2008-11-25 version 2.0.3: 431 432 protoc 433 * Enum values may now have custom options, using syntax similar to field 434 options. 435 * Fixed bug where .proto files which use custom options but don't actually 436 define them (i.e. they import another .proto file defining the options) 437 had to explicitly import descriptor.proto. 438 * Adjacent string literals in .proto files will now be concatenated, like in 439 C. 440 * If an input file is a Windows absolute path (e.g. "C:\foo\bar.proto") and 441 the import path only contains "." (or contains "." but does not contain 442 the file), protoc incorrectly thought that the file was under ".", because 443 it thought that the path was relative (since it didn't start with a slash). 444 This has been fixed. 445 446 C++ 447 * Generated message classes now have a Swap() method which efficiently swaps 448 the contents of two objects. 449 * All message classes now have a SpaceUsed() method which returns an estimate 450 of the number of bytes of allocated memory currently owned by the object. 451 This is particularly useful when you are reusing a single message object 452 to improve performance but want to make sure it doesn't bloat up too large. 453 * New method Message::SerializeAsString() returns a string containing the 454 serialized data. May be more convenient than calling 455 SerializeToString(string*). 456 * In debug mode, log error messages when string-type fields are found to 457 contain bytes that are not valid UTF-8. 458 * Fixed bug where a message with multiple extension ranges couldn't parse 459 extensions. 460 * Fixed bug where MergeFrom(const Message&) didn't do anything if invoked on 461 a message that contained no fields (but possibly contained extensions). 462 * Fixed ShortDebugString() to not be O(n^2). Durr. 463 * Fixed crash in TextFormat parsing if the first token in the input caused a 464 tokenization error. 465 * Fixed obscure bugs in zero_copy_stream_impl.cc. 466 * Added support for HP C++ on Tru64. 467 * Only build tests on "make check", not "make". 468 * Fixed alignment issue that caused crashes when using DynamicMessage on 469 64-bit Sparc machines. 470 * Simplify template usage to work with MSVC 2003. 471 * Work around GCC 4.3.x x86_64 compiler bug that caused crashes on startup. 472 (This affected Fedora 9 in particular.) 473 * Now works on "Solaris 10 using recent Sun Studio". 474 475 Java 476 * New overload of mergeFrom() which parses a slice of a byte array instead 477 of the whole thing. 478 * New method ByteString.asReadOnlyByteBuffer() does what it sounds like. 479 * Improved performance of isInitialized() when optimizing for code size. 480 481 Python 482 * Corrected ListFields() signature in Message base class to match what 483 subclasses actually implement. 484 * Some minor refactoring. 485 * Don't pass self as first argument to superclass constructor (no longer 486 allowed in Python 2.6). 487 488 2008-09-29 version 2.0.2: 489 490 General 491 * License changed from Apache 2.0 to New BSD. 492 * It is now possible to define custom "options", which are basically 493 annotations which may be placed on definitions in a .proto file. 494 For example, you might define a field option called "foo" like so: 495 import "google/protobuf/descriptor.proto" 496 extend google.protobuf.FieldOptions { 497 optional string foo = 12345; 498 } 499 Then you annotate a field using the "foo" option: 500 message MyMessage { 501 optional int32 some_field = 1 [(foo) = "bar"] 502 } 503 The value of this option is then visible via the message's 504 Descriptor: 505 const FieldDescriptor* field = 506 MyMessage::descriptor()->FindFieldByName("some_field"); 507 assert(field->options().GetExtension(foo) == "bar"); 508 This feature has been implemented and tested in C++ and Java. 509 Other languages may or may not need to do extra work to support 510 custom options, depending on how they construct descriptors. 511 512 C++ 513 * Fixed some GCC warnings that only occur when using -pedantic. 514 * Improved static initialization code, making ordering more 515 predictable among other things. 516 * TextFormat will no longer accept messages which contain multiple 517 instances of a singular field. Previously, the latter instance 518 would overwrite the former. 519 * Now works on systems that don't have hash_map. 520 521 Java 522 * Print @Override annotation in generated code where appropriate. 523 524 Python 525 * Strings now use the "unicode" type rather than the "str" type. 526 String fields may still be assigned ASCII "str" values; they will 527 automatically be converted. 528 * Adding a property to an object representing a repeated field now 529 raises an exception. For example: 530 # No longer works (and never should have). 531 message.some_repeated_field.foo = 1 532 533 Windows 534 * We now build static libraries rather than DLLs by default on MSVC. 535 See vsprojects/readme.txt for more information. 536 537 2008-08-15 version 2.0.1: 538 539 protoc 540 * New flags --encode and --decode can be used to convert between protobuf text 541 format and binary format from the command-line. 542 * New flag --descriptor_set_out can be used to write FileDescriptorProtos for 543 all parsed files directly into a single output file. This is particularly 544 useful if you wish to parse .proto files from programs written in languages 545 other than C++: just run protoc as a background process and have it output 546 a FileDescriptorList, then parse that natively. 547 * Improved error message when an enum value's name conflicts with another 548 symbol defined in the enum type's scope, e.g. if two enum types declared 549 in the same scope have values with the same name. This is disallowed for 550 compatibility with C++, but this wasn't clear from the error. 551 * Fixed absolute output paths on Windows. 552 * Allow trailing slashes in --proto_path mappings. 553 554 C++ 555 * Reflection objects are now per-class rather than per-instance. To make this 556 possible, the Reflection interface had to be changed such that all methods 557 take the Message instance as a parameter. This change improves performance 558 significantly in memory-bandwidth-limited use cases, since it makes the 559 message objects smaller. Note that source-incompatible interface changes 560 like this will not be made again after the library leaves beta. 561 * Heuristically detect sub-messages when printing unknown fields. 562 * Fix static initialization ordering bug that caused crashes at startup when 563 compiling on Mac with static linking. 564 * Fixed TokenizerTest when compiling with -DNDEBUG on Linux. 565 * Fixed incorrect definition of kint32min. 566 * Fix bytes type setter to work with byte sequences with embedded NULLs. 567 * Other irrelevant tweaks. 568 569 Java 570 * Fixed UnknownFieldSet's parsing of varints larger than 32 bits. 571 * Fixed TextFormat's parsing of "inf" and "nan". 572 * Fixed TextFormat's parsing of comments. 573 * Added info to Java POM that will be required when we upload the 574 package to a Maven repo. 575 576 Python 577 * MergeFrom(message) and CopyFrom(message) are now implemented. 578 * SerializeToString() raises an exception if the message is missing required 579 fields. 580 * Code organization improvements. 581 * Fixed doc comments for RpcController and RpcChannel, which had somehow been 582 swapped. 583 * Fixed text_format_test on Windows where floating-point exponents sometimes 584 contain extra zeros. 585 * Fix Python service CallMethod() implementation. 586 587 Other 588 * Improved readmes. 589 * VIM syntax highlighting improvements. 590 591 2008-07-07 version 2.0.0: 592 593 * First public release. 594