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

Change-Id: I504915c6b5367e8c05dc056463158b8420ad8c5e
Tested: on Linux.

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