Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
Protocol Buffers - Google's data interchange format (grpc依赖) https://developers.google.com/protocol-buffers/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
602 Commits
201 Branches
346 Tags
254 MiB
Tag: Branch: Tree: b354ead7ef
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b354ead7ef'
${ noResults }
protobuf/Makefile

521 lines
16 KiB
Raw Normal View History Unescape

Various fixes.
16 years ago
#
Significant memory-management refactoring any Python extension.
15 years ago
# This Makefile builds the upb library as well as associated tests, tools, and
# language extensions.
#
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
# It does not use autoconf/automake/libtool in order to stay lightweight and
# avoid the need for running ./configure.
Significant memory-management refactoring any Python extension.
15 years ago
#
Various fixes.
16 years ago
# Summary of compiler flags you may want to use:
#
Make the absence of perf-cppflags give a good default build. Defaults are now: - thread-safe with GCC/Clang - Debugging not enabled (enable with -UNDEBUG)
10 years ago
# * -UNDEBUG: enables assertions() (makes binary larger and slower)
# * -O0: disable optimizations
# * -g: enable debug symbols
Various fixes.
16 years ago
# * -fomit-frame-pointer: makes code smaller and faster by freeing up a reg.
#
# Threading:
# * -DUPB_THREAD_UNSAFE: remove all thread-safety.
Initial commit.
16 years ago
Changes from Google-internal development. * JSON parser expanded to handle split buffers. * bugfix to the protobuf decoder.
10 years ago
.PHONY: all lib clean tests test descriptorgen amalgamate
Use FDO for benchmarks, which gives a 10-15% improvement.
14 years ago
.PHONY: clean_leave_profile
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# Prevents the deletion of intermediate files.
.SECONDARY:
Sync from Google-internal development. Most notably, a JSON parser is now provided.
10 years ago
UPB_MODULES = upb upb.pb upb.json upb.descriptor
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
UPB_LIBS = $(patsubst %,lib/lib%.a,$(UPB_MODULES))
UPB_PICLIBS = $(patsubst %,lib/lib%_pic.a,$(UPB_MODULES))
# Default rule: build all upb libraries (but no bindings)
default: $(UPB_LIBS)
Const invasion: large parts of upb made const-correct.
13 years ago
# All: build absolutely everything
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
all: lib tests tools/upbc lua python
Const invasion: large parts of upb made const-correct.
13 years ago
testall: test pythontest
Makefile is much improved ("make deps" works again, etc).
16 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# Set this to have user-specific flags (especially things like -O0 and -g).
Enabled asserts() and verbosity for most Travis builds. Also added a separate ndebug build for testing that -DNDEBUG builds still work. Also disabled reference debugging by default, since it requires either a global lock or -DUPB_THREAD_UNSAFE.
10 years ago
USER_CPPFLAGS?=
Don't require NASM to build unless using the x64 decoder.
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# Build with "make WITH_JIT=yes" (or anything besides "no") to enable the JIT.
WITH_JIT=no
Benchmark JIT vs no JIT without forcing a whole-project recompile.
13 years ago
Enable Travis for Clang, and enable -Werror for all Travis builds. Also added an extra Clang-only warning flag.
10 years ago
# Build with "make UPB_FAIL_WARNINGS=yes" (or anything besides "no") to turn
# warnings into errors.
UPB_FAIL_WARNINGS?=no
Resolve compilation errors if compiled with more stringent semantic checks. Adding Travis test to build with strict warnings. Fixing a warning in a test which used signed/unsigned integer comparison.
10 years ago
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
# Basic compiler/flag setup.
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
# We are C89/C++98, with the one exception that we need stdint and "long long."
Enable Travis for Clang, and enable -Werror for all Travis builds. Also added an extra Clang-only warning flag.
10 years ago
CC?=cc
CXX?=c++
Parameterize AR properly in the Makefile.
10 years ago
AR?=ar
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
CFLAGS=
CXXFLAGS=
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
INCLUDE=-I.
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
CSTD=-std=c89 -pedantic -Wno-long-long
CXXSTD=-std=c++98 -pedantic -Wno-long-long
Enable Travis for Clang, and enable -Werror for all Travis builds. Also added an extra Clang-only warning flag.
10 years ago
WARNFLAGS=-Wall -Wextra -Wpointer-arith
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
WARNFLAGS_CXX=$(WARNFLAGS) -Wno-unused-private-field
Sync to Google-internal development.
10 years ago
CPPFLAGS=$(INCLUDE) -DNDEBUG $(USER_CPPFLAGS)
Updated benchmarks to new APIs.
12 years ago
LUA=lua # 5.1 and 5.2 should both be supported
Makefile is much improved ("make deps" works again, etc).
16 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
ifneq ($(WITH_JIT), no)
USE_JIT=true
CPPFLAGS += -DUPB_USE_JIT_X64
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
EXTRA_LIBS += -ldl
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
endif
Enable Travis for Clang, and enable -Werror for all Travis builds. Also added an extra Clang-only warning flag.
10 years ago
ifeq ($(CC), clang)
WARNFLAGS += -Wconditional-uninitialized
endif
ifeq ($(CXX), clang++)
WARNFLAGS_CXX += -Wconditional-uninitialized
endif
ifneq ($(UPB_FAIL_WARNINGS), no)
WARNFLAGS += -Werror
WARNFLAGS_CXX += -Werror
Resolve compilation errors if compiled with more stringent semantic checks. Adding Travis test to build with strict warnings. Fixing a warning in a test which used signed/unsigned integer comparison.
10 years ago
endif
Support "make Q=" to view full commands.
14 years ago
# Build with "make Q=" to see all commands that are being executed.
Enabled asserts() and verbosity for most Travis builds. Also added a separate ndebug build for testing that -DNDEBUG builds still work. Also disabled reference debugging by default, since it requires either a global lock or -DUPB_THREAD_UNSAFE.
10 years ago
Q?=@
Support "make Q=" to view full commands.
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# Function to expand a wildcard pattern recursively.
rwildcard=$(strip $(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2)$(filter $(subst *,%,$2),$d)))
Support "make Q=" to view full commands.
14 years ago
ifeq ($(Q), @)
E=@echo
else
E=@:
endif
Beginnings of a prototype Ruby extension.
10 years ago
install:
test -f upb/bindings/ruby/upb.so && cd upb/bindings/ruby && make install
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
# Dependency generating. #######################################################
Minor bugfix and makefile change.
16 years ago
The last major revision to the upb_stream protocol. Sources and sinks communicate by means of a upb_handlers object, which encapsulates a set of handler callbacks and will possibly offer richer semantics in the future like giving specific fields different callbacks. The upb_handlers protocol supports delegation, so sets of handlers can be written in reusable ways. For example, if a set of handlers is written to handle a specific .proto type, those handlers can be used whether that type is at the top level or whether it is a sub-message of a higher-level type. Delegation allows the streaming protocol to properly compose.
14 years ago
-include deps
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
# Unfortuantely we can't easily generate deps for benchmarks or tests because
# of the scheme we use that compiles the same source file multiple times with
# different -D options, which can include different header files.
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
dep:
Directory restructure. Includes are now via upb/foo.h. Files specific to the protobuf format are now in upb/pb (the core library is concerned with message definitions, handlers, and byte streams, but knows nothing about any particular serializationf format).
14 years ago
$(E) Regenerating dependencies for upb/...
Fold gen-deps.sh into Makefile.
13 years ago
@set -e
@rm -f deps
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
@for file in $$(find . -name '*.c'); do \
Revised upb_bytesink, refactored upb_textprinter (untested).
13 years ago
gcc -MM $$file -MT $${file%.*}.o $(CPPFLAGS) -I. >> deps 2> /dev/null; \
Fold gen-deps.sh into Makefile.
13 years ago
done
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
clean_leave_profile:
Enable more Travis configurations.
10 years ago
@rm -rf obj lib
Coverage support for coveralls.io.
10 years ago
@rm -f tests/google_message?.h
Enable more Travis configurations.
10 years ago
@rm -f $(TESTS) tests/testmain.o tests/t.*
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
@rm -f upb/descriptor/descriptor.pb
Enable more Travis configurations.
10 years ago
@rm -rf tools/upbc deps
@rm -rf upb/bindings/python/build
@rm -f upb/bindings/ruby/Makefile
Sync to Google-internal development.
10 years ago
@rm -f upb/bindings/ruby/upb.o
Enable more Travis configurations.
10 years ago
@rm -f upb/bindings/ruby/upb.so
@rm -f upb/bindings/ruby/mkmf.log
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
@rm -f tests/google_messages.pb.*
@rm -f tests/google_messages.proto.pb
@rm -f upb.c upb.h
Enable more Travis configurations.
10 years ago
@find . | grep dSYM | xargs rm -rf
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
clean: clean_leave_profile clean_lua
Enable more Travis configurations.
10 years ago
@rm -rf $(call rwildcard,,*.gcno) $(call rwildcard,,*.gcda)
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# A little bit of Make voodoo: you can call this from the deps of a patterned
# rule like so:
#
# all: lib/libfoo.bar.a
#
# foo_bar_SRCS = a.c b.c
#
# # This will expand into a.o b.o
# lib/lib%.a: $(call make_objs,o)
# gcc -c -o $@ $^
#
Sync to Google-internal development.
10 years ago
# SECONDEXPANSION: flips on a bit essentially that allows this "secondary
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# expansion": it must appear before anything that uses make_objs.
.SECONDEXPANSION:
to_srcs = $(subst .,_,$(1)_SRCS)
pc = %
Coverage support for coveralls.io.
10 years ago
make_objs = $$(patsubst upb/$$(pc).c,obj/upb/$$(pc).$(1),$$($$(call to_srcs,$$*)))
make_objs_cc = $$(patsubst upb/$$(pc).cc,obj/upb/$$(pc).$(1),$$($$(call to_srcs,$$*)))
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# Core libraries (ie. not bindings). ###############################################################
upb_SRCS = \
Directory restructure. Includes are now via upb/foo.h. Files specific to the protobuf format are now in upb/pb (the core library is concerned with message definitions, handlers, and byte streams, but knows nothing about any particular serializationf format).
14 years ago
upb/def.c \
Fixes for the open-source build.
10 years ago
upb/env.c \
Sync from internal Google development.
13 years ago
upb/handlers.c \
Sync with 8 months of Google-internal development. Many things have changed and been simplified. The memory-management story for upb_def and upb_handlers is much more robust; upb_def and upb_handlers should be fairly stable interfaces now. There is still much work to do for the runtime component (upb_sink).
12 years ago
upb/refcounted.c \
Synced with Google-internal development. C++ handlers are now type-safe; SinkFrame is gone. Various other changes.
12 years ago
upb/shim/shim.c \
Sync with 8 months of Google-internal development. Many things have changed and been simplified. The memory-management story for upb_def and upb_handlers is much more robust; upb_def and upb_handlers should be fairly stable interfaces now. There is still much work to do for the runtime component (upb_sink).
12 years ago
upb/symtab.c \
Sync from internal Google development.
13 years ago
upb/table.c \
upb/upb.c \
Sync from internal Google development. Many improvements, too many to mention. One significant perf regression warrants investigation: omitfp.parsetoproto2_googlemessage1.upb_jit: 343 -> 252 (-26.53) plain.parsetoproto2_googlemessage1.upb_jit: 334 -> 251 (-24.85) 25% regression for this benchmark is bad, but since I don't think there's any fundamental design issue that caused it I'm going to go ahead with the commit anyway. Can investigate and fix later. Other benchmarks were neutral or showed slight improvement.
13 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
upb_descriptor_SRCS = \
upb/descriptor/descriptor.upb.c \
Sync to Google-internal development.
10 years ago
upb/descriptor/reader.c \
Directory restructure. Includes are now via upb/foo.h. Files specific to the protobuf format are now in upb/pb (the core library is concerned with message definitions, handlers, and byte streams, but knows nothing about any particular serializationf format).
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
upb_pb_SRCS = \
Fixes to make the open-source build compile on Linux.
11 years ago
upb/pb/compile_decoder.c \
Sync to Google-internal development.
10 years ago
upb/pb/decoder.c \
upb/pb/encoder.c \
Directory restructure. Includes are now via upb/foo.h. Files specific to the protobuf format are now in upb/pb (the core library is concerned with message definitions, handlers, and byte streams, but knows nothing about any particular serializationf format).
14 years ago
upb/pb/glue.c \
Fixed build and added Travis CI support.
10 years ago
upb/pb/textprinter.c \
Sync to Google-internal development.
10 years ago
upb/pb/varint.c \
Open source fixes: builds on OS X again.
12 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# If the JIT is enabled we include its source.
# If Lua is present we can use DynASM to regenerate the .h file.
ifdef USE_JIT
upb_pb_SRCS += upb/pb/compile_decoder_x64.c
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
# The JIT can't compile with -Wpedantic, since it does some inherently
# platform-specific things like casting between data pointers and function
# pointers. Also DynASM emits some GNU extensions.
obj/upb/pb/compile_decoder_x64.o : CSTD = -std=gnu89
obj/upb/pb/compile_decoder_x64.lo : CSTD = -std=gnu89
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
upb/pb/compile_decoder_x64.h: upb/pb/compile_decoder_x64.dasc
$(E) DYNASM $<
Moved DynASM to third_party to comply with Google policy.
10 years ago
$(Q) $(LUA) third_party/dynasm/dynasm.lua -c upb/pb/compile_decoder_x64.dasc > upb/pb/compile_decoder_x64.h || (rm upb/pb/compile_decoder_x64.h ; false)
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
endif
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
upb_json_SRCS = \
Sync from Google-internal development. Most notably, a JSON parser is now provided.
10 years ago
upb/json/parser.c \
JSON printer: remove dependency on YAJL, using a hand-rolled printer instead.
10 years ago
upb/json/printer.c \
Sync from Google-internal development. Most notably, a JSON parser is now provided.
10 years ago
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
# Ideally we could keep this uncommented, but Git apparently sometimes skews
# timestamps slightly at "clone" time, which makes "Make" think that it needs
# to rebuild upb/json/parser.c when it actually doesn't. This would be harmless
# except that the user might not have Ragel installed.
#
# So instead we require an excplicit "make ragel" to rebuild this (for now).
# More pain for people developing upb/json/parser.rl, but less pain for everyone
# else.
#
# upb/json/parser.c: upb/json/parser.rl
# $(E) RAGEL $<
# $(Q) ragel -C -o upb/json/parser.c upb/json/parser.rl
ragel:
$(E) RAGEL upb/json/parser.rl
Sync from Google-internal development. Most notably, a JSON parser is now provided.
10 years ago
$(Q) ragel -C -o upb/json/parser.c upb/json/parser.rl
Use FDO for benchmarks, which gives a 10-15% improvement.
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# If the user doesn't specify an -O setting, we use -O3 for critical-path
# code and -Os for the rest.
Added lua and core32 Travis builds, and rewrote README.md
10 years ago
ifeq (, $(findstring -O, $(USER_CPPFLAGS)))
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
OPT = -O3
lib/libupb.a : OPT = -Os
lib/libupb.descriptor.a : OPT = -Os
Coverage support for coveralls.io.
10 years ago
obj/upb/pb/compile_decoder.o : OPT = -Os
obj/upb/pb/compile_decoder_64.o : OPT = -Os
Sync to Google-internal development.
10 years ago
ifdef USE_JIT
Coverage support for coveralls.io.
10 years ago
obj/upb/pb/compile_decoder_x64.o: OPT=-Os
Sync to Google-internal development.
10 years ago
endif
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
endif
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
$(UPB_PICLIBS): lib/lib%_pic.a: $(call make_objs,lo)
$(E) AR $@
Parameterize AR properly in the Makefile.
10 years ago
$(Q) mkdir -p lib && $(AR) rcs $@ $^
Don't require NASM to build unless using the x64 decoder.
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
$(UPB_LIBS): lib/lib%.a: $(call make_objs,o)
$(E) AR $@
Parameterize AR properly in the Makefile.
10 years ago
$(Q) mkdir -p lib && $(AR) rcs $@ $^
Sync from internal Google development. Many improvements, too many to mention. One significant perf regression warrants investigation: omitfp.parsetoproto2_googlemessage1.upb_jit: 343 -> 252 (-26.53) plain.parsetoproto2_googlemessage1.upb_jit: 334 -> 251 (-24.85) 25% regression for this benchmark is bad, but since I don't think there's any fundamental design issue that caused it I'm going to go ahead with the commit anyway. Can investigate and fix later. Other benchmarks were neutral or showed slight improvement.
13 years ago
Don't require NASM to build unless using the x64 decoder.
14 years ago
Coverage support for coveralls.io.
10 years ago
obj/upb/%.o: upb/%.c | $$(@D)/.
Support "make Q=" to view full commands.
14 years ago
$(E) CC $<
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CC) $(OPT) $(CSTD) $(WARNFLAGS) $(CPPFLAGS) $(CFLAGS) -c -o $@ $<
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Coverage support for coveralls.io.
10 years ago
obj/upb/%.o: upb/%.cc | $$(@D)/.
Sync from internal Google development. Many improvements, too many to mention. One significant perf regression warrants investigation: omitfp.parsetoproto2_googlemessage1.upb_jit: 343 -> 252 (-26.53) plain.parsetoproto2_googlemessage1.upb_jit: 334 -> 251 (-24.85) 25% regression for this benchmark is bad, but since I don't think there's any fundamental design issue that caused it I'm going to go ahead with the commit anyway. Can investigate and fix later. Other benchmarks were neutral or showed slight improvement.
13 years ago
$(E) CXX $<
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CXX) $(OPT) $(CXXSTD) $(WARNFLAGS_CXX) $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $<
Sync from internal Google development. Many improvements, too many to mention. One significant perf regression warrants investigation: omitfp.parsetoproto2_googlemessage1.upb_jit: 343 -> 252 (-26.53) plain.parsetoproto2_googlemessage1.upb_jit: 334 -> 251 (-24.85) 25% regression for this benchmark is bad, but since I don't think there's any fundamental design issue that caused it I'm going to go ahead with the commit anyway. Can investigate and fix later. Other benchmarks were neutral or showed slight improvement.
13 years ago
Coverage support for coveralls.io.
10 years ago
obj/upb/%.lo: upb/%.c | $$(@D)/.
Support "make Q=" to view full commands.
14 years ago
$(E) 'CC -fPIC' $<
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CC) $(OPT) $(CSTD) $(WARNFLAGS) $(CPPFLAGS) $(CFLAGS) -c -o $@ $< -fPIC
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Coverage support for coveralls.io.
10 years ago
obj/upb/%.lo: upb/%.cc | $$(@D)/.
Enable Travis for Clang, and enable -Werror for all Travis builds. Also added an extra Clang-only warning flag.
10 years ago
$(E) CXX -fPIC $<
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CXX) $(OPT) $(CXXSTD) $(WARNFLAGS_CXX) $(CPPFLAGS) $(CXXFLAGS) -c -o $@ $< -fPIC
Sync from internal Google development. Many improvements, too many to mention. One significant perf regression warrants investigation: omitfp.parsetoproto2_googlemessage1.upb_jit: 343 -> 252 (-26.53) plain.parsetoproto2_googlemessage1.upb_jit: 334 -> 251 (-24.85) 25% regression for this benchmark is bad, but since I don't think there's any fundamental design issue that caused it I'm going to go ahead with the commit anyway. Can investigate and fix later. Other benchmarks were neutral or showed slight improvement.
13 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# Note: mkdir -p is technically susceptible to races when used with make -j.
%/.:
$(Q) mkdir -p $@
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Directory restructure. Includes are now via upb/foo.h. Files specific to the protobuf format are now in upb/pb (the core library is concerned with message definitions, handlers, and byte streams, but knows nothing about any particular serializationf format).
14 years ago
# Regenerating the auto-generated files in upb/.
Sync to Google-internal development.
10 years ago
upb/descriptor/descriptor.pb: upb/descriptor/descriptor.proto
Support "make Q=" to view full commands.
14 years ago
@# TODO: replace with upbc
Sync to Google-internal development.
10 years ago
protoc upb/descriptor/descriptor.proto -oupb/descriptor/descriptor.pb
Refactoring: unify upb_msg. The cost is that a upb_msg will now always have an overhead of 2*sizeof(void*). This is comparable to proto2 overhead. The benefit is that upb_msg is now self-describing, and read-only algorithms can now operate on a upb_msg regardless of the memory-management scheme. Also, upb_array and upb_string now know inherently if they own their associated memory, and upb_array has a generic pointer for memory management purposes like upb_msg does.
16 years ago
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
genfiles: upb/descriptor/descriptor.pb tools/upbc
./tools/upbc upb/descriptor/descriptor.pb upb/descriptor/descriptor google_protobuf_descriptor
Moved DynASM to third_party to comply with Google policy.
10 years ago
$(LUA) third_party/dynasm/dynasm.lua -c upb/pb/compile_decoder_x64.dasc > upb/pb/compile_decoder_x64.h || (rm upb/pb/compile_decoder_x64.h ; false)
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
# upbc depends on these Lua extensions.
UPBC_LUA_EXTS = \
upb/bindings/lua/upb_c.so \
upb/bindings/lua/upb/pb_c.so \
upb/bindings/lua/upb/table_c.so \
tools/upbc: $(UPBC_LUA_EXTS) Makefile
$(E) ECHO tools/upbc
$(Q) echo "#!/bin/sh" > tools/upbc
$(Q) echo 'BASE=`dirname "$$0"`' >> tools/upbc
$(Q) echo 'export LUA_CPATH="$$BASE/../upb/bindings/lua/?.so"' >> tools/upbc
$(Q) echo 'export LUA_PATH="$$BASE/?.lua;$$BASE/../upb/bindings/lua/?.lua"' >> tools/upbc
$(Q) echo 'lua $$BASE/upbc.lua "$$@"' >> tools/upbc
$(Q) chmod a+x tools/upbc
Added an example, constified some more methods.
13 years ago
examples/msg: examples/msg.c $(LIBUPB)
$(E) CC $<
$(Q) $(CC) $(CFLAGS) $(CPPFLAGS) -o $@ $< $(LIBUPB)
Moved upbc -> src/
14 years ago
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
# Tests. #######################################################################
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# This section contains only the tests that don't depend on any external
# libraries.
Add a test for circularly-linked descriptors. The test currently triggers valgrind-detected memory errors.
15 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
C_TESTS = \
Sync to internal Google development.
11 years ago
tests/pb/test_varint \
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
tests/test_def \
tests/test_handlers \
Decoder redesign in preparation for packed fields and start/endseq.
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
CC_TESTS = \
Beginnings of a prototype Ruby extension.
10 years ago
tests/pb/test_decoder \
Fixed some bad bugs in upb_env. Also added a unit test for upb_encoder that demonstrates the bugs and the fix.
10 years ago
tests/pb/test_encoder \
JSON test, symbolic enum names in JSON, and a few improvements. - Added a JSON test that round-trips (parses then re-serializes) several test messages, ensuring that the re-serialized form matches the original exactly. - Added support for printing and parsing symbolic enum names (rather than integer values) in JSON. - Updated JSON printer to properly handle string fields that come in multiple pieces. ('bytes' fields still do not support this, and this work is more challenging because it requires making the base64 encoder resumable. Base64 encoding is not separable at an input-byte granularity, unlike string escaping.) - Fixed a < vs. <= bug in UTF-8 encoding generation (oops).
10 years ago
tests/json/test_json \
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
tests/test_cpp \
tests/test_table \
All tests pass again, valgrind-clean! Next up: benchmarks.
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
TESTS=$(C_TESTS) $(CC_TESTS)
tests: $(TESTS)
Unit test comparing parsed results with proto2.
15 years ago
Sync with 8 months of Google-internal development. Many things have changed and been simplified. The memory-management story for upb_def and upb_handlers is much more robust; upb_def and upb_handlers should be fairly stable interfaces now. There is still much work to do for the runtime component (upb_sink).
12 years ago
tests/testmain.o: tests/testmain.cc
$(E) CXX $<
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CXX) $(OPT) $(CXXSTD) $(WARNFLAGS_CXX) $(CXXFLAGS) $(CPPFLAGS) -c -o $@ $<
Sync with 8 months of Google-internal development. Many things have changed and been simplified. The memory-management story for upb_def and upb_handlers is much more robust; upb_def and upb_handlers should be fairly stable interfaces now. There is still much work to do for the runtime component (upb_sink).
12 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
$(C_TESTS): % : %.c tests/testmain.o $$(LIBS)
Support "make Q=" to view full commands.
14 years ago
$(E) CC $<
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CC) $(OPT) $(CSTD) $(WARNFLAGS) $(CPPFLAGS) $(CFLAGS) -o $@ tests/testmain.o $< $(LIBS)
Sync with 8 months of Google-internal development. Many things have changed and been simplified. The memory-management story for upb_def and upb_handlers is much more robust; upb_def and upb_handlers should be fairly stable interfaces now. There is still much work to do for the runtime component (upb_sink).
12 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
$(CC_TESTS): % : %.cc tests/testmain.o $$(LIBS)
Sync with 8 months of Google-internal development. Many things have changed and been simplified. The memory-management story for upb_def and upb_handlers is much more robust; upb_def and upb_handlers should be fairly stable interfaces now. There is still much work to do for the runtime component (upb_sink).
12 years ago
$(E) CXX $<
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CXX) $(OPT) $(CXXSTD) $(WARNFLAGS_CXX) $(CPPFLAGS) $(CXXFLAGS) -Wno-deprecated -o $@ tests/testmain.o $< $(LIBS)
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# Several of these tests don't actually test these libs, but use them
# incidentally to load a descriptor
LOAD_DESCRIPTOR_LIBS = lib/libupb.pb.a lib/libupb.descriptor.a
# Specify which libs each test depends on.
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
tests/pb/test_varint: LIBS = lib/libupb.pb.a lib/libupb.a $(EXTRA_LIBS)
tests/test_def: LIBS = $(LOAD_DESCRIPTOR_LIBS) lib/libupb.a $(EXTRA_LIBS)
tests/test_handlers: LIBS = lib/libupb.descriptor.a lib/libupb.a $(EXTRA_LIBS)
tests/pb/test_decoder: LIBS = lib/libupb.pb.a lib/libupb.a $(EXTRA_LIBS)
Fixed some bad bugs in upb_env. Also added a unit test for upb_encoder that demonstrates the bugs and the fix.
10 years ago
tests/pb/test_encoder: LIBS = lib/libupb.pb.a lib/libupb.descriptor.a lib/libupb.a $(EXTRA_LIBS)
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
tests/test_cpp: LIBS = $(LOAD_DESCRIPTOR_LIBS) lib/libupb.a $(EXTRA_LIBS)
tests/test_table: LIBS = lib/libupb.a $(EXTRA_LIBS)
tests/json/test_json: LIBS = lib/libupb.a lib/libupb.json.a $(EXTRA_LIBS)
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
tests/test.proto.pb: tests/test.proto
@# TODO: add .proto file parser to upb so this isn't necessary.
protoc tests/test.proto -otests/test.proto.pb
VARIADIC_TESTS= \
tests/t.test_vs_proto2.googlemessage1 \
tests/t.test_vs_proto2.googlemessage2 \
ifeq ($(RUN_UNDER), valgrind)
RUN_UNDER=valgrind --leak-check=full --error-exitcode=1 --track-origins=yes
endif
Support "make Q=" to view full commands.
14 years ago
Enable more Travis configurations.
10 years ago
test:
Basic test_def links and passes no-op test!
15 years ago
@set -e # Abort on error.
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
@find tests -perm -u+x -type f | while read test; do \
Fixed the open-source build.
13 years ago
if [ -x ./$$test ] ; then \
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
echo "RUN $$test"; \
$(RUN_UNDER) ./$$test tests/test.proto.pb || exit 1; \
Fixed the open-source build.
13 years ago
fi \
done;
@echo "All tests passed!"
Unit test comparing parsed results with proto2.
15 years ago
Tests use valgrind, chdir in test.
15 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
# Google protobuf binding ######################################################
Makefile is much improved ("make deps" works again, etc).
16 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
upb_bindings_googlepb_SRCS = \
upb/bindings/googlepb/bridge.cc \
upb/bindings/googlepb/proto2.cc \
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
GOOGLEPB_TESTS = \
tests/bindings/googlepb/test_vs_proto2.googlemessage1 \
tests/bindings/googlepb/test_vs_proto2.googlemessage2 \
Makefile is much improved ("make deps" works again, etc).
16 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
GOOGLEPB_LIB=lib/libupb.bindings.googlepb.a
Benchmark JIT vs no JIT without forcing a whole-project recompile.
13 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
.PHONY: googlepb clean_googlepb googlepbtest
Enable more Travis configurations.
10 years ago
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
clean: clean_googlepb
clean_googlepb:
Enable more Travis configurations.
10 years ago
@rm -f tests/bindings/googlepb/test_vs_proto2.googlemessage*
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
@rm -f tests/googlemessage?.h
Enable more Travis configurations.
10 years ago
@rm -f $(GOOGLEPB_LIB)
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
googlepb: default $(GOOGLEPB_LIB)
Enable more Travis configurations.
10 years ago
googlepbtests: googlepb $(GOOGLEPB_TESTS)
More work on benchmarks (performance tests).
16 years ago
Coverage support for coveralls.io.
10 years ago
lib/libupb.bindings.googlepb.a: $(upb_bindings_googlepb_SRCS:upb/%.cc=obj/upb/%.o)
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
$(E) AR $@
Parameterize AR properly in the Makefile.
10 years ago
$(Q) mkdir -p lib && $(AR) rcs $@ $^
Integrated benchmarks into main Makefile.
16 years ago
Enable more Travis configurations.
10 years ago
# Generate C++ with Google's protobuf compiler, to test and benchmark against.
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
tests/google_messages.proto.pb: tests/google_messages.proto
Cleanup Makefile and mv descriptor/ -> src/
14 years ago
@# TODO: replace with upbc.
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
protoc tests/google_messages.proto -otests/google_messages.proto.pb
tests/google_messages.pb.cc: tests/google_messages.proto
protoc tests/google_messages.proto --cpp_out=.
Integrated benchmarks into main Makefile.
16 years ago
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
tests/google_message1.h:
$(E) XXD tests/google_message1.dat
$(Q) xxd -i < tests/google_message1.dat > tests/google_message1.h
Enable more Travis configurations.
10 years ago
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
tests/google_message2.h:
$(E) XXD tests/google_message2.dat
$(Q) xxd -i < tests/google_message2.dat > tests/google_message2.h
Enable more Travis configurations.
10 years ago
GOOGLEPB_TEST_LIBS = \
lib/libupb.bindings.googlepb.a \
lib/libupb.pb.a \
lib/libupb.descriptor.a \
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
lib/libupb.a \
$(EXTRA_LIBS)
Enable more Travis configurations.
10 years ago
GOOGLEPB_TEST_DEPS = \
tests/bindings/googlepb/test_vs_proto2.cc \
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
tests/google_messages.proto.pb \
tests/google_messages.pb.cc \
Enable more Travis configurations.
10 years ago
tests/testmain.o \
$(GOOGLEPB_TEST_LIBS)
tests/bindings/googlepb/test_vs_proto2.googlemessage1: $(GOOGLEPB_TEST_DEPS) \
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
tests/google_message1.h \
tests/google_message2.h
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
$(E) CXX $< '(benchmarks::SpeedMessage1)'
Enable Travis for Clang, and enable -Werror for all Travis builds. Also added an extra Clang-only warning flag.
10 years ago
$(Q) $(CXX) $(OPT) $(WARNFLAGS_CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $< \
Benchmark to parse into proto2 messages.
13 years ago
-DMESSAGE_CIDENT="benchmarks::SpeedMessage1" \
Fixed building of googlepbtests.
10 years ago
-DMESSAGE_DATA_IDENT=message1_data \
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
tests/google_messages.pb.cc tests/testmain.o -lprotobuf -lpthread \
Enable more Travis configurations.
10 years ago
$(GOOGLEPB_TEST_LIBS)
Benchmark JIT vs no JIT without forcing a whole-project recompile.
13 years ago
Enable more Travis configurations.
10 years ago
tests/bindings/googlepb/test_vs_proto2.googlemessage2: $(GOOGLEPB_TEST_DEPS) \
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
tests/google_message1.h \
tests/google_message2.h
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
$(E) CXX $< '(benchmarks::SpeedMessage2)'
Enable Travis for Clang, and enable -Werror for all Travis builds. Also added an extra Clang-only warning flag.
10 years ago
$(Q) $(CXX) $(OPT) $(WARNFLAGS_CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $< \
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
-DMESSAGE_CIDENT="benchmarks::SpeedMessage2" \
Fixed building of googlepbtests.
10 years ago
-DMESSAGE_DATA_IDENT=message2_data \
Removed obsolete benchmarks/ and examples/ directories.
10 years ago
tests/google_messages.pb.cc tests/testmain.o -lprotobuf -lpthread \
Enable more Travis configurations.
10 years ago
$(GOOGLEPB_TEST_LIBS)
Benchmark to parse into proto2 messages.
13 years ago
Revive Lua extension. It builds and you can inspect a symtab. Still need to expose streaming and message based interfaces.
14 years ago
# Lua extension ##################################################################
ifeq ($(shell uname), Darwin)
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
LUA_LDFLAGS = -undefined dynamic_lookup -flat_namespace
Revive Lua extension. It builds and you can inspect a symtab. Still need to expose streaming and message based interfaces.
14 years ago
else
Fix building of Lua extension on OS X.
14 years ago
LUA_LDFLAGS =
Revive Lua extension. It builds and you can inspect a symtab. Still need to expose streaming and message based interfaces.
14 years ago
endif
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
LUAEXTS = \
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
upb/bindings/lua/upb_c.so \
upb/bindings/lua/upb/pb_c.so \
Added lua and core32 Travis builds, and rewrote README.md
10 years ago
LUATESTS = \
tests/bindings/lua/test_upb.lua \
tests/bindings/lua/test_upb.pb.lua \
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
.PHONY: clean_lua testlua lua
Enable more Travis configurations.
10 years ago
Added lua and core32 Travis builds, and rewrote README.md
10 years ago
testlua: lua
@set -e # Abort on error.
@for test in $(LUATESTS) ; do \
echo LUA $$test; \
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
LUA_PATH="tests/bindings/lua/lunit/?.lua;upb/bindings/lua/?.lua" \
Added lua and core32 Travis builds, and rewrote README.md
10 years ago
LUA_CPATH=upb/bindings/lua/?.so \
lua $$test; \
done
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
Enable more Travis configurations.
10 years ago
clean: clean_lua
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
clean_lua:
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
@rm -f upb/bindings/lua/upb_c.so
@rm -f upb/bindings/lua/upb/pb_c.so
@rm -f upb/bindings/lua/upb/table_c.so
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
lua: $(LUAEXTS)
Added lua and core32 Travis builds, and rewrote README.md
10 years ago
# Right now the core upb module depends on all of these.
# It's a TODO to factor this more cleanly in the code.
LUA_LIB_DEPS = \
lib/libupb.pb_pic.a \
lib/libupb.descriptor_pic.a \
lib/libupb_pic.a \
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
upb/bindings/lua/upb_c.so: upb/bindings/lua/upb.c $(LUA_LIB_DEPS)
Added lua and core32 Travis builds, and rewrote README.md
10 years ago
$(E) CC upb/bindings/lua/upb.c
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CC) $(OPT) $(CSTD) $(WARNFLAGS) $(CPPFLAGS) $(CFLAGS) -fpic -shared -o $@ $< $(LUA_LDFLAGS) $(LUA_LIB_DEPS)
Added lua and core32 Travis builds, and rewrote README.md
10 years ago
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
upb/bindings/lua/upb/table_c.so: upb/bindings/lua/upb/table.c lib/libupb_pic.a
$(E) CC upb/bindings/lua/upb/table.c
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CC) $(OPT) $(CSTD) $(WARNFLAGS) $(CPPFLAGS) $(CFLAGS) -fpic -shared -o $@ $< $(LUA_LDFLAGS)
Changes to Lua module loading, and file generation. This change has several parts: 1. Resurrected tools/upbc. The code was all there but the build was broken for open-source. Now you can type "make tools/upbc" and it will build all necessary Lua modules and create a robust shell script for running upbc. 2. Changed Lua module loading to no longer rely on OS-level .so dependencies. The net effect of this is that you now only need to set LUA_PATH and LUA_CPATH; setting LD_LIBRARY_PATH or rpaths is no longer required. Downside: this drops compatibility with Lua 5.1, since it depends on a feature that only exists in Lua >=5.2 (and LuaJIT). 3. Since upbc works again, I fixed the re-generation of the descriptor files (descriptor.upb.h, descriptor.upb.c). "make genfiles" will re-generate these as well as the JIT code generator. 4. Added a Travis test target that ensures that the checked-in generated files are not out of date. I would do this for the Ragel generated file also, but we can't count on all versions of Ragel to necessarily generate identical output. 5. Changed Makefile to no longer automatically run Ragel to regenerate the JSON parser. This is unfortuante, because it's convenient when you're developing the JSON parser. However, "git clone" sometimes skews the timestamps a little bit so that "make" thinks it needs to regenerate these files for a fresh "git clone." This would normally be harmless, but if the user doesn't have Ragel installed, it makes the build fail completely. So now you have to explicitly regenerate the Ragel output. If you want to you can uncomment the auto-generation during development.
10 years ago
upb/bindings/lua/upb/pb_c.so: upb/bindings/lua/upb/pb.c $(LUA_LIB_DEPS)
$(E) CC upb/bindings/lua/upb/pb.c
Ported upb to C89, for greater portability. A large part of this change contains surface-level porting, like moving variable declarations to the top of the block. However there are a few more substantial things too: - moved internal-only struct definitions to a separate file (structdefs.int.h), for greater encapsulation and ABI compatibility. - removed the UPB_UPCAST macro, since it requires access to the internal-only struct definitions. Replaced uses with calls to inline, type-safe casting functions. - removed the UPB_DEFINE_CLASS/UPB_DEFINE_STRUCT macros. Class and struct definitions are now more explicit -- you get to see the actual class/struct keywords in the source. The casting convenience functions have been moved into UPB_DECLARE_DERIVED_TYPE() and UPB_DECLARE_DERIVED_TYPE2(). - the new way that we duplicate base methods in derived types is also more convenient and requires less duplication. It is also less greppable, but hopefully that is not too big a problem. Compiler flags (-std=c89 -pedantic) should help to rigorously enforce that the code is free of C99-isms. A few functions are not available in C89 (strtoll). There are temporary, hacky solutions in place.
10 years ago
$(Q) $(CC) $(OPT) $(CSTD) $(WARNFLAGS) $(CPPFLAGS) $(CFLAGS) -fpic -shared -o $@ $< $(LUA_LDFLAGS)
Makefile target for running Python tests.
14 years ago
# Python extension #############################################################
Fixed overzealous assert().
13 years ago
PYTHON=python
Renamed lang_ext -> bindings, README updates.
13 years ago
PYTHONEXT=bindings/python/build/install/lib/python/upb/__init__.so
Makefile target for running Python tests.
14 years ago
python: $(PYTHONEXT)
Renamed lang_ext -> bindings, README updates.
13 years ago
$(PYTHONEXT): $(LIBUPB_PIC) bindings/python/upb.c
$(E) PYTHON bindings/python/upb.c
$(Q) cd bindings/python && $(PYTHON) setup.py build --debug install --home=build/install
Makefile target for running Python tests.
14 years ago
pythontest: $(PYTHONEXT)
Renamed lang_ext -> bindings, README updates.
13 years ago
cd bindings/python && cp test.py build/install/lib/python && valgrind $(PYTHON) ./build/install/lib/python/test.py
Beginnings of a prototype Ruby extension.
10 years ago
# Ruby extension ###############################################################
RUBY=ruby
RUBYEXT=upb/bindings/ruby/upb.so
ruby: $(RUBYEXT)
Sync to Google-internal development.
10 years ago
# We pass our important flags to Ruby, but leave the warning flags out.
# Some uses of the Ruby/C API trigger the warnings we normally use, so
# we let Ruby decide the set of warning options to use.
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
upb/bindings/ruby/Makefile: upb/bindings/ruby/extconf.rb lib/libupb_pic.a lib/libupb.pb_pic.a lib/libupb.descriptor_pic.a
Beginnings of a prototype Ruby extension.
10 years ago
$(E) RUBY upb/bindings/ruby/extconf.rb
Sync to Google-internal development.
10 years ago
$(Q) cd upb/bindings/ruby && ruby extconf.rb "$(OPT) $(CPPFLAGS) $(CFLAGS)"
Rewrite of build system. Notable changes: - We now only build things by default that require no dependencies. So you can build upb even if you don't have Lua or Google protobuf installed. - Checked in a pre-built version of the JIT, so you don't need Lua installed at build time to run DynASM. It will still notice if you change the .dasc file and attempt to re-run DynASM in that case. - The build system now builds all modules of upb into separate libraries, reflecting the modularity that is already inherent in upb's design. This should make it easier to trim the fat. - removed the GDB JIT interface. I wasn't using it much; using a .so is easier and more robust.
10 years ago
$(RUBYEXT): upb/bindings/ruby/upb.c upb/bindings/ruby/Makefile
Beginnings of a prototype Ruby extension.
10 years ago
$(E) CC upb/bindings/ruby/upb.c
$(Q) cd upb/bindings/ruby && make
Sync to Google-internal development.
10 years ago
rubytest: $(RUBYEXT) upb/descriptor/descriptor.pb
RUBYLIB="upb/bindings/ruby" ruby tests/bindings/ruby/upb.rb
Amalgamated distribution (upb.c/upb.h) tool. There are a number of tweaks to get this to work: - The #include dependence graph wasn't quite complete, and I had to add a few #includes to get the tool to work. - I had to change a number of symbol names to avoid conflicts between 'static' definitions in different .c files. This could be avoided if the tool were smart enough to rename static symbols to have unique prefixes instead, but (i) this requires semantic understanding of C, and (ii) the macro-defined static functions (e.g., handlers for primitive types in several places) would probably trip this up. Verified that the resulting upb.h/upb.c compiles and doesn't have any unresolved references.
10 years ago
# Amalgamated source (upb.c/upb.h) ############################################
AMALGAMATE_SRCS=$(upb_SRCS) $(upb_descriptor_SRCS) $(upb_pb_SRCS) $(upb_json_SRCS)
amalgamate: upb.c upb.h
upb.c upb.h: $(AMALGAMATE_SRCS)
$(E) AMALGAMATE $@
$(Q) ./tools/amalgamate.py "" "" $^