Added fenced code blocks to the C++/Java/Go docs for syntax highlighting.

Change-Id: I504915c6b5367e8c05dc056463158b8420ad8c5e
Tested: on Linux.

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.
 
@@ -237,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

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/JavaUsage.md

@@ -7,13 +7,17 @@ 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
@@ -39,8 +43,10 @@ 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
@@ -49,7 +55,9 @@ 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
@@ -57,14 +65,19 @@ buffer is of the desired type before accessing it using:
 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);
@@ -74,6 +87,7 @@ Create a table with a struct contained therein:
     Monster.addTest(fbb, mon2);
     Monster.addTest4(fbb, test4s);
     int mon = Monster.endMonster(fbb);
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 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
@@ -94,15 +108,19 @@ case must thus be taken that you set the right offset on the right field.
 
 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
@@ -116,7 +134,9 @@ 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