Modify code blocks

doc/compile/README.md

@@ -23,11 +23,9 @@ Inside of the root directory of the mruby source exist a file
 called *build_config.rb*. This file contains the build configuration
 of mruby and looks like this for example:
 
-```
-MRuby::Build.new do |conf|
+	MRuby::Build.new do |conf|
 	  toolchain :gcc
-end
-```
+	end
 
 All tools necessary to compile mruby can be set or modified here. In case
 you want to maintain an additional *build_config.rb* you can define a
@@ -51,26 +49,20 @@ configurates the build environment for specific compiler infrastructures.
 
 Toolchain configuration for the GNU C Compiler.
 
-```
-toolchain :gcc
-```
+	toolchain :gcc
 
 #### clang
 
 Toolchain configuration for the LLVM C Compiler clang. Mainly equal to the
 GCC toolchain.
 
-```
-toolchain :clang
-```
+	toolchain :clang
 
 #### Visual Studio 2012
 
 Toolchain configuration for Visual Studio 2012 on Windows.
 
-```
-toolchain :vs2012
-```
+	toolchain :vs2012
 
 ### Binaries
 
@@ -81,25 +73,21 @@ process. The following tools can be selected:
 * mirb (mruby interactive shell
 
 To select all define an array in ```conf.bins```:
-```
-conf.bins = %(mrbc mruby mirb)
-```
+
+	conf.bins = %(mrbc mruby mirb)
 
 ### File Separator
 
 Some environments require a different file separator character. It is possible to
 set the character via ```conf.file_separator```.
 
-```
-conf.file_separator = '/'
-```
+	conf.file_separator = '/'
 
 ### C Compiler
 
 Configuration of the C compiler binary, flags and include paths.
 
-```
-conf.cc do |cc|
+	conf.cc do |cc|
 	  cc.command = ...
 	  cc.flags = ...
 	  cc.include_paths = ...
@@ -107,15 +95,13 @@ conf.cc do |cc|
 	  cc.option_include_path = ...
 	  cc.option_define = ...
 	  cc.compile_options = ...
-end
-```
+	end
 
 ### Linker
 
 Configuration of the Linker binary, flags and library paths.
 
-```
-conf.linker do |linker|
+	conf.linker do |linker|
 	  linker.command = ...
 	  linker.flags = ...
 	  linker.flags_before_libraries = ...
@@ -125,64 +111,54 @@ conf.linker do |linker|
 	  linker.option_library = ...
 	  linker.option_library_path = ...
 	  linker.link_options = ...
-end
-```
+	end
 
 ### Archiver
 
 Configuration of the Archiver binary and flags.
 
-```
-conf.archiver do |archiver|
+	conf.archiver do |archiver|
 	  archiver.command = ...
 	  archiver.archive_options = ...
-end
-```
+	end
 
 ### Parser Generator
 
 Configuration of the Parser Generator binary and flags.
 
-```
-conf.yacc do |yacc|
+	conf.yacc do |yacc|
 	  yacc.command = ...
 	  yacc.compile_options = ...
-end
-```
+	end
 
 ### GPerf
 
 Configuration of the GPerf binary and flags.
-```
-conf.gperf do |gperf|
+
+	conf.gperf do |gperf|
 	  gperf.command = ...
 	  gperf.compile_options = ...
-end
-```
+	end
 
 ### File Extensions
 
-```
-conf.exts do |exts
+	conf.exts do |exts
 	  exts.object = ...
 	  exts.executable = ...
 	  exts.library = ...
-end
-```
+	end
 
 ### Mrbgems
 
 Integrate GEMs in the build process.
 
-```
-# Integrate GEM with additional configuration
-conf.gem 'path/to/gem' do |g|
+	# Integrate GEM with additional configuration
+	conf.gem 'path/to/gem' do |g|
 	  g.cc.flags << ...
-end
+	end
 
-# Integrate GEM without additional configuration
-conf.gem 'path/to/another/gem'
-```
+	# Integrate GEM without additional configuration
+	conf.gem 'path/to/another/gem'
 
 ## Cross-Compilation
 
@@ -192,14 +168,12 @@ achive this the *build_config.rb* needs to contain an instance of
 tools and flags for the target platform. An example could look
 like this:
 
-```
-MRuby::CrossBuild.new('32bit') do |conf|
+	MRuby::CrossBuild.new('32bit') do |conf|
 	  toolchain :gcc
 
 	  conf.cc.flags << "-m32"
 	  conf.linker.flags << "-m32
-end
-```
+	end
 
 All configuration options of ```MRuby::Build``` can also be used
 in ```MRuby::CrossBuild```.
@@ -209,8 +183,7 @@ in ```MRuby::CrossBuild```.
 During the build process the directory *build* will be created in the
 root directory. The structure of this directory will look like this:
 
-```
-+- build
+	+- build
 	   |
 	   +-  host
 	       |
@@ -231,7 +204,6 @@ root directory. The structure of this directory will look like this:
 	          +- mrbc
 	          | 
 	          +- mruby
-```
 
 The compilation workflow will look like this:
 * compile all files under *src* (object files will be stored 
@@ -251,20 +223,17 @@ link with *build/host/lib/libmruby.a*
 * create ```build/host/bin/mirb``` by compile *tools/mirb/mirb.c* and
 link with *build/host/lib/libmruby.a*
 
-```
 	 _____    _____    ______    ____    ____    _____    _____    ____
-| CC  |->|GEN  |->|AR    |->|CC  |->|CC  |->|AR   |->|CC   |->|CC  |
-| *.c |  |y.tab|  |core.a|  |mrbc|  |*.rb|  |lib.a|  |mruby|  |mirb|
+	| CC  |->|GEN  |->|AR    |->|CC  |->|CC  |->|AR   |->|CC   |->|CC  |
+	| *.c |  |y.tab|  |core.a|  |mrbc|  |*.rb|  |lib.a|  |mruby|  |mirb|
 	 -----    -----    ------    ----    ----    -----    -----    ----
-```
 
 ### Cross-Compilation
 
 In case of a cross-compilation to *i386* the *build* directory structure looks
 like this:
 
-```
-+- build
+	+- build
 	   |
 	   +-  host
 	   |   |
@@ -304,7 +273,6 @@ like this:
 	         +- mrbc
 	         | 
 	         +- mruby
-```
 
 An extra directory is created for the target platform. In case you
 compile for *i386* a directory called *i386* is created under the
@@ -330,25 +298,23 @@ link with *build/i386/lib/libmruby.a*
 * create ```build/i386/bin/mrbc``` by cross-compile *tools/mrbc/mrbc.c* and
 link with *build/i386/lib/libmruby_core.a* 
 
-```
 	 _____________________________________________________________
-|              Native Compilation for Host System             |
-| _____      ______      _____      ____      ____      _____ |
-|| CC  | -> |AR    | -> |GEN  | -> |CC  | -> |CC  | -> |AR   ||
-|| *.c |    |core.a|    |y.tab|    |mrbc|    |*.rb|    |lib.a||
-| -----      ------      -----      ----      ----      ----- |
+	|              Native Compilation for Host System             |
+	| _____      ______      _____      ____      ____      _____ |
+	|| CC  | -> |AR    | -> |GEN  | -> |CC  | -> |CC  | -> |AR   ||
+	|| *.c |    |core.a|    |y.tab|    |mrbc|    |*.rb|    |lib.a||
+	| -----      ------      -----      ----      ----      ----- |
 	 -------------------------------------------------------------
 	                                ||
 	                               \||/
 	                                \/
 	 ______________________________________________________________
-|             Cross Compilation for Target System              |
-| _____      _____      _____      ____      ______      _____ |
-|| CC  | -> |AR   | -> |CC   | -> |CC  | -> |AR    | -> |CC   ||
-|| *.c |    |lib.a|    |mruby|    |mirb|    |core.a|    |mrbc ||
-| -----      -----      -----      ----      ------      ----- |
+	|             Cross Compilation for Target System              |
+	| _____      _____      _____      ____      ______      _____ |
+	|| CC  | -> |AR   | -> |CC   | -> |CC  | -> |AR    | -> |CC   ||
+	|| *.c |    |lib.a|    |mruby|    |mirb|    |core.a|    |mrbc ||
+	| -----      -----      -----      ----      ------      ----- |
 	 --------------------------------------------------------------
-```
 
 ## Test Environment
 

doc/mrbgems/README.md

@@ -99,13 +99,10 @@ mrbgems expects that you have implemented a C method called
 by the name of your GEM. If you call your GEM *c_extension_example*, your
 finalizer method could look like this:
 
-```
-void
-mrb_c_extension_example_gem_final(mrb_state* mrb) {
+	void
+	mrb_c_extension_example_gem_final(mrb_state* mrb) {
 	  free(someone);
-}
-```
-
+	}
 
 ### Example