roebe 0.5.187

data/doc/core/compiling_ruby_c_code.md

@@ -0,0 +1,1969 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    Dies ist mein Tutorial, wie man Ruby <b>embedded</b>, also mit
+C Programmen verknüpft.
+
+    Ein Vorteil des "Embedding" ist der immense 
+<b class="darkblue FI">Geschwindigkeitsgewinn</b>.
+
+    Meine Beispiele hierzu findet man unter:
+
+cd $RSRC/C
+
+  _
+
+## Wie überprüfe ich, in Ruby-MRB, ob ein String Objekt
+frozen ist?
+!MRB_FROZEN_P(mrb->exc)) {
+
+    Man kann auch recht einfach bestehende .rb Dateien 
+in Ruby-C (um)schreiben.
+
+    Dir Initialisierung (also der Beginn) geht via:
+
+ruby_init()','BO
+
+    Dabei wird der <b>Ruby Interpreter</b> initialisiert.
+
+ruby_init_loadpath()
+
+    ist sehr wichtig wenn man Module laden will, denn sie
+initialisiert
+
+    die <b class="BO">$LOAD_PATH Variable</b>.
+
+    Sie enthält auch den Ort von <b>site_ruby</b>.
+
+    <b>ruby_script(name</b> ist einfach, denn diese Funktion
+weist den Namen des Ruby Scripts an die $0 variable.
+
+    Abfragen gehen zum Beispiel so:
+
+if $0 != "embed"
+
+    Fehlt dies, so <b></b>wird $0 der false Wert zugewiesen</b>.
+
+    Klingt ein wenig chaotisch?
+
+    Nun gut - bringen wir ein wenig Ordnung in dieses Chaos.
+
+# ===================================================================== #
+# === Ruby QTrue tag (true tag) 
+# ===================================================================== #
+## Ruby True',HEADER_CSS,'true',HEADER_BORDER
+    VALUE some_function(VALUE mod)
+    {
+  return Qtrue;
+    }
+
+# ===================================================================== #
+# === Define alias in Ruby C. alias tag.
+# ===================================================================== #
+## Ruby Aliases in C',HEADER_CSS, HEADER_BORDER,
+'rb_define_alias
+
+Dies geht via <b>rb_define_alias</b>, wobei der 
+erste Name der AliasName ist:
+
+rb_define_alias(klass, name1, name2);
+rb_define_alias(cJukebox, "a", "add");
+rb_define_alias(cJukebox, "d", "delete");
+
+  (Das gehört zum Beispiel innerhalb der <b>Init_*</b> Funktion rein.)
+
+# ===================================================================== #
+# === Ruby Funcall
+# ===================================================================== #
+## Ruby Funcall',HEADER_CSS,'ruby_funcall',HEADER_BORDER
+    rb_funcall - Calls a method.
+
+    First arg is the invocant','marl1em
+
+Second is the method','marl2em
+
+  Third is the number of arguments','marl3em
+
+    Der Rest sind die restlichen Argumente.
+
+rb_funcall(file, method, 1, self);
+VALUE name = rb_funcall(current, rb_intern("to_s"), 0);
+
+anm('<b>rb_funcall</b> raises a NameError if you try to call
+a method that does not exist.
+
+# ==================================================================== #
+# === rb iv get tag
+#
+# Getter Methode.
+#
+#   rf ruby_embedded rb_iv_get
+#
+# ===================================================================== #
+## rb_iv_get',HEADER_CSS,'rb_iv_get',HEADER_BORDER
+    Getter Methode auf Ruby-C Ebene.
+
+array_sum = rb_iv_get(self, "@array_sum");
+
+rb_iv_get(self, "@file");
+rb_iv_get(self, "@line");
+
+# ===================================================================== #
+# === Ruby Cache
+# ===================================================================== #
+## Ruby Cache',HEADER_CSS,'ruby_cache',HEADER_BORDER
+rb_clear_cache_by_id(id);
+
+# ===================================================================== #
+# === RESPOND TO
+# ===================================================================== #
+## Ruby and .respond_to?',HEADER_CSS,'ruby_respond_to',HEADER_BORDER
+    rb_respond_to(current, rb_intern("to_s")));
+
+# ===================================================================== #
+# === protect method calls in ruby-C
+# ===================================================================== #
+## Ruby and protected methods?',HEADER_CSS,'rb_protet',HEADER_BORDER)+
+    Method calls can be protected by surrounding them via:
+
+    rb_protect();
+
+# ===================================================================== #
+# === Ruby Thread Schedule
+# ===================================================================== #
+## Ruby Thread Schedule',HEADER_CSS,'ruby_thread_schedule',HEADER_BORDER)+
+    Mache einen Scheduler:
+
+rb_thread_schedule();
+
+    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().
+
+    Das ganze ist letzten Endes <b>Thread.pass</b> in Ruby direkt
+äquivalent.
+
+# ===================================================================== #
+# Modul Funktionen definieren
+# ===================================================================== #
+## Modul Funktionen definieren',HEADER_CSS, 'ruby_module_functions',HEADER_BORDER)+
+mModul = rb_define_module("CModul");
+rb_define_module_function(mModul, "sendeGrussAnC", sendeGrussAnC, 1);
+rb_define_module_function(mDB2CLI, 
+"SQLColAttribute",  db2_SQLColAttribute,  4);
+
+    Das erste Argument in rb_define_module_function ist das Module, das
+die Funktion erhalten soll.
+
+# ===================================================================== #
+# === Ruby Info. Ruby Version.
+# ===================================================================== #
+## Ruby Info',HEADER_CSS,'ruby_info',HEADER_BORDER)+
+    Zeige information über Ruby an:
+
+ruby_show_version(); // shows ruby info like so: 
+ruby 1.8.6 (2007-03-13 patchlevel 0) [i686-linux]
+
+# ===================================================================== #
+# === Data get Tag. get tag. struct tag.
+# ===================================================================== #
+div(id: 'Data_Get_Struct'){
+  e("Data_Get_Struct wird recht häufig eingesetzt")+
+  
+Zuerst die allgemeine Syntax hierzu:
+  
+  void Data_Get_Struct(VALUE obj, type, type *ptr
+  Data_Get_Struct(self, qp_movie_context, movie_ctx);
+  
+Die C Extension sieht dann etwa so aus:
+  
+  VALUE CompondShape_arelink VALUE self) {
+  CompoundShape *ptr;
+  Data_Get_Struct(selof, CompoundShape, ptr);')
+
+# ===================================================================== #
+# === Ruby Return Values.
+#
+# qtrue tag siehe eins darunter.
+#
+# return tag. qnil tag. qfalse tag.
+# ===================================================================== #
+## Ruby Return Values',HEADER_CSS,'return_values',HEADER_BORDER)+
+    Ein VALUE (wie die folgenden) auf der C Seite ist das Äquivalent
+zu einem Object auf Ruby Seite.
+
+    Hat man eine Funktion vom void type, gibt man <b>return Qnil</b>
+zurück.
+
+	    return Qtrue;
+	    return Qfalse;
+	    return Qnil;
+	    return Qundef;
+	    br+
+	    # ===================================================================== # 
+# === RUBY METHODEN DEFINIEREN in C via rb_define_method tag
+#
+# method tag 
+# METHODEN tag. rf embedded ruby_methods
+# ===================================================================== #
+## Methoden - Ruby Methoden definieren in RUBY C, (es wird eine Klasse
+gebraucht)', HEADER_CSS, 'ruby_methods', HEADER_BORDER)+
+    In Ruby erklärt man eine Methode mittels 
+<b class="darkblue">def</b>.
+
+    Auf C Seite geschieht das mittels <b>rb_define_method</b>.
+
+    Jede Methode in Ruby-C, die etwas bestimmtes mit Ruby Pointern 
+macht, muss als erstes Argument <b>VALUE self</b> erhalten.
+
+    Beispiel:
+
+static VALUE t_add(VALUE self, VALUE anObject);
+
+    Instanz Methoden in Ruby-C setzt man mittels
+<b>rb_define_method</b>:
+
+static VALUE der_klassen_pointer;
+rb_define_method(dieRubyKlasse, const char * methodName, VALUE(*) cFunc, int numArgs);
+rb_define_method(der_klassen_pointer, "add", t_add, 1);
+rb_define_method(cTest, "initialize", t_init, 0);
+rb_define_method(cSimpleClass, "add_to_array", t_add, 1 // akzeptiert 1 Argument);
+rb_define_method(cSimpleClass, "show_var", t_show_var, 0);
+rb_define_method(cCircle, "area", Circle_area, 3 // akzeptiert 3 Argumente);
+rb_define_method(rb_mKernel, "nil?", rb_false, 0);
+rb_define_method(rb_cMeine_klasse, "methoden_name_in_ruby", 
+name_der_c_funktion, anzahl_der_argumente_als_int);
+
+    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.
+
+    Nun ein kurzer Ausflug nach array.c, um anzusehen, 
+wie es implementiert ist auf C Ebene:
+
+    rb_define_method(rb_cArray,"to_s", rb_ary_to_s, 0);
+
+    Um die <b>method_id</b> zu bekommen verwendet man rb_intern:
+
+rb_intern("method_name");
+
+    Noch ein kompletteres Beispiel, wie so eine Methode dann
+aussieht:
+
+VALUE your_method(VALUE self) {
+	  int x = 10;
+	  return INT2NUM(x
+	    }
+	    br+
+	    # ===================================================================== #
+# === CONSTANTS AND RUBY const tag constants tag
+#   rf rubyembedded ruby_constants
+# ===================================================================== #
+## Constants und Ruby',HEADER_CSS,'ruby_constants',HEADER_BORDER)+
+
+
+    Eine <b>normale Konstante</b> in Ruby folgt diesen Regeln:
+
+rb_define_const(klass, name_of_our_constant, value);
+rb_define_const(module_or_class, "NAME", value);'  )+
+
+    name_of_our_constant ist der Name unserer Konstanten.
+
+    Weitere, konkrete Beispiele für Konstanten:
+
+rb_define_const("RELEASE_DATE", d);
+rb_define_const(module, "Value", rb_str_new2("Hello World"));  
+rb_define_const(rb_mProcess, "PRIO_PROCESS", INT2FIX(PRIO_PROCESS);
+rb_define_const(rb_mProcess, "PRIO_PGRP", INT2FIX(PRIO_PGRP);
+rb_define_const(rb_mProcess, "PRIO_USER", INT2FIX(PRIO_USER);
+rb_define_const(mRubygame,"INIT_TIMER",INT2NUM(SDL_INIT_TIMER);
+rb_define_const(cCD,"STOPPED",INT2NUM(CD_STOPPED);
+rb_define_const(cCD,"PLAYING",INT2NUM(CD_PLAYING);
+rb_define_const(cCD,"PAUSED",INT2NUM(CD_PAUSED);
+rb_define_const(cCD,"ERROR",INT2NUM(CD_ERROR);
+rb_define_const(mVte, "BUILD_VERSION);",
+rb_ary_new3(3, INT2FIX(VTE_MAJOR_VERSION), 
+INT2FIX(VTE_MINOR_VERSION), INT2FIX(VTE_MICRO_VERSION)));
+
+    Innerhalb einer ifdef Schleife geht dies so:
+
+ifdef RLIMIT_CORE
+    rb_define_const(rb_mProcess, "RLIMIT_CORE", INT2FIX(RLIMIT_CORE)
+#endif
+
+# ===================================================================== #
+# === Ruby False tag
+# ===================================================================== #
+## Ruby False',HEADER_CSS,'false',HEADER_BORDER)+
+    In ruby können wir <b>false</b> wie folgt verwenden:
+
+    VALUE some_function(VALUE mod)
+    {
+  return Qfalse;
+    }
+
+# ===================================================================== #
+# === RUBY OBJEKTE IN C
+#
+# Ruby_objekte. # rf embedded Ruby_objekte
+# ===================================================================== #
+## Ruby Objekte in C',HEADER_CSS,'Ruby_objekte',HEADER_BORDER)+
+    In Ruby wird jeder Inhalt eines Objektes mittels  
+einer <b>C Structure</b> beschrieben.
+
+    Dies wird mittels <b>pointer</b> realisiert.
+
+    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.
+
+img('PC/RUBY/ch_object_value.png','bblack1 mars1em
+
+    <b>VALUE</b> wiederum findet man in <b>ruby.h</b>
+
+    vim $PROGRAMS/Ruby/Current/lib/ruby/1.8/i686-linux/ruby.h','BO s3em
+
+    Dort gibt es viele besondere Structs, wie zum Beispiel:
+
+  struct RData
+  struct RBasic
+  struct RObject
+  struct RClass 
+  struct RHash
+  struct RFile
+  struct RFloat
+  struct RString # siehe Anhang für ein beispiel
+  struct RArray 
+  struct RRegexp
+
+    Und <b>VALUE</b> hat diese Struktur:
+
+    typedef unsigned long VALUE;
+
+    Folgendes Beispiel zeigt eine <b>Initialierung eines Ruby
+Array</b> (entspräche dem Ruby Code <b>def initialize</b>):
+
+    static VALUE t_init(VALUE self) //# def initialize
+    {
+  VALUE array;
+  array = rb_ary_new();
+  rb_iv_set(self, "@array", array);
+  return self;
+    }
+
+    Genauer betrachtet ist .new in Ruby-C etwas komplizierter,
+wie folgendes Beispiel illustriert:
+
+info = Data_Make_Struct(cTest, MP3Info, 0, free, one);
+
+rb_obj_call_init(info, argc, argv);
+
+    Klassen sind in Ruby ein <b>zentrales Element</b>, 
+die zuerst deklariert werden müssen, bevor man sie 
+verwenden kann.','padl1em
+
+    Folgendes Beispiel illustriert dies anhand der 
+cTest Klasse:
+
+    VALUE cTest;
+
+    void Init_my_test() {
+cTest = rb_define_class("MyTest", rb_cObject
+
+    Jede C-Extension definiert eine globale C Funktion
+namens <b>Init_</b>, der Name der Extension wird
+angehängt.
+
+    Mit anderen Worten, die allgemein Syntax ist:
+
+    Init_moduleName
+
+    Lädt man zb eine Datei namens <b>hello_world.so</b>,
+so ist die dazugehörige Init funktion diese:
+
+Init_hello_world
+
+    Diese <b>muss</b> soweit mir bekannt immer vom <b>void</b>
+Typ sein, nicht static oder irgendwas sonst. Beispiel:
+
+void Init_global_variables();
+void Init_hello_world();
+void Init_genx4r();
+
+    Diese Funktion wird aufgerufen wenn der Interpreter 
+die <b>Extension ladet</b>.
+
+    Ausserdem kann man das ganze in eine schöne Methode
+verpacken, in Verbindung mit Data_Make_Struct. Siehe
+dazu folgendes Beispiel:
+
+VALUE mp3_info_new() {
+  VALUE info;
+  MP3Info *one;
+  info = Data_Make_Struct(cTest, MP3Info, 0, free, one
+    rb_obj_call_init(info, 0, 0
+    return info;
+}
+
+# ===================================================================== #
+# === rb_class2name
+# ===================================================================== #
+## Ruby Class2Name Konversion',HEADER_CSS,'rb_class2name',HEADER_BORDER)+
+    Die reverse function von rb_class2Name() ist so:
+
+rb_path2class(path);
+
+# ===================================================================== #
+# === Define ruby attr Ruby C
+# ===================================================================== #
+## Ruby Attr in C',HEADER_CSS,'rb_define_attr',HEADER_BORDER)+
+    Attr Methoden gehen einfach, wobei ein Wert von 1 ein <b>ja</b>
+bedeutet.
+
+    Zuerst kommt read, dann write.
+
+rb_define_attr( die_klass_für_das_attr, ihr_attr_name, read, write)
+rb_define_attr( cLoader, "families", 1, 1 );
+rb_define_attr( cprivateType, "value", 1, 1 );
+rb_define_attr( cJukebox, "value", 1, 1 );
+rb_define_attr( cparser, "options", 1, 1 );
+rb_define_attr( cTest, "test_var", 1, 0 );
+
+# ===================================================================== #
+# === rb_scan_args tag. rf embedded rb_scan_args
+# ===================================================================== #
+## Ruby und rb_scan_args',HEADER_CSS,'rb_scan_args',HEADER_BORDER)+
+    rb_scan_args ist zu verwenden um Arguments zu counten.
+
+    Beispiel:
+
+static VALUE my_function(int argc, VALUE* argv, VALUE self)
+{
+    VALUE v_name, v_age; // die argumente
+
+rb_scan_args(argc, argv, "11", &v_name, &v_age
+
+    Zudem kann man rb_scan_args verwenden um default values zu
+setzen:
+in_ruby+
+    def foobar(arg=1)
+    end
+
+in_ruby_c+
+rb_define_method(myclass, "method_name", meth_fnc, -1);
+rb_define_method_function(module, "name", c_function, argc);
+  
+    In your method use rb_scan_args to scan the argument list.
+
+    If you dont get enough arguments, use the default values instead.
+
+div {
+  h2('Random Tidbits
+Ruby stores ivars for immutable object types (e.g. Fixnum/Symbol) 
+  in external hashes (see generic_ivar_* in variable.c for 
+  ruby/trunk).')
+
+div {
+  ## Was ist rb_funcall2?')
+
+div {
+  ## Wie erhalte ich den Namen einer Klasse in Ruby-C?
+   class Bar; end; Object.const_get("bar".capitalize).new
+  VALUE time_klass = rb_const_get( rb_cObject, rb_intern("Time") );')
+
+div {
+Hier eine Liste mit C code und Ruby code:
+  
+  table2('s1em','','',
+    'rb_current_realfilepath', '== __FILE__'
+  )
+
+    From 1.8 to 1.9...
+    bitsweat> change RSTRING(...)->ptr to RSTRING_PTR(...)
+    bitsweat> and same for ->len to _LEN
+
+    Damit die .c Beispiele funktionieren, müssen sie allesamt
+eine <b class="FI darkblue">Init Funktion</b> deklarieren,
+wie zum Beispiel so:
+
+void Init_genx4r();
+void Init_ruby_fstab();
+void Init_hello();
+
+    Die Init Funktionen geben <b>nichts zurück</b> via return.
+
+anm('Der Name der Init Funktionen ist immer <b>der Name der 
+Extension</b>, also zum Beispiel:','FW4
+
+void Init_extname();
+
+    // void Init_jukebox()  // wie man hier sieht, muss 
+der Name nach Init_ <b>klein</b> geschrieben werden.
+
+# ===================================================================== #
+# === Data Wrap Tag. Wrap tag. struct tag.
+# ===================================================================== #
+div {
+  ## Ruby Data_Wrap_Struct',HEADER_CSS,'rb_data_wrap_struct',HEADER_BORDER)+
+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.
+  
+API des Makro ist:
+  
+  VALUE Data_Wrap_Struct(VALUE class, void (*mark_func) (void *),
+  void (*free_func) (void *), void *ptr
+  
+Der ptr nimmt einen Pointer zu einer Speicherort auf.
+  
+Typischerweise sieht der Code dann in etwa so aus:
+  
+  lem('  CompoundShape *ptr;
+  lem('  VALUE obj;
+  
+  lem('  ptr = CreateCompoundShape(
+  lem('  obj = Data_Wrap_Struct(cCompoundShape, CompoundShape_mark, 
+  CompoundShape_free, ptr
+  
+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:
+  
+  lem('  VALUE Data_Make_Struct(VALUE class, type, void
+  (*mark_func)(void *), void (*free_func)(void *), void
+  *ptr
+  
+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.
+  
+Anmerkung: dieser Speicher sollte mit free() befreit werden.
+  
+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
+# ===================================================================== #
+## Definieren von Singleton Methods:',HEADER_CSS,
+'ruby_singleton_methods',HEADER_BORDER)+
+    rb_define_singleton_method
+
+# ===================================================================== #
+# === OBJECT ID tag
+#
+#   von http://www.oreillynet.com/ruby/blog/2006/02/ruby_values_and_object_ids.html
+# ===================================================================== #
+## Object ID von Ruby Objekten',HEADER_CSS,'ruby_object_id',HEADER_BORDER)+
+    Ruby kalkuliert Objekt IDs (object_id) wie folgt: # drbrain: see rb_obj_id for how the object_id is computed
+
+VALUE rb_obj_id(VALUE obj)
+{
+    if (SPECIAL_CONST_pobj)) {
+cmd3('return LONG2NUM((long)obj
+  }
+  return (VALUE)((long)obj|FIXNUM_FLAG
+    }
+
+    nil.object_id zb gibt immer <b>4</b> zurück.
+
+# ===================================================================== #
+# === Check_Type
+# ===================================================================== #
+## Herausfinden was was ist mit Check_Type',
+  HEADER_CSS,'ruby_check_type',HEADER_BORDER
+)+
+    Finde heraus, was was ist mittels Check_Type(VALUE val, int type)
+
+Check_Type(val, T_STRING); // Ist es ein String?
+Check_Type(val, T_OBJECT); // Ist es ein Object?
+
+# ===================================================================== #
+# === STRUCTS TAG
+# ===================================================================== #
+## Hier ein Beispiel von Struct Usage',HEADER_CSS,'ruby_struct',HEADER_BORDER)+
+    struct time_object {
+
+  struct timeval tv;
+  struct tm tm;
+  int gmt;
+  int tm_got;
+
+    };
+
+struct time_object *tobj;
+obj = Data_Make_Struct(klass, struct time_object, 0, time_free, tobj
+tobj->tm_got = 0;
+tobj->tv.tv_sec = 0;
+    tobj->tv.tv_usec = 0;
+
+# ===================================================================== #
+# === COMPILEN VON RUBY C CODE STRUKTUREN. compile tag
+#
+# Makefile tag.
+#   rf embedded compiling
+# ===================================================================== #
+## Compilen von Ruby C Code Strukturen mittels mkmf / Makefile:',
+HEADER_CSS,'compiling',HEADER_BORDER)+
+    Zum Compilen muss man zb dies hier machen:
+
+    -lruby
+
+    Hier ein Beispiel dazu:
+
+    gcc test.c -lruby -o embedded','extconf
+
+gcc -o embeddedRuby embeddedRuby.o -O2 -fpic \\")+
+-I/usr/lib/ruby/1.6/i386-linux -rdynamic 
+-L/usr/lib/ruby/1.6/i386-linux \\")+
+    -lruby -lm -ldl
+
+anm('Der einfachste Weg zum Kompilieren ist es aber  
+<b>extconf.rb</b> zu nutzen.
+
+    Typische Struktur bzw Commands dazu folgt wobei wir mit
+extconf.rb anfangen:
+
+vim $RSRC/C/extconf.rb
+bl $RSRC/C/extconf.rb
+
+    <b>extconf.rb</b> erlaubt einige Besonderheiten,
+wie zum Beispiel <b>dir_config("some_dir")</b>.
+
+    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>.
+
+    Folgend sehen wir ein kompletteres Beispiel für
+<b>extconf.rb</b>:
+
+cmd2("  require('mkmf')")+
+
+  dir_config("genx4r")
+
+  abort "need stdio.h" unless have_header("stdio.h") # aborten geht auch
+cmd2("  have_library('libraryName', 'libraryFunction')")+
+
+    dir_config hat übrigens 2 weitere Argumente - Nr 2 gibt 
+include Paths an, Nr 3 gibt Library Paths an.
+
+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
+
+
+  create_makefile("my_test") # my_test is the name of
+your c. file
+
+    Es gehen auch mehrere Argumente, wobei ich aber noch nicht 
+weiss, was die weiteren Argumente bewirken.
+
+    Beispiel:
+
+create_makefile('inotify', 'ext')")+
+
+// or this create_makefile("genx4r")
+
+    <b>dir_config</b> sagt Ruby, das man alle .c Dateien im aktuellen 
+Verzeichnis nutzen soll, um eine Extension namens genx4r zu
+erstellen.
+
+anm('Danach kann man ruby extconf.rb anwenden; dies erstellt
+dann eine Makefile Datei.
+
+    Ob ein Computer System bestimmte <b>Headers</b> hat, kann
+man so abfragen:
+
+have_header('linux/inotify.h')")+
+
+    Dies würde zb so eine Zeile ausgeben:
+
+checking for linux/inotify.h... no
+
+    Hier ein "chained" Beispiel dazu:
+
+if have_header("readline/readline.h") and 
+have_header("readline/history.h") and have_library("readline", "readline")'
+)+
+    Das ganze alleine bricht aber nicht ab, wenn man einen Abbruch
+möchte, dann muss man ein <b>if</b> davor schalten.
+
+    Mehrere headers überprüfen kann man zb so:
+
+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')")+
+  	  end
+  	  br+
+    Das Übergeben einer bestimmten Bibliothek geht so:
+
+have_library('foo') # -lfoo")+
+have_library('m') # -lm")+
+
+    Will man hier gleich mehrer Libaries zugleich abfragen, geht
+dies zum Beispiel so:
+
+    if have_library("ole32") and  have_library("oleaut32")
+
+    Einen <b class="darkblue">speziellen Namen </b> kann man 
+seiner Extension auch geben (sehr zu empfehlen):
+
+extension_name = 'mytest'")+
+
+    Ein Win-Makefile kann man so erstellen:
+
+create_win32ole_makefile
+  # To create it, run: 
+  ruby extconf.rb;make(
+
+    Nun kommt eine Meldung "<b>creating Makefile</b>", die sehr
+schnell beendet sein sollte - ansonsten handelt es sich wohl
+um einen Syntax Fehler.
+
+    Danach <b>make</b> aufrufen
+
+    Übrigens, nicht auf <b>Init_</b> vergessen!
+
+    Dies erstellt zb foobar.so (shared library), und kann dann so 
+genutzt werden (die <b>.so Extension</b> muss nicht angegeben
+werden):
+require('foobar'")+
+require('global_variables'")+
+
+    Man kann übrigens nur require verwenden, load 
+funktioniert nur mit .rb Dateien.
+
+    Ok, folgend nun ein paar Code Beispiele für C:
+
+VALUE callback(void) 
+{
+    printf("C callback\n"
+    return T_TRUE;
+}
+
+# ===================================================================== #
+# === FIXNUMS UND RUBY (Fixnum tag, Fixnums tag.
+# ===================================================================== #
+## Fixnums und Ruby',HEADER_CSS,'ruby_fixnums',HEADER_BORDER)+
+    Fixnum, Symbol, true, false, und nil werden direkt in VALUE
+gespeichert, und sind keine Pointers. Man nennt sie auch
+<b>immediate values</b>.
+
+    Um zu überprüfen, ob es sich bei einem Wert um einen 
+<b>Fixnum</b> handelt, kann man zb dies hier tun:
+
+    FIXNUM_pvalue)
+
+    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.
+
+    Im Anhang A gibts ein Listing, ansonsten folgen hier
+noch einige Beispiele:
+
+    /* structure for ordinary objects */
+
+    struct RObject {
+
+  struct RBasic basic;
+  struct st_table *iv_tbl;
+
+    };
+
+    /* structure for strings (instance of String) */
+
+    struct RString {
+struct RBasic basic;
+  long len;
+  char *ptr;
+  union {
+long capa;
+VALUE shared;
+  } aux;
+}
+
+    /* structure for arrays (instance of Array) */
+
+struct RArray {
+    struct RBasic basic;
+    long len;
+  union {
+long capa;
+VALUE shared;
+    } aux;
+  VALUE *ptr;
+};
+
+    Jede Extension in Ruby definiert eine globale C Funktion, die
+so aussieht:
+
+    Init_<i>name</i>
+
+    Wie oben beschrieben definiert man den Namen einer Klasse in
+C-Ruby so:
+
+    VALUE der_klassen_pointer;
+    der_klassen_pointer = <b>rb_define_class</b>("MeineKlasse",
+rb_cObject);
+
+# ===================================================================== #
+# === Class Method. define a c method or class method.
+# ===================================================================== #
+## Class Methods',HEADER_CSS,'ruby_class_methods',HEADER_BORDER)+
+    define_c_method
+
+# ===================================================================== #
+# === ruby modules tag mod tag module tag.
+# ===================================================================== #
+## Definieren von Ruby Modules', HEADER_CSS,'ruby_modules',HEADER_BORDER)+
+
+    Es ist anzuraten, ein kleines <b>m</b> voranzustellen, um
+darauf hinzuweisen, das es sich um ein Modul handelt.
+
+    Dies ist eine gute Konvention in Ruby.
+br +
+VALUE mNcurses;
+
+static VALUE mWtmp;
+mWtmp = rb_define_module("Wtmp"); // the argument is the module name
+VALUE module = rb_define_module("name");'  )+
+rb_mGenX = rb_define_module ("GenX");
+
+anm('Anmerkung: Ein module in Ruby-C gibt <b>immer</b> ein VALUE
+zurück.
+
+rb_define_method_function(module, "name", c_function, argc); 
+rb_define_method_function
+
+    Noch ein Beispiel:
+
+static VALUE rb_mHello, mShapes;
+rb_mHello = rb_define_module("Hello");
+mShapes = rb_define_module("Shape");
+
+    Module innerhalb anderer Module zu definieren geht so:
+
+VALUE mRubygame;
+
+mRubygame = rb_define_module("Rubygame");
+
+    Hier noch wie das Modul Enumerable definiert wurde:
+
+VALUE rb_mEnumerable;
+
+rb_mEnumerable = rb_define_module("Enumerable");
+
+    Um Module Functions zu definieren siehe
+
+a('#ruby_module_functions', content: 'hier
+
+# ===================================================================== #
+# === rb_require tag
+# ===================================================================== #
+## Ruby Require',HEADER_CSS,'rb_require',HEADER_BORDER)+
+rb_require("./embedding.rb"); // Ruby-Modul laden
+
+# ===================================================================== #
+# === rb_class_new_instance tag
+# ===================================================================== #
+## Ruby und rb_class_new_instance',HEADER_CSS, 'rb_class_new_instance',HEADER_BORDER)+
+    Beispiel:
+
+VALUE entry = rb_class_new_instance (0, 0, cEntry);
+
+    Was macht rb_class_new_instance?
+
+obj = rb_obj_alloc(klass);
+rb_obj_call_init(obj, argc, argv);
+
+    Man findet es in object.c
+
+# ===================================================================== #
+# === Dynamic Libraries.
+# ===================================================================== #
+div('FS1em','dynamic_libraries'){
+  
+C libraries can usually be accessed via <b>dynamic linker</b>.
+  Die Ruby dl-Bibliothek vereinfacht dies ungemein:
+  
+  require('dl'")+
+  require('dl/import'")+
+  
+  module Libc")+
+  extend DL::Importable")+
+  dlload '/lib/libc.so.6'")+
+  extern 'char* ttyname(int)'")+
+  end
+  
+  puts Libc.ttyname(0)")
+
+# ===================================================================== #
+# === Ruby Array Entry tag.
+# ===================================================================== #
+## Ruby Array Entry',HEADER_CSS,'rb_ary_entry',HEADER_BORDER)+
+VALUE rb_ary_entry(VALUE ary, long offset)
+[1,2,3][2]
+[1,2,3].at(2)
+
+    Der C Code sieht so aus:
+
+VALUE num;
+num = rb_ary_entry(ary, offset);
+printf("%d\n", FIX2INT(num));
+VALUE num = RARRAY(ary)->ptr[offset]);
+
+div {
+static VALUE sendeGrussAnC(VALUE self, VALUE str)
+ {
+     printf("Ruby hat uns den Gruss gesendet: %s\n",
+ StringValuePtr(str)
+}
+  
+int main (int argv[], int argc)
+{
+    VALUE cModul;
+    VALUE gruss;')
+
+
+printf("Ein Hallo von C\n");
+ruby_init; // Dieser Aufruf ist zwingend
+cModul = rb_define_module("CModul");
+rb_define_module_function(cModul,
+     "sendeGrussAnC", sendeGrussAnC, 1);
+
+# ===================================================================== #
+# === C HASH DEFINIEREN in C. (hash tag, hashes tag). #Hashes
+# ===================================================================== #
+## Ruby Hash definieren in RUBY C',HEADER_CSS,'Hashes',HEADER_BORDER)+
+cEntry = rb_define_class_under (mWtmp, "Entry", rb_cHash);
+
+    <b>hash = Hash.new</b> geht so:
+
+VALUE hash; hash = rb_hash_new(); // Hash.new # Wir erstellen
+einen neuen Hash
+
+    <b>.select</b> in Hash:
+
+rb_hash_select
+
+    <b>.values_at</b> in Hash:
+
+rb_hash_values_at
+
+    <b>.reject!</b> in Hash:
+
+rb_hash_reject_bang
+
+    <b>.freeze</b> in Hash:
+
+rb_hash_freeze
+
+    <b>.each</b> in Hash:
+
+rb_hash_foreach # iterate over a hash
+rb_define_alloc_func hash_alloc;
+"[]", rb_hash_s_create, -1
+"initialize", rb_hash_initialize, -1
+"initialize_copy", rb_hash_replace, 1
+"rehash", rb_hash_rehash, 0
+"to_hash", rb_hash_to_hash, 0
+"to_a", rb_hash_to_a, 0
+"to_s", rb_hash_to_s, 0
+"inspect", rb_hash_inspect, 0
+"==", rb_hash_equal, 1
+
+    Um gespeicherte Einträge aus einem Hash zu <b>holen</b>, 
+geht dies hier:
+in_ruby+
+hash = { :foo => 'blah' }")+
+
+    In Ruby-C:
+
+hash = rb_hash_new();
+foo = rb_hash_aref(hash, ID2SYM(rb_intern("foo")));
+
+    bzw (etwas länger)
+
+int age;
+hash = rb_hash_new();
+key = rb_str_new2("Oscar");
+value = rb_hash_aref(hash, key);
+age = NUM2INT(value); // Should return 6, Siehe oben bei
+INT2NUM
+
+anm('NUM2INT und INT2FIX sind Möglichkeiten wie man Nummer in
+Ruby erstellt.
+
+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.
+
+    Das heisst auch, das ein Hash, der strings als Keys verwenden,
+diese zuerst in Ruby Strings konvertieren muss:
+
+VALUE string_key, value;
+ 
+string_key = rb_str_new2("Some key"); 
+value = rb_hash_aref(hash, string_key)
+in_ruby+
+h = { "a" => 100, "b" => 200 }; h.fetch("a")
+in_ruby_c+
+foo = rb_hash_fetch(hash, ID2SYM(rb_intern("foo"))
+
+    Um <b>neue</b> Einträge (key, value) in einen Hash
+reinzugeben verwendet man rb_hash_aset():
+
+    Beispiel:
+
+in_ruby+
+     hash << "foo"
+in_ruby_c+
+h = { "a" => 100, "b" => 200 }; h.fetch("a")
+hash = rb_hash_new();
+key = rb_str_new2("Oscar");
+value = INT2NUM(6);
+rb_hash_aset(hash, key, value));
+
+    Weiter geht es:
+
+"store", rb_hash_aset, 2
+"default", rb_hash_default, -1
+"default=", rb_hash_set_default, 1
+"default_proc", rb_hash_default_proc, 0
+"index", rb_hash_index, 1
+"indexes", rb_hash_indexes, -1
+"indices", rb_hash_indexes, -1
+"size", rb_hash_size, 0
+"length", rb_hash_size, 0
+"empty?", rb_hash_empty_p, 0
+"each", rb_hash_each, 0
+"each_value", rb_hash_each_value, 0
+"each_key", rb_hash_each_key, 0
+"each_pair", rb_hash_each_pair, 0
+
+    Sortieren geht in Ruby so:
+in_ruby+
+h = { "c"=> 300, "a" => 100, "b" => 200 }; h.sort
+in_ruby_c+
+"sort", rb_hash_sort, 0
+"keys", rb_hash_keys, 0
+"values", rb_hash_values, 0
+"values_at", rb_hash_values_at, -1
+"shift", rb_hash_shift, 0
+"delete", rb_hash_delete, 1
+"delete_if", rb_hash_delete_if, 0
+"select", rb_hash_select, -1
+"reject", rb_hash_reject, 0
+"reject!", rb_hash_reject_bang, 0
+"clear", rb_hash_clear, 0
+"invert", rb_hash_invert, 0
+"update", rb_hash_update, 1
+"replace", rb_hash_replace, 1
+"merge!", rb_hash_update, 1
+"merge", rb_hash_merge, 1
+"include?", rb_hash_has_key, 1
+"member?", rb_hash_has_key, 1
+"has_key?", rb_hash_has_key, 1
+"has_value?", rb_hash_has_value, 1
+"key?", rb_hash_has_key, 1
+"value?", rb_hash_has_value, 1
+"[]", rb_f_getenv, 1
+"fetch", env_fetch, -1
+"[]=", env_aset, 2
+"store", env_aset, 2
+"each", env_each, 0
+"each_pair", env_each_pair, 0
+"each_key", env_each_key, 0
+"each_value", env_each_value, 0
+"delete", env_delete_m, 1
+"delete_if", env_delete_if, 0
+"clear", env_clear, 0
+"reject", env_reject, 0
+"reject!", env_reject_bang, 0
+"select", env_select, -1
+"shift", env_shift, 0
+"invert", env_invert, 0
+"replace", env_replace, 1
+"update", env_update, 1
+"inspect", env_inspect, 0
+"rehash", env_none, 0
+"to_a", env_to_a, 0
+"to_s", env_to_s, 0
+"index", env_index, 1
+"indexes", env_indexes, -1
+"indices", env_indexes, -1
+"size", env_size, 0
+"length", env_size, 0
+"empty?", env_empty_p, 0
+"keys", env_keys, 0
+"values", env_values, 0
+"values_at", env_values_at, -1
+"include?", env_has_key, 1
+"member?", env_has_key, 1
+"has_key?", env_has_key, 1
+"has_value?", env_has_value, 1
+"key?", env_has_key, 1
+"value?", env_has_value, 1
+"to_hash", env_to_hash, 0
+
+    # ======================================================================= #
+    # === 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)+
+    VALUE array; array = rb_ary_new();
+    VALUE hardware_list; hardware_list = rb_ary_new();
+    br+
+  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+
+    return rb_ary_new2(ARY_DEFAULT_SIZE
+    br+
+  Wie man sieht genügt die Deklaration <b>VALUE array_name</b>
+    br+
+  Weitere Manipulationen mit Arrays gehen so:
+    br+
+    rb_ary_push(VALUE ary, VALUE val); // <b>.push</b> fügt am 
+    Ende des Array ein neues Element hinzu
+    br+
+     rb_ary_push(hardware_list, rb_str_new2("\"HDD1\"=>\"/dev/hdc1\"")',
+    'marl4em
+    br+
+    rb_ary_pop(VALUE ary); // <b>.pop</b> entfernt das letzte 
+    Element eines Array und gibt ihn wieder
+    br+
+    rb_ary_shift(VALUE ary) // Entfernt das erste Element
+    eines Arrays und gibt es wieder
+    br+
+    rb_ary_unshift(VALUE ary, VALUE val) // das Gegenteil
+    von shift - fügt den Eintrag vorne an
+    br+
+  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
+# ===================================================================== #
+## Ruby und .dup',HEADER_CSS,'ruby_dup',HEADER_BORDER)+
+rb_str_dupstr
+
+    (Allerdings mag dies nicht mehr aktuell sein.)
+
+# ===================================================================== #
+# === Globale Variables in Ruby
+# ===================================================================== #
+## Globale Variablen in Ruby',HEADER_CSS,'ruby_global_vars',HEADER_BORDER)+
+    Anmerkung: Man sollte seine globalen Variablen mit dem $ 
+Prefix prependen.','s0_5em
+
+    Allgemein deklarieren wir eine Variable in C-Ruby so (mit
+Beispiel):
+
+rb_define_variable();
+rb_define_variable("$gvars", &hardware_list);
+rb_define_variable("$String", &MyString);
+
+    Folgender BeispielCode zeigt an, wie man globale Variablen in
+Ruby-C definiert:
+
+static VALUE hardware_list;
+static VALUE MyString;
+MyString = rb_str_new(
+static VALUE Init_SysInfo() {
+  rb_define_class(....
+  hardware_list = rb_ary_new();
+  rb_define_variable("$hardware", &hardware_list
+  rb_ary_push(hardware_list, rb_str_new2("DVD")
+  rb_ary_push(hardware_list, rb_str_new2("CDPlayer1")
+  rb_ary_push(hardware_list, rb_str_new2("CDPlayer2")
+    }
+
+# ====================================================================== #
+# === RUBY ERRORS TAG ERROR TAG
+#
+# rb_raise tag.
+#   rf embedded ruby_errors
+# ===================================================================== #
+## Ruby Errors',HEADER_CSS,'ruby_errors',HEADER_BORDER)+
+    Gezielte Errors erzielt man mittels <b>rb_raise</b> so:
+
+    rb_raise(rb_eRangeError, "0x%lx is recycled object", p0
+
+    Ein anderer Fehler zb so:
+
+rb_raise(rb_eTypeError, "wrong argument type %s 
+(expected %s)", etype, type->name);
+
+rb_raise(rb_eTypeError, "operand is not valid type");
+
+rb_raise(rb_eTypeError, "cannot convert 
+%s into String", rb_obj_classname(arg1));
+
+rb_raise(rb_eArgError, "no stream to tell");
+
+rb_raise(rb_eNameError, "undefined method %s 
+in super", rb_id2name(id));
+
+rb_raise(rb_eTypeError, "type of arg must be Matrix");
+
+    Wie man übrigens sieht, werden Errors mit <b>rb_e</b>
+prepended.
+
+# ===================================================================== #
+# === RUBY CLASS DEFINIEREN in C class tag
+# ===================================================================== #
+## Ruby Classes definieren in RUBY C',HEADER_CSS,'Class_definieren',HEADER_BORDER)+
+    Eine Klasse in ruby-C definieren geht über <b>static VALUE</b>:
+
+static VALUE rb_cGenX;
+static VALUE rb_cGenXWriter;
+static VALUE rb_cFstabAppender;
+static VALUE rb_cTest;
+
+    Hier nochmals letzteres Beispiel kombiniert, um zu demonstrieren
+wie wir eine Klasse in <b>Ruby-C</b> definieren:
+
+static VALUE cTest; cTest = rb_define_class("Test",
+<b>rb_cObject</b>);  // <b class="red">class Test</b>
+
+rb_cFstabAppender = rb_define_class("FstabAppender", 
+rb_cObject);
+
+    Das zweite Argument (also <b>rb_cObject</b>) zeigt an, 
+das unsere Klasse eine <b>Subklasse von Object</b> ist. 
+
+    Object wird durch rb_cObject dargestellt. Den Rest 
+findet man in ruby.h, bzw in Anhang D.
+
+    Um eine Klasse innerhalb zb eines Modules zu definieren 
+muss man folgendes verwenden:
+
+cTest = rb_define_class_under("Test", rb_cObject);
+rb_cMyFile = rb_define_class_under(rb_mHello,"MyFile", rb_cObject);
+rb_cGenXWriter = rb_define_class_under (rb_mGenX, 
+"Writer", rb_cObject);
+
+    Die Klasse kann man dann einfach benutzen nachdem man die
+.so-SharedLib geladen hat.
+
+    Verwendungs Beispiel:
+
+x = Test.new
+x = Jukebox.new
+x = SimpleClass.new
+
+# ===================================================================== #
+# === rb define alloc func
+# ===================================================================== #
+## Ruby Alloc',HEADER_CSS,'rb_define_alloc_func',HEADER_BORDER)+
+    Noch keine Info dazu erhältlich.
+
+rb_define_alloc_func();
+
+# ===================================================================== #
+# rb iv set tag. #rb_iv_set
+#   rf embedded rb_iv_set
+# ===================================================================== #
+## rb_iv_set',HEADER_CSS,'rb_iv_set',HEADER_BORDER)+
+    Eine Instanz Variable kann man auch setzen, und zwar so:
+
+    VALUE rb_iv_set(VALUE obj, char *name, VALUE value)
+
+    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.
+
+  	Konkrete Beispiele:
+  	  br+
+  	  rb_iv_set(self, "@array", array);
+  	  rb_iv_set(self, "@msg", rb_str_new2("Hello, World !") // String Beispiel
+  	  br+
+  	  # ===================================================================== #
+# === Ruby Symbols
+# ===================================================================== #
+## Ruby Symbols in RUBY C',HEADER_CSS,'Symbols_definieren',HEADER_BORDER)+
+    Das Erstellen eines Symbols ist leicht:
+
+ID2SYM( rb_intern("verbose") ); '+ruby('/* In Ruby :verbose */'))+
+ID2SYM( rb_intern("noop") ); '+ruby('/* In Ruby :noop */'))+
+
+    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>.
+
+    Hierzu nun ein kompletteres Beispiel:
+
+ID2SYM(rb_intern("name")); 
+node_name = ID2SYM(rb_intern("ICKY"));
+ID method = rb_intern("<<");
+
+    creates a symbol :name for the string name.
+
+    Hat man die ID kann man <b>rb_id2name</b> verwenden um 
+den Namen zu rekonstruieren.
+
+    Diese Nummer verwandelt man in ein Ruby Symbol Object
+indem man das ID2SYM() macro verwendet.
+
+    Den ID Wert eines Strings innerhalb von C erhält man
+allgemein so:
+
+rb_intern(const char *name);
+
+header('class Thread
+    VALUE rb_thread_create(VALUE *func, void *data)
+    Dies erstellt ein neues Thread.
+
+# ===================================================================== #
+# === rb_obj_is_instance_of
+# ===================================================================== #
+div(id: 'rb_obj_is_instance_of'){
+  h2('rb_obj_is_instance_of
+rb_obj_is_instance_of
+  br
+
+# ===================================================================== #
+# === Ruby Nil tag
+# ===================================================================== #
+## Ruby Nil',HEADER_CSS,'nil',HEADER_BORDER)+
+    Es scheint so zu sein, das man in Ruby Qnil als Ergebnis zu 
+liefern hat, auch wenn die Methode an sich nix macht...
+
+VALUE some_function(int argc, VALUE *argv, VALUE classmod)
+{
+    return Qnil;
+}
+
+# ===================================================================== #
+# === ruby_inline
+# ===================================================================== #
+div(id: 'ruby_inline'){
+Mittels ruby inline kann man C code in .rb Dateien einbetten.
+  br +
+Dies kann oft zu schnellerem Code führen.
+  
+  require('inline'")+
+  class << self
+    	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('  		"
+end
+  end
+  
+  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
+Mittels rb eval kann man bequem Ruby Code testen:','','','Strings
+rb_eval_string("anObject.each{|x| x.clearFlag }"
+  
+Will man eine spezielle Methode aufrufen (sollte schneller gehen
+  als eval), so ist folgendes zu empfehlen:
+  
+  rb_funcall(receiver, method_id, argc, ...)
+  
+Hier noch die andere String Functions:
+  
+  h2('String functions
+  
+  rb_str_new(const char *ptr, long len);
+    --Creates a new Ruby string.
+  rb_str_new2(const char *ptr);
+    -- Creates a new Ruby string from a C string. 
+  This is equivalent to rb_str_new(ptr, strlen(ptr))
+  rb_tainted_str_new(const char *ptr, long len)
+  -- Creates a new tainted Ruby string. 
+  Strings from external data sources should be tainted.
+  
+  rb_tainted_str_new2(const char *ptr);
+  -- Creates a new tainted Ruby string from a C string.
+  
+  rb_str_cat(VALUE str, const char *ptr, long len);
+  -- Appends len bytes of data from ptr to the Ruby string.
+  
+  # =================================================================== #
+  # === rb_define_module_function
+  # =================================================================== #
+  div(id: 'rb_define_module_function'){
+  Dies nutzt man um module_function zu implementieren.
+    
+  rb_define_module_function')
+  
+  # =================================================================== #
+  # === Strings in Ruby
+  # =================================================================== #
+  ## Ruby Strings auf C Ebene', HEADER_CSS,'ruby_str_new',HEADER_BORDER)+
+Strings in Ruby werden so verwendet:
+  
+  rb_str_new2
+  
+Dies is die typische Art von Ruby, wie man Strings nutzt
+
+  VALUE str = rb_str_new2(p);
+	return str;
+	result = xmlBufferCreate();
+  ret = rb_str_new2(result->content);
+  
+Noch ein Beispiel:
+  
+  VALUE roebe;
+  roebe = rb_str_new2("Roebe war hier");  
+  printf("%s <--",roebe);
+  
+Noch ein Beispiel:
+  
+  VALUE string;
+  string = rb_str_new2("Dein String");
+Will man die Information von einem Ruby String als einen C
+  String repräsentieren, verwendet man das STR2CSTR Makro.
+  
+  VALUE stringObj;
+  char *cstr;
+  cstr = STR2CSTR(stringObj);
+  
+  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.
+  
+Will man die echte Länge eines Ruby String wissen, inklusive der 
+  NULL bytes und so weiter, kann man dies verwenden:
+  
+  VALUE stringObj;
+  char *cstr;
+  int stringLength;
+  cstr = rb_str2cstr(stringObj, &stringLength);
+  
+Statt diesem Weg gibt es einen noch schnelleren Weg:
+  
+  VALUE stringObj;
+  int stringLength;
+  stringLength = RSTRING(stringObj)->len;
+  p {
+  Hier noch Funktionen um einen neuen String zu 
+    erstellen (String.new):
+    
+    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.'
+    )+
+    
+  Und hier Funktionen, mit denen wir mit Strings arbeiten:
+    
+    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:
+  
+  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
+rb_iv_get
+rb_ivar_get
+rb_iv_set
+rb_ivar_set
+rb_gv_set
+rb_gv_get
+rb_cvar_set
+rb_cvar_get
+rb_cvar_defined
+rb_cv_set
+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'
+    )+
+    
+    a('http://rhg.rubyforge.org/chapter02.html',
+content: 'A GREAT Tutorial', css_class: 's1em'
+    )+
+    
+    a('http://www.ruby-doc.org/doxygen/1.8.4/classes.html',
+content: 'Die C Klassen von Ruby', css_class: 's1em'
+    )+
+    
+    a('http://www.oreillynet.com/ruby/blog/2006/02/ruby_values_and_object_ids.html',
+content: 'Ruby VALUEs und .object_id', css_class: 's1em'
+    )+
+    
+    a('http://eigenclass.org/hiki.rb?ruby+internals+guide',
+content: 'Ruby VALUEs und .object_id', css_class: 's1em'
+    )+
+    
+    a('http://phrogz.net/ProgrammingRuby/ext_ruby.html',
+content: 'Auch gute Erklärungen', css_class: 's1em'
+    )+
+    
+    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'
+    )+
+    
+    a('http://www.jaredrichardson.net/blog/2006/03/25/#C-extenstions',
+content: 'Ruby-C', css_class: 's1em'
+    )+
+    
+    a('http://www.rubyist.net/~nobu/ruby/Ruby_Extension_Manual.html',
+content: 'Extending Ruby', css_class: 's1em'
+    )+
+    
+    a('http://fixnum.org/ruby_c.html',
+content: 'Von Ruby zu C', css_class: 's1em'
+    )+
+    
+    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'
+    )+
+    
+    a('http://www.ruby-forum.com/',
+content: 'Ruby Forum', css_class: 's1em'
+    )+
+    
+    a('http://blog.zenspider.com/archives/2006/08/writing_c_exten.html', 
+content: 'Zenspider on Writing a C extension', css_class: 's1em'
+    )+
+    
+    a('http://banisterfiend.wordpress.com/2008/10/25/the-secret-life-of-singletons/', 
+content: 'The Secret of Singletons', css_class: 's1em'
+    )+
+    
+    a('http://www.rubyfleebie.com/ruby-and-c-part-1/', 
+content: 'Ruby and C', css_class: 's1em'
+    )+
+    
+    a('http://coaxialhost.com/tutorials/writing_ruby_extensions.html', 
+content: 'Ruby and C', css_class: 's1em'
+    )+
+    
+    a('https://silverhammermba.github.io/emberb/c/', 
+content: 'Ruby and C', css_class: 's1em'
+    )+
+    
+    a(:c_language, content: 'Lokale C Page', css_class: 's1em
+    
+    a(:ruby_gtk, content: 'Lokale GTK Page', css_class: 's1em
+    br
+