roebe 0.5.123

data/lib/roebe/documentation/ruby_c.rb

@@ -0,0 +1,1989 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# And stored all variables as globals to keep the garbage collector from
+# eating them, things progressed quickly.
+# =========================================================================== #
+module Roebe::Documentation
+
+  # ========================================================================= #
+  # === Roebe::Documentation.header
+  # ========================================================================= #
+  def self.header(i = '')
+    h2(i)
+  end
+
+  # ========================================================================= #
+  # === Roebe::Documentation.ruby_c
+  # ========================================================================= #
+  def self.ruby_c
+    _ = ''.dup
+    here = '/home/x/DATA/PROGRAMMING_LANGUAGES/RUBY/src/C/'
+    if File.directory? here
+      entries = Dir[here+'**/**'].flatten.select {|entry|
+        File.file? entry
+      }
+      entries.each { |file|
+        description = sg(:pfeil3,'marr8px')+file
+        _ << a('src/C/'+file, content: description, css_class: 'marl3m')+
+        br
+      }
+    end
+    div(css_class: 'outer_div') {
+    div(css_class: 'default', id: __method__.to_s) {
+      h2(__method__)+
+      br+
+      e('Dies ist mein Tutorial, wie man Ruby <b>embedded</b>, also mit
+      C Programmen verknüpft.')+
+      br+
+      e('Ein Vorteil des "Embedding" ist der immense 
+      <b class="darkblue FI">Geschwindigkeitsgewinn</b>.')+
+      br+
+      e('Meine Beispiele hierzu findet man unter:')+
+      br+
+      cmd('  cd $RSRC/C')+
+      br+
+      p('ind0px smaller'){ # Display the files under $RSRC/C.
+        _
+      }+
+      frage('Wie überprüfe ich, in Ruby-MRB, ob ein String Objekt
+      frozen ist?')+
+      cmd('  !MRB_FROZEN_P(mrb->exc)) {')+
+      br+
+      e('Man kann auch recht einfach bestehende .rb Dateien 
+      in Ruby-C (um)schreiben.')+
+      br+
+      e('Dir Initialisierung (also der Beginn) geht via:')+
+      br+
+      l3em('  ruby_init()','BO')+
+      br+
+      e('Dabei wird der <b>Ruby Interpreter</b> initialisiert.')+
+      br+
+      cmd('  ruby_init_loadpath()')+
+      br+
+      e('ist sehr wichtig wenn man Module laden will, denn sie
+      initialisiert')+
+      br+
+      e('die <b class="BO">$LOAD_PATH Variable</b>.')+
+      br+
+      e('Sie enthält auch den Ort von <b>site_ruby</b>.')+
+      br+
+      e('<b>ruby_script(name</b> ist einfach, denn diese Funktion
+      weist den Namen des Ruby Scripts an die $0 variable.')+
+      br+
+      e('Abfragen gehen zum Beispiel so:')+
+      br+
+      cmd('  if $0 != "embed"')+
+      br+
+      e('Fehlt dies, so <b></b>wird $0 der false Wert zugewiesen</b>.')+
+      br+
+      e('Klingt ein wenig chaotisch?')+
+      br+
+      e('Nun gut - bringen wir ein wenig Ordnung in dieses Chaos.')+
+      br+
+      # ===================================================================== #
+      # === Ruby QTrue tag (true tag) 
+      # ===================================================================== #
+      h4('Ruby True',HEADER_CSS,'true',HEADER_BORDER)+
+      cmd('VALUE some_function(VALUE mod)')+
+      cmd('{')+
+      cmd2('  return Qtrue;')+
+      cmd('}')+
+      br+
+      # ===================================================================== #
+      # === Define alias in Ruby C. alias tag.
+      # ===================================================================== #
+      h4('Ruby Aliases in C',HEADER_CSS, HEADER_BORDER,
+      'rb_define_alias')+
+      e('Dies geht via <b>rb_define_alias</b>, wobei der 
+      erste Name der AliasName ist:')+
+      br+
+      cmd('  rb_define_alias(klass, name1, name2);')+
+      cmd('  rb_define_alias(cJukebox, "a", "add");')+
+      cmd('  rb_define_alias(cJukebox, "d", "delete");')+
+      br+
+      e('(Das gehört zum Beispiel innerhalb der <b>Init_*</b> Funktion rein.)')+
+      br+
+      # ===================================================================== #
+      # === Ruby Funcall
+      # ===================================================================== #
+      h4('Ruby Funcall',HEADER_CSS,'ruby_funcall',HEADER_BORDER)+
+      e('rb_funcall - Calls a method.')+
+      br+
+      e('First arg is the invocant','marl1em')+
+      br+
+      e('  Second is the method','marl2em')+
+      br+
+      e('    Third is the number of arguments','marl3em')+
+      br+
+      e('Der Rest sind die restlichen Argumente.')+
+      br+
+      cmd('  rb_funcall(file, method, 1, self);')+
+      cmd('  VALUE name = rb_funcall(current, rb_intern("to_s"), 0);')+
+      br+
+      anm('<b>rb_funcall</b> raises a NameError if you try to call
+      a method that does not exist.')+
+      br+
+      # ==================================================================== #
+      # === rb iv get tag
+      #
+      # Getter Methode.
+      #
+      #   rf ruby_embedded rb_iv_get
+      #
+      # ===================================================================== #
+      h4('rb_iv_get',HEADER_CSS,'rb_iv_get',HEADER_BORDER)+
+      e('Getter Methode auf Ruby-C Ebene.')+
+      br+
+      cmd('  array_sum = rb_iv_get(self, "@array_sum");')+
+      br+
+      cmd('  rb_iv_get(self, "@file");')+
+      cmd('  rb_iv_get(self, "@line");')+
+      br+
+      # ===================================================================== #
+      # === Ruby Cache
+      # ===================================================================== #
+      h4('Ruby Cache',HEADER_CSS,'ruby_cache',HEADER_BORDER)+
+      cmd('  rb_clear_cache_by_id(id);')+
+      br+
+      # ===================================================================== #
+      # === RESPOND TO
+      # ===================================================================== #
+      h4('Ruby and .respond_to?',HEADER_CSS,'ruby_respond_to',HEADER_BORDER)+
+      cmd('rb_respond_to(current, rb_intern("to_s")));')+
+      br+
+      # ===================================================================== #
+      # === protect method calls in ruby-C
+      # ===================================================================== #
+      h4('Ruby and protected methods?',HEADER_CSS,'rb_protet',HEADER_BORDER)+
+      e('Method calls can be protected by surrounding them via:')+
+      br+
+      cmd('rb_protect();')+
+      br+
+      # ===================================================================== #
+      # === Ruby Thread Schedule
+      # ===================================================================== #
+      h4('Ruby Thread Schedule',HEADER_CSS,'ruby_thread_schedule',HEADER_BORDER)+
+      e('Mache einen Scheduler:')+
+      br+
+      cmd('  rb_thread_schedule();')+
+      br+
+      e('Once you are finished with your Ruby thread and assuming no 
+      other threads are scheduled to run, control will return back to the 
+      point in C extension where you called rb_thread_schedule().')+
+      br+
+      e('Das ganze ist letzten Endes <b>Thread.pass</b> in Ruby direkt
+      äquivalent.')+
+      br+
+      # ===================================================================== #
+      # Modul Funktionen definieren
+      # ===================================================================== #
+      h4('Modul Funktionen definieren',HEADER_CSS, 'ruby_module_functions',HEADER_BORDER)+
+      cmd('  mModul = rb_define_module("CModul");')+
+      cmd('  rb_define_module_function(mModul, "sendeGrussAnC", sendeGrussAnC, 1);')+
+      cmd('  rb_define_module_function(mDB2CLI, 
+      "SQLColAttribute",  db2_SQLColAttribute,  4);')+
+      br+
+      e('Das erste Argument in rb_define_module_function ist das Module, das
+      die Funktion erhalten soll.')+
+      br+
+      # ===================================================================== #
+      # === Ruby Info. Ruby Version.
+      # ===================================================================== #
+      h4('Ruby Info',HEADER_CSS,'ruby_info',HEADER_BORDER)+
+      e('Zeige information über Ruby an:')+
+      br+
+      cmd('  ruby_show_version(); // shows ruby info like so: 
+      ruby 1.8.6 (2007-03-13 patchlevel 0) [i686-linux]')+
+      br+
+      # ===================================================================== #
+      # === Data get Tag. get tag. struct tag.
+      # ===================================================================== #
+      div(id: 'Data_Get_Struct'){
+        e("Data_Get_Struct wird recht häufig eingesetzt")+
+        br+
+        e('Zuerst die allgemeine Syntax hierzu:')+
+        br+
+        cmd('  void Data_Get_Struct(VALUE obj, type, type *ptr')+
+        cmd('  Data_Get_Struct(self, qp_movie_context, movie_ctx);')+
+        br+
+        e('Die C Extension sieht dann etwa so aus:')+
+        br+
+        cmd('  VALUE CompondShape_arelink VALUE self) {')+
+        cmd('  CompoundShape *ptr;')+
+        cmd('  Data_Get_Struct(selof, CompoundShape, ptr);')
+      }+
+      # ===================================================================== #
+      # === Ruby Return Values.
+      #
+      # qtrue tag siehe eins darunter.
+      #
+      # return tag. qnil tag. qfalse tag.
+      # ===================================================================== #
+      h4('Ruby Return Values',HEADER_CSS,'return_values',HEADER_BORDER)+
+      e('Ein VALUE (wie die folgenden) auf der C Seite ist das Äquivalent
+      zu einem Object auf Ruby Seite.')+
+      br+
+      e('Hat man eine Funktion vom void type, gibt man <b>return Qnil</b>
+      zurück.')+
+      br+
+	    cmd('  return Qtrue;')+
+	    cmd('  return Qfalse;')+
+	    cmd('  return Qnil;')+
+	    cmd('  return Qundef;')+
+	    br+
+	    # ===================================================================== # 
+      # === RUBY METHODEN DEFINIEREN in C via rb_define_method tag
+      #
+      # method tag 
+      # METHODEN tag. rf embedded ruby_methods
+      # ===================================================================== #
+      h4('Methoden - Ruby Methoden definieren in RUBY C, (es wird eine Klasse
+      gebraucht)', HEADER_CSS, 'ruby_methods', HEADER_BORDER)+
+      e('In Ruby erklärt man eine Methode mittels 
+      <b class="darkblue">def</b>.')+
+      br+
+      e('Auf C Seite geschieht das mittels <b>rb_define_method</b>.')+
+      br+
+      e('Jede Methode in Ruby-C, die etwas bestimmtes mit Ruby Pointern 
+      macht, muss als erstes Argument <b>VALUE self</b> erhalten.')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd('  static VALUE t_add(VALUE self, VALUE anObject);')+
+      br+
+      e('Instanz Methoden in Ruby-C setzt man mittels
+      <b>rb_define_method</b>:')+
+      br+
+      cmd('  static VALUE der_klassen_pointer;')+
+      cmd('  rb_define_method(dieRubyKlasse, const char * methodName, VALUE(*) cFunc, int numArgs);')+
+      cmd('  rb_define_method(der_klassen_pointer, "add", t_add, 1);')+
+      cmd('  rb_define_method(cTest, "initialize", t_init, 0);')+
+      cmd('  rb_define_method(cSimpleClass, "add_to_array", t_add, 1 // akzeptiert 1 Argument);')+
+      cmd('  rb_define_method(cSimpleClass, "show_var", t_show_var, 0);')+
+      cmd('  rb_define_method(cCircle, "area", Circle_area, 3 // akzeptiert 3 Argumente);')+
+      cmd('  rb_define_method(rb_mKernel, "nil?", rb_false, 0);')+
+      cmd('  rb_define_method(rb_cMeine_klasse, "methoden_name_in_ruby", 
+      name_der_c_funktion, anzahl_der_argumente_als_int);')+
+      br+
+      e('Das erste Argument ist also immer die Klasse, an der die Methode anhaftet - 
+      das letzte Argument sagt einem, wie viele Argumente die Methode erhalten
+      soll.')+
+      br+
+      e('Nun ein kurzer Ausflug nach array.c, um anzusehen, 
+      wie es implementiert ist auf C Ebene:')+
+      br+
+      cmd('rb_define_method(rb_cArray,"to_s", rb_ary_to_s, 0);')+
+      br+
+      e('Um die <b>method_id</b> zu bekommen verwendet man rb_intern:')+
+      br+
+      cmd('  rb_intern("method_name");')+
+      br+
+      e('Noch ein kompletteres Beispiel, wie so eine Methode dann
+      aussieht:')+
+      br+
+      cmd('  VALUE your_method(VALUE self) {')+
+	    cmd2('    int x = 10;')+
+	    cmd2('    return INT2NUM(x')+
+	    cmd('  }')+
+	    br+
+	    # ===================================================================== #
+      # === CONSTANTS AND RUBY const tag constants tag
+      #   rf rubyembedded ruby_constants
+      # ===================================================================== #
+      h4('Constants und Ruby',HEADER_CSS,'ruby_constants',HEADER_BORDER)+
+      e('Eine globale Konstante kann man in Ruby so definieren:')+
+      br+
+      cmd('  rb_define_global_const("RELEASE_DATE", d);')+
+      br+
+      e('wobei d in etwa so definiert wäre:')+
+      br+
+      cmd('  VALUE d = rb_obj_freeze(rb_str_new2(ruby_release_date);')+
+      cmd('  const char ruby_release_date[] = RUBY_RELEASE_DATE;')+
+      br+
+      e('Eine <b>normale Konstante</b> in Ruby folgt diesen Regeln:')+
+      br+
+      cmd('  rb_define_const(klass, name_of_our_constant, value);')+
+      cmd('  rb_define_const(module_or_class, "NAME", value);'  )+
+      br+
+      e('name_of_our_constant ist der Name unserer Konstanten.')+
+      br+
+      e('Weitere, konkrete Beispiele für Konstanten:')+
+      br+
+      cmd('  rb_define_const("RELEASE_DATE", d);')+
+      cmd('  rb_define_const(module, "Value", rb_str_new2("Hello World"));')+  
+      cmd('  rb_define_const(rb_mProcess, "PRIO_PROCESS", INT2FIX(PRIO_PROCESS);')+
+      cmd('  rb_define_const(rb_mProcess, "PRIO_PGRP", INT2FIX(PRIO_PGRP);')+
+      cmd('  rb_define_const(rb_mProcess, "PRIO_USER", INT2FIX(PRIO_USER);')+
+      cmd('  rb_define_const(mRubygame,"INIT_TIMER",INT2NUM(SDL_INIT_TIMER);')+
+      cmd('  rb_define_const(cCD,"STOPPED",INT2NUM(CD_STOPPED);')+
+      cmd('  rb_define_const(cCD,"PLAYING",INT2NUM(CD_PLAYING);')+
+      cmd('  rb_define_const(cCD,"PAUSED",INT2NUM(CD_PAUSED);')+
+      cmd('  rb_define_const(cCD,"ERROR",INT2NUM(CD_ERROR);')+
+      cmd('  rb_define_const(mVte, "BUILD_VERSION);",
+      rb_ary_new3(3, INT2FIX(VTE_MAJOR_VERSION), 
+      INT2FIX(VTE_MINOR_VERSION), INT2FIX(VTE_MICRO_VERSION)));')+
+      br+
+      e('Innerhalb einer ifdef Schleife geht dies so:')+
+      br+
+      cmd('  ifdef RLIMIT_CORE')+
+      cmd2('    rb_define_const(rb_mProcess, "RLIMIT_CORE", INT2FIX(RLIMIT_CORE)')+
+      cmd('  #endif')+
+      br+
+      # ===================================================================== #
+      # === Ruby False tag
+      # ===================================================================== #
+      h4('Ruby False',HEADER_CSS,'false',HEADER_BORDER)+
+      e('In ruby können wir <b>false</b> wie folgt verwenden:')+
+      br+
+      cmd('VALUE some_function(VALUE mod)')+
+      cmd('{')+
+      cmd2('  return Qfalse;')+
+      cmd('}')+
+      br+
+      # ===================================================================== #
+      # === RUBY OBJEKTE IN C
+      #
+      # Ruby_objekte. # rf embedded Ruby_objekte
+      # ===================================================================== #
+      h4('Ruby Objekte in C',HEADER_CSS,'Ruby_objekte',HEADER_BORDER)+
+      e('In Ruby wird jeder Inhalt eines Objektes mittels  
+      einer <b>C Structure</b> beschrieben.')+
+      br+
+      e('Dies wird mittels <b>pointer</b> realisiert.')+
+      br+
+      e('Jede Klasse hat eine andere <b>struct</b>, der Pointer Type ist
+      aber immer <b>VALUE</b>. Mit anderen Worten, ein VALUE auf C
+      Ebene ist ein Objekt auf Ruby Ebene.')+
+      br+
+      img('PC/RUBY/ch_object_value.png','bblack1 mars1em')+
+      br+
+      e('<b>VALUE</b> wiederum findet man in <b>ruby.h</b>')+
+      br+
+      e('vim $PROGRAMS/Ruby/Current/lib/ruby/1.8/i686-linux/ruby.h','BO s3em')+
+      br+
+      e('Dort gibt es viele besondere Structs, wie zum Beispiel:')+
+      br+
+      cmd2('  struct RData')+
+      cmd2('  struct RBasic')+
+      cmd2('  struct RObject')+
+      cmd2('  struct RClass ')+
+      cmd2('  struct RHash')+
+      cmd2('  struct RFile')+
+      cmd2('  struct RFloat')+
+      cmd2('  struct RString # siehe Anhang für ein beispiel')+
+      cmd2('  struct RArray ')+
+      cmd2('  struct RRegexp')+
+      br+
+      e('Und <b>VALUE</b> hat diese Struktur:')+
+      br+
+      cmd('typedef unsigned long VALUE;')+
+      br+
+      e('Folgendes Beispiel zeigt eine <b>Initialierung eines Ruby
+      Array</b> (entspräche dem Ruby Code <b>def initialize</b>):')+
+      br+
+      cmd('static VALUE t_init(VALUE self) //# def initialize')+
+      cmd('{')+
+      cmd2('  VALUE array;')+
+      cmd2('  array = rb_ary_new();')+
+      cmd2('  rb_iv_set(self, "@array", array);')+
+      cmd2('  return self;')+
+      cmd('}')+
+      br+
+      e('Genauer betrachtet ist .new in Ruby-C etwas komplizierter,
+      wie folgendes Beispiel illustriert:')+
+      br+
+      cmd('  info = Data_Make_Struct(cTest, MP3Info, 0, free, one);')+
+      br+
+      cmd('  rb_obj_call_init(info, argc, argv);')+
+      br+
+      e('Klassen sind in Ruby ein <b>zentrales Element</b>, 
+      die zuerst deklariert werden müssen, bevor man sie 
+      verwenden kann.','padl1em')+
+      br+
+      e('Folgendes Beispiel illustriert dies anhand der 
+      cTest Klasse:')+
+      br+
+      cmd('VALUE cTest;')+
+      br+
+      cmd('void Init_my_test() {')+
+      cmd2('cTest = rb_define_class("MyTest", rb_cObject')+
+      br+
+      e('Jede C-Extension definiert eine globale C Funktion
+      namens <b>Init_</b>, der Name der Extension wird
+      angehängt.')+
+      br+
+      e('Mit anderen Worten, die allgemein Syntax ist:')+
+      br+
+      cmd('Init_moduleName')+
+      br+
+      e('Lädt man zb eine Datei namens <b>hello_world.so</b>,
+      so ist die dazugehörige Init funktion diese:')+
+      br+
+      cmd('  Init_hello_world')+
+      br+
+      e('Diese <b>muss</b> soweit mir bekannt immer vom <b>void</b>
+      Typ sein, nicht static oder irgendwas sonst. Beispiel:')+
+      br+
+      cmd('  void Init_global_variables();')+
+      cmd('  void Init_hello_world();')+
+      cmd('  void Init_genx4r();')+
+      br+
+      e('Diese Funktion wird aufgerufen wenn der Interpreter 
+      die <b>Extension ladet</b>.')+
+      br+
+      e('Ausserdem kann man das ganze in eine schöne Methode
+      verpacken, in Verbindung mit Data_Make_Struct. Siehe
+      dazu folgendes Beispiel:')+
+      br+
+      cmd('  VALUE mp3_info_new() {')+
+      cmd2('  VALUE info;')+
+      cmd2('  MP3Info *one;')+
+      cmd2('  info = Data_Make_Struct(cTest, MP3Info, 0, free, one')+
+      cmd2('    rb_obj_call_init(info, 0, 0')+
+      cmd2('    return info;')+
+      cmd('  }')+
+      br+
+      # ===================================================================== #
+      # === rb_class2name
+      # ===================================================================== #
+      h4('Ruby Class2Name Konversion',HEADER_CSS,'rb_class2name',HEADER_BORDER)+
+      e('Die reverse function von rb_class2Name() ist so:')+
+      br+
+      cmd('  rb_path2class(path);')+
+      br+
+      # ===================================================================== #
+      # === Define ruby attr Ruby C
+      # ===================================================================== #
+      h4('Ruby Attr in C',HEADER_CSS,'rb_define_attr',HEADER_BORDER)+
+      e('Attr Methoden gehen einfach, wobei ein Wert von 1 ein <b>ja</b>
+      bedeutet.')+
+      br+
+      e('Zuerst kommt read, dann write.')+
+      br+
+      cmd('  rb_define_attr( die_klass_für_das_attr, ihr_attr_name, read, write)')+
+      cmd('  rb_define_attr( cLoader, "families", 1, 1 );')+
+      cmd('  rb_define_attr( cprivateType, "value", 1, 1 );')+
+      cmd('  rb_define_attr( cJukebox, "value", 1, 1 );')+
+      cmd('  rb_define_attr( cparser, "options", 1, 1 );')+
+      cmd('  rb_define_attr( cTest, "test_var", 1, 0 );')+
+      br+
+      # ===================================================================== #
+      # === rb_scan_args tag. rf embedded rb_scan_args
+      # ===================================================================== #
+      h4('Ruby und rb_scan_args',HEADER_CSS,'rb_scan_args',HEADER_BORDER)+
+      e('rb_scan_args ist zu verwenden um Arguments zu counten.')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd('  static VALUE my_function(int argc, VALUE* argv, VALUE self)')+
+      cmd('  {')+
+      cmd2('    VALUE v_name, v_age; // die argumente')+
+      br+
+      cmd2('rb_scan_args(argc, argv, "11", &v_name, &v_age')+
+      br+
+      e('Zudem kann man rb_scan_args verwenden um default values zu
+      setzen:')+
+      in_ruby+
+      e('def foobar(arg=1)')+
+      e('end')+
+      br+
+      in_ruby_c+
+      cmd('  rb_define_method(myclass, "method_name", meth_fnc, -1);')+
+      cmd('  rb_define_method_function(module, "name", c_function, argc);')+
+      br+  
+      e('In your method use rb_scan_args to scan the argument list.')+
+      br+
+      e('If you dont get enough arguments, use the default values instead.')+
+      br+
+      div {
+        h2('Random Tidbits')+
+        e('Ruby stores ivars for immutable object types (e.g. Fixnum/Symbol) 
+        in external hashes (see generic_ivar_* in variable.c for 
+        ruby/trunk).')
+      }+
+      div {
+        frage('Was ist rb_funcall2?')
+      }+
+      div {
+        frage('Wie erhalte ich den Namen einer Klasse in Ruby-C?')+
+        cmd('   class Bar; end; Object.const_get("bar".capitalize).new')+
+        cmd('  VALUE time_klass = rb_const_get( rb_cObject, rb_intern("Time") );')
+      }+
+      div {
+        e('Hier eine Liste mit C code und Ruby code:')+
+        br+
+        table2('s1em','','',
+          'rb_current_realfilepath', '== __FILE__'
+        )
+      }+
+      e('From 1.8 to 1.9...')+
+      e('bitsweat> change RSTRING(...)->ptr to RSTRING_PTR(...)')+
+      e('bitsweat> and same for ->len to _LEN')+
+      br+
+      e('Damit die .c Beispiele funktionieren, müssen sie allesamt
+      eine <b class="FI darkblue">Init Funktion</b> deklarieren,
+      wie zum Beispiel so:')+
+      br+
+      cmd('  void Init_genx4r();')+
+      cmd('  void Init_ruby_fstab();')+
+      cmd('  void Init_hello();')+
+      br+
+      e('Die Init Funktionen geben <b>nichts zurück</b> via return.')+
+      br+
+      anm('Der Name der Init Funktionen ist immer <b>der Name der 
+      Extension</b>, also zum Beispiel:','FW4')+
+      br+
+      cmd('  void Init_extname();')+
+      br+
+      e('// void Init_jukebox()  // wie man hier sieht, muss 
+      der Name nach Init_ <b>klein</b> geschrieben werden.')+
+      br+
+      # ===================================================================== #
+      # === Data Wrap Tag. Wrap tag. struct tag.
+      # ===================================================================== #
+      div {
+        h4('Ruby Data_Wrap_Struct',HEADER_CSS,'rb_data_wrap_struct',HEADER_BORDER)+
+        e('Ruby-C stellt eine besonderen Data Type bereit, mit dem man Pointers
+        zu C und C++ Speicher nutzen kann. Der Ruby Interpreter glaubt, das es
+        sich um echte Ruby Klassen handelt.')+
+        br+
+        e('API des Makro ist:')+
+        br+
+        cmd('  VALUE Data_Wrap_Struct(VALUE class, void (*mark_func) (void *),
+        void (*free_func) (void *), void *ptr')+
+        br+
+        e('Der ptr nimmt einen Pointer zu einer Speicherort auf.')+
+        br+
+        e('Typischerweise sieht der Code dann in etwa so aus:')+
+        br+
+        lem('  CompoundShape *ptr;')+
+        lem('  VALUE obj;')+
+        br+
+        lem('  ptr = CreateCompoundShape(')+
+        lem('  obj = Data_Wrap_Struct(cCompoundShape, CompoundShape_mark, 
+        CompoundShape_free, ptr')+
+        br+
+        e('Es gibt eine ähnliche Form dieses Funktion, und zwar wird hierbei 
+        eine neue Instanz des C struczt erstellt, und erst danach wird die
+        <b>Data_Wrap_Struct()</b> Aktion durchgeführt:')+
+        br+
+        lem('  VALUE Data_Make_Struct(VALUE class, type, void
+        (*mark_func)(void *), void (*free_func)(void *), void
+        *ptr')+
+        br+
+        e('Nutzt man diesen Code, dann wird der Speicher mittels Rubys
+        ALLOC macro alloziiert. Dieser Makro ruft wiederum malloc() auf,
+        und wenn Speicher limitiert ist, ruft er Rubys Garbage Collector
+        auf bevor er malloc() aufruft.')+
+        br+
+        e('Anmerkung: dieser Speicher sollte mit free() befreit werden.')+
+        br+
+        e('Zudem muss man jedes Mal wenn man Data_Make_Struct() oder
+        <b>Data_Wrap_Struct()</b> verwendet, pointers zur C Funktion
+        schicken, die die mark und free Phasen sehen.')
+      }+
+      # ===================================================================== #
+      # === ruby_singleton_methods
+      # ===================================================================== #
+      h4('Definieren von Singleton Methods:',HEADER_CSS,
+      'ruby_singleton_methods',HEADER_BORDER)+
+      cmd('rb_define_singleton_method')+
+      br+
+      # ===================================================================== #
+      # === OBJECT ID tag
+      #
+      #   von http://www.oreillynet.com/ruby/blog/2006/02/ruby_values_and_object_ids.html
+      # ===================================================================== #
+      h4('Object ID von Ruby Objekten',HEADER_CSS,'ruby_object_id',HEADER_BORDER)+
+      e('Ruby kalkuliert Objekt IDs (object_id) wie folgt:')+ # drbrain: see rb_obj_id for how the object_id is computed
+      br+
+      cmd('  VALUE rb_obj_id(VALUE obj)')+
+      cmd('  {')+
+      cmd2('    if (SPECIAL_CONST_pobj)) {')+
+      cmd3('      return LONG2NUM((long)obj')+
+      cmd2('  }')+
+      cmd2('  return (VALUE)((long)obj|FIXNUM_FLAG')+
+      cmd('}')+
+      br+
+      e('nil.object_id zb gibt immer <b>4</b> zurück.')+
+      br+
+      # ===================================================================== #
+      # === Check_Type
+      # ===================================================================== #
+      h4('Herausfinden was was ist mit Check_Type',
+        HEADER_CSS,'ruby_check_type',HEADER_BORDER
+      )+
+      e('Finde heraus, was was ist mittels Check_Type(VALUE val, int type)')+
+      br+
+      cmd('  Check_Type(val, T_STRING); // Ist es ein String?')+
+      cmd('  Check_Type(val, T_OBJECT); // Ist es ein Object?')+
+      br+
+      # ===================================================================== #
+      # === STRUCTS TAG
+      # ===================================================================== #
+      h4('Hier ein Beispiel von Struct Usage',HEADER_CSS,'ruby_struct',HEADER_BORDER)+
+      cmd('struct time_object {')+
+      br+
+      cmd2('  struct timeval tv;')+
+      cmd2('  struct tm tm;')+
+      cmd2('  int gmt;')+
+      cmd2('  int tm_got;')+
+      br+
+      cmd('};')+
+      br+
+      cmd('  struct time_object *tobj;')+
+      cmd('  obj = Data_Make_Struct(klass, struct time_object, 0, time_free, tobj')+
+      cmd('  tobj->tm_got = 0;')+
+      cmd('  tobj->tv.tv_sec = 0;')+
+      cmd('tobj->tv.tv_usec = 0;')+
+      br+
+      # ===================================================================== #
+      # === COMPILEN VON RUBY C CODE STRUKTUREN. compile tag
+      #
+      # Makefile tag.
+      #   rf embedded compiling
+      # ===================================================================== #
+      h4('Compilen von Ruby C Code Strukturen mittels mkmf / Makefile:',
+      HEADER_CSS,'compiling',HEADER_BORDER)+
+      e('Zum Compilen muss man zb dies hier machen:')+
+      br+
+      cmd('-lruby')+
+      br+
+      e('Hier ein Beispiel dazu:')+
+      br+
+      cmd('gcc test.c -lruby -o embedded','extconf')+
+      br+
+      cmd("gcc -o embeddedRuby embeddedRuby.o -O2 -fpic \\")+
+      cmd("-I/usr/lib/ruby/1.6/i386-linux -rdynamic 
+      -L/usr/lib/ruby/1.6/i386-linux \\")+
+      cmd('-lruby -lm -ldl')+
+      br+
+      anm('Der einfachste Weg zum Kompilieren ist es aber  
+      <b>extconf.rb</b> zu nutzen.')+
+      br+
+      e('Typische Struktur bzw Commands dazu folgt wobei wir mit
+      extconf.rb anfangen:')+
+      br+
+      cmd('  vim $RSRC/C/extconf.rb')+
+      cmd('  bl $RSRC/C/extconf.rb')+
+      br+
+      e('<b>extconf.rb</b> erlaubt einige Besonderheiten,
+      wie zum Beispiel <b>dir_config("some_dir")</b>.')+
+      br+
+      e('Soweit ich weiss, nutzt dies alle vorhandenen .c Dateien in
+      einem Verzeichnis, wird also besonders gerne angewandt bei
+      Verzeichnissen in <b>non-standard directories</b>.')+
+      br+
+      e('Folgend sehen wir ein kompletteres Beispiel für
+      <b>extconf.rb</b>:')+
+      br+
+      cmd2("  require('mkmf')")+
+      br+
+      cmd2('  dir_config("genx4r")')+
+      br+
+      cmd2('  abort "need stdio.h" unless have_header("stdio.h") # aborten geht auch')+
+      cmd2("  have_library('libraryName', 'libraryFunction')")+
+      br+
+      e('dir_config hat übrigens 2 weitere Argumente - Nr 2 gibt 
+      include Paths an, Nr 3 gibt Library Paths an.')+
+      br+
+      ee('Eine weitere Methode ist <b>create_makefile</b>, Docu hierzu 
+      sieht man ')+
+      a('http://www.ruby-doc.org/core/files/lib/mkmf_rb.src/M000067.html',
+        content: 'hier', css_class: 'BO marl2em')+
+      br+
+      br+
+      cmd2('  create_makefile("my_test") # my_test is the name of
+      your c. file')+
+      br+
+      e('Es gehen auch mehrere Argumente, wobei ich aber noch nicht 
+      weiss, was die weiteren Argumente bewirken.')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd("  create_makefile('inotify', 'ext')")+
+      br+
+      cmd2('// or this create_makefile("genx4r")')+
+      br+
+      e('<b>dir_config</b> sagt Ruby, das man alle .c Dateien im aktuellen 
+      Verzeichnis nutzen soll, um eine Extension namens genx4r zu
+      erstellen.')+
+      br+
+      anm('Danach kann man ruby extconf.rb anwenden; dies erstellt
+      dann eine Makefile Datei.')+
+      br+
+      e('Ob ein Computer System bestimmte <b>Headers</b> hat, kann
+      man so abfragen:')+
+      br+
+      cmd("  have_header('linux/inotify.h')")+
+      br+
+      e('Dies würde zb so eine Zeile ausgeben:')+
+      br+
+      cmd('  checking for linux/inotify.h... no')+
+      br+
+      e('Hier ein "chained" Beispiel dazu:')+
+      br+
+      cmd('  if have_header("readline/readline.h") and 
+      have_header("readline/history.h") and have_library("readline", "readline")'
+      )+
+      e('Das ganze alleine bricht aber nicht ab, wenn man einen Abbruch
+      möchte, dann muss man ein <b>if</b> davor schalten.')+
+      br+
+      e('Mehrere headers überprüfen kann man zb so:')+
+      br+
+      cmd("  if have_header('X11/Xlib.h') and find_library('X11', 'XOpenDisplay', 
+      '/usr/X11R6/lib') and find_library('Xpm', 'XpmCreatePixmapFromData', 
+      '/usr/X11R6/lib') and find_library('Xext', 'XShapeCombineMask', 
+      '/usr/X11R6/lib')")+
+  	  cmd2("  create_makefile('dockapp')")+
+  	  cmd('  end')+
+  	  br+
+      e('Das Übergeben einer bestimmten Bibliothek geht so:')+
+      br+
+      cmd("  have_library('foo') # -lfoo")+
+      cmd("  have_library('m') # -lm")+
+      br+
+      e('Will man hier gleich mehrer Libaries zugleich abfragen, geht
+      dies zum Beispiel so:')+
+      br+
+      cmd('if have_library("ole32") and  have_library("oleaut32")')+
+      br+
+      e('Einen <b class="darkblue">speziellen Namen </b> kann man 
+      seiner Extension auch geben (sehr zu empfehlen):')+
+      br+
+      cmd("  extension_name = 'mytest'")+
+      br+
+      e('Ein Win-Makefile kann man so erstellen:')+
+      br+
+      cmd('  create_win32ole_makefile')+
+      cmd2('  # To create it, run: ')+
+      cmd2('  ruby extconf.rb;make(')+
+      br+
+      e('Nun kommt eine Meldung "<b>creating Makefile</b>", die sehr
+      schnell beendet sein sollte - ansonsten handelt es sich wohl
+      um einen Syntax Fehler.')+
+      br+
+      e('Danach <b>make</b> aufrufen')+
+      br+
+      e('Übrigens, nicht auf <b>Init_</b> vergessen!')+
+      br+
+      e('Dies erstellt zb foobar.so (shared library), und kann dann so 
+      genutzt werden (die <b>.so Extension</b> muss nicht angegeben
+      werden):')+
+      cmd("  require('foobar'")+
+      cmd("  require('global_variables'")+
+      br+
+      e('Man kann übrigens nur require verwenden, load 
+      funktioniert nur mit .rb Dateien.')+
+      br+
+      e('Ok, folgend nun ein paar Code Beispiele für C:')+
+      br+
+      cmd('  VALUE callback(void) ')+
+      cmd('  {')+
+      cmd2('    printf("C callback\n"')+
+      cmd2('    return T_TRUE;')+
+      cmd('  }')+
+      br+
+      # ===================================================================== #
+      # === FIXNUMS UND RUBY (Fixnum tag, Fixnums tag.
+      # ===================================================================== #
+      h4('Fixnums und Ruby',HEADER_CSS,'ruby_fixnums',HEADER_BORDER)+
+      e('Fixnum, Symbol, true, false, und nil werden direkt in VALUE
+      gespeichert, und sind keine Pointers. Man nennt sie auch
+      <b>immediate values</b>.')+
+      br+
+      e('Um zu überprüfen, ob es sich bei einem Wert um einen 
+      <b>Fixnum</b> handelt, kann man zb dies hier tun:')+
+      br+
+      cmd('FIXNUM_pvalue)')+
+      br+
+      e('Dies gibt einen Wert von <b>nicht 0</b> zurück wenn es 
+      sich um einen Fixnum Wert handelt. Ähnliches geht auch mit 
+      SYMBOL_P für symbols, NIL_P für nil Werte, und RTEST für Werte 
+      die weder nil noch false sind.')+
+      br+
+      e('Im Anhang A gibts ein Listing, ansonsten folgen hier
+      noch einige Beispiele:')+
+      br+
+      e('/* structure for ordinary objects */')+
+      br+
+      cmd('struct RObject {')+
+      br+
+      cmd2('  struct RBasic basic;')+
+      cmd2('  struct st_table *iv_tbl;')+
+      br+
+      cmd('};')+
+      br+
+      e('/* structure for strings (instance of String) */')+
+      br+
+      cmd('struct RString {')+
+      cmd('  struct RBasic basic;')+
+      cmd('    long len;')+
+      cmd('    char *ptr;')+
+      cmd('    union {')+
+      cmd2('      long capa;')+
+      cmd2('      VALUE shared;')+
+      cmd('    } aux;')+
+      e('  }')+
+      br+
+      cmd('/* structure for arrays (instance of Array) */')+
+      br+
+      cmd('  struct RArray {')+
+      cmd2('    struct RBasic basic;')+
+      cmd2('    long len;')+
+      cmd('    union {')+
+      cmd2('      long capa;')+
+      cmd2('      VALUE shared;')+
+      cmd2('    } aux;')+
+      cmd('    VALUE *ptr;')+
+      cmd('  };')+
+      br+
+      e('Jede Extension in Ruby definiert eine globale C Funktion, die
+      so aussieht:')+
+      br+
+      cmd('Init_<i>name</i>')+
+      br+
+      e('Wie oben beschrieben definiert man den Namen einer Klasse in
+      C-Ruby so:')+
+      br+
+      cmd('VALUE der_klassen_pointer;')+
+      cmd('der_klassen_pointer = <b>rb_define_class</b>("MeineKlasse",
+      rb_cObject);')+
+      br+
+      # ===================================================================== #
+      # === Class Method. define a c method or class method.
+      # ===================================================================== #
+      h4('Class Methods',HEADER_CSS,'ruby_class_methods',HEADER_BORDER)+
+      cmd('define_c_method')+
+      br+
+      # ===================================================================== #
+      # === ruby modules tag mod tag module tag.
+      # ===================================================================== #
+      h4('Definieren von Ruby Modules', HEADER_CSS,'ruby_modules',HEADER_BORDER)+
+      br+
+      e('Es ist anzuraten, ein kleines <b>m</b> voranzustellen, um
+      darauf hinzuweisen, das es sich um ein Modul handelt.')+
+      br+
+      e('Dies ist eine gute Konvention in Ruby.')+
+      br +
+      cmd('  VALUE mNcurses;')+
+      br+
+      cmd('  static VALUE mWtmp;')+
+      cmd('  mWtmp = rb_define_module("Wtmp"); // the argument is the module name')+
+      cmd('  VALUE module = rb_define_module("name");'  )+
+      cmd('  rb_mGenX = rb_define_module ("GenX");')+
+      br+
+      anm('Anmerkung: Ein module in Ruby-C gibt <b>immer</b> ein VALUE
+      zurück.')+
+      br+
+      cmd('  rb_define_method_function(module, "name", c_function, argc);')+ 
+      cmd('  rb_define_method_function')+
+      br+
+      e('Noch ein Beispiel:')+
+      br+
+      cmd('  static VALUE rb_mHello, mShapes;')+
+      cmd('  rb_mHello = rb_define_module("Hello");')+
+      cmd('  mShapes = rb_define_module("Shape");')+
+      br+
+      e('Module innerhalb anderer Module zu definieren geht so:')+
+      br+
+      cmd('  VALUE mRubygame;')+
+      br+
+      cmd('  mRubygame = rb_define_module("Rubygame");')+
+      br+
+      e('Hier noch wie das Modul Enumerable definiert wurde:')+
+      br+
+      cmd('  VALUE rb_mEnumerable;')+
+      br+
+      cmd('  rb_mEnumerable = rb_define_module("Enumerable");')+
+      br+
+      e('Um Module Functions zu definieren siehe')+
+      br+
+      a('#ruby_module_functions', content: 'hier')+
+      br+
+      # ===================================================================== #
+      # === rb_require tag
+      # ===================================================================== #
+      h4('Ruby Require',HEADER_CSS,'rb_require',HEADER_BORDER)+
+      cmd('  rb_require("./embedding.rb"); // Ruby-Modul laden')+
+      br+
+      # ===================================================================== #
+      # === rb_class_new_instance tag
+      # ===================================================================== #
+      h4('Ruby und rb_class_new_instance',HEADER_CSS, 'rb_class_new_instance',HEADER_BORDER)+
+      e('Beispiel:')+
+      br+
+      cmd('  VALUE entry = rb_class_new_instance (0, 0, cEntry);')+
+      br+
+      e('Was macht rb_class_new_instance?')+
+      br+
+      cmd('  obj = rb_obj_alloc(klass);')+
+      cmd('  rb_obj_call_init(obj, argc, argv);')+
+      br+
+      e('Man findet es in object.c')+
+      br+
+      # ===================================================================== #
+      # === Dynamic Libraries.
+      # ===================================================================== #
+      div('FS1em','dynamic_libraries'){
+        br+
+        e('C libraries can usually be accessed via <b>dynamic linker</b>.
+        Die Ruby dl-Bibliothek vereinfacht dies ungemein:')+
+        br+
+        cmd("  require('dl'")+
+        cmd("  require('dl/import'")+
+        br+
+        cmd("  module Libc")+
+        cmd("  extend DL::Importable")+
+        cmd("  dlload '/lib/libc.so.6'")+
+        cmd("  extern 'char* ttyname(int)'")+
+        cmd('  end')+
+        br+
+        cmd("  puts Libc.ttyname(0)")
+      }+
+      # ===================================================================== #
+      # === Ruby Array Entry tag.
+      # ===================================================================== #
+      h4('Ruby Array Entry',HEADER_CSS,'rb_ary_entry',HEADER_BORDER)+
+      cmd('  VALUE rb_ary_entry(VALUE ary, long offset)')+
+      cmd('  [1,2,3][2]')+
+      cmd('  [1,2,3].at(2)')+
+      br+
+      e('Der C Code sieht so aus:')+
+      br+
+      cmd('  VALUE num;')+
+      cmd('  num = rb_ary_entry(ary, offset);')+
+      cmd('  printf("%d\n", FIX2INT(num));')+
+      cmd('  VALUE num = RARRAY(ary)->ptr[offset]);')+
+      br+
+      div {
+        cmd('static VALUE sendeGrussAnC(VALUE self, VALUE str)')+
+        cmd(' {')+
+        cmd2('   printf("Ruby hat uns den Gruss gesendet: %s\n",')+
+        cmd2('           StringValuePtr(str)')+
+        cmd('}')+
+        br+
+        cmd('int main (int argv[], int argc)')+
+        cmd('{')+
+        cmd2('  VALUE cModul;')+
+        cmd2('  VALUE gruss;')
+      }+
+      br+
+      cmd('  printf("Ein Hallo von C\n");')+
+      cmd('  ruby_init; // Dieser Aufruf ist zwingend')+
+      cmd('  cModul = rb_define_module("CModul");')+
+      cmd('  rb_define_module_function(cModul,')+
+      cmd(' "sendeGrussAnC", sendeGrussAnC, 1);')+
+      br+
+      # ===================================================================== #
+      # === C HASH DEFINIEREN in C. (hash tag, hashes tag). #Hashes
+      # ===================================================================== #
+      h4('Ruby Hash definieren in RUBY C',HEADER_CSS,'Hashes',HEADER_BORDER)+
+      cmd('  cEntry = rb_define_class_under (mWtmp, "Entry", rb_cHash);')+
+      br+
+      e('<b>hash = Hash.new</b> geht so:')+
+      br+
+      cmd('  VALUE hash; hash = rb_hash_new(); // Hash.new # Wir erstellen
+      einen neuen Hash')+
+      br+
+      e('<b>.select</b> in Hash:')+
+      br+
+      cmd('  rb_hash_select')+
+      br+
+      e('<b>.values_at</b> in Hash:')+
+      br+
+      cmd('  rb_hash_values_at')+
+      br+
+      e('<b>.reject!</b> in Hash:')+
+      br+
+      cmd('  rb_hash_reject_bang')+
+      br+
+      e('<b>.freeze</b> in Hash:')+
+      br+
+      cmd('  rb_hash_freeze')+
+      br+
+      e('<b>.each</b> in Hash:')+
+      br+
+      cmd('  rb_hash_foreach # iterate over a hash')+
+      cmd('  rb_define_alloc_func hash_alloc;')+
+      cmd('  "[]", rb_hash_s_create, -1')+
+      cmd('  "initialize", rb_hash_initialize, -1')+
+      cmd('  "initialize_copy", rb_hash_replace, 1')+
+      cmd('  "rehash", rb_hash_rehash, 0')+
+      cmd('  "to_hash", rb_hash_to_hash, 0')+
+      cmd('  "to_a", rb_hash_to_a, 0')+
+      cmd('  "to_s", rb_hash_to_s, 0')+
+      cmd('  "inspect", rb_hash_inspect, 0')+
+      cmd('  "==", rb_hash_equal, 1')+
+      br+
+      e('Um gespeicherte Einträge aus einem Hash zu <b>holen</b>, 
+      geht dies hier:')+
+      in_ruby+
+      cmd("  hash = { :foo => 'blah' }")+
+      br+
+      e('In Ruby-C:')+
+      br+
+      cmd('  hash = rb_hash_new();')+
+      cmd('  foo = rb_hash_aref(hash, ID2SYM(rb_intern("foo")));')+
+      br+
+      e('bzw (etwas länger)')+
+      br+
+      cmd('  int age;')+
+      cmd('  hash = rb_hash_new();')+
+      cmd('  key = rb_str_new2("Oscar");')+
+      cmd('  value = rb_hash_aref(hash, key);')+
+      cmd('  age = NUM2INT(value); // Should return 6, Siehe oben bei
+      INT2NUM')+
+      br+
+      anm('NUM2INT und INT2FIX sind Möglichkeiten wie man Nummer in
+      Ruby erstellt.')+
+      br+
+      anm('rb_hash_aref gibt Qnil wieder wenn der angegebene
+      Key nicht im Hash drinnen is. Argumente an rb_hash_aset 
+      und rb_hash_aref müssen vom type VALUE sein.')+
+      br+
+      e('Das heisst auch, das ein Hash, der strings als Keys verwenden,
+      diese zuerst in Ruby Strings konvertieren muss:')+
+      br+
+      cmd('  VALUE string_key, value;')+
+      br+ 
+      cmd('  string_key = rb_str_new2("Some key");')+ 
+      cmd('  value = rb_hash_aref(hash, string_key)')+
+      in_ruby+
+      cmd('  h = { "a" => 100, "b" => 200 }; h.fetch("a")')+
+      in_ruby_c+
+      cmd('  foo = rb_hash_fetch(hash, ID2SYM(rb_intern("foo"))')+
+      br+
+      e('Um <b>neue</b> Einträge (key, value) in einen Hash
+      reinzugeben verwendet man rb_hash_aset():')+
+      br+
+      e('Beispiel:')+
+      br+
+      in_ruby+
+      cmd(' hash << "foo"')+
+      in_ruby_c+
+      cmd('  h = { "a" => 100, "b" => 200 }; h.fetch("a")')+
+      cmd('  hash = rb_hash_new();')+
+      cmd('  key = rb_str_new2("Oscar");')+
+      cmd('  value = INT2NUM(6);')+
+      cmd('  rb_hash_aset(hash, key, value));')+
+      br+
+      e('Weiter geht es:')+
+      br+
+      cmd('  "store", rb_hash_aset, 2')+
+      cmd('  "default", rb_hash_default, -1')+
+      cmd('  "default=", rb_hash_set_default, 1')+
+      cmd('  "default_proc", rb_hash_default_proc, 0')+
+      cmd('  "index", rb_hash_index, 1')+
+      cmd('  "indexes", rb_hash_indexes, -1')+
+      cmd('  "indices", rb_hash_indexes, -1')+
+      cmd('  "size", rb_hash_size, 0')+
+      cmd('  "length", rb_hash_size, 0')+
+      cmd('  "empty?", rb_hash_empty_p, 0')+
+      cmd('  "each", rb_hash_each, 0')+
+      cmd('  "each_value", rb_hash_each_value, 0')+
+      cmd('  "each_key", rb_hash_each_key, 0')+
+      cmd('  "each_pair", rb_hash_each_pair, 0')+
+      br+
+      e('Sortieren geht in Ruby so:')+
+      in_ruby+
+      cmd('  h = { "c"=> 300, "a" => 100, "b" => 200 }; h.sort')+
+      in_ruby_c+
+      cmd('  "sort", rb_hash_sort, 0')+
+      cmd('  "keys", rb_hash_keys, 0')+
+      cmd('  "values", rb_hash_values, 0')+
+      cmd('  "values_at", rb_hash_values_at, -1')+
+      cmd('  "shift", rb_hash_shift, 0')+
+      cmd('  "delete", rb_hash_delete, 1')+
+      cmd('  "delete_if", rb_hash_delete_if, 0')+
+      cmd('  "select", rb_hash_select, -1')+
+      cmd('  "reject", rb_hash_reject, 0')+
+      cmd('  "reject!", rb_hash_reject_bang, 0')+
+      cmd('  "clear", rb_hash_clear, 0')+
+      cmd('  "invert", rb_hash_invert, 0')+
+      cmd('  "update", rb_hash_update, 1')+
+      cmd('  "replace", rb_hash_replace, 1')+
+      cmd('  "merge!", rb_hash_update, 1')+
+      cmd('  "merge", rb_hash_merge, 1')+
+      cmd('  "include?", rb_hash_has_key, 1')+
+      cmd('  "member?", rb_hash_has_key, 1')+
+      cmd('  "has_key?", rb_hash_has_key, 1')+
+      cmd('  "has_value?", rb_hash_has_value, 1')+
+      cmd('  "key?", rb_hash_has_key, 1')+
+      cmd('  "value?", rb_hash_has_value, 1')+
+      cmd('  "[]", rb_f_getenv, 1')+
+      cmd('  "fetch", env_fetch, -1')+
+      cmd('  "[]=", env_aset, 2')+
+      cmd('  "store", env_aset, 2')+
+      cmd('  "each", env_each, 0')+
+      cmd('  "each_pair", env_each_pair, 0')+
+      cmd('  "each_key", env_each_key, 0')+
+      cmd('  "each_value", env_each_value, 0')+
+      cmd('  "delete", env_delete_m, 1')+
+      cmd('  "delete_if", env_delete_if, 0')+
+      cmd('  "clear", env_clear, 0')+
+      cmd('  "reject", env_reject, 0')+
+      cmd('  "reject!", env_reject_bang, 0')+
+      cmd('  "select", env_select, -1')+
+      cmd('  "shift", env_shift, 0')+
+      cmd('  "invert", env_invert, 0')+
+      cmd('  "replace", env_replace, 1')+
+      cmd('  "update", env_update, 1')+
+      cmd('  "inspect", env_inspect, 0')+
+      cmd('  "rehash", env_none, 0')+
+      cmd('  "to_a", env_to_a, 0')+
+      cmd('  "to_s", env_to_s, 0')+
+      cmd('  "index", env_index, 1')+
+      cmd('  "indexes", env_indexes, -1')+
+      cmd('  "indices", env_indexes, -1')+
+      cmd('  "size", env_size, 0')+
+      cmd('  "length", env_size, 0')+
+      cmd('  "empty?", env_empty_p, 0')+
+      cmd('  "keys", env_keys, 0')+
+      cmd('  "values", env_values, 0')+
+      cmd('  "values_at", env_values_at, -1')+
+      cmd('  "include?", env_has_key, 1')+
+      cmd('  "member?", env_has_key, 1')+
+      cmd('  "has_key?", env_has_key, 1')+
+      cmd('  "has_value?", env_has_value, 1')+
+      cmd('  "key?", env_has_key, 1')+
+      cmd('  "value?", env_has_value, 1')+
+      cmd('  "to_hash", env_to_hash, 0')+
+      br+
+    # ======================================================================= #
+    # === Arrays in C (ruby c)
+    #
+    # C ARRAY DEFINIEREN in C. array tag.
+    #
+    #   rf embedded Array_definieren
+    # ======================================================================= #
+    h4('Ruby Array definieren in RUBY C',
+        HEADER_CSS,'Array_definieren',HEADER_BORDER)+
+    cmd('  VALUE array; array = rb_ary_new();')+
+    cmd('  VALUE hardware_list; hardware_list = rb_ary_new();')+
+    br+
+    e('Intern ruft rb_ary_new übrigens rb_ary_new2 auf
+    (ist in <i class="darkblue">
+    <a href="http://www.ruby-doc.org/doxygen/1.8.4/array_8c.html">
+    array.c </a></i> beschrieben):')+
+    br+
+    cmd('  return rb_ary_new2(ARY_DEFAULT_SIZE')+
+    br+
+    e('Wie man sieht genügt die Deklaration <b>VALUE array_name</b>')+
+    br+
+    e('Weitere Manipulationen mit Arrays gehen so:')+
+    br+
+    cmd('  rb_ary_push(VALUE ary, VALUE val); // <b>.push</b> fügt am 
+    Ende des Array ein neues Element hinzu')+
+    br+
+    e('   rb_ary_push(hardware_list, rb_str_new2("\"HDD1\"=>\"/dev/hdc1\"")',
+    'marl4em')+
+    br+
+    cmd('  rb_ary_pop(VALUE ary); // <b>.pop</b> entfernt das letzte 
+    Element eines Array und gibt ihn wieder')+
+    br+
+    cmd('  rb_ary_shift(VALUE ary) // Entfernt das erste Element
+    eines Arrays und gibt es wieder')+
+    br+
+    cmd('  rb_ary_unshift(VALUE ary, VALUE val) // das Gegenteil
+    von shift - fügt den Eintrag vorne an')+
+    br+
+    e('Hier noch die wichtigsten Funktionen als <b>Übersicht</b>:')+
+    br+
+    table3('marl1em','','',
+      'C Function','Equivalent Ruby Statement','Description',
+      
+      'VALUE rb_ary_new()','anArray = [] (or anArray = Array.new())','Returns 
+       a new empty array. Internally, it will create an array 
+       with a default capacity, which is 16 elements.',
+      'VALUE rb_ary_new2(long size)','anArray = Array.new(size)','Returns 
+       a new array with size elements; each element is initialized to 
+       Qnil, which is Rubys way of nil. The advantage is that 
+       this function is faster than rb_ary_new, however you must 
+       know how big your array will be.',
+      
+      'VALUE rb_ary_new3(long size, VALUE arg1, VALUE arg2, ...)',
+      'anArray = [arg1, arg2, ...]','Returns a new array with size
+       elements; each element is initialized with the corresponding
+       argument passed into rb_ary_new3()+',
+      
+      'VALUE rb_ary_new4(long size, VALUE *values)','anArray = ["this",
+       "that","other"]','Returns a new array with size elements; each 
+       element is initialized with the corresponding 
+       element in the values array.',
+      
+      'VALUE rb_ary_aref (int argc, 
+       VALUE *argv, VALUE array)','value = array[index]<br>
+       value = array[start, length]<br>
+       value = Array[range]','This is the implementation of the 
+       Array class [] method and accepts three different forms of 
+       inputs; here, argv is a C array of the input argument
+       values and argc is the number of arguments in that array.
+       If there is only one input argument, it is evaluated
+       as either a Fixnum index into the array or a
+       Range of indices. If there are
+       two arguments, they are evaluated
+       as Fixnums indiciating the starting index and
+       length of the subarray.',
+      
+      'void rb_ary_store(VALUE array, long index, VALUE value)',
+      'array[index] = value',
+      'Stores value in the specified array slot (where index is zero-based)',
+      
+      'VALUE rb_ary_entry(VALUE array, long index)','value = array[index]',
+      'Dies gibt das Element am spezifizierten Index wieder',
+      
+      'VALUE rb_ary_push(VALUE array, VALUE value)','array.push(value)',
+      'pushes value onto the end of array and returns a reference to it.',
+      
+      'VALUE rb_ary_popVALUE array)','value = array.pop','Pops value 
+       onto the end of array and returns a reference to it.',
+      
+      'VALUE rb_ary_shift(VALUE array)','array.shift','Removes and 
+       returns the first element from array.',
+      
+      'VALUE rb_ary_unshift(VALUE array, VALUE value)','array.unshift(value)',
+      'Pushes value onto the front of array and returns a reference to 
+       value.',
+      
+      'VALUE rb_ary_each(VALUE array)','array.each','Calls rb_yield() on each 
+       element of the array in turn and returns a reference to the array as 
+       its result',
+       
+      'VALUE rb_ary_join(VALUE array, VALUE sep)','array.join(sep)','Returns 
+       a new string whose contents are formed by joining the array elements 
+       with the specified string separator',
+       
+      'VALUE rb_ary_reverse(VALUE array)','array.reverse','Returns a 
+       reference to a new array whose elements are the same as those of 
+       array, in reverse order.',
+       
+      'VALUE rb_ary_sort(VALUE array)','array.sort','Returns a reference 
+       to a new array whose elements are the same as those 
+       of array, in sorted order.',
+       
+      'VALUE rb_ary_sort_bang(VALUE array)','array.sort!','
+       performs an in-place sort of array and returns a reference to the 
+       array. Example: <br>
+       <b>rb_funcall(ary, rb_intern("sort!"), 0</b>',
+       
+      'VALUE rb_ary_delete(VALUE array, VALUE value)',
+      'array.delete(value)','Deletes all occurrences of value 
+       from array and returns a reference to value.',
+      
+      'VALUE rb_ary_delete_at(VALUE array, long index)','array.delete_at(index)','
+       deletes the array element at the specified index.',
+      
+      'VALUE rb_ary_clear(VALUE array)','array.clear','Removes 
+       all elements from the array and returns a reference to the array',
+      
+      'VALUE rb_ary_plus(VALUE array, VALUE other)','array.concat(other)',
+      'adds the contents of other onto the end of array and returns a
+       reference to the array. Unlike rb_ary_plus(), this function
+       does modify the first array',
+      
+      'VALUE rb_ary_includes(VALUE array, VALUE value)','array.include?(value)','
+       returns Qtrue or Qfalse, depending on whether value is found in array.',
+
+      'VALUE rb_ary_length(VALUE array)','array.length','Returns the legnth of 
+       the array as a Fixnum. An alternatvie method for determinign the 
+       length of an array is to use RARRAY(array)->len',
+      
+      'VALUE rb_ary_empty_pVALUE array)','array.empty?','returns 
+       Qtrue if the array lenght is zero, Qfalse otherwise. 
+       An alternative is to check the array length directly 
+       with RARRAY(array)->len'
+      )+
+      # ===================================================================== #
+      # === ruby und .dup
+      # ===================================================================== #
+      h4('Ruby und .dup',HEADER_CSS,'ruby_dup',HEADER_BORDER)+
+      cmd('  rb_str_dupstr')+
+      br+
+      e('(Allerdings mag dies nicht mehr aktuell sein.)')+
+      br+
+      # ===================================================================== #
+      # === Globale Variables in Ruby
+      # ===================================================================== #
+      h4('Globale Variablen in Ruby',HEADER_CSS,'ruby_global_vars',HEADER_BORDER)+
+      e('Anmerkung: Man sollte seine globalen Variablen mit dem $ 
+      Prefix prependen.','s0_5em')+
+      br+
+      e('Allgemein deklarieren wir eine Variable in C-Ruby so (mit
+      Beispiel):')+
+      br+
+      cmd('  rb_define_variable();')+
+      cmd('  rb_define_variable("$gvars", &hardware_list);')+
+      cmd('  rb_define_variable("$String", &MyString);')+
+      br+
+      e('Folgender BeispielCode zeigt an, wie man globale Variablen in
+      Ruby-C definiert:')+
+      br+
+      cmd('  static VALUE hardware_list;')+
+      cmd('  static VALUE MyString;')+
+      cmd('  MyString = rb_str_new(')+
+      cmd('  static VALUE Init_SysInfo() {')+
+      cmd2('  rb_define_class(....')+
+      cmd2('  hardware_list = rb_ary_new();')+
+      cmd2('  rb_define_variable("$hardware", &hardware_list')+
+      cmd2('  rb_ary_push(hardware_list, rb_str_new2("DVD")')+
+      cmd2('  rb_ary_push(hardware_list, rb_str_new2("CDPlayer1")')+
+      cmd2('  rb_ary_push(hardware_list, rb_str_new2("CDPlayer2")')+
+      cmd('}')+
+      br+
+      # ====================================================================== #
+      # === RUBY ERRORS TAG ERROR TAG
+      #
+      # rb_raise tag.
+      #   rf embedded ruby_errors
+      # ===================================================================== #
+      h4('Ruby Errors',HEADER_CSS,'ruby_errors',HEADER_BORDER)+
+      e('Gezielte Errors erzielt man mittels <b>rb_raise</b> so:')+
+      br+
+      cmd('rb_raise(rb_eRangeError, "0x%lx is recycled object", p0')+
+      br+
+      e('Ein anderer Fehler zb so:')+
+      br+
+      cmd('  rb_raise(rb_eTypeError, "wrong argument type %s 
+      (expected %s)", etype, type->name);')+
+      br+
+      cmd('  rb_raise(rb_eTypeError, "operand is not valid type");')+
+      br+
+      cmd('  rb_raise(rb_eTypeError, "cannot convert 
+      %s into String", rb_obj_classname(arg1));')+
+      br+
+      cmd('  rb_raise(rb_eArgError, "no stream to tell");')+
+      br+
+      cmd('  rb_raise(rb_eNameError, "undefined method %s 
+      in super", rb_id2name(id));')+
+      br+
+      cmd('  rb_raise(rb_eTypeError, "type of arg must be Matrix");')+
+      br+
+      e('Wie man übrigens sieht, werden Errors mit <b>rb_e</b>
+      prepended.')+
+      br+
+      # ===================================================================== #
+      # === RUBY CLASS DEFINIEREN in C class tag
+      # ===================================================================== #
+      h4('Ruby Classes definieren in RUBY C',HEADER_CSS,'Class_definieren',HEADER_BORDER)+
+      e('Eine Klasse in ruby-C definieren geht über <b>static VALUE</b>:')+
+      br+
+      cmd('  static VALUE rb_cGenX;')+
+      cmd('  static VALUE rb_cGenXWriter;')+
+      cmd('  static VALUE rb_cFstabAppender;')+
+      cmd('  static VALUE rb_cTest;')+
+      br+
+      e('Hier nochmals letzteres Beispiel kombiniert, um zu demonstrieren
+      wie wir eine Klasse in <b>Ruby-C</b> definieren:')+
+      br+
+      cmd('  static VALUE cTest; cTest = rb_define_class("Test",
+      <b>rb_cObject</b>);  // <b class="red">class Test</b>')+
+      br+
+      cmd('  rb_cFstabAppender = rb_define_class("FstabAppender", 
+      rb_cObject);')+
+      br+
+      e('Das zweite Argument (also <b>rb_cObject</b>) zeigt an, 
+      das unsere Klasse eine <b>Subklasse von Object</b> ist. ')+
+      br+
+      e('Object wird durch rb_cObject dargestellt. Den Rest 
+      findet man in ruby.h, bzw in Anhang D.')+
+      br+
+      e('Um eine Klasse innerhalb zb eines Modules zu definieren 
+      muss man folgendes verwenden:')+
+      br+
+      cmd('  cTest = rb_define_class_under("Test", rb_cObject);')+
+      cmd('  rb_cMyFile = rb_define_class_under(rb_mHello,"MyFile", rb_cObject);')+
+      cmd('  rb_cGenXWriter = rb_define_class_under (rb_mGenX, 
+      "Writer", rb_cObject);')+
+      br+
+      e('Die Klasse kann man dann einfach benutzen nachdem man die
+      .so-SharedLib geladen hat.')+
+      br+
+      e('Verwendungs Beispiel:')+
+      br+
+      cmd('  x = Test.new')+
+      cmd('  x = Jukebox.new')+
+      cmd('  x = SimpleClass.new')+
+      br+
+      # ===================================================================== #
+      # === rb define alloc func
+      # ===================================================================== #
+      h4('Ruby Alloc',HEADER_CSS,'rb_define_alloc_func',HEADER_BORDER)+
+      e('Noch keine Info dazu erhältlich.')+
+      br+
+      cmd('  rb_define_alloc_func();')+
+      br+
+      # ===================================================================== #
+      # rb iv set tag. #rb_iv_set
+      #   rf embedded rb_iv_set
+      # ===================================================================== #
+      h4('rb_iv_set',HEADER_CSS,'rb_iv_set',HEADER_BORDER)+
+      e('Eine Instanz Variable kann man auch setzen, und zwar so:')+
+      br+
+      cmd('VALUE rb_iv_set(VALUE obj, char *name, VALUE value)')+
+      br+
+      e('Dies setzt den Wert der <b>InstanzVariablen</b> namens name, 
+      also <b>@name</b> in ruby code, im Objekt auf value, 
+      welcher auch zurückgeliefert wird.')+
+      br+
+  	  e('Konkrete Beispiele:')+
+  	  br+
+  	  cmd('  rb_iv_set(self, "@array", array);')+
+  	  cmd('  rb_iv_set(self, "@msg", rb_str_new2("Hello, World !") // String Beispiel')+
+  	  br+
+  	  # ===================================================================== #
+      # === Ruby Symbols
+      # ===================================================================== #
+      h4('Ruby Symbols in RUBY C',HEADER_CSS,'Symbols_definieren',HEADER_BORDER)+
+      e('Das Erstellen eines Symbols ist leicht:')+
+      br+
+      cmd('  ID2SYM( rb_intern("verbose") ); '+ruby('/* In Ruby :verbose */'))+
+      cmd('  ID2SYM( rb_intern("noop") ); '+ruby('/* In Ruby :noop */'))+
+      br+
+      e('rb_intern() gibt einem eine ID, die lediglich eine C Nummer ist.
+      Man muss diese Nummer in ein Ruby Symbol Objekt verändern mittels
+      des <b>ID2SYM() macro</b>.')+
+      br+
+      e('Hierzu nun ein kompletteres Beispiel:')+
+      br+
+      cmd('  ID2SYM(rb_intern("name")); ')+
+      cmd('  node_name = ID2SYM(rb_intern("ICKY"));')+
+      cmd('  ID method = rb_intern("<<");')+
+      br+
+      e('creates a symbol :name for the string name.')+
+      br+
+      e('Hat man die ID kann man <b>rb_id2name</b> verwenden um 
+      den Namen zu rekonstruieren.')+
+      br+
+      e('Diese Nummer verwandelt man in ein Ruby Symbol Object
+      indem man das ID2SYM() macro verwendet.')+
+      br+
+      e('Den ID Wert eines Strings innerhalb von C erhält man
+      allgemein so:')+
+      br+
+      cmd('  rb_intern(const char *name);')+
+      br+
+      header('class Thread')+
+      cmd('VALUE rb_thread_create(VALUE *func, void *data)')+
+      e('Dies erstellt ein neues Thread.')+
+      br+
+      # ===================================================================== #
+      # === rb_obj_is_instance_of
+      # ===================================================================== #
+      div(id: 'rb_obj_is_instance_of'){
+        h2('rb_obj_is_instance_of')+
+        cmd('rb_obj_is_instance_of')+
+        br
+      }+
+      # ===================================================================== #
+      # === Ruby Nil tag
+      # ===================================================================== #
+      h4('Ruby Nil',HEADER_CSS,'nil',HEADER_BORDER)+
+      e('Es scheint so zu sein, das man in Ruby Qnil als Ergebnis zu 
+      liefern hat, auch wenn die Methode an sich nix macht...')+
+      br+
+      cmd('  VALUE some_function(int argc, VALUE *argv, VALUE classmod)')+
+      cmd('  {')+
+      cmd2('    return Qnil;')+
+      cmd('  }')+
+      br+
+      # ===================================================================== #
+      # === ruby_inline
+      # ===================================================================== #
+      div(id: 'ruby_inline'){
+        e('Mittels ruby inline kann man C code in .rb Dateien einbetten.')+
+        br +
+        e('Dies kann oft zu schnellerem Code führen.')+
+        br+
+        cmd("  require('inline'")+
+        cmd('  class << self')+
+        cmd2('  	inline do |builder|')+
+        cmd3('  		builder.c "')+
+        cmd4('  			int dummy(int input) {')+
+        cmd5('  				int i = 1;')+
+        cmd5('  				while (input >= 1) { input--; i *= 2; }')+
+        cmd5('  				return i;')+
+        cmd4('  			}')+
+        cmd3('  		"')+
+        cmd2('    end')+
+        cmd('  end')+
+        br+
+        cmd('  puts dummy(8)')
+      }+
+      # ===================================================================== #
+      # === String tag strings tag.
+      #
+      # rb_eval_string tag. rf embedded rb_eval_string
+      #
+      # ===================================================================== #
+      div(id: 'rb_eval_string'){
+        h2("rb_eval_string und weitere String Functions",'','strings')+
+        e('Mittels rb eval kann man bequem Ruby Code testen:','','','Strings')+
+        cmd('rb_eval_string("anObject.each{|x| x.clearFlag }"')+
+        br+
+        e('Will man eine spezielle Methode aufrufen (sollte schneller gehen
+        als eval), so ist folgendes zu empfehlen:')+
+        br+
+        cmd('  rb_funcall(receiver, method_id, argc, ...)')+
+        br+
+        e('Hier noch die andere String Functions:')+
+        br+
+        h2('String functions')+
+        br+
+        e('  rb_str_new(const char *ptr, long len);')+
+        e('    --Creates a new Ruby string.')+
+        e('  rb_str_new2(const char *ptr);')+
+        e('    -- Creates a new Ruby string from a C string. 
+        This is equivalent to rb_str_new(ptr, strlen(ptr))')+
+        e('  rb_tainted_str_new(const char *ptr, long len)')+
+        e('  -- Creates a new tainted Ruby string. 
+        Strings from external data sources should be tainted.')+
+        br+
+        e('  rb_tainted_str_new2(const char *ptr);')+
+        e('  -- Creates a new tainted Ruby string from a C string.')+
+        br+
+        e('  rb_str_cat(VALUE str, const char *ptr, long len);')+
+        e('  -- Appends len bytes of data from ptr to the Ruby string.')+
+        br+
+        # =================================================================== #
+        # === rb_define_module_function
+        # =================================================================== #
+        div(id: 'rb_define_module_function'){
+          e('Dies nutzt man um module_function zu implementieren.')+
+          br+
+          cmd('rb_define_module_function')
+        }+
+        # =================================================================== #
+        # === Strings in Ruby
+        # =================================================================== #
+        h4('Ruby Strings auf C Ebene', HEADER_CSS,'ruby_str_new',HEADER_BORDER)+
+        e('Strings in Ruby werden so verwendet:')+
+        br+
+        cmd('  rb_str_new2')+
+        br+
+        e('Dies is die typische Art von Ruby, wie man Strings nutzt')+
+        br+    
+        cmd('  VALUE str = rb_str_new2(p);')+
+	      cmd('  return str;')+
+	      cmd('  result = xmlBufferCreate();')+
+        cmd('  ret = rb_str_new2(result->content);')+
+        br+
+        e('Noch ein Beispiel:')+
+        br+
+        cmd('  VALUE roebe;')+
+        cmd('  roebe = rb_str_new2("Roebe war hier");')+  
+        cmd('  printf("%s <--",roebe);')+
+        br+
+        e('Noch ein Beispiel:')+
+        br+
+        cmd('  VALUE string;')+
+        cmd('  string = rb_str_new2("Dein String");')+
+        e('Will man die Information von einem Ruby String als einen C
+        String repräsentieren, verwendet man das STR2CSTR Makro.')+
+        br+
+        cmd('  VALUE stringObj;')+
+        cmd('  char *cstr;')+
+        cmd('  cstr = STR2CSTR(stringObj);')+
+        br+
+        anm('Dieses Makro gibt einem einen Pointer zurück, der die 
+        aktuelle String Daten hat - es ist also keine Kopie, und man
+        sollte genau schauen was man damit macht.')+
+        br+
+        e('Will man die echte Länge eines Ruby String wissen, inklusive der 
+        NULL bytes und so weiter, kann man dies verwenden:')+
+        br+
+        cmd('  VALUE stringObj;')+
+        cmd('  char *cstr;')+
+        cmd('  int stringLength;')+
+        cmd('  cstr = rb_str2cstr(stringObj, &stringLength);')+
+        br+
+        e('Statt diesem Weg gibt es einen noch schnelleren Weg:')+
+        br+
+        cmd('  VALUE stringObj;')+
+        cmd('  int stringLength;')+
+        cmd('  stringLength = RSTRING(stringObj)->len;')+
+        p {
+          e('Hier noch Funktionen um einen neuen String zu 
+          erstellen (String.new):')+
+          br+
+          table2('','','',
+            'VALUE rb_str_new(const char *str, long size)','Returns a 
+             new string whose contents are copied from the first size
+             characters pointed to by str.',
+            'VALUE rb_str_ne2 (const char *cstr)','Returns a new Ruby string 
+             whose contents are copied from the NULL-terminated C string cstr.'
+          )+
+          br+
+          e('Und hier Funktionen, mit denen wir mit Strings arbeiten:')+
+          br+
+          table3('','','',
+            'C Funktion','Äquivalentes Ruby Statement','Beschreibung',
+            'VALUE rb_str_to_str(VALUE obj)','obj.to_str', 'Attempts to 
+             convert the original object to a string by calling its to_str method.',
+            'VALUE rb_str_dup VALUE str)','String.new(str)','Returns a 
+             new string that is a duplicate of the original',
+            'VALUE rb_str_plus(VALUE str1, VALUE str2)','str1+str2.to_str',
+            'returns a new string formed by concatenating the contents of str1 
+             and str2; neither of the original strings is modified. Note 
+             that if str2 is not a string but is a string-like object
+             that implements a to_str method, Ruby will first call that 
+             objects to_str method to get a string representation 
+             of str2',
+            'VALUE rb_str_times(VALUE str, VALUE count)','str * count',
+            'Returns a new string which is formed by repeating the 
+             original string count times.',
+            'VALUE rb_str_substr(VALUE str, long start, long length)',
+            'str[start, length]','Returns a new string which is the 
+             substring of str, beginning at position start and with 
+             specified length.',
+            'VALUE rb_str_cat(VALUE str, const char *str, long size)',
+            'str += "another string"','Modifies the original string
+             by adding the first size characters pointed to by str to 
+             the end of this string. Returns a reference to 
+             the modified string.',
+            'VALUE rb_str_cat2(VALUE str, const char *cstr)','','
+             same as rb_str_cat(), but assumes that cstr is a 
+             NULL-terminated C string.',
+            'VALUE rb_str_append(VALUE str1, VALUE str2)','str1 += str2.to_str',
+            'Modifies str1 by appending str2 to it. Note that if str2 is not 
+             astring but is a string-like object that 
+             implements a to_str method, Ruby will first call that objects 
+             to_str method to get a string representation of str',
+            'VALUE rb_str_concat(VALUE str1, VALUE str2)','str1 << str2',
+            'Modifies str1 by concatenating it with str2. If str2 is a Fixnum,
+             it is interpreted as an ASCII character code; otherwise, the
+             same rules used for rb_str_append() apply.',
+            'int rb_str_hash(VALUE str)','str.hash','returns the hash code for str',
+            'int rb_str_cmpVALUE str1, VALUE str2)','str1 <=> str','Compares 
+             the contents of the two strings and returns -1 if str1 is lexicographically 
+             less than str2, 1 if str1 is greater than str2, or 0 if they are equial.',
+             'VALUE rb_str_match(VALUE str, VALUE obj)','str =~ obj','Uses obj as a pattern 
+             to match against str. If obj is either a Regexp or String instance, 
+             rb_str_match() will return a Fixnum containing the match position or 
+             Qnil if no match is found. If obj is some other type that doesnt 
+             implement a =~ method, rb_str_match() will return QFalse',
+            'VALUE rb_str_split(VALUE str, const char *pattern)','str.split(pattern)',
+            'Returns a new array formed by splitting the input string at delimiters 
+             specified in the pattern string. If pattern is not a single 
+             character string (for example, a comma) it is evaluated as a 
+             regular expression.',
+            'VALUE rb_str_length(VALUE str)','str.length','Returns the length of str.',
+            'VALUE rb_str_empty(VALUE str)','str.empty?','Returns Qtrue if str 
+             is empty (its size = 0), otherwise it returns Qfalse'
+           )
+        }
+      }+
+      # ===================================================================== #
+      # === ANHANG TAG
+      #
+      # ANHANG A
+      # ===================================================================== #
+      div('mart3em s0_5em'){
+        h1('Anhang zu Embedding and Extending Ruby','','','Anhang')+
+        h2('Anhang A - bitte alfabetisch ordnen. ')+
+        h3('Structs:')+
+        br+
+        table2('s2em','','anhang_a',
+          '<b>struct RArray</b>','array',
+          '<b>struct RBignum</b>','big integers (one of the three numeric types)',
+          '<b>struct RClass</b>','class object, also has 
+           an m_tbl (a symbol table for storing methods) 
+           and a superclass (pointer to a superclass)',
+          '<b>struct RData</b>','all the classes defined at C level, 
+           except the ones mentioned above',
+          '<b>struct RFile</b>','IO, File, Socket, etc',
+          '<b>struct RFloat</b>','small numbers',
+          '<b>struct RHash</b>','hash table',
+          '<b>struct RObject</b>','all things for which none of 
+           the following applies',
+          '<b>struct RRegexp</b>','regular expression',
+          '<b>struct RString</b>','string class',
+          '<b>struct RStruct</b>',"Ruby's Struct class"
+        )
+      }+
+      # ===================================================================== #
+      # === Anhang B - Makros und Methoden zum Konvertieren
+      #
+      # MAKROS TAG
+      #   rf rembedded anhang_b
+      # ===================================================================== #
+      h3('Anhang B - Makros und Methoden zum Konvertieren')+
+      table2('s2em','','anhang_b',
+        '<b>INT2FIX(long or int)</b>','Integer nach Fixnum 
+        Konvertierung (faster) [Beispiel: v_age = INT2FIX(25]',
+        '<b>INT2NUM(int)</b>','Fixnum or Bignum',
+        '<b>INT2NUM(long or int)</b>','Fixnum or Bignum',
+        '<b>LL2NUM</b>','conversion for 64bit',
+        '<b>LONG2FIX</b>','',
+        '<b>rb_str_new2(char *)</b>','String',
+        '<b>rb_float_new(double)</b>','Float, wird zum
+         Beispiel so eingesetzt:
+           <b>return rb_float_new(qp_get_frame_rate(movie_ctx)</b>'
+      )+    
+      # ===================================================================== #
+      # === Anhang C
+      #
+      # CHECKS TAG
+      # ===================================================================== #
+      h3('Anhang C - Checks (Pointer ist zum Beispiel
+      <b>unsigned long ptr</b>, p0; p0 =
+      ptr = NUM2ULONG(objid)')+
+      table2('s2em','','anhang_c',
+        'if (ptr == Qtrue)', 'return Qtrue;',
+        'if (ptr == Qfalse)','return Qfalse;',
+        'if (ptr == Qnil)',  'return Qnil;'
+      )+
+      # ===================================================================== #
+      # === CLASS VARS TAG
+      # ===================================================================== #
+      h3('Anhang D - Vordefinierte Klassenvariablen, bitte <b>alphabetisch</b>
+      ordnen.')+
+      table2('s2em', '','anhang_d',
+        'rb_cArray;',     '',
+        'rb_cBignum;',    '',
+        'rb_cClass;',     '',
+        'rb_cDir;',       '',
+        'rb_cData;',      '',
+        'rb_cFalseClass;','',
+        'rb_cFile;',      '',
+        'rb_cFixnum;',    '',
+        'rb_cFloat;',     '',
+        'rb_cHash;',      '',
+        'rb_cInteger;',   'oder <b>rb_int_new(</b><br>
+         rb_define_const(iFP, "MAX_PATHLEN", rb_int_new(IFP_MAXPATHLEN)',
+        'rb_cIO;',        '',
+        'rb_cModule;',    '',
+        'rb_cNilClass;',  '',
+        'rb_cNumeric;',   '',
+        'rb_cObject;',    '',
+        'rb_cproc;',      '',
+        'rb_cRange;',     '',
+        'rb_cRegexp;',    '',
+        'rb_cString;',    '',
+        'rb_cStruct;',    '',
+        'rb_cSymbol;',    '',
+        'rb_cThread;',    '',
+        'rb_cTime;',      '',
+        'rb_cTrueClass;', ''
+      )+
+      # ===================================================================== #
+      # === Anhang E - Data Types für Ruby
+      # ===================================================================== #
+      h3('Anhang E - Data Types für Ruby (<b>alphabetisch</b> geordnet)')+
+      table2('BO mars4px s2em','','anhang_e',
+        'T_ARRAY',  'array',
+        'T_BIGNUM', 'multi precision integer',
+        'T_CLASS',  'class',
+        'T_DATA',   'data',
+        'T_FALSE',  'false',
+        'T_FILE',   'IO',
+        'T_FIXNUM', 'Fixnum(31bit integer)',
+        'T_FLOAT',  'floating point number',
+        'T_HASH',   'associative array',
+        'T_MODULE', 'module',
+        'T_NIL',    'nil',
+        'T_OBJECT', 'ordinary object',
+	      'T_REGEXP', 'regular expression',
+	      'T_STRING', 'string',
+	      'T_STRUCT', '(Ruby) structure',
+	      'T_SYMBOL ','symbol',
+	      'T_TRUE',   'true'      
+      )+
+      # ===================================================================== #
+      # === Anhang F
+      #
+      # Functions for Working with Objects #anhang_f
+      # ===================================================================== #
+      h3('Anhang F - Funktionen zum Arbeiten mit Objekten 
+      (<b>alphabetisch</b> ordnen)')+
+      table2('FW4 mars4px s2em','','anhang_f',
+        'void rb_obj_call_init (<b>VALUE</b> obj, int argc, VALUE *argv)',
+        'Calls the objects initialize method, passing the array
+         of arguments, argv, with lengthc argc.array',
+
+        '<b>VALUE</b> rb_obj_is_instance_of(VALUE obj, VALUE klass)','Returns
+         Qtrue (the C constant for rubys true) if obj is an instance of
+         class klass.',
+        
+        '<b>VALUE</b> rb_obj_is_kind_of (VALUE obj, VALUE klass)',
+        'Returns Qtrue if obj is an instance of class klass or one
+         of its subclasses',
+        
+        '<b>VALUE</b> rb_obj_clone (VALUE obj)','Returns the result of
+         calling the objects <b>.clone</b> method',
+        
+        '<b>VALUE</b> rb_obj_dup (VALUE obj)','Returns the result of
+         calling the objects <b>.dup</b> method.',
+        
+        '<b>VALUE</b> rb_any_to_s (VALUE obj)','Returns a string containing
+         information about the object, the default <b>.to_s</b> method
+         from Rubys Kernel module',
+
+        '<b>VALUE</b> rb_obj_as_string (VALUE obj)','returns a string 
+         representation of obj by first calling the objects <b>.to_s</b> 
+         method or, if that fails, by calling rb_any_to_s() on obj',
+
+        '<b>VALUE</b> rb_inspect (VALUE obj)','returns the result of
+         calling the objects <b>.inspect</b> method'
+      )+
+      # ===================================================================== #
+      # === Anhang G
+      #
+      # Functions for Conversion from Ruby Numeric Types into C
+      #
+      # Numeric Types.
+      # ===================================================================== #
+      h3('Anhang G - Funktionen zum Konvertieren von Ruby Numeric Types in
+      C Numeric Types (<b>alphabetisch</b> ordnen)')+
+      table2('FW4 mars4px s2em','','anhang_g',
+        'C Function/Macro','Beschreibung',
+        'int NUM2INT (VALUE aNumeric)','Converts the input Numeric 
+         value to a C int. If you know that the input value is a
+         Fixnum, use the faster FIX2INT macro.',
+        
+        'int FIX2INT(VALUE aFixnum)','Converts the input 
+         Fixnum value to a C int.',
+
+        'unsigned int NUM2UINT(VALUE aNumeric)','Converts the 
+         input Numeric value to a C unsigned int. If you know that 
+         the input value is a Fixnum, use the faster FIX2UINT macro.',
+
+        'unsigned int FIX2UINT(VALUE aFixnum)','Converts the input 
+         Fixnum value to a C unsigned int.',
+
+        'long NUM2LONG (VALUE aNumeric)','Converts the input Numeric 
+         value to a C long. If you know that the input value is
+         a Fixnum, use the faster FIX2LONG macro',
+        
+        'long FIX2LONG (VALUE aFixnum)','Converts the input Fixnum
+         value to a C long',
+        
+        'unsigned long NUM2ULONG (VALUE aNumeric)','Converts
+         the input Numeric value to a C unsigned long',
+
+        'char NUM2CHR (VALUE aNumeric)', 'converts the input
+         Numeric value to a C char',
+        
+        'double NUM2DBL (VALUE aNumeric)','Converts the input
+         Numeric value to a C double',
+        
+        'VALUE INT2NUM(int i) or VALUE INT2NUM(long l) ','converts
+         the input int or long value into either a Fixnum or
+         Bignum instance, depending on its size.',
+        
+        'VALUE INT2FIX(int i) or VALUE INT2FIX(long l)',' converts
+         the input int or long alue into a Fixnum. If you are sure 
+         that the input value will fit into a Fixnumm, this macro
+         is a little faster than the INT2NUM macro.',
+        
+        'VALUE CHR2FIX(char c)','converts the input char value
+         into a fixnum.',
+                
+        'VALUE rb_float_new(double f) ','converts the input
+         double value into a Float'
+      )+
+      # ===================================================================== #
+      # === Anhang H
+      # ===================================================================== #
+      h3('Anhang H')+
+      div {
+        h3('Ruby API Accessing Variables')+
+        e('rb_iv_get')+
+        e('rb_ivar_get')+
+        e('rb_iv_set')+
+        e('rb_ivar_set')+
+        e('rb_gv_set')+
+        e('rb_gv_get')+
+        e('rb_cvar_set')+
+        e('rb_cvar_get')+
+        e('rb_cvar_defined')+
+        e('rb_cv_set')+
+        e('rb_cv_get')
+      }+
+      # ========================================================================= #
+      # === LINKS ZU EMBEDDED RUBY
+      # ========================================================================= #
+      div('marpad1em marl2_5em','','border:5px dotted grey'){
+        h2('Links zu Embedded Ruby','mart2px')+
+        p('marl1em ind0px'){
+          a('http://www.onlamp.com/pub/a/onlamp/2004/11/18/extending_ruby.html',
+            content: 'RubyOnLamp.com', css_class: 's1em'
+          )+
+          br+
+          a('http://rhg.rubyforge.org/chapter02.html',
+            content: 'A GREAT Tutorial', css_class: 's1em'
+          )+
+          br+
+          a('http://www.ruby-doc.org/doxygen/1.8.4/classes.html',
+            content: 'Die C Klassen von Ruby', css_class: 's1em'
+          )+
+          br+
+          a('http://www.oreillynet.com/ruby/blog/2006/02/ruby_values_and_object_ids.html',
+            content: 'Ruby VALUEs und .object_id', css_class: 's1em'
+          )+
+          br+
+          a('http://eigenclass.org/hiki.rb?ruby+internals+guide',
+            content: 'Ruby VALUEs und .object_id', css_class: 's1em'
+          )+
+          br+
+          a('http://phrogz.net/ProgrammingRuby/ext_ruby.html',
+            content: 'Auch gute Erklärungen', css_class: 's1em'
+          )+
+          br+
+          a('http://www.oreillynet.com/ruby/blog/2007/04/c_extension_authors_use_rb_sca_1.html',
+            content: 'Ruby-C Scan Arg Beispiel', css_class: 's1em'
+          )+
+          br+
+          a('http://www.jaredrichardson.net/blog/2006/03/25/#C-extenstions',
+            content: 'Ruby-C', css_class: 's1em'
+          )+
+          br+
+          a('http://www.rubyist.net/~nobu/ruby/Ruby_Extension_Manual.html',
+            content: 'Extending Ruby', css_class: 's1em'
+          )+
+          br+
+          a('http://fixnum.org/ruby_c.html',
+            content: 'Von Ruby zu C', css_class: 's1em'
+          )+
+          br+
+          a('http://izumi.plan99.net/blog/index.php/2007/10/12/how-the-ruby-heap-is-implemented/',
+            content: 'Ruby und Heap Management', css_class: 's1em'
+          )+
+          br+
+          a('http://www.ruby-forum.com/',
+            content: 'Ruby Forum', css_class: 's1em'
+          )+
+          br+
+          a('http://blog.zenspider.com/archives/2006/08/writing_c_exten.html', 
+            content: 'Zenspider on Writing a C extension', css_class: 's1em'
+          )+
+          br+
+          a('http://banisterfiend.wordpress.com/2008/10/25/the-secret-life-of-singletons/', 
+            content: 'The Secret of Singletons', css_class: 's1em'
+          )+
+          br+
+          a('http://www.rubyfleebie.com/ruby-and-c-part-1/', 
+            content: 'Ruby and C', css_class: 's1em'
+          )+
+          br+
+          a('http://coaxialhost.com/tutorials/writing_ruby_extensions.html', 
+            content: 'Ruby and C', css_class: 's1em'
+          )+
+          br+
+          a('https://silverhammermba.github.io/emberb/c/', 
+            content: 'Ruby and C', css_class: 's1em'
+          )+
+          br+
+          a(:c_language, content: 'Lokale C Page', css_class: 's1em')+
+          br+
+          a(:ruby_gtk, content: 'Lokale GTK Page', css_class: 's1em')+
+          br
+        }
+       }
+    }
+    }
+  end
+
+end