Angepinnt Bas.Edit der Basic Editor unter Windows !


  • Schlowski
  • 34594 Aufrufe 157 Antworten

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Schlowski schrieb:

    Kleine Anekdote: Genau das von Dir gewünschte Feature des ' Kommentars nur für den Editor hatte ich ursprünglich, bis mich ein Anwender von Exbasic darauf hinwies, dass ich ihm seinen Source verstümmel...

    Machs doch einstellbar.

    Hier übrigens mal mein Preprozessor, geschrieben in FreeBASIC. Entfernt alle unnötigen Leerzeichen und macht möglichst kurze Zeilennummern.
    (Bitte nicht zu schief ansehen, das ganze ist eigentlich nur ein Hack für mich...)

    Quellcode

    1. dim t as string
    2. dim ta as string
    3. dim tm as string
    4. dim te as string
    5. dim tn as integer
    6. dim linenums(65535) as integer
    7. dim lines(65535) as string
    8. dim lastline as integer
    9. dim posi as integer
    10. dim i as integer
    11. dim j as integer
    12. dim quotescheck as integer
    13. dim quotesbegin as integer
    14. dim quotesend as integer
    15. dim onwith as integer
    16. #define ON_ERROR 0
    17. #define ON_GOTO 1
    18. #define ON_GOSUB 2
    19. open command(1) for input as #1
    20. open command(2) for output as #2
    21. do
    22. posi += 1
    23. do
    24. line input #1,t
    25. t = trim(t)
    26. if left(t,3) = "rem" then t = ""
    27. if left(t,1) = "'" then t = ""
    28. if eof(1) then exit do
    29. loop until len(t) > 0
    30. print posi,t
    31. print "len:";len(t)
    32. 'Zeilennummer holen, wenn vorhanden
    33. if instr(left(t,1),any "0123456789") then
    34. for i = 1 to len(t)
    35. if t[i] = asc(" ") then exit for
    36. next i
    37. 'Zeilennummer holen
    38. linenums(posi) = val(left(t,i))
    39. '''print linenums(posi),
    40. 'Zeile selber holen
    41. lines(posi) = trim(mid(t,i+1))
    42. '''print lines(posi)
    43. else 'Keine Zeilennummer
    44. lines(posi) = t
    45. '''print 0,lines(posi)
    46. end if
    47. loop until eof(1)
    48. lastline = posi
    49. close 1
    50. print "beginne renum"
    51. for posi = 1 to lastline
    52. 'Pruefe auf Anfuehrungszeichen...
    53. quotescheck = 0
    54. t = lines(posi)
    55. 'print posi,t
    56. i = 0
    57. do
    58. i += 1
    59. if mid(t,i,1) = """" then
    60. do
    61. i += 1
    62. if mid(t,i,1) = """" then exit do
    63. if i>len(t) then
    64. print "ERROR: Something wrong with the quotes in:";posi
    65. print "Line:";t
    66. end
    67. end if
    68. loop
    69. end if
    70. if mid(t,i,2) = "on" then
    71. i += 2
    72. onwith = ON_ERROR
    73. for j = i to len(t)
    74. if mid(t,j,4) = "goto" then onwith = ON_GOTO:i = j + 4:exit for
    75. if mid(t,j,5) = "gosub" then onwith = ON_GOSUB:i = j+ 5:exit for
    76. next j
    77. 'Break if we dont have a goto or a gosub
    78. if onwith = ON_ERROR then
    79. print "ERROR: Something wrong with an ON ... GO* in:";posi
    80. print "Line:";t
    81. end
    82. end if
    83. do
    84. ta = trim(left(t,i-1))
    85. for j = i to len(t)
    86. if instr(mid(t,j,1),any "0123456789 ") = 0 then exit for
    87. next j
    88. tm = mid(t,i,j-i)
    89. te = trim(mid(t,j))
    90. ' print "ON:"
    91. ' print ta;"|";tm;"|";te
    92. ' print "i=";i
    93. tn = val(tm)
    94. for j = 1 to lastline
    95. if tn = linenums(j) then exit for
    96. next j
    97. tn = j
    98. t = ta+str(tn)
    99. i = len(t)
    100. t = t + te
    101. j=0
    102. do
    103. if mid(t,i,1) = "," then i +=1:exit do
    104. if mid(t,i,1) = ":" then j = 1:i +=1:exit do
    105. if i > len(t) then j = 1:exit do
    106. i +=1
    107. loop
    108. if j = 1 then exit do
    109. loop
    110. end if
    111. if mid(t,i,4) = "goto" then
    112. i += 4
    113. ta = trim(left(t,i))
    114. for j = i to len(t)
    115. if instr(mid(t,j,1),any "0123456789 ") = 0 then exit for
    116. next j
    117. tm = mid(t,i,j-i)
    118. te = mid(t,j)
    119. tn = val(tm)
    120. ' print "GOTO:"
    121. ' print ta;"|";tm;"|";te
    122. ' print "i=";i
    123. for j = 1 to lastline
    124. if tn = linenums(j) then exit for
    125. next j
    126. tn = j
    127. t = ta+str(tn)
    128. i = len(t)+1
    129. t = t + te
    130. end if
    131. if mid(t,i,4) = "then" then
    132. i += 4
    133. te = trim(mid(t,i))
    134. if instr(left(te,1),any "0123456789") = 1 then
    135. ta = trim(left(t,i))
    136. for j = i to len(t)
    137. if instr(mid(t,j,1),any "0123456789 ") = 0 then exit for
    138. next j
    139. tm = mid(t,i,j-i)
    140. te = mid(t,j)
    141. tn = val(tm)
    142. for j = 1 to lastline
    143. if tn = linenums(j) then exit for
    144. next j
    145. tn = j
    146. t = ta+str(tn)
    147. i = len(t)+1
    148. t = t + te
    149. end if
    150. end if
    151. if mid(t,i,5) = "gosub" then
    152. i += 5
    153. ta = trim(left(t,i))
    154. for j = i to len(t)
    155. if instr(mid(t,j,1),any "0123456789 ") = 0 then exit for
    156. next j
    157. tm = mid(t,i,j-i)
    158. te = mid(t,j)
    159. tn = val(tm)
    160. for j = 1 to lastline
    161. if tn = linenums(j) then exit for
    162. next j
    163. tn = j
    164. t = ta+str(tn)
    165. i = len(t)+1
    166. t = t + te
    167. end if
    168. loop until i >= len(t)
    169. lines(posi) = t
    170. next posi
    171. 'Unnötige Leerzeichen killen
    172. for posi = 1 to lastline
    173. t=lines(posi)
    174. ta = ""
    175. quotescheck = 0
    176. for i = 1 to len(t)
    177. select case mid(t,i,1)
    178. case """"
    179. select case quotescheck
    180. case 0
    181. quotescheck = 1
    182. case 1
    183. quotescheck = 0
    184. end select
    185. case " "
    186. if quotescheck = 0 then continue for
    187. end select
    188. ta = ta + mid(t,i,1)
    189. next i
    190. lines(posi)=ta
    191. next posi
    192. for posi = 1 to lastline-1
    193. print #2,posi;" ";lines(posi)
    194. next posi
    195. if lines(lastline) <> "" then
    196. posi = lastline
    197. print #2,posi;" ";lines(posi)
    198. end if
    199. close 2
    Alles anzeigen
    SELECT signatur FROM dummesprueche WHERE forumsbezug > 0
    0 rows returned.
  • Ja, das sieht so ähnlich aus wie meine erste Inkarnation - die Vergleiche auf "THEN", "GOTO" "GOSUB" kommen mir doch sehr bekannt vor ^^

    Aber wofür ich mir echt einen Klapps auf den Hinterkopf geben sollte: ich hab eine Routine zum Entfernen überflüssiger Leerplätze außerhalb von Strings, die benutze ich für die Umwandlung von Label-Code zurück in den Zeilennummern-Mode. Vor lauter Betriebsblindheit :anonym hab ich nicht daran gedacht, die auch einfach mal vor dem Tokenisieren aufzurufen, das hätte mir manchen Klimmzug erspart... Ich hab das Problem mit dem IF fo= ba zwar jetzt gelöst, aber das wäre natürlich gar nicht nötig gewesen. Naja, man lebt und lernt ...
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • Naja, jetzt hab ich einfach ein paar Prüfungen auf Spaces mehr als unbedingt nötig wäre - aber lieber doppelt als keinmal. Da es nicht zeitkritisch ist, lass ich das mal drin, ansonsten würde ich die ganzen scSkipSpaces(buffer, p) wieder rausnehmen... Allein der Syntax-Check sind jetzt schon 1300 Zeilen Code, da bin ich vorsichtig mit unnötigen Änderungen - if it runs, don't touch it!

    Nochmal zu Deinen ' Kommentaren: Das wirft natürlich ein Problem beim Speichern auf. Im PRG-File sollen die dann ja nicht drin sein, damit der Commodore Interpreter nicht meckert, also müssen die beim "Save PRG" rausfliegen. Damit Du die bei der nächsten Editier-Session noch hast, musst Du den Source also auch noch als PETSCII specichern. Und das nächste mal dann entsprechend die PETSCII-Datei laden. alles machbar, aber so richtig glücklich macht mich das nicht.
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • So, nach den ersten Erfahrungen schnell noch ein Update nachgeschoben, aktuell ist jetzt V1.05.

    Quellcode

    1. - verbesserte Erkennung von Stringausdrücken im Syntax-Check
    2. - verbesserte Erkennung von logischen Ausdrücken (<log>) im Syntax-Check
    3. - überflüssige Leerzeichen nach dem Tokenisieren aber vor dem Syntax-Check entfernt, dadurch nicht mehr anfällig gegen "unerwartete Leerplätze"
    4. - Endlosschleife bei Erkennung gültiger PRINT-Ausdrücke (<print>) behoben
    5. - nach Fehler-Erkennung im Syntax-Check wird jetzt der Cursor an die entsprechende Stelle im Source positioniert
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • Version 1.07 hochgeladen

    Quellcode

    1. - Bugfix, Program crashte wenn minimiert
    2. - Proofreader zugefügt (F8) - ermittelt für jede Zeile die Checksum nach dem ersten Proofreader-Algorithmus aus der Compute
    3. (Alle Zeichen der Zeile außer Leerplätzen werden als ASCII 8 Bit ohne Überlauf aufaddiert, der resultierende 8-Bit-Wert am Ende ist die Prüfsumme)
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • Version 1.10 hochgeladen:

    Quellcode

    1. - nach erfolgreichem Syntax-Check werden jetzt noch alle Sprünge auf Gültigkeit geprüft
    2. - Intelli-Auto eingebaut


    Intelli-Auto bedeutet, dass die Auto-Numbering Funktion jetzt die Zeilen über und unter der einzufügenden Zeile beachtet und eine Zeilennummer dazwischen erzeugt. Also zwischen 10 und 20 automatisch die 15 vergibt, zwischen 15 und 20 dann die 18 usw. Sollte kein Platz mehr sein, werden die nachfolgenden Zeilen, soweit nötig, um 1 nach oben verschoben, dabei werden natürlich alle Sprünge entsprechend angepasst.
    Im Endeffekt bedeutet das, Auto Numbering einmal einschalten und dann Zeilennummern beim Eingeben einfach vergessen, das System kümmert sich um alles!

    @HOL2001: Gute Idee, hab ich mal gemacht!
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • WOW! Das nennt man Fortschritt :)

    Habe vorher immer mit Word und VICE (cut/paste) und manchmal tok64 gearbeitet. Dies gehört jetzt definitiv zur Crossdevelopment toolliste dabei.

    Wenn ich das richtig sehe wird das Font vom Originalen CharROM des Cevi's generiert?

    Wäre eine Simons Basic Token Unterstützung schwierig ein zu binden?
    Gruß, lordbubsy
  • Wenn ich das richtig sehe wird das Font vom Originalen CharROM des Cevi's generiert?

    Jupp, genau, den Font für den VC-20 und den C64 findest Du im fonts-Unterverzeichnis, einstellen, welchen er benutzt kannst Du in der BasEdit.Ini

    Quellcode

    1. ' character ROM file
    2. chargen=fonts\chargen64

    Du kannst auch einen selbstdefinierten Font nehmen, das File muss 2*256 Zeichen a 8 Byte enthalten, bzw. die 4k werden so interpretiert...

    Wäre eine Simons Basic Token Unterstützung schwierig ein zu binden?

    Sollte problemlos möglich sein, Du brauchst nur ein entsprechendes Tokenfile zu erzeugen, siehe beiliegende Samples für diverse Basic-Dialekte.
    Schön kann man das am Beispiel TokenList_BasicV7.txt für das Basic V7 des C128 sehen:

    C-Quellcode

    1. ; Basic V7
    2. #include TokenList_BasicV2.txt
    3. rgr, $CC
    4. rclr, $CD
    5. ...


    d.h. für SimonsBasic benötigts Du sowas wie

    C-Quellcode

    1. ; Simons Basic
    2. #include TokenList_BasicV2.txt
    3. ...ab hier die Tokens von SimonsBasic...


    Leider werde ich aus der Übersicht hier: Basic-Tokens bei SimonsBasic nicht schlau, was sollen die ganzen >> Tokens???
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • Schlowski schrieb:

    Leider werde ich aus der Übersicht hier: Basic-Tokens bei SimonsBasic nicht schlau, was sollen die ganzen >> Tokens???

    Tokens sind Kürzel für BASIC Befehle. BASIC benutz sie um Platz zu sparen und es erhöht die Geschwindigkeit des Interpreter enorm.

    Das BASIC-II des C64 nutz nicht alle Codes für Token. Die "freien" Token werden leider unterschiedlich interpretiert von verschiedenen BASIC Varianten.

    Simos's BASIC nutzt offenbar zwei Byte Tokens. Dadurch schlagen die mehrere Fliegen mit einer Klappe:
    • Die maximale Anzahl neuer befehle erhöht sich auf 256!
    • Es gibt keinerlei Kollisionen mit bestehenden BASIC Dialekten.
    Letztlich ist alles nur Illusion
    Es gibt hier nichts von Bedeutung
  • Schlowski schrieb:

    Jupp, genau, den Font für den VC-20 und den C64 findest Du im fonts-Unterverzeichnis, einstellen, welchen er benutzt kannst Du in der BasEdit.Ini

    Quellcode
    1
    2
    ' character ROM file
    chargen=fonts\chargen64

    Ich hatte es schon gesehen und geändert. Perfekt!

    Schlowski schrieb:

    Leider werde ich aus der Übersicht hier: Basic-Tokens bei SimonsBasic nicht schlau, was sollen die ganzen >> Tokens???


    Ich bin mir da nicht sicher, aber sind die Basic V2.0 und die Simons Basic Anweisungen zusammen nicht mehr als 256, und somit ein zweites Byte benötigen zur Erkennung?

    Edit:
    @Diddl
    Da bestätigst du meine Vermutung.
    Gruß, lordbubsy
  • Hi Diddl, das ist mir schon klar - ansonsten würde mein BasEdit nicht funzen.
    Ich unterstütze bereits 2-Byte Tokens, wie sie z.B. Basic V7 benutzt und sogar 3-Byte-Tokens, wie sie Waterloo Structured Basic benutzt. Das sind quasi 1-Byte-Tokens mit angehängter 2-Byte-Zieladresse für Schleifen, um sofort dahin zu springen statt erst den Basic Quelltext nach der Zeilennummer zu durchsuchen. Also soweit sogut.

    Was mit Kopfzerbrechen bereitet ist folgendes:

    Quellcode

    1. 6428 at(
    2. 6429 until
    3. 642a >>
    4. 642b >>
    5. 642c use
    6. 642d >>
    7. 642e global
    8. 642f >>


    Was soll ich mit 642a, 642b, 642d und 642f anfangen? Was sind das für Befehle? Und von diesen ">>-Befehlen" tauchen noch viel mehr in der Liste auf.
    Ich könnte natürlich ein Tokenfile machen, in dem alle anderen befehle aus der Liste drin sind, aber irggendwie hab ich ein ungutes Gefühl dabei. Es sei den irgendjemand kann bestätigen, dass die ">>-Befehle" einfach nicht implementierte Codes sind.
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • Neue Version 1.11 hochgeladen

    Quellcode

    1. - Fehler bei der Prüfung auf gültige Sprungadressen behoben
    2. - kleine Syntax-Änderung für den RUN Befehl in TokenFile_BasicV2.txt


    Die Syntax-Änderung war nötig, weil außer RUN und RUN 100 auch sowas wie RUN X oder auch RUN 1+X*(2-3+A) gültige Befehle sind. Letztendlich wird alles, was keine Zahl-Konstante ist, als RUN 0 interpretiert. Daher musste ich die Syntax von "c[<num_lit>]" auf "c[<num>]" ändern.
    Achtung: Der Syntax-Check meckert allerdings bei einer Zeile wie 10 RUN X jetzt eine ungültige Sprungadresse an. RUN oder RUN 100 werden natürlich noch korrekt erkannt. Eventuell bau ich dafür nochmal einen workaround, erschien mir jetzt aber nicht so releant wie den ersten Fehler zu beheben...
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • Das Ganze ist viel komplizierter als ich dachte, allein dass RUN <ausdruck> geht wusste ich gar nicht!


    Damit sind vermutlich alle RENUM Implementierungen an die Wand gespielt. Wenn ich mir das Sprungziel errechnen kann, darf so ein Programm nicht mehr neu nummeriert werden. Nur wenn alle Ziele konstant sind ist RENUM ok.
    Letztlich ist alles nur Illusion
    Es gibt hier nichts von Bedeutung
  • Nö, RENUM ist safe, weil nur RUN <constant> tatsächlich zu <constant> springt, RUN <expression> hingegen sprint immer in Zeile 0, egal, was für ein Ausdruck da steht. Scheint mir ein Bug im Interpreter zu sein, anscheinend ist bei der Berechnung des Sprungzieles jenseits von Konstanten irgendwas schiefgelaufen und es kommt immer 0 raus.

    Lustig ist auch Folgendes:

    Quellcode

    1. 10 GOTO100BLABLABLA


    Das springt tatsächlich in Zeile 100 ohne zu meckern.

    Auch sehr schön:

    Quellcode

    1. 10 GOSUB100BLABLABLA:PRINT"WIEDER DA!"
    2. 20 END
    3. 100 PRINT"SUB 100"
    4. 110 RETURN

    Das springt in Zeile 100, printet "SUB100", kommt zurück und printet "WIEDER DA!".

    Solche Konstrukte meckert allerdings mein Syntax-Checker an, ich hoffe, niemand benutzt solchen Dreck :argue

    Ebenfalls im Interpreter erlaubt und von meinem Syntax-Checker auch durchgewunken:

    Quellcode

    1. 10 GOTO100,200,300
    2. 20 GOSUB 100,200,300

    Da wird einfach nur die 100 angesprngen, der Rest wird ignoriert...

    Ich hab jedenfalls eine Menge dazugelernt nach fast 30 Jahren. Allein dafür hat sich das gelohnt.
    Basic V2 Programme unter Windows editieren: BasEdit.NET
  • Schlowski schrieb:

    Quellcode

    1. 10 GOSUB100BLABLABLA:PRINT"WIEDER DA!"

    Also das ist wohl klar ein Bug des v2 BASIC!

    Ich verstehe noch dass er das Sprungziel (100) auswertet und springt. Also mit GOTO könnte es meinetwegen noch ok sein. Aber spätestens beim RETURN würde ich mir ein SYNTAX ERROR erwarten wegen dem BLABLA..

    Naja, Microsoft hat bis heute einen äußerst schlampigen Programierstil. Das scheint schon in den ersten Jahren so gewesen zu sein ... :(
    Letztlich ist alles nur Illusion
    Es gibt hier nichts von Bedeutung
  • Ich denke mal, das ist ein Seiteneffekt von ON X GOSUB 100,200,300 - bei X=1 oder 2 wird dann, sobald die passende Sprungmarke gefunden wurde, einfach zum nächsten : gesprungen und der Rest damit überlesen. Deswegen ist auch ein Konstrukt wie 10 GOTO 100,200,300 erlaubt. Das hat wohl eher mit platzoptimiertem Code wegen zu wenig ROM zu tun als mit Schlamperei, weil die Auswertung nach GOTO/GOSUB immer die gleiche ist, egal ob vorher ein ON X stand oder nicht.
    Nachdem ich jetzt ein paar Tage mit dem Syntax-Check zugebracht habe, muss ich sagen, dass der Basic V2 Interpreter schon ein recht geniales Teil ist, an einigen Befehlsfolgen hab ich mir fast die Zähne ausgebissen und das in einer vergleichsweise bequemen Hochsprache. Der Syntax-Check belegt etwa 1.400 Programmzeilen bei mir... Dafür kann ich den über Tokenfiles und eine Syntaxbeschreibung steuern :)
    Basic V2 Programme unter Windows editieren: BasEdit.NET