Ignore-this: aa3a3b933a4c89e2ee1f911a7d817509

darcs-hash:f4113722f0acc0f3ab7f60d9e880a8d19ca0292c

Ignore-this: 61d7e8213b5e0fc764ebfbe7cc199c66

PARSE-NUMBER used to use READ-FROM-STRING.  This was causing problems with
some application-building systems. We replace use of the reader (through
read-from-string) by PARSE-NUMBER.

darcs-hash:83714c5dde3da6e58d17766ea6311529e4bda293

darcs-hash:bf783749252da7e5866b376ec10fca76ca214175

darcs-hash:f45ad0aa5a0ea9e392df3653637524f513402d6d

darcs-hash:8b1575728f0c8118231e0ca4e2ca50771acb3c7e

darcs-hash:d9321b1a8f53bfd78c6e15b0d330b1dd55ce73cf

darcs-hash:ba69adcb53497502e31d4ae3ac26af85b390572c

darcs-hash:bd2d34e74d7cba27b3e3736fe65b2627a7bdbb74

darcs-hash:e43f512825a5d6330c4b04695b638a6696d142d1

darcs-hash:611eeec784fcb705a1694b8b1848a94aab97a32a

A large number of changes that provide json-rpc-2.0 support to
cl-json.  Tests are included.

darcs-hash:79170f123f878bab89580228742102860b5930a9

  Originally, when one defined a function to be exported as a json-rpc
  function, the function object was cached in a hash table.  This made it
  very difficult to debug with the CL tracer, since the trace-encapsulated
  function wouldn't make it onto the function table.  However, this problem
  goes away with this patch, which caches the function /name/ (a symbol)
  instead of the function itself.  Since json-rpc functions are invoked
  with APPLY, nothing else need change.  Slightly less efficient, but
  JSON-RPC is never going to be that efficient anyway.

darcs-hash:6cbf64e6a3c7c2f1a6a3d0ef3c62f01b4294bb0f

darcs-hash:2a17ebd0757961a53050bd251207fa44eb4e1c88

Reorganized JSON-RPC result encoding, using CLOS, to make it more flexible,
along lines discussed on the mailing list.

Also added /partial/ support for JSON-RPC 2.0.

This support is not yet tested in the test suite.

darcs-hash:9e5c2e2612459c486253c91b20feea833f866b75

darcs-hash:8f1e9fa6f270ca341a9f3998952836bd356d624d

On Allegro Common Lisp, when there's a numeric overflow in the reader,
they don't signal a reader-error, but a simple-error (I have reported this
and they may fix it in the future).  This patch makes use of information
about that simple-error to catch the case in parse-number and treat it
the way parse-number overflows are handled on other lisps.

darcs-hash:699f0644f511321c9970c997685f78c64a1ec573

A couple of modifications to hande JSON-RPC notifications (like normal requests, but they
don't expect a response).

Also made it possible to invoke a helper function of invoke-json with the pieces of the
request.  This is necessary because you can't use the standard invoke-rpc if you've
already parsed the JSON message from the client.

darcs-hash:291c0ac880ce33534006a5c633c08f7d6fb9dc94

Ignore-this: 47abf3061d43c8088614a40744ecd3b3

darcs-hash:80c3e13e65fa9a1b25fb28cfa777228af8fedb16

Allegro just raises a simple-error when it reads a floating point
number that's too big.  So we have to catch simple errors when
in parse-number on allegro.

darcs-hash:1c9f3f52d57e5b20a063e9e396b299420ffa01aa

Ignore-this: 9beb1705b45b3692776de2f3731112b7

darcs-hash:ce641288c5b582001a85ea07223088e754580158

Ignore-this: 360302b256b196d7186d7b1bbc6384d2

darcs-hash:6bd9f3975de1147464861c123f99edb5cf564143

Ignore-this: 555b36f352707e7baec21f2638f60d0b
With testcases.

darcs-hash:de8a913aa3282f69f4d8f3b7c6c0dd1d2324c6ea

Ignore-this: 50a860841d16fc5333f17b6392c006f6
beacuse it establishes a new restart for every recursion. My top count
was 8000+ restarts. Instead, export it and let the user use it outside any
encode-json calls if he or she wants it.

darcs-hash:49a84c878b8817f2c255666c185dc7a3927a1b4e

Ignore-this: 1e809eead41e2f6bc8d1e3e490c80cfe

darcs-hash:b41e358b65edd3825ac34cf8cc485c5cb555c35e

Ignore-this: 8d2d1d112d69b0abfe2194010da5cc35

darcs-hash:02f255d6976f67f250d774166242f70fbcc175bf

Ignore-this: 44ab030099e2258d7acb37b647911fe4
The default json-intern is not safe (spotted by Red Daly). Interns of
many unique symbols could potentially use a lot of memory.  An attack
could exploit this by submitting something that is passed through
cl-json that has many very large, unique symbols. This version is safe
in that respect because it only allows symbols that already exists.

darcs-hash:03353858e9fcb248ba6e6252e4198a85ca3dbc4a

Ignore-this: a4a08ed5960fb2417c584d6a86277291

darcs-hash:f018ff31ccb1722268e520858ee8d3eb00f48b84

1) Through the use of string-stream accumulators.
2) By compiling escape char lookup as a CASE construction.

darcs-hash:e45e27051c13fd4bccf1c3e605db8f28ba3cc6af

The former do not improve performance as I was hoping, if anything, they
harm it.

darcs-hash:bc1ca7eb459bf01c463e0c6bd8e067c126c4b9f3

darcs-hash:a118489e82f0acdf2b2836470b4750a3b589bd2e

darcs-hash:18cd3ea3667f70be4b401292207ac716e17deab8

Workaround for the Clozure idiosyncrasy that the patch Thu Feb 26 15:22:25 MSK 2009  Henrik Hjelte <henrik@evahjelte.com> used to solve.

darcs-hash:3764ef105cac52e81900998481d6d451b27221b3

darcs-hash:678ba83cb93a0aa072f1b2657598321ce04ded9f

Removed symboltojs.lisp, as the functionality of SYMBOL-TO-JS is subsumed by LISP-TO-CAMEL-CASE.  Fixed conflicts which the patches of Dec. 8, 2008 were causing with more recent ones.

darcs-hash:92ef305aa1ff60d80190adab53abc5b9bbd0390e

* Improved error handling: several ostensibly exceptional
  situations which were previously handled inconsistently (or not
  handled at all) are now reified as condition types and
  restarts, among them new ones: UNENCODABLE-VALUE-ERROR,
  SUBSTITUTE-PRINTED-REPRESENTATION, BIGNUMBER-STRING,
  RATIONAL-APPROXIMATION, PLACEHOLDER.

* Added function DECODE-JSON-FROM-SOURCE.

* Encoding and decoding operations shall henceforth have their
  own default streams, *JSON-OUTPUT* and *JSON-INPUT*.

* It is now permissible to use strings as prototypes.  (String
  prototype is interpreted as the name of the class, interned in
  the current *JSON-SYMBOLS-PACKAGE*.)

* Fixed some bugs (and sources of compiler warnings).

* Fixed some documentation strings, argument naming and
  passing conventions, and return values.

* Fixed some copyright notices.

* Improved implementation of JSON-BIND.

* Put CLOS semantics under conditional compilation guards.

* Advanced the version number to 0.4.0.

darcs-hash:64cf95786ab3b66ac3531570ba62f46e3fa69d08

darcs-hash:5051f8ef0d72933af45c096f9137d29a2fe0e291

The new implementation replaces fall-back function handler with restarts
(returning prefixed string, rational approximation, or user-supplied
placeholder) which seems more proper in this context.

darcs-hash:d1b9753949f20bf57acc6ef11af96de03cf96828

Originally, an anonymous singleton class was created for each unprototyped
object received by the decoder.  It turned out that this approach can lead to
strong degradation of performance.  E. g., OpenMCL employs an optimization
technique which includes caching methods of generic function based on the
classes of their arguments.  If classes proliferate beyond measure, the effect
of caching is the opposite of intended.

The new approach is to keep a table of classes (mapping from lists of classes
such as prototyped lispSuperclasses to anonymous fluid classes).  For every
received unprototyped object we either create a new entry or, if a class with
exactly the same list of superclasses is already in the table, update it to
include the new slots.  Anyway, a typical remote party (such as a web app)
can be expected to have only a few different object configurations.

The code is now much cleaner and includes a rounded-up interface to fluid
classes.  A lot of docstrings has been added as well.

darcs-hash:f8c70831cdf301fc2608a0dece1df2062dad2dbe

darcs-hash:49bef834d27b3694c15202a172f631932ff93328

darcs-hash:84edff4234aacc57ba7b9d85a2e9e0abab9d66bf