Fixed missing files in Xcode project.

Change-Id: I3480de9157fd6d0eeb123e77e448bd57c75c74ad
Tested: on OS X

.gitignore

@@ -35,3 +35,6 @@ flatsampletext
 snapshot.sh
 tests/go_gen
 CMakeLists.txt.user
+CMakeScripts/**
+build/Xcode/FlatBuffers.xcodeproj/project.xcworkspace/**
+build/Xcode/FlatBuffers.xcodeproj/xcuserdata/**

CMakeLists.txt

@@ -4,6 +4,8 @@ project(FlatBuffers)
 
 # NOTE: Code coverage only works on Linux & OSX.
 option(FLATBUFFERS_CODE_COVERAGE "Enable the code coverage build option." OFF)
+option(FLATBUFFERS_BUILD_TESTS "Enable the build of tests and samples." ON)
+option(FLATBUFFERS_INSTALL "Enable the installation of targets." ON)
 
 set(FlatBuffers_Compiler_SRCS
   include/flatbuffers/flatbuffers.h
@@ -11,9 +13,10 @@ set(FlatBuffers_Compiler_SRCS
   include/flatbuffers/util.h
   src/idl_parser.cpp
   src/idl_gen_cpp.cpp
-  src/idl_gen_java.cpp
+  src/idl_gen_general.cpp
   src/idl_gen_go.cpp
   src/idl_gen_text.cpp
+  src/idl_gen_fbs.cpp
   src/flatc.cpp
 )
 
@@ -23,16 +26,17 @@ set(FlatBuffers_Tests_SRCS
   include/flatbuffers/util.h
   src/idl_parser.cpp
   src/idl_gen_text.cpp
+  src/idl_gen_fbs.cpp
   tests/test.cpp
   # file generate by running compiler on tests/monster_test.fbs
-  tests/monster_test_generated.h
+  ${CMAKE_CURRENT_BINARY_DIR}/tests/monster_test_generated.h
 )
 
 set(FlatBuffers_Sample_Binary_SRCS
   include/flatbuffers/flatbuffers.h
   samples/sample_binary.cpp
-  # file generate by running compiler on samples/monster.fbs
-  samples/monster_generated.h
+  # file generated by running compiler on samples/monster.fbs
+  ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 )
 
 set(FlatBuffers_Sample_Text_SRCS
@@ -42,23 +46,21 @@ set(FlatBuffers_Sample_Text_SRCS
   src/idl_parser.cpp
   src/idl_gen_text.cpp
   samples/sample_text.cpp
-  # file generate by running compiler on samples/monster.fbs
-  samples/monster_generated.h
+  # file generated by running compiler on samples/monster.fbs
+  ${CMAKE_CURRENT_BINARY_DIR}/samples/monster_generated.h
 )
 
-set(CMAKE_BUILD_TYPE Debug)
-
 # source_group(Compiler FILES ${FlatBuffers_Compiler_SRCS})
 # source_group(Tests FILES ${FlatBuffers_Tests_SRCS})
 
 if(APPLE)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++")
+  set(CMAKE_CXX_FLAGS
+    "${CMAKE_CXX_FLAGS} -std=c++11 -stdlib=libc++ -Wall -pedantic -Werror -Wextra")
 elseif(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")
+  set(CMAKE_CXX_FLAGS
+    "${CMAKE_CXX_FLAGS} -std=c++0x -Wall -pedantic -Werror -Wextra")
 endif()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Werror -Wextra")
-
 if(FLATBUFFERS_CODE_COVERAGE)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fprofile-arcs -ftest-coverage")
   set(CMAKE_EXE_LINKER_FLAGS
@@ -68,14 +70,36 @@ endif()
 include_directories(include)
 
 add_executable(flatc ${FlatBuffers_Compiler_SRCS})
-add_executable(flattests ${FlatBuffers_Tests_SRCS})
-add_executable(flatsamplebinary ${FlatBuffers_Sample_Binary_SRCS})
-add_executable(flatsampletext ${FlatBuffers_Sample_Text_SRCS})
 
-install(DIRECTORY include/flatbuffers DESTINATION include)
-install(TARGETS flatc DESTINATION bin)
+function(compile_flatbuffers_schema_to_cpp SRC_FBS)
+  get_filename_component(SRC_FBS_DIR ${SRC_FBS} DIRECTORY)
+  string(REGEX REPLACE "\\.fbs$" "_generated.h" GEN_HEADER ${SRC_FBS})
+  add_custom_command(
+    OUTPUT ${GEN_HEADER}
+    COMMAND flatc -c -o "${SRC_FBS_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FBS}"
+    DEPENDS flatc)
+endfunction()
 
-add_test(NAME flattest
-         CONFIGURATIONS Debug
-         WORKING_DIRECTORY tests
-         COMMAND flattests)
+if(FLATBUFFERS_BUILD_TESTS)
+  compile_flatbuffers_schema_to_cpp(tests/monster_test.fbs)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/tests)
+  add_executable(flattests ${FlatBuffers_Tests_SRCS})
+
+  compile_flatbuffers_schema_to_cpp(samples/monster.fbs)
+  include_directories(${CMAKE_CURRENT_BINARY_DIR}/samples)
+  add_executable(flatsamplebinary ${FlatBuffers_Sample_Binary_SRCS})
+  add_executable(flatsampletext ${FlatBuffers_Sample_Text_SRCS})
+endif()
+
+if(FLATBUFFERS_INSTALL)
+  install(DIRECTORY include/flatbuffers DESTINATION include)
+  install(TARGETS flatc DESTINATION bin)
+endif()
+
+if(FLATBUFFERS_BUILD_TESTS)
+  enable_testing()
+
+  file(COPY "${CMAKE_CURRENT_SOURCE_DIR}/tests" DESTINATION
+       "${CMAKE_CURRENT_BINARY_DIR}")
+  add_test(NAME flattests COMMAND flattests)
+endif()

build/VS2010/flatc.vcxproj

@@ -266,12 +266,13 @@
     <ClInclude Include="..\..\include\flatbuffers\flatbuffers.h" />
     <ClInclude Include="..\..\include\flatbuffers\idl.h" />
     <ClInclude Include="..\..\include\flatbuffers\util.h" />
+    <ClCompile Include="..\..\src\idl_gen_fbs.cpp" />
+    <ClCompile Include="..\..\src\idl_gen_general.cpp" />
     <ClCompile Include="..\..\src\idl_gen_go.cpp">
       <WarningLevel Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Level4</WarningLevel>
     </ClCompile>
     <ClCompile Include="..\..\src\idl_parser.cpp" />
     <ClCompile Include="..\..\src\idl_gen_cpp.cpp" />
-    <ClCompile Include="..\..\src\idl_gen_java.cpp" />
     <ClCompile Include="..\..\src\idl_gen_text.cpp" />
     <ClCompile Include="..\..\src\flatc.cpp" />
   </ItemGroup>

build/VS2010/flatc.vcxproj.user

@@ -3,15 +3,15 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <LocalDebuggerWorkingDirectory>..\..\tests</LocalDebuggerWorkingDirectory>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
-    <LocalDebuggerCommandArguments>-j -c -g -b -t monster_test.fbs monsterdata_test.golden</LocalDebuggerCommandArguments>
+    <LocalDebuggerCommandArguments>-j -c -n -g -b -t monster_test.fbs monsterdata_test.golden</LocalDebuggerCommandArguments>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LocalDebuggerWorkingDirectory>..\..</LocalDebuggerWorkingDirectory>
     <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>
-    <LocalDebuggerCommandArguments>-j -c -g -b -t monster_test.fbs monsterdata_test.golden</LocalDebuggerCommandArguments>
+    <LocalDebuggerCommandArguments>-j -c -n -g -b -t monster_test.fbs monsterdata_test.golden</LocalDebuggerCommandArguments>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LocalDebuggerCommandArguments>-j -c -g -b -t monster_test.fbs monsterdata_test.golden</LocalDebuggerCommandArguments>
+    <LocalDebuggerCommandArguments>-j -c -g -n -b -t monster_test.fbs monsterdata_test.golden</LocalDebuggerCommandArguments>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LocalDebuggerWorkingDirectory>..\..\tests</LocalDebuggerWorkingDirectory>

build/VS2010/flattests.vcxproj

@@ -267,6 +267,7 @@
     <ClInclude Include="..\..\include\flatbuffers\idl.h" />
     <ClInclude Include="..\..\include\flatbuffers\util.h" />
     <ClInclude Include="..\..\tests\monster_test_generated.h" />
+    <ClCompile Include="..\..\src\idl_gen_fbs.cpp" />
     <ClCompile Include="..\..\src\idl_parser.cpp" />
     <ClCompile Include="..\..\src\idl_gen_text.cpp" />
     <ClCompile Include="..\..\tests\test.cpp" />

build/Xcode/FlatBuffers.xcodeproj/project.pbxproj

@@ -8,10 +8,19 @@
 
 /* Begin PBXBuildFile section */
 		1963D7D2A57344A3B1C1713F /* idl_parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3709AC883348409592530AE6 /* idl_parser.cpp */; settings = {COMPILER_FLAGS = ""; }; };
-		3343DD4ED370434BBA148FAB /* idl_gen_java.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3803689175184C7E8CB3EED0 /* idl_gen_java.cpp */; settings = {COMPILER_FLAGS = ""; }; };
 		61823BBC53544106B6DBC38E /* idl_parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3709AC883348409592530AE6 /* idl_parser.cpp */; settings = {COMPILER_FLAGS = ""; }; };
 		61FF3C34FBEC4819A1C30F92 /* sample_text.cpp in Sources */ = {isa = PBXBuildFile; fileRef = ECCEBFFA6977404F858F9739 /* sample_text.cpp */; settings = {COMPILER_FLAGS = ""; }; };
 		8C303C591975D6A700D7C1C5 /* idl_gen_go.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C303C581975D6A700D7C1C5 /* idl_gen_go.cpp */; };
+		8C6905ED19F8357300CB8866 /* idl_gen_fbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905EC19F8357300CB8866 /* idl_gen_fbs.cpp */; };
+		8C6905F619F835A900CB8866 /* flatc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905EF19F835A900CB8866 /* flatc.cpp */; };
+		8C6905F719F835A900CB8866 /* idl_gen_cpp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905F019F835A900CB8866 /* idl_gen_cpp.cpp */; };
+		8C6905F819F835A900CB8866 /* idl_gen_fbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905F119F835A900CB8866 /* idl_gen_fbs.cpp */; };
+		8C6905F919F835A900CB8866 /* idl_gen_general.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905F219F835A900CB8866 /* idl_gen_general.cpp */; };
+		8C6905FA19F835A900CB8866 /* idl_gen_go.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905F319F835A900CB8866 /* idl_gen_go.cpp */; };
+		8C6905FB19F835A900CB8866 /* idl_gen_text.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905F419F835A900CB8866 /* idl_gen_text.cpp */; };
+		8C6905FC19F835A900CB8866 /* idl_parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905F519F835A900CB8866 /* idl_parser.cpp */; };
+		8C6905FD19F835B400CB8866 /* idl_gen_fbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C6905EC19F8357300CB8866 /* idl_gen_fbs.cpp */; };
+		8CD8717B19CB937D0012A827 /* idl_gen_general.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CD8717A19CB937D0012A827 /* idl_gen_general.cpp */; };
 		A9C9A99F719A4ED58DC2D2FC /* idl_parser.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3709AC883348409592530AE6 /* idl_parser.cpp */; settings = {COMPILER_FLAGS = ""; }; };
 		AA9BACF55EB3456BA2F633BB /* flatc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0DFD29781D8E490284B06504 /* flatc.cpp */; settings = {COMPILER_FLAGS = ""; }; };
 		AD71FEBEE4E846529002C1F0 /* idl_gen_text.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F6C5D81DBF864365B12E269D /* idl_gen_text.cpp */; settings = {COMPILER_FLAGS = ""; }; };
@@ -27,13 +36,21 @@
 		0DFD29781D8E490284B06504 /* flatc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = flatc.cpp; path = src/flatc.cpp; sourceTree = SOURCE_ROOT; };
 		18185F364F604E648CF6EE25 /* flatc */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; path = flatc; sourceTree = BUILT_PRODUCTS_DIR; };
 		3709AC883348409592530AE6 /* idl_parser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = idl_parser.cpp; path = src/idl_parser.cpp; sourceTree = SOURCE_ROOT; };
-		3803689175184C7E8CB3EED0 /* idl_gen_java.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = idl_gen_java.cpp; path = src/idl_gen_java.cpp; sourceTree = SOURCE_ROOT; };
 		3863042BCEC64791BFB48625 /* flatsamplebinary */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; path = flatsamplebinary; sourceTree = BUILT_PRODUCTS_DIR; };
 		420E3BC724ED4A008D79297F /* flatsampletext */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; path = flatsampletext; sourceTree = BUILT_PRODUCTS_DIR; };
 		423CA92401AE442B91546E63 /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CMakeLists.txt; path = /Users/wvo/flatbuffers_snapshot9/CMakeLists.txt; sourceTree = "<absolute>"; };
 		5EE44BFFAF8E43F485859145 /* sample_binary.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = sample_binary.cpp; path = samples/sample_binary.cpp; sourceTree = SOURCE_ROOT; };
 		6AD24EEB3D024825A37741FF /* test.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = test.cpp; path = tests/test.cpp; sourceTree = SOURCE_ROOT; };
 		8C303C581975D6A700D7C1C5 /* idl_gen_go.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = idl_gen_go.cpp; path = src/idl_gen_go.cpp; sourceTree = "<group>"; };
+		8C6905EC19F8357300CB8866 /* idl_gen_fbs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = idl_gen_fbs.cpp; path = src/idl_gen_fbs.cpp; sourceTree = "<group>"; };
+		8C6905EF19F835A900CB8866 /* flatc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = flatc.cpp; sourceTree = "<group>"; };
+		8C6905F019F835A900CB8866 /* idl_gen_cpp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = idl_gen_cpp.cpp; sourceTree = "<group>"; };
+		8C6905F119F835A900CB8866 /* idl_gen_fbs.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = idl_gen_fbs.cpp; sourceTree = "<group>"; };
+		8C6905F219F835A900CB8866 /* idl_gen_general.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = idl_gen_general.cpp; sourceTree = "<group>"; };
+		8C6905F319F835A900CB8866 /* idl_gen_go.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = idl_gen_go.cpp; sourceTree = "<group>"; };
+		8C6905F419F835A900CB8866 /* idl_gen_text.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = idl_gen_text.cpp; sourceTree = "<group>"; };
+		8C6905F519F835A900CB8866 /* idl_parser.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = idl_parser.cpp; sourceTree = "<group>"; };
+		8CD8717A19CB937D0012A827 /* idl_gen_general.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = idl_gen_general.cpp; path = src/idl_gen_general.cpp; sourceTree = "<group>"; };
 		A13F25CDAD23435DA293690D /* flattests */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; path = flattests; sourceTree = BUILT_PRODUCTS_DIR; };
 		AB70F1FBA50E4120BCF37C8D /* monster_test_generated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = monster_test_generated.h; path = tests/monster_test_generated.h; sourceTree = SOURCE_ROOT; };
 		AD3682C6E1DD4EABB822C0CC /* monster_generated.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = monster_generated.h; path = samples/monster_generated.h; sourceTree = SOURCE_ROOT; };
@@ -55,12 +72,11 @@
 		28237E300FE042DEADA302D3 /* Source Files */ = {
 			isa = PBXGroup;
 			children = (
+				8C6905EC19F8357300CB8866 /* idl_gen_fbs.cpp */,
+				8CD8717A19CB937D0012A827 /* idl_gen_general.cpp */,
 				8C303C581975D6A700D7C1C5 /* idl_gen_go.cpp */,
 				0DFD29781D8E490284B06504 /* flatc.cpp */,
 				CD90A7F6B2BE4D0384294DD1 /* idl_gen_cpp.cpp */,
-				3803689175184C7E8CB3EED0 /* idl_gen_java.cpp */,
-				F6C5D81DBF864365B12E269D /* idl_gen_text.cpp */,
-				3709AC883348409592530AE6 /* idl_parser.cpp */,
 			);
 			name = "Source Files";
 			sourceTree = "<group>";
@@ -68,6 +84,7 @@
 		355DCA17961E4B2FB2C71403 /* Source Files */ = {
 			isa = PBXGroup;
 			children = (
+				8C6905EE19F835A900CB8866 /* src */,
 				F6C5D81DBF864365B12E269D /* idl_gen_text.cpp */,
 				3709AC883348409592530AE6 /* idl_parser.cpp */,
 				6AD24EEB3D024825A37741FF /* test.cpp */,
@@ -80,7 +97,6 @@
 			children = (
 				5FEA84E7D39645988300317C /* Header Files */,
 				28237E300FE042DEADA302D3 /* Source Files */,
-				423CA92401AE442B91546E63 /* CMakeLists.txt */,
 			);
 			name = flatc;
 			sourceTree = "<group>";
@@ -88,9 +104,6 @@
 		40E30B8480BD493EA459E9B4 /* Header Files */ = {
 			isa = PBXGroup;
 			children = (
-				DD8B353D4756412195777FBA /* flatbuffers.h */,
-				00154BD8654B4B5B9FF45FA6 /* idl.h */,
-				C0E7B66C3FF849A0AD9A7168 /* util.h */,
 				AD3682C6E1DD4EABB822C0CC /* monster_generated.h */,
 			);
 			name = "Header Files";
@@ -99,8 +112,6 @@
 		4D1151F6FE594E40A1C177FF /* Header Files */ = {
 			isa = PBXGroup;
 			children = (
-				DD8B353D4756412195777FBA /* flatbuffers.h */,
-				AD3682C6E1DD4EABB822C0CC /* monster_generated.h */,
 			);
 			name = "Header Files";
 			sourceTree = "<group>";
@@ -127,9 +138,6 @@
 		5FEA84E7D39645988300317C /* Header Files */ = {
 			isa = PBXGroup;
 			children = (
-				DD8B353D4756412195777FBA /* flatbuffers.h */,
-				00154BD8654B4B5B9FF45FA6 /* idl.h */,
-				C0E7B66C3FF849A0AD9A7168 /* util.h */,
 			);
 			name = "Header Files";
 			sourceTree = "<group>";
@@ -154,6 +162,20 @@
 			name = flattests;
 			sourceTree = "<group>";
 		};
+		8C6905EE19F835A900CB8866 /* src */ = {
+			isa = PBXGroup;
+			children = (
+				8C6905EF19F835A900CB8866 /* flatc.cpp */,
+				8C6905F019F835A900CB8866 /* idl_gen_cpp.cpp */,
+				8C6905F119F835A900CB8866 /* idl_gen_fbs.cpp */,
+				8C6905F219F835A900CB8866 /* idl_gen_general.cpp */,
+				8C6905F319F835A900CB8866 /* idl_gen_go.cpp */,
+				8C6905F419F835A900CB8866 /* idl_gen_text.cpp */,
+				8C6905F519F835A900CB8866 /* idl_parser.cpp */,
+			);
+			path = src;
+			sourceTree = "<group>";
+		};
 		8F5E926B72104F4194B3BD5A = {
 			isa = PBXGroup;
 			children = (
@@ -187,8 +209,6 @@
 			isa = PBXGroup;
 			children = (
 				ECCEBFFA6977404F858F9739 /* sample_text.cpp */,
-				F6C5D81DBF864365B12E269D /* idl_gen_text.cpp */,
-				3709AC883348409592530AE6 /* idl_parser.cpp */,
 			);
 			name = "Source Files";
 			sourceTree = "<group>";
@@ -317,12 +337,20 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				8C6905FB19F835A900CB8866 /* idl_gen_text.cpp in Sources */,
 				8C303C591975D6A700D7C1C5 /* idl_gen_go.cpp in Sources */,
 				AA9BACF55EB3456BA2F633BB /* flatc.cpp in Sources */,
 				BE03D7B0C9584DD58B50ED34 /* idl_gen_cpp.cpp in Sources */,
-				3343DD4ED370434BBA148FAB /* idl_gen_java.cpp in Sources */,
 				AD71FEBEE4E846529002C1F0 /* idl_gen_text.cpp in Sources */,
+				8C6905F619F835A900CB8866 /* flatc.cpp in Sources */,
+				8C6905FC19F835A900CB8866 /* idl_parser.cpp in Sources */,
+				8C6905ED19F8357300CB8866 /* idl_gen_fbs.cpp in Sources */,
+				8C6905FA19F835A900CB8866 /* idl_gen_go.cpp in Sources */,
+				8C6905F919F835A900CB8866 /* idl_gen_general.cpp in Sources */,
 				A9C9A99F719A4ED58DC2D2FC /* idl_parser.cpp in Sources */,
+				8C6905F719F835A900CB8866 /* idl_gen_cpp.cpp in Sources */,
+				8C6905F819F835A900CB8866 /* idl_gen_fbs.cpp in Sources */,
+				8CD8717B19CB937D0012A827 /* idl_gen_general.cpp in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
@@ -330,6 +358,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				8C6905FD19F835B400CB8866 /* idl_gen_fbs.cpp in Sources */,
 				E0680D6B5BFD484BA9D88EE8 /* idl_gen_text.cpp in Sources */,
 				61823BBC53544106B6DBC38E /* idl_parser.cpp in Sources */,
 				EE4AEE138D684B30A1BF5462 /* test.cpp in Sources */,

docs/html/md__compiler.html

@@ -53,7 +53,7 @@ $(document).ready(function(){initNavTree('md__compiler.html','');});
 <div class="title">Using the schema compiler </div>  </div>
 </div><!--header-->
 <div class="contents">
-<div class="textblock"><p>Usage: </p><pre class="fragment">flatc [ -c ] [ -j ] [ -b ] [ -t ] [ -o PATH ] [ -S ] FILES...
+<div class="textblock"><p>Usage: </p><pre class="fragment">flatc [ -c ] [ -j ] [ -b ] [ -t ] [ -o PATH ] [ -I PATH ] [ -S ] FILES...
       [ -- FILES...]
 </pre><p>The files are read and parsed in order, and can contain either schemas or data (see below). Later files can make use of definitions in earlier files.</p>
 <p><code>--</code> indicates that the following files are binary files in FlatBuffer format conforming to the schema(s) indicated before it. Incompatible binary files currently will give unpredictable results (!)</p>
@@ -61,10 +61,16 @@ $(document).ready(function(){initNavTree('md__compiler.html','');});
 <ul>
 <li><code>-c</code> : Generate a C++ header for all definitions in this file (as <code>filename_generated.h</code>). Skipped for data.</li>
 <li><code>-j</code> : Generate Java classes. Skipped for data.</li>
+<li><code>-n</code> : Generate C# classes. Skipped for data.</li>
+<li><code>-g</code> : Generate Go classes. Skipped for data.</li>
 <li><code>-b</code> : If data is contained in this file, generate a <code>filename.bin</code> containing the binary flatbuffer.</li>
 <li><code>-t</code> : If data is contained in this file, generate a <code>filename.json</code> representing the data in the flatbuffer.</li>
 <li><code>-o PATH</code> : Output all generated files to PATH (either absolute, or relative to the current directory). If omitted, PATH will be the current directory. PATH should end in your systems path separator, e.g. <code>/</code> or <code>\</code>.</li>
-<li><code>-S</code> : Generate strict JSON (field names are enclosed in quotes). By default, no quotes are generated. </li>
+<li><code>-I PATH</code> : when encountering <code>include</code> statements, attempt to load the files from this path. Paths will be tried in the order given, and if all fail (or none are specified) it will try to load relative to the path of the schema file being parsed.</li>
+<li><code>--strict-json</code> : Generate strict JSON (field names are enclosed in quotes). By default, no quotes are generated.</li>
+<li><code>--no-prefix</code> : Don't prefix enum values in generated C++ by their enum type.</li>
+<li><code>--gen-includes</code> : Generate include statements for included schemas the generated file depends on (C++).</li>
+<li><code>--proto</code>: Expect input files to be .proto files (protocol buffers). Output the corresponding .fbs file. Currently supports: <code>package</code>, <code>message</code>, <code>enum</code>. Does not support, but will skip without error: <code>import</code>, <code>option</code>. Does not support, will generate error: <code>service</code>, <code>extend</code>, <code>extensions</code>, <code>oneof</code>, <code>group</code>, custom options, nested declarations. </li>
 </ul>
 </div></div><!-- contents -->
 </div><!-- doc-content -->

docs/html/md__cpp_usage.html

@@ -55,42 +55,52 @@ $(document).ready(function(){initNavTree('md__cpp_usage.html','');});
 <div class="contents">
 <div class="textblock"><p>Assuming you have written a schema using the above language in say <code>mygame.fbs</code> (FlatBuffer Schema, though the extension doesn't matter), you've generated a C++ header called <code>mygame_generated.h</code> using the compiler (e.g. <code>flatc -c mygame.fbs</code>), you can now start using this in your program by including the header. As noted, this header relies on <code>flatbuffers/flatbuffers.h</code>, which should be in your include path.</p>
 <h3>Writing in C++</h3>
-<p>To start creating a buffer, create an instance of <code>FlatBufferBuilder</code> which will contain the buffer as it grows: </p><pre class="fragment">FlatBufferBuilder fbb;
-</pre><p>Before we serialize a Monster, we need to first serialize any objects that are contained there-in, i.e. we serialize the data tree using depth first, pre-order traversal. This is generally easy to do on any tree structures. For example: </p><pre class="fragment">auto name = fbb.CreateString("MyMonster");
-
-unsigned char inv[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-auto inventory = fbb.CreateVector(inv, 10);
-</pre><p><code>CreateString</code> and <code>CreateVector</code> serialize these two built-in datatypes, and return offsets into the serialized data indicating where they are stored, such that <code>Monster</code> below can refer to them.</p>
+<p>To start creating a buffer, create an instance of <code>FlatBufferBuilder</code> which will contain the buffer as it grows:</p>
+<div class="fragment"><div class="line">FlatBufferBuilder fbb;</div>
+</div><!-- fragment --><p>Before we serialize a Monster, we need to first serialize any objects that are contained there-in, i.e. we serialize the data tree using depth first, pre-order traversal. This is generally easy to do on any tree structures. For example:</p>
+<div class="fragment"><div class="line"><span class="keyword">auto</span> name = fbb.CreateString(<span class="stringliteral">&quot;MyMonster&quot;</span>);</div>
+<div class="line"></div>
+<div class="line"><span class="keywordtype">unsigned</span> <span class="keywordtype">char</span> inv[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };</div>
+<div class="line"><span class="keyword">auto</span> inventory = fbb.CreateVector(inv, 10);</div>
+</div><!-- fragment --><p><code>CreateString</code> and <code>CreateVector</code> serialize these two built-in datatypes, and return offsets into the serialized data indicating where they are stored, such that <code>Monster</code> below can refer to them.</p>
 <p><code>CreateString</code> can also take an <code>std::string</code>, or a <code>const char *</code> with an explicit length, and is suitable for holding UTF-8 and binary data if needed.</p>
-<p><code>CreateVector</code> can also take an <code>std::vector</code>. The offset it returns is typed, i.e. can only be used to set fields of the correct type below. To create a vector of struct objects (which will be stored as contiguous memory in the buffer, use <code>CreateVectorOfStructs</code> instead. </p><pre class="fragment">Vec3 vec(1, 2, 3);
-</pre><p><code>Vec3</code> is the first example of code from our generated header. Structs (unlike tables) translate to simple structs in C++, so we can construct them in a familiar way.</p>
-<p>We have now serialized the non-scalar components of of the monster example, so we could create the monster something like this: </p><pre class="fragment">auto mloc = CreateMonster(fbb, &amp;vec, 150, 80, name, inventory, Color_Red, 0, Any_NONE);
-</pre><p>Note that we're passing <code>150</code> for the <code>mana</code> field, which happens to be the default value: this means the field will not actually be written to the buffer, since we'll get that value anyway when we query it. This is a nice space savings, since it is very common for fields to be at their default. It means we also don't need to be scared to add fields only used in a minority of cases, since they won't bloat up the buffer sizes if they're not actually used.</p>
+<p><code>CreateVector</code> can also take an <code>std::vector</code>. The offset it returns is typed, i.e. can only be used to set fields of the correct type below. To create a vector of struct objects (which will be stored as contiguous memory in the buffer, use <code>CreateVectorOfStructs</code> instead.</p>
+<div class="fragment"><div class="line">Vec3 vec(1, 2, 3);</div>
+</div><!-- fragment --><p><code>Vec3</code> is the first example of code from our generated header. Structs (unlike tables) translate to simple structs in C++, so we can construct them in a familiar way.</p>
+<p>We have now serialized the non-scalar components of of the monster example, so we could create the monster something like this:</p>
+<div class="fragment"><div class="line"><span class="keyword">auto</span> mloc = CreateMonster(fbb, &amp;vec, 150, 80, name, inventory, Color_Red, 0, Any_NONE);</div>
+</div><!-- fragment --><p>Note that we're passing <code>150</code> for the <code>mana</code> field, which happens to be the default value: this means the field will not actually be written to the buffer, since we'll get that value anyway when we query it. This is a nice space savings, since it is very common for fields to be at their default. It means we also don't need to be scared to add fields only used in a minority of cases, since they won't bloat up the buffer sizes if they're not actually used.</p>
 <p>We do something similarly for the union field <code>test</code> by specifying a <code>0</code> offset and the <code>NONE</code> enum value (part of every union) to indicate we don't actually want to write this field. You can use <code>0</code> also as a default for other non-scalar types, such as strings, vectors and tables.</p>
-<p>Tables (like <code>Monster</code>) give you full flexibility on what fields you write (unlike <code>Vec3</code>, which always has all fields set because it is a <code>struct</code>). If you want even more control over this (i.e. skip fields even when they are not default), instead of the convenient <code>CreateMonster</code> call we can also build the object field-by-field manually: </p><pre class="fragment">MonsterBuilder mb(fbb);
-mb.add_pos(&amp;vec);
-mb.add_hp(80);
-mb.add_name(name);
-mb.add_inventory(inventory);
-auto mloc = mb.Finish();
-</pre><p>We start with a temporary helper class <code>MonsterBuilder</code> (which is defined in our generated code also), then call the various <code>add_</code> methods to set fields, and <code>Finish</code> to complete the object. This is pretty much the same code as you find inside <code>CreateMonster</code>, except we're leaving out a few fields. Fields may also be added in any order, though orderings with fields of the same size adjacent to each other most efficient in size, due to alignment. You should not nest these Builder classes (serialize your data in pre-order).</p>
-<p>Regardless of whether you used <code>CreateMonster</code> or <code>MonsterBuilder</code>, you now have an offset to the root of your data, and you can finish the buffer using: </p><pre class="fragment">FinishMonsterBuffer(fbb, mloc);
-</pre><p>The buffer is now ready to be stored somewhere, sent over the network, be compressed, or whatever you'd like to do with it. You can access the start of the buffer with <code>fbb.GetBufferPointer()</code>, and it's size from <code>fbb.GetSize()</code>.</p>
+<p>Tables (like <code>Monster</code>) give you full flexibility on what fields you write (unlike <code>Vec3</code>, which always has all fields set because it is a <code>struct</code>). If you want even more control over this (i.e. skip fields even when they are not default), instead of the convenient <code>CreateMonster</code> call we can also build the object field-by-field manually:</p>
+<div class="fragment"><div class="line">MonsterBuilder mb(fbb);</div>
+<div class="line">mb.add_pos(&amp;vec);</div>
+<div class="line">mb.add_hp(80);</div>
+<div class="line">mb.add_name(name);</div>
+<div class="line">mb.add_inventory(inventory);</div>
+<div class="line"><span class="keyword">auto</span> mloc = mb.Finish();</div>
+</div><!-- fragment --><p>We start with a temporary helper class <code>MonsterBuilder</code> (which is defined in our generated code also), then call the various <code>add_</code> methods to set fields, and <code>Finish</code> to complete the object. This is pretty much the same code as you find inside <code>CreateMonster</code>, except we're leaving out a few fields. Fields may also be added in any order, though orderings with fields of the same size adjacent to each other most efficient in size, due to alignment. You should not nest these Builder classes (serialize your data in pre-order).</p>
+<p>Regardless of whether you used <code>CreateMonster</code> or <code>MonsterBuilder</code>, you now have an offset to the root of your data, and you can finish the buffer using:</p>
+<div class="fragment"><div class="line">FinishMonsterBuffer(fbb, mloc);</div>
+</div><!-- fragment --><p>The buffer is now ready to be stored somewhere, sent over the network, be compressed, or whatever you'd like to do with it. You can access the start of the buffer with <code>fbb.GetBufferPointer()</code>, and it's size from <code>fbb.GetSize()</code>.</p>
 <p><code>samples/sample_binary.cpp</code> is a complete code sample similar to the code above, that also includes the reading code below.</p>
 <h3>Reading in C++</h3>
-<p>If you've received a buffer from somewhere (disk, network, etc.) you can directly start traversing it using: </p><pre class="fragment">auto monster = GetMonster(buffer_pointer);
-</pre><p><code>monster</code> is of type <code>Monster *</code>, and points to somewhere inside your buffer. If you look in your generated header, you'll see it has convenient accessors for all fields, e.g. </p><pre class="fragment">assert(monster-&gt;hp() == 80);
-assert(monster-&gt;mana() == 150);  // default
-assert(strcmp(monster-&gt;name()-&gt;c_str(), "MyMonster") == 0);
-</pre><p>These should all be true. Note that we never stored a <code>mana</code> value, so it will return the default.</p>
-<p>To access sub-objects, in this case the <code>Vec3</code>: </p><pre class="fragment">auto pos = monster-&gt;pos();
-assert(pos);
-assert(pos-&gt;z() == 3);
-</pre><p>If we had not set the <code>pos</code> field during serialization, it would be <code>NULL</code>.</p>
-<p>Similarly, we can access elements of the inventory array: </p><pre class="fragment">auto inv = monster-&gt;inventory();
-assert(inv);
-assert(inv-&gt;Get(9) == 9);
-</pre><h3>Direct memory access</h3>
+<p>If you've received a buffer from somewhere (disk, network, etc.) you can directly start traversing it using:</p>
+<div class="fragment"><div class="line"><span class="keyword">auto</span> monster = GetMonster(buffer_pointer);</div>
+</div><!-- fragment --><p><code>monster</code> is of type <code>Monster *</code>, and points to somewhere inside your buffer. If you look in your generated header, you'll see it has convenient accessors for all fields, e.g.</p>
+<div class="fragment"><div class="line">assert(monster-&gt;hp() == 80);</div>
+<div class="line">assert(monster-&gt;mana() == 150);  <span class="comment">// default</span></div>
+<div class="line">assert(strcmp(monster-&gt;name()-&gt;c_str(), <span class="stringliteral">&quot;MyMonster&quot;</span>) == 0);</div>
+</div><!-- fragment --><p>These should all be true. Note that we never stored a <code>mana</code> value, so it will return the default.</p>
+<p>To access sub-objects, in this case the <code>Vec3</code>:</p>
+<div class="fragment"><div class="line"><span class="keyword">auto</span> pos = monster-&gt;pos();</div>
+<div class="line">assert(pos);</div>
+<div class="line">assert(pos-&gt;z() == 3);</div>
+</div><!-- fragment --><p>If we had not set the <code>pos</code> field during serialization, it would be <code>NULL</code>.</p>
+<p>Similarly, we can access elements of the inventory array:</p>
+<div class="fragment"><div class="line"><span class="keyword">auto</span> inv = monster-&gt;inventory();</div>
+<div class="line">assert(inv);</div>
+<div class="line">assert(inv-&gt;Get(9) == 9);</div>
+</div><!-- fragment --><h3>Direct memory access</h3>
 <p>As you can see from the above examples, all elements in a buffer are accessed through generated accessors. This is because everything is stored in little endian format on all platforms (the accessor performs a swap operation on big endian machines), and also because the layout of things is generally not known to the user.</p>
 <p>For structs, layout is deterministic and guaranteed to be the same accross platforms (scalars are aligned to their own size, and structs themselves to their largest member), and you are allowed to access this memory directly by using <code>sizeof()</code> and <code>memcpy</code> on the pointer to a struct, or even an array of structs.</p>
 <p>To compute offsets to sub-elements of a struct, make sure they are a structs themselves, as then you can use the pointers to figure out the offset without having to hardcode it. This is handy for use of arrays of structs with calls like <code>glVertexAttribPointer</code> in OpenGL or similar APIs.</p>
@@ -100,10 +110,11 @@ assert(inv-&gt;Get(9) == 9);
 <p>When you're processing large amounts of data from a source you know (e.g. your own generated data on disk), this is acceptable, but when reading data from the network that can potentially have been modified by an attacker, this is undesirable.</p>
 <p>For this reason, you can optionally use a buffer verifier before you access the data. This verifier will check all offsets, all sizes of fields, and null termination of strings to ensure that when a buffer is accessed, all reads will end up inside the buffer.</p>
 <p>Each root type will have a verification function generated for it, e.g. for <code>Monster</code>, you can call:</p>
-<p>bool ok = VerifyMonsterBuffer(Verifier(buf, len));</p>
-<p>if <code>ok</code> is true, the buffer is safe to read.</p>
+<div class="fragment"><div class="line"><span class="keywordtype">bool</span> ok = VerifyMonsterBuffer(Verifier(buf, len));</div>
+</div><!-- fragment --><p>if <code>ok</code> is true, the buffer is safe to read.</p>
 <p>Besides untrusted data, this function may be useful to call in debug mode, as extra insurance against data being corrupted somewhere along the way.</p>
 <p>While verifying a buffer isn't "free", it is typically faster than a full traversal (since any scalar data is not actually touched), and since it may cause the buffer to be brought into cache before reading, the actual overhead may be even lower than expected.</p>
+<p>In specialized cases where a denial of service attack is possible, the verifier has two additional constructor arguments that allow you to limit the nesting depth and total amount of tables the verifier may encounter before declaring the buffer malformed.</p>
 <h2>Text &amp; schema parsing</h2>
 <p>Using binary buffers with the generated header provides a super low overhead use of FlatBuffer data. There are, however, times when you want to use text formats, for example because it interacts better with source control, or you want to give your users easy access to data.</p>
 <p>Another reason might be that you already have a lot of data in JSON format, or a tool that generates JSON, and if you can write a schema for it, this will provide you an easy way to use that data directly.</p>
@@ -116,9 +127,12 @@ assert(inv-&gt;Get(9) == 9);
 <p>This gives you maximum flexibility. You could even opt to support both, i.e. check for both files, and regenerate the binary from text when required, otherwise just load the binary.</p>
 <p>This option is currently only available for C++, or Java through JNI.</p>
 <p>As mentioned in the section "Building" above, this technique requires you to link a few more files into your program, and you'll want to include <code>flatbuffers/idl.h</code>.</p>
-<p>Load text (either a schema or json) into an in-memory buffer (there is a convenient <code>LoadFile()</code> utility function in <code>flatbuffers/util.h</code> if you wish). Construct a parser: </p><pre class="fragment">flatbuffers::Parser parser;
-</pre><p>Now you can parse any number of text files in sequence: </p><pre class="fragment">parser.Parse(text_file.c_str());
-</pre><p>This works similarly to how the command-line compiler works: a sequence of files parsed by the same <code>Parser</code> object allow later files to reference definitions in earlier files. Typically this means you first load a schema file (which populates <code>Parser</code> with definitions), followed by one or more JSON files.</p>
+<p>Load text (either a schema or json) into an in-memory buffer (there is a convenient <code>LoadFile()</code> utility function in <code>flatbuffers/util.h</code> if you wish). Construct a parser:</p>
+<div class="fragment"><div class="line">flatbuffers::Parser parser;</div>
+</div><!-- fragment --><p>Now you can parse any number of text files in sequence:</p>
+<div class="fragment"><div class="line">parser.Parse(text_file.c_str());</div>
+</div><!-- fragment --><p>This works similarly to how the command-line compiler works: a sequence of files parsed by the same <code>Parser</code> object allow later files to reference definitions in earlier files. Typically this means you first load a schema file (which populates <code>Parser</code> with definitions), followed by one or more JSON files.</p>
+<p>As optional argument to <code>Parse</code>, you may specify a null-terminated list of include paths. If not specified, any include statements try to resolve from the current directory.</p>
 <p>If there were any parsing errors, <code>Parse</code> will return <code>false</code>, and <code>Parser::err</code> contains a human readable error string with a line number etc, which you should present to the creator of that file.</p>
 <p>After each JSON file, the <code>Parser::fbb</code> member variable is the <code>FlatBufferBuilder</code> that contains the binary buffer version of that file, that you can access as described above.</p>
 <p><code>samples/sample_text.cpp</code> is a code sample showing the above operations.</p>

docs/html/md__go_usage.html

@@ -54,40 +54,47 @@ $(document).ready(function(){initNavTree('md__go_usage.html','');});
 </div><!--header-->
 <div class="contents">
 <div class="textblock"><p>There's experimental support for reading FlatBuffers in Go. Generate code for Go with the <code>-g</code> option to <code>flatc</code>.</p>
-<p>See <code>go_test.go</code> for an example. You import the generated code, read a FlatBuffer binary file into a <code>[]byte</code>, which you pass to the <code>GetRootAsMonster</code> function: </p><pre class="fragment">import (
-   example "MyGame/Example"
-   flatbuffers "github.com/google/flatbuffers/go"
-
-   io/ioutil
-)
-
-buf, err := ioutil.ReadFile("monster.dat")
-// handle err
-monster := example.GetRootAsMonster(buf, 0)
-</pre><p>Now you can access values like this: </p><pre class="fragment">hp := monster.Hp()
-pos := monster.Pos(nil)
-</pre><p>Note that whenever you access a new object like in the <code>Pos</code> example above, a new temporary accessor object gets created. If your code is very performance sensitive (you iterate through a lot of objects), you can replace nil with a pointer to a <code>Vec3</code> object you've already created. This allows you to reuse it across many calls and reduce the amount of object allocation (and thus garbage collection) your program does.</p>
-<p>To access vectors you pass an extra index to the vector field accessor. Then a second method with the same name suffixed by <code>Length</code> let's you know the number of elements you can access: </p><pre class="fragment">for i := 0; i &lt; monster.InventoryLength(); i++ {
-    monster.Inventory(i) // do something here
-}
-</pre><p>You can also construct these buffers in Go using the functions found in the generated code, and the FlatBufferBuilder class: </p><pre class="fragment">builder := flatbuffers.NewBuilder(0)
-</pre><p>Create strings: </p><pre class="fragment">str := builder.CreateString("MyMonster")
-</pre><p>Create a table with a struct contained therein: </p><pre class="fragment">example.MonsterStart(builder)
-example.MonsterAddPos(builder, example.CreateVec3(builder, 1.0, 2.0, 3.0, 3.0, 4, 5, 6))
-example.MonsterAddHp(builder, 80)
-example.MonsterAddName(builder, str)
-example.MonsterAddInventory(builder, inv)
-example.MonsterAddTest_Type(builder, 1)
-example.MonsterAddTest(builder, mon2)
-example.MonsterAddTest4(builder, test4s)
-mon := example.MonsterEnd(builder)
-</pre><p>Unlike C++, Go does not support table creation functions like 'createMonster()'. This is to create the buffer without using temporary object allocation (since the <code>Vec3</code> is an inline component of <code>Monster</code>, it has to be created right where it is added, whereas the name and the inventory are not inline). Structs do have convenient methods that allow you to construct them in one call. These also have arguments for nested structs, e.g. if a struct has a field <code>a</code> and a nested struct field <code>b</code> (which has fields <code>c</code> and <code>d</code>), then the arguments will be <code>a</code>, <code>c</code> and <code>d</code>.</p>
-<p>Vectors also use this start/end pattern to allow vectors of both scalar types and structs: </p><pre class="fragment">example.MonsterStartInventoryVector(builder, 5)
-for i := 4; i &gt;= 0; i-- {
-    builder.PrependByte(byte(i))
-}
-inv := builder.EndVector(5)
-</pre><p>The generated method 'StartInventoryVector' is provided as a convenience function which calls 'StartVector' with the correct element size of the vector type which in this case is 'ubyte' or 1 byte per vector element. You pass the number of elements you want to write. You write the elements backwards since the buffer is being constructed back to front.</p>
+<p>See <code>go_test.go</code> for an example. You import the generated code, read a FlatBuffer binary file into a <code>[]byte</code>, which you pass to the <code>GetRootAsMonster</code> function:</p>
+<div class="fragment"><div class="line"><span class="keyword">import</span> (</div>
+<div class="line">   example <span class="stringliteral">&quot;MyGame/Example&quot;</span></div>
+<div class="line">   flatbuffers <span class="stringliteral">&quot;github.com/google/flatbuffers/go&quot;</span></div>
+<div class="line"></div>
+<div class="line">   io/ioutil</div>
+<div class="line">)</div>
+<div class="line"></div>
+<div class="line">buf, err := ioutil.ReadFile(<span class="stringliteral">&quot;monster.dat&quot;</span>)</div>
+<div class="line"><span class="comment">// handle err</span></div>
+<div class="line">monster := example.GetRootAsMonster(buf, 0)</div>
+</div><!-- fragment --><p>Now you can access values like this:</p>
+<div class="fragment"><div class="line">hp := monster.Hp()</div>
+<div class="line">pos := monster.Pos(nil)</div>
+</div><!-- fragment --><p>Note that whenever you access a new object like in the <code>Pos</code> example above, a new temporary accessor object gets created. If your code is very performance sensitive (you iterate through a lot of objects), you can replace nil with a pointer to a <code>Vec3</code> object you've already created. This allows you to reuse it across many calls and reduce the amount of object allocation (and thus garbage collection) your program does.</p>
+<p>To access vectors you pass an extra index to the vector field accessor. Then a second method with the same name suffixed by <code>Length</code> let's you know the number of elements you can access:</p>
+<div class="fragment"><div class="line"><span class="keywordflow">for</span> i := 0; i &lt; monster.InventoryLength(); i++ {</div>
+<div class="line">    monster.Inventory(i) <span class="comment">// do something here</span></div>
+<div class="line">}</div>
+</div><!-- fragment --><p>You can also construct these buffers in Go using the functions found in the generated code, and the FlatBufferBuilder class:</p>
+<div class="fragment"><div class="line">builder := flatbuffers.NewBuilder(0)</div>
+</div><!-- fragment --><p>Create strings:</p>
+<div class="fragment"><div class="line">str := builder.CreateString(<span class="stringliteral">&quot;MyMonster&quot;</span>)</div>
+</div><!-- fragment --><p>Create a table with a struct contained therein:</p>
+<div class="fragment"><div class="line">example.MonsterStart(builder)</div>
+<div class="line">example.MonsterAddPos(builder, example.CreateVec3(builder, 1.0, 2.0, 3.0, 3.0, 4, 5, 6))</div>
+<div class="line">example.MonsterAddHp(builder, 80)</div>
+<div class="line">example.MonsterAddName(builder, str)</div>
+<div class="line">example.MonsterAddInventory(builder, inv)</div>
+<div class="line">example.MonsterAddTest_Type(builder, 1)</div>
+<div class="line">example.MonsterAddTest(builder, mon2)</div>
+<div class="line">example.MonsterAddTest4(builder, test4s)</div>
+<div class="line">mon := example.MonsterEnd(builder)</div>
+</div><!-- fragment --><p>Unlike C++, Go does not support table creation functions like 'createMonster()'. This is to create the buffer without using temporary object allocation (since the <code>Vec3</code> is an inline component of <code>Monster</code>, it has to be created right where it is added, whereas the name and the inventory are not inline). Structs do have convenient methods that allow you to construct them in one call. These also have arguments for nested structs, e.g. if a struct has a field <code>a</code> and a nested struct field <code>b</code> (which has fields <code>c</code> and <code>d</code>), then the arguments will be <code>a</code>, <code>c</code> and <code>d</code>.</p>
+<p>Vectors also use this start/end pattern to allow vectors of both scalar types and structs:</p>
+<div class="fragment"><div class="line">example.MonsterStartInventoryVector(builder, 5)</div>
+<div class="line"><span class="keywordflow">for</span> i := 4; i &gt;= 0; i-- {</div>
+<div class="line">    builder.PrependByte(byte(i))</div>
+<div class="line">}</div>
+<div class="line">inv := builder.EndVector(5)</div>
+</div><!-- fragment --><p>The generated method 'StartInventoryVector' is provided as a convenience function which calls 'StartVector' with the correct element size of the vector type which in this case is 'ubyte' or 1 byte per vector element. You pass the number of elements you want to write. You write the elements backwards since the buffer is being constructed back to front.</p>
 <p>There are <code>Prepend</code> functions for all the scalar types. You use <code>PrependUOffset</code> for any previously constructed objects (such as other tables, strings, vectors). For structs, you use the appropriate <code>create</code> function in-line, as shown above in the <code>Monster</code> example.</p>
 <h2>Text Parsing</h2>
 <p>There currently is no support for parsing text (Schema's and JSON) directly from Go, though you could use the C++ parser through cgo. Please see the C++ documentation for more on text parsing. </p>

docs/html/md__grammar.html

@@ -53,7 +53,8 @@ $(document).ready(function(){initNavTree('md__grammar.html','');});
 <div class="title">Formal Grammar of the schema language </div>  </div>
 </div><!--header-->
 <div class="contents">
-<div class="textblock"><p>schema = namespace_decl | type_decl | enum_decl | root_decl | object</p>
+<div class="textblock"><p>schema = include* ( namespace_decl | type_decl | enum_decl | root_decl | object )*</p>
+<p>include = <code>include</code> string_constant <code>;</code></p>
 <p>namespace_decl = <code>namespace</code> ident ( <code>.</code> ident )* <code>;</code></p>
 <p>type_decl = ( <code>table</code> | <code>struct</code> ) ident metadata <code>{</code> field_decl+ <code>}</code></p>
 <p>enum_decl = ( <code>enum</code> | <code>union</code> ) ident [ <code>:</code> type ] metadata <code>{</code> commasep( enumval_decl ) <code>}</code></p>

docs/html/md__internals.html

@@ -107,7 +107,7 @@ inline const char **EnumNamesAny() {
 inline const char *EnumNameAny(int e) { return EnumNamesAny()[e]; }
 </pre><p>Unions share a lot with enums. </p><pre class="fragment">struct Vec3;
 struct Monster;
-</pre><p>Predeclare all datatypes since there may be circular references. </p><pre class="fragment">MANUALLY_ALIGNED_STRUCT(4) Vec3 {
+</pre><p>Predeclare all data types since circular references between types are allowed (circular references between object are not, though). </p><pre class="fragment">MANUALLY_ALIGNED_STRUCT(4) Vec3 {
  private:
   float x_;
   float y_;

docs/html/md__java_usage.html

@@ -54,35 +54,51 @@ $(document).ready(function(){initNavTree('md__java_usage.html','');});
 </div><!--header-->
 <div class="contents">
 <div class="textblock"><p>FlatBuffers supports reading and writing binary FlatBuffers in Java. Generate code for Java with the <code>-j</code> option to <code>flatc</code>.</p>
-<p>See <code>javaTest.java</code> for an example. Essentially, you read a FlatBuffer binary file into a <code>byte[]</code>, which you then turn into a <code>ByteBuffer</code>, which you pass to the <code>getRootAsMyRootType</code> function: </p><pre class="fragment">ByteBuffer bb = ByteBuffer.wrap(data);
-Monster monster = Monster.getRootAsMonster(bb);
-</pre><p>Now you can access values much like C++: </p><pre class="fragment">short hp = monster.hp();
-Vec3 pos = monster.pos();
-</pre><p>Note that whenever you access a new object like in the <code>pos</code> example above, a new temporary accessor object gets created. If your code is very performance sensitive (you iterate through a lot of objects), there's a second <code>pos()</code> method to which you can pass a <code>Vec3</code> object you've already created. This allows you to reuse it across many calls and reduce the amount of object allocation (and thus garbage collection) your program does.</p>
+<p>See <code>javaTest.java</code> for an example. Essentially, you read a FlatBuffer binary file into a <code>byte[]</code>, which you then turn into a <code>ByteBuffer</code>, which you pass to the <code>getRootAsMyRootType</code> function:</p>
+<div class="fragment"><div class="line">ByteBuffer bb = ByteBuffer.wrap(data);</div>
+<div class="line">Monster monster = Monster.getRootAsMonster(bb);</div>
+</div><!-- fragment --><p>Now you can access values much like C++:</p>
+<div class="fragment"><div class="line"><span class="keywordtype">short</span> hp = monster.hp();</div>
+<div class="line">Vec3 pos = monster.pos();</div>
+</div><!-- fragment --><p>Note that whenever you access a new object like in the <code>pos</code> example above, a new temporary accessor object gets created. If your code is very performance sensitive (you iterate through a lot of objects), there's a second <code>pos()</code> method to which you can pass a <code>Vec3</code> object you've already created. This allows you to reuse it across many calls and reduce the amount of object allocation (and thus garbage collection) your program does.</p>
 <p>Java does not support unsigned scalars. This means that any unsigned types you use in your schema will actually be represented as a signed value. This means all bits are still present, but may represent a negative value when used. For example, to read a <code>byte b</code> as an unsigned number, you can do: <code>(short)(b &amp; 0xFF)</code></p>
-<p>Sadly the string accessors currently always create a new string when accessed, since FlatBuffer's UTF-8 strings can't be read in-place by Java.</p>
-<p>Vector access is also a bit different from C++: you pass an extra index to the vector field accessor. Then a second method with the same name suffixed by <code>Length</code> let's you know the number of elements you can access: </p><pre class="fragment">for (int i = 0; i &lt; monster.inventoryLength(); i++)
-    monster.inventory(i); // do something here
-</pre><p>You can also construct these buffers in Java using the static methods found in the generated code, and the FlatBufferBuilder class: </p><pre class="fragment">FlatBufferBuilder fbb = new FlatBufferBuilder();
-</pre><p>Create strings: </p><pre class="fragment">int str = fbb.createString("MyMonster");
-</pre><p>Create a table with a struct contained therein: </p><pre class="fragment">Monster.startMonster(fbb);
-Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0, (byte)4, (short)5, (byte)6));
-Monster.addHp(fbb, (short)80);
-Monster.addName(fbb, str);
-Monster.addInventory(fbb, inv);
-Monster.addTest_type(fbb, (byte)1);
-Monster.addTest(fbb, mon2);
-Monster.addTest4(fbb, test4s);
-int mon = Monster.endMonster(fbb);
-</pre><p>As you can see, the Java code for tables does not use a convenient <code>createMonster</code> call like the C++ code. This is to create the buffer without using temporary object allocation.</p>
+<p>The default string accessor (e.g. <code>monster.name()</code>) currently always create a new Java <code>String</code> when accessed, since FlatBuffer's UTF-8 strings can't be used in-place by <code>String</code>. Alternatively, use <code>monster.nameAsByteBuffer()</code> which returns a <code>ByteBuffer</code> referring to the UTF-8 data in the original <code>ByteBuffer</code>, which is much more efficient. The <code>ByteBuffer</code>'s <code>position</code> points to the first character, and its <code>limit</code> to just after the last.</p>
+<p>Vector access is also a bit different from C++: you pass an extra index to the vector field accessor. Then a second method with the same name suffixed by <code>Length</code> let's you know the number of elements you can access:</p>
+<div class="fragment"><div class="line"><span class="keywordflow">for</span> (<span class="keywordtype">int</span> i = 0; i &lt; monster.inventoryLength(); i++)</div>
+<div class="line">    monster.inventory(i); <span class="comment">// do something here</span></div>
+</div><!-- fragment --><p>Alternatively, much like strings, you can use <code>monster.inventoryAsByteBuffer()</code> to get a <code>ByteBuffer</code> referring to the whole vector. Use <code>ByteBuffer</code> methods like <code>asFloatBuffer</code> to get specific views if needed.</p>
+<p>If you specified a file_indentifier in the schema, you can query if the buffer is of the desired type before accessing it using:</p>
+<div class="fragment"><div class="line"><span class="keywordflow">if</span> (Monster.MonsterBufferHasIdentifier(bb)) ...</div>
+</div><!-- fragment --><h2>Buffer construction in Java</h2>
+<p>You can also construct these buffers in Java using the static methods found in the generated code, and the FlatBufferBuilder class:</p>
+<div class="fragment"><div class="line">FlatBufferBuilder fbb = <span class="keyword">new</span> FlatBufferBuilder();</div>
+</div><!-- fragment --><p>Create strings:</p>
+<div class="fragment"><div class="line"><span class="keywordtype">int</span> str = fbb.createString(<span class="stringliteral">&quot;MyMonster&quot;</span>);</div>
+</div><!-- fragment --><p>Create a table with a struct contained therein:</p>
+<div class="fragment"><div class="line">Monster.startMonster(fbb);</div>
+<div class="line">Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0, (byte)4, (<span class="keywordtype">short</span>)5, (byte)6));</div>
+<div class="line">Monster.addHp(fbb, (short)80);</div>
+<div class="line">Monster.addName(fbb, str);</div>
+<div class="line">Monster.addInventory(fbb, inv);</div>
+<div class="line">Monster.addTest_type(fbb, (byte)1);</div>
+<div class="line">Monster.addTest(fbb, mon2);</div>
+<div class="line">Monster.addTest4(fbb, test4s);</div>
+<div class="line"><span class="keywordtype">int</span> mon = Monster.endMonster(fbb);</div>
+</div><!-- fragment --><p>For some simpler types, you can use a convenient <code>create</code> function call that allows you to construct tables in one function call. This example definition however contains an inline struct field, so we have to create the table manually. This is to create the buffer without using temporary object allocation.</p>
 <p>It's important to understand that fields that are structs are inline (like <code>Vec3</code> above), and MUST thus be created between the start and end calls of a table. Everything else (other tables, strings, vectors) MUST be created before the start of the table they are referenced in.</p>
 <p>Structs do have convenient methods that even have arguments for nested structs.</p>
 <p>As you can see, references to other objects (e.g. the string above) are simple ints, and thus do not have the type-safety of the Offset type in C++. Extra case must thus be taken that you set the right offset on the right field.</p>
-<p>Vectors also use this start/end pattern to allow vectors of both scalar types and structs: </p><pre class="fragment">Monster.startInventoryVector(fbb, 5);
-for (byte i = 4; i &gt;=0; i--) fbb.addByte(i);
-int inv = fbb.endVector();
-</pre><p>You can use the generated method <code>startInventoryVector</code> to conveniently call <code>startVector</code> with the right element size. You pass the number of elements you want to write. You write the elements backwards since the buffer is being constructed back to front.</p>
+<p>Vectors can be created from the corresponding Java array like so:</p>
+<div class="fragment"><div class="line"><span class="keywordtype">int</span> inv = Monster.createInventoryVector(fbb, <span class="keyword">new</span> byte[] { 0, 1, 2, 3, 4 });</div>
+</div><!-- fragment --><p>This works for arrays of scalars and (int) offsets to strings/tables, but not structs. If you want to write structs, or what you want to write does not sit in an array, you can also use the start/end pattern:</p>
+<div class="fragment"><div class="line">Monster.startInventoryVector(fbb, 5);</div>
+<div class="line"><span class="keywordflow">for</span> (byte i = 4; i &gt;=0; i--) fbb.addByte(i);</div>
+<div class="line"><span class="keywordtype">int</span> inv = fbb.endVector();</div>
+</div><!-- fragment --><p>You can use the generated method <code>startInventoryVector</code> to conveniently call <code>startVector</code> with the right element size. You pass the number of elements you want to write. Note how you write the elements backwards since the buffer is being constructed back to front.</p>
 <p>There are <code>add</code> functions for all the scalar types. You use <code>addOffset</code> for any previously constructed objects (such as other tables, strings, vectors). For structs, you use the appropriate <code>create</code> function in-line, as shown above in the <code>Monster</code> example.</p>
+<p>To finish the buffer, call:</p>
+<div class="fragment"><div class="line">Monster.finishMonsterBuffer(fbb, mon);</div>
+</div><!-- fragment --><p>The buffer is now ready to be transmitted. It is contained in the <code>ByteBuffer</code> which you can obtain from <code>fbb.dataBuffer()</code>. Importantly, the valid data does not start from offset 0 in this buffer, but from <code>fbb.dataBuffer().position()</code> (this is because the data was built backwards in memory). It ends at <code>fbb.capacity()</code>.</p>
 <h2>Text Parsing</h2>
 <p>There currently is no support for parsing text (Schema's and JSON) directly from Java, though you could use the C++ parser through JNI. Please see the C++ documentation for more on text parsing. </p>
 </div></div><!-- contents -->

docs/html/md__schemas.html

@@ -111,6 +111,10 @@ root_type Monster;
 <p>Unions share a lot of properties with enums, but instead of new names for constants, you use names of tables. You can then declare a union field which can hold a reference to any of those types, and additionally a hidden field with the suffix <code>_type</code> is generated that holds the corresponding enum value, allowing you to know which type to cast to at runtime.</p>
 <h3>Namespaces</h3>
 <p>These will generate the corresponding namespace in C++ for all helper code, and packages in Java. You can use <code>.</code> to specify nested namespaces / packages.</p>
+<h3>Includes</h3>
+<p>You can include other schemas files in your current one, e.g.: </p><pre class="fragment">include "mydefinitions.fbs"
+</pre><p>This makes it easier to refer to types defined elsewhere. <code>include</code> automatically ensures each file is parsed just once, even when referred to more than once.</p>
+<p>When using the <code>flatc</code> compiler to generate code for schema definitions, only definitions in the current file will be generated, not those from the included files (those you still generate separately).</p>
 <h3>Root type</h3>
 <p>This declares what you consider to be the root table (or struct) of the serialized data. This is particular important for parsing JSON data, which doesn't include object type information.</p>
 <h3>File identification and extension</h3>
@@ -129,6 +133,7 @@ root_type Monster;
 <ul>
 <li><code>id: n</code> (on a table field): manually set the field identifier to <code>n</code>. If you use this attribute, you must use it on ALL fields of this table, and the numbers must be a contiguous range from 0 onwards. Additionally, since a union type effectively adds two fields, its id must be that of the second field (the first field is the type field and not explicitly declared in the schema). For example, if the last field before the union field had id 6, the union field should have id 8, and the unions type field will implicitly be 7. IDs allow the fields to be placed in any order in the schema. When a new field is added to the schema is must use the next available ID.</li>
 <li><code>deprecated</code> (on a field): do not generate accessors for this field anymore, code should stop using this data.</li>
+<li><code>required</code> (on a non-scalar table field): this field must always be set. By default, all fields are optional, i.e. may be left out. This is desirable, as it helps with forwards/backwards compatibility, and flexibility of data structures. It is also a burden on the reading code, since for non-scalar fields it requires you to check against NULL and take appropriate action. By specifying this field, you force code that constructs FlatBuffers to ensure this field is initialized, so the reading code may access it directly, without checking for NULL. If the constructing code does not initialize this field, they will get an assert, and also the verifier will fail on buffers that have missing required fields.</li>
 <li><code>original_order</code> (on a table): since elements in a table do not need to be stored in any particular order, they are often optimized for space by sorting them to size. This attribute stops that from happening.</li>
 <li><code>force_align: size</code> (on a struct): force the alignment of this struct to be something higher than what it is naturally aligned to. Causes these structs to be aligned to that amount inside a buffer, IF that buffer is allocated with that alignment (which is not necessarily the case for buffers accessed directly inside a <code>FlatBufferBuilder</code>).</li>
 <li><code>bit_flags</code> (on an enum): the values of this field indicate bits, meaning that any value N specified in the schema will end up representing 1&lt;&lt;N, or if you don't specify values at all, you'll get the sequence 1, 2, 4, 8, ...</li>
@@ -140,6 +145,20 @@ root_type Monster;
 <li>It accepts field names with and without quotes, like many JSON parsers already do. It outputs them without quotes as well, though can be made to output them using the <code>strict_json</code> flag.</li>
 <li>If a field has an enum type, the parser will recognize symbolic enum values (with or without quotes) instead of numbers, e.g. <code>field: EnumVal</code>. If a field is of integral type, you can still use symbolic names, but values need to be prefixed with their type and need to be quoted, e.g. <code>field: "Enum.EnumVal"</code>. For enums representing flags, you may place multiple inside a string separated by spaces to OR them, e.g. <code>field: "EnumVal1 EnumVal2"</code> or <code>field: "Enum.EnumVal1 Enum.EnumVal2"</code>.</li>
 </ul>
+<p>When parsing JSON, it recognizes the following escape codes in strings:</p>
+<ul>
+<li><code>\n</code> - linefeed.</li>
+<li><code>\t</code> - tab.</li>
+<li><code>\r</code> - carriage return.</li>
+<li><code>\b</code> - backspace.</li>
+<li><code>\f</code> - form feed.</li>
+<li><code>\"</code> - double quote.</li>
+<li><code>\\</code> - backslash.</li>
+<li><code>\/</code> - forward slash.</li>
+<li><code>\uXXXX</code> - 16-bit unicode code point, converted to the equivalent UTF-8 representation.</li>
+<li><code>\xXX</code> - 8-bit binary hexadecimal number XX. This is the only one that is not in the JSON spec (see <a href="http://json.org/">http://json.org/</a>), but is needed to be able to encode arbitrary binary in strings to text and back without losing information (e.g. the byte 0xFF can't be represented in standard JSON).</li>
+</ul>
+<p>It also generates these escape codes back again when generating JSON from a binary representation.</p>
 <h2>Gotchas</h2>
 <h3>Schemas and version control</h3>
 <p>FlatBuffers relies on new field declarations being added at the end, and earlier declarations to not be removed, but be marked deprecated when needed. We think this is an improvement over the manual number assignment that happens in Protocol Buffers (and which is still an option using the <code>id</code> attribute mentioned above).</p>

docs/source/Compiler.md

@@ -2,7 +2,7 @@
 
 Usage:
 
-    flatc [ -c ] [ -j ] [ -b ] [ -t ] [ -o PATH ] [ -S ] FILES...
+    flatc [ -c ] [ -j ] [ -b ] [ -t ] [ -o PATH ] [ -I PATH ] [ -S ] FILES...
           [ -- FILES...]
 
 The files are read and parsed in order, and can contain either schemas
@@ -21,6 +21,10 @@ be generated for each file processed:
 
 -   `-j` : Generate Java classes. Skipped for data.
 
+-   `-n` : Generate C# classes. Skipped for data.
+
+-   `-g` : Generate Go classes. Skipped for data.
+
 -   `-b` : If data is contained in this file, generate a
     `filename.bin` containing the binary flatbuffer.
 
@@ -32,5 +36,23 @@ be generated for each file processed:
     current directory. PATH should end in your systems path separator,
     e.g. `/` or `\`.
 
--   `-S` : Generate strict JSON (field names are enclosed in quotes).
+-   `-I PATH` : when encountering `include` statements, attempt to load the
+    files from this path. Paths will be tried in the order given, and if all
+    fail (or none are specified) it will try to load relative to the path of
+    the schema file being parsed.
+
+-   `--strict-json` : Generate strict JSON (field names are enclosed in quotes).
     By default, no quotes are generated.
+
+-   `--no-prefix` : Don't prefix enum values in generated C++ by their enum
+    type.
+
+-   `--gen-includes` : Generate include statements for included schemas the
+    generated file depends on (C++).
+
+-   `--proto`: Expect input files to be .proto files (protocol buffers).
+    Output the corresponding .fbs file.
+    Currently supports: `package`, `message`, `enum`.
+    Does not support, but will skip without error: `import`, `option`.
+    Does not support, will generate error: `service`, `extend`, `extensions`,
+    `oneof`, `group`, custom options, nested declarations.

docs/source/CppUsage.md

@@ -12,17 +12,21 @@ your program by including the header. As noted, this header relies on
 To start creating a buffer, create an instance of `FlatBufferBuilder`
 which will contain the buffer as it grows:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     FlatBufferBuilder fbb;
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Before we serialize a Monster, we need to first serialize any objects
 that are contained there-in, i.e. we serialize the data tree using
 depth first, pre-order traversal. This is generally easy to do on
 any tree structures. For example:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     auto name = fbb.CreateString("MyMonster");
 
     unsigned char inv[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
     auto inventory = fbb.CreateVector(inv, 10);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 `CreateString` and `CreateVector` serialize these two built-in
 datatypes, and return offsets into the serialized data indicating where
@@ -38,7 +42,9 @@ correct type below. To create a vector of struct objects (which will
 be stored as contiguous memory in the buffer, use `CreateVectorOfStructs`
 instead.
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     Vec3 vec(1, 2, 3);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 `Vec3` is the first example of code from our generated
 header. Structs (unlike tables) translate to simple structs in C++, so
@@ -47,7 +53,9 @@ we can construct them in a familiar way.
 We have now serialized the non-scalar components of of the monster
 example, so we could create the monster something like this:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     auto mloc = CreateMonster(fbb, &vec, 150, 80, name, inventory, Color_Red, 0, Any_NONE);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Note that we're passing `150` for the `mana` field, which happens to be the
 default value: this means the field will not actually be written to the buffer,
@@ -67,12 +75,14 @@ If you want even more control over this (i.e. skip fields even when they are
 not default), instead of the convenient `CreateMonster` call we can also
 build the object field-by-field manually:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     MonsterBuilder mb(fbb);
     mb.add_pos(&vec);
     mb.add_hp(80);
     mb.add_name(name);
     mb.add_inventory(inventory);
     auto mloc = mb.Finish();
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 We start with a temporary helper class `MonsterBuilder` (which is
 defined in our generated code also), then call the various `add_`
@@ -88,7 +98,9 @@ Regardless of whether you used `CreateMonster` or `MonsterBuilder`, you
 now have an offset to the root of your data, and you can finish the
 buffer using:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     FinishMonsterBuffer(fbb, mloc);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The buffer is now ready to be stored somewhere, sent over the network,
 be compressed, or whatever you'd like to do with it. You can access the
@@ -103,33 +115,41 @@ the code above, that also includes the reading code below.
 If you've received a buffer from somewhere (disk, network, etc.) you can
 directly start traversing it using:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     auto monster = GetMonster(buffer_pointer);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 `monster` is of type `Monster *`, and points to somewhere inside your
 buffer. If you look in your generated header, you'll see it has
 convenient accessors for all fields, e.g.
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     assert(monster->hp() == 80);
     assert(monster->mana() == 150);  // default
     assert(strcmp(monster->name()->c_str(), "MyMonster") == 0);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 These should all be true. Note that we never stored a `mana` value, so
 it will return the default.
 
 To access sub-objects, in this case the `Vec3`:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     auto pos = monster->pos();
     assert(pos);
     assert(pos->z() == 3);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 If we had not set the `pos` field during serialization, it would be
 `NULL`.
 
 Similarly, we can access elements of the inventory array:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     auto inv = monster->inventory();
     assert(inv);
     assert(inv->Get(9) == 9);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ### Direct memory access
 
@@ -175,7 +195,9 @@ is accessed, all reads will end up inside the buffer.
 Each root type will have a verification function generated for it,
 e.g. for `Monster`, you can call:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
 	bool ok = VerifyMonsterBuffer(Verifier(buf, len));
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 if `ok` is true, the buffer is safe to read.
 
@@ -188,6 +210,11 @@ a full traversal (since any scalar data is not actually touched),
 and since it may cause the buffer to be brought into cache before
 reading, the actual overhead may be even lower than expected.
 
+In specialized cases where a denial of service attack is possible,
+the verifier has two additional constructor arguments that allow
+you to limit the nesting depth and total amount of tables the
+verifier may encounter before declaring the buffer malformed.
+
 ## Text & schema parsing
 
 Using binary buffers with the generated header provides a super low
@@ -232,11 +259,15 @@ Load text (either a schema or json) into an in-memory buffer (there is a
 convenient `LoadFile()` utility function in `flatbuffers/util.h` if you
 wish). Construct a parser:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     flatbuffers::Parser parser;
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Now you can parse any number of text files in sequence:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.cpp}
     parser.Parse(text_file.c_str());
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 This works similarly to how the command-line compiler works: a sequence
 of files parsed by the same `Parser` object allow later files to
@@ -244,6 +275,10 @@ reference definitions in earlier files. Typically this means you first
 load a schema file (which populates `Parser` with definitions), followed
 by one or more JSON files.
 
+As optional argument to `Parse`, you may specify a null-terminated list of
+include paths. If not specified, any include statements try to resolve from
+the current directory.
+
 If there were any parsing errors, `Parse` will return `false`, and
 `Parser::err` contains a human readable error string with a line number
 etc, which you should present to the creator of that file.

docs/source/GoUsage.md

@@ -7,6 +7,7 @@ See `go_test.go` for an example. You import the generated code, read a
 FlatBuffer binary file into a `[]byte`, which you pass to the
 `GetRootAsMonster` function:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}
     import (
        example "MyGame/Example"
        flatbuffers "github.com/google/flatbuffers/go"
@@ -17,11 +18,14 @@ FlatBuffer binary file into a `[]byte`, which you pass to the
     buf, err := ioutil.ReadFile("monster.dat")
     // handle err
     monster := example.GetRootAsMonster(buf, 0)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Now you can access values like this:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}
     hp := monster.Hp()
     pos := monster.Pos(nil)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Note that whenever you access a new object like in the `Pos` example above,
 a new temporary accessor object gets created. If your code is very performance
@@ -34,21 +38,28 @@ To access vectors you pass an extra index to the
 vector field accessor. Then a second method with the same name suffixed
 by `Length` let's you know the number of elements you can access:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}
     for i := 0; i < monster.InventoryLength(); i++ {
         monster.Inventory(i) // do something here
     }
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You can also construct these buffers in Go using the functions found in the
 generated code, and the FlatBufferBuilder class:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}
     builder := flatbuffers.NewBuilder(0)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Create strings:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}
     str := builder.CreateString("MyMonster")
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Create a table with a struct contained therein:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}
     example.MonsterStart(builder)
     example.MonsterAddPos(builder, example.CreateVec3(builder, 1.0, 2.0, 3.0, 3.0, 4, 5, 6))
     example.MonsterAddHp(builder, 80)
@@ -58,6 +69,7 @@ Create a table with a struct contained therein:
     example.MonsterAddTest(builder, mon2)
     example.MonsterAddTest4(builder, test4s)
     mon := example.MonsterEnd(builder)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Unlike C++, Go does not support table creation functions like 'createMonster()'.
 This is to create the buffer without
@@ -72,11 +84,13 @@ will be `a`, `c` and `d`.
 Vectors also use this start/end pattern to allow vectors of both scalar types
 and structs:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.go}
     example.MonsterStartInventoryVector(builder, 5)
     for i := 4; i >= 0; i-- {
         builder.PrependByte(byte(i))
     }
     inv := builder.EndVector(5)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The generated method 'StartInventoryVector' is provided as a convenience
 function which calls 'StartVector' with the correct element size of the vector

docs/source/Grammar.md

@@ -1,6 +1,9 @@
 # Formal Grammar of the schema language
 
-schema = namespace\_decl | type\_decl | enum\_decl | root\_decl | object
+schema = include*
+         ( namespace\_decl | type\_decl | enum\_decl | root\_decl | object )*
+
+include = `include` string\_constant `;`
 
 namespace\_decl = `namespace` ident ( `.` ident )* `;`
 

docs/source/Internals.md

@@ -159,7 +159,8 @@ Unions share a lot with enums.
     struct Vec3;
     struct Monster;
 
-Predeclare all datatypes since there may be circular references.
+Predeclare all data types since circular references between types are allowed
+(circular references between object are not, though).
 
     MANUALLY_ALIGNED_STRUCT(4) Vec3 {
      private:

docs/source/JavaUsage.md

@@ -1,26 +1,30 @@
 # Use in Java
 
-FlatBuffers supports reading and writing binary FlatBuffers in Java. Generate code
-for Java with the `-j` option to `flatc`.
+FlatBuffers supports reading and writing binary FlatBuffers in Java. Generate
+code for Java with the `-j` option to `flatc`.
 
 See `javaTest.java` for an example. Essentially, you read a FlatBuffer binary
 file into a `byte[]`, which you then turn into a `ByteBuffer`, which you pass to
 the `getRootAsMyRootType` function:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
     ByteBuffer bb = ByteBuffer.wrap(data);
     Monster monster = Monster.getRootAsMonster(bb);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Now you can access values much like C++:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
     short hp = monster.hp();
     Vec3 pos = monster.pos();
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Note that whenever you access a new object like in the `pos` example above,
 a new temporary accessor object gets created. If your code is very performance
 sensitive (you iterate through a lot of objects), there's a second `pos()`
 method to which you can pass a `Vec3` object you've already created. This allows
-you to reuse it across many calls and reduce the amount of object allocation (and
-thus garbage collection) your program does.
+you to reuse it across many calls and reduce the amount of object allocation
+(and thus garbage collection) your program does.
 
 Java does not support unsigned scalars. This means that any unsigned types you
 use in your schema will actually be represented as a signed value. This means
@@ -28,27 +32,52 @@ all bits are still present, but may represent a negative value when used.
 For example, to read a `byte b` as an unsigned number, you can do:
 `(short)(b & 0xFF)`
 
-Sadly the string accessors currently always create a new string when accessed,
-since FlatBuffer's UTF-8 strings can't be read in-place by Java.
+The default string accessor (e.g. `monster.name()`) currently always create
+a new Java `String` when accessed, since FlatBuffer's UTF-8 strings can't be
+used in-place by `String`. Alternatively, use `monster.nameAsByteBuffer()`
+which returns a `ByteBuffer` referring to the UTF-8 data in the original
+`ByteBuffer`, which is much more efficient. The `ByteBuffer`'s `position`
+points to the first character, and its `limit` to just after the last.
 
 Vector access is also a bit different from C++: you pass an extra index
 to the vector field accessor. Then a second method with the same name
 suffixed by `Length` let's you know the number of elements you can access:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
     for (int i = 0; i < monster.inventoryLength(); i++)
         monster.inventory(i); // do something here
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Alternatively, much like strings, you can use `monster.inventoryAsByteBuffer()`
+to get a `ByteBuffer` referring to the whole vector. Use `ByteBuffer` methods
+like `asFloatBuffer` to get specific views if needed.
+
+If you specified a file_indentifier in the schema, you can query if the
+buffer is of the desired type before accessing it using:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
+    if (Monster.MonsterBufferHasIdentifier(bb)) ...
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+## Buffer construction in Java
 
 You can also construct these buffers in Java using the static methods found
 in the generated code, and the FlatBufferBuilder class:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
     FlatBufferBuilder fbb = new FlatBufferBuilder();
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Create strings:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
     int str = fbb.createString("MyMonster");
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Create a table with a struct contained therein:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
     Monster.startMonster(fbb);
     Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0, (byte)4, (short)5, (byte)6));
     Monster.addHp(fbb, (short)80);
@@ -58,10 +87,13 @@ Create a table with a struct contained therein:
     Monster.addTest(fbb, mon2);
     Monster.addTest4(fbb, test4s);
     int mon = Monster.endMonster(fbb);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-As you can see, the Java code for tables does not use a convenient
-`createMonster` call like the C++ code. This is to create the buffer without
-using temporary object allocation.
+For some simpler types, you can use a convenient `create` function call that
+allows you to construct tables in one function call. This example definition
+however contains an inline struct field, so we have to create the table
+manually.
+This is to create the buffer without using temporary object allocation.
 
 It's important to understand that fields that are structs are inline (like
 `Vec3` above), and MUST thus be created between the start and end calls of
@@ -74,23 +106,45 @@ As you can see, references to other objects (e.g. the string above) are simple
 ints, and thus do not have the type-safety of the Offset type in C++. Extra
 case must thus be taken that you set the right offset on the right field.
 
-Vectors also use this start/end pattern to allow vectors of both scalar types
-and structs:
+Vectors can be created from the corresponding Java array like so:
 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
+    int inv = Monster.createInventoryVector(fbb, new byte[] { 0, 1, 2, 3, 4 });
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+This works for arrays of scalars and (int) offsets to strings/tables,
+but not structs. If you want to write structs, or what you want to write
+does not sit in an array, you can also use the start/end pattern:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
     Monster.startInventoryVector(fbb, 5);
     for (byte i = 4; i >=0; i--) fbb.addByte(i);
     int inv = fbb.endVector();
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You can use the generated method `startInventoryVector` to conveniently call
 `startVector` with the right element size. You pass the number of
-elements you want to write. You write the elements backwards since the buffer
-is being constructed back to front.
+elements you want to write. Note how you write the elements backwards since
+the buffer is being constructed back to front.
 
 There are `add` functions for all the scalar types. You use `addOffset` for
 any previously constructed objects (such as other tables, strings, vectors).
 For structs, you use the appropriate `create` function in-line, as shown
 above in the `Monster` example.
 
+To finish the buffer, call:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.java}
+    Monster.finishMonsterBuffer(fbb, mon);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The buffer is now ready to be transmitted. It is contained in the `ByteBuffer`
+which you can obtain from `fbb.dataBuffer()`. Importantly, the valid data does
+not start from offset 0 in this buffer, but from `fbb.dataBuffer().position()`
+(this is because the data was built backwards in memory).
+It ends at `fbb.capacity()`.
+
+
 ## Text Parsing
 
 There currently is no support for parsing text (Schema's and JSON) directly

docs/source/Schemas.md

@@ -141,6 +141,20 @@ These will generate the corresponding namespace in C++ for all helper
 code, and packages in Java. You can use `.` to specify nested namespaces /
 packages.
 
+### Includes
+
+You can include other schemas files in your current one, e.g.:
+
+    include "mydefinitions.fbs"
+
+This makes it easier to refer to types defined elsewhere. `include`
+automatically ensures each file is parsed just once, even when referred to
+more than once.
+
+When using the `flatc` compiler to generate code for schema definitions,
+only definitions in the current file will be generated, not those from the
+included files (those you still generate separately).
+
 ### Root type
 
 This declares what you consider to be the root table (or struct) of the
@@ -218,6 +232,16 @@ Current understood attributes:
     When a new field is added to the schema is must use the next available ID.
 -   `deprecated` (on a field): do not generate accessors for this field
     anymore, code should stop using this data.
+-   `required` (on a non-scalar table field): this field must always be set.
+    By default, all fields are optional, i.e. may be left out. This is
+    desirable, as it helps with forwards/backwards compatibility, and
+    flexibility of data structures. It is also a burden on the reading code,
+    since for non-scalar fields it requires you to check against NULL and
+    take appropriate action. By specifying this field, you force code that
+    constructs FlatBuffers to ensure this field is initialized, so the reading
+    code may access it directly, without checking for NULL. If the constructing
+    code does not initialize this field, they will get an assert, and also
+    the verifier will fail on buffers that have missing required fields.
 -   `original_order` (on a table): since elements in a table do not need
     to be stored in any particular order, they are often optimized for
     space by sorting them to size. This attribute stops that from happening.
@@ -254,6 +278,26 @@ JSON:
     separated by spaces to OR them, e.g.
     `field: "EnumVal1 EnumVal2"` or `field: "Enum.EnumVal1 Enum.EnumVal2"`.
 
+When parsing JSON, it recognizes the following escape codes in strings:
+
+-   `\n` - linefeed.
+-   `\t` - tab.
+-   `\r` - carriage return.
+-   `\b` - backspace.
+-   `\f` - form feed.
+-   `\"` - double quote.
+-   `\\` - backslash.
+-   `\/` - forward slash.
+-   `\uXXXX` - 16-bit unicode code point, converted to the equivalent UTF-8
+    representation.
+-   `\xXX` - 8-bit binary hexadecimal number XX. This is the only one that is
+     not in the JSON spec (see http://json.org/), but is needed to be able to
+     encode arbitrary binary in strings to text and back without losing
+     information (e.g. the byte 0xFF can't be represented in standard JSON).
+
+It also generates these escape codes back again when generating JSON from a
+binary representation.
+
 ## Gotchas
 
 ### Schemas and version control

go/builder.go

@@ -231,9 +231,10 @@ func (b *Builder) PrependUOffsetT(off UOffsetT) {
 // A vector has the following format:
 //   <UOffsetT: number of elements in this vector>
 //   <T: data>+, where T is the type of elements of this vector.
-func (b *Builder) StartVector(elemSize, numElems int) UOffsetT {
+func (b *Builder) StartVector(elemSize, numElems, alignment int) UOffsetT {
 	b.notNested()
 	b.Prep(SizeUint32, elemSize*numElems)
+	b.Prep(alignment, elemSize*numElems) // Just in case alignment > int.
 	return b.Offset()
 }
 

go/table.go

@@ -26,7 +26,6 @@ func (t *Table) Indirect(off UOffsetT) UOffsetT {
 
 // String gets a string from data stored inside the flatbuffer.
 func (t *Table) String(off UOffsetT) string {
-	off += t.Pos
 	off += GetUOffsetT(t.Bytes[off:])
 	start := off + UOffsetT(SizeUOffsetT)
 	length := GetUOffsetT(t.Bytes[off:])

include/flatbuffers/flatbuffers.h

@@ -247,15 +247,25 @@ public:
   typedef VectorIterator<T, false> iterator;
   typedef VectorIterator<T, true> const_iterator;
 
-  uoffset_t Length() const { return EndianScalar(length_); }
+  uoffset_t size() const { return EndianScalar(length_); }
+
+  // Deprecated: use size(). Here for backwards compatibility.
+  uoffset_t Length() const { return size(); }
 
   typedef typename IndirectHelper<T>::return_type return_type;
 
   return_type Get(uoffset_t i) const {
-    assert(i < Length());
+    assert(i < size());
     return IndirectHelper<T>::Read(Data(), i);
   }
 
+  // If this is a Vector of enums, T will be its storage type, not the enum
+  // type. This function makes it convenient to retrieve value with enum
+  // type E.
+  template<typename E> E GetEnum(uoffset_t i) const {
+    return static_cast<E>(Get(i));
+  }
+
   const void *GetStructFromOffset(size_t o) const {
     return reinterpret_cast<const void *>(Data() + o);
   }
@@ -537,6 +547,17 @@ class FlatBufferBuilder {
     return vtableoffsetloc;
   }
 
+  // This checks a required field has been set in a given table that has
+  // just been constructed.
+  template<typename T> void Required(Offset<T> table, voffset_t field) {
+    auto table_ptr = buf_.data_at(table.o);
+    auto vtable_ptr = table_ptr - ReadScalar<uoffset_t>(table_ptr);
+    bool ok = ReadScalar<voffset_t>(vtable_ptr + field) != 0;
+    // If this fails, the caller will show what field needs to be set.
+    assert(ok);
+    (void)ok;
+  }
+
   uoffset_t StartStruct(size_t alignment) {
     Align(alignment);
     return GetSize();
@@ -662,33 +683,39 @@ template<typename T> const T *GetRoot(const void *buf) {
 
 // Helper to see if the identifier in a buffer has the expected value.
 inline bool BufferHasIdentifier(const void *buf, const char *identifier) {
-  return strncmp(reinterpret_cast<const char *>(buf) + 4, identifier,
-                 FlatBufferBuilder::kFileIdentifierLength) == 0;
+  return strncmp(reinterpret_cast<const char *>(buf) + sizeof(uoffset_t),
+                 identifier, FlatBufferBuilder::kFileIdentifierLength) == 0;
 }
 
 // Helper class to verify the integrity of a FlatBuffer
 class Verifier {
  public:
-  Verifier(const uint8_t *buf, size_t buf_len)
-    : buf_(buf), end_(buf + buf_len)
+  Verifier(const uint8_t *buf, size_t buf_len, size_t _max_depth = 64,
+           size_t _max_tables = 1000000)
+    : buf_(buf), end_(buf + buf_len), depth_(0), max_depth_(_max_depth),
+      num_tables_(0), max_tables_(_max_tables)
     {}
 
-  // Verify any range within the buffer.
-  bool Verify(const void *elem, size_t elem_len) const {
-    bool ok = elem >= buf_ && elem <= end_ - elem_len;
+  // Central location where any verification failures register.
+  bool Check(bool ok) const {
     #ifdef FLATBUFFERS_DEBUG_VERIFICATION_FAILURE
       assert(ok);
     #endif
     return ok;
   }
 
+  // Verify any range within the buffer.
+  bool Verify(const void *elem, size_t elem_len) const {
+    return Check(elem >= buf_ && elem <= end_ - elem_len);
+  }
+
   // Verify a range indicated by sizeof(T).
   template<typename T> bool Verify(const void *elem) const {
     return Verify(elem, sizeof(T));
   }
 
   // Verify a pointer (may be NULL) of a table type.
-  template<typename T> bool VerifyTable(const T *table) const {
+  template<typename T> bool VerifyTable(const T *table) {
     return !table || table->Verify(*this);
   }
 
@@ -705,8 +732,8 @@ class Verifier {
     const uint8_t *end;
     return !str ||
            (VerifyVector(reinterpret_cast<const uint8_t *>(str), 1, &end) &&
-            Verify(end, 1) &&  // Must have terminator
-            *end == '\0');  // Terminating byte must be 0.
+            Verify(end, 1) &&      // Must have terminator
+            Check(*end == '\0'));  // Terminating byte must be 0.
   }
 
   // Common code between vectors and strings.
@@ -725,7 +752,7 @@ class Verifier {
   // Special case for string contents, after the above has been called.
   bool VerifyVectorOfStrings(const Vector<Offset<String>> *vec) const {
       if (vec) {
-        for (uoffset_t i = 0; i < vec->Length(); i++) {
+        for (uoffset_t i = 0; i < vec->size(); i++) {
           if (!Verify(vec->Get(i))) return false;
         }
       }
@@ -733,10 +760,9 @@ class Verifier {
   }
 
   // Special case for table contents, after the above has been called.
-  template<typename T> bool VerifyVectorOfTables(const Vector<Offset<T>> *vec)
-      const {
+  template<typename T> bool VerifyVectorOfTables(const Vector<Offset<T>> *vec) {
     if (vec) {
-      for (uoffset_t i = 0; i < vec->Length(); i++) {
+      for (uoffset_t i = 0; i < vec->size(); i++) {
         if (!vec->Get(i)->Verify(*this)) return false;
       }
     }
@@ -744,16 +770,36 @@ class Verifier {
   }
 
   // Verify this whole buffer, starting with root type T.
-  template<typename T> bool VerifyBuffer() const {
+  template<typename T> bool VerifyBuffer() {
     // Call T::Verify, which must be in the generated code for this type.
     return Verify<uoffset_t>(buf_) &&
       reinterpret_cast<const T *>(buf_ + ReadScalar<uoffset_t>(buf_))->
         Verify(*this);
   }
 
+  // Called at the start of a table to increase counters measuring data
+  // structure depth and amount, and possibly bails out with false if
+  // limits set by the constructor have been hit. Needs to be balanced
+  // with EndTable().
+  bool VerifyComplexity() {
+    depth_++;
+    num_tables_++;
+    return Check(depth_ <= max_depth_ && num_tables_ <= max_tables_);
+  }
+
+  // Called at the end of a table to pop the depth count.
+  bool EndTable() {
+    depth_--;
+    return true;
+  }
+
  private:
   const uint8_t *buf_;
   const uint8_t *end_;
+  size_t depth_;
+  size_t max_depth_;
+  size_t num_tables_;
+  size_t max_tables_;
 };
 
 // "structs" are flat structures that do not have an offset table, thus
@@ -828,12 +874,13 @@ class Table {
 
   // Verify the vtable of this table.
   // Call this once per table, followed by VerifyField once per field.
-  bool VerifyTable(const Verifier &verifier) const {
+  bool VerifyTableStart(Verifier &verifier) const {
     // Check the vtable offset.
     if (!verifier.Verify<soffset_t>(data_)) return false;
     auto vtable = data_ - ReadScalar<soffset_t>(data_);
     // Check the vtable size field, then check vtable fits in its entirety.
-    return verifier.Verify<voffset_t>(vtable) &&
+    return verifier.VerifyComplexity() &&
+           verifier.Verify<voffset_t>(vtable) &&
            verifier.Verify(vtable, ReadScalar<voffset_t>(vtable));
   }
 
@@ -847,6 +894,14 @@ class Table {
     return !field_offset || verifier.Verify<T>(data_ + field_offset);
   }
 
+  // VerifyField for required fields.
+  template<typename T> bool VerifyFieldRequired(const Verifier &verifier,
+                                        voffset_t field) const {
+    auto field_offset = GetOptionalFieldOffset(field);
+    return verifier.Check(field_offset != 0) &&
+           verifier.Verify<T>(data_ + field_offset);
+  }
+
  private:
   // private constructor & copy constructor: you obtain instances of this
   // class by pointing to existing data only

include/flatbuffers/idl.h

@@ -19,6 +19,7 @@
 
 #include <map>
 #include <memory>
+#include <functional>
 
 #include "flatbuffers/flatbuffers.h"
 
@@ -31,31 +32,38 @@ namespace flatbuffers {
 // Additionally, Parser::ParseType assumes bool..string is a contiguous range
 // of type tokens.
 #define FLATBUFFERS_GEN_TYPES_SCALAR(TD) \
-  TD(NONE,   "",       uint8_t,  byte,   byte) \
-  TD(UTYPE,  "",       uint8_t,  byte,   byte) /* begin scalars, ints */ \
-  TD(BOOL,   "bool",   uint8_t,  byte,   byte) \
-  TD(CHAR,   "byte",   int8_t,   byte,   int8) \
-  TD(UCHAR,  "ubyte",  uint8_t,  byte,   byte) \
-  TD(SHORT,  "short",  int16_t,  short,  int16) \
-  TD(USHORT, "ushort", uint16_t, short,  uint16) \
-  TD(INT,    "int",    int32_t,  int,    int32) \
-  TD(UINT,   "uint",   uint32_t, int,    uint32) \
-  TD(LONG,   "long",   int64_t,  long,   int64) \
-  TD(ULONG,  "ulong",  uint64_t, long,   uint64) /* end ints */ \
-  TD(FLOAT,  "float",  float,    float,  float32) /* begin floats */ \
-  TD(DOUBLE, "double", double,   double, float64) /* end floats, scalars */
+  TD(NONE,   "",       uint8_t,  byte,   byte,    byte) \
+  TD(UTYPE,  "",       uint8_t,  byte,   byte,    byte) /* begin scalar/int */ \
+  TD(BOOL,   "bool",   uint8_t,  byte,   byte,    byte) \
+  TD(CHAR,   "byte",   int8_t,   byte,   int8,    sbyte) \
+  TD(UCHAR,  "ubyte",  uint8_t,  byte,   byte,    byte) \
+  TD(SHORT,  "short",  int16_t,  short,  int16,   short) \
+  TD(USHORT, "ushort", uint16_t, short,  uint16,  ushort) \
+  TD(INT,    "int",    int32_t,  int,    int32,   int) \
+  TD(UINT,   "uint",   uint32_t, int,    uint32,  uint) \
+  TD(LONG,   "long",   int64_t,  long,   int64,   long) \
+  TD(ULONG,  "ulong",  uint64_t, long,   uint64,  ulong)  /* end int */ \
+  TD(FLOAT,  "float",  float,    float,  float32, float)  /* begin float */ \
+  TD(DOUBLE, "double", double,   double, float64, double) /* end float/scalar */
 #define FLATBUFFERS_GEN_TYPES_POINTER(TD) \
-  TD(STRING, "string", Offset<void>, int, int) \
-  TD(VECTOR, "",       Offset<void>, int, int) \
-  TD(STRUCT, "",       Offset<void>, int, int) \
-  TD(UNION,  "",       Offset<void>, int, int)
+  TD(STRING, "string", Offset<void>, int, int, int) \
+  TD(VECTOR, "",       Offset<void>, int, int, int) \
+  TD(STRUCT, "",       Offset<void>, int, int, int) \
+  TD(UNION,  "",       Offset<void>, int, int, int)
 
+// The fields are:
+// - enum
+// - FlatBuffers schema type.
+// - C++ type.
+// - Java type.
+// - Go type.
+// - C# / .Net type.
 
 // using these macros, we can now write code dealing with types just once, e.g.
 
 /*
 switch (type) {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
     case BASE_TYPE_ ## ENUM: \
       // do something specific to CTYPE here
     FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
@@ -72,12 +80,13 @@ switch (type) {
 __extension__  // Stop GCC complaining about trailing comma with -Wpendantic.
 #endif
 enum BaseType {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) BASE_TYPE_ ## ENUM,
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
+      BASE_TYPE_ ## ENUM,
     FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
   #undef FLATBUFFERS_TD
 };
 
-#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
     static_assert(sizeof(CTYPE) <= sizeof(largest_scalar_t), \
                   "define largest_scalar_t as " #CTYPE);
   FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
@@ -159,22 +168,30 @@ template<typename T> class SymbolTable {
   std::vector<T *> vec;  // Used to iterate in order of insertion
 };
 
+// A name space, as set in the schema.
+struct Namespace {
+  std::vector<std::string> components;
+};
+
 // Base class for all definition types (fields, structs_, enums_).
 struct Definition {
-  Definition() : generated(false) {}
+  Definition() : generated(false), defined_namespace(nullptr) {}
 
   std::string name;
-  std::string doc_comment;
+  std::vector<std::string> doc_comment;
   SymbolTable<Value> attributes;
   bool generated;  // did we already output code for this definition?
+  Namespace *defined_namespace;  // Where it was defined.
 };
 
 struct FieldDef : public Definition {
-  FieldDef() : deprecated(false), padding(0) {}
+  FieldDef() : deprecated(false), required(false), padding(0), used(false) {}
 
   Value value;
   bool deprecated;
-  size_t padding;  // bytes to always pad after this field
+  bool required;
+  size_t padding;  // Bytes to always pad after this field.
+  bool used;       // Used during JSON parsing to check for repeated fields.
 };
 
 struct StructDef : public Definition {
@@ -217,7 +234,7 @@ struct EnumVal {
     : name(_name), value(_val), struct_def(nullptr) {}
 
   std::string name;
-  std::string doc_comment;
+  std::vector<std::string> doc_comment;
   int64_t value;
   StructDef *struct_def;  // only set if this is a union
 };
@@ -225,8 +242,10 @@ struct EnumVal {
 struct EnumDef : public Definition {
   EnumDef() : is_union(false) {}
 
-  EnumVal *ReverseLookup(int enum_idx) {
-    for (auto it = vals.vec.begin() + 1; it != vals.vec.end(); ++it) {
+  EnumVal *ReverseLookup(int enum_idx, bool skip_union_default = true) {
+    for (auto it = vals.vec.begin() + static_cast<int>(is_union &&
+                                                       skip_union_default);
+             it != vals.vec.end(); ++it) {
       if ((*it)->value == enum_idx) {
         return *it;
       }
@@ -241,23 +260,46 @@ struct EnumDef : public Definition {
 
 class Parser {
  public:
-  Parser() :
+  Parser(bool proto_mode = false) :
     root_struct_def(nullptr),
     source_(nullptr),
     cursor_(nullptr),
-    line_(1) {}
+    line_(1),
+    proto_mode_(proto_mode) {
+      // Just in case none are declared:
+      namespaces_.push_back(new Namespace());
+  }
+
+  ~Parser() {
+    for (auto it = namespaces_.begin(); it != namespaces_.end(); ++it) {
+      delete *it;
+    }
+  }
 
   // Parse the string containing either schema or JSON data, which will
   // populate the SymbolTable's or the FlatBufferBuilder above.
-  bool Parse(const char *_source);
+  // include_paths is used to resolve any include statements, and typically
+  // should at least include the project path (where you loaded source_ from).
+  // include_paths must be nullptr terminated if specified.
+  // If include_paths is nullptr, it will attempt to load from the current
+  // directory.
+  // If the source was loaded from a file and isn't an include file,
+  // supply its name in source_filename.
+  bool Parse(const char *_source, const char **include_paths = nullptr,
+             const char *source_filename = nullptr);
 
   // Set the root type. May override the one set in the schema.
   bool SetRootType(const char *name);
 
+  // Mark all definitions as already having code generated.
+  void MarkGenerated();
+
  private:
+  int64_t ParseHexNum(int nibbles);
   void Next();
   bool IsNext(int t);
   void Expect(int t);
+  void ParseTypeIdent(Type &type);
   void ParseType(Type &type);
   FieldDef &AddField(StructDef &struct_def,
                      const std::string &name,
@@ -274,12 +316,16 @@ class Parser {
   int64_t ParseIntegerFromString(Type &type);
   StructDef *LookupCreateStruct(const std::string &name);
   void ParseEnum(bool is_union);
+  void ParseNamespace();
+  StructDef &StartStruct();
   void ParseDecl();
+  void ParseProtoDecl();
+  Type ParseTypeFromProtoType();
 
  public:
   SymbolTable<StructDef> structs_;
   SymbolTable<EnumDef> enums_;
-  std::vector<std::string> name_space_;  // As set in the schema.
+  std::vector<Namespace *> namespaces_;
   std::string error_;         // User readable error_ if Parse() == false
 
   FlatBufferBuilder builder_;  // any data contained in the file
@@ -287,41 +333,44 @@ class Parser {
   std::string file_identifier_;
   std::string file_extension_;
 
+  std::map<std::string, bool> included_files_;
+
  private:
   const char *source_, *cursor_;
   int line_;  // the current line being parsed
   int token_;
-  std::string attribute_, doc_comment_;
+  bool proto_mode_;
+  std::string attribute_;
+  std::vector<std::string> doc_comment_;
 
   std::vector<std::pair<Value, FieldDef *>> field_stack_;
   std::vector<uint8_t> struct_stack_;
 };
 
-// Utility functions for generators:
+// Utility functions for multiple generators:
 
-// Convert an underscore_based_indentifier in to camelCase.
-// Also uppercases the first character if first is true.
-inline std::string MakeCamel(const std::string &in, bool first = true) {
-  std::string s;
-  for (size_t i = 0; i < in.length(); i++) {
-    if (!i && first)
-      s += static_cast<char>(toupper(in[0]));
-    else if (in[i] == '_' && i + 1 < in.length())
-      s += static_cast<char>(toupper(in[++i]));
-    else
-      s += in[i];
-  }
-  return s;
-}
+extern std::string MakeCamel(const std::string &in, bool first = true);
+extern void GenComment(const std::vector<std::string> &dc,
+                       std::string *code_ptr,
+                       const char *prefix = "");
 
 // Container of options that may apply to any of the source/text generators.
 struct GeneratorOptions {
   bool strict_json;
   int indent_step;
   bool output_enum_identifiers;
+  bool prefixed_enums;
+  bool include_dependence_headers;
+
+  // Possible options for the more general generator below.
+  enum Language { kJava, kCSharp, kMAX };
+
+  Language lang;
 
   GeneratorOptions() : strict_json(false), indent_step(2),
-                       output_enum_identifiers(true) {}
+                       output_enum_identifiers(true), prefixed_enums(true),
+                       include_dependence_headers(false),
+                       lang(GeneratorOptions::kJava) {}
 };
 
 // Generate text (JSON) from a given FlatBuffer, and a given Parser
@@ -338,7 +387,8 @@ extern void GenerateText(const Parser &parser,
 // Generate a C++ header from the definitions in the Parser object.
 // See idl_gen_cpp.
 extern std::string GenerateCPP(const Parser &parser,
-                               const std::string &include_guard_ident);
+                               const std::string &include_guard_ident,
+                               const GeneratorOptions &opts);
 extern bool GenerateCPP(const Parser &parser,
                         const std::string &path,
                         const std::string &file_name,
@@ -358,6 +408,30 @@ extern bool GenerateJava(const Parser &parser,
                          const std::string &file_name,
                          const GeneratorOptions &opts);
 
+// Generate C# files from the definitions in the Parser object.
+// See idl_gen_csharp.cpp.
+extern bool GenerateCSharp(const Parser &parser,
+                           const std::string &path,
+                           const std::string &file_name,
+                           const GeneratorOptions &opts);
+
+// Generate Java/C#/.. files from the definitions in the Parser object.
+// See idl_gen_general.cpp.
+extern bool GenerateGeneral(const Parser &parser,
+                            const std::string &path,
+                            const std::string &file_name,
+                            const GeneratorOptions &opts);
+
+// Generate a schema file from the internal representation, useful after
+// parsing a .proto schema.
+extern std::string GenerateFBS(const Parser &parser,
+                               const std::string &file_name,
+                               const GeneratorOptions &opts);
+extern bool GenerateFBS(const Parser &parser,
+                        const std::string &path,
+                        const std::string &file_name,
+                        const GeneratorOptions &opts);
+
 }  // namespace flatbuffers
 
 #endif  // FLATBUFFERS_IDL_H_

include/flatbuffers/util.h

@@ -22,16 +22,24 @@
 #include <string>
 #include <sstream>
 #include <stdlib.h>
+#include <assert.h>
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+  #define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef NOMINMAX
+  #define NOMINMAX
+#endif
+#include <windows.h>
+#include <winbase.h>
+#include <direct.h>
+#else
+#include <sys/stat.h>
+#include <limits.h>
+#endif
 
 namespace flatbuffers {
 
-static const char kPosixPathSeparator = '/';
-#ifdef _WIN32
-static const char kPathSeparator = '\\';
-#else
-static const char kPathSeparator = kPosixPathSeparator;
-#endif // _WIN32
-
 // Convert an integer or floating point value to a string.
 // In contrast to std::stringstream, "char" values are
 // converted to a string of digits.
@@ -51,13 +59,11 @@ template<> inline std::string NumToString<unsigned char>(unsigned char t) {
 }
 
 // Convert an integer value to a hexadecimal string.
-// The returned string length is the number of nibbles in
-// the supplied value prefixed by 0 digits.  For example,
-// IntToStringHex(static_cast<int>(0x23)) returns the
-// string "00000023".
-template<typename T> std::string IntToStringHex(T i) {
+// The returned string length is always xdigits long, prefixed by 0 digits.
+// For example, IntToStringHex(0x23, 8) returns the string "00000023".
+inline std::string IntToStringHex(int i, int xdigits) {
   std::stringstream ss;
-  ss << std::setw(sizeof(T) * 2)
+  ss << std::setw(xdigits)
      << std::setfill('0')
      << std::hex
      << std::uppercase
@@ -66,11 +72,11 @@ template<typename T> std::string IntToStringHex(T i) {
 }
 
 // Portable implementation of strtoull().
-inline int64_t StringToInt(const char *str) {
+inline int64_t StringToInt(const char *str, int base = 10) {
   #ifdef _MSC_VER
-    return _strtoui64(str, nullptr, 10);
+    return _strtoui64(str, nullptr, base);
   #else
-    return strtoull(str, nullptr, 10);
+    return strtoull(str, nullptr, base);
   #endif
 }
 
@@ -107,6 +113,127 @@ inline bool SaveFile(const char *name, const std::string &buf, bool binary) {
   return SaveFile(name, buf.c_str(), buf.size(), binary);
 }
 
+// Functionality for minimalistic portable path handling:
+
+static const char kPosixPathSeparator = '/';
+#ifdef _WIN32
+static const char kPathSeparator = '\\';
+static const char *PathSeparatorSet = "\\/";  // Intentionally no ':'
+#else
+static const char kPathSeparator = kPosixPathSeparator;
+static const char *PathSeparatorSet = "/";
+#endif // _WIN32
+
+// Returns the path with the extension, if any, removed.
+inline std::string StripExtension(const std::string &filepath) {
+  size_t i = filepath.find_last_of(".");
+  return i != std::string::npos ? filepath.substr(0, i) : filepath;
+}
+
+// Return the last component of the path, after the last separator.
+inline std::string StripPath(const std::string &filepath) {
+  size_t i = filepath.find_last_of(PathSeparatorSet);
+  return i != std::string::npos ? filepath.substr(i + 1) : filepath;
+}
+
+// Strip the last component of the path + separator.
+inline std::string StripFileName(const std::string &filepath) {
+  size_t i = filepath.find_last_of(PathSeparatorSet);
+  return i != std::string::npos ? filepath.substr(0, i) : "";
+}
+
+// Concatenates a path with a filename, regardless of wether the path
+// ends in a separator or not.
+inline std::string ConCatPathFileName(const std::string &path,
+                                      const std::string &filename) {
+  std::string filepath = path;
+  if (path.length() && path.back() != kPathSeparator &&
+                       path.back() != kPosixPathSeparator)
+    filepath += kPathSeparator;
+  filepath += filename;
+  return filepath;
+}
+
+// This function ensure a directory exists, by recursively
+// creating dirs for any parts of the path that don't exist yet.
+inline void EnsureDirExists(const std::string &filepath) {
+  auto parent = StripFileName(filepath);
+  if (parent.length()) EnsureDirExists(parent);
+  #ifdef _WIN32
+    _mkdir(filepath.c_str());
+  #else
+    mkdir(filepath.c_str(), S_IRWXU|S_IRGRP|S_IXGRP);
+  #endif
+}
+
+// Obtains the absolute path from any other path.
+// Returns the input path if the absolute path couldn't be resolved.
+inline std::string AbsolutePath(const std::string &filepath) {
+  #ifdef _WIN32
+    char abs_path[MAX_PATH];
+    return GetFullPathNameA(filepath.c_str(), MAX_PATH, abs_path, nullptr)
+  #else
+    char abs_path[PATH_MAX];
+    return realpath(filepath.c_str(), abs_path)
+  #endif
+    ? abs_path
+    : filepath;
+}
+
+// To and from UTF-8 unicode conversion functions
+
+// Convert a unicode code point into a UTF-8 representation by appending it
+// to a string. Returns the number of bytes generated.
+inline int ToUTF8(uint32_t ucc, std::string *out) {
+  assert(!(ucc & 0x80000000));  // Top bit can't be set.
+  // 6 possible encodings: http://en.wikipedia.org/wiki/UTF-8
+  for (int i = 0; i < 6; i++) {
+    // Max bits this encoding can represent.
+    uint32_t max_bits = 6 + i * 5 + static_cast<int>(!i);
+    if (ucc < (1u << max_bits)) {  // does it fit?
+      // Remaining bits not encoded in the first byte, store 6 bits each
+      uint32_t remain_bits = i * 6;
+      // Store first byte:
+      (*out) += static_cast<char>((0xFE << (max_bits - remain_bits)) |
+                                 (ucc >> remain_bits));
+      // Store remaining bytes:
+      for (int j = i - 1; j >= 0; j--) {
+        (*out) += static_cast<char>(((ucc >> (j * 6)) & 0x3F) | 0x80);
+      }
+      return i + 1;  // Return the number of bytes added.
+    }
+  }
+  assert(0);  // Impossible to arrive here.
+  return -1;
+}
+
+// Converts whatever prefix of the incoming string corresponds to a valid
+// UTF-8 sequence into a unicode code. The incoming pointer will have been
+// advanced past all bytes parsed.
+// returns -1 upon corrupt UTF-8 encoding (ignore the incoming pointer in
+// this case).
+inline int FromUTF8(const char **in) {
+  int len = 0;
+  // Count leading 1 bits.
+  for (int mask = 0x80; mask >= 0x04; mask >>= 1) {
+    if (**in & mask) {
+      len++;
+    } else {
+      break;
+    }
+  }
+  if ((**in << len) & 0x80) return -1;  // Bit after leading 1's must be 0.
+  if (!len) return *(*in)++;
+  // Grab initial bits of the code.
+  int ucc = *(*in)++ & ((1 << (7 - len)) - 1);
+  for (int i = 0; i < len - 1; i++) {
+    if ((**in & 0xC0) != 0x80) return -1;  // Upper bits must 1 0.
+    ucc <<= 6;
+    ucc |= *(*in)++ & 0x3F;  // Grab 6 more bits of the code.
+  }
+  return ucc;
+}
+
 }  // namespace flatbuffers
 
 #endif  // FLATBUFFERS_UTIL_H_

java/com/google/flatbuffers/Constants.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.flatbuffers;
+
+// Class that holds shared constants.
+
+public class Constants {
+    // Java doesn't seem to have these.
+    static final int SIZEOF_SHORT = 2;
+    static final int SIZEOF_INT = 4;
+    static final int FILE_IDENTIFIER_LENGTH = 4;
+}
+

java/com/google/flatbuffers/FlatBufferBuilder.java

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-package flatbuffers;
+package com.google.flatbuffers;
 
-import java.lang.String;
+import static com.google.flatbuffers.Constants.*;
 import java.util.Arrays;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
@@ -30,47 +30,50 @@ public class FlatBufferBuilder {
     int space;           // Remaining space in the ByteBuffer.
     static final Charset utf8charset = Charset.forName("UTF-8");
     int minalign = 1;    // Minimum alignment encountered so far.
-    int[] vtable;        // The vtable for the current table, null otherwise.
+    int[] vtable = null; // The vtable for the current table, null otherwise.
     int object_start;    // Starting offset of the current struct/table.
     int[] vtables = new int[16];  // List of offsets of all vtables.
     int num_vtables = 0;          // Number of entries in `vtables` in use.
     int vector_num_elems = 0;     // For the current vector being built.
 
-    // Java doesn't seem to have these.
-    final int SIZEOF_SHORT = 2;
-    final int SIZEOF_INT = 4;
-
     // Start with a buffer of size `initial_size`, then grow as required.
     public FlatBufferBuilder(int initial_size) {
         if (initial_size <= 0) initial_size = 1;
         space = initial_size;
-        bb = newByteBuffer(new byte[initial_size]);
+        bb = newByteBuffer(initial_size);
     }
 
-    ByteBuffer newByteBuffer(byte[] buf) {
-        ByteBuffer newbb = ByteBuffer.wrap(buf);
+    // Alternative constructor allowing reuse of ByteBuffers
+    public FlatBufferBuilder(ByteBuffer existing_bb) {
+        bb = existing_bb;
+        bb.clear();
+        bb.order(ByteOrder.LITTLE_ENDIAN);
+        space = bb.capacity();
+    }
+
+    static ByteBuffer newByteBuffer(int capacity) {
+        ByteBuffer newbb = ByteBuffer.allocate(capacity);
         newbb.order(ByteOrder.LITTLE_ENDIAN);
         return newbb;
     }
 
     // Doubles the size of the ByteBuffer, and copies the old data towards the
     // end of the new buffer (since we build the buffer backwards).
-    ByteBuffer growByteBuffer(ByteBuffer bb) {
-        byte[] old_buf = bb.array();
-        int old_buf_size = old_buf.length;
+    static ByteBuffer growByteBuffer(ByteBuffer bb) {
+        int old_buf_size = bb.capacity();
         if ((old_buf_size & 0xC0000000) != 0)  // Ensure we don't grow beyond what fits in an int.
             throw new AssertionError("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
         int new_buf_size = old_buf_size << 1;
-        byte[] new_buf = new byte[new_buf_size];
-        System.arraycopy(old_buf, 0, new_buf, new_buf_size - old_buf_size, old_buf_size);
-        ByteBuffer nbb = newByteBuffer(new_buf);
-        nbb.position(bb.position());
+        bb.position(0);
+        ByteBuffer nbb = newByteBuffer(new_buf_size);
+        nbb.position(new_buf_size - old_buf_size);
+        nbb.put(bb);
         return nbb;
     }
 
     // Offset relative to the end of the buffer.
     public int offset() {
-        return bb.array().length - space;
+        return bb.capacity() - space;
     }
 
     public void pad(int byte_size) {
@@ -87,12 +90,12 @@ public class FlatBufferBuilder {
         if (size > minalign) minalign = size;
         // Find the amount of alignment needed such that `size` is properly
         // aligned after `additional_bytes`
-        int align_size = ((~(bb.array().length - space + additional_bytes)) + 1) & (size - 1);
+        int align_size = ((~(bb.capacity() - space + additional_bytes)) + 1) & (size - 1);
         // Reallocate the buffer if needed.
         while (space < align_size + size + additional_bytes) {
-            int old_buf_size = bb.array().length;
+            int old_buf_size = bb.capacity();
             bb = growByteBuffer(bb);
-            space += bb.array().length - old_buf_size;
+            space += bb.capacity() - old_buf_size;
         }
         pad(align_size);
     }
@@ -139,7 +142,8 @@ public class FlatBufferBuilder {
         byte[] utf8 = s.getBytes(utf8charset);
         addByte((byte)0);
         startVector(1, utf8.length, 1);
-        System.arraycopy(utf8, 0, bb.array(), space -= utf8.length, utf8.length);
+        bb.position(space -= utf8.length);
+        bb.put(utf8, 0, utf8.length);
         return endVector();
     }
 
@@ -205,7 +209,7 @@ public class FlatBufferBuilder {
         int existing_vtable = 0;
         outer_loop:
         for (int i = 0; i < num_vtables; i++) {
-            int vt1 = bb.array().length - vtables[i];
+            int vt1 = bb.capacity() - vtables[i];
             int vt2 = space;
             short len = bb.getShort(vt1);
             if (len == bb.getShort(vt2)) {
@@ -222,7 +226,7 @@ public class FlatBufferBuilder {
         if (existing_vtable != 0) {
             // Found a match:
             // Remove the current vtable.
-            space = bb.array().length - vtableloc;
+            space = bb.capacity() - vtableloc;
             // Point table to existing vtable.
             bb.putInt(space, existing_vtable - vtableloc);
         } else {
@@ -231,27 +235,64 @@ public class FlatBufferBuilder {
             if (num_vtables == vtables.length) vtables = Arrays.copyOf(vtables, num_vtables * 2);
             vtables[num_vtables++] = offset();
             // Point table to current vtable.
-            bb.putInt(bb.array().length - vtableloc, offset() - vtableloc);
+            bb.putInt(bb.capacity() - vtableloc, offset() - vtableloc);
         }
 
         vtable = null;
         return vtableloc;
     }
 
+    // This checks a required field has been set in a given table that has
+    // just been constructed.
+    public void required(int table, int field) {
+        int table_start = bb.capacity() - table;
+        int vtable_start = table_start - bb.getInt(table_start);
+        boolean ok = bb.getShort(vtable_start + field) != 0;
+        // If this fails, the caller will show what field needs to be set.
+        if (!ok)
+            throw new AssertionError("FlatBuffers: field " + field + " must be set");
+    }
+
     public void finish(int root_table) {
         prep(minalign, SIZEOF_INT);
         addOffset(root_table);
+        bb.position(space);
     }
 
+    public void finish(int root_table, String file_identifier) {
+        prep(minalign, SIZEOF_INT + FILE_IDENTIFIER_LENGTH);
+        if (file_identifier.length() != FILE_IDENTIFIER_LENGTH)
+            throw new AssertionError("FlatBuffers: file identifier must be length " +
+                                     FILE_IDENTIFIER_LENGTH);
+        for (int i = FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {
+            addByte((byte)file_identifier.charAt(i));
+        }
+        finish(root_table);
+    }
+
+    // Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+    // called finish(). The actual data starts at the ByteBuffer's current position,
+    // not necessarily at 0.
     public ByteBuffer dataBuffer() { return bb; }
 
-    // The FlatBuffer data doesn't start at offset 0 in the ByteBuffer:
-    public int dataStart() {
+    // The FlatBuffer data doesn't start at offset 0 in the ByteBuffer,
+    // but now the ByteBuffer's position is set to that location upon
+    // finish(). This method should not be needed anymore, but is left
+    // here as private for the moment to document this API change.
+    // It will be removed in the future.
+    private int dataStart() {
         return space;
     }
 
+    public byte[] sizedByteArray(int start, int length){
+        byte[] array = new byte[length];
+        bb.position(start);
+        bb.get(array);
+        return array;
+    }
+
     // Utility function for copying a byte array that starts at 0.
     public byte[] sizedByteArray() {
-        return Arrays.copyOfRange(bb.array(), dataStart(), bb.array().length);
+        return sizedByteArray(space, bb.capacity() - space);
     }
 }

java/com/google/flatbuffers/Struct.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package flatbuffers;
+package com.google.flatbuffers;
 
 import java.nio.ByteBuffer;
 

java/com/google/flatbuffers/Table.java

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-package flatbuffers;
+package com.google.flatbuffers;
 
-import java.lang.String;
+import static com.google.flatbuffers.Constants.*;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 
@@ -25,8 +25,6 @@ public class Table {
   protected int bb_pos;
   protected ByteBuffer bb;
 
-  final int SIZEOF_INT = 4;
-
   // Look up a field in the vtable, return an offset into the object, or 0 if the field is not
   // present.
   protected int __offset(int vtable_offset) {
@@ -40,9 +38,24 @@ public class Table {
   }
 
   // Create a java String from UTF-8 data stored inside the flatbuffer.
+  // This allocates a new string and converts to wide chars upon each access,
+  // which is not very efficient. Instead, each FlatBuffer string also comes with an
+  // accessor based on __vector_as_bytebuffer below, which is much more efficient,
+  // assuming your Java program can handle UTF-8 data directly.
   protected String __string(int offset) {
     offset += bb.getInt(offset);
-    return new String(bb.array(), offset + SIZEOF_INT, bb.getInt(offset), Charset.forName("UTF-8"));
+    if (bb.hasArray()) {
+      return new String(bb.array(), offset + SIZEOF_INT, bb.getInt(offset), Charset.forName("UTF-8"));
+    } else {
+      // We can't access .array(), since the ByteBuffer is read-only.
+      // We're forced to make an extra copy:
+      byte[] copy = new byte[bb.getInt(offset)];
+      int old_pos = bb.position();
+      bb.position(offset + SIZEOF_INT);
+      bb.get(copy);
+      bb.position(old_pos);
+      return new String(copy, 0, copy.length, Charset.forName("UTF-8"));
+    }
   }
 
   // Get the length of a vector whose offset is stored at "offset" in this object.
@@ -58,6 +71,21 @@ public class Table {
     return offset + bb.getInt(offset) + SIZEOF_INT;  // data starts after the length
   }
 
+  // Get a whole vector as a ByteBuffer. This is efficient, since it only allocates a new
+  // bytebuffer object, but does not actually copy the data, it still refers to the same
+  // bytes as the original ByteBuffer.
+  // Also useful with nested FlatBuffers etc.
+  protected ByteBuffer __vector_as_bytebuffer(int vector_offset, int elem_size) {
+    int o = __offset(vector_offset);
+    if (o == 0) return null;
+    int old_pos = bb.position();
+    bb.position(__vector(o));
+    ByteBuffer nbb = bb.slice();
+    bb.position(old_pos);
+    nbb.limit(__vector_len(o) * elem_size);
+    return nbb;
+  }
+
   // Initialize any Table-derived type to point to the union at the given offset.
   protected Table __union(Table t, int offset) {
     offset += bb_pos;
@@ -65,4 +93,14 @@ public class Table {
     t.bb = bb;
     return t;
   }
+
+  protected static boolean __has_identifier(ByteBuffer bb, String ident) {
+    if (ident.length() != FILE_IDENTIFIER_LENGTH)
+        throw new AssertionError("FlatBuffers: file identifier must be length " +
+                                 FILE_IDENTIFIER_LENGTH);
+    for (int i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {
+      if (ident.charAt(i) != (char)bb.get(bb.position() + SIZEOF_INT + i)) return false;
+    }
+    return true;
+  }
 }

net/FlatBuffers/ByteBuffer.cs

@@ -0,0 +1,200 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Linq;
+
+namespace FlatBuffers
+{
+    /// <summary>
+    /// Class to mimick Java's ByteBuffer which is used heavily in Flatbuffers
+    /// </summary>
+    public class ByteBuffer
+    {
+        private readonly byte[] _buffer;
+        private int _pos;  // Must track start of the buffer.
+
+        public int Length { get { return _buffer.Length; } }
+
+        public byte[] Data { get { return _buffer; } }
+
+        public ByteBuffer(byte[] buffer)
+        {
+            _buffer = buffer;
+            _pos = 0;
+        }
+
+        public int position() { return _pos; }
+
+        protected void WriteLittleEndian(int offset, byte[] data)
+        {
+            if (!BitConverter.IsLittleEndian)
+            {
+                data = data.Reverse().ToArray();
+            }
+            Buffer.BlockCopy(data, 0, _buffer, offset, data.Length);
+            _pos = offset;
+        }
+
+        protected byte[] ReadLittleEndian(int offset, int count)
+        {
+            AssertOffsetAndLength(offset, count);
+            var tmp = new byte[count];
+            Buffer.BlockCopy(_buffer, offset, tmp, 0, count);
+            return (BitConverter.IsLittleEndian)
+              ? tmp
+              : tmp.Reverse().ToArray();
+        }
+
+        private void AssertOffsetAndLength(int offset, int length)
+        {
+            if (offset < 0 ||
+                offset >= _buffer.Length ||
+                offset + length > _buffer.Length)
+                throw new ArgumentOutOfRangeException();
+        }
+
+        public void PutSbyte(int offset, sbyte value)
+        {
+            AssertOffsetAndLength(offset, sizeof(sbyte));
+            _buffer[offset] = (byte)value;
+            _pos = offset;
+        }
+
+        public void PutByte(int offset, byte value)
+        {
+            AssertOffsetAndLength(offset, sizeof(byte));
+            _buffer[offset] = value;
+            _pos = offset;
+        }
+
+        public void PutShort(int offset, short value)
+        {
+            AssertOffsetAndLength(offset, sizeof(short));
+            WriteLittleEndian(offset, BitConverter.GetBytes(value));
+        }
+
+        public void PutUshort(int offset, ushort value)
+        {
+            AssertOffsetAndLength(offset, sizeof(ushort));
+            WriteLittleEndian(offset, BitConverter.GetBytes(value));
+        }
+
+        public void PutInt(int offset, int value)
+        {
+            AssertOffsetAndLength(offset, sizeof(int));
+            WriteLittleEndian(offset, BitConverter.GetBytes(value));
+        }
+
+        public void PutUint(int offset, uint value)
+        {
+            AssertOffsetAndLength(offset, sizeof(uint));
+            WriteLittleEndian(offset, BitConverter.GetBytes(value));
+        }
+
+        public void PutLong(int offset, long value)
+        {
+            AssertOffsetAndLength(offset, sizeof(long));
+            WriteLittleEndian(offset, BitConverter.GetBytes(value));
+        }
+
+        public void PutUlong(int offset, ulong value)
+        {
+            AssertOffsetAndLength(offset, sizeof(ulong));
+            WriteLittleEndian(offset, BitConverter.GetBytes(value));
+        }
+
+        public void PutFloat(int offset, float value)
+        {
+            AssertOffsetAndLength(offset, sizeof(float));
+            WriteLittleEndian(offset, BitConverter.GetBytes(value));
+        }
+
+        public void PutDouble(int offset, double value)
+        {
+            AssertOffsetAndLength(offset, sizeof(double));
+            WriteLittleEndian(offset, BitConverter.GetBytes(value));
+        }
+
+        public sbyte GetSbyte(int index)
+        {
+            AssertOffsetAndLength(index, sizeof(sbyte));
+            return (sbyte)_buffer[index];
+        }
+
+        public byte Get(int index)
+        {
+            AssertOffsetAndLength(index, sizeof(byte));
+            return _buffer[index];
+        }
+
+        public short GetShort(int index)
+        {
+            var tmp = ReadLittleEndian(index, sizeof(short));
+            var value = BitConverter.ToInt16(tmp, 0);
+            return value;
+        }
+
+        public ushort GetUshort(int index)
+        {
+            var tmp = ReadLittleEndian(index, sizeof(ushort));
+            var value = BitConverter.ToUInt16(tmp, 0);
+            return value;
+        }
+
+        public int GetInt(int index)
+        {
+            var tmp = ReadLittleEndian(index, sizeof(int));
+            var value = BitConverter.ToInt32(tmp, 0);
+            return value;
+        }
+
+        public uint GetUint(int index)
+        {
+            var tmp = ReadLittleEndian(index, sizeof(uint));
+            var value = BitConverter.ToUInt32(tmp, 0);
+            return value;
+        }
+
+        public long GetLong(int index)
+        {
+            var tmp = ReadLittleEndian(index, sizeof(long));
+            var value = BitConverter.ToInt64(tmp, 0);
+            return value;
+        }
+
+        public ulong GetUlong(int index)
+        {
+            var tmp = ReadLittleEndian(index, sizeof(ulong));
+            var value = BitConverter.ToUInt64(tmp, 0);
+            return value;
+        }
+
+        public float GetFloat(int index)
+        {
+            var tmp = ReadLittleEndian(index, sizeof(float));
+            var value = BitConverter.ToSingle(tmp, 0);
+            return value;
+        }
+
+        public double GetDouble(int index)
+        {
+            var tmp = ReadLittleEndian(index, sizeof(double));
+            var value = BitConverter.ToDouble(tmp, 0);
+            return value;
+        }
+    }
+}

net/FlatBuffers/FlatBufferBuilder.cs

@@ -0,0 +1,388 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Text;
+
+namespace FlatBuffers
+{
+    /// <summary>
+    /// Responsible for building up and accessing a flatbuffer formatted byte
+    /// array (via ByteBuffer)
+    /// </summary>
+    public class FlatBufferBuilder
+    {
+        private int _space;
+        private ByteBuffer _bb;
+        private int _minAlign = 1;
+
+        // The vtable for the current table, null otherwise.
+        private int[] _vtable;
+        // Starting offset of the current struct/table.
+        private int _objectStart;
+        // List of offsets of all vtables.
+        private int[] _vtables = new int[16];
+        // Number of entries in `vtables` in use.
+        private int _numVtables = 0;
+        // For the current vector being built.
+        private int _vectorNumElems = 0;
+
+        public FlatBufferBuilder(int initialSize)
+        {
+            if (initialSize <= 0)
+                throw new ArgumentOutOfRangeException("initialSize",
+                    initialSize, "Must be greater than zero");
+            _space = initialSize;
+            _bb = new ByteBuffer(new byte[initialSize]);
+        }
+
+
+        public int Offset() { return _bb.Length - _space; }
+
+        public void Pad(int size)
+        {
+            for (var i = 0; i < size; i++)
+            {
+                _bb.PutByte(--_space, 0);
+            }
+        }
+
+        // Doubles the size of the ByteBuffer, and copies the old data towards
+        // the end of the new buffer (since we build the buffer backwards).
+        void GrowBuffer()
+        {
+            var oldBuf = _bb.Data;
+            var oldBufSize = oldBuf.Length;
+            if ((oldBufSize & 0xC0000000) != 0)
+                throw new Exception(
+                    "FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+
+            var newBufSize = oldBufSize << 1;
+            var newBuf = new byte[newBufSize];
+
+            Buffer.BlockCopy(oldBuf, 0, newBuf, newBufSize - oldBufSize,
+                             oldBufSize);
+
+            _bb = new ByteBuffer(newBuf);
+        }
+
+        // Prepare to write an element of `size` after `additional_bytes`
+        // have been written, e.g. if you write a string, you need to align
+        // such the int length field is aligned to SIZEOF_INT, and the string
+        // data follows it directly.
+        // If all you need to do is align, `additional_bytes` will be 0.
+        public void Prep(int size, int additionalBytes)
+        {
+            // Track the biggest thing we've ever aligned to.
+            if (size > _minAlign)
+                _minAlign = size;
+            // Find the amount of alignment needed such that `size` is properly
+            // aligned after `additional_bytes`
+            var alignSize =
+                ((~((int)_bb.Length - _space + additionalBytes)) + 1) &
+                (size - 1);
+            // Reallocate the buffer if needed.
+            while (_space < alignSize + size + additionalBytes)
+            {
+                var oldBufSize = (int)_bb.Length;
+                GrowBuffer();
+                _space += (int)_bb.Length - oldBufSize;
+
+            }
+            Pad(alignSize);
+        }
+
+        public void PutSbyte(sbyte x)
+        {
+          _bb.PutSbyte(_space -= sizeof(sbyte), x);
+        }
+
+        public void PutByte(byte x)
+        {
+            _bb.PutByte(_space -= sizeof(byte), x);
+        }
+
+        public void PutShort(short x)
+        {
+            _bb.PutShort(_space -= sizeof(short), x);
+        }
+
+        public void PutUshort(ushort x)
+        {
+          _bb.PutUshort(_space -= sizeof(ushort), x);
+        }
+
+        public void PutInt(int x)
+        {
+            _bb.PutInt(_space -= sizeof(int), x);
+        }
+
+        public void PutUint(uint x)
+        {
+          _bb.PutUint(_space -= sizeof(uint), x);
+        }
+
+        public void PutLong(long x)
+        {
+            _bb.PutLong(_space -= sizeof(long), x);
+        }
+
+        public void PutUlong(ulong x)
+        {
+          _bb.PutUlong(_space -= sizeof(ulong), x);
+        }
+
+        public void PutFloat(float x)
+        {
+            _bb.PutFloat(_space -= sizeof(float), x);
+        }
+
+        public void PutDouble(double x)
+        {
+            _bb.PutDouble(_space -= sizeof(double), x);
+        }
+
+        // Adds a scalar to the buffer, properly aligned, and the buffer grown
+        // if needed.
+        public void AddSbyte(sbyte x) { Prep(sizeof(sbyte), 0); PutSbyte(x); }
+        public void AddByte(byte x) { Prep(sizeof(byte), 0); PutByte(x); }
+        public void AddShort(short x) { Prep(sizeof(short), 0); PutShort(x); }
+        public void AddUshort(ushort x) { Prep(sizeof(ushort), 0); PutUshort(x); }
+        public void AddInt(int x) { Prep(sizeof(int), 0); PutInt(x); }
+        public void AddUint(uint x) { Prep(sizeof(uint), 0); PutUint(x); }
+        public void AddLong(long x) { Prep(sizeof(long), 0); PutLong(x); }
+        public void AddULong(ulong x) { Prep(sizeof(ulong), 0); PutUlong(x); }
+        public void AddFloat(float x) { Prep(sizeof(float), 0); PutFloat(x); }
+        public void AddDouble(double x) { Prep(sizeof(double), 0);
+                                          PutDouble(x); }
+
+
+
+        // Adds on offset, relative to where it will be written.
+        public void AddOffset(int off)
+        {
+            Prep(sizeof(int), 0);  // Ensure alignment is already done.
+            if (off > Offset())
+                throw new ArgumentException();
+
+            off = Offset() - off + sizeof(int);
+            PutInt(off);
+        }
+
+        public void StartVector(int elemSize, int count, int alignment)
+        {
+            NotNested();
+            _vectorNumElems = count;
+            Prep(sizeof(int), elemSize * count);
+            Prep(alignment, elemSize * count); // Just in case alignment > int.
+        }
+
+        public int EndVector()
+        {
+            PutInt(_vectorNumElems);
+            return Offset();
+        }
+
+        public void Nested(int obj)
+        {
+            // Structs are always stored inline, so need to be created right
+            // where they are used. You'll get this assert if you created it
+            // elsewhere.
+            if (obj != Offset())
+                throw new Exception(
+                    "FlatBuffers: struct must be serialized inline.");
+        }
+
+        public void NotNested()
+        {
+            // You should not be creating any other objects or strings/vectors
+            // while an object is being constructed
+            if (_vtable != null)
+                throw new Exception(
+                    "FlatBuffers: object serialization must not be nested.");
+        }
+
+        public void StartObject(int numfields)
+        {
+            NotNested();
+            _vtable = new int[numfields];
+            _objectStart = Offset();
+        }
+
+
+        // Set the current vtable at `voffset` to the current location in the
+        // buffer.
+        public void Slot(int voffset)
+        {
+            _vtable[voffset] = Offset();
+        }
+
+        // Add a scalar to a table at `o` into its vtable, with value `x` and default `d`
+        public void AddSbyte(int o, sbyte x, sbyte d) { if (x != d) { AddSbyte(x); Slot(o); } }
+        public void AddByte(int o, byte x, byte d) { if (x != d) { AddByte(x); Slot(o); } }
+        public void AddShort(int o, short x, int d) { if (x != d) { AddShort(x); Slot(o); } }
+        public void AddUshort(int o, ushort x, ushort d) { if (x != d) { AddUshort(x); Slot(o); } }
+        public void AddInt(int o, int x, int d) { if (x != d) { AddInt(x); Slot(o); } }
+        public void AddUint(int o, uint x, uint d) { if (x != d) { AddUint(x); Slot(o); } }
+        public void AddLong(int o, long x, long d) { if (x != d) { AddLong(x); Slot(o); } }
+        public void AddULong(int o, ulong x, ulong d) { if (x != d) { AddULong(x); Slot(o); } }
+        public void AddFloat(int o, float x, double d) { if (x != d) { AddFloat(x); Slot(o); } }
+        public void AddDouble(int o, double x, double d) { if (x != d) { AddDouble(x); Slot(o); } }
+        public void AddOffset(int o, int x, int d) { if (x != d) { AddOffset(x); Slot(o); } }
+
+        public int CreateString(string s)
+        {
+            NotNested();
+            byte[] utf8 = Encoding.UTF8.GetBytes(s);
+            AddByte((byte)0);
+            StartVector(1, utf8.Length, 1);
+            Buffer.BlockCopy(utf8, 0, _bb.Data, _space -= utf8.Length,
+                             utf8.Length);
+            return EndVector();
+        }
+
+        // Structs are stored inline, so nothing additional is being added.
+        // `d` is always 0.
+        public void AddStruct(int voffset, int x, int d)
+        {
+            if (x != d)
+            {
+                Nested(x);
+                Slot(voffset);
+            }
+        }
+
+        public int EndObject()
+        {
+
+            if (_vtable == null)
+                throw new InvalidOperationException(
+                  "Flatbuffers: calling endObject without a startObject");
+
+            AddInt((int)0);
+            var vtableloc = Offset();
+            // Write out the current vtable.
+            for (int i = _vtable.Length - 1; i >= 0 ; i--) {
+                // Offset relative to the start of the table.
+                short off = (short)(_vtable[i] != 0
+                                        ? vtableloc - _vtable[i]
+                                        : 0);
+                AddShort(off);
+            }
+
+            const int standardFields = 2; // The fields below:
+            AddShort((short)(vtableloc - _objectStart));
+            AddShort((short)((_vtable.Length + standardFields) *
+                             sizeof(short)));
+
+            // Search for an existing vtable that matches the current one.
+            int existingVtable = 0;
+
+            for (int i = 0; i < _numVtables; i++) {
+                int vt1 = _bb.Length - _vtables[i];
+                int vt2 = _space;
+                short len = _bb.GetShort(vt1);
+                if (len == _bb.GetShort(vt2)) {
+                    for (int j = sizeof(short); j < len; j += sizeof(short)) {
+                        if (_bb.GetShort(vt1 + j) != _bb.GetShort(vt2 + j)) {
+                            goto endLoop;
+                        }
+                    }
+                    existingVtable = _vtables[i];
+                    break;
+                }
+
+            endLoop: { }
+            }
+
+            if (existingVtable != 0) {
+                // Found a match:
+                // Remove the current vtable.
+                _space = _bb.Length - vtableloc;
+                // Point table to existing vtable.
+                _bb.PutInt(_space, existingVtable - vtableloc);
+            } else {
+                // No match:
+                // Add the location of the current vtable to the list of
+                // vtables.
+                if (_numVtables == _vtables.Length)
+                {
+                    // Arrays.CopyOf(vtables num_vtables * 2);
+                    var newvtables = new int[ _numVtables * 2];
+                    Array.Copy(_vtables, newvtables, _vtables.Length);
+
+                    _vtables = newvtables;
+                };
+                _vtables[_numVtables++] = Offset();
+                // Point table to current vtable.
+                _bb.PutInt(_bb.Length - vtableloc, Offset() - vtableloc);
+            }
+
+            _vtable = null;
+            return vtableloc;
+        }
+
+        // This checks a required field has been set in a given table that has
+        // just been constructed.
+        public void Required(int table, int field)
+        {
+          int table_start = _bb.Length - table;
+          int vtable_start = table_start - _bb.GetInt(table_start);
+          bool ok = _bb.GetShort(vtable_start + field) != 0;
+          // If this fails, the caller will show what field needs to be set.
+          if (!ok)
+            throw new InvalidOperationException("FlatBuffers: field " + field +
+                                                " must be set");
+        }
+
+        public void Finish(int rootTable)
+        {
+            Prep(_minAlign, sizeof(int));
+            AddOffset(rootTable);
+        }
+
+        public ByteBuffer DataBuffer() { return _bb; }
+
+        // Utility function for copying a byte array that starts at 0.
+        public byte[] SizedByteArray()
+        {
+            var newArray = new byte[_bb.Data.Length];
+            Buffer.BlockCopy(_bb.Data, _bb.position(), newArray, 0,
+                             _bb.Data.Length);
+            return newArray;
+        }
+
+         public void Finish(int rootTable, string fileIdentifier)
+         {
+             Prep(_minAlign, sizeof(int) +
+                             FlatBufferConstants.FileIdentifierLength);
+             if (fileIdentifier.Length !=
+                 FlatBufferConstants.FileIdentifierLength)
+                 throw new ArgumentException(
+                     "FlatBuffers: file identifier must be length " +
+                     FlatBufferConstants.FileIdentifierLength,
+                     "fileIdentifier");
+             for (int i = FlatBufferConstants.FileIdentifierLength - 1; i >= 0;
+                  i--)
+             {
+                AddByte((byte)fileIdentifier[i]);
+             }
+             AddOffset(rootTable);
+        }
+
+
+    }
+}

net/FlatBuffers/FlatBufferConstants.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FlatBuffers
+{
+    public static class FlatBufferConstants
+    {
+        public const int FileIdentifierLength = 4;
+    }
+}

net/FlatBuffers/FlatBuffers.csproj

@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{28C00774-1E73-4A75-AD8F-844CD21A064D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>FlatBuffers</RootNamespace>
+    <AssemblyName>FlatBuffers</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ByteBuffer.cs" />
+    <Compile Include="FlatBufferBuilder.cs" />
+    <Compile Include="FlatBufferConstants.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Struct.cs" />
+    <Compile Include="Table.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="FlatBuffers.1.0.0.nuspec" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

net/FlatBuffers/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("FlatBuffers")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("FlatBuffers")]
+[assembly: AssemblyCopyright("Copyright ©  2014 Google Inc")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("91c32e64-ef20-47df-9c9f-cec9207bc6df")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

net/FlatBuffers/Struct.cs

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace FlatBuffers
+{
+    /// <summary>
+    /// All structs in the generated code derive from this class, and add their own accessors.
+    /// </summary>
+    public abstract class Struct
+    {
+        protected int bb_pos;
+        protected ByteBuffer bb;
+    }
+}

net/FlatBuffers/Table.cs

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Text;
+
+namespace FlatBuffers
+{
+    /// <summary>
+    /// All tables in the generated code derive from this class, and add their own accessors.
+    /// </summary>
+    public abstract class Table
+    {
+        protected int bb_pos;
+        protected ByteBuffer bb;
+
+        // Look up a field in the vtable, return an offset into the object, or 0 if the field is not
+        // present.
+        protected int __offset(int vtableOffset)
+        {
+            int vtable = bb_pos - bb.GetInt(bb_pos);
+            return vtableOffset < bb.GetShort(vtable) ? bb.GetShort(vtable + vtableOffset) : 0;
+        }
+
+        // Retrieve the relative offset stored at "offset"
+        protected int __indirect(int offset)
+        {
+            return offset + bb.GetInt(offset);
+        }
+
+        // Create a .NET String from UTF-8 data stored inside the flatbuffer.
+        protected string __string(int offset)
+        {
+            offset += bb.GetInt(offset);
+            var len = bb.GetInt(offset);
+            var startPos = offset + sizeof(int);
+            return Encoding.UTF8.GetString(bb.Data, startPos , len);
+        }
+
+        // Get the length of a vector whose offset is stored at "offset" in this object.
+        protected int __vector_len(int offset)
+        {
+            offset += bb_pos;
+            offset += bb.GetInt(offset);
+            return bb.GetInt(offset);
+        }
+
+        // Get the start of data of a vector whose offset is stored at "offset" in this object.
+        protected int __vector(int offset)
+        {
+            offset += bb_pos;
+            return offset + bb.GetInt(offset) + sizeof(int);  // data starts after the length
+        }
+
+        // Initialize any Table-derived type to point to the union at the given offset.
+        protected Table __union(Table t, int offset)
+        {
+            offset += bb_pos;
+            t.bb_pos = offset + bb.GetInt(offset);
+            t.bb = bb;
+            return t;
+        }
+
+        protected static bool __has_identifier(ByteBuffer bb, string ident)
+        {
+            if (ident.Length != FlatBufferConstants.FileIdentifierLength)
+                throw new ArgumentException("FlatBuffers: file identifier must be length " + FlatBufferConstants.FileIdentifierLength, "ident");
+
+            for (var i = 0; i < FlatBufferConstants.FileIdentifierLength; i++)
+            {
+                if (ident[i] != (char)bb.Get(bb.position() + sizeof(int) + i)) return false;
+            }
+
+            return true;
+        }
+
+
+    }
+}

samples/monster_generated.h

@@ -5,10 +5,14 @@
 
 #include "flatbuffers/flatbuffers.h"
 
+
 namespace MyGame {
 namespace Sample {
 
-enum {
+struct Vec3;
+struct Monster;
+
+enum Color {
   Color_Red = 0,
   Color_Green = 1,
   Color_Blue = 2
@@ -19,9 +23,9 @@ inline const char **EnumNamesColor() {
   return names;
 }
 
-inline const char *EnumNameColor(int e) { return EnumNamesColor()[e]; }
+inline const char *EnumNameColor(Color e) { return EnumNamesColor()[e]; }
 
-enum {
+enum Any {
   Any_NONE = 0,
   Any_Monster = 1
 };
@@ -31,12 +35,9 @@ inline const char **EnumNamesAny() {
   return names;
 }
 
-inline const char *EnumNameAny(int e) { return EnumNamesAny()[e]; }
+inline const char *EnumNameAny(Any e) { return EnumNamesAny()[e]; }
 
-bool VerifyAny(const flatbuffers::Verifier &verifier, const void *union_obj, uint8_t type);
-
-struct Vec3;
-struct Monster;
+inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *union_obj, uint8_t type);
 
 MANUALLY_ALIGNED_STRUCT(4) Vec3 {
  private:
@@ -46,7 +47,7 @@ MANUALLY_ALIGNED_STRUCT(4) Vec3 {
 
  public:
   Vec3(float x, float y, float z)
-    : x_(flatbuffers::EndianScalar(x)), y_(flatbuffers::EndianScalar(y)), z_(flatbuffers::EndianScalar(z)) {}
+    : x_(flatbuffers::EndianScalar(x)), y_(flatbuffers::EndianScalar(y)), z_(flatbuffers::EndianScalar(z)) { }
 
   float x() const { return flatbuffers::EndianScalar(x_); }
   float y() const { return flatbuffers::EndianScalar(y_); }
@@ -60,9 +61,9 @@ struct Monster : private flatbuffers::Table {
   int16_t hp() const { return GetField<int16_t>(8, 100); }
   const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(10); }
   const flatbuffers::Vector<uint8_t> *inventory() const { return GetPointer<const flatbuffers::Vector<uint8_t> *>(14); }
-  int8_t color() const { return GetField<int8_t>(16, 2); }
-  bool Verify(const flatbuffers::Verifier &verifier) const {
-    return VerifyTable(verifier) &&
+  Color color() const { return static_cast<Color>(GetField<int8_t>(16, 2)); }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
            VerifyField<Vec3>(verifier, 4 /* pos */) &&
            VerifyField<int16_t>(verifier, 6 /* mana */) &&
            VerifyField<int16_t>(verifier, 8 /* hp */) &&
@@ -70,7 +71,8 @@ struct Monster : private flatbuffers::Table {
            verifier.Verify(name()) &&
            VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* inventory */) &&
            verifier.Verify(inventory()) &&
-           VerifyField<int8_t>(verifier, 16 /* color */);
+           VerifyField<int8_t>(verifier, 16 /* color */) &&
+           verifier.EndTable();
   }
 };
 
@@ -82,10 +84,13 @@ struct MonsterBuilder {
   void add_hp(int16_t hp) { fbb_.AddElement<int16_t>(8, hp, 100); }
   void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(10, name); }
   void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) { fbb_.AddOffset(14, inventory); }
-  void add_color(int8_t color) { fbb_.AddElement<int8_t>(16, color, 2); }
+  void add_color(Color color) { fbb_.AddElement<int8_t>(16, static_cast<int8_t>(color), 2); }
   MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
   MonsterBuilder &operator=(const MonsterBuilder &);
-  flatbuffers::Offset<Monster> Finish() { return flatbuffers::Offset<Monster>(fbb_.EndTable(start_, 7)); }
+  flatbuffers::Offset<Monster> Finish() {
+    auto o = flatbuffers::Offset<Monster>(fbb_.EndTable(start_, 7));
+    return o;
+  }
 };
 
 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb,
@@ -94,7 +99,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
    int16_t hp = 100,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0,
-   int8_t color = 2) {
+   Color color = Color_Blue) {
   MonsterBuilder builder_(_fbb);
   builder_.add_inventory(inventory);
   builder_.add_name(name);
@@ -105,7 +110,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
   return builder_.Finish();
 }
 
-bool VerifyAny(const flatbuffers::Verifier &verifier, const void *union_obj, uint8_t type) {
+inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *union_obj, uint8_t type) {
   switch (type) {
     case Any_NONE: return true;
     case Any_Monster: return verifier.VerifyTable(reinterpret_cast<const Monster *>(union_obj));
@@ -115,7 +120,9 @@ bool VerifyAny(const flatbuffers::Verifier &verifier, const void *union_obj, uin
 
 inline const Monster *GetMonster(const void *buf) { return flatbuffers::GetRoot<Monster>(buf); }
 
-inline bool VerifyMonsterBuffer(const flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer<Monster>(); }
+inline bool VerifyMonsterBuffer(flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer<Monster>(); }
+
+inline void FinishMonsterBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<Monster> root) { fbb.Finish(root); }
 
 }  // namespace Sample
 }  // namespace MyGame

samples/sample_binary.cpp

@@ -54,9 +54,11 @@ int main(int /*argc*/, const char * /*argv*/[]) {
   auto pos = monster->pos();
   assert(pos);
   assert(pos->z() == 3);
+  (void)pos;
 
   auto inv = monster->inventory();
   assert(inv);
   assert(inv->Get(9) == 9);
+  (void)inv;
 }
 

samples/sample_text.cpp

@@ -37,8 +37,9 @@ int main(int /*argc*/, const char * /*argv*/[]) {
 
   // parse schema first, so we can use it to parse the data after
   flatbuffers::Parser parser;
-  ok = parser.Parse(schemafile.c_str()) &&
-       parser.Parse(jsonfile.c_str());
+  const char *include_directories[] = { "samples", nullptr };
+  ok = parser.Parse(schemafile.c_str(), include_directories) &&
+       parser.Parse(jsonfile.c_str(), include_directories);
   assert(ok);
 
   // here, parser.builder_ contains a binary buffer that is the parsed data.

src/flatc.cpp

@@ -19,7 +19,7 @@
 #include "flatbuffers/util.h"
 
 static void Error(const char *err, const char *obj = nullptr,
-                  bool usage = false);
+                  bool usage = false, bool show_exe_name = true);
 
 namespace flatbuffers {
 
@@ -60,105 +60,107 @@ struct Generator {
                    const std::string &path,
                    const std::string &file_name,
                    const flatbuffers::GeneratorOptions &opts);
-  const char *extension;
+  const char *opt;
   const char *name;
+  flatbuffers::GeneratorOptions::Language lang;
   const char *help;
 };
 
 const Generator generators[] = {
-  { flatbuffers::GenerateBinary,   "b", "binary",
+  { flatbuffers::GenerateBinary,   "-b", "binary",
+    flatbuffers::GeneratorOptions::kMAX,
     "Generate wire format binaries for any data definitions" },
-  { flatbuffers::GenerateTextFile, "t", "text",
+  { flatbuffers::GenerateTextFile, "-t", "text",
+    flatbuffers::GeneratorOptions::kMAX,
     "Generate text output for any data definitions" },
-  { flatbuffers::GenerateCPP,      "c", "C++",
+  { flatbuffers::GenerateCPP,      "-c", "C++",
+    flatbuffers::GeneratorOptions::kMAX,
     "Generate C++ headers for tables/structs" },
-  { flatbuffers::GenerateGo,       "g", "Go",
+  { flatbuffers::GenerateGo,       "-g", "Go",
+    flatbuffers::GeneratorOptions::kMAX,
     "Generate Go files for tables/structs" },
-  { flatbuffers::GenerateJava,     "j", "Java",
+  { flatbuffers::GenerateGeneral,  "-j", "Java",
+    flatbuffers::GeneratorOptions::kJava,
     "Generate Java classes for tables/structs" },
+  { flatbuffers::GenerateGeneral,  "-n", "C#",
+    flatbuffers::GeneratorOptions::kCSharp,
+    "Generate C# classes for tables/structs" }
 };
 
 const char *program_name = NULL;
 
-static void Error(const char *err, const char *obj, bool usage) {
-  printf("%s: %s", program_name, err);
+static void Error(const char *err, const char *obj, bool usage,
+                  bool show_exe_name) {
+  if (show_exe_name) printf("%s: ", program_name);
+  printf("%s", err);
   if (obj) printf(": %s", obj);
   printf("\n");
   if (usage) {
     printf("usage: %s [OPTION]... FILE... [-- FILE...]\n", program_name);
     for (size_t i = 0; i < sizeof(generators) / sizeof(generators[0]); ++i)
-      printf("  -%s      %s.\n", generators[i].extension, generators[i].help);
-    printf("  -o PATH Prefix PATH to all generated files.\n"
-           "  -S      Strict JSON: add quotes to field names.\n"
-           "FILEs may depend on declarations in earlier files.\n"
-           "FILEs after the -- must be binary flatbuffer format files.\n"
-           "Output files are named using the base file name of the input,"
-           "and written to the current directory or the path given by -o.\n"
-           "example: %s -c -b schema1.fbs schema2.fbs data.json\n",
-           program_name);
+      printf("  %s             %s.\n", generators[i].opt, generators[i].help);
+    printf(
+      "  -o PATH         Prefix PATH to all generated files.\n"
+      "  -I PATH         Search for includes in the specified path.\n"
+      "  --strict-json   Strict JSON: add quotes to field names.\n"
+      "  --no-prefix     Don\'t prefix enum values with the enum type in C++.\n"
+      "  --gen-includes  Generate include statements for included schemas the\n"
+      "                  generated file depends on (C++).\n"
+      "  --proto         Input is a .proto, translate to .fbs.\n"
+      "FILEs may depend on declarations in earlier files.\n"
+      "FILEs after the -- must be binary flatbuffer format files.\n"
+      "Output files are named using the base file name of the input,"
+      "and written to the current directory or the path given by -o.\n"
+      "example: %s -c -b schema1.fbs schema2.fbs data.json\n",
+      program_name);
   }
   exit(1);
 }
 
-std::string StripExtension(const std::string &filename) {
-  size_t i = filename.find_last_of(".");
-  return i != std::string::npos ? filename.substr(0, i) : filename;
-}
-
-std::string StripPath(const std::string &filename) {
-  size_t i = filename.find_last_of(
-    #ifdef _WIN32
-      "\\:"
-    #else
-      "/"
-    #endif
-    );
-  return i != std::string::npos ? filename.substr(i + 1) : filename;
-}
-
 int main(int argc, const char *argv[]) {
   program_name = argv[0];
-  flatbuffers::Parser parser;
   flatbuffers::GeneratorOptions opts;
   std::string output_path;
   const size_t num_generators = sizeof(generators) / sizeof(generators[0]);
   bool generator_enabled[num_generators] = { false };
   bool any_generator = false;
+  bool proto_mode = false;
   std::vector<std::string> filenames;
+  std::vector<const char *> include_directories;
   size_t binary_files_from = std::numeric_limits<size_t>::max();
   for (int i = 1; i < argc; i++) {
     const char *arg = argv[i];
     if (arg[0] == '-') {
       if (filenames.size() && arg[1] != '-')
         Error("invalid option location", arg, true);
-      if (strlen(arg) != 2)
-        Error("invalid commandline argument", arg, true);
-      switch (arg[1]) {
-        case 'o':
-          if (++i >= argc) Error("missing path following", arg, true);
-          output_path = argv[i];
-          if (!(output_path.back() == flatbuffers::kPathSeparator ||
-                output_path.back() == flatbuffers::kPosixPathSeparator)) {
-            output_path += flatbuffers::kPathSeparator;
+      std::string opt = arg;
+      if (opt == "-o") {
+        if (++i >= argc) Error("missing path following", arg, true);
+        output_path = flatbuffers::ConCatPathFileName(argv[i], "");
+      } else if(opt == "-I") {
+        if (++i >= argc) Error("missing path following", arg, true);
+        include_directories.push_back(argv[i]);
+      } else if(opt == "--strict-json") {
+        opts.strict_json = true;
+      } else if(opt == "--no-prefix") {
+        opts.prefixed_enums = false;
+      } else if(opt == "--gen-includes") {
+        opts.include_dependence_headers = true;
+      } else if(opt == "--") {  // Separator between text and binary inputs.
+        binary_files_from = filenames.size();
+      } else if(opt == "--proto") {
+        proto_mode = true;
+        any_generator = true;
+      } else {
+        for (size_t i = 0; i < num_generators; ++i) {
+          if(opt == generators[i].opt) {
+            generator_enabled[i] = true;
+            any_generator = true;
+            goto found;
           }
-          break;
-        case 'S':
-          opts.strict_json = true;
-          break;
-        case '-':  // Separator between text and binary input files.
-          binary_files_from = filenames.size();
-          break;
-        default:
-          for (size_t i = 0; i < num_generators; ++i) {
-            if(!strcmp(arg+1, generators[i].extension)) {
-              generator_enabled[i] = true;
-              any_generator = true;
-              goto found;
-            }
-          }
-          Error("unknown commandline argument", arg, true);
-          found:
-          break;
+        }
+        Error("unknown commandline argument", arg, true);
+        found:;
       }
     } else {
       filenames.push_back(argv[i]);
@@ -172,6 +174,7 @@ int main(int argc, const char *argv[]) {
           "specify one of -c -g -j -t -b etc.", true);
 
   // Now process the files:
+  flatbuffers::Parser parser(proto_mode);
   for (auto file_it = filenames.begin();
             file_it != filenames.end();
           ++file_it) {
@@ -187,14 +190,23 @@ int main(int argc, const char *argv[]) {
           reinterpret_cast<const uint8_t *>(contents.c_str()),
           contents.length());
       } else {
-        if (!parser.Parse(contents.c_str()))
-          Error(parser.error_.c_str());
+        auto local_include_directory = flatbuffers::StripFileName(*file_it);
+        include_directories.push_back(local_include_directory.c_str());
+        include_directories.push_back(nullptr);
+        if (!parser.Parse(contents.c_str(), &include_directories[0],
+                          file_it->c_str()))
+          Error(parser.error_.c_str(), nullptr, false, false);
+        include_directories.pop_back();
+        include_directories.pop_back();
       }
 
-      std::string filebase = StripPath(StripExtension(*file_it));
+      std::string filebase = flatbuffers::StripPath(
+                               flatbuffers::StripExtension(*file_it));
 
       for (size_t i = 0; i < num_generators; ++i) {
         if (generator_enabled[i]) {
+          flatbuffers::EnsureDirExists(output_path);
+          opts.lang = generators[i].lang;
           if (!generators[i].generate(parser, output_path, filebase, opts)) {
             Error((std::string("Unable to generate ") +
                    generators[i].name +
@@ -204,17 +216,11 @@ int main(int argc, const char *argv[]) {
         }
       }
 
-      // Since the Parser object retains definitions across files, we must
-      // ensure we only output code for these once, in the file they are first
-      // declared:
-      for (auto it = parser.enums_.vec.begin();
-               it != parser.enums_.vec.end(); ++it) {
-        (*it)->generated = true;
-      }
-      for (auto it = parser.structs_.vec.begin();
-               it != parser.structs_.vec.end(); ++it) {
-        (*it)->generated = true;
-      }
+      if (proto_mode) GenerateFBS(parser, output_path, filebase, opts);
+
+      // We do not want to generate code for the definitions in this file
+      // in any files coming up next.
+      parser.MarkGenerated();
   }
 
   return 0;

src/idl_gen_cpp.cpp

@@ -23,28 +23,52 @@
 namespace flatbuffers {
 namespace cpp {
 
+// Ensure that a type is prefixed with its namespace whenever it is used
+// outside of its namespace.
+static std::string WrapInNameSpace(const Parser &parser, const Namespace *ns,
+                                   const std::string &name) {
+  if (parser.namespaces_.back() != ns) {
+    std::string qualified_name;
+    for (auto it = ns->components.begin();
+             it != ns->components.end(); ++it) {
+      qualified_name += *it + "::";
+    }
+    return qualified_name + name;
+  } else {
+    return name;
+  }
+}
+
 // Return a C++ type from the table in idl.h
-static std::string GenTypeBasic(const Type &type) {
+static std::string GenTypeBasic(const Parser &parser, const Type &type,
+                                bool real_enum) {
   static const char *ctypename[] = {
-    #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) #CTYPE,
+    #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) #CTYPE,
       FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
     #undef FLATBUFFERS_TD
   };
-  return ctypename[type.base_type];
+  return real_enum && type.enum_def
+      ? WrapInNameSpace(parser, type.enum_def->defined_namespace,
+                        type.enum_def->name)
+      : ctypename[type.base_type];
 }
 
-static std::string GenTypeWire(const Type &type, const char *postfix);
+static std::string GenTypeWire(const Parser &parser, const Type &type,
+                               const char *postfix, bool real_enum);
 
 // Return a C++ pointer type, specialized to the actual struct/table types,
 // and vector element types.
-static std::string GenTypePointer(const Type &type) {
+static std::string GenTypePointer(const Parser &parser, const Type &type) {
   switch (type.base_type) {
     case BASE_TYPE_STRING:
       return "flatbuffers::String";
     case BASE_TYPE_VECTOR:
-      return "flatbuffers::Vector<" + GenTypeWire(type.VectorType(), "") + ">";
-    case BASE_TYPE_STRUCT:
-      return type.struct_def->name;
+      return "flatbuffers::Vector<" +
+             GenTypeWire(parser, type.VectorType(), "", false) + ">";
+    case BASE_TYPE_STRUCT: {
+      return WrapInNameSpace(parser, type.struct_def->defined_namespace,
+                             type.struct_def->name);
+    }
     case BASE_TYPE_UNION:
       // fall through
     default:
@@ -54,57 +78,56 @@ static std::string GenTypePointer(const Type &type) {
 
 // Return a C++ type for any type (scalar/pointer) specifically for
 // building a flatbuffer.
-static std::string GenTypeWire(const Type &type, const char *postfix) {
+static std::string GenTypeWire(const Parser &parser, const Type &type,
+                               const char *postfix, bool real_enum) {
   return IsScalar(type.base_type)
-    ? GenTypeBasic(type) + postfix
+    ? GenTypeBasic(parser, type, real_enum) + postfix
     : IsStruct(type)
-      ? "const " + GenTypePointer(type) + " *"
-      : "flatbuffers::Offset<" + GenTypePointer(type) + ">" + postfix;
+      ? "const " + GenTypePointer(parser, type) + " *"
+      : "flatbuffers::Offset<" + GenTypePointer(parser, type) + ">" + postfix;
 }
 
 // Return a C++ type for any type (scalar/pointer) that reflects its
 // serialized size.
-static std::string GenTypeSize(const Type &type) {
+static std::string GenTypeSize(const Parser &parser, const Type &type) {
   return IsScalar(type.base_type)
-    ? GenTypeBasic(type)
+    ? GenTypeBasic(parser, type, false)
     : IsStruct(type)
-      ? GenTypePointer(type)
+      ? GenTypePointer(parser, type)
       : "flatbuffers::uoffset_t";
 }
 
 // Return a C++ type for any type (scalar/pointer) specifically for
 // using a flatbuffer.
-static std::string GenTypeGet(const Type &type, const char *afterbasic,
-                              const char *beforeptr, const char *afterptr) {
+static std::string GenTypeGet(const Parser &parser, const Type &type,
+                              const char *afterbasic, const char *beforeptr,
+                              const char *afterptr, bool real_enum) {
   return IsScalar(type.base_type)
-    ? GenTypeBasic(type) + afterbasic
-    : beforeptr + GenTypePointer(type) + afterptr;
+    ? GenTypeBasic(parser, type, real_enum) + afterbasic
+    : beforeptr + GenTypePointer(parser, type) + afterptr;
 }
 
-// Generate a documentation comment, if available.
-static void GenComment(const std::string &dc,
-                       std::string *code_ptr,
-                       const char *prefix = "") {
-  std::string &code = *code_ptr;
-  if (dc.length()) {
-    code += std::string(prefix) + "///" + dc + "\n";
-  }
+static std::string GenEnumVal(const EnumDef &enum_def, const EnumVal &enum_val,
+                              const GeneratorOptions &opts) {
+  return opts.prefixed_enums ? enum_def.name + "_" + enum_val.name
+                             : enum_val.name;
 }
 
 // Generate an enum declaration and an enum string lookup table.
-  static void GenEnum(EnumDef &enum_def, std::string *code_ptr,
-                                         std::string *code_ptr_post) {
+static void GenEnum(EnumDef &enum_def, std::string *code_ptr,
+                    std::string *code_ptr_post,
+                    const GeneratorOptions &opts) {
   if (enum_def.generated) return;
   std::string &code = *code_ptr;
   std::string &code_post = *code_ptr_post;
   GenComment(enum_def.doc_comment, code_ptr);
-  code += "enum {\n";
+  code += "enum " + enum_def.name + " {\n";
   for (auto it = enum_def.vals.vec.begin();
        it != enum_def.vals.vec.end();
        ++it) {
     auto &ev = **it;
     GenComment(ev.doc_comment, code_ptr, "  ");
-    code += "  " + enum_def.name + "_" + ev.name + " = ";
+    code += "  " + GenEnumVal(enum_def, ev, opts) + " = ";
     code += NumToString(ev.value);
     code += (it + 1) != enum_def.vals.vec.end() ? ",\n" : "\n";
   }
@@ -131,9 +154,9 @@ static void GenComment(const std::string &dc,
     }
     code += "nullptr };\n  return names;\n}\n\n";
     code += "inline const char *EnumName" + enum_def.name;
-    code += "(int e) { return EnumNames" + enum_def.name + "()[e";
+    code += "(" + enum_def.name + " e) { return EnumNames" + enum_def.name + "()[e";
     if (enum_def.vals.vec.front()->value)
-      code += " - " + enum_def.name + "_" + enum_def.vals.vec.front()->name;
+      code += " - " + GenEnumVal(enum_def, *enum_def.vals.vec.front(), opts);
     code += "]; }\n\n";
   }
 
@@ -143,16 +166,16 @@ static void GenComment(const std::string &dc,
     // verifier function to call, this should be safe even if the union type
     // has been corrupted, since the verifiers will simply fail when called
     // on the wrong type.
-    auto signature = "bool Verify" + enum_def.name +
-                     "(const flatbuffers::Verifier &verifier, " +
-                     "const void *union_obj, uint8_t type)";
+    auto signature = "inline bool Verify" + enum_def.name +
+                     "(flatbuffers::Verifier &verifier, " +
+                     "const void *union_obj, " + enum_def.name + " type)";
     code += signature + ";\n\n";
     code_post += signature + " {\n  switch (type) {\n";
     for (auto it = enum_def.vals.vec.begin();
          it != enum_def.vals.vec.end();
          ++it) {
       auto &ev = **it;
-      code_post += "    case " + enum_def.name + "_" + ev.name;
+      code_post += "    case " + GenEnumVal(enum_def, ev, opts);
       if (!ev.value) {
         code_post += ": return true;\n";  // "NONE" enum value.
       } else {
@@ -164,9 +187,21 @@ static void GenComment(const std::string &dc,
   }
 }
 
+// Generates a value with optionally a cast applied if the field has a
+// different underlying type from its interface type (currently only the
+// case for enums. "from" specify the direction, true meaning from the
+// underlying type to the interface type.
+std::string GenUnderlyingCast(const Parser &parser, const FieldDef &field,
+                              bool from, const std::string &val) {
+  return field.value.type.enum_def && IsScalar(field.value.type.base_type)
+      ? "static_cast<" + GenTypeBasic(parser, field.value.type, from) + ">(" +
+        val + ")"
+      : val;
+}
+
 // Generate an accessor struct, builder structs & function for a table.
 static void GenTable(const Parser &parser, StructDef &struct_def,
-                     std::string *code_ptr) {
+                     const GeneratorOptions &opts, std::string *code_ptr) {
   if (struct_def.generated) return;
   std::string &code = *code_ptr;
 
@@ -181,18 +216,21 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
     auto &field = **it;
     if (!field.deprecated) {  // Deprecated fields won't be accessible.
       GenComment(field.doc_comment, code_ptr, "  ");
-      code += "  " + GenTypeGet(field.value.type, " ", "const ", " *");
+      code += "  " + GenTypeGet(parser, field.value.type, " ", "const ", " *",
+                                true);
       code += field.name + "() const { return ";
       // Call a different accessor for pointers, that indirects.
-      code += IsScalar(field.value.type.base_type)
+      std::string call = IsScalar(field.value.type.base_type)
         ? "GetField<"
         : (IsStruct(field.value.type) ? "GetStruct<" : "GetPointer<");
-      code += GenTypeGet(field.value.type, "", "const ", " *") + ">(";
-      code += NumToString(field.value.offset);
+      call += GenTypeGet(parser, field.value.type, "", "const ", " *", false);
+      call += ">(" + NumToString(field.value.offset);
       // Default value as second arg for non-pointer types.
       if (IsScalar(field.value.type.base_type))
-        code += ", " + field.value.constant;
-      code += "); }\n";
+        call += ", " + field.value.constant;
+      call += ")";
+      code += GenUnderlyingCast(parser, field, true, call);
+      code += "; }\n";
       auto nested = field.attributes.Lookup("nested_flatbuffer");
       if (nested) {
         auto nested_root = parser.structs_.Lookup(nested->constant);
@@ -205,15 +243,17 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
   }
   // Generate a verifier function that can check a buffer from an untrusted
   // source will never cause reads outside the buffer.
-  code += "  bool Verify(const flatbuffers::Verifier &verifier) const {\n";
-  code += "    return VerifyTable(verifier)";
+  code += "  bool Verify(flatbuffers::Verifier &verifier) const {\n";
+  code += "    return VerifyTableStart(verifier)";
   std::string prefix = " &&\n           ";
   for (auto it = struct_def.fields.vec.begin();
        it != struct_def.fields.vec.end();
        ++it) {
     auto &field = **it;
     if (!field.deprecated) {
-      code += prefix + "VerifyField<" + GenTypeSize(field.value.type);
+      code += prefix + "VerifyField";
+      if (field.required) code += "Required";
+      code += "<" + GenTypeSize(parser, field.value.type);
       code += ">(verifier, " + NumToString(field.value.offset);
       code += " /* " + field.name + " */)";
       switch (field.value.type.base_type) {
@@ -254,6 +294,7 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
       }
     }
   }
+  code += prefix + "verifier.EndTable()";
   code += ";\n  }\n";
   code += "};\n\n";
 
@@ -268,14 +309,18 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
     auto &field = **it;
     if (!field.deprecated) {
       code += "  void add_" + field.name + "(";
-      code += GenTypeWire(field.value.type, " ") + field.name + ") { fbb_.Add";
-      if (IsScalar(field.value.type.base_type))
-        code += "Element<" + GenTypeWire(field.value.type, "") + ">";
-      else if (IsStruct(field.value.type))
+      code += GenTypeWire(parser, field.value.type, " ", true) + field.name;
+      code += ") { fbb_.Add";
+      if (IsScalar(field.value.type.base_type)) {
+        code += "Element<" + GenTypeWire(parser, field.value.type, "", false);
+        code += ">";
+      } else if (IsStruct(field.value.type)) {
         code += "Struct";
-      else
+      } else {
         code += "Offset";
-      code += "(" + NumToString(field.value.offset) + ", " + field.name;
+      }
+      code += "(" + NumToString(field.value.offset) + ", ";
+      code += GenUnderlyingCast(parser, field, false, field.name);
       if (IsScalar(field.value.type.base_type))
         code += ", " + field.value.constant;
       code += "); }\n";
@@ -287,9 +332,19 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
   code += "  " + struct_def.name + "Builder &operator=(const ";
   code += struct_def.name + "Builder &);\n";
   code += "  flatbuffers::Offset<" + struct_def.name;
-  code += "> Finish() { return flatbuffers::Offset<" + struct_def.name;
+  code += "> Finish() {\n    auto o = flatbuffers::Offset<" + struct_def.name;
   code += ">(fbb_.EndTable(start_, ";
-  code += NumToString(struct_def.fields.vec.size()) + ")); }\n};\n\n";
+  code += NumToString(struct_def.fields.vec.size()) + "));\n";
+  for (auto it = struct_def.fields.vec.begin();
+       it != struct_def.fields.vec.end();
+       ++it) {
+    auto &field = **it;
+    if (!field.deprecated && field.required) {
+      code += "    fbb_.Required(o, " + NumToString(field.value.offset);
+      code += ");  // " + field.name + "\n";
+    }
+  }
+  code += "    return o;\n  }\n};\n\n";
 
   // Generate a convenient CreateX function that uses the above builder
   // to create a table in one go.
@@ -301,8 +356,22 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
        ++it) {
     auto &field = **it;
     if (!field.deprecated) {
-      code += ",\n   " + GenTypeWire(field.value.type, " ") + field.name;
-      code += " = " + field.value.constant;
+      code += ",\n   " + GenTypeWire(parser, field.value.type, " ", true);
+      code += field.name + " = ";
+      if (field.value.type.enum_def && IsScalar(field.value.type.base_type)) {
+        auto ev = field.value.type.enum_def->ReverseLookup(
+           static_cast<int>(StringToInt(field.value.constant.c_str())), false);
+        if (ev) {
+          code += WrapInNameSpace(parser,
+                                  field.value.type.enum_def->defined_namespace,
+                                  GenEnumVal(*field.value.type.enum_def, *ev,
+                                             opts));
+        } else {
+          code += GenUnderlyingCast(parser, field, true, field.value.constant);
+        }
+      } else {
+        code += field.value.constant;
+      }
     }
   }
   code += ") {\n  " + struct_def.name + "Builder builder_(_fbb);\n";
@@ -323,8 +392,18 @@ static void GenTable(const Parser &parser, StructDef &struct_def,
   code += "  return builder_.Finish();\n}\n\n";
 }
 
+static void GenPadding(const FieldDef &field, const std::function<void (int bits)> &f) {
+  if (field.padding) {
+    for (int i = 0; i < 4; i++)
+      if (static_cast<int>(field.padding) & (1 << i))
+        f((1 << i) * 8);
+    assert(!(field.padding & ~0xF));
+  }
+}
+
 // Generate an accessor struct with constructor for a flatbuffers struct.
-static void GenStruct(StructDef &struct_def, std::string *code_ptr) {
+static void GenStruct(const Parser &parser, StructDef &struct_def,
+                      std::string *code_ptr) {
   if (struct_def.generated) return;
   std::string &code = *code_ptr;
 
@@ -341,15 +420,12 @@ static void GenStruct(StructDef &struct_def, std::string *code_ptr) {
        it != struct_def.fields.vec.end();
        ++it) {
     auto &field = **it;
-    code += "  " + GenTypeGet(field.value.type, " ", "", " ");
+    code += "  " + GenTypeGet(parser, field.value.type, " ", "", " ", false);
     code += field.name + "_;\n";
-    if (field.padding) {
-      for (int i = 0; i < 4; i++)
-        if (static_cast<int>(field.padding) & (1 << i))
-          code += "  int" + NumToString((1 << i) * 8) +
-                  "_t __padding" + NumToString(padding_id++) + ";\n";
-      assert(!(field.padding & ~0xF));
-    }
+    GenPadding(field, [&code, &padding_id](int bits) {
+      code += "  int" + NumToString(bits) +
+              "_t __padding" + NumToString(padding_id++) + ";\n";
+    });
   }
 
   // Generate a constructor that takes all fields as arguments.
@@ -359,7 +435,8 @@ static void GenStruct(StructDef &struct_def, std::string *code_ptr) {
        ++it) {
     auto &field = **it;
     if (it != struct_def.fields.vec.begin()) code += ", ";
-    code += GenTypeGet(field.value.type, " ", "const ", " &") + field.name;
+    code += GenTypeGet(parser, field.value.type, " ", "const ", " &", true);
+    code += field.name;
   }
   code += ")\n    : ";
   padding_id = 0;
@@ -369,14 +446,30 @@ static void GenStruct(StructDef &struct_def, std::string *code_ptr) {
     auto &field = **it;
     if (it != struct_def.fields.vec.begin()) code += ", ";
     code += field.name + "_(";
-    if (IsScalar(field.value.type.base_type))
-      code += "flatbuffers::EndianScalar(" + field.name + "))";
-    else
+    if (IsScalar(field.value.type.base_type)) {
+      code += "flatbuffers::EndianScalar(";
+      code += GenUnderlyingCast(parser, field, false, field.name);
+      code += "))";
+    } else {
       code += field.name + ")";
-    if (field.padding)
+    }
+    GenPadding(field, [&code, &padding_id](int bits) {
+      (void)bits;
       code += ", __padding" + NumToString(padding_id++) + "(0)";
+    });
   }
-  code += " {}\n\n";
+  code += " {";
+  padding_id = 0;
+  for (auto it = struct_def.fields.vec.begin();
+       it != struct_def.fields.vec.end();
+       ++it) {
+    auto &field = **it;
+    GenPadding(field, [&code, &padding_id](int bits) {
+      (void)bits;
+      code += " (void)__padding" + NumToString(padding_id++) + ";";
+    });
+  }
+  code += " }\n\n";
 
   // Generate accessor methods of the form:
   // type name() const { return flatbuffers::EndianScalar(name_); }
@@ -385,63 +478,112 @@ static void GenStruct(StructDef &struct_def, std::string *code_ptr) {
        ++it) {
     auto &field = **it;
     GenComment(field.doc_comment, code_ptr, "  ");
-    code += "  " + GenTypeGet(field.value.type, " ", "const ", " &");
+    code += "  " + GenTypeGet(parser, field.value.type, " ", "const ", " &",
+                              true);
     code += field.name + "() const { return ";
-    if (IsScalar(field.value.type.base_type))
-      code += "flatbuffers::EndianScalar(" + field.name + "_)";
-    else
-      code += field.name + "_";
+    code += GenUnderlyingCast(parser, field, true,
+      IsScalar(field.value.type.base_type)
+        ? "flatbuffers::EndianScalar(" + field.name + "_)"
+        : field.name + "_");
     code += "; }\n";
   }
   code += "};\nSTRUCT_END(" + struct_def.name + ", ";
   code += NumToString(struct_def.bytesize) + ");\n\n";
 }
 
+void GenerateNestedNameSpaces(Namespace *ns, std::string *code_ptr) {
+  for (auto it = ns->components.begin(); it != ns->components.end(); ++it) {
+    *code_ptr += "namespace " + *it + " {\n";
+  }
+}
+
+void CloseNestedNameSpaces(Namespace *ns, std::string *code_ptr) {
+  for (auto it = ns->components.rbegin(); it != ns->components.rend(); ++it) {
+    *code_ptr += "}  // namespace " + *it + "\n";
+  }
+}
+
 }  // namespace cpp
 
 // Iterate through all definitions we haven't generate code for (enums, structs,
 // and tables) and output them to a single file.
-std::string GenerateCPP(const Parser &parser, const std::string &include_guard_ident) {
+std::string GenerateCPP(const Parser &parser,
+                        const std::string &file_name,
+                        const GeneratorOptions &opts) {
   using namespace cpp;
 
   // Generate code for all the enum declarations.
   std::string enum_code, enum_code_post;
   for (auto it = parser.enums_.vec.begin();
        it != parser.enums_.vec.end(); ++it) {
-    GenEnum(**it, &enum_code, &enum_code_post);
+    GenEnum(**it, &enum_code, &enum_code_post, opts);
   }
 
   // Generate forward declarations for all structs/tables, since they may
   // have circular references.
-  std::string forward_decl_code;
+  std::string forward_decl_code_same_namespace;
+  std::string forward_decl_code_other_namespace;
+  Namespace *cur_name_space = nullptr;
   for (auto it = parser.structs_.vec.begin();
        it != parser.structs_.vec.end(); ++it) {
-    if (!(*it)->generated)
-      forward_decl_code += "struct " + (*it)->name + ";\n";
+    auto &struct_def = **it;
+    auto decl = "struct " + struct_def.name + ";\n";
+    if (struct_def.defined_namespace == parser.namespaces_.back()) {
+      forward_decl_code_same_namespace += decl;
+    } else {
+      // Wrap this decl in the correct namespace. Only open a namespace if
+      // the adjacent one is different.
+      // TODO: this could be done more intelligently, by sorting to
+      // namespace path and only opening/closing what is necessary, but that's
+      // quite a bit more complexity.
+      if (cur_name_space != struct_def.defined_namespace) {
+        if (cur_name_space) {
+          CloseNestedNameSpaces(cur_name_space,
+                                &forward_decl_code_other_namespace);
+        }
+        GenerateNestedNameSpaces(struct_def.defined_namespace,
+                                 &forward_decl_code_other_namespace);
+        cur_name_space = struct_def.defined_namespace;
+      }
+      forward_decl_code_other_namespace += decl;
+    }
+  }
+  if (cur_name_space) {
+    CloseNestedNameSpaces(cur_name_space,
+                          &forward_decl_code_other_namespace);
   }
 
   // Generate code for all structs, then all tables.
   std::string decl_code;
   for (auto it = parser.structs_.vec.begin();
        it != parser.structs_.vec.end(); ++it) {
-    if ((**it).fixed) GenStruct(**it, &decl_code);
+    if ((**it).fixed) GenStruct(parser, **it, &decl_code);
   }
   for (auto it = parser.structs_.vec.begin();
        it != parser.structs_.vec.end(); ++it) {
-    if (!(**it).fixed) GenTable(parser, **it, &decl_code);
+    if (!(**it).fixed) GenTable(parser, **it, opts, &decl_code);
   }
 
   // Only output file-level code if there were any declarations.
-  if (enum_code.length() || forward_decl_code.length() || decl_code.length()) {
+  if (enum_code.length() || decl_code.length()) {
     std::string code;
     code = "// automatically generated by the FlatBuffers compiler,"
            " do not modify\n\n";
 
     // Generate include guard.
+    std::string include_guard_ident = file_name;
+    // Remove any non-alpha-numeric characters that may appear in a filename.
+    include_guard_ident.erase(
+      std::remove_if(include_guard_ident.begin(),
+                     include_guard_ident.end(),
+                     [](char c) { return !isalnum(c); }),
+      include_guard_ident.end());
     std::string include_guard = "FLATBUFFERS_GENERATED_" + include_guard_ident;
     include_guard += "_";
-    for (auto it = parser.name_space_.begin();
-         it != parser.name_space_.end(); ++it) {
+    // For further uniqueness, also add the namespace.
+    auto name_space = parser.namespaces_.back();
+    for (auto it = name_space->components.begin();
+             it != name_space->components.end(); ++it) {
       include_guard += *it + "_";
     }
     include_guard += "H_";
@@ -452,17 +594,31 @@ std::string GenerateCPP(const Parser &parser, const std::string &include_guard_i
 
     code += "#include \"flatbuffers/flatbuffers.h\"\n\n";
 
-    // Generate nested namespaces.
-    for (auto it = parser.name_space_.begin();
-         it != parser.name_space_.end(); ++it) {
-      code += "namespace " + *it + " {\n";
+    if (opts.include_dependence_headers) {
+      int num_includes = 0;
+      for (auto it = parser.included_files_.begin();
+           it != parser.included_files_.end(); ++it) {
+        auto basename = flatbuffers::StripPath(
+                          flatbuffers::StripExtension(it->first));
+        if (basename != file_name) {
+          code += "#include \"" + basename + "_generated.h\"\n";
+          num_includes++;
+        }
+      }
+      if (num_includes) code += "\n";
     }
 
+    code += forward_decl_code_other_namespace;
+    code += "\n";
+
+    GenerateNestedNameSpaces(name_space, &code);
+    code += "\n";
+
+    code += forward_decl_code_same_namespace;
+    code += "\n";
+
     // Output the main declaration code from above.
-    code += "\n";
     code += enum_code;
-    code += forward_decl_code;
-    code += "\n";
     code += decl_code;
     code += enum_code_post;
 
@@ -477,7 +633,7 @@ std::string GenerateCPP(const Parser &parser, const std::string &include_guard_i
       // The root verifier:
       code += "inline bool Verify";
       code += parser.root_struct_def->name;
-      code += "Buffer(const flatbuffers::Verifier &verifier) { "
+      code += "Buffer(flatbuffers::Verifier &verifier) { "
               "return verifier.VerifyBuffer<";
       code += parser.root_struct_def->name + ">(); }\n\n";
 
@@ -498,11 +654,7 @@ std::string GenerateCPP(const Parser &parser, const std::string &include_guard_i
       }
     }
 
-    // Close the namespaces.
-    for (auto it = parser.name_space_.rbegin();
-         it != parser.name_space_.rend(); ++it) {
-      code += "}  // namespace " + *it + "\n";
-    }
+    CloseNestedNameSpaces(name_space, &code);
 
     // Close the include guard.
     code += "\n#endif  // " + include_guard + "\n";
@@ -516,8 +668,8 @@ std::string GenerateCPP(const Parser &parser, const std::string &include_guard_i
 bool GenerateCPP(const Parser &parser,
                  const std::string &path,
                  const std::string &file_name,
-                 const GeneratorOptions & /*opts*/) {
-    auto code = GenerateCPP(parser, file_name);
+                 const GeneratorOptions &opts) {
+    auto code = GenerateCPP(parser, file_name, opts);
     return !code.length() ||
            SaveFile((path + file_name + "_generated.h").c_str(), code, false);
 }

src/idl_gen_fbs.cpp

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// independent from idl_parser, since this code is not needed for most clients
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/util.h"
+
+namespace flatbuffers {
+
+static std::string GenType(const Type &type) {
+  switch (type.base_type) {
+    case BASE_TYPE_STRUCT: return type.struct_def->name;
+    case BASE_TYPE_UNION:  return type.enum_def->name;
+    case BASE_TYPE_VECTOR: return "[" + GenType(type.VectorType()) + "]";
+    default: return kTypeNames[type.base_type];
+  }
+}
+
+// Generate a flatbuffer schema from the Parser's internal representation.
+std::string GenerateFBS(const Parser &parser, const std::string &file_name,
+                        const GeneratorOptions &opts) {
+  std::string schema;
+  schema += "// Generated from " + file_name + ".proto\n\n";
+  if (opts.include_dependence_headers) {
+    int num_includes = 0;
+    for (auto it = parser.included_files_.begin();
+         it != parser.included_files_.end(); ++it) {
+      auto basename = flatbuffers::StripPath(
+                        flatbuffers::StripExtension(it->first));
+      if (basename != file_name) {
+        schema += "include \"" + basename + ".fbs\";\n";
+        num_includes++;
+      }
+    }
+    if (num_includes) schema += "\n";
+  }
+  schema += "namespace ";
+  auto name_space = parser.namespaces_.back();
+  for (auto it = name_space->components.begin();
+           it != name_space->components.end(); ++it) {
+    if (it != name_space->components.begin()) schema += ".";
+    schema += *it;
+  }
+  schema += ";\n\n";
+  // Generate code for all the enum declarations.
+  for (auto it = parser.enums_.vec.begin();
+           it != parser.enums_.vec.end(); ++it) {
+    EnumDef &enum_def = **it;
+    schema += "enum " + enum_def.name + " : ";
+    schema += GenType(enum_def.underlying_type) + " {\n";
+    for (auto it = enum_def.vals.vec.begin();
+         it != enum_def.vals.vec.end(); ++it) {
+      auto &ev = **it;
+      schema += "  " + ev.name + " = " + NumToString(ev.value) + ",\n";
+    }
+    schema += "}\n\n";
+  }
+  // Generate code for all structs/tables.
+  for (auto it = parser.structs_.vec.begin();
+           it != parser.structs_.vec.end(); ++it) {
+    StructDef &struct_def = **it;
+    schema += "table " + struct_def.name + " {\n";
+    for (auto it = struct_def.fields.vec.begin();
+             it != struct_def.fields.vec.end(); ++it) {
+      auto &field = **it;
+      schema += "  " + field.name + ":" + GenType(field.value.type);
+      if (field.value.constant != "0") schema += " = " + field.value.constant;
+      if (field.required) schema += " (required)";
+      schema += ";\n";
+    }
+    schema += "}\n\n";
+  }
+  return schema;
+}
+
+bool GenerateFBS(const Parser &parser,
+                 const std::string &path,
+                 const std::string &file_name,
+                 const GeneratorOptions &opts) {
+  return SaveFile((path + file_name + ".fbs").c_str(),
+                  GenerateFBS(parser, file_name, opts), false);
+}
+
+}  // namespace flatbuffers
+

src/idl_gen_general.cpp

@@ -0,0 +1,644 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// independent from idl_parser, since this code is not needed for most clients
+
+#include "flatbuffers/flatbuffers.h"
+#include "flatbuffers/idl.h"
+#include "flatbuffers/util.h"
+
+namespace flatbuffers {
+
+// Convert an underscore_based_indentifier in to camelCase.
+// Also uppercases the first character if first is true.
+std::string MakeCamel(const std::string &in, bool first) {
+  std::string s;
+  for (size_t i = 0; i < in.length(); i++) {
+    if (!i && first)
+      s += static_cast<char>(toupper(in[0]));
+    else if (in[i] == '_' && i + 1 < in.length())
+      s += static_cast<char>(toupper(in[++i]));
+    else
+      s += in[i];
+  }
+  return s;
+}
+
+// Generate a documentation comment, if available.
+void GenComment(const std::vector<std::string> &dc, std::string *code_ptr,
+                const char *prefix) {
+  std::string &code = *code_ptr;
+  for (auto it = dc.begin();
+       it != dc.end();
+       ++it) {
+    code += std::string(prefix) + "///" + *it + "\n";
+  }
+}
+
+// These arrays need to correspond to the GeneratorOptions::k enum.
+
+struct LanguageParameters {
+  GeneratorOptions::Language language;
+  // Whether function names in the language typically start with uppercase.
+  bool first_camel_upper;
+  const char *file_extension;
+  const char *string_type;
+  const char *bool_type;
+  const char *open_curly;
+  const char *const_decl;
+  const char *inheritance_marker;
+  const char *namespace_ident;
+  const char *namespace_begin;
+  const char *namespace_end;
+  const char *set_bb_byteorder;
+  const char *includes;
+};
+
+LanguageParameters language_parameters[] = {
+  {
+    GeneratorOptions::kJava,
+    false,
+    ".java",
+    "String",
+    "boolean ",
+    " {\n",
+    " final ",
+    " extends ",
+    "package ",
+    ";",
+    "",
+    "_bb.order(ByteOrder.LITTLE_ENDIAN); ",
+    "import java.nio.*;\nimport java.lang.*;\nimport java.util.*;\n"
+      "import com.google.flatbuffers.*;\n\n",
+  },
+  {
+    GeneratorOptions::kCSharp,
+    true,
+    ".cs",
+    "string",
+    "bool ",
+    "\n{\n",
+    " readonly ",
+    " : ",
+    "namespace ",
+    "\n{",
+    "\n}\n",
+    "",
+    "using FlatBuffers;\n\n",
+  }
+};
+
+static_assert(sizeof(language_parameters) / sizeof(LanguageParameters) ==
+              GeneratorOptions::kMAX,
+              "Please add extra elements to the arrays above.");
+
+static std::string FunctionStart(const LanguageParameters &lang, char upper) {
+  return std::string() +
+      (lang.language == GeneratorOptions::kJava
+         ? static_cast<char>(tolower(upper))
+         : upper);
+}
+
+static std::string GenTypeBasic(const LanguageParameters &lang,
+                                const Type &type) {
+  static const char *gtypename[] = {
+    #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
+        #JTYPE, #NTYPE,
+      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
+    #undef FLATBUFFERS_TD
+  };
+  return gtypename[type.base_type * GeneratorOptions::kMAX + lang.language];
+}
+
+static std::string GenTypeGet(const LanguageParameters &lang,
+                              const Type &type);
+
+static std::string GenTypePointer(const LanguageParameters &lang,
+                                  const Type &type) {
+  switch (type.base_type) {
+    case BASE_TYPE_STRING:
+      return lang.string_type;
+    case BASE_TYPE_VECTOR:
+      return GenTypeGet(lang, type.VectorType());
+    case BASE_TYPE_STRUCT:
+      return type.struct_def->name;
+    case BASE_TYPE_UNION:
+      // fall through
+    default:
+      return "Table";
+  }
+}
+
+static std::string GenTypeGet(const LanguageParameters &lang,
+                              const Type &type) {
+  return IsScalar(type.base_type)
+    ? GenTypeBasic(lang, type)
+    : GenTypePointer(lang, type);
+}
+
+static void GenEnum(const LanguageParameters &lang, EnumDef &enum_def,
+                    std::string *code_ptr) {
+  std::string &code = *code_ptr;
+  if (enum_def.generated) return;
+
+  // Generate enum definitions of the form:
+  // public static (final) int name = value;
+  // In Java, we use ints rather than the Enum feature, because we want them
+  // to map directly to how they're used in C/C++ and file formats.
+  // That, and Java Enums are expensive, and not universally liked.
+  GenComment(enum_def.doc_comment, code_ptr);
+  code += "public class " + enum_def.name + lang.open_curly;
+  for (auto it = enum_def.vals.vec.begin();
+       it != enum_def.vals.vec.end();
+       ++it) {
+    auto &ev = **it;
+    GenComment(ev.doc_comment, code_ptr, "  ");
+    code += "  public static";
+    code += lang.const_decl;
+    code += GenTypeBasic(lang, enum_def.underlying_type);
+    code += " " + ev.name + " = ";
+    code += NumToString(ev.value) + ";\n";
+  }
+
+  // Generate a generate string table for enum values.
+  // Problem is, if values are very sparse that could generate really big
+  // tables. Ideally in that case we generate a map lookup instead, but for
+  // the moment we simply don't output a table at all.
+  auto range = enum_def.vals.vec.back()->value -
+               enum_def.vals.vec.front()->value + 1;
+  // Average distance between values above which we consider a table
+  // "too sparse". Change at will.
+  static const int kMaxSparseness = 5;
+  if (range / static_cast<int64_t>(enum_def.vals.vec.size()) < kMaxSparseness) {
+    code += "\n  private static";
+    code += lang.const_decl;
+    code += lang.string_type;
+    code += "[] names = { ";
+    auto val = enum_def.vals.vec.front()->value;
+    for (auto it = enum_def.vals.vec.begin();
+         it != enum_def.vals.vec.end();
+         ++it) {
+      while (val++ != (*it)->value) code += "\"\", ";
+      code += "\"" + (*it)->name + "\", ";
+    }
+    code += "};\n\n";
+    code += "  public static ";
+    code += lang.string_type;
+    code += " " + MakeCamel("name", lang.first_camel_upper);
+    code += "(int e) { return names[e";
+    if (enum_def.vals.vec.front()->value)
+      code += " - " + enum_def.vals.vec.front()->name;
+    code += "]; }\n";
+  }
+
+  // Close the class
+  code += "};\n\n";
+}
+
+// Returns the function name that is able to read a value of the given type.
+static std::string GenGetter(const LanguageParameters &lang,
+                             const Type &type) {
+  switch (type.base_type) {
+    case BASE_TYPE_STRING: return "__string";
+    case BASE_TYPE_STRUCT: return "__struct";
+    case BASE_TYPE_UNION: return "__union";
+    case BASE_TYPE_VECTOR: return GenGetter(lang, type.VectorType());
+    default:
+      return "bb." + FunctionStart(lang, 'G') + "et" +
+        (GenTypeBasic(lang, type) != "byte"
+          ? MakeCamel(GenTypeGet(lang, type))
+          : "");
+  }
+}
+
+// Returns the method name for use with add/put calls.
+static std::string GenMethod(const LanguageParameters &lang, const Type &type) {
+  return IsScalar(type.base_type)
+    ? MakeCamel(GenTypeBasic(lang, type))
+    : (IsStruct(type) ? "Struct" : "Offset");
+}
+
+// Recursively generate arguments for a constructor, to deal with nested
+// structs.
+static void GenStructArgs(const LanguageParameters &lang,
+                          const StructDef &struct_def,
+                          std::string *code_ptr, const char *nameprefix) {
+  std::string &code = *code_ptr;
+  for (auto it = struct_def.fields.vec.begin();
+       it != struct_def.fields.vec.end();
+       ++it) {
+    auto &field = **it;
+    if (IsStruct(field.value.type)) {
+      // Generate arguments for a struct inside a struct. To ensure names
+      // don't clash, and to make it obvious these arguments are constructing
+      // a nested struct, prefix the name with the struct name.
+      GenStructArgs(lang, *field.value.type.struct_def, code_ptr,
+                    (field.value.type.struct_def->name + "_").c_str());
+    } else {
+      code += ", " + GenTypeBasic(lang, field.value.type) + " " + nameprefix;
+      code += MakeCamel(field.name, lang.first_camel_upper);
+    }
+  }
+}
+
+// Recusively generate struct construction statements of the form:
+// builder.putType(name);
+// and insert manual padding.
+static void GenStructBody(const LanguageParameters &lang,
+                          const StructDef &struct_def,
+                          std::string *code_ptr, const char *nameprefix) {
+  std::string &code = *code_ptr;
+  code += "    builder." + FunctionStart(lang, 'P') + "rep(";
+  code += NumToString(struct_def.minalign) + ", ";
+  code += NumToString(struct_def.bytesize) + ");\n";
+  for (auto it = struct_def.fields.vec.rbegin();
+       it != struct_def.fields.vec.rend(); ++it) {
+    auto &field = **it;
+    if (field.padding) {
+      code += "    builder." + FunctionStart(lang, 'P') + "ad(";
+      code += NumToString(field.padding) + ");\n";
+    }
+    if (IsStruct(field.value.type)) {
+      GenStructBody(lang, *field.value.type.struct_def, code_ptr,
+                    (field.value.type.struct_def->name + "_").c_str());
+    } else {
+      code += "    builder." + FunctionStart(lang, 'P') + "ut";
+      code += GenMethod(lang, field.value.type) + "(" += nameprefix;
+      code += MakeCamel(field.name, lang.first_camel_upper) + ");\n";
+    }
+  }
+}
+
+static void GenStruct(const LanguageParameters &lang, const Parser &parser,
+                      StructDef &struct_def, std::string *code_ptr) {
+  if (struct_def.generated) return;
+  std::string &code = *code_ptr;
+
+  // Generate a struct accessor class, with methods of the form:
+  // public type name() { return bb.getType(i + offset); }
+  // or for tables of the form:
+  // public type name() {
+  //   int o = __offset(offset); return o != 0 ? bb.getType(o + i) : default;
+  // }
+  GenComment(struct_def.doc_comment, code_ptr);
+  code += "public class " + struct_def.name + lang.inheritance_marker;
+  code += struct_def.fixed ? "Struct" : "Table";
+  code += " {\n";
+  if (!struct_def.fixed) {
+    // Generate a special accessor for the table that when used as the root
+    // of a FlatBuffer
+    code += "  public static " + struct_def.name + " ";
+    code += FunctionStart(lang, 'G') + "etRootAs" + struct_def.name;
+    code += "(ByteBuffer _bb) { ";
+    code += lang.set_bb_byteorder;
+    code += "return (new " + struct_def.name;
+    code += "()).__init(_bb." + FunctionStart(lang, 'G');
+    code += "etInt(_bb.position()) + _bb.position(), _bb); }\n";
+    if (parser.root_struct_def == &struct_def) {
+      if (parser.file_identifier_.length()) {
+        // Check if a buffer has the identifier.
+        code += "  public static ";
+        code += lang.bool_type + struct_def.name;
+        code += "BufferHasIdentifier(ByteBuffer _bb) { return ";
+        code += "__has_identifier(_bb, \"" + parser.file_identifier_;
+        code += "\"); }\n";
+      }
+    }
+  }
+  // Generate the __init method that sets the field in a pre-existing
+  // accessor object. This is to allow object reuse.
+  code += "  public " + struct_def.name;
+  code += " __init(int _i, ByteBuffer _bb) ";
+  code += "{ bb_pos = _i; bb = _bb; return this; }\n\n";
+  for (auto it = struct_def.fields.vec.begin();
+       it != struct_def.fields.vec.end();
+       ++it) {
+    auto &field = **it;
+    if (field.deprecated) continue;
+    GenComment(field.doc_comment, code_ptr, "  ");
+    std::string type_name = GenTypeGet(lang, field.value.type);
+    std::string method_start = "  public " + type_name + " " +
+                               MakeCamel(field.name, lang.first_camel_upper);
+    // Generate the accessors that don't do object reuse.
+    if (field.value.type.base_type == BASE_TYPE_STRUCT) {
+      // Calls the accessor that takes an accessor object with a new object.
+      code += method_start + "() { return ";
+      code += MakeCamel(field.name, lang.first_camel_upper);
+      code += "(new ";
+      code += type_name + "()); }\n";
+    } else if (field.value.type.base_type == BASE_TYPE_VECTOR &&
+               field.value.type.element == BASE_TYPE_STRUCT) {
+      // Accessors for vectors of structs also take accessor objects, this
+      // generates a variant without that argument.
+      code += method_start + "(int j) { return ";
+      code += MakeCamel(field.name, lang.first_camel_upper);
+      code += "(new ";
+      code += type_name + "(), j); }\n";
+    }
+    std::string getter = GenGetter(lang, field.value.type);
+    code += method_start + "(";
+    // Most field accessors need to retrieve and test the field offset first,
+    // this is the prefix code for that:
+    auto offset_prefix = ") { int o = __offset(" +
+                         NumToString(field.value.offset) +
+                         "); return o != 0 ? ";
+    std::string default_cast = "";
+    if (lang.language == GeneratorOptions::kCSharp)
+      default_cast = "(" + type_name + ")";
+    if (IsScalar(field.value.type.base_type)) {
+      if (struct_def.fixed) {
+        code += ") { return " + getter;
+        code += "(bb_pos + " + NumToString(field.value.offset) + ")";
+      } else {
+        code += offset_prefix + getter;
+        code += "(o + bb_pos) : " + default_cast + field.value.constant;
+      }
+    } else {
+      switch (field.value.type.base_type) {
+        case BASE_TYPE_STRUCT:
+          code += type_name + " obj";
+          if (struct_def.fixed) {
+            code += ") { return obj.__init(bb_pos + ";
+            code += NumToString(field.value.offset) + ", bb)";
+          } else {
+            code += offset_prefix;
+            code += "obj.__init(";
+            code += field.value.type.struct_def->fixed
+                      ? "o + bb_pos"
+                      : "__indirect(o + bb_pos)";
+            code += ", bb) : null";
+          }
+          break;
+        case BASE_TYPE_STRING:
+          code += offset_prefix + getter +"(o + bb_pos) : null";
+          break;
+        case BASE_TYPE_VECTOR: {
+          auto vectortype = field.value.type.VectorType();
+          if (vectortype.base_type == BASE_TYPE_STRUCT) {
+            code += type_name + " obj, ";
+            getter = "obj.__init";
+          }
+          code += "int j" + offset_prefix + getter +"(";
+          auto index = "__vector(o) + j * " +
+                       NumToString(InlineSize(vectortype));
+          if (vectortype.base_type == BASE_TYPE_STRUCT) {
+            code += vectortype.struct_def->fixed
+                      ? index
+                      : "__indirect(" + index + ")";
+            code += ", bb";
+          } else {
+            code += index;
+          }
+          code += ") : ";
+          code += IsScalar(field.value.type.element)
+                  ? default_cast + "0"
+                  : "null";
+          break;
+        }
+        case BASE_TYPE_UNION:
+          code += type_name + " obj" + offset_prefix + getter;
+          code += "(obj, o) : null";
+          break;
+        default:
+          assert(0);
+      }
+    }
+    code += "; }\n";
+    if (field.value.type.base_type == BASE_TYPE_VECTOR) {
+      code += "  public int " + MakeCamel(field.name, lang.first_camel_upper);
+      code += "Length(" + offset_prefix;
+      code += "__vector_len(o) : 0; }\n";
+    }
+    if ((field.value.type.base_type == BASE_TYPE_VECTOR ||
+         field.value.type.base_type == BASE_TYPE_STRING) &&
+        lang.language == GeneratorOptions::kJava) {
+      code += "  public ByteBuffer ";
+      code += MakeCamel(field.name, lang.first_camel_upper);
+      code += "AsByteBuffer() { return __vector_as_bytebuffer(";
+      code += NumToString(field.value.offset) + ", ";
+      code += NumToString(field.value.type.base_type == BASE_TYPE_STRING ? 1 :
+                          InlineSize(field.value.type.VectorType()));
+      code += "); }\n";
+    }
+  }
+  code += "\n";
+  if (struct_def.fixed) {
+    // create a struct constructor function
+    code += "  public static int " + FunctionStart(lang, 'C') + "reate";
+    code += struct_def.name + "(FlatBufferBuilder builder";
+    GenStructArgs(lang, struct_def, code_ptr, "");
+    code += ") {\n";
+    GenStructBody(lang, struct_def, code_ptr, "");
+    code += "    return builder.";
+    code += FunctionStart(lang, 'O') + "ffset();\n  }\n";
+  } else {
+    // Generate a method that creates a table in one go. This is only possible
+    // when the table has no struct fields, since those have to be created
+    // inline, and there's no way to do so in Java.
+    bool has_no_struct_fields = true;
+    int num_fields = 0;
+    for (auto it = struct_def.fields.vec.begin();
+         it != struct_def.fields.vec.end(); ++it) {
+      auto &field = **it;
+      if (field.deprecated) continue;
+      if (IsStruct(field.value.type)) {
+        has_no_struct_fields = false;
+      } else {
+        num_fields++;
+      }
+    }
+    if (has_no_struct_fields && num_fields) {
+      // Generate a table constructor of the form:
+      // public static void createName(FlatBufferBuilder builder, args...)
+      code += "  public static int " + FunctionStart(lang, 'C') + "reate";
+      code += struct_def.name;
+      code += "(FlatBufferBuilder builder";
+      for (auto it = struct_def.fields.vec.begin();
+           it != struct_def.fields.vec.end(); ++it) {
+        auto &field = **it;
+        if (field.deprecated) continue;
+        code += ",\n      " + GenTypeBasic(lang, field.value.type) + " ";
+        code += field.name;
+        // Java doesn't have defaults, which means this method must always
+        // supply all arguments, and thus won't compile when fields are added.
+        if (lang.language != GeneratorOptions::kJava)
+          code += " = " + field.value.constant;
+      }
+      code += ") {\n    builder.";
+      code += FunctionStart(lang, 'S') + "tartObject(";
+      code += NumToString(struct_def.fields.vec.size()) + ");\n";
+      for (size_t size = struct_def.sortbysize ? sizeof(largest_scalar_t) : 1;
+           size;
+           size /= 2) {
+        for (auto it = struct_def.fields.vec.rbegin();
+             it != struct_def.fields.vec.rend(); ++it) {
+          auto &field = **it;
+          if (!field.deprecated &&
+              (!struct_def.sortbysize ||
+               size == SizeOf(field.value.type.base_type))) {
+            code += "    " + struct_def.name + ".";
+            code += FunctionStart(lang, 'A') + "dd";
+            code += MakeCamel(field.name) + "(builder, " + field.name + ");\n";
+          }
+        }
+      }
+      code += "    return " + struct_def.name + ".";
+      code += FunctionStart(lang, 'E') + "nd" + struct_def.name;
+      code += "(builder);\n  }\n\n";
+    }
+    // Generate a set of static methods that allow table construction,
+    // of the form:
+    // public static void addName(FlatBufferBuilder builder, short name)
+    // { builder.addShort(id, name, default); }
+    // Unlike the Create function, these always work.
+    code += "  public static void " + FunctionStart(lang, 'S') + "tart";
+    code += struct_def.name;
+    code += "(FlatBufferBuilder builder) { builder.";
+    code += FunctionStart(lang, 'S') + "tartObject(";
+    code += NumToString(struct_def.fields.vec.size()) + "); }\n";
+    for (auto it = struct_def.fields.vec.begin();
+         it != struct_def.fields.vec.end(); ++it) {
+      auto &field = **it;
+      if (field.deprecated) continue;
+      code += "  public static void " + FunctionStart(lang, 'A') + "dd";
+      code += MakeCamel(field.name);
+      code += "(FlatBufferBuilder builder, ";
+      code += GenTypeBasic(lang, field.value.type);
+      auto argname = MakeCamel(field.name, false);
+      if (!IsScalar(field.value.type.base_type)) argname += "Offset";
+      code += " " + argname + ") { builder." + FunctionStart(lang, 'A') + "dd";
+      code += GenMethod(lang, field.value.type) + "(";
+      code += NumToString(it - struct_def.fields.vec.begin()) + ", ";
+      code += argname + ", " + field.value.constant;
+      code += "); }\n";
+      if (field.value.type.base_type == BASE_TYPE_VECTOR) {
+        auto vector_type = field.value.type.VectorType();
+        auto alignment = InlineAlignment(vector_type);
+        auto elem_size = InlineSize(vector_type);
+        if (!IsStruct(vector_type)) {
+          // Generate a method to create a vector from a Java array.
+          code += "  public static int " + FunctionStart(lang, 'C') + "reate";
+          code += MakeCamel(field.name);
+          code += "Vector(FlatBufferBuilder builder, ";
+          code += GenTypeBasic(lang, vector_type) + "[] data) ";
+          code += "{ builder." + FunctionStart(lang, 'S') + "tartVector(";
+          code += NumToString(elem_size);
+          code += ", data." + FunctionStart(lang, 'L') + "ength, ";
+          code += NumToString(alignment);
+          code += "); for (int i = data.";
+          code += FunctionStart(lang, 'L') + "ength - 1; i >= 0; i--) builder.";
+          code += FunctionStart(lang, 'A') + "dd";
+          code += GenMethod(lang, vector_type);
+          code += "(data[i]); return builder.";
+          code += FunctionStart(lang, 'E') + "ndVector(); }\n";
+        }
+        // Generate a method to start a vector, data to be added manually after.
+        code += "  public static void " + FunctionStart(lang, 'S') + "tart";
+        code += MakeCamel(field.name);
+        code += "Vector(FlatBufferBuilder builder, int numElems) ";
+        code += "{ builder." + FunctionStart(lang, 'S') + "tartVector(";
+        code += NumToString(elem_size);
+        code += ", numElems, " + NumToString(alignment);
+        code += "); }\n";
+      }
+    }
+    code += "  public static int ";
+    code += FunctionStart(lang, 'E') + "nd" + struct_def.name;
+    code += "(FlatBufferBuilder builder) {\n    int o = builder.";
+    code += FunctionStart(lang, 'E') + "ndObject();\n";
+    for (auto it = struct_def.fields.vec.begin();
+         it != struct_def.fields.vec.end();
+         ++it) {
+      auto &field = **it;
+      if (!field.deprecated && field.required) {
+        code += "    builder." + FunctionStart(lang, 'R') + "equired(o, ";
+        code += NumToString(field.value.offset);
+        code += ");  // " + field.name + "\n";
+      }
+    }
+    code += "    return o;\n  }\n";
+    if (parser.root_struct_def == &struct_def) {
+      code += "  public static void ";
+      code += FunctionStart(lang, 'F') + "inish" + struct_def.name;
+      code += "Buffer(FlatBufferBuilder builder, int offset) { ";
+      code += "builder." + FunctionStart(lang, 'F') + "inish(offset";
+      if (parser.file_identifier_.length())
+        code += ", \"" + parser.file_identifier_ + "\"";
+      code += "); }\n";
+    }
+  }
+  code += "};\n\n";
+}
+
+// Save out the generated code for a single class while adding
+// declaration boilerplate.
+static bool SaveClass(const LanguageParameters &lang, const Parser &parser,
+                      const Definition &def, const std::string &classcode,
+                      const std::string &path, bool needs_includes) {
+  if (!classcode.length()) return true;
+
+  std::string namespace_general;
+  std::string namespace_dir = path;
+  auto &namespaces = parser.namespaces_.back()->components;
+  for (auto it = namespaces.begin(); it != namespaces.end(); ++it) {
+    if (namespace_general.length()) {
+      namespace_general += ".";
+      namespace_dir += kPathSeparator;
+    }
+    namespace_general += *it;
+    namespace_dir += *it;
+  }
+  EnsureDirExists(namespace_dir);
+
+  std::string code = "// automatically generated, do not modify\n\n";
+  code += lang.namespace_ident + namespace_general + lang.namespace_begin;
+  code += "\n\n";
+  if (needs_includes) code += lang.includes;
+  code += classcode;
+  code += lang.namespace_end;
+  auto filename = namespace_dir + kPathSeparator + def.name +
+                  lang.file_extension;
+  return SaveFile(filename.c_str(), code, false);
+}
+
+bool GenerateGeneral(const Parser &parser,
+                     const std::string &path,
+                     const std::string & /*file_name*/,
+                     const GeneratorOptions &opts) {
+
+  assert(opts.lang <= GeneratorOptions::kMAX);
+  auto lang = language_parameters[opts.lang];
+
+  for (auto it = parser.enums_.vec.begin();
+       it != parser.enums_.vec.end(); ++it) {
+    std::string enumcode;
+    GenEnum(lang, **it, &enumcode);
+    if (!SaveClass(lang, parser, **it, enumcode, path, false))
+      return false;
+  }
+
+  for (auto it = parser.structs_.vec.begin();
+       it != parser.structs_.vec.end(); ++it) {
+    std::string declcode;
+    GenStruct(lang, parser, **it, &declcode);
+    if (!SaveClass(lang, parser, **it, declcode, path, true))
+      return false;
+  }
+
+  return true;
+}
+
+}  // namespace flatbuffers

src/idl_gen_go.cpp

@@ -44,16 +44,6 @@ static std::string GenTypeGet(const Type &type);
 static std::string TypeName(const FieldDef &field);
 
 
-// Write a comment.
-static void Comment(const std::string &dc,
-                       std::string *code_ptr,
-                       const char *prefix = "") {
-  std::string &code = *code_ptr;
-  if (dc.length()) {
-    code += std::string(prefix) + "///" + dc + "\n";
-  }
-}
-
 // Most field accessors need to retrieve and test the field offset first,
 // this is the prefix code for that.
 std::string OffsetPrefix(const FieldDef &field) {
@@ -235,7 +225,7 @@ static void GetStringField(const StructDef &struct_def,
   code += " " +  MakeCamel(field.name);
   code += "() " + TypeName(field) + " ";
   code += OffsetPrefix(field) + "\t\treturn " + GenGetter(field.value.type);
-  code += "(o)\n\t}\n\treturn \"\"\n";
+  code += "(o + rcv._tab.Pos)\n\t}\n\treturn \"\"\n";
   code += "}\n\n";
 }
 
@@ -426,8 +416,12 @@ static void BuildVectorOfTable(const StructDef &struct_def,
   code += MakeCamel(field.name);
   code += "Vector(builder *flatbuffers.Builder, numElems int) ";
   code += "flatbuffers.UOffsetT { return builder.StartVector(";
-  code += NumToString(InlineSize(field.value.type.VectorType()));
-  code += ", numElems) }\n";
+  auto vector_type = field.value.type.VectorType();
+  auto alignment = InlineAlignment(vector_type);
+  auto elem_size = InlineSize(vector_type);
+  code += NumToString(elem_size);
+  code += ", numElems, " + NumToString(alignment);
+  code += ")\n}\n";
 }
 
 // Get the offset of the end of a table.
@@ -449,7 +443,7 @@ static void GenReceiver(const StructDef &struct_def, std::string *code_ptr) {
 static void GenStructAccessor(const StructDef &struct_def,
                               const FieldDef &field,
                               std::string *code_ptr) {
-  Comment(field.doc_comment, code_ptr, "");
+  GenComment(field.doc_comment, code_ptr, "");
   if (IsScalar(field.value.type.base_type)) {
     if (struct_def.fixed) {
       GetScalarFieldOfStruct(struct_def, field, code_ptr);
@@ -516,7 +510,7 @@ static void GenStruct(const StructDef &struct_def,
                       StructDef *root_struct_def) {
   if (struct_def.generated) return;
 
-  Comment(struct_def.doc_comment, code_ptr);
+  GenComment(struct_def.doc_comment, code_ptr);
   BeginClass(struct_def, code_ptr);
   if (&struct_def == root_struct_def) {
     // Generate a special accessor for the table that has been declared as
@@ -548,13 +542,13 @@ static void GenStruct(const StructDef &struct_def,
 static void GenEnum(const EnumDef &enum_def, std::string *code_ptr) {
   if (enum_def.generated) return;
 
-  Comment(enum_def.doc_comment, code_ptr);
+  GenComment(enum_def.doc_comment, code_ptr);
   BeginEnum(code_ptr);
   for (auto it = enum_def.vals.vec.begin();
        it != enum_def.vals.vec.end();
        ++it) {
     auto &ev = **it;
-    Comment(ev.doc_comment, code_ptr, "  ");
+    GenComment(ev.doc_comment, code_ptr, "\t");
     EnumMember(enum_def, ev, code_ptr);
   }
   EndEnum(code_ptr);
@@ -585,30 +579,30 @@ static bool SaveType(const Parser &parser, const Definition &def,
                      bool needs_imports) {
   if (!classcode.length()) return true;
 
-  std::string name_space_name;
-  std::string name_space_dir = path;
-  for (auto it = parser.name_space_.begin();
-        it != parser.name_space_.end(); ++it) {
-    if (name_space_name.length()) {
-      name_space_name += ".";
-      name_space_dir += PATH_SEPARATOR;
+  std::string namespace_name;
+  std::string namespace_dir = path;
+  auto &namespaces = parser.namespaces_.back()->components;
+  for (auto it = namespaces.begin(); it != namespaces.end(); ++it) {
+    if (namespace_name.length()) {
+      namespace_name += ".";
+      namespace_dir += PATH_SEPARATOR;
     }
-    name_space_name = *it;
-    name_space_dir += *it;
-    mkdir(name_space_dir.c_str(), S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
+    namespace_name = *it;
+    namespace_dir += *it;
+    mkdir(namespace_dir.c_str(), S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
   }
 
 
   std::string code = "";
-  BeginFile(name_space_name, needs_imports, &code);
+  BeginFile(namespace_name, needs_imports, &code);
   code += classcode;
-  std::string filename = name_space_dir + PATH_SEPARATOR + def.name + ".go";
+  std::string filename = namespace_dir + PATH_SEPARATOR + def.name + ".go";
   return SaveFile(filename.c_str(), code, false);
 }
 
 static std::string GenTypeBasic(const Type &type) {
   static const char *ctypename[] = {
-    #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) #GTYPE,
+    #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) #GTYPE,
       FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
     #undef FLATBUFFERS_TD
   };

src/idl_gen_java.cpp

@@ -1,395 +0,0 @@
-/*
- * Copyright 2014 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-// independent from idl_parser, since this code is not needed for most clients
-
-#include "flatbuffers/flatbuffers.h"
-#include "flatbuffers/idl.h"
-#include "flatbuffers/util.h"
-
-#ifdef _WIN32
-#include <direct.h>
-#define mkdir(n, m) _mkdir(n)
-#else
-#include <sys/stat.h>
-#endif
-
-namespace flatbuffers {
-namespace java {
-
-static std::string GenTypeBasic(const Type &type) {
-  static const char *ctypename[] = {
-    #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) #JTYPE,
-      FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
-    #undef FLATBUFFERS_TD
-  };
-  return ctypename[type.base_type];
-}
-
-static std::string GenTypeGet(const Type &type);
-
-static std::string GenTypePointer(const Type &type) {
-  switch (type.base_type) {
-    case BASE_TYPE_STRING:
-      return "String";
-    case BASE_TYPE_VECTOR:
-      return GenTypeGet(type.VectorType());
-    case BASE_TYPE_STRUCT:
-      return type.struct_def->name;
-    case BASE_TYPE_UNION:
-      // fall through
-    default:
-      return "Table";
-  }
-}
-
-static std::string GenTypeGet(const Type &type) {
-  return IsScalar(type.base_type)
-    ? GenTypeBasic(type)
-    : GenTypePointer(type);
-}
-
-static void GenComment(const std::string &dc,
-                       std::string *code_ptr,
-                       const char *prefix = "") {
-  std::string &code = *code_ptr;
-  if (dc.length()) {
-    code += std::string(prefix) + "///" + dc + "\n";
-  }
-}
-
-static void GenEnum(EnumDef &enum_def, std::string *code_ptr) {
-  std::string &code = *code_ptr;
-  if (enum_def.generated) return;
-
-  // Generate enum definitions of the form:
-  // public static final int name = value;
-  // We use ints rather than the Java Enum feature, because we want them
-  // to map directly to how they're used in C/C++ and file formats.
-  // That, and Java Enums are expensive, and not universally liked.
-  GenComment(enum_def.doc_comment, code_ptr);
-  code += "public class " + enum_def.name + " {\n";
-  for (auto it = enum_def.vals.vec.begin();
-       it != enum_def.vals.vec.end();
-       ++it) {
-    auto &ev = **it;
-    GenComment(ev.doc_comment, code_ptr, "  ");
-    code += "  public static final " + GenTypeBasic(enum_def.underlying_type);
-    code += " " + ev.name + " = ";
-    code += NumToString(ev.value) + ";\n";
-  }
-  code += "};\n\n";
-}
-
-// Returns the function name that is able to read a value of the given type.
-static std::string GenGetter(const Type &type) {
-  switch (type.base_type) {
-    case BASE_TYPE_STRING: return "__string";
-    case BASE_TYPE_STRUCT: return "__struct";
-    case BASE_TYPE_UNION: return "__union";
-    case BASE_TYPE_VECTOR: return GenGetter(type.VectorType());
-    default:
-      return "bb.get" + (SizeOf(type.base_type) > 1
-        ? MakeCamel(GenTypeGet(type))
-        : "");
-  }
-}
-
-// Returns the method name for use with add/put calls.
-static std::string GenMethod(const FieldDef &field) {
-  return IsScalar(field.value.type.base_type)
-    ? MakeCamel(GenTypeBasic(field.value.type))
-    : (IsStruct(field.value.type) ? "Struct" : "Offset");
-}
-
-// Recursively generate arguments for a constructor, to deal with nested
-// structs.
-static void GenStructArgs(const StructDef &struct_def, std::string *code_ptr,
-                          const char *nameprefix) {
-  std::string &code = *code_ptr;
-  for (auto it = struct_def.fields.vec.begin();
-       it != struct_def.fields.vec.end();
-       ++it) {
-    auto &field = **it;
-    if (IsStruct(field.value.type)) {
-      // Generate arguments for a struct inside a struct. To ensure names
-      // don't clash, and to make it obvious these arguments are constructing
-      // a nested struct, prefix the name with the struct name.
-      GenStructArgs(*field.value.type.struct_def, code_ptr,
-                    (field.value.type.struct_def->name + "_").c_str());
-    } else {
-      code += ", " + GenTypeBasic(field.value.type) + " " + nameprefix;
-      code += MakeCamel(field.name, false);
-    }
-  }
-}
-
-// Recusively generate struct construction statements of the form:
-// builder.putType(name);
-// and insert manual padding.
-static void GenStructBody(const StructDef &struct_def, std::string *code_ptr,
-                          const char *nameprefix) {
-  std::string &code = *code_ptr;
-  code += "    builder.prep(" + NumToString(struct_def.minalign) + ", ";
-  code += NumToString(struct_def.bytesize) + ");\n";
-  for (auto it = struct_def.fields.vec.rbegin();
-       it != struct_def.fields.vec.rend();
-       ++it) {
-    auto &field = **it;
-    if (field.padding)
-      code += "    builder.pad(" + NumToString(field.padding) + ");\n";
-    if (IsStruct(field.value.type)) {
-      GenStructBody(*field.value.type.struct_def, code_ptr,
-                    (field.value.type.struct_def->name + "_").c_str());
-    } else {
-      code += "    builder.put" + GenMethod(field) + "(";
-      code += nameprefix + MakeCamel(field.name, false) + ");\n";
-    }
-  }
-}
-
-static void GenStruct(StructDef &struct_def,
-                      std::string *code_ptr,
-                      StructDef *root_struct_def) {
-  if (struct_def.generated) return;
-  std::string &code = *code_ptr;
-
-  // Generate a struct accessor class, with methods of the form:
-  // public type name() { return bb.getType(i + offset); }
-  // or for tables of the form:
-  // public type name() {
-  //   int o = __offset(offset); return o != 0 ? bb.getType(o + i) : default;
-  // }
-  GenComment(struct_def.doc_comment, code_ptr);
-  code += "public class " + struct_def.name + " extends ";
-  code += struct_def.fixed ? "Struct" : "Table";
-  code += " {\n";
-  if (&struct_def == root_struct_def) {
-    // Generate a special accessor for the table that has been declared as
-    // the root type.
-    code += "  public static " + struct_def.name + " getRootAs";
-    code += struct_def.name;
-    code += "(ByteBuffer _bb, int offset) { ";
-    code += "_bb.order(ByteOrder.LITTLE_ENDIAN); ";
-    code += "return (new " + struct_def.name;
-    code += "()).__init(_bb.getInt(offset) + offset, _bb); }\n";
-  }
-  // Generate the __init method that sets the field in a pre-existing
-  // accessor object. This is to allow object reuse.
-  code += "  public " + struct_def.name;
-  code += " __init(int _i, ByteBuffer _bb) ";
-  code += "{ bb_pos = _i; bb = _bb; return this; }\n";
-  for (auto it = struct_def.fields.vec.begin();
-       it != struct_def.fields.vec.end();
-       ++it) {
-    auto &field = **it;
-    if (field.deprecated) continue;
-    GenComment(field.doc_comment, code_ptr, "  ");
-    std::string type_name = GenTypeGet(field.value.type);
-    std::string method_start = "  public " + type_name + " " +
-                               MakeCamel(field.name, false);
-    // Generate the accessors that don't do object reuse.
-    if (field.value.type.base_type == BASE_TYPE_STRUCT) {
-      // Calls the accessor that takes an accessor object with a new object.
-      code += method_start + "() { return " + MakeCamel(field.name, false);
-      code += "(new ";
-      code += type_name + "()); }\n";
-    } else if (field.value.type.base_type == BASE_TYPE_VECTOR &&
-               field.value.type.element == BASE_TYPE_STRUCT) {
-      // Accessors for vectors of structs also take accessor objects, this
-      // generates a variant without that argument.
-      code += method_start + "(int j) { return " + MakeCamel(field.name, false);
-      code += "(new ";
-      code += type_name + "(), j); }\n";
-    }
-    std::string getter = GenGetter(field.value.type);
-    code += method_start + "(";
-    // Most field accessors need to retrieve and test the field offset first,
-    // this is the prefix code for that:
-    auto offset_prefix = ") { int o = __offset(" +
-                         NumToString(field.value.offset) +
-                         "); return o != 0 ? ";
-    if (IsScalar(field.value.type.base_type)) {
-      if (struct_def.fixed) {
-        code += ") { return " + getter;
-        code += "(bb_pos + " + NumToString(field.value.offset) + ")";
-      } else {
-        code += offset_prefix + getter;
-        code += "(o + bb_pos) : " + field.value.constant;
-      }
-    } else {
-      switch (field.value.type.base_type) {
-        case BASE_TYPE_STRUCT:
-          code += type_name + " obj";
-          if (struct_def.fixed) {
-            code += ") { return obj.__init(bb_pos + ";
-            code += NumToString(field.value.offset) + ", bb)";
-          } else {
-            code += offset_prefix;
-            code += "obj.__init(";
-            code += field.value.type.struct_def->fixed
-                      ? "o + bb_pos"
-                      : "__indirect(o + bb_pos)";
-            code += ", bb) : null";
-          }
-          break;
-        case BASE_TYPE_STRING:
-          code += offset_prefix + getter +"(o + bb_pos) : null";
-          break;
-        case BASE_TYPE_VECTOR: {
-          auto vectortype = field.value.type.VectorType();
-          if (vectortype.base_type == BASE_TYPE_STRUCT) {
-            code += type_name + " obj, ";
-            getter = "obj.__init";
-          }
-          code += "int j" + offset_prefix + getter +"(";
-          auto index = "__vector(o) + j * " +
-                       NumToString(InlineSize(vectortype));
-          if (vectortype.base_type == BASE_TYPE_STRUCT) {
-            code += vectortype.struct_def->fixed
-                      ? index
-                      : "__indirect(" + index + ")";
-            code += ", bb";
-          } else {
-            code += index;
-          }
-          code += ") : ";
-          code += IsScalar(field.value.type.element) ? "0" : "null";
-          break;
-        }
-        case BASE_TYPE_UNION:
-          code += type_name + " obj" + offset_prefix + getter;
-          code += "(obj, o) : null";
-          break;
-        default:
-          assert(0);
-      }
-    }
-    code += "; }\n";
-    if (field.value.type.base_type == BASE_TYPE_VECTOR) {
-      code += "  public int " + MakeCamel(field.name, false) + "Length(";
-      code += offset_prefix;
-      code += "__vector_len(o) : 0; }\n";
-    }
-  }
-  code += "\n";
-  if (struct_def.fixed) {
-    // create a struct constructor function
-    code += "  public static int create" + struct_def.name;
-    code += "(FlatBufferBuilder builder";
-    GenStructArgs(struct_def, code_ptr, "");
-    code += ") {\n";
-    GenStructBody(struct_def, code_ptr, "");
-    code += "    return builder.offset();\n  }\n";
-  } else {
-    // Create a set of static methods that allow table construction,
-    // of the form:
-    // public static void addName(FlatBufferBuilder builder, short name)
-    // { builder.addShort(id, name, default); }
-    code += "  public static void start" + struct_def.name;
-    code += "(FlatBufferBuilder builder) { builder.startObject(";
-    code += NumToString(struct_def.fields.vec.size()) + "); }\n";
-    for (auto it = struct_def.fields.vec.begin();
-         it != struct_def.fields.vec.end();
-         ++it) {
-      auto &field = **it;
-      if (field.deprecated) continue;
-      code += "  public static void add" + MakeCamel(field.name);
-      code += "(FlatBufferBuilder builder, " + GenTypeBasic(field.value.type);
-      auto argname = MakeCamel(field.name, false);
-      if (!IsScalar(field.value.type.base_type)) argname += "Offset";
-      code += " " + argname + ") { builder.add";
-      code += GenMethod(field) + "(";
-      code += NumToString(it - struct_def.fields.vec.begin()) + ", ";
-      code += argname + ", " + field.value.constant;
-      code += "); }\n";
-      if (field.value.type.base_type == BASE_TYPE_VECTOR) {
-        code += "  public static void start" + MakeCamel(field.name);
-        code += "Vector(FlatBufferBuilder builder, int numElems) ";
-        code += "{ builder.startVector(";
-        auto vector_type = field.value.type.VectorType();
-        auto alignment = InlineAlignment(vector_type);
-        auto elem_size = InlineSize(vector_type);
-        code += NumToString(elem_size);
-        code += ", numElems, " + NumToString(alignment);
-        code += "); }\n";
-      }
-    }
-    code += "  public static int end" + struct_def.name;
-    code += "(FlatBufferBuilder builder) { return builder.endObject(); }\n";
-  }
-  code += "};\n\n";
-}
-
-// Save out the generated code for a single Java class while adding
-// declaration boilerplate.
-static bool SaveClass(const Parser &parser, const Definition &def,
-                      const std::string &classcode, const std::string &path,
-                      bool needs_imports) {
-  if (!classcode.length()) return true;
-
-  std::string name_space_java;
-  std::string name_space_dir = path;
-  for (auto it = parser.name_space_.begin();
-        it != parser.name_space_.end(); ++it) {
-    if (name_space_java.length()) {
-      name_space_java += ".";
-      name_space_dir += kPathSeparator;
-    }
-    name_space_java += *it;
-    name_space_dir += *it;
-    mkdir(name_space_dir.c_str(), S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
-  }
-
-  std::string code = "// automatically generated, do not modify\n\n";
-  code += "package " + name_space_java + ";\n\n";
-  if (needs_imports) {
-    code += "import java.nio.*;\nimport java.lang.*;\nimport java.util.*;\n";
-    code += "import flatbuffers.*;\n\n";
-  }
-  code += classcode;
-  auto filename = name_space_dir + kPathSeparator + def.name + ".java";
-  return SaveFile(filename.c_str(), code, false);
-}
-
-}  // namespace java
-
-bool GenerateJava(const Parser &parser,
-                  const std::string &path,
-                  const std::string & /*file_name*/,
-                  const GeneratorOptions & /*opts*/) {
-  using namespace java;
-
-  for (auto it = parser.enums_.vec.begin();
-       it != parser.enums_.vec.end(); ++it) {
-    std::string enumcode;
-    GenEnum(**it, &enumcode);
-    if (!SaveClass(parser, **it, enumcode, path, false))
-      return false;
-  }
-
-  for (auto it = parser.structs_.vec.begin();
-       it != parser.structs_.vec.end(); ++it) {
-    std::string declcode;
-    GenStruct(**it, &declcode, parser.root_struct_def);
-    if (!SaveClass(parser, **it, declcode, path, true))
-      return false;
-  }
-
-  return true;
-}
-
-}  // namespace flatbuffers

src/idl_gen_text.cpp

@@ -28,8 +28,12 @@ static void GenStruct(const StructDef &struct_def, const Table *table,
 
 // If indentation is less than 0, that indicates we don't want any newlines
 // either.
-const char *NewLine(int indent_step) {
-  return indent_step >= 0 ? "\n" : "";
+const char *NewLine(const GeneratorOptions &opts) {
+  return opts.indent_step >= 0 ? "\n" : "";
+}
+
+int Indent(const GeneratorOptions &opts) {
+  return std::max(opts.indent_step, 0);
 }
 
 // Output an identifier with or without quotes depending on strictness.
@@ -65,21 +69,21 @@ template<typename T> void PrintVector(const Vector<T> &v, Type type,
                                       std::string *_text) {
   std::string &text = *_text;
   text += "[";
-  text += NewLine(opts.indent_step);
-  for (uoffset_t i = 0; i < v.Length(); i++) {
+  text += NewLine(opts);
+  for (uoffset_t i = 0; i < v.size(); i++) {
     if (i) {
       text += ",";
-      text += NewLine(opts.indent_step);
+      text += NewLine(opts);
     }
-    text.append(indent + opts.indent_step, ' ');
+    text.append(indent + Indent(opts), ' ');
     if (IsStruct(type))
       Print(v.GetStructFromOffset(i * type.struct_def->bytesize), type,
-            indent + opts.indent_step, nullptr, opts, _text);
+            indent + Indent(opts), nullptr, opts, _text);
     else
-      Print(v.Get(i), type, indent + opts.indent_step, nullptr,
+      Print(v.Get(i), type, indent + Indent(opts), nullptr,
             opts, _text);
   }
-  text += NewLine(opts.indent_step);
+  text += NewLine(opts);
   text.append(indent, ' ');
   text += "]";
 }
@@ -87,21 +91,35 @@ template<typename T> void PrintVector(const Vector<T> &v, Type type,
 static void EscapeString(const String &s, std::string *_text) {
   std::string &text = *_text;
   text += "\"";
-  for (uoffset_t i = 0; i < s.Length(); i++) {
+  for (uoffset_t i = 0; i < s.size(); i++) {
     char c = s.Get(i);
     switch (c) {
       case '\n': text += "\\n"; break;
       case '\t': text += "\\t"; break;
       case '\r': text += "\\r"; break;
+      case '\b': text += "\\b"; break;
+      case '\f': text += "\\f"; break;
       case '\"': text += "\\\""; break;
       case '\\': text += "\\\\"; break;
       default:
         if (c >= ' ' && c <= '~') {
           text += c;
         } else {
-          auto u = static_cast<unsigned char>(c);
-          text += "\\x";
-          text += IntToStringHex(u);
+          // Not printable ASCII data. Let's see if it's valid UTF-8 first:
+          const char *utf8 = s.c_str() + i;
+          int ucc = FromUTF8(&utf8);
+          if (ucc >= 0x80 && ucc <= 0xFFFF) {
+            // Parses as Unicode within JSON's \uXXXX range, so use that.
+            text += "\\u";
+            text += IntToStringHex(ucc, 4);
+            // Skip past characters recognized.
+            i = static_cast<uoffset_t>(utf8 - s.c_str() - 1);
+          } else {
+            // It's either unprintable ASCII, arbitrary binary, or Unicode data
+            // that doesn't fit \uXXXX, so use \xXX escape code instead.
+            text += "\\x";
+            text += IntToStringHex(static_cast<uint8_t>(c), 2);
+          }
         }
         break;
     }
@@ -141,7 +159,7 @@ template<> void Print<const void *>(const void *val,
       type = type.VectorType();
       // Call PrintVector above specifically for each element type:
       switch (type.base_type) {
-        #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+        #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
           case BASE_TYPE_ ## ENUM: \
             PrintVector<CTYPE>( \
               *reinterpret_cast<const Vector<CTYPE> *>(val), \
@@ -202,24 +220,24 @@ static void GenStruct(const StructDef &struct_def, const Table *table,
       if (fieldout++) {
         text += ",";
       }
-      text += NewLine(opts.indent_step);
-      text.append(indent + opts.indent_step, ' ');
+      text += NewLine(opts);
+      text.append(indent + Indent(opts), ' ');
       OutputIdentifier(fd.name, opts, _text);
       text += ": ";
       switch (fd.value.type.base_type) {
-         #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+         #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
            case BASE_TYPE_ ## ENUM: \
               GenField<CTYPE>(fd, table, struct_def.fixed, \
-                              opts, indent + opts.indent_step, _text); \
+                              opts, indent + Indent(opts), _text); \
               break;
           FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD)
         #undef FLATBUFFERS_TD
         // Generate drop-thru case statements for all pointer types:
-        #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+        #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
           case BASE_TYPE_ ## ENUM:
           FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD)
         #undef FLATBUFFERS_TD
-            GenFieldOffset(fd, table, struct_def.fixed, indent + opts.indent_step,
+            GenFieldOffset(fd, table, struct_def.fixed, indent + Indent(opts),
                            union_sd, opts, _text);
             break;
       }
@@ -231,7 +249,7 @@ static void GenStruct(const StructDef &struct_def, const Table *table,
       }
     }
   }
-  text += NewLine(opts.indent_step);
+  text += NewLine(opts);
   text.append(indent, ' ');
   text += "}";
 }
@@ -247,7 +265,7 @@ void GenerateText(const Parser &parser, const void *flatbuffer,
             0,
             opts,
             _text);
-  text += NewLine(opts.indent_step);
+  text += NewLine(opts);
 }
 
 }  // namespace flatbuffers

src/idl_parser.cpp

@@ -23,14 +23,15 @@
 namespace flatbuffers {
 
 const char *const kTypeNames[] = {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) IDLTYPE,
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) IDLTYPE,
     FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
   #undef FLATBUFFERS_TD
   nullptr
 };
 
 const char kTypeSizes[] = {
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) sizeof(CTYPE),
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
+      sizeof(CTYPE),
     FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
   #undef FLATBUFFERS_TD
 };
@@ -83,7 +84,8 @@ template<> inline Offset<void> atot<Offset<void>>(const char *s) {
   TD(NameSpace, 265, "namespace") \
   TD(RootType, 266, "root_type") \
   TD(FileIdentifier, 267, "file_identifier") \
-  TD(FileExtension, 268, "file_extension")
+  TD(FileExtension, 268, "file_extension") \
+  TD(Include, 269, "include")
 #ifdef __GNUC__
 __extension__  // Stop GCC complaining about trailing comma with -Wpendantic.
 #endif
@@ -91,7 +93,8 @@ enum {
   #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) kToken ## NAME = VALUE,
     FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN)
   #undef FLATBUFFERS_TOKEN
-  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) kToken ## ENUM,
+  #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
+      kToken ## ENUM,
     FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
   #undef FLATBUFFERS_TD
 };
@@ -101,19 +104,30 @@ static std::string TokenToString(int t) {
     #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) STRING,
       FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN)
     #undef FLATBUFFERS_TOKEN
-    #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) IDLTYPE,
+    #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) IDLTYPE,
       FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD)
     #undef FLATBUFFERS_TD
   };
   if (t < 256) {  // A single ascii char token.
     std::string s;
-    s.append(1, t);
+    s.append(1, static_cast<char>(t));
     return s;
   } else {       // Other tokens.
     return tokens[t - 256];
   }
 }
 
+// Parses exactly nibbles worth of hex digits into a number, or error.
+int64_t Parser::ParseHexNum(int nibbles) {
+  for (int i = 0; i < nibbles; i++)
+    if (!isxdigit(cursor_[i]))
+      Error("escape code must be followed by " + NumToString(nibbles) +
+            " hex digits");
+  auto val = StringToInt(cursor_, 16);
+  cursor_ += nibbles;
+  return val;
+}
+
 void Parser::Next() {
   doc_comment_.clear();
   bool seen_newline = false;
@@ -141,8 +155,21 @@ void Parser::Next() {
               case 'n':  attribute_ += '\n'; cursor_++; break;
               case 't':  attribute_ += '\t'; cursor_++; break;
               case 'r':  attribute_ += '\r'; cursor_++; break;
+              case 'b':  attribute_ += '\b'; cursor_++; break;
+              case 'f':  attribute_ += '\f'; cursor_++; break;
               case '\"': attribute_ += '\"'; cursor_++; break;
               case '\\': attribute_ += '\\'; cursor_++; break;
+              case '/':  attribute_ += '/';  cursor_++; break;
+              case 'x': {  // Not in the JSON standard
+                cursor_++;
+                attribute_ += static_cast<char>(ParseHexNum(2));
+                break;
+              }
+              case 'u': {
+                cursor_++;
+                ToUTF8(static_cast<int>(ParseHexNum(4)), &attribute_);
+                break;
+              }
               default: Error("unknown escape code in string constant"); break;
             }
           } else { // printable chars + UTF-8 bytes
@@ -159,8 +186,7 @@ void Parser::Next() {
           if (*start == '/') {  // documentation comment
             if (!seen_newline)
               Error("a documentation comment should be on a line on its own");
-            // todo: do we want to support multiline comments instead?
-            doc_comment_ += std::string(start + 1, cursor_);
+            doc_comment_.push_back(std::string(start + 1, cursor_));
           }
           break;
         }
@@ -175,7 +201,7 @@ void Parser::Next() {
           attribute_.clear();
           attribute_.append(start, cursor_);
           // First, see if it is a type keyword from the table of types:
-          #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+          #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
             if (attribute_ == IDLTYPE) { \
               token_ = kToken ## ENUM; \
               return; \
@@ -196,6 +222,7 @@ void Parser::Next() {
           if (attribute_ == "union")     { token_ = kTokenUnion;     return; }
           if (attribute_ == "namespace") { token_ = kTokenNameSpace; return; }
           if (attribute_ == "root_type") { token_ = kTokenRootType;  return; }
+          if (attribute_ == "include")   { token_ = kTokenInclude;  return; }
           if (attribute_ == "file_identifier") {
             token_ = kTokenFileIdentifier;
             return;
@@ -253,20 +280,24 @@ void Parser::Expect(int t) {
   Next();
 }
 
+void Parser::ParseTypeIdent(Type &type) {
+  auto enum_def = enums_.Lookup(attribute_);
+  if (enum_def) {
+    type = enum_def->underlying_type;
+    if (enum_def->is_union) type.base_type = BASE_TYPE_UNION;
+  } else {
+    type.base_type = BASE_TYPE_STRUCT;
+    type.struct_def = LookupCreateStruct(attribute_);
+  }
+}
+
 // Parse any IDL type.
 void Parser::ParseType(Type &type) {
   if (token_ >= kTokenBOOL && token_ <= kTokenSTRING) {
     type.base_type = static_cast<BaseType>(token_ - kTokenNONE);
   } else {
     if (token_ == kTokenIdentifier) {
-      auto enum_def = enums_.Lookup(attribute_);
-      if (enum_def) {
-        type = enum_def->underlying_type;
-        if (enum_def->is_union) type.base_type = BASE_TYPE_UNION;
-      } else {
-        type.base_type = BASE_TYPE_STRUCT;
-        type.struct_def = LookupCreateStruct(attribute_);
-      }
+      ParseTypeIdent(type);
     } else if (token_ == '[') {
       Next();
       Type subtype;
@@ -317,7 +348,7 @@ FieldDef &Parser::AddField(StructDef &struct_def,
 
 void Parser::ParseField(StructDef &struct_def) {
   std::string name = attribute_;
-  std::string dc = doc_comment_;
+  std::vector<std::string> dc = doc_comment_;
   Expect(kTokenIdentifier);
   Expect(':');
   Type type;
@@ -338,14 +369,30 @@ void Parser::ParseField(StructDef &struct_def) {
 
   if (token_ == '=') {
     Next();
+    if (!IsScalar(type.base_type))
+      Error("default values currently only supported for scalars");
     ParseSingleValue(field.value);
   }
 
+  if (type.enum_def &&
+      IsScalar(type.base_type) &&
+      !struct_def.fixed &&
+      !type.enum_def->attributes.Lookup("bit_flags") &&
+      !type.enum_def->ReverseLookup(static_cast<int>(
+                         StringToInt(field.value.constant.c_str()))))
+    Error("enum " + type.enum_def->name +
+          " does not have a declaration for this field\'s default of " +
+          field.value.constant);
+
   field.doc_comment = dc;
   ParseMetaData(field);
   field.deprecated = field.attributes.Lookup("deprecated") != nullptr;
   if (field.deprecated && struct_def.fixed)
     Error("can't deprecate fields in a struct");
+  field.required = field.attributes.Lookup("required") != nullptr;
+  if (field.required && (struct_def.fixed ||
+                         IsScalar(field.value.type.base_type)))
+    Error("only non-scalar fields in tables may be 'required'");
   auto nested = field.attributes.Lookup("nested_flatbuffer");
   if (nested) {
     if (nested->type.base_type != BASE_TYPE_STRING)
@@ -437,6 +484,16 @@ uoffset_t Parser::ParseTable(const StructDef &struct_def) {
     if (IsNext('}')) break;
     Expect(',');
   }
+  for (auto it = field_stack_.rbegin();
+           it != field_stack_.rbegin() + fieldn; ++it) {
+    if (it->second->used)
+      Error("field set more than once: " + it->second->name);
+    it->second->used = true;
+  }
+  for (auto it = field_stack_.rbegin();
+           it != field_stack_.rbegin() + fieldn; ++it) {
+    it->second->used = false;
+  }
   if (struct_def.fixed && fieldn != struct_def.fields.vec.size())
     Error("incomplete struct initialization: " + struct_def.name);
   auto start = struct_def.fixed
@@ -453,7 +510,7 @@ uoffset_t Parser::ParseTable(const StructDef &struct_def) {
       auto field = it->second;
       if (!struct_def.sortbysize || size == SizeOf(value.type.base_type)) {
         switch (value.type.base_type) {
-          #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+          #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
             case BASE_TYPE_ ## ENUM: \
               builder_.Pad(field->padding); \
               if (struct_def.fixed) { \
@@ -466,7 +523,7 @@ uoffset_t Parser::ParseTable(const StructDef &struct_def) {
               break;
             FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD);
           #undef FLATBUFFERS_TD
-          #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+          #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
             case BASE_TYPE_ ## ENUM: \
               builder_.Pad(field->padding); \
               if (IsStruct(field->value.type)) { \
@@ -521,7 +578,7 @@ uoffset_t Parser::ParseVector(const Type &type) {
     // start at the back, since we're building the data backwards.
     auto &val = field_stack_.back().first;
     switch (val.type.base_type) {
-      #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE) \
+      #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE) \
         case BASE_TYPE_ ## ENUM: \
           if (IsStruct(val.type)) SerializeStruct(*val.type.struct_def, val); \
           else builder_.PushElement(atot<CTYPE>(val.constant.c_str())); \
@@ -645,12 +702,13 @@ StructDef *Parser::LookupCreateStruct(const std::string &name) {
     structs_.Add(name, struct_def);
     struct_def->name = name;
     struct_def->predecl = true;
+    struct_def->defined_namespace = namespaces_.back();
   }
   return struct_def;
 }
 
 void Parser::ParseEnum(bool is_union) {
-  std::string dc = doc_comment_;
+  std::vector<std::string> dc = doc_comment_;
   Next();
   std::string name = attribute_;
   Expect(kTokenIdentifier);
@@ -658,19 +716,24 @@ void Parser::ParseEnum(bool is_union) {
   enum_def.name = name;
   enum_def.doc_comment = dc;
   enum_def.is_union = is_union;
+  enum_def.defined_namespace = namespaces_.back();
   if (enums_.Add(name, &enum_def)) Error("enum already exists: " + name);
   if (is_union) {
     enum_def.underlying_type.base_type = BASE_TYPE_UTYPE;
     enum_def.underlying_type.enum_def = &enum_def;
   } else {
-    // Give specialized error message, since this type spec used to
-    // be optional in the first FlatBuffers release.
-    if (!IsNext(':')) Error("must specify the underlying integer type for this"
-                            " enum (e.g. \': short\', which was the default).");
-    // Specify the integer type underlying this enum.
-    ParseType(enum_def.underlying_type);
-    if (!IsInteger(enum_def.underlying_type.base_type))
-      Error("underlying enum type must be integral");
+    if (proto_mode_) {
+      enum_def.underlying_type.base_type = BASE_TYPE_SHORT;
+    } else {
+      // Give specialized error message, since this type spec used to
+      // be optional in the first FlatBuffers release.
+      if (!IsNext(':')) Error("must specify the underlying integer type for this"
+                              " enum (e.g. \': short\', which was the default).");
+      // Specify the integer type underlying this enum.
+      ParseType(enum_def.underlying_type);
+      if (!IsInteger(enum_def.underlying_type.base_type))
+        Error("underlying enum type must be integral");
+    }
     // Make this type refer back to the enum it was derived from.
     enum_def.underlying_type.enum_def = &enum_def;
   }
@@ -679,7 +742,7 @@ void Parser::ParseEnum(bool is_union) {
   if (is_union) enum_def.vals.Add("NONE", new EnumVal("NONE", 0));
   do {
     std::string name = attribute_;
-    std::string dc = doc_comment_;
+    std::vector<std::string> dc = doc_comment_;
     Expect(kTokenIdentifier);
     auto prevsize = enum_def.vals.vec.size();
     auto value = enum_def.vals.vec.size()
@@ -698,7 +761,7 @@ void Parser::ParseEnum(bool is_union) {
       if (prevsize && enum_def.vals.vec[prevsize - 1]->value >= ev.value)
         Error("enum values must be specified in ascending order");
     }
-  } while (IsNext(','));
+  } while (IsNext(proto_mode_ ? ';' : ',') && token_ != '}');
   Expect('}');
   if (enum_def.attributes.Lookup("bit_flags")) {
     for (auto it = enum_def.vals.vec.begin(); it != enum_def.vals.vec.end();
@@ -711,22 +774,27 @@ void Parser::ParseEnum(bool is_union) {
   }
 }
 
-void Parser::ParseDecl() {
-  std::string dc = doc_comment_;
-  bool fixed = IsNext(kTokenStruct);
-  if (!fixed) Expect(kTokenTable);
+StructDef &Parser::StartStruct() {
   std::string name = attribute_;
   Expect(kTokenIdentifier);
   auto &struct_def = *LookupCreateStruct(name);
   if (!struct_def.predecl) Error("datatype already exists: " + name);
   struct_def.predecl = false;
   struct_def.name = name;
-  struct_def.doc_comment = dc;
-  struct_def.fixed = fixed;
   // Move this struct to the back of the vector just in case it was predeclared,
-  // to preserve declartion order.
+  // to preserve declaration order.
   remove(structs_.vec.begin(), structs_.vec.end(), &struct_def);
   structs_.vec.back() = &struct_def;
+  return struct_def;
+}
+
+void Parser::ParseDecl() {
+  std::vector<std::string> dc = doc_comment_;
+  bool fixed = IsNext(kTokenStruct);
+  if (!fixed) Expect(kTokenTable);
+  auto &struct_def = StartStruct();
+  struct_def.doc_comment = dc;
+  struct_def.fixed = fixed;
   ParseMetaData(struct_def);
   struct_def.sortbysize =
     struct_def.attributes.Lookup("original_order") == nullptr && !fixed;
@@ -773,6 +841,31 @@ void Parser::ParseDecl() {
       }
     }
   }
+  // Check that no identifiers clash with auto generated fields.
+  // This is not an ideal situation, but should occur very infrequently,
+  // and allows us to keep using very readable names for type & length fields
+  // without inducing compile errors.
+  auto CheckClash = [&fields, &struct_def](const char *suffix,
+                                           BaseType basetype) {
+    auto len = strlen(suffix);
+    for (auto it = fields.begin(); it != fields.end(); ++it) {
+      auto &name = (*it)->name;
+      if (name.length() > len &&
+          name.compare(name.length() - len, len, suffix) == 0 &&
+          (*it)->value.type.base_type != BASE_TYPE_UTYPE) {
+        auto field = struct_def.fields.Lookup(
+                       name.substr(0, name.length() - len));
+        if (field && field->value.type.base_type == basetype)
+          Error("Field " + name +
+                " would clash with generated functions for field " +
+                field->name);
+      }
+    }
+  };
+  CheckClash("_type", BASE_TYPE_UNION);
+  CheckClash("Type", BASE_TYPE_UNION);
+  CheckClash("_length", BASE_TYPE_VECTOR);
+  CheckClash("Length", BASE_TYPE_VECTOR);
   Expect('}');
 }
 
@@ -781,29 +874,192 @@ bool Parser::SetRootType(const char *name) {
   return root_struct_def != nullptr;
 }
 
-bool Parser::Parse(const char *source) {
+void Parser::MarkGenerated() {
+  // Since the Parser object retains definitions across files, we must
+  // ensure we only output code for definitions once, in the file they are first
+  // declared. This function marks all existing definitions as having already
+  // been generated.
+  for (auto it = enums_.vec.begin();
+           it != enums_.vec.end(); ++it) {
+    (*it)->generated = true;
+  }
+  for (auto it = structs_.vec.begin();
+           it != structs_.vec.end(); ++it) {
+    (*it)->generated = true;
+  }
+}
+
+void Parser::ParseNamespace() {
+  Next();
+  auto ns = new Namespace();
+  namespaces_.push_back(ns);
+  for (;;) {
+    ns->components.push_back(attribute_);
+    Expect(kTokenIdentifier);
+    if (!IsNext('.')) break;
+  }
+  Expect(';');
+}
+
+// Best effort parsing of .proto declarations, with the aim to turn them
+// in the closest corresponding FlatBuffer equivalent.
+// We parse everything as identifiers instead of keywords, since we don't
+// want protobuf keywords to become invalid identifiers in FlatBuffers.
+void Parser::ParseProtoDecl() {
+  if (attribute_ == "package") {
+    // These are identical in syntax to FlatBuffer's namespace decl.
+    ParseNamespace();
+  } else if (attribute_ == "message") {
+    Next();
+    auto &struct_def = StartStruct();
+    Expect('{');
+    while (token_ != '}') {
+      // Parse the qualifier.
+      bool required = false;
+      bool repeated = false;
+      if (attribute_ == "optional") {
+        // This is the default.
+      } else if (attribute_ == "required") {
+        required = true;
+      } else if (attribute_ == "repeated") {
+        repeated = true;
+      } else {
+        Error("expecting optional/required/repeated, got: " + attribute_);
+      }
+      Type type = ParseTypeFromProtoType();
+      // Repeated elements get mapped to a vector.
+      if (repeated) {
+        type.element = type.base_type;
+        type.base_type = BASE_TYPE_VECTOR;
+      }
+      std::string name = attribute_;
+      Expect(kTokenIdentifier);
+      // Parse the field id. Since we're just translating schemas, not
+      // any kind of binary compatibility, we can safely ignore these, and
+      // assign our own.
+      Expect('=');
+      Expect(kTokenIntegerConstant);
+      auto &field = AddField(struct_def, name, type);
+      field.required = required;
+      // See if there's a default specified.
+      if (IsNext('[')) {
+        if (attribute_ != "default") Error("\'default\' expected");
+        Next();
+        Expect('=');
+        field.value.constant = attribute_;
+        Next();
+        Expect(']');
+      }
+      Expect(';');
+    }
+    Next();
+  } else if (attribute_ == "enum") {
+    // These are almost the same, just with different terminator:
+    ParseEnum(false);
+  } else if (attribute_ == "import") {
+    Next();
+    included_files_[attribute_] = true;
+    Expect(kTokenStringConstant);
+    Expect(';');
+  } else if (attribute_ == "option") {  // Skip these.
+    Next();
+    Expect(kTokenIdentifier);
+    Expect('=');
+    Next();  // Any single token.
+    Expect(';');
+  } else {
+    Error("don\'t know how to parse .proto declaration starting with " +
+          attribute_);
+  }
+}
+
+// Parse a protobuf type, and map it to the corresponding FlatBuffer one.
+Type Parser::ParseTypeFromProtoType() {
+  Expect(kTokenIdentifier);
+  struct type_lookup { const char *proto_type; BaseType fb_type; };
+  static type_lookup lookup[] = {
+    { "float", BASE_TYPE_FLOAT },  { "double", BASE_TYPE_DOUBLE },
+    { "int32", BASE_TYPE_INT },    { "int64", BASE_TYPE_LONG },
+    { "uint32", BASE_TYPE_UINT },  { "uint64", BASE_TYPE_ULONG },
+    { "sint32", BASE_TYPE_INT },   { "sint64", BASE_TYPE_LONG },
+    { "fixed32", BASE_TYPE_UINT }, { "fixed64", BASE_TYPE_ULONG },
+    { "sfixed32", BASE_TYPE_INT }, { "sfixed64", BASE_TYPE_LONG },
+    { "bool", BASE_TYPE_BOOL },
+    { "string", BASE_TYPE_STRING },
+    { "bytes", BASE_TYPE_STRING },
+    { nullptr, BASE_TYPE_NONE }
+  };
+  Type type;
+  for (auto tl = lookup; tl->proto_type; tl++) {
+    if (attribute_ == tl->proto_type) {
+      type.base_type = tl->fb_type;
+      Next();
+      return type;
+    }
+  }
+  ParseTypeIdent(type);
+  Expect(kTokenIdentifier);
+  return type;
+}
+
+bool Parser::Parse(const char *source, const char **include_paths,
+                   const char *source_filename) {
+  if (source_filename) included_files_[source_filename] = true;
   source_ = cursor_ = source;
   line_ = 1;
   error_.clear();
   builder_.Clear();
   try {
     Next();
-    while (token_ != kTokenEof) {
-      if (token_ == kTokenNameSpace) {
-        Next();
-        name_space_.clear();
-        for (;;) {
-          name_space_.push_back(attribute_);
-          Expect(kTokenIdentifier);
-          if (!IsNext('.')) break;
+    // Includes must come first:
+    while (IsNext(kTokenInclude)) {
+      auto name = attribute_;
+      Expect(kTokenStringConstant);
+      if (included_files_.find(name) == included_files_.end()) {
+        // We found an include file that we have not parsed yet.
+        // Load it and parse it.
+        std::string contents;
+        if (!include_paths) {
+          const char *current_directory[] = { "", nullptr };
+          include_paths = current_directory;
         }
-        Expect(';');
+        for (auto paths = include_paths; paths && *paths; paths++) {
+          auto filepath = flatbuffers::ConCatPathFileName(*paths, name);
+          if(LoadFile(filepath.c_str(), true, &contents)) break;
+        }
+        if (contents.empty())
+          Error("unable to load include file: " + name);
+        included_files_[name] = true;
+        if (!Parse(contents.c_str(), include_paths)) {
+          // Any errors, we're done.
+          return false;
+        }
+        // We do not want to output code for any included files:
+        MarkGenerated();
+        // This is the easiest way to continue this file after an include:
+        // instead of saving and restoring all the state, we simply start the
+        // file anew. This will cause it to encounter the same include statement
+        // again, but this time it will skip it, because it was entered into
+        // included_files_.
+        // This is recursive, but only go as deep as the number of include
+        // statements.
+        return Parse(source, include_paths, source_filename);
+      }
+      Expect(';');
+    }
+    // Now parse all other kinds of declarations:
+    while (token_ != kTokenEof) {
+      if (proto_mode_) {
+        ParseProtoDecl();
+      } else if (token_ == kTokenNameSpace) {
+        ParseNamespace();
       } else if (token_ == '{') {
         if (!root_struct_def) Error("no root type set to parse json with");
         if (builder_.GetSize()) {
           Error("cannot have more than one json object in a file");
         }
-        builder_.Finish(Offset<Table>(ParseTable(*root_struct_def)));
+        builder_.Finish(Offset<Table>(ParseTable(*root_struct_def)),
+          file_identifier_.length() ? file_identifier_.c_str() : nullptr);
       } else if (token_ == kTokenEnum) {
         ParseEnum(false);
       } else if (token_ == kTokenUnion) {
@@ -832,6 +1088,8 @@ bool Parser::Parse(const char *source) {
         file_extension_ = attribute_;
         Expect(kTokenStringConstant);
         Expect(';');
+      } else if(token_ == kTokenInclude) {
+        Error("includes must come before declarations");
       } else {
         ParseDecl();
       }
@@ -853,7 +1111,14 @@ bool Parser::Parse(const char *source) {
       }
     }
   } catch (const std::string &msg) {
-    error_ = "line " + NumToString(line_) + ": " + msg;
+    error_ = source_filename ? AbsolutePath(source_filename) : "";
+    #ifdef _WIN32
+      error_ += "(" + NumToString(line_) + ")";  // MSVC alike
+    #else
+      if (source_filename) error_ += ":";
+      error_ += NumToString(line_) + ":0";  // gcc alike
+    #endif
+    error_ += ": error: " + msg;
     return false;
   }
   assert(!struct_stack_.size());

tests/FlatBuffers.Test/Assert.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace FlatBuffers.Test
+{
+
+    public class AssertFailedException : Exception
+    {
+        private readonly object _expected;
+        private readonly object _actual;
+
+        public AssertFailedException(object expected, object actual)
+        {
+            _expected = expected;
+            _actual = actual;
+        }
+
+        public override string Message
+        {
+            get { return string.Format("Expected {0} but saw {1}", _expected, _actual); }
+        }
+    }
+
+    public class AssertUnexpectedThrowException : Exception
+    {
+        private readonly object _expected;
+
+        public AssertUnexpectedThrowException(object expected)
+        {
+            _expected = expected;
+        }
+
+        public override string Message
+        {
+            get { return string.Format("Expected exception of type {0}", _expected); }
+        }
+    }
+
+    public static class Assert
+    {
+        public static void AreEqual<T>(T expected, T actual)
+        {
+            if (!expected.Equals(actual))
+            {
+                throw new AssertFailedException(expected, actual);
+            }
+        }
+
+        public static void IsTrue(bool value)
+        {
+            if (!value)
+            {
+                throw new AssertFailedException(true, value);
+            }
+        }
+
+        public static void Throws<T>(Action action) where T : Exception
+        {
+            var caught = false;
+            try
+            {
+                action();
+            }
+            catch (T)
+            {
+                caught = true;
+            }
+
+            if (!caught)
+            {
+                throw new AssertUnexpectedThrowException(typeof (T));
+            }
+        }
+    }
+}

tests/FlatBuffers.Test/ByteBufferTests.cs

@@ -0,0 +1,244 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+
+namespace FlatBuffers.Test
+{
+    public class ByteBufferTests
+    {
+
+        public void ByteBuffer_Length_MatchesBufferLength()
+        {
+            var buffer = new byte[1000];
+            var uut = new ByteBuffer(buffer);
+            Assert.AreEqual(buffer.Length, uut.Length);
+        }
+
+        public void ByteBuffer_PutBytePopulatesBufferAtZeroOffset()
+        {
+            var buffer = new byte[1];
+            var uut = new ByteBuffer(buffer);
+            uut.PutByte(0, (byte)99);
+
+            Assert.AreEqual((byte)99, buffer[0]);
+        }
+
+        public void ByteBuffer_PutByteCannotPutAtOffsetPastLength()
+        {
+            var buffer = new byte[1];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutByte(1, 99));
+        }
+
+        public void ByteBuffer_PutShortPopulatesBufferCorrectly()
+        {
+            var buffer = new byte[2];
+            var uut = new ByteBuffer(buffer);
+            uut.PutShort(0, (short)1);
+
+            // Ensure Endianness was written correctly
+            Assert.AreEqual((byte)1, buffer[0]);
+            Assert.AreEqual((byte)0, buffer[1]);
+        }
+
+        public void ByteBuffer_PutShortCannotPutAtOffsetPastLength()
+        {
+            var buffer = new byte[2];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutShort(2, 99));
+        }
+
+        public void ByteBuffer_PutShortChecksLength()
+        {
+            var buffer = new byte[1];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutShort(0, 99));
+        }
+
+        public void ByteBuffer_PutShortChecksLengthAndOffset()
+        {
+            var buffer = new byte[2];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutShort(1, 99));
+        }
+
+        public void ByteBuffer_PutIntPopulatesBufferCorrectly()
+        {
+            var buffer = new byte[4];
+            var uut = new ByteBuffer(buffer);
+            uut.PutInt(0, 0x0A0B0C0D);
+
+            // Ensure Endianness was written correctly
+            Assert.AreEqual(0x0D, buffer[0]);
+            Assert.AreEqual(0x0C, buffer[1]);
+            Assert.AreEqual(0x0B, buffer[2]);
+            Assert.AreEqual(0x0A, buffer[3]);
+        }
+
+        public void ByteBuffer_PutIntCannotPutAtOffsetPastLength()
+        {
+            var buffer = new byte[4];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutInt(2, 0x0A0B0C0D));
+        }
+
+        public void ByteBuffer_PutIntChecksLength()
+        {
+            var buffer = new byte[1];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutInt(0, 0x0A0B0C0D));
+        }
+
+        public void ByteBuffer_PutIntChecksLengthAndOffset()
+        {
+            var buffer = new byte[4];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutInt(2, 0x0A0B0C0D));
+        }
+
+        public void ByteBuffer_PutLongPopulatesBufferCorrectly()
+        {
+            var buffer = new byte[8];
+            var uut = new ByteBuffer(buffer);
+            uut.PutLong(0, 0x010203040A0B0C0D);
+
+            // Ensure Endianness was written correctly
+            Assert.AreEqual(0x0D, buffer[0]);
+            Assert.AreEqual(0x0C, buffer[1]);
+            Assert.AreEqual(0x0B, buffer[2]);
+            Assert.AreEqual(0x0A, buffer[3]);
+            Assert.AreEqual(0x04, buffer[4]);
+            Assert.AreEqual(0x03, buffer[5]);
+            Assert.AreEqual(0x02, buffer[6]);
+            Assert.AreEqual(0x01, buffer[7]);
+        }
+
+        public void ByteBuffer_PutLongCannotPutAtOffsetPastLength()
+        {
+            var buffer = new byte[8];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutLong(2, 0x010203040A0B0C0D));
+        }
+
+        public void ByteBuffer_PutLongChecksLength()
+        {
+            var buffer = new byte[1];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutLong(0, 0x010203040A0B0C0D));
+        }
+
+        public void ByteBuffer_PutLongChecksLengthAndOffset()
+        {
+            var buffer = new byte[8];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.PutLong(2, 0x010203040A0B0C0D));
+        }
+
+        public void ByteBuffer_GetByteReturnsCorrectData()
+        {
+            var buffer = new byte[1];
+            buffer[0] = 99;
+            var uut = new ByteBuffer(buffer);
+            Assert.AreEqual((byte)99, uut.Get(0));
+        }
+
+        public void ByteBuffer_GetByteChecksOffset()
+        {
+            var buffer = new byte[1];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(()=>uut.Get(1));
+        }
+
+        public void ByteBuffer_GetShortReturnsCorrectData()
+        {
+            var buffer = new byte[2];
+            buffer[0] = 1;
+            buffer[1] = 0;
+            var uut = new ByteBuffer(buffer);
+            Assert.AreEqual(1, uut.GetShort(0));
+        }
+
+        public void ByteBuffer_GetShortChecksOffset()
+        {
+            var buffer = new byte[2];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.GetShort(2));
+        }
+
+        public void ByteBuffer_GetShortChecksLength()
+        {
+            var buffer = new byte[2];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.GetShort(1));
+        }
+
+        public void ByteBuffer_GetIntReturnsCorrectData()
+        {
+            var buffer = new byte[4];
+            buffer[0] = 0x0D;
+            buffer[1] = 0x0C;
+            buffer[2] = 0x0B;
+            buffer[3] = 0x0A;
+            var uut = new ByteBuffer(buffer);
+            Assert.AreEqual(0x0A0B0C0D, uut.GetInt(0));
+        }
+
+        public void ByteBuffer_GetIntChecksOffset()
+        {
+            var buffer = new byte[4];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.GetInt(4));
+        }
+
+        public void ByteBuffer_GetIntChecksLength()
+        {
+            var buffer = new byte[2];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.GetInt(0));
+        }
+
+        public void ByteBuffer_GetLongReturnsCorrectData()
+        {
+            var buffer = new byte[8];
+            buffer[0] = 0x0D;
+            buffer[1] = 0x0C;
+            buffer[2] = 0x0B;
+            buffer[3] = 0x0A;
+            buffer[4] = 0x04;
+            buffer[5] = 0x03;
+            buffer[6] = 0x02;
+            buffer[7] = 0x01;
+            var uut = new ByteBuffer(buffer);
+            Assert.AreEqual(0x010203040A0B0C0D, uut.GetLong(0));
+        }
+
+        public void ByteBuffer_GetLongChecksOffset()
+        {
+            var buffer = new byte[8];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.GetLong(8));
+        }
+
+        public void ByteBuffer_GetLongChecksLength()
+        {
+            var buffer = new byte[7];
+            var uut = new ByteBuffer(buffer);
+            Assert.Throws<ArgumentOutOfRangeException>(() => uut.GetLong(0));
+        }
+
+    }
+}

tests/FlatBuffers.Test/FlatBuffers.Test.csproj

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{9DB0B5E7-757E-4BD1-A5F6-279390331254}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>FlatBuffers.Test</RootNamespace>
+    <AssemblyName>FlatBuffers.Test</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <StartupObject />
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\MyGame\Example\Any.cs">
+      <Link>MyGame\Example\Any.cs</Link>
+    </Compile>
+    <Compile Include="..\MyGame\Example\Color.cs">
+      <Link>MyGame\Example\Color.cs</Link>
+    </Compile>
+    <Compile Include="..\MyGame\Example\Monster.cs">
+      <Link>MyGame\Example\Monster.cs</Link>
+    </Compile>
+    <Compile Include="..\MyGame\Example\Test.cs">
+      <Link>MyGame\Example\Test.cs</Link>
+    </Compile>
+    <Compile Include="..\MyGame\Example\Vec3.cs">
+      <Link>MyGame\Example\Vec3.cs</Link>
+    </Compile>
+    <Compile Include="Assert.cs" />
+    <Compile Include="ByteBufferTests.cs" />
+    <Compile Include="MyGame\Example\Stat.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="FlatBuffersExampleTests.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\net\FlatBuffers\FlatBuffers.csproj">
+      <Project>{28C00774-1E73-4A75-AD8F-844CD21A064D}</Project>
+      <Name>FlatBuffers</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="..\monsterdata_test.mon">
+      <Link>Resources\monsterdata_test.mon</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

tests/FlatBuffers.Test/FlatBuffersExampleTests.cs

@@ -0,0 +1,154 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.IO;
+using MyGame.Example;
+
+namespace FlatBuffers.Test
+{
+    public class FlatBuffersExampleTests
+    {
+        public void RunTests()
+        {
+            CanCreateNewFlatBufferFromScratch();
+            CanReadCppGeneratedWireFile();
+            TestEnums();
+        }
+
+        public void CanCreateNewFlatBufferFromScratch()
+        {
+            // Second, let's create a FlatBuffer from scratch in C#, and test it also.
+            // We use an initial size of 1 to exercise the reallocation algorithm,
+            // normally a size larger than the typical FlatBuffer you generate would be
+            // better for performance.
+            var fbb = new FlatBufferBuilder(1);
+
+            // We set up the same values as monsterdata.json:
+
+            var str = fbb.CreateString("MyMonster");
+            var test1 = fbb.CreateString("test1");
+            var test2 = fbb.CreateString("test2");
+
+
+            Monster.StartInventoryVector(fbb, 5);
+            for (int i = 4; i >= 0; i--)
+            {
+                fbb.AddByte((byte)i);
+            }
+            var inv = fbb.EndVector();
+
+            var fred = fbb.CreateString("Fred");
+            Monster.StartMonster(fbb);
+            Monster.AddName(fbb, fred);
+            var mon2 = Monster.EndMonster(fbb);
+
+            Monster.StartTest4Vector(fbb, 2);
+            MyGame.Example.Test.CreateTest(fbb, (short)10, (sbyte)20);
+            MyGame.Example.Test.CreateTest(fbb, (short)30, (sbyte)40);
+            var test4 = fbb.EndVector();
+
+            Monster.StartTestarrayofstringVector(fbb, 2);
+            fbb.AddOffset(test2);
+            fbb.AddOffset(test1);
+            var testArrayOfString = fbb.EndVector();
+
+
+            Monster.StartMonster(fbb);
+            Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
+                                                     Color.Green, (short)5, (sbyte)6));
+            Monster.AddHp(fbb, (short)80);
+            Monster.AddName(fbb, str);
+            Monster.AddInventory(fbb, inv);
+            Monster.AddTestType(fbb, (byte)1);
+            Monster.AddTest(fbb, mon2);
+            Monster.AddTest4(fbb, test4);
+            Monster.AddTestarrayofstring(fbb, testArrayOfString);
+            var mon = Monster.EndMonster(fbb);
+
+            fbb.Finish(mon);
+
+            // Dump to output directory so we can inspect later, if needed
+            using (var ms = new MemoryStream(fbb.DataBuffer().Data, fbb.DataBuffer().position(), fbb.Offset()))
+            {
+                var data = ms.ToArray();
+                File.WriteAllBytes(@"Resources/monsterdata_cstest.mon",data);
+            }
+
+            // Now assert the buffer
+            TestBuffer(fbb.DataBuffer());
+        }
+
+        private void TestBuffer(ByteBuffer bb)
+        {
+            var monster = Monster.GetRootAsMonster(bb);
+
+            Assert.AreEqual(80, monster.Hp());
+            Assert.AreEqual(150, monster.Mana());
+            Assert.AreEqual("MyMonster", monster.Name());
+
+            var pos = monster.Pos();
+            Assert.AreEqual(1.0f, pos.X());
+            Assert.AreEqual(2.0f, pos.Y());
+            Assert.AreEqual(3.0f, pos.Z());
+
+            Assert.AreEqual(3.0f, pos.Test1());
+            Assert.AreEqual(Color.Green, pos.Test2());
+            var t = pos.Test3();
+            Assert.AreEqual((short)5, t.A());
+            Assert.AreEqual((sbyte)6, t.B());
+
+            Assert.AreEqual((byte)Any.Monster, monster.TestType());
+
+            var monster2 = new Monster();
+            Assert.IsTrue(monster.Test(monster2) != null);
+            Assert.AreEqual("Fred", monster2.Name());
+
+
+            Assert.AreEqual(5, monster.InventoryLength());
+            var invsum = 0;
+            for (var i = 0; i < monster.InventoryLength(); i++)
+            {
+                invsum += monster.Inventory(i);
+            }
+            Assert.AreEqual(10, invsum);
+
+            var test0 = monster.Test4(0);
+            var test1 = monster.Test4(1);
+            Assert.AreEqual(2, monster.Test4Length());
+
+            Assert.AreEqual(100, test0.A() + test0.B() + test1.A() + test1.B());
+
+            Assert.AreEqual(2, monster.TestarrayofstringLength());
+            Assert.AreEqual("test1", monster.Testarrayofstring(0));
+            Assert.AreEqual("test2", monster.Testarrayofstring(1));
+        }
+
+        public void CanReadCppGeneratedWireFile()
+        {
+            var data = File.ReadAllBytes(@"Resources/monsterdata_test.mon");
+            var bb = new ByteBuffer(data);
+            TestBuffer(bb);
+        }
+
+        public void TestEnums()
+        {
+            Assert.AreEqual(Color.Name(Color.Red), "Red");
+            Assert.AreEqual(Color.Name(Color.Blue), "Blue");
+            Assert.AreEqual(Any.Name(Any.NONE), "NONE");
+            Assert.AreEqual(Any.Name(Any.Monster), "Monster");
+        }
+    }
+}

tests/FlatBuffers.Test/Program.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace FlatBuffers.Test
+{
+    static class Program
+    {
+        public static int Main(string[] args)
+        {
+            var tests = new FlatBuffersExampleTests();
+            try
+            {
+                tests.RunTests();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine("FlatBuffersExampleTests FAILED - {0}", ex.GetBaseException());
+                return -1;
+            }
+
+            // Run ByteBuffers Tests
+            var testClass = new ByteBufferTests();
+
+            var methods = testClass.GetType().GetMethods(BindingFlags.Public |
+                                                         BindingFlags.Instance)
+                          .Where(m => m.Name.StartsWith("ByteBuffer_"));
+            foreach (var method in methods)
+            {
+                try
+                {
+                    method.Invoke(testClass, new object[] { });
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine("ByteBufferTests FAILED when invoking {0} with error {1}",
+                                      method.Name, ex.GetBaseException());
+                    return -1;
+                }
+
+            }
+
+            return 0;
+        }
+    }
+}

tests/FlatBuffers.Test/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("FlatBuffers.Test")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("FlatBuffers.Test")]
+[assembly: AssemblyCopyright("Copyright © 2014  Google Inc")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("a1d58a51-3e74-4ae9-aac7-5a399c9eed1a")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

tests/GoTest.sh

@@ -41,8 +41,8 @@ cp -u ./go_test.go ./go_gen/src/flatbuffers_test/
 #   go -test -test.bench=. ...
 GOPATH=${go_path} go test flatbuffers_test \
                      --test.coverpkg=github.com/google/flatbuffers/go \
-                     --cpp_data=${test_dir}/monsterdata_test.bin \
-                     --out_data=${test_dir}/monsterdata_go_wire.bin \
+                     --cpp_data=${test_dir}/monsterdata_test.mon \
+                     --out_data=${test_dir}/monsterdata_go_wire.mon \
                      --fuzz=true \
                      --fuzz_fields=4 \
                      --fuzz_objects=10000

tests/JavaTest.java

@@ -17,7 +17,7 @@
 import java.io.*;
 import java.nio.ByteBuffer;
 import MyGame.Example.*;
-import flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.FlatBufferBuilder;
 
 class JavaTest {
     public static void main(String[] args) {
@@ -26,7 +26,7 @@ class JavaTest {
         // This file was generated from monsterdata_test.json
 
         byte[] data = null;
-        File file = new File("monsterdata_test.bin");
+        File file = new File("monsterdata_test.mon");
         RandomAccessFile f = null;
         try {
             f = new RandomAccessFile(file, "r");
@@ -41,7 +41,7 @@ class JavaTest {
         // Now test it:
 
         ByteBuffer bb = ByteBuffer.wrap(data);
-        TestBuffer(bb, 0);
+        TestBuffer(bb);
 
         // Second, let's create a FlatBuffer from scratch in Java, and test it also.
         // We use an initial size of 1 to exercise the reallocation algorithm,
@@ -52,15 +52,12 @@ class JavaTest {
         // We set up the same values as monsterdata.json:
 
         int str = fbb.createString("MyMonster");
-        int test1 = fbb.createString("test1");
-        int test2 = fbb.createString("test2");
 
-        Monster.startInventoryVector(fbb, 5);
-        for (byte i = 4; i >=0; i--) fbb.addByte(i);
-        int inv = fbb.endVector();
+        int inv = Monster.createInventoryVector(fbb, new byte[] { 0, 1, 2, 3, 4 });
 
+        int fred = fbb.createString("Fred");
         Monster.startMonster(fbb);
-        Monster.addHp(fbb, (short)20);
+        Monster.addName(fbb, fred);
         int mon2 = Monster.endMonster(fbb);
 
         Monster.startTest4Vector(fbb, 2);
@@ -68,24 +65,24 @@ class JavaTest {
         Test.createTest(fbb, (short)30, (byte)40);
         int test4 = fbb.endVector();
 
-        Monster.startTestarrayofstringVector(fbb, 2);
-        fbb.addOffset(test2);
-        fbb.addOffset(test1);
-        int testArrayOfString = fbb.endVector();
+        int testArrayOfString = Monster.createTestarrayofstringVector(fbb, new int[] {
+            fbb.createString("test1"),
+            fbb.createString("test2")
+        });
 
         Monster.startMonster(fbb);
         Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
-                                                 (byte)4, (short)5, (byte)6));
+                                                 Color.Green, (short)5, (byte)6));
         Monster.addHp(fbb, (short)80);
         Monster.addName(fbb, str);
         Monster.addInventory(fbb, inv);
-        Monster.addTestType(fbb, (byte)1);
+        Monster.addTestType(fbb, (byte)Any.Monster);
         Monster.addTest(fbb, mon2);
         Monster.addTest4(fbb, test4);
         Monster.addTestarrayofstring(fbb, testArrayOfString);
         int mon = Monster.endMonster(fbb);
 
-        fbb.finish(mon);
+        Monster.finishMonsterBuffer(fbb, mon);
 
         // Write the result to a file for debugging purposes:
         // Note that the binaries are not necessarily identical, since the JSON
@@ -93,24 +90,39 @@ class JavaTest {
         // Java code. They are functionally equivalent though.
 
         try {
-             DataOutputStream os = new DataOutputStream(new FileOutputStream(
-                                           "monsterdata_java_wire.bin"));
-             os.write(fbb.dataBuffer().array(), fbb.dataStart(), fbb.offset());
-             os.close();
+            DataOutputStream os = new DataOutputStream(new FileOutputStream(
+                                           "monsterdata_java_wire.mon"));
+            os.write(fbb.dataBuffer().array(), fbb.dataBuffer().position(), fbb.offset());
+            os.close();
         } catch(java.io.IOException e) {
             System.out.println("FlatBuffers test: couldn't write file");
             return;
         }
 
         // Test it:
+        TestBuffer(fbb.dataBuffer());
 
-        TestBuffer(fbb.dataBuffer(), fbb.dataStart());
+        // Make sure it also works with read only ByteBuffers. This is slower,
+        // since creating strings incurs an additional copy
+        // (see Table.__string).
+        TestBuffer(fbb.dataBuffer().asReadOnlyBuffer());
+
+        TestEnums();
 
         System.out.println("FlatBuffers test: completed successfully");
     }
 
-    static void TestBuffer(ByteBuffer bb, int start) {
-        Monster monster = Monster.getRootAsMonster(bb, start);
+    static void TestEnums() {
+      TestEq(Color.name(Color.Red), "Red");
+      TestEq(Color.name(Color.Blue), "Blue");
+      TestEq(Any.name(Any.NONE), "NONE");
+      TestEq(Any.name(Any.Monster), "Monster");
+    }
+
+    static void TestBuffer(ByteBuffer bb) {
+        TestEq(Monster.MonsterBufferHasIdentifier(bb), true);
+
+        Monster monster = Monster.getRootAsMonster(bb);
 
         TestEq(monster.hp(), (short)80);
         TestEq(monster.mana(), (short)150);  // default
@@ -123,7 +135,7 @@ class JavaTest {
         TestEq(pos.y(), 2.0f);
         TestEq(pos.z(), 3.0f);
         TestEq(pos.test1(), 3.0);
-        TestEq(pos.test2(), (byte)4);
+        TestEq(pos.test2(), Color.Green);
         Test t = pos.test3();
         TestEq(t.a(), (short)5);
         TestEq(t.b(), (byte)6);
@@ -131,7 +143,7 @@ class JavaTest {
         TestEq(monster.testType(), (byte)Any.Monster);
         Monster monster2 = new Monster();
         TestEq(monster.test(monster2) != null, true);
-        TestEq(monster2.hp(), (short)20);
+        TestEq(monster2.name(), "Fred");
 
         TestEq(monster.inventoryLength(), 5);
         int invsum = 0;
@@ -139,6 +151,13 @@ class JavaTest {
             invsum += monster.inventory(i);
         TestEq(invsum, 10);
 
+        // Alternative way of accessing a vector:
+        ByteBuffer ibb = monster.inventoryAsByteBuffer();
+        invsum = 0;
+        while (ibb.position() < ibb.limit())
+            invsum += ibb.get();
+        TestEq(invsum, 10);
+
         Test test_0 = monster.test4(0);
         Test test_1 = monster.test4(1);
         TestEq(monster.test4Length(), 2);

tests/MyGame/Example/Any.cs

@@ -0,0 +1,17 @@
+// automatically generated, do not modify
+
+namespace MyGame.Example
+{
+
+public class Any
+{
+  public static readonly byte NONE = 0;
+  public static readonly byte Monster = 1;
+
+  private static readonly string[] names = { "NONE", "Monster", };
+
+  public static string Name(int e) { return names[e]; }
+};
+
+
+}

tests/MyGame/Example/Any.java

@@ -5,5 +5,9 @@ package MyGame.Example;
 public class Any {
   public static final byte NONE = 0;
   public static final byte Monster = 1;
+
+  private static final String[] names = { "NONE", "Monster", };
+
+  public static String name(int e) { return names[e]; }
 };
 

tests/MyGame/Example/Color.cs

@@ -0,0 +1,18 @@
+// automatically generated, do not modify
+
+namespace MyGame.Example
+{
+
+public class Color
+{
+  public static readonly sbyte Red = 1;
+  public static readonly sbyte Green = 2;
+  public static readonly sbyte Blue = 8;
+
+  private static readonly string[] names = { "Red", "Green", "", "", "", "", "", "Blue", };
+
+  public static string Name(int e) { return names[e - Red]; }
+};
+
+
+}

tests/MyGame/Example/Color.java

@@ -6,5 +6,9 @@ public class Color {
   public static final byte Red = 1;
   public static final byte Green = 2;
   public static final byte Blue = 8;
+
+  private static final String[] names = { "Red", "Green", "", "", "", "", "", "Blue", };
+
+  public static String name(int e) { return names[e - Red]; }
 };
 

tests/MyGame/Example/Monster.cs

@@ -0,0 +1,73 @@
+// automatically generated, do not modify
+
+namespace MyGame.Example
+{
+
+using FlatBuffers;
+
+public class Monster : Table {
+  public static Monster GetRootAsMonster(ByteBuffer _bb) { return (new Monster()).__init(_bb.GetInt(_bb.position()) + _bb.position(), _bb); }
+  public static bool MonsterBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "MONS"); }
+  public Monster __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public Vec3 Pos() { return Pos(new Vec3()); }
+  public Vec3 Pos(Vec3 obj) { int o = __offset(4); return o != 0 ? obj.__init(o + bb_pos, bb) : null; }
+  public short Mana() { int o = __offset(6); return o != 0 ? bb.GetShort(o + bb_pos) : (short)150; }
+  public short Hp() { int o = __offset(8); return o != 0 ? bb.GetShort(o + bb_pos) : (short)100; }
+  public string Name() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; }
+  public byte Inventory(int j) { int o = __offset(14); return o != 0 ? bb.Get(__vector(o) + j * 1) : (byte)0; }
+  public int InventoryLength() { int o = __offset(14); return o != 0 ? __vector_len(o) : 0; }
+  public sbyte Color() { int o = __offset(16); return o != 0 ? bb.GetSbyte(o + bb_pos) : (sbyte)8; }
+  public byte TestType() { int o = __offset(18); return o != 0 ? bb.Get(o + bb_pos) : (byte)0; }
+  public Table Test(Table obj) { int o = __offset(20); return o != 0 ? __union(obj, o) : null; }
+  public Test Test4(int j) { return Test4(new Test(), j); }
+  public Test Test4(Test obj, int j) { int o = __offset(22); return o != 0 ? obj.__init(__vector(o) + j * 4, bb) : null; }
+  public int Test4Length() { int o = __offset(22); return o != 0 ? __vector_len(o) : 0; }
+  public string Testarrayofstring(int j) { int o = __offset(24); return o != 0 ? __string(__vector(o) + j * 4) : null; }
+  public int TestarrayofstringLength() { int o = __offset(24); return o != 0 ? __vector_len(o) : 0; }
+  /// an example documentation comment: this will end up in the generated code
+  /// multiline too
+  public Monster Testarrayoftables(int j) { return Testarrayoftables(new Monster(), j); }
+  public Monster Testarrayoftables(Monster obj, int j) { int o = __offset(26); return o != 0 ? obj.__init(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int TestarrayoftablesLength() { int o = __offset(26); return o != 0 ? __vector_len(o) : 0; }
+  public Monster Enemy() { return Enemy(new Monster()); }
+  public Monster Enemy(Monster obj) { int o = __offset(28); return o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null; }
+  public byte Testnestedflatbuffer(int j) { int o = __offset(30); return o != 0 ? bb.Get(__vector(o) + j * 1) : (byte)0; }
+  public int TestnestedflatbufferLength() { int o = __offset(30); return o != 0 ? __vector_len(o) : 0; }
+  public Stat Testempty() { return Testempty(new Stat()); }
+  public Stat Testempty(Stat obj) { int o = __offset(32); return o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null; }
+
+  public static void StartMonster(FlatBufferBuilder builder) { builder.StartObject(15); }
+  public static void AddPos(FlatBufferBuilder builder, int posOffset) { builder.AddStruct(0, posOffset, 0); }
+  public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); }
+  public static void AddHp(FlatBufferBuilder builder, short hp) { builder.AddShort(2, hp, 100); }
+  public static void AddName(FlatBufferBuilder builder, int nameOffset) { builder.AddOffset(3, nameOffset, 0); }
+  public static void AddInventory(FlatBufferBuilder builder, int inventoryOffset) { builder.AddOffset(5, inventoryOffset, 0); }
+  public static int CreateInventoryVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); }
+  public static void StartInventoryVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
+  public static void AddColor(FlatBufferBuilder builder, sbyte color) { builder.AddSbyte(6, color, 8); }
+  public static void AddTestType(FlatBufferBuilder builder, byte testType) { builder.AddByte(7, testType, 0); }
+  public static void AddTest(FlatBufferBuilder builder, int testOffset) { builder.AddOffset(8, testOffset, 0); }
+  public static void AddTest4(FlatBufferBuilder builder, int test4Offset) { builder.AddOffset(9, test4Offset, 0); }
+  public static void StartTest4Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 2); }
+  public static void AddTestarrayofstring(FlatBufferBuilder builder, int testarrayofstringOffset) { builder.AddOffset(10, testarrayofstringOffset, 0); }
+  public static int CreateTestarrayofstringVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i]); return builder.EndVector(); }
+  public static void StartTestarrayofstringVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddTestarrayoftables(FlatBufferBuilder builder, int testarrayoftablesOffset) { builder.AddOffset(11, testarrayoftablesOffset, 0); }
+  public static int CreateTestarrayoftablesVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i]); return builder.EndVector(); }
+  public static void StartTestarrayoftablesVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddEnemy(FlatBufferBuilder builder, int enemyOffset) { builder.AddOffset(12, enemyOffset, 0); }
+  public static void AddTestnestedflatbuffer(FlatBufferBuilder builder, int testnestedflatbufferOffset) { builder.AddOffset(13, testnestedflatbufferOffset, 0); }
+  public static int CreateTestnestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddByte(data[i]); return builder.EndVector(); }
+  public static void StartTestnestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); }
+  public static void AddTestempty(FlatBufferBuilder builder, int testemptyOffset) { builder.AddOffset(14, testemptyOffset, 0); }
+  public static int EndMonster(FlatBufferBuilder builder) {
+    int o = builder.EndObject();
+    builder.Required(o, 10);  // name
+    return o;
+  }
+  public static void FinishMonsterBuffer(FlatBufferBuilder builder, int offset) { builder.Finish(offset, "MONS"); }
+};
+
+
+}

tests/MyGame/Example/Monster.go

@@ -53,7 +53,7 @@ func (rcv *Monster) Hp() int16 {
 func (rcv *Monster) Name() string {
 	o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
 	if o != 0 {
-		return rcv._tab.String(o)
+		return rcv._tab.String(o + rcv._tab.Pos)
 	}
 	return ""
 }
@@ -139,7 +139,8 @@ func (rcv *Monster) TestarrayofstringLength() int {
 	return 0
 }
 
-/// an example documentation comment: this will end up in the generated code multiline too
+/// an example documentation comment: this will end up in the generated code
+/// multiline too
 func (rcv *Monster) Testarrayoftables(obj *Monster, j int) bool {
 	o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
 	if o != 0 {
@@ -193,23 +194,42 @@ func (rcv *Monster) TestnestedflatbufferLength() int {
 	return 0
 }
 
-func MonsterStart(builder *flatbuffers.Builder) { builder.StartObject(14) }
+func (rcv *Monster) Testempty(obj *Stat) *Stat {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
+	if o != 0 {
+		x := rcv._tab.Indirect(o + rcv._tab.Pos)
+		if obj == nil {
+			obj = new(Stat)
+		}
+		obj.Init(rcv._tab.Bytes, x)
+		return obj
+	}
+	return nil
+}
+
+func MonsterStart(builder *flatbuffers.Builder) { builder.StartObject(15) }
 func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) { builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0) }
 func MonsterAddMana(builder *flatbuffers.Builder, mana int16) { builder.PrependInt16Slot(1, mana, 150) }
 func MonsterAddHp(builder *flatbuffers.Builder, hp int16) { builder.PrependInt16Slot(2, hp, 100) }
 func MonsterAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(name), 0) }
 func MonsterAddInventory(builder *flatbuffers.Builder, inventory flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(inventory), 0) }
-func MonsterStartInventoryVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(1, numElems) }
+func MonsterStartInventoryVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(1, numElems, 1)
+}
 func MonsterAddColor(builder *flatbuffers.Builder, color int8) { builder.PrependInt8Slot(6, color, 8) }
 func MonsterAddTestType(builder *flatbuffers.Builder, testType byte) { builder.PrependByteSlot(7, testType, 0) }
 func MonsterAddTest(builder *flatbuffers.Builder, test flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(test), 0) }
 func MonsterAddTest4(builder *flatbuffers.Builder, test4 flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(9, flatbuffers.UOffsetT(test4), 0) }
-func MonsterStartTest4Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems) }
+func MonsterStartTest4Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 2)
+}
 func MonsterAddTestarrayofstring(builder *flatbuffers.Builder, testarrayofstring flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(testarrayofstring), 0) }
-func MonsterStartTestarrayofstringVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems) }
+func MonsterStartTestarrayofstringVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4)
+}
 func MonsterAddTestarrayoftables(builder *flatbuffers.Builder, testarrayoftables flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(testarrayoftables), 0) }
-func MonsterStartTestarrayoftablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems) }
+func MonsterStartTestarrayoftablesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(4, numElems, 4)
+}
 func MonsterAddEnemy(builder *flatbuffers.Builder, enemy flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(12, flatbuffers.UOffsetT(enemy), 0) }
 func MonsterAddTestnestedflatbuffer(builder *flatbuffers.Builder, testnestedflatbuffer flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(13, flatbuffers.UOffsetT(testnestedflatbuffer), 0) }
-func MonsterStartTestnestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(1, numElems) }
+func MonsterStartTestnestedflatbufferVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { return builder.StartVector(1, numElems, 1)
+}
+func MonsterAddTestempty(builder *flatbuffers.Builder, testempty flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(14, flatbuffers.UOffsetT(testempty), 0) }
 func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() }

tests/MyGame/Example/Monster.java

@@ -5,36 +5,45 @@ package MyGame.Example;
 import java.nio.*;
 import java.lang.*;
 import java.util.*;
-import flatbuffers.*;
+import com.google.flatbuffers.*;
 
 public class Monster extends Table {
-  public static Monster getRootAsMonster(ByteBuffer _bb, int offset) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (new Monster()).__init(_bb.getInt(offset) + offset, _bb); }
+  public static Monster getRootAsMonster(ByteBuffer _bb) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (new Monster()).__init(_bb.getInt(_bb.position()) + _bb.position(), _bb); }
+  public static boolean MonsterBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "MONS"); }
   public Monster __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
   public Vec3 pos() { return pos(new Vec3()); }
   public Vec3 pos(Vec3 obj) { int o = __offset(4); return o != 0 ? obj.__init(o + bb_pos, bb) : null; }
   public short mana() { int o = __offset(6); return o != 0 ? bb.getShort(o + bb_pos) : 150; }
   public short hp() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) : 100; }
   public String name() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer nameAsByteBuffer() { return __vector_as_bytebuffer(10, 1); }
   public byte inventory(int j) { int o = __offset(14); return o != 0 ? bb.get(__vector(o) + j * 1) : 0; }
   public int inventoryLength() { int o = __offset(14); return o != 0 ? __vector_len(o) : 0; }
+  public ByteBuffer inventoryAsByteBuffer() { return __vector_as_bytebuffer(14, 1); }
   public byte color() { int o = __offset(16); return o != 0 ? bb.get(o + bb_pos) : 8; }
   public byte testType() { int o = __offset(18); return o != 0 ? bb.get(o + bb_pos) : 0; }
   public Table test(Table obj) { int o = __offset(20); return o != 0 ? __union(obj, o) : null; }
   public Test test4(int j) { return test4(new Test(), j); }
   public Test test4(Test obj, int j) { int o = __offset(22); return o != 0 ? obj.__init(__vector(o) + j * 4, bb) : null; }
   public int test4Length() { int o = __offset(22); return o != 0 ? __vector_len(o) : 0; }
+  public ByteBuffer test4AsByteBuffer() { return __vector_as_bytebuffer(22, 4); }
   public String testarrayofstring(int j) { int o = __offset(24); return o != 0 ? __string(__vector(o) + j * 4) : null; }
   public int testarrayofstringLength() { int o = __offset(24); return o != 0 ? __vector_len(o) : 0; }
-  /// an example documentation comment: this will end up in the generated code multiline too
+  public ByteBuffer testarrayofstringAsByteBuffer() { return __vector_as_bytebuffer(24, 4); }
+  /// an example documentation comment: this will end up in the generated code
+  /// multiline too
   public Monster testarrayoftables(int j) { return testarrayoftables(new Monster(), j); }
   public Monster testarrayoftables(Monster obj, int j) { int o = __offset(26); return o != 0 ? obj.__init(__indirect(__vector(o) + j * 4), bb) : null; }
   public int testarrayoftablesLength() { int o = __offset(26); return o != 0 ? __vector_len(o) : 0; }
+  public ByteBuffer testarrayoftablesAsByteBuffer() { return __vector_as_bytebuffer(26, 4); }
   public Monster enemy() { return enemy(new Monster()); }
   public Monster enemy(Monster obj) { int o = __offset(28); return o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null; }
   public byte testnestedflatbuffer(int j) { int o = __offset(30); return o != 0 ? bb.get(__vector(o) + j * 1) : 0; }
   public int testnestedflatbufferLength() { int o = __offset(30); return o != 0 ? __vector_len(o) : 0; }
-  public Monster testempty() { return testempty(new Monster()); }
-  public Monster testempty(Monster obj) { int o = __offset(32); return o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null; }
+  public ByteBuffer testnestedflatbufferAsByteBuffer() { return __vector_as_bytebuffer(30, 1); }
+  public Stat testempty() { return testempty(new Stat()); }
+  public Stat testempty(Stat obj) { int o = __offset(32); return o != 0 ? obj.__init(__indirect(o + bb_pos), bb) : null; }
 
   public static void startMonster(FlatBufferBuilder builder) { builder.startObject(15); }
   public static void addPos(FlatBufferBuilder builder, int posOffset) { builder.addStruct(0, posOffset, 0); }
@@ -42,6 +51,7 @@ public class Monster extends Table {
   public static void addHp(FlatBufferBuilder builder, short hp) { builder.addShort(2, hp, 100); }
   public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(3, nameOffset, 0); }
   public static void addInventory(FlatBufferBuilder builder, int inventoryOffset) { builder.addOffset(5, inventoryOffset, 0); }
+  public static int createInventoryVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
   public static void startInventoryVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
   public static void addColor(FlatBufferBuilder builder, byte color) { builder.addByte(6, color, 8); }
   public static void addTestType(FlatBufferBuilder builder, byte testType) { builder.addByte(7, testType, 0); }
@@ -49,13 +59,21 @@ public class Monster extends Table {
   public static void addTest4(FlatBufferBuilder builder, int test4Offset) { builder.addOffset(9, test4Offset, 0); }
   public static void startTest4Vector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 2); }
   public static void addTestarrayofstring(FlatBufferBuilder builder, int testarrayofstringOffset) { builder.addOffset(10, testarrayofstringOffset, 0); }
+  public static int createTestarrayofstringVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
   public static void startTestarrayofstringVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
   public static void addTestarrayoftables(FlatBufferBuilder builder, int testarrayoftablesOffset) { builder.addOffset(11, testarrayoftablesOffset, 0); }
+  public static int createTestarrayoftablesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
   public static void startTestarrayoftablesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
   public static void addEnemy(FlatBufferBuilder builder, int enemyOffset) { builder.addOffset(12, enemyOffset, 0); }
   public static void addTestnestedflatbuffer(FlatBufferBuilder builder, int testnestedflatbufferOffset) { builder.addOffset(13, testnestedflatbufferOffset, 0); }
+  public static int createTestnestedflatbufferVector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); }
   public static void startTestnestedflatbufferVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
   public static void addTestempty(FlatBufferBuilder builder, int testemptyOffset) { builder.addOffset(14, testemptyOffset, 0); }
-  public static int endMonster(FlatBufferBuilder builder) { return builder.endObject(); }
+  public static int endMonster(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    builder.required(o, 10);  // name
+    return o;
+  }
+  public static void finishMonsterBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset, "MONS"); }
 };
 

tests/MyGame/Example/Stat.cs

@@ -0,0 +1,34 @@
+// automatically generated, do not modify
+
+namespace MyGame.Example
+{
+
+using FlatBuffers;
+
+public class Stat : Table {
+  public static Stat GetRootAsStat(ByteBuffer _bb) { return (new Stat()).__init(_bb.GetInt(_bb.position()) + _bb.position(), _bb); }
+  public Stat __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public string Id() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public long Val() { int o = __offset(6); return o != 0 ? bb.GetLong(o + bb_pos) : (long)0; }
+
+  public static int CreateStat(FlatBufferBuilder builder,
+      int id = 0,
+      long val = 0) {
+    builder.StartObject(2);
+    Stat.AddVal(builder, val);
+    Stat.AddId(builder, id);
+    return Stat.EndStat(builder);
+  }
+
+  public static void StartStat(FlatBufferBuilder builder) { builder.StartObject(2); }
+  public static void AddId(FlatBufferBuilder builder, int idOffset) { builder.AddOffset(0, idOffset, 0); }
+  public static void AddVal(FlatBufferBuilder builder, long val) { builder.AddLong(1, val, 0); }
+  public static int EndStat(FlatBufferBuilder builder) {
+    int o = builder.EndObject();
+    return o;
+  }
+};
+
+
+}

tests/MyGame/Example/Stat.go

@@ -0,0 +1,36 @@
+// automatically generated, do not modify
+
+package Example
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+type Stat struct {
+	_tab flatbuffers.Table
+}
+
+func (rcv *Stat) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *Stat) Id() string {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+	if o != 0 {
+		return rcv._tab.String(o + rcv._tab.Pos)
+	}
+	return ""
+}
+
+func (rcv *Stat) Val() int64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+	if o != 0 {
+		return rcv._tab.GetInt64(o + rcv._tab.Pos)
+	}
+	return 0
+}
+
+func StatStart(builder *flatbuffers.Builder) { builder.StartObject(2) }
+func StatAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) { builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0) }
+func StatAddVal(builder *flatbuffers.Builder, val int64) { builder.PrependInt64Slot(1, val, 0) }
+func StatEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { return builder.EndObject() }

tests/MyGame/Example/Stat.java

@@ -0,0 +1,35 @@
+// automatically generated, do not modify
+
+package MyGame.Example;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+public class Stat extends Table {
+  public static Stat getRootAsStat(ByteBuffer _bb) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (new Stat()).__init(_bb.getInt(_bb.position()) + _bb.position(), _bb); }
+  public Stat __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public String id() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer idAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+  public long val() { int o = __offset(6); return o != 0 ? bb.getLong(o + bb_pos) : 0; }
+
+  public static int createStat(FlatBufferBuilder builder,
+      int id,
+      long val) {
+    builder.startObject(2);
+    Stat.addVal(builder, val);
+    Stat.addId(builder, id);
+    return Stat.endStat(builder);
+  }
+
+  public static void startStat(FlatBufferBuilder builder) { builder.startObject(2); }
+  public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addOffset(0, idOffset, 0); }
+  public static void addVal(FlatBufferBuilder builder, long val) { builder.addLong(1, val, 0); }
+  public static int endStat(FlatBufferBuilder builder) {
+    int o = builder.endObject();
+    return o;
+  }
+};
+

tests/MyGame/Example/Test.cs

@@ -0,0 +1,24 @@
+// automatically generated, do not modify
+
+namespace MyGame.Example
+{
+
+using FlatBuffers;
+
+public class Test : Struct {
+  public Test __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public short A() { return bb.GetShort(bb_pos + 0); }
+  public sbyte B() { return bb.GetSbyte(bb_pos + 2); }
+
+  public static int CreateTest(FlatBufferBuilder builder, short A, sbyte B) {
+    builder.Prep(2, 4);
+    builder.Pad(1);
+    builder.PutSbyte(B);
+    builder.PutShort(A);
+    return builder.Offset();
+  }
+};
+
+
+}

tests/MyGame/Example/Test.java

@@ -5,10 +5,11 @@ package MyGame.Example;
 import java.nio.*;
 import java.lang.*;
 import java.util.*;
-import flatbuffers.*;
+import com.google.flatbuffers.*;
 
 public class Test extends Struct {
   public Test __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
   public short a() { return bb.getShort(bb_pos + 0); }
   public byte b() { return bb.get(bb_pos + 2); }
 

tests/MyGame/Example/Vec3.cs

@@ -0,0 +1,38 @@
+// automatically generated, do not modify
+
+namespace MyGame.Example
+{
+
+using FlatBuffers;
+
+public class Vec3 : Struct {
+  public Vec3 __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
+  public float X() { return bb.GetFloat(bb_pos + 0); }
+  public float Y() { return bb.GetFloat(bb_pos + 4); }
+  public float Z() { return bb.GetFloat(bb_pos + 8); }
+  public double Test1() { return bb.GetDouble(bb_pos + 16); }
+  public sbyte Test2() { return bb.GetSbyte(bb_pos + 24); }
+  public Test Test3() { return Test3(new Test()); }
+  public Test Test3(Test obj) { return obj.__init(bb_pos + 26, bb); }
+
+  public static int CreateVec3(FlatBufferBuilder builder, float X, float Y, float Z, double Test1, sbyte Test2, short Test_A, sbyte Test_B) {
+    builder.Prep(16, 32);
+    builder.Pad(2);
+    builder.Prep(2, 4);
+    builder.Pad(1);
+    builder.PutSbyte(Test_B);
+    builder.PutShort(Test_A);
+    builder.Pad(1);
+    builder.PutSbyte(Test2);
+    builder.PutDouble(Test1);
+    builder.Pad(4);
+    builder.PutFloat(Z);
+    builder.PutFloat(Y);
+    builder.PutFloat(X);
+    return builder.Offset();
+  }
+};
+
+
+}

tests/MyGame/Example/Vec3.java

@@ -5,10 +5,11 @@ package MyGame.Example;
 import java.nio.*;
 import java.lang.*;
 import java.util.*;
-import flatbuffers.*;
+import com.google.flatbuffers.*;
 
 public class Vec3 extends Struct {
   public Vec3 __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; return this; }
+
   public float x() { return bb.getFloat(bb_pos + 0); }
   public float y() { return bb.getFloat(bb_pos + 4); }
   public float z() { return bb.getFloat(bb_pos + 8); }

tests/go_test.go

@@ -21,9 +21,9 @@ var (
 
 func init() {
 	flag.StringVar(&cppData, "cpp_data", "",
-		"location of monsterdata_test.bin to verify against (required)")
+		"location of monsterdata_test.mon to verify against (required)")
 	flag.StringVar(&javaData, "java_data", "",
-		"location of monsterdata_java_wire.bin to verify against (optional)")
+		"location of monsterdata_java_wire.mon to verify against (optional)")
 	flag.StringVar(&outData, "out_data", "",
 		"location to write generated Go data")
 	flag.BoolVar(&fuzz, "fuzz", false, "perform fuzzing")
@@ -146,8 +146,8 @@ func CheckReadBuffer(buf []byte, offset flatbuffers.UOffsetT, fail func(string,
 		fail(FailString("Pos.Test1", float64(3.0), got))
 	}
 
-	if got := vec.Test2(); int8(4) != got {
-		fail(FailString("Pos.Test2", int8(4), got))
+	if got := vec.Test2(); int8(2) != got {
+		fail(FailString("Pos.Test2", int8(2), got))
 	}
 
 	// initialize a Test from Test3(...)
@@ -190,8 +190,8 @@ func CheckReadBuffer(buf []byte, offset flatbuffers.UOffsetT, fail func(string,
 	var monster2 example.Monster
 	monster2.Init(table2.Bytes, table2.Pos)
 
-	if got := monster2.Hp(); int16(20) != got {
-		fail(FailString("monster2.Hp()", int16(20), got))
+	if got := monster2.Name(); "Fred" != got {
+		fail(FailString("monster2.Name()", "Fred", got))
 	}
 
 	if got := monster.InventoryLength(); 5 != got {
@@ -235,6 +235,18 @@ func CheckReadBuffer(buf []byte, offset flatbuffers.UOffsetT, fail func(string,
 	if 100 != sum {
 		fail(FailString("test0 and test1 sum", 100, sum))
 	}
+
+	if got := monster.TestarrayofstringLength(); 2 != got {
+		fail(FailString("Testarrayofstring length", 2, got))
+	}
+
+	if got := monster.Testarrayofstring(0); "test1" != got {
+		fail(FailString("Testarrayofstring(0)", "test1", got))
+	}
+
+	if got := monster.Testarrayofstring(1); "test2" != got {
+		fail(FailString("Testarrayofstring(1)", "test2", got))
+	}
 }
 
 // Low level stress/fuzz test: serialize/deserialize a variety of
@@ -429,7 +441,7 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 
 	b = flatbuffers.NewBuilder(0)
 	check([]byte{})
-	b.StartVector(flatbuffers.SizeByte, 1)
+	b.StartVector(flatbuffers.SizeByte, 1, 1)
 	check([]byte{0, 0, 0}) // align to 4bytes
 	b.PrependByte(1)
 	check([]byte{1, 0, 0, 0})
@@ -439,7 +451,7 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 	// test 3: 2xbyte vector
 
 	b = flatbuffers.NewBuilder(0)
-	b.StartVector(flatbuffers.SizeByte, 2)
+	b.StartVector(flatbuffers.SizeByte, 2, 1)
 	check([]byte{0, 0}) // align to 4bytes
 	b.PrependByte(1)
 	check([]byte{1, 0, 0})
@@ -451,7 +463,7 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 	// test 4: 1xuint16 vector
 
 	b = flatbuffers.NewBuilder(0)
-	b.StartVector(flatbuffers.SizeUint16, 1)
+	b.StartVector(flatbuffers.SizeUint16, 1, 1)
 	check([]byte{0, 0}) // align to 4bytes
 	b.PrependUint16(1)
 	check([]byte{1, 0, 0, 0})
@@ -461,7 +473,7 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 	// test 5: 2xuint16 vector
 
 	b = flatbuffers.NewBuilder(0)
-	b.StartVector(flatbuffers.SizeUint16, 2)
+	b.StartVector(flatbuffers.SizeUint16, 2, 1)
 	check([]byte{}) // align to 4bytes
 	b.PrependUint16(0xABCD)
 	check([]byte{0xCD, 0xAB})
@@ -565,7 +577,7 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 
 	// test 12: vtable with empty vector
 	b = flatbuffers.NewBuilder(0)
-	b.StartVector(flatbuffers.SizeByte, 0)
+	b.StartVector(flatbuffers.SizeByte, 0, 1)
 	vecend := b.EndVector(0)
 	b.StartObject(1)
 	b.PrependUOffsetTSlot(0, vecend, 0)
@@ -581,7 +593,7 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 
 	// test 12b: vtable with empty vector of byte and some scalars
 	b = flatbuffers.NewBuilder(0)
-	b.StartVector(flatbuffers.SizeByte, 0)
+	b.StartVector(flatbuffers.SizeByte, 0, 1)
 	vecend = b.EndVector(0)
 	b.StartObject(2)
 	b.PrependInt16Slot(0, 55, 0)
@@ -601,7 +613,7 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 
 	// test 13: vtable with 1 int16 and 2-vector of int16
 	b = flatbuffers.NewBuilder(0)
-	b.StartVector(flatbuffers.SizeInt16, 2)
+	b.StartVector(flatbuffers.SizeInt16, 2, 1)
 	b.PrependInt16(0x1234)
 	b.PrependInt16(0x5678)
 	vecend = b.EndVector(2)
@@ -649,7 +661,7 @@ func CheckByteLayout(fail func(string, ...interface{})) {
 
 	// test 15: vtable with 1 vector of 2 struct of 2 int8
 	b = flatbuffers.NewBuilder(0)
-	b.StartVector(flatbuffers.SizeInt8*2, 2)
+	b.StartVector(flatbuffers.SizeInt8*2, 2, 1)
 	b.PrependInt8(33)
 	b.PrependInt8(44)
 	b.PrependInt8(55)
@@ -824,7 +836,7 @@ func CheckManualBuild(fail func(string, ...interface{})) ([]byte, flatbuffers.UO
 	b := flatbuffers.NewBuilder(0)
 	str := b.CreateString("MyMonster")
 
-	b.StartVector(1, 5)
+	b.StartVector(1, 5, 1)
 	b.PrependByte(4)
 	b.PrependByte(3)
 	b.PrependByte(2)
@@ -837,7 +849,7 @@ func CheckManualBuild(fail func(string, ...interface{})) ([]byte, flatbuffers.UO
 	mon2 := b.EndObject()
 
 	// Test4Vector
-	b.StartVector(4, 2)
+	b.StartVector(4, 2, 1)
 
 	// Test 0
 	b.Prep(2, 4)
@@ -891,6 +903,10 @@ func CheckManualBuild(fail func(string, ...interface{})) ([]byte, flatbuffers.UO
 func CheckGeneratedBuild(fail func(string, ...interface{})) ([]byte, flatbuffers.UOffsetT) {
 	b := flatbuffers.NewBuilder(0)
 	str := b.CreateString("MyMonster")
+	test1 := b.CreateString("test1")
+	test2 := b.CreateString("test2")
+	fred := b.CreateString("Fred")
+
 	example.MonsterStartInventoryVector(b, 5)
 	b.PrependByte(4)
 	b.PrependByte(3)
@@ -900,7 +916,7 @@ func CheckGeneratedBuild(fail func(string, ...interface{})) ([]byte, flatbuffers
 	inv := b.EndVector(5)
 
 	example.MonsterStart(b)
-	example.MonsterAddHp(b, int16(20))
+	example.MonsterAddName(b, fred)
 	mon2 := example.MonsterEnd(b)
 
 	example.MonsterStartTest4Vector(b, 2)
@@ -908,9 +924,14 @@ func CheckGeneratedBuild(fail func(string, ...interface{})) ([]byte, flatbuffers
 	example.CreateTest(b, 30, 40)
 	test4 := b.EndVector(2)
 
+	example.MonsterStartTestarrayofstringVector(b, 2)
+	b.PrependUOffsetT(test2)
+	b.PrependUOffsetT(test1)
+	testArrayOfString := b.EndVector(2)
+
 	example.MonsterStart(b)
 
-	pos := example.CreateVec3(b, 1.0, 2.0, 3.0, 3.0, 4, 5, 6)
+	pos := example.CreateVec3(b, 1.0, 2.0, 3.0, 3.0, 2, 5, 6)
 	example.MonsterAddPos(b, pos)
 
 	example.MonsterAddHp(b, 80)
@@ -919,6 +940,7 @@ func CheckGeneratedBuild(fail func(string, ...interface{})) ([]byte, flatbuffers
 	example.MonsterAddTestType(b, 1)
 	example.MonsterAddTest(b, mon2)
 	example.MonsterAddTest4(b, test4)
+	example.MonsterAddTestarrayofstring(b, testArrayOfString)
 	mon := example.MonsterEnd(b)
 
 	b.Finish(mon)

tests/include_test1.fbs

@@ -0,0 +1,5 @@
+include "include_test2.fbs";
+include "include_test2.fbs";  // should be skipped
+include "include_test1.fbs";  // should be skipped
+
+

tests/include_test2.fbs

@@ -0,0 +1,9 @@
+include "include_test2.fbs";    // should be skipped
+
+namespace MyGame.OtherNameSpace;
+
+enum FromInclude:long { IncludeVal }
+
+struct Unused {}
+
+

tests/monster_test.fbs

@@ -1,8 +1,10 @@
-// example IDL file
+// test schema file
+
+include "include_test1.fbs";
 
 namespace MyGame.Example;
 
-enum Color:byte (bit_flags) { Red = 0, Green, Blue = 3 }
+enum Color:byte (bit_flags) { Red = 0, Green, Blue = 3, }
 
 union Any { Monster }  // TODO: add more elements
 
@@ -13,15 +15,20 @@ struct Vec3 (force_align: 16) {
   y:float;
   z:float;
   test1:double;
-  test2:byte;
+  test2:Color;
   test3:Test;
 }
 
+table Stat {
+  id:string;
+  val:long;
+}
+
 table Monster {
   pos:Vec3 (id: 0);
   hp:short = 100 (id: 2);
   mana:short = 150 (id: 1);
-  name:string (id: 3);
+  name:string (id: 3, required);
   color:Color = Blue (id: 6);
   inventory:[ubyte] (id: 5);
   friendly:bool = false (deprecated, priority: 1, id: 4);
@@ -33,7 +40,7 @@ table Monster {
   test:Any (id: 8);
   test4:[Test] (id: 9);
   testnestedflatbuffer:[ubyte] (id:13, nested_flatbuffer: "Monster");
-  testempty:Monster (id:14);
+  testempty:Stat (id:14);
 }
 
 root_type Monster;

tests/monster_test_generated.h

@@ -1,14 +1,25 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 
-#ifndef FLATBUFFERS_GENERATED_MONSTER_TEST_MYGAME_EXAMPLE_H_
-#define FLATBUFFERS_GENERATED_MONSTER_TEST_MYGAME_EXAMPLE_H_
+#ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
+#define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_
 
 #include "flatbuffers/flatbuffers.h"
 
+namespace MyGame {
+namespace OtherNameSpace {
+struct Unused;
+}  // namespace OtherNameSpace
+}  // namespace MyGame
+
 namespace MyGame {
 namespace Example {
 
-enum {
+struct Test;
+struct Vec3;
+struct Stat;
+struct Monster;
+
+enum Color {
   Color_Red = 1,
   Color_Green = 2,
   Color_Blue = 8
@@ -19,9 +30,9 @@ inline const char **EnumNamesColor() {
   return names;
 }
 
-inline const char *EnumNameColor(int e) { return EnumNamesColor()[e - Color_Red]; }
+inline const char *EnumNameColor(Color e) { return EnumNamesColor()[e - Color_Red]; }
 
-enum {
+enum Any {
   Any_NONE = 0,
   Any_Monster = 1
 };
@@ -31,13 +42,9 @@ inline const char **EnumNamesAny() {
   return names;
 }
 
-inline const char *EnumNameAny(int e) { return EnumNamesAny()[e]; }
+inline const char *EnumNameAny(Any e) { return EnumNamesAny()[e]; }
 
-bool VerifyAny(const flatbuffers::Verifier &verifier, const void *union_obj, uint8_t type);
-
-struct Test;
-struct Vec3;
-struct Monster;
+inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *union_obj, Any type);
 
 MANUALLY_ALIGNED_STRUCT(2) Test {
  private:
@@ -47,7 +54,7 @@ MANUALLY_ALIGNED_STRUCT(2) Test {
 
  public:
   Test(int16_t a, int8_t b)
-    : a_(flatbuffers::EndianScalar(a)), b_(flatbuffers::EndianScalar(b)), __padding0(0) {}
+    : a_(flatbuffers::EndianScalar(a)), b_(flatbuffers::EndianScalar(b)), __padding0(0) { (void)__padding0; }
 
   int16_t a() const { return flatbuffers::EndianScalar(a_); }
   int8_t b() const { return flatbuffers::EndianScalar(b_); }
@@ -67,41 +74,76 @@ MANUALLY_ALIGNED_STRUCT(16) Vec3 {
   int16_t __padding2;
 
  public:
-  Vec3(float x, float y, float z, double test1, int8_t test2, const Test &test3)
-    : x_(flatbuffers::EndianScalar(x)), y_(flatbuffers::EndianScalar(y)), z_(flatbuffers::EndianScalar(z)), __padding0(0), test1_(flatbuffers::EndianScalar(test1)), test2_(flatbuffers::EndianScalar(test2)), __padding1(0), test3_(test3), __padding2(0) {}
+  Vec3(float x, float y, float z, double test1, Color test2, const Test &test3)
+    : x_(flatbuffers::EndianScalar(x)), y_(flatbuffers::EndianScalar(y)), z_(flatbuffers::EndianScalar(z)), __padding0(0), test1_(flatbuffers::EndianScalar(test1)), test2_(flatbuffers::EndianScalar(static_cast<int8_t>(test2))), __padding1(0), test3_(test3), __padding2(0) { (void)__padding0; (void)__padding1; (void)__padding2; }
 
   float x() const { return flatbuffers::EndianScalar(x_); }
   float y() const { return flatbuffers::EndianScalar(y_); }
   float z() const { return flatbuffers::EndianScalar(z_); }
   double test1() const { return flatbuffers::EndianScalar(test1_); }
-  int8_t test2() const { return flatbuffers::EndianScalar(test2_); }
+  Color test2() const { return static_cast<Color>(flatbuffers::EndianScalar(test2_)); }
   const Test &test3() const { return test3_; }
 };
 STRUCT_END(Vec3, 32);
 
+struct Stat : private flatbuffers::Table {
+  const flatbuffers::String *id() const { return GetPointer<const flatbuffers::String *>(4); }
+  int64_t val() const { return GetField<int64_t>(6, 0); }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<flatbuffers::uoffset_t>(verifier, 4 /* id */) &&
+           verifier.Verify(id()) &&
+           VerifyField<int64_t>(verifier, 6 /* val */) &&
+           verifier.EndTable();
+  }
+};
+
+struct StatBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_id(flatbuffers::Offset<flatbuffers::String> id) { fbb_.AddOffset(4, id); }
+  void add_val(int64_t val) { fbb_.AddElement<int64_t>(6, val, 0); }
+  StatBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
+  StatBuilder &operator=(const StatBuilder &);
+  flatbuffers::Offset<Stat> Finish() {
+    auto o = flatbuffers::Offset<Stat>(fbb_.EndTable(start_, 2));
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Stat> CreateStat(flatbuffers::FlatBufferBuilder &_fbb,
+   flatbuffers::Offset<flatbuffers::String> id = 0,
+   int64_t val = 0) {
+  StatBuilder builder_(_fbb);
+  builder_.add_val(val);
+  builder_.add_id(id);
+  return builder_.Finish();
+}
+
 struct Monster : private flatbuffers::Table {
   const Vec3 *pos() const { return GetStruct<const Vec3 *>(4); }
   int16_t mana() const { return GetField<int16_t>(6, 150); }
   int16_t hp() const { return GetField<int16_t>(8, 100); }
   const flatbuffers::String *name() const { return GetPointer<const flatbuffers::String *>(10); }
   const flatbuffers::Vector<uint8_t> *inventory() const { return GetPointer<const flatbuffers::Vector<uint8_t> *>(14); }
-  int8_t color() const { return GetField<int8_t>(16, 8); }
-  uint8_t test_type() const { return GetField<uint8_t>(18, 0); }
+  Color color() const { return static_cast<Color>(GetField<int8_t>(16, 8)); }
+  Any test_type() const { return static_cast<Any>(GetField<uint8_t>(18, 0)); }
   const void *test() const { return GetPointer<const void *>(20); }
   const flatbuffers::Vector<const Test *> *test4() const { return GetPointer<const flatbuffers::Vector<const Test *> *>(22); }
   const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *testarrayofstring() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(24); }
-  /// an example documentation comment: this will end up in the generated code multiline too
+  /// an example documentation comment: this will end up in the generated code
+  /// multiline too
   const flatbuffers::Vector<flatbuffers::Offset<Monster>> *testarrayoftables() const { return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Monster>> *>(26); }
   const Monster *enemy() const { return GetPointer<const Monster *>(28); }
   const flatbuffers::Vector<uint8_t> *testnestedflatbuffer() const { return GetPointer<const flatbuffers::Vector<uint8_t> *>(30); }
   const Monster *testnestedflatbuffer_nested_root() { return flatbuffers::GetRoot<Monster>(testnestedflatbuffer()->Data()); }
-  const Monster *testempty() const { return GetPointer<const Monster *>(32); }
-  bool Verify(const flatbuffers::Verifier &verifier) const {
-    return VerifyTable(verifier) &&
+  const Stat *testempty() const { return GetPointer<const Stat *>(32); }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
            VerifyField<Vec3>(verifier, 4 /* pos */) &&
            VerifyField<int16_t>(verifier, 6 /* mana */) &&
            VerifyField<int16_t>(verifier, 8 /* hp */) &&
-           VerifyField<flatbuffers::uoffset_t>(verifier, 10 /* name */) &&
+           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, 10 /* name */) &&
            verifier.Verify(name()) &&
            VerifyField<flatbuffers::uoffset_t>(verifier, 14 /* inventory */) &&
            verifier.Verify(inventory()) &&
@@ -122,7 +164,8 @@ struct Monster : private flatbuffers::Table {
            VerifyField<flatbuffers::uoffset_t>(verifier, 30 /* testnestedflatbuffer */) &&
            verifier.Verify(testnestedflatbuffer()) &&
            VerifyField<flatbuffers::uoffset_t>(verifier, 32 /* testempty */) &&
-           verifier.VerifyTable(testempty());
+           verifier.VerifyTable(testempty()) &&
+           verifier.EndTable();
   }
 };
 
@@ -134,18 +177,22 @@ struct MonsterBuilder {
   void add_hp(int16_t hp) { fbb_.AddElement<int16_t>(8, hp, 100); }
   void add_name(flatbuffers::Offset<flatbuffers::String> name) { fbb_.AddOffset(10, name); }
   void add_inventory(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory) { fbb_.AddOffset(14, inventory); }
-  void add_color(int8_t color) { fbb_.AddElement<int8_t>(16, color, 8); }
-  void add_test_type(uint8_t test_type) { fbb_.AddElement<uint8_t>(18, test_type, 0); }
+  void add_color(Color color) { fbb_.AddElement<int8_t>(16, static_cast<int8_t>(color), 8); }
+  void add_test_type(Any test_type) { fbb_.AddElement<uint8_t>(18, static_cast<uint8_t>(test_type), 0); }
   void add_test(flatbuffers::Offset<void> test) { fbb_.AddOffset(20, test); }
   void add_test4(flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4) { fbb_.AddOffset(22, test4); }
   void add_testarrayofstring(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring) { fbb_.AddOffset(24, testarrayofstring); }
   void add_testarrayoftables(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables) { fbb_.AddOffset(26, testarrayoftables); }
   void add_enemy(flatbuffers::Offset<Monster> enemy) { fbb_.AddOffset(28, enemy); }
   void add_testnestedflatbuffer(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer) { fbb_.AddOffset(30, testnestedflatbuffer); }
-  void add_testempty(flatbuffers::Offset<Monster> testempty) { fbb_.AddOffset(32, testempty); }
+  void add_testempty(flatbuffers::Offset<Stat> testempty) { fbb_.AddOffset(32, testempty); }
   MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); }
   MonsterBuilder &operator=(const MonsterBuilder &);
-  flatbuffers::Offset<Monster> Finish() { return flatbuffers::Offset<Monster>(fbb_.EndTable(start_, 15)); }
+  flatbuffers::Offset<Monster> Finish() {
+    auto o = flatbuffers::Offset<Monster>(fbb_.EndTable(start_, 15));
+    fbb_.Required(o, 10);  // name
+    return o;
+  }
 };
 
 inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb,
@@ -154,15 +201,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
    int16_t hp = 100,
    flatbuffers::Offset<flatbuffers::String> name = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> inventory = 0,
-   int8_t color = 8,
-   uint8_t test_type = 0,
+   Color color = Color_Blue,
+   Any test_type = Any_NONE,
    flatbuffers::Offset<void> test = 0,
    flatbuffers::Offset<flatbuffers::Vector<const Test *>> test4 = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> testarrayofstring = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Monster>>> testarrayoftables = 0,
    flatbuffers::Offset<Monster> enemy = 0,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> testnestedflatbuffer = 0,
-   flatbuffers::Offset<Monster> testempty = 0) {
+   flatbuffers::Offset<Stat> testempty = 0) {
   MonsterBuilder builder_(_fbb);
   builder_.add_testempty(testempty);
   builder_.add_testnestedflatbuffer(testnestedflatbuffer);
@@ -181,7 +228,7 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
   return builder_.Finish();
 }
 
-bool VerifyAny(const flatbuffers::Verifier &verifier, const void *union_obj, uint8_t type) {
+inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *union_obj, Any type) {
   switch (type) {
     case Any_NONE: return true;
     case Any_Monster: return verifier.VerifyTable(reinterpret_cast<const Monster *>(union_obj));
@@ -191,7 +238,7 @@ bool VerifyAny(const flatbuffers::Verifier &verifier, const void *union_obj, uin
 
 inline const Monster *GetMonster(const void *buf) { return flatbuffers::GetRoot<Monster>(buf); }
 
-inline bool VerifyMonsterBuffer(const flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer<Monster>(); }
+inline bool VerifyMonsterBuffer(flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer<Monster>(); }
 
 inline void FinishMonsterBuffer(flatbuffers::FlatBufferBuilder &fbb, flatbuffers::Offset<Monster> root) { fbb.Finish(root, "MONS"); }
 
@@ -200,4 +247,4 @@ inline bool MonsterBufferHasIdentifier(const void *buf) { return flatbuffers::Bu
 }  // namespace Example
 }  // namespace MyGame
 
-#endif  // FLATBUFFERS_GENERATED_MONSTER_TEST_MYGAME_EXAMPLE_H_
+#endif  // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_

tests/monsterdata_test.golden

@@ -4,7 +4,7 @@
     y: 2,
     z: 3,
     test1: 3,
-    test2: 4,
+    test2: Green,
     test3: {
       a: 5,
       b: 6
@@ -21,7 +21,7 @@
   ],
   test_type: Monster,
   test: {
-    hp: 20
+    name: "Fred"
   },
   test4: [
     {
@@ -36,7 +36,5 @@
   testarrayofstring: [
     "test1",
     "test2"
-  ],
-  testempty: {
-  }
+  ]
 }

tests/monsterdata_test.json

@@ -4,7 +4,7 @@
     y: 2,
     z: 3,
     test1: 3,
-    test2: 4,
+    test2: Green,
     test3: {
       a: 5,
       b: 6
@@ -21,7 +21,7 @@
   ],
   test_type: Monster,
   test: {
-    hp: 20
+    name: "Fred"
   },
   test4: [
     {
@@ -32,5 +32,9 @@
       a: 30,
       b: 40
     }
+  ],
+  testarrayofstring: [
+    "test1",
+    "test2"
   ]
 }

tests/prototest/test.golden

@@ -0,0 +1,32 @@
+// Generated from test.proto
+
+namespace proto.test;
+
+enum ProtoEnum : short {
+  FOO = 1,
+  BAR = 5,
+}
+
+table OtherMessage {
+  a:double;
+  b:float = 3.14149;
+}
+
+table ProtoMessage {
+  c:int = 16;
+  d:long;
+  p:uint;
+  e:ulong;
+  f:int = -1;
+  g:long;
+  h:uint;
+  q:ulong;
+  i:int;
+  j:long;
+  k:bool;
+  l:string (required);
+  m:string;
+  n:OtherMessage;
+  o:[string];
+}
+

tests/prototest/test.proto

@@ -0,0 +1,34 @@
+// Sample .proto file that we can translate to the corresponding .fbs.
+
+package proto.test;
+
+option some_option = is_ignored;
+import "some_other_schema.proto";
+
+enum ProtoEnum {
+  FOO = 1;
+  BAR = 5;
+}
+
+message OtherMessage {
+  optional double a = 26;
+  optional float b = 32 [default = 3.14149];
+}
+
+message ProtoMessage {
+  optional int32 c = 12 [default = 16];
+  optional int64 d = 1 [default = 0];
+  optional uint32 p = 1;
+  optional uint64 e = 2;
+  optional sint32 f = 3 [default = -1];
+  optional sint64 g = 4;
+  optional fixed32 h = 5;
+  optional fixed64 q = 6;
+  optional sfixed32 i = 7;
+  optional sfixed64 j = 8;
+  optional bool k = 9;
+  required string l = 10;
+  optional bytes m = 11;
+  optional OtherMessage n = 12;
+  repeated string o = 14;
+}

tests/test.cpp

@@ -63,7 +63,7 @@ void lcg_reset() { lcg_seed = 48271; }
 std::string CreateFlatBufferTest() {
   flatbuffers::FlatBufferBuilder builder;
 
-  auto vec = Vec3(1, 2, 3, 0, 0, Test(10, 20));
+  auto vec = Vec3(1, 2, 3, 0, Color_Red, Test(10, 20));
 
   auto name = builder.CreateString("MyMonster");
 
@@ -75,8 +75,9 @@ std::string CreateFlatBufferTest() {
 
   // create monster with very few fields set:
   // (same functionality as CreateMonster below, but sets fields manually)
+  auto fred = builder.CreateString("Fred");
   MonsterBuilder mb(builder);
-  mb.add_hp(20);
+  mb.add_name(fred);
   auto mloc2 = mb.Finish();
 
   // Create an array of strings:
@@ -144,7 +145,7 @@ void AccessFlatBufferTest(const std::string &flatbuf) {
   TEST_EQ(monster->test_type(), Any_Monster);  // First make sure which it is.
   auto monster2 = reinterpret_cast<const Monster *>(monster->test());
   TEST_NOTNULL(monster2);
-  TEST_EQ(monster2->hp(), 20);
+  TEST_EQ(strcmp(monster2->name()->c_str(), "Fred"), 0);
 
   // Example of accessing a vector of strings:
   auto vecofstrings = monster->testarrayofstring();
@@ -156,7 +157,7 @@ void AccessFlatBufferTest(const std::string &flatbuf) {
   auto vecoftables = monster->testarrayoftables();
   TEST_EQ(vecoftables->Length(), 1U);
   for (auto it = vecoftables->begin(); it != vecoftables->end(); ++it)
-    TEST_EQ(it->hp(), 20);
+    TEST_EQ(strcmp(it->name()->c_str(), "Fred"), 0);
 
   // Since Flatbuffers uses explicit mechanisms to override the default
   // compiler alignment, double check that the compiler indeed obeys them:
@@ -181,7 +182,6 @@ void AccessFlatBufferTest(const std::string &flatbuf) {
 // example of parsing text straight into a buffer, and generating
 // text back from it:
 void ParseAndGenerateTextTest() {
-
   // load FlatBuffer schema (.fbs) and JSON from disk
   std::string schemafile;
   std::string jsonfile;
@@ -192,8 +192,9 @@ void ParseAndGenerateTextTest() {
 
   // parse schema first, so we can use it to parse the data after
   flatbuffers::Parser parser;
-  TEST_EQ(parser.Parse(schemafile.c_str()), true);
-  TEST_EQ(parser.Parse(jsonfile.c_str()), true);
+  const char *include_directories[] = { "tests", nullptr };
+  TEST_EQ(parser.Parse(schemafile.c_str(), include_directories), true);
+  TEST_EQ(parser.Parse(jsonfile.c_str(), include_directories), true);
 
   // here, parser.builder_ contains a binary buffer that is the parsed data.
 
@@ -214,6 +215,34 @@ void ParseAndGenerateTextTest() {
   }
 }
 
+// Parse a .proto schema, output as .fbs
+void ParseProtoTest() {
+  // load the .proto and the golden file from disk
+  std::string protofile;
+  std::string goldenfile;
+  TEST_EQ(flatbuffers::LoadFile(
+    "tests/prototest/test.proto", false, &protofile), true);
+  TEST_EQ(flatbuffers::LoadFile(
+    "tests/prototest/test.golden", false, &goldenfile), true);
+
+  // Parse proto.
+  flatbuffers::Parser parser(true);
+  TEST_EQ(parser.Parse(protofile.c_str(), nullptr), true);
+
+  // Generate fbs.
+  flatbuffers::GeneratorOptions opts;
+  auto fbs = flatbuffers::GenerateFBS(parser, "test", opts);
+
+  // Ensure generated file is parsable.
+  flatbuffers::Parser parser2;
+  TEST_EQ(parser2.Parse(fbs.c_str(), nullptr), true);
+
+  if (fbs != goldenfile) {
+    printf("%s----------------\n%s", fbs.c_str(), goldenfile.c_str());
+    TEST_NOTNULL(NULL);
+  }
+}
+
 template<typename T> void CompareTableFieldValue(flatbuffers::Table *table,
                                                  flatbuffers::voffset_t voffset,
                                                  T val) {
@@ -488,6 +517,9 @@ void ErrorTest() {
   TestError("struct X { Y:int; } root_type X;", "a table");
   TestError("union X { Y }", "referenced");
   TestError("union Z { X } struct X { Y:int; }", "only tables");
+  TestError("table X { Y:[int]; YLength:int; }", "clash");
+  TestError("table X { Y:string = 1; }", "scalar");
+  TestError("table X { Y:byte; } root_type X; { Y:1, Y:2 }", "more than once");
 }
 
 // Additional parser testing not covered elsewhere.
@@ -502,7 +534,8 @@ void ScientificTest() {
   auto root = flatbuffers::GetRoot<float>(parser.builder_.GetBufferPointer());
   // root will point to the table, which is a 32bit vtable offset followed
   // by a float:
-  TEST_EQ(fabs(root[1] - 3.14159) < 0.001, true);
+  TEST_EQ(sizeof(flatbuffers::soffset_t) == 4 &&  // Test assumes 32bit offsets
+          fabs(root[1] - 3.14159) < 0.001, true);
 }
 
 void EnumStringsTest() {
@@ -516,7 +549,19 @@ void EnumStringsTest() {
                         "{ F:[ \"E.C\", \"E.A E.B E.C\" ] }"), true);
 }
 
-
+void UnicodeTest() {
+  flatbuffers::Parser parser;
+  TEST_EQ(parser.Parse("table T { F:string; }"
+                       "root_type T;"
+                       "{ F:\"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC"
+                       "\\u5225\\u30B5\\u30A4\\u30C8\\x01\\x80\" }"), true);
+  std::string jsongen;
+  flatbuffers::GeneratorOptions opts;
+  opts.indent_step = -1;
+  GenerateText(parser, parser.builder_.GetBufferPointer(), opts, &jsongen);
+  TEST_EQ(jsongen == "{F: \"\\u20AC\\u00A2\\u30E6\\u30FC\\u30B6\\u30FC"
+                     "\\u5225\\u30B5\\u30A4\\u30C8\\x01\\x80\"}", true);
+}
 
 int main(int /*argc*/, const char * /*argv*/[]) {
   // Run our various test suites:
@@ -526,6 +571,7 @@ int main(int /*argc*/, const char * /*argv*/[]) {
 
   #ifndef __ANDROID__  // requires file access
   ParseAndGenerateTextTest();
+  ParseProtoTest();
   #endif
 
   FuzzTest1();
@@ -534,6 +580,7 @@ int main(int /*argc*/, const char * /*argv*/[]) {
   ErrorTest();
   ScientificTest();
   EnumStringsTest();
+  UnicodeTest();
 
   if (!testing_fails) {
     TEST_OUTPUT_LINE("ALL TESTS PASSED");