Anregungen und Vorschläge zu PROFAN
Hier können Vorschläge für künftige PROFAN-Versionen, Ausgestaltung der PROFAN-Seiten und -Foren, etc. gemacht werden.

| Suchen
| Zurück zur Übersicht

Autor | Thema: Betatest für Neue PROFAN-Version!
Roland G. Hülsmann
| Datum:17.08.02 16:52 (rgh-soft@t-online.de) |
Codename "PROFAN 7.6ß" ACHTUNG: Das ist nur ein Arbeitstitel! Diese PROFAN-Version ist eher als eine Studie zu betrachten. Es ist weder sicher, dass alle Funktionen im nächsten PROFAN enthalten sein werden, noch dass es tatsächlich vor PROFAN 8.0 (Arbeitstitel "XProfan") noch ein PROFAN 7.6 geben wird! Die Betaversion gibt es im Downloadbereich! Der direkte Link: http://www.profan2.de/download/xprofan.zip Drei Funktionalitäten wurden hinzugefügt: 1. Vererbbare Strukturen 2. Prozeduren als Funktionen (= mehrzeilige Funktionen) 3. SQL: Variable Länge bei Memofeldern u.ä. (inkl. Bugfix) 1. Vererbbare Strukturen Eine Struktur kann Eigenschaften von einer zuvor mit STRUCT definierten Struktur erben, in dem der Name dieser Struktur in der Strukturdefinition verwandt wird. Das heißt: Die Elemente dieser Struktur werden der neuen Struktur hinzugefügt. Natürlich können noch weitere Elemente dieser Struktur hinzugefügt werden, wobei darauf zu achten ist, daß die neuen Elemente andere Namen haben, als die schon vorhandenen. Eine Struktur kann auch mehrere vorhandene Strukturen enthalten. Bestehende bewährte Strukturen können somit genutzt werden, um neue erweiterte Strukturen zu erzeugen. Ein simples Beispiel:
    declare punkt#,linie#
    struct spunkt = x&,y&
    struct slinie = spunkt,dx&,y&

    dim punkt#,spunkt
    dim linie#,slinie

    cls

    punkt#.x& = 10
    punkt#.y& = 20

    with punkt#
      print .x&
      print .y&
    endwith

    linie#.x& = 30
    linie#.y& = 40
    linie#.dx& = 50
    linie#.dy& = 60

    with linie#
      print .x&
      print .y&
      print .dx&
      print .dy&
    endwith

    waitinput

    end
Bei der Definition der Struktur "slinie" wird auf die bereits definierte Struktur "spunkt" zurükgegriffen! Noch eine Überlegung: Man könnte es auch so einrichten, daß Elemente einer Struktur "überschrieben" werden, wenn neue gleichen Namens hinzukommen. Nehmen wir z.B. an, es gäbe eine Struktur sAdresse, in der das Element PLZ$(5) definiert ist. Nun benötigt mn z.B. für die Niederlande eine Adresstruktur mit 6-stelligen Postleitzahlen. Das ginge nun ganz einfach: sstruct sAdresseNL = sAdresse,PLZ$(6) Wie gesagt: In der vorliegenden Version geht es nicht. Es wäre aber eine Überlegung wert, ob so etwas sinnvoll und wünschenswert ist. 2. Prozeduren als Funktionen Das wurde schon lange geforder: Mehrzeilige Funktionen. Jetzt sind sie da: Man kann alle selbst definierten Prozeduren (PROC) auch als Funktionen aufrufen. Der mit RETURN zurückgegebene Wert ist das Ergebnis der Fuktion. Beim Aufruf als Funktion sind die Parameter der Prozedur in Klammern zu setzen. Ein winziges Beispiel:
    cls

    proc test
    parameters x$,x&
      print "Hier ist Test"
      print x$
      print x&
      return 13
    endproc

    test "Peter",999
    print &(0)
    print "Ergebnis: "+Str$(test("Hugo",3))
    print "---"
    print "Und hier danach!"
    waitkey

    end
Naturgemäß hat diese Erweiterung einen tiefgehenden Eingriff in den Parser mit sich gebracht. Hier bitte ich Euch also um besonders kritisches Testen! 3. SQL und Memofelder Zunächst der behobene Bug: In allen (!) bisher existierenden 32-Bit-PROFAN-Versionen wurden MEMO-Felder beim Auslesen nicht wie unter 16 Bit nach dm 50. Zeichen angeschnitten, sondern schon nach dem 8. Zeichen. Da dies erst in den letzten Wochen einem Programmierer aufgefallen ist, habe ich erst jetzt danach gesucht und bei dieser Gegelegenheit neben der Behebung eine Erweiterung eingebaut: MEMO-felder in dBase-Dateien werden unter SQL als "LongVarChar" behandelt. Mit der Funktion SET("SQLWidth",N%) kann die beim Auslesen genutzte Länge nun nahezu beliebig (max. 65535) eingestellt werden. Auf Eure Meinungen zu diesen Erweiterungen bin ich sehr gespannt! Gruß Roland
Sven Schneider
| Datum:17.08.02 23:02 (sv.sch@freenet.de) |
Hallo, die neuen Erweiterungen finde ich wirklich gut, besonders die mehrzeiligen Funktionen. Ich hoffe, dass sie auch in die nächste Version übernommen werden! Ich habe mal ein bisschen mit den neuen mehrzeiligen Funktionen herumprobiert. Bei folgendem Code ist das Ergebnis beim ersten Aufruf (als Funktion) falsch, beim zweiten (als Prozedur) jedoch richtig. Sven PS: Gibt es eigentlich schon einen ungefähren Zeitplan, wann die nächste Profan-Version erscheinen soll? --- Code Anfang --- Cls Decimals 0 Proc test Print "Prozedur test" Return 2+5 EndProc Proc test2 Parameters a& Print "Prozedur test2" test Return a& + @&(0) EndProc Print test2(11) 'falsches Ergebnis test2 11 Print %(0) 'richtiges Ergebnis WaitKey --- Code Ende ---
Jörg Sellmeyer
| Datum:18.08.02 11:17 (joerse@gmx.de) |
Hallo, Das hier ist auch lustig. Ist ja ähnlich. Die Funktion schein sich da mit den Parametern zu verschlucken.
    Cls
    Decimals 0
    Declare z&

    Proc ErsteZahl
    Return 1
    EndProc

    Proc ZweiteZahl
    Parameters a&
    Declare b&
    ErsteZahl
    b&=@&(0)
    a&=b& + a&
    print "A& b& &(0) ",a&,b&,&(0)
    Return a&
    EndProc

    Print "ErsteZahl"
    ErsteZahl
    Print @&(0)
    Print ErsteZahl()
    print ""

    Print "ZweiteZahl"
    ZweiteZahl 5
    Print @&(0)
    Print ZweiteZahl(5)
    WaitInput
Gruß Jörg
Jörg Sellmeyer
| Datum:18.08.02 12:10 (joerse@gmx.de) |
Das ist auch seltsam: proc msgbox declare s$ whileloop %pcount s$=s$ + chr$(13) + chr$(10) + @$(&loop) wend messagebox(s$,"Test",0) Endproc msgbox 3,6,"ret",6 msgbox(3,6,"ret",6) Ansonsten finde ich das übrigens sehr vielversprechend !! Gruß Jörg
Jörg Sellmeyer
| Datum:18.08.02 15:14 (joerse@gmx.de) |
Na, da scheint doch noch einiges im Argen zu liegen: Cls Proc zählen Parameters x& WhileLoop 1000 x&=x& + &Loop Wend Return x& EndProc Declare tick& tick&=&gettickcount zählen 1 print "Ergebnis=",&(0) print "Zeit=",&gettickcount - tick& WaitInput tick&=&gettickcount print "Ergebnis=",zählen(1) print "Zeit=",&gettickcount - tick& WaitInput Gruß Jörg
Roland G. Hülsmann
| Datum:18.08.02 16:07 (rgh-soft@t-online.de) |
Hallo, das Problem ist hier der Prozeurname mit Umlaut. Das funktioniert leider nicht. Wenn Du die Prozedur umbenennst, dann klappt es. Ein weiteres Problem tritt (auch in bisherigen PROFAN-Versionen) manchmal auf, wenn Funktionsergebnisse direkt in einem PRINT-Befehl vorkommen; die Funktionen also direkt im PRINT-Befehl stehen. Hier ist es besser, bei numerischen Ergebnissen die Funktion Str$ zu benutzen und mehrere Strings mit "+" zu verbinden. So funktioniert Dein Programm korrekt:
    Cls

    Proc zahlen
      Parameters x&
      WhileLoop 1000
        x&=x& + &Loop
      Wend
      Return x&
    EndProc

    Declare tick&, a$

    tick&=&gettickcount
    zahlen 1
    print "Ergebnis=",&(0)
    print "Zeit=",&gettickcount - tick&

    WaitInput

    tick&=&gettickcount
    print "Ergebnis= " + str$(zahlen(1))
    print "Zeit=",&gettickcount - tick&
    WaitInput
Noch ein Hinweis: Bei Code-Stücken bitte vorher ein "code" in eckigen Klammern setzen und abschließend ein "/code" wieder in eckigen Klammern. Das sieht dann besser aus und Einrückungen bleiben erhalten! Gruß Roland
Jörg Sellmeyer
| Datum:18.08.02 16:16 (joerse@gmx.de) |
...und wie man sieht ist es schneller. Das war es, was ich herausfinden wollte. Wunderbar Jörg
Marcel Pursche
| Datum:18.08.02 16:34 (mp05@metropolis.de) |
Hallo, Ich würde es gut finden wenn man bei den vererbbaren Strukturen auch eine "Vorsilbe" setzen könnte. zum Beispiel so:
    Declare Vertex#
    Struct sVector = x&, y&, z&
    Struct sVertex = sVector(Punkt), sVector(Normale), tu&, tv&

    Dim Vertex#, sVertex

    With Vertex#
     .Punkt.x& = Single(1.0)
     .Punkt.y& = Single(2.0)
     .Punkt.z& = Single(0.0)
     .Normale.x& = Single(0.0)
     .Normale.y& = Single(1.0)
     .Normale.z& = Single(3.0)
     .tu& = Single(0.0)
     .tv& = Single(0.0)
    EndWith

    Dispose Vertex#
Das wäre sehr nützlich bei API-Aufrufen mit verschachtelten Strukturen. Ebenso nützlich wäre es, wenn man Bereichsvariablen-Arrays erstellen könnte z.B. für Tabellen.
Sven Schneider
| Datum:18.08.02 18:09 (sv.sch@freenet.de) |
Hallo, leider funktioniert mein Test-Programm aber auch nicht, wenn ich die Zeile
    Print test2(11) 'falsches Ergebnis
durch
    Print Str$(test2(11))
ersetze. Sven PS: Hier noch einmal der Quellcode mit "code", damit auch die Einrückungen zu sehen sind.
    Cls
    Decimals 0

    Proc test
       Print "Prozedur test"
       Return 2+5
    EndProc

    Proc test2
       Parameters a&
       Print "Prozedur test2"
       test
       Return a& + @&(0)
    EndProc

    Print Str$(test2(11)) 'falsches Ergebnis

    test2 11
    Print %(0)            'richtiges Ergebnis

    WaitKey
Jörg Sellmeyer
| Datum:18.08.02 20:39 (joerse@gmx.de) |
Hallo, Die Verschachtelung solcher Prunktionen oder Frunczeduren scheint nicht zu klappen: Proc Wort1 parameters s$ s$=Translate$(s$,"I","i") Return s$ EndProc Proc Wort2 Parameters w$ Declare a$ WhileLoop Len(w$) a$=Mid$(w$,&Loop,1) + a$ Wort1 a$ 'Wort1(a$) hierbei passiert gar nichts a$=@$(0) Wend Return a$ EndProc print "Vorwärts:",$Syspath Wort2 $Syspath print "Rückwärts:",@$(0) WaitInput print "Rückwärts:",Wort2($Syspath) WaitInput Gruß Jörg
Roland G. Hülsmann
| Datum:19.08.02 09:17 (rgh-soft@t-online.de) |
Hallo Sven, ja, das mit dem @&(0) und Verschachtelung ist noch ein Problem. Da muß ich noch mal schauen ... Wenn Du aber
     test
    Return a& + @&(0)
durch
    Return a& + test()
ersetzt, sollte es gehen. Gruß Roland
Sven Schneider
| Datum:19.08.02 11:25 (sv.sch@freenet.de) |
Hallo, du hast Recht, dann geht's. Komischerweise geht es aber nicht, wenn ich
    test
    Return a& + test()
verwende, obwohl dabei ja kein "@&(0)" vorkommt. Sven
Roland G. Hülsmann
| Datum: 25.08.02 00:43 (rgh-soft@t-online.de) |
Hallo, zunächst mal ein Dank an alle Tester. Ich hoffe die wesentlichen Probleme nun beseitigt zu haben! Die Verschachtelung und die Verwendung von @&(0) sollte klappen und Umlaute in Prozedurnamen sollten auch dann keine Probleme mehr bereiten, wenn die Prozedur als Funktion aufgerufen wird. BTW: Kleingeschriebene Umlaute in Namen von definierten Funktionen machten seit jeher Probleme ... ist nur niemandem aufgefallen, da man normalerweise keine verwendet. Die neue Version gibt es an der bekannten Adresse: http://www.profan2.de/download/xprofan.zip Gruß Roland

| Zurück zur Übersicht

| Ein kostenloses WebMart Forum WebMart Homepage Tools kostenlos |