Skip to content


Subversion checkout URL

You can clone with
Download ZIP
Tree: 98981fac5c
Fetching contributors…

Cannot retrieve contributors at this time

113 lines (76 sloc) 3.78 KB
high priority
Update the web site to reflect the new installation instructions.
Use autoconf/automake to configure protoc/lisp and protoc/sexp.
Fix generated code so that unknown proto fields are collected into a data
Remove all references to the BASE package in generated code. Make generated
files independently loadable.
Use base::vector-index or eliminate it in protobuf Lisp files?
Add more tests for merging from a protobuf instance.
Implement extensions
Add tests
Look at all XXXX comments in the compiler source and remove them.
involves filing some bugs against C++ code
General stuff
5. read the binary description of a protocol buffer into RAM
output S-expression protobuf forms
Compare output to S-expression backend of compiler on all Google protobufs.
Talk to Kenton about which approach he prefers -- backend or binary reader.
6. read S-expression protobuf forms
create internal protobuf data structures that represent the messages
generate Lisp code that uses proto form to read and write binary data
generate Lisp code that directly reads and writes binary data
Look at the Java unit tests for unittest.proto
Maybe the Java semantics are what we want, since protos are more
immutable in the Java world.
What do we do with strings?
Some are declared as byte(octet) arrays, others as strings.
add slick check-several bits code to clear / is-initialized
implement RPC service stubs ??
move more unit test code from google-protobuf/src/google/protobuf into protobuf
review proto-lisp-test code ... remove it ?
move the package decl for protocol-buffer into each compiled file?
would be nice of users could just load a compiled protobuf
pick a testing framework
Port the tests to the unit test framework.
look at all tests in google-protobuf/src/google/protobuf
start migrating them here
create a testing directory?
Figure out a strategy for specifying Common Lisp optimization levels and
apply it uniformally. There's some support for this in optimize.lisp, and
there are some #+opt conditionalizations sprinkled around the code.
primitive field octet size and serialize do not work with packed
repeated data ...
search for "packed" in at lease and
add extensions and other features needed to load protobuf files
add README file to the top level explaining the Lisp changes
merge in latest Google changes
Implement a protocol buffer compiler. There are several ways to do this.
Here are my favorites:
a. Implement a new backend for Google's protocol buffer compiler that
generates CLOS classes from protobuf descriptions. It is unlikely that
Google will integrate this change into their code, and it requires Lisp
developers to use Google's protobuf syntax.
b. Implement a new backend for Google's protocol buffer compiler that
outputs protobuf descriptions in s-expression form. Write a compiler in
Lisp that translates the s-expressions into CLOS classes. Google may be
more receptive to integrating this change into their code, since it is
useful for any language in the Lisp family. Also, the change is much
smaller, amounting to just a pretty printer. Lisp developers can write
protobuf descriptions as s-expressions. The disadvantage is that this
approach is a bit more work.
c. Implement a compiler via either of the methods above that converts
protobuf descriptions into run-time data structures. The programmer
decides which protobufs are translated into code at compile time and which
are translated at run time. In the second case, the CLOS generic
functions for a protobuf would just be small stubs. When they are ever
called, they replace themselves with the right access code.
Jump to Line
Something went wrong with that request. Please try again.