Flo: Unterschied zwischen den Versionen

Aktuelle Version vom 22. Februar 2013, 14:23 Uhr

Wir weisen darauf hin, dass möglicherweise nicht alle Beiträge den Anforderungen genügen. Die Anforderungen sind: Flos sind in Liste "flo" gespeichert, zur Ausführ- oder Compilierzeit werden durch den Code einzelne flo0, flo1, flo2, flo3 Variablen angelegt, die später dann auch zur Ausgabe verwendet werden.

 Wir sind die Flo, Widerstand ist zwecklos!

Inhaltsverzeichnis

1 Beiträge, die die Anforderungen erfüllen
- 1.1 ruby
- 1.2 lisp
- 1.3 C
- 1.4 Perl
- 1.5 Perl
- 1.6 PHP
- 1.7 Bash
- 1.8 PHP, Lisp, Perl, XML, Bash
- 1.9 Ruby
- 1.10 JavaScript
- 1.11 Lua
- 1.12 C++11
2 Bloatiger Angebercode, der auch noch etwas völlig anderes macht
- 2.1 Ruby
- 2.2 Ru^W Objektorientiertes C
3 Die Enterprise-Loesung
4 Fußnoten

Beiträge, die die Anforderungen erfüllen

ruby

#!/usr/bin/env ruby

flo = [ "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" ]

# flos sind keine arrayss1!
for i in 0..flo.size-1
  eval "flo#{i} = flo[#{i}]"
  puts "flo#{i} == \"" + eval("flo#{i}") + "\""
end

lisp

Dieses Perl (*duck*) kann ja keiner lesen!¹⁾ Daher:

(eval-when (:compile-toplevel :load-toplevel :execute)
  (defvar *flo-sequence* #("dividuum" "syb" "fiji" "flowhase" "florolf" "FlorianJW")))

(defmacro make-individual-flo-variables ()
  (cons 'progn
        (loop for flo across *flo-sequence*
              for i from 0
              collect `(defvar ,(read-from-string (format nil "*flo~d*" i)) ,flo))))

(make-individual-flo-variables)

(dotimes (i 5)
    (format t "~&flo~d = ~a" i (eval (read-from-string (format nil "*flo~d*" i)))))

C

Dreckiges C:

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
const int flolen = 6;
static const char *flos[] = {"dividuum","syb","fiji","flowhase","florolf", "FlorianJW"};
static const char *proghead = "#include <stdio.h>\nint main(void){\n";
static const char *progend =  "  return(0);\n}\n";
int main(void){
        int i; FILE *o;
        o=fopen("flo2.c","w");
        fputs(proghead,o);
        for(i=0;i<flolen;i++){
                fprintf(o,"  char *flo%d = \"%s\";\n",i,flos[i]);
                fprintf(o,"  printf(\"flo%%d ist %%s\\n\",%d,flo%d);\n",i,i); }
        fputs(progend,o);
        fclose(o);
        system("/usr/bin/gcc -o flos flo2.c;./flos;rm -f flo2.c flos");
        return 0;
}

Perl

Nu aber wirklich noch in Perl:

#!/usr/bin/perl

@flo = ( "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" );

for $i (0..$#flo) {
  eval "\$flo$i = \$flo\[$i\]";
  print "\$flo$i eq \"" . eval("\$flo$i") . "\"\n";
}

Perl

#!/usr/bin/perl

@flo = ( "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" );

for $i (0..$#flo) {
  ${"flo$i"} = $flo[$i];
  print "\$flo$i eq \"" . ${"flo$i"} . "\"\n";
}

PHP

<?php
$flo = array( "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" );

foreach ($flo as $i => $x) {
  ${"flo$i"} = $flo[$i];
  echo "\$flo$i = \"" . ${"flo$i"} . "\"\n";
}
?>

Bash

Gute alte Bash:

#!/bin/sh

flo="dividuum syb fiji flowhase florolf FlorianJW"

n=0
for f in $flo
do
  eval flo$n=$f
  echo -n "flo$n == "
  eval echo \$flo$n
  n=$(($n+1))
done

PHP, Lisp, Perl, XML, Bash

Realisiert in PHP, Lisp, Perl, XML, Bash und XSLT und immernoch kürzer als die C-Version:

<?php
$flo = array( "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" );

$l = fopen("flo.lisp", "w"); $p = fopen("flo.pl", "w");
fwrite($l, '(progn (format t "~a" "<flo>")');
fwrite($p,'
print <<EOF
  <xsl:stylesheet version="1.0"
                  xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                  xmlns="http://www.w3.org/TR/xhtml1/strict">
  <xsl:template match="/">');
    for($i=0;$i<count($flo);$i++) {
      fwrite($l, "(format t \"~a~a~a\" \"<flo$i>\" \"$flo[$i]\" \"</flo$i>\")");
      fwrite($p, "flo$i == <xsl:value-of select=\"flo/flo$i\"/>\n");
    }
    fwrite($l, '(format t "~a" "</flo>"))');
    fwrite($p,'
  </xsl:template>
  </xsl:stylesheet>
EOF'."\n");
fclose($l); fclose($p);
system("sbcl --noinform --load flo.lisp --eval '(quit)' > flo.xml");
system("perl flo.pl > flo.xslt");
system("xsltproc flo.xslt flo.xml | grep -v xml");
?>

Ruby

Noch einmal in Ruby:

#!/usr/bin/env ruby

flo = [ "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" ]

# flos sind keine arrayss1!
flo.each_with_index do | f, i |
  instance_variable_set "@flo#{i}", f
  puts "flo#{i} = #{instance_variable_get "@flo#{i}"}"
end

JavaScript

'cause JavaScript rocks:

flo = new Array("dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW");
for (i in flo) {
  eval("flo"+i+" = flo["+i+"]");
  dump("flo"+i+" == "+eval("flo"+i)+"\n");
}

Lua

Wir moegen Lua:

#include <lua.h>
#include <lualib.h>
#include <lauxlib.h>

lua_State *L;

char *flos[] = {"dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW"};
char buf[1024];

void main() {
        char *p;
        int i;

        L = luaL_newstate();
        luaL_openlibs(L);

        for(i=0; i < 6; i++) {
                sprintf(buf, "flo%d", i);
                lua_pushstring(L, flos[i]);
                lua_setglobal(L, buf);
        }

        p=buf;
        for(i=0; i < 6; i++)
                p += sprintf(p, "print(\"flo%d = \" .. flo%d);", i, i);

        luaL_dostring(L, buf);
}

C++11

#include <vector>
#include <string>
#include <cstdlib>
#include <fstream>

using namespace std;

int main(){
	vector<string> flo={"dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW"};
	ofstream cpp_2("cpp_2.cpp");
	cpp_2<<"#include <iostream>\n#include <string> \nusing namespace std;\nint main(){\n";
	for(int i=0;i<flo.size();++i){
		cpp_2<<"\tstring flo"<<i<<" =\""<<flo[i]<<"\";\n";
	}
	cpp_2<<"\tcout\n";
	for(int i=0;i<flo.size();++i){
		cpp_2<<"\t\t<<flo"<<i;
		if(i+1==flo.size()){
			cpp_2<<"<<endl;\n";
		}
		else{
			cpp_2<<"<<\", \"\n";
		}
		
	}
	cpp_2<<"}"<<endl;
	cpp_2.close();
	system("g++ cpp_2.cpp -o cpp_2; ./cpp_2");
	return 0;
}

Bloatiger Angebercode, der auch noch etwas völlig anderes macht

Ruby

Und nochmal das, was das Ruby-Programm "mit viel bloatigem Metaprogramming-Foo" macht, allerdings wiederum in Common Lisp gegossen:
(Warnung: (Zumindest) als Lispprogramm ist dieses Beispiel ziemlich unsinning, und z.B. die PRINT-OBJECT-Methode widerspricht der gängigen Konvention.)

(defclass flo ()
  ((name :initarg :name :reader flo-name)
   (skill :initarg :skill :reader flo-skill)
   (notebook :initarg :notebook :reader flo-notebook)))

(defun slot-value-or-something (object &key (slot 'name) (something "without name"))
  (if (slot-boundp object slot)
      (slot-value object slot)
      something))

(defmethod print-object ((flo flo) stream)
  (format stream "~&~a is actually ~a and is good at ~a.~&He loves hacking on his ~a."
          (class-name (class-of flo))
          (slot-value-or-something flo)
          (slot-value-or-something flo :slot 'skill    :something "nothing")
          (slot-value-or-something flo :slot 'notebook :something "dulcimer")))

(defmacro def-flo-class (class-name &key name skill notebook)
  (macrolet ((make-slot-def (name)
               `(when ,name
                  `(,',name :initform ,,name))))
  `(defclass ,class-name (flo)
     ,(remove nil (list
                   (make-slot-def name)
                   (make-slot-def skill)
                   (make-slot-def notebook))))))

(def-flo-class |Flo0|
    :name "dividuum"
    :skill "DOOM"
    :notebook "old Dell")

(def-flo-class |Flo1|
    :name "Peter"
    :skill "math"
    :notebook "IBM Thinkpad")

(def-flo-class |Flo2|
    :name "Fiji"
    :skill "WOW"
    :notebook "I-have-no-idea")

(def-flo-class |Flo3|
    :name "flohase"
    :skill "hoppeln"
    :notebook "hasIbook")

(def-flo-class |Flo4|
    :name "florolf"
    :skill "konfusion"
    :notebook "Thinkpad")

(def-flo-class |Flo5|
    :name "FlorianJW"
    :skill "pirat"
    :notebook "I-have-no-idea")


(let ((flos (list (make-instance '|Flo0|)
                  (make-instance '|Flo1|)
                  (make-instance '|Flo2|)
                  (make-instance '|Flo3|)
                  (make-instance '|Flo4|)
                  (make-instance '|Flo5|))))
  (dolist (flo flos)
    (print flo)))

Ru^W Objektorientiertes C

// Das aendern:
#include "/usr/local/lib/ruby/1.8/i386-freebsd5/ruby.h"

VALUE flo_init(VALUE self)
{
        char *flo[] = {"dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW"};
        int i;

        for(i = 0; i < 6; i++)
        {
                char varname[7];
                sprintf(varname, "@flo%i", i);  // Insecure!
                rb_iv_set(self, varname, rb_str_new2(flo[i]));
        }
}

VALUE flo_each(VALUE self)
{
        int i;
        VALUE vars = rb_funcall(self, rb_intern("instance_variables"), 0);
        VALUE varname = rb_ary_shift(vars);

        while(varname != Qnil)
        {
                rb_yield(rb_ary_new3(2, varname, rb_iv_get(self, RSTRING(varname)->ptr)));
                varname = rb_ary_shift(vars);
        }

        return(Qnil);
}

int main()
{
        VALUE flo;

        ruby_init();

        flo = rb_define_class("Flo", rb_cObject);
        rb_define_method(flo, "initialize", flo_init, 0);
        rb_define_method(flo, "each", flo_each, 0);

        rb_eval_string("Flo.new.each { |name,value| puts \"#{name.gsub(/^@/, '')} = #{value}\" }");

        return(0);
}

Die Enterprise-Loesung

Das Schlimmste aus beiden Welten.

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>

#include <jni.h>

const char *flos[] = { "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" };
const int n_flos = sizeof(flos)/sizeof(char*);

unsigned char class[] = {
	0xca, 0xfe, 0xba, 0xbe,
	0x00, 0x00,
	0x00, 0x33,
	0, 0,
	0x01, 0x00, 16, 'j', 'a', 'v', 'a', '/', 'l', 'a', 'n', 'g', '/', 'O', 'b', 'j', 'e', 'c', 't',
	0x01, 0x00, 4, 'F', 'l', 'o', 's',
	0x01, 0x00, 18, 'L', 'j', 'a', 'v', 'a', '/', 'l', 'a', 'n', 'g', '/', 'S', 't', 'r', 'i', 'n', 'g', ';',
	0x01, 0x00, 6, '<', 'i', 'n', 'i', 't', '>',
	0x01, 0x00, 3, '(', ')', 'V',
	0x07, 0, 1,
	0x07, 0, 2,
	0x0C, 0, 4, 0, 5,
	0x0A, 0, 6, 0, 8,
	0x01, 0x00, 4, 'C', 'o', 'd', 'e',
};

int cp_i = 11;
FILE *cout;

void fputc16(uint16_t in, FILE *out) {
	fputc(in >> 8, out); fputc(in & 0xFF, out);
}

uint16_t add_utf8(const char *string) {
	size_t len = strlen(string);

	fputc(0x01, cout);
	fputc16(len, cout);

	fputs(string, cout);

	return cp_i++;
}

uint16_t add_string(const char *string) {
	uint16_t utf8 = add_utf8(string);

	fputc(0x08, cout);
	fputc16(utf8, cout);
	return cp_i++;
}

uint16_t add_name_and_type(const char *name, uint16_t type) {
	uint16_t namei = add_utf8(name);

	fputc(0x0C, cout);
	fputc16(namei, cout);
	fputc16(type, cout);
	
	return cp_i++;
}

uint16_t add_field(uint16_t class, const char *name, uint16_t type) {
	int nat = add_name_and_type(name, type);

	fputc(0x09, cout);
	fputc16(class, cout);
	fputc16(nat, cout);

	return cp_i++;
}

void make_flontainer(void) {
	cout = fopen("Flos.class", "w");

	class[9] = 1 + 10 + 5 * n_flos;

	for(int i = 0; i < sizeof(class); i++) {
		fputc(class[i], cout);
	}

	for(int i = 0; i < n_flos; i++) {
		int ref;

		char varbuf[16];
		snprintf(varbuf, 16, "flo%u", i);
		add_field(7, varbuf, 3);

		add_string(flos[i]);
	}

	fputc16(0x0001, cout);
	fputc16(0x0007, cout);
	fputc16(0x0006, cout);

	fputc16(0, cout);

	fputc16(n_flos, cout);
	for(int i = 0; i < n_flos; i++) {
		fputc16(0x0001, cout);
		fputc16(11 + i * 5, cout);
		fputc16(3, cout);
		fputc16(0, cout);
	}

	fputc16(1, cout);
	fputc16(0x0001, cout);
	fputc16(4, cout);
	fputc16(5, cout);
	fputc16(1, cout);
	fputc16(10, cout);
	fputc16(0, cout);
	fputc16(17 + n_flos * 6, cout);
	fputc16(2, cout);
	fputc16(1, cout);
	fputc16(0, cout);
	fputc16(5 + n_flos * 6, cout);
	fputc(0x2A, cout);
	fputc(0xB7, cout); fputc16(0x0009, cout);
	for(int i = 0; i < n_flos; i++) {
		fputc(0x2A, cout);
		fputc(0x12, cout); fputc(15 + 5 * i, cout);
		fputc(0xB5, cout); fputc16(13 + 5 * i, cout);
	}
	fputc(0xB1, cout);

	fputc16(0, cout);
	fputc16(0, cout);

	fputc16(0, cout);

	fclose(cout);
}

const char *printer = "\
import java.lang.reflect.Field;\n\
\n\
public class Printer {\n\
	public static void print() throws Exception {\n\
		Flos floContainer = new Flos();\n\
		Field[] flos = floContainer.getClass().getFields();\n\
\n\
		for(Field flo : flos) {\n\
			System.out.println(flo.getName() + \": \" + flo.get(floContainer));\n\
		}\n\
	}\n\
}\n";

void make_printer(void) {
	FILE *out = fopen("Printer.java", "w");
	fputs(printer, out);
	fclose(out);

	system("javac Printer.java");
}

void print_flos(void) {
	JNIEnv *env;
	JavaVMInitArgs args;

	memset(&args, 0, sizeof(JavaVMInitArgs));
	args.version = JNI_VERSION_1_6;

	JavaVM *jvm;
	JNI_CreateJavaVM(&jvm, (void**)&env, &args);

	jclass printer = (*env)->FindClass(env, "Printer");
	jmethodID print = (*env)->GetStaticMethodID(env, printer, "print", "()V");
	(*env)->CallStaticVoidMethod(env, printer, print);
}

int main(void) {
	make_flontainer();
	make_printer();
	print_flos();

	return EXIT_SUCCESS;
}

Fußnoten

1) Anmerkung zu: "Dieses Perl (*duck*) kann ja keiner lesen!"

Stimmt doch gar nicht! Ist ganz einfach:

map printf("%s = %s\n", [flo0..flo5]->[$_], [dividuum, syb, fiji, flowhase, florolf, FlorianJW]->[$_]), 0..$#{@{[flo0..flo5]}};

(Kommentar von mgr: Genau, "0..$#{@{[flo0..flo5]}}" ... q.e.d. Danke für das gute Beispiel. Aber ernsthaft, es ging hier eben gerade *nicht* um Einzeiler, die will niemand.)

Und auch in python kann man Einzeiler schreiben:

print "\n".join(["%s = %s" % (k, v) for k, v in {"flo0":"dividuum", "flo1":"syb", "flo2":"fiji", "flo3":"flowhase","flo4":"florolf", "flo5":"FlorianJW"}.items()])

Flo: Unterschied zwischen den Versionen

Aktuelle Version vom 22. Februar 2013, 14:23 Uhr

Inhaltsverzeichnis

Beiträge, die die Anforderungen erfüllen

ruby

lisp

C

Perl

Perl

PHP

Bash

PHP, Lisp, Perl, XML, Bash

Ruby

JavaScript

Lua

C++11

Bloatiger Angebercode, der auch noch etwas völlig anderes macht

Ruby

Ru^W Objektorientiertes C

Die Enterprise-Loesung

Fußnoten

Navigationsmenü

Ansichten

Meine Werkzeuge

Navigation

Suche

fnord

Werkzeuge

@@ Zeile 1: / Zeile 1: @@
 <div id="Vorlage_FIXME">
-{| width="100%" border="0" cellspacing="8" cellpadding="0" style="background-color: #f9f9f9; border: 1px solid #f00; font-size: 95%; margin-top: 2px; margin-bottom: 2px; clear: both"
+{| width="100%" border="0" cellspacing="8" cellpadding="0" style="border: 1px solid #f00; font-size: 95%; margin-top: 2px; margin-bottom: 2px; clear: both"
 | style="width: 24px" | [[Bild:Qsicon Ueberarbeiten.png|24px]]
 | Wir weisen darauf hin, dass möglicherweise nicht alle Beiträge den Anforderungen genügen. Die Anforderungen sind: Flos sind in Liste "flo" gespeichert, zur Ausführ- oder Compilierzeit werden durch den Code einzelne flo0, flo1, flo2, flo3 Variablen angelegt, die später dann auch zur Ausgabe verwendet werden.
@@ Zeile 6: / Zeile 6: @@
 </div>
+  '''Wir sind die Flo, Widerstand ist zwecklos!'''
 == Beiträge, die die Anforderungen erfüllen ==
+=== ruby ===
-<pre>
+<syntaxhighlight lang="ruby">
 #!/usr/bin/env ruby
-flo = [ "dividuum", "syb", "fiji", "flowhase" ]
+flo = [ "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" ]
 # flos sind keine arrayss1!
@@ Zeile 19: / Zeile 20: @@
    puts "flo#{i} == \"" + eval("flo#{i}") + "\""
 end
-</pre>
+</syntaxhighlight>
+===lisp===
 Dieses Perl (*duck*) kann ja keiner lesen!<span id="footref1">[[#footnote1|<sup><small>1)</small></sup>]]</span> Daher:
 {| cellpadding=5
-|<pre>
+|<syntaxhighlight lang="lisp">
 (eval-when (:compile-toplevel :load-toplevel :execute)
-   (defvar *flo-sequence* #("dividuum" "syb" "fiji" "flowhase")))
+   (defvar *flo-sequence* #("dividuum" "syb" "fiji" "flowhase" "florolf" "FlorianJW")))
 (defmacro make-individual-flo-variables ()
@@ Zeile 36: / Zeile 37: @@
 (make-individual-flo-variables)
-(dotimes (i 4)
+(dotimes (i 5)
      (format t "~&flo~d = ~a" i (eval (read-from-string (format nil "*flo~d*" i)))))
-</pre>
+</syntaxhighlight>
 |
 |[[Bild:Lisplogo_warning_128.png]]
 |}
+=== C ===
-Dreckig:
+Dreckiges C:
-<pre>
+<syntaxhighlight lang="c">
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <unistd.h>
-const int flolen = 4;
+const int flolen = 6;
-static char *flos[] = {"dividuum","syb","fiji","flowhase"};
+static const char *flos[] = {"dividuum","syb","fiji","flowhase","florolf", "FlorianJW"};
-static char *proghead = "#include <stdio.h>\nint main(void){\n"'
+static const char *proghead = "#include <stdio.h>\nint main(void){\n";
-static char *progend =  "  return(0);\n}\n";
+static const char *progend =  "  return(0);\n}\n";
 int main(void){
          int i; FILE *o;
@@ Zeile 63: / Zeile 64: @@
          fclose(o);
          system("/usr/bin/gcc -o flos flo2.c;./flos;rm -f flo2.c flos");
-         return(0);
+         return 0;
 }
-</pre>
+</syntaxhighlight>
+===Perl===
 Nu aber wirklich noch in Perl:
-<pre>
+<syntaxhighlight lang="perl">
 #!/usr/bin/perl
-@flo = ( "dividuum", "syb", "fiji", "flowhase" );
+@flo = ( "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" );
 for $i (0..$#flo) {
@@ Zeile 78: / Zeile 80: @@
    print "\$flo$i eq \"" . eval("\$flo$i") . "\"\n";
 }
-</pre>
+</syntaxhighlight>
+===Perl===
+<syntaxhighlight lang="perl">
+#!/usr/bin/perl
+@flo = ( "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" );
+for $i (0..$#flo) {
+  ${"flo$i"} = $flo[$i];
+  print "\$flo$i eq \"" . ${"flo$i"} . "\"\n";
+}
+</syntaxhighlight>
+===PHP===
+<syntaxhighlight lang="php">
+<?php
+$flo = array( "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" );
+foreach ($flo as $i => $x) {
+  ${"flo$i"} = $flo[$i];
+  echo "\$flo$i = \"" . ${"flo$i"} . "\"\n";
+}
+?>
+</syntaxhighlight>
+===Bash===
 Gute alte Bash:
-<pre>
+<syntaxhighlight lang="bash">
 #!/bin/sh
-flo="dividuum syb fiji flowhase"
+flo="dividuum syb fiji flowhase florolf FlorianJW"
 n=0
@@ Zeile 95: / Zeile 120: @@
    n=$(($n+1))
 done
-</pre>
+</syntaxhighlight>
+=== PHP, Lisp, Perl, XML, Bash ===
 Realisiert in PHP, Lisp, Perl, XML, Bash und XSLT und immernoch kürzer als die C-Version:
 {| cellpadding=5
 |
-<pre>
+<syntaxhighlight lang="php">
 <?php
-$flo = array( "dividuum", "syb", "fiji", "flowhase" );
+$flo = array( "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" );
 $l = fopen("flo.lisp", "w"); $p = fopen("flo.pl", "w");
@@ Zeile 125: / Zeile 151: @@
 system("sbcl --noinform --load flo.lisp --eval '(quit)' > flo.xml");
 system("perl flo.pl > flo.xslt");
-system("xsltproc flo.xslt flo.xml");
+system("xsltproc flo.xslt flo.xml | grep -v xml");
 ?>
-</pre>
+</syntaxhighlight>
 |
 |
-http://static.php.net/www.php.net/images/news/php-logo.gif
+[[Bild:php-logo.gif]]
 [[Bild:Lisplogo_warning_128.png]]
-http://www.mail-archive.com/copenhagen@perl.org/msg00162/logo_mermaid.png
+[[Bild:perl_logo_mermaid.png]]
+[[Bild:Bash-org.jpg|128px]]
+[[Bild:Xslt.png|150px]]
 |}
+===Ruby===
+Noch einmal in Ruby:
-== Bloatiger Angebercode, der auch noch etwas völlig anderes macht ==
+<syntaxhighlight lang="ruby">
-Und nun nochmal Ruby mit viel bloatigem Metaprogramming-Foo (Und etwas völlig anderes machend. Anm. v. [[Benutzer:Mgr|mgr]]):
-<pre>
 #!/usr/bin/env ruby
-class Flo
-  def self.metaclass; class << self; self; end; end
-  def self.traits(*arr)
-    return @traits if arr.empty?
-    attr_accessor *arr
-    arr.each do |a|
-      metaclass.instance_eval do
-        define_method( a ) do |val|
-          @traits ||= {}
-          @traits[a] = val
-        end
-      end
-    end
-    class_eval do
-      define_method( :initialize ) do
-        self.class.traits.each do |k,v|
-          instance_variable_set("@#{k}", v)
-        end
-      end
-    end
-  end
-  traits :name, :skill, :notebook
+flo = [ "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" ]
-   def to_s
+# flos sind keine arrayss1!
-    s = "#{self.class} is actually #{self.name} and is good at #{self.skill}\n\tHe loves hacking on his #{self.notebook}"
+flo.each_with_index do | f, i |
-  end
+   instance_variable_set "@flo#{i}", f
+  puts "flo#{i} = #{instance_variable_get "@flo#{i}"}"
 end
+</syntaxhighlight>
+===JavaScript===
+'cause JavaScript rocks:
+<syntaxhighlight lang="JavaScript">
+flo = new Array("dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW");
+for (i in flo) {
+  eval("flo"+i+" = flo["+i+"]");
+  dump("flo"+i+" == "+eval("flo"+i)+"\n");
+}
+</syntaxhighlight>
+===Lua===
+Wir moegen Lua:
+<syntaxhighlight lang="lua">
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
-class Flo0 < Flo
+lua_State *L;
-  name "dividuum"
-  skill "DOOM"
+char *flos[] = {"dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW"};
-  notebook "old Dell"
+char buf[1024];
-end
+void main() {
+        char *p;
+        int i;
+        L = luaL_newstate();
+        luaL_openlibs(L);
+        for(i=0; i < 6; i++) {
+                sprintf(buf, "flo%d", i);
+                lua_pushstring(L, flos[i]);
+                lua_setglobal(L, buf);
+        }
+        p=buf;
+        for(i=0; i < 6; i++)
+                p += sprintf(p, "print(\"flo%d = \" .. flo%d);", i, i);
-class Flo1 < Flo
+        luaL_dostring(L, buf);
-  name "Peter"
+}
-  skill "math"
+</syntaxhighlight>
-  notebook "IBM Thinkpad"
-end
-class Flo2 < Flo
-  name "Fiji"
-  skill "WOW"
-  notebook "i have no idea"
-end
-class Flo3 < Flo
+===C++11===
-  name "flowhase"
+<syntaxhighlight lang="c">
-  skill "hoppeln"
+#include <vector>
-  notebook "hasIbook"
+#include <string>
-end
+#include <cstdlib>
+#include <fstream>
-a = [ Flo0.new, Flo1.new, Flo2.new, Flo3.new ]
+using namespace std;
-a.each { |f| puts f }
-</pre>
+int main(){
+	vector<string> flo={"dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW"};
+	ofstream cpp_2("cpp_2.cpp");
+	cpp_2<<"#include <iostream>\n#include <string> \nusing namespace std;\nint main(){\n";
+	for(int i=0;i<flo.size();++i){
+		cpp_2<<"\tstring flo"<<i<<" =\""<<flo[i]<<"\";\n";
+	}
+	cpp_2<<"\tcout\n";
+	for(int i=0;i<flo.size();++i){
+		cpp_2<<"\t\t<<flo"<<i;
+		if(i+1==flo.size()){
+			cpp_2<<"<<endl;\n";
+		}
+		else{
+			cpp_2<<"<<\", \"\n";
+		}
+	}
+	cpp_2<<"}"<<endl;
+	cpp_2.close();
+	system("g++ cpp_2.cpp -o cpp_2; ./cpp_2");
+	return 0;
+}
+</syntaxhighlight>
-Und nochmal das, was das Ruby-Programm "mit viel bloatigem Metaprogramming-Foo" macht, allerdings wiederum in Common Lisp gegossen:
+== Bloatiger Angebercode, der auch noch etwas völlig anderes macht ==
-<br>(Warnung: (Zumindest) als Lispprogramm ist dieses Beispiel ziemlich unsinning, und z.B. die PRINT-OBJECT-Methode widerspricht der gängigen Konvention.)
+===Ruby===
+Und nochmal das, was das Ruby-Programm "mit viel bloatigem Metaprogramming-Foo" macht, allerdings wiederum in Common Lisp gegossen:<br>
+(Warnung: (Zumindest) als Lispprogramm ist dieses Beispiel ziemlich unsinning, und z.B. die PRINT-OBJECT-Methode widerspricht der gängigen Konvention.)
 {| cellpadding=5
-|<pre>
+|<syntaxhighlight lang="ruby">
 (defclass flo ()
    ((name :initarg :name :reader flo-name)
@@ Zeile 249: / Zeile 307: @@
      :skill "hoppeln"
      :notebook "hasIbook")
+(def-flo-class |Flo4|
+    :name "florolf"
+    :skill "konfusion"
+    :notebook "Thinkpad")
+(def-flo-class |Flo5|
+    :name "FlorianJW"
+    :skill "pirat"
+    :notebook "I-have-no-idea")
 (let ((flos (list (make-instance '|Flo0|)
                    (make-instance '|Flo1|)
                    (make-instance '|Flo2|)
-                   (make-instance '|Flo3|))))
+                   (make-instance '|Flo3|)
+                  (make-instance '|Flo4|)
+                  (make-instance '|Flo5|))))
    (dolist (flo flos)
      (print flo)))
-</pre>
+</syntaxhighlight>
 |
 |[[Bild:Lisplogo_256.png]]
 |}
+=== Ru^W Objektorientiertes C ===
+<syntaxhighlight lang="c">
+// Das aendern:
+#include "/usr/local/lib/ruby/1.8/i386-freebsd5/ruby.h"
+VALUE flo_init(VALUE self)
+{
+        char *flo[] = {"dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW"};
+        int i;
+        for(i = 0; i < 6; i++)
+        {
+                char varname[7];
+                sprintf(varname, "@flo%i", i);  // Insecure!
+                rb_iv_set(self, varname, rb_str_new2(flo[i]));
+        }
+}
+VALUE flo_each(VALUE self)
+{
+        int i;
+        VALUE vars = rb_funcall(self, rb_intern("instance_variables"), 0);
+        VALUE varname = rb_ary_shift(vars);
+        while(varname != Qnil)
+        {
+                rb_yield(rb_ary_new3(2, varname, rb_iv_get(self, RSTRING(varname)->ptr)));
+                varname = rb_ary_shift(vars);
+        }
+        return(Qnil);
+}
+int main()
+{
+        VALUE flo;
+        ruby_init();
+        flo = rb_define_class("Flo", rb_cObject);
+        rb_define_method(flo, "initialize", flo_init, 0);
+        rb_define_method(flo, "each", flo_each, 0);
+        rb_eval_string("Flo.new.each { |name,value| puts \"#{name.gsub(/^@/, '')} = #{value}\" }");
+        return(0);
+}
+</syntaxhighlight>
+== Die Enterprise-Loesung ==
+Das Schlimmste aus beiden Welten.
+<syntaxhighlight lang="c">
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <jni.h>
+const char *flos[] = { "dividuum", "syb", "fiji", "flowhase", "florolf", "FlorianJW" };
+const int n_flos = sizeof(flos)/sizeof(char*);
+unsigned char class[] = {
+xca, 0xfe, 0xba, 0xbe,
+x00, 0x00,
+x00, 0x33,
+, 0,
+x01, 0x00, 16, 'j', 'a', 'v', 'a', '/', 'l', 'a', 'n', 'g', '/', 'O', 'b', 'j', 'e', 'c', 't',
+x01, 0x00, 4, 'F', 'l', 'o', 's',
+x01, 0x00, 18, 'L', 'j', 'a', 'v', 'a', '/', 'l', 'a', 'n', 'g', '/', 'S', 't', 'r', 'i', 'n', 'g', ';',
+x01, 0x00, 6, '<', 'i', 'n', 'i', 't', '>',
+x01, 0x00, 3, '(', ')', 'V',
+x07, 0, 1,
+x07, 0, 2,
+x0C, 0, 4, 0, 5,
+x0A, 0, 6, 0, 8,
+x01, 0x00, 4, 'C', 'o', 'd', 'e',
+};
+int cp_i = 11;
+FILE *cout;
+void fputc16(uint16_t in, FILE *out) {
+	fputc(in >> 8, out); fputc(in & 0xFF, out);
+}
+uint16_t add_utf8(const char *string) {
+	size_t len = strlen(string);
+	fputc(0x01, cout);
+	fputc16(len, cout);
+	fputs(string, cout);
+	return cp_i++;
+}
+uint16_t add_string(const char *string) {
+	uint16_t utf8 = add_utf8(string);
+	fputc(0x08, cout);
+	fputc16(utf8, cout);
+	return cp_i++;
+}
+uint16_t add_name_and_type(const char *name, uint16_t type) {
+	uint16_t namei = add_utf8(name);
+	fputc(0x0C, cout);
+	fputc16(namei, cout);
+	fputc16(type, cout);
+	return cp_i++;
+}
+uint16_t add_field(uint16_t class, const char *name, uint16_t type) {
+	int nat = add_name_and_type(name, type);
+	fputc(0x09, cout);
+	fputc16(class, cout);
+	fputc16(nat, cout);
+	return cp_i++;
+}
+void make_flontainer(void) {
+	cout = fopen("Flos.class", "w");
+	class[9] = 1 + 10 + 5 * n_flos;
+	for(int i = 0; i < sizeof(class); i++) {
+		fputc(class[i], cout);
+	}
+	for(int i = 0; i < n_flos; i++) {
+		int ref;
+		char varbuf[16];
+		snprintf(varbuf, 16, "flo%u", i);
+		add_field(7, varbuf, 3);
+		add_string(flos[i]);
+	}
+	fputc16(0x0001, cout);
+	fputc16(0x0007, cout);
+	fputc16(0x0006, cout);
+	fputc16(0, cout);
+	fputc16(n_flos, cout);
+	for(int i = 0; i < n_flos; i++) {
+		fputc16(0x0001, cout);
+		fputc16(11 + i * 5, cout);
+		fputc16(3, cout);
+		fputc16(0, cout);
+	}
+	fputc16(1, cout);
+	fputc16(0x0001, cout);
+	fputc16(4, cout);
+	fputc16(5, cout);
+	fputc16(1, cout);
+	fputc16(10, cout);
+	fputc16(0, cout);
+	fputc16(17 + n_flos * 6, cout);
+	fputc16(2, cout);
+	fputc16(1, cout);
+	fputc16(0, cout);
+	fputc16(5 + n_flos * 6, cout);
+	fputc(0x2A, cout);
+	fputc(0xB7, cout); fputc16(0x0009, cout);
+	for(int i = 0; i < n_flos; i++) {
+		fputc(0x2A, cout);
+		fputc(0x12, cout); fputc(15 + 5 * i, cout);
+		fputc(0xB5, cout); fputc16(13 + 5 * i, cout);
+	}
+	fputc(0xB1, cout);
+	fputc16(0, cout);
+	fputc16(0, cout);
+	fputc16(0, cout);
+	fclose(cout);
+}
+const char *printer = "\
+import java.lang.reflect.Field;\n\
+\n\
+public class Printer {\n\
+	public static void print() throws Exception {\n\
+		Flos floContainer = new Flos();\n\
+		Field[] flos = floContainer.getClass().getFields();\n\
+\n\
+		for(Field flo : flos) {\n\
+			System.out.println(flo.getName() + \": \" + flo.get(floContainer));\n\
+		}\n\
+	}\n\
+}\n";
+void make_printer(void) {
+	FILE *out = fopen("Printer.java", "w");
+	fputs(printer, out);
+	fclose(out);
+	system("javac Printer.java");
+}
+void print_flos(void) {
+	JNIEnv *env;
+	JavaVMInitArgs args;
+	memset(&args, 0, sizeof(JavaVMInitArgs));
+	args.version = JNI_VERSION_1_6;
+	JavaVM *jvm;
+	JNI_CreateJavaVM(&jvm, (void**)&env, &args);
+	jclass printer = (*env)->FindClass(env, "Printer");
+	jmethodID print = (*env)->GetStaticMethodID(env, printer, "print", "()V");
+	(*env)->CallStaticVoidMethod(env, printer, print);
+}
+int main(void) {
+	make_flontainer();
+	make_printer();
+	print_flos();
+	return EXIT_SUCCESS;
+}
+</syntaxhighlight>
 == Fußnoten ==
@@ Zeile 267: / Zeile 572: @@
 Stimmt doch gar nicht! Ist ganz einfach:
-<pre>
+<syntaxhighlight lang="perl">
-map printf("%s = %s\n", [flo0..flo3]->[$_], [dividuum, syb, fiji, flowhase]->[$_]), 0..$#{@{[flo0..flo3]}};
+map printf("%s = %s\n", [flo0..flo5]->[$_], [dividuum, syb, fiji, flowhase, florolf, FlorianJW]->[$_]), 0..$#{@{[flo0..flo5]}};
-</pre>
+</syntaxhighlight>
-(Kommentar von [[Benutzer:Mgr|mgr]]: Genau, "0..$#{@{[flo0..flo3]}}" ... q.e.d. Danke für das gute Beispiel.
+(Kommentar von [[Benutzer:Mgr|mgr]]: Genau, "0..$#{@{[flo0..flo5]}}" ... q.e.d. Danke für das gute Beispiel.
 Aber ernsthaft, es ging hier eben gerade *nicht* um Einzeiler, die will niemand.)
 Und auch in python kann man Einzeiler schreiben:
-<pre>
+<syntaxhighlight lang="python">
-print "\n".join(["%s = %s" % (k, v) for k, v in {"flo0":"dividuum", "flo1":"syb", "flo2":"fiji", "flo3":"flowhase"}.items()])
+print "\n".join(["%s = %s" % (k, v) for k, v in {"flo0":"dividuum", "flo1":"syb", "flo2":"fiji", "flo3":"flowhase","flo4":"florolf", "flo5":"FlorianJW"}.items()])
-</pre>
+</syntaxhighlight>
 [[Kategorie:Wissen]]
 [[Kategorie:Entropia]]