Quelltext der Seite Luna (Programmiersprache)


{{Infobox Programmiersprache
| Name                         = Luna
| Logo                         = [[Datei:Luna-AVR-Logo.png|130px|Luna-Logo]]
| Beschreibung                 = Luna-Logo
| Paradigma                    = Multiparadigmen ([[Imperative Programmierung|imperativ]], [[Objektorientierte Programmierung|objektorientiert]], [[Prozedurale Programmierung|prozedural]], [[Strukturierte Programmierung|strukturiert]], [[Funktionale Programmierung|funktional]])
| Erscheinungsjahr             = 2011
| Entwickler                   = Richard-Gordon Faika († Januar 2022)<ref>[https://www.mikrocontroller.net/articles/LunaAVR lunaAVR] auf mikrocontroller.net</ref>
| AktuelleVersion              = 2018.r1
| AktuelleVersionFreigabeDatum = {{FormatDate|2018-02-13}}
| AktuelleVorabVersion         = 
| AktuelleVorabVersionFreigabeDatum = 
| Typisierung                  = [[Statische Typisierung]] (static typing)
| Standardisierungen           = 
| Beeinflusst_von              = [[Xojo]], [[Pascal (Programmiersprache)|Pascal]], [[C++]], [[GFA-Basic]]
| Website                      = [https://avr.myluna.de/ avr.myluna.de]
}}
'''Luna''' ({{laS}} für ''Mond'') ist eine imperative, funktionale und objektbasierte [[Programmiersprache]] mit [[Visuelle Programmierumgebung|visueller Entwicklungsumgebung]] für [[Linux]], [[Mac OS&nbsp;X]] und [[Microsoft Windows|Windows]]. Sie unterstützt [[Imperative Programmierung|imperative]], [[Strukturierte Programmierung|strukturierte]], [[Funktionale Programmierung|funktionale]] und [[Objektorientierte Programmierung|objektbasierte]] Programmierung. Die Sprache wird nicht mehr aktiv weiter entwickelt.

== Implementierungen ==
Es existiert eine Implementierung für [[Mikrocontroller]] der [[Atmel AVR|AVR-Architektur]].

== Eigenschaften ==
=== Sprachdesign ===
Die Sprache Luna besteht aus relativ wenigen Schlüsselwörtern („Sprachkern“); ihre eigentliche Funktionalität erhält sie – ähnlich wie auch die Sprachen C/C++ – durch die Standardbibliotheken sowie, je nach Einsatzgebiet, zusätzliche Bibliotheken und Frameworks. Luna legt einen Schwerpunkt auf die Sprachmittel zur Entwicklung von Bibliotheken.

Eine der Stärken von Luna ist die Kombinierbarkeit von effizienter, maschinennaher Programmierung mit mächtigen Sprachmitteln, die einfache bis komplexe Implementierungsdetails zusammenfassen und weitgehend hinter abstrakten Befehlsfolgen verbergen. Dabei kommt vor allem die [[C++-Metaprogrammierung|Template-Metaprogrammierung wie in C++]] zum Zuge, eine Technik, die eine nahezu kompromisslose Verbindung von Effizienz und Abstraktion erlaubt.

==== Ressourcenverwaltung ====
Es ist vorgesehen, Speicher manuell zu verwalten und im Hinblick auf die maschinennahe Programmierung direkt auf Speicherbereiche zuzugreifen. Luna besitzt jedoch parallel eine auf hohe Effizienz ausgelegte, integrierte, automatische, generationelle [[Garbage-Collection|Speicherbereinigung (Garbage Collection)]]. In der Praxis ist die Lebensdauer von Objekten meist sehr unterschiedlich. Auf der einen Seite existieren Objekte, die die gesamte Laufzeit der Applikation überleben. Auf der anderen Seite gibt es eine große Menge von Objekten, die nur temporär für die Durchführung einer einzelnen Aufgabe benötigt werden. Mit jeder Anwendung des Freigabe-Algorithmus werden langlebige Objekte in eine höhere Generation verschoben. Der Vorteil liegt darin, dass die Speicherbereinigung für niedrige Generationen häufiger und schneller durchgeführt werden kann, da nur ein Teil der Objekte verschoben und deren Zeiger verändert werden müssen. Höhere Generationen enthalten mit hoher Wahrscheinlichkeit nur lebende (bzw. sehr wenige tote) Objekte und müssen deshalb seltener bereinigt werden. Die Besonderheit des in Luna implementierten Algorithmus ist, dass er keine Zähler für die Lebensdauer der einzelnen Objekte benötigt und alle Objekte Rückwärtsreferenzen aufweisen. Die Rückwärtsreferenzen erlauben es „tote“ Speicher-Objekte und fehlerhafte Objektvariablen zu erkennen.

== Entwicklungsumgebung ==
Die gesamte Luna Entwicklungsumgebung „Luna Studio“ besteht aus einer integrierten Entwicklungsumgebung (IDE), einem [[Makroprozessor|Präprozessor (Makroprozessor)]], [[Cross-Compiler|Compiler und Assembler]]. Programme können wahlweise in der IDE oder in einem normalen Texteditor geschrieben werden. Die IDE bietet hierbei zusätzlich zu den allgemein wünschenswerten Funktionen wie Syntaxfärbung, automatischer Einrückung, Code-Strukturierung und Autovervollständigen, eine direkte Unterstützung der einzelnen Atmel-AVR-Controller. Zusätzlich sind ein mächtiger Bibliothekseditor, Verzeichnis der Controller-Defines, eine GUI für [[AvrDude]] und zahlreiche, weitere nützliche Werkzeuge vorhanden.

== Zielarchitektur ==
Der Cross-Compiler/Assembler sowie die Entwicklungsumgebung unterstützen die Mikrocontroller der [[Atmel AVR|AVR-Architektur]] der Firma [[Atmel]]. Dies umfasst die Controllerfamilien Attiny, Atmega und Atxmega.

== Sprachmerkmale im Detail ==
Die Syntax lehnt sich im Wesentlichen an die Programmiersprachen [[Xojo]] (ehemals RealBasic) und [[Pascal (Programmiersprache)|Pascal]] an, was besonders Anfängern den Einstieg in Luna erleichtert. Weiterhin ist Luna von [[C++]] beeinflusst und implementiert zahlreiche Operatoren und Direktiven.

=== Definitionen/Aliase ===
Mit Definitionen können Befehle, Befehlskombinationen oder Ausdrücke im Sinne eines Alias mit einem Bezeichner verknüpft werden. Der Bezeichner kann dann wiederum im Sourcecode so genutzt werden, als würde es sich um den zugewiesenen Ausdruck handeln. Anstelle des Platzhalter setzt der Compiler die dem Namen zugewiesenen Ausdruck während des Kompiliervorgangs automatisch ein. Dies schließt auch die aus C/C++ bekannten sog. Define-Funktionen (Makro-Funktionen) ein. D.&nbsp;h., es kann ein virtueller Funktionsname anstatt eines Ausdrucks verwendet werden. Die Parameter werden dann durch Textersetzung in Ausdruck rechts eingesetzt.

Zugehörige Befehle:

* #define ''Name'' as ''Ausdruck''
* #undef ''Name''

=== Strukturen ===
Strukturen fassen Datentypen und/oder Datenobjekte unter einem Namen statisch zusammenfassen. Strukturen können hierbei verschachtelt genutzt werden.
<syntaxhighlight lang="delphi">
// Struktur deklarieren
struct point
  byte x
  byte y
endstruct

dim a(3) as point  // Array mit 4 Elementen des Typs "point" dimensionieren

a(0).x = 1
a(0).y = 20
a(1).x = 23
a(1).y = 42
</syntaxhighlight>
=== Mengen ===
Mengen sind spezielle Ausdrücke, die eine Sammlung von konstanten Werten zusammenfassen und das Verwalten oder Zuweisen von Datensammlungen erleichtern (z.&nbsp;B. eine Liste von Zahlen und Texten). Eine Menge steht im Quelltext innerhalb geschweifter Klammern {…}. Wenn als Basis eine Strukturdeklaration zugrunde liegt, können innerhalb einer Menge weitere Untermengen eingebettet sein.
<syntaxhighlight lang="delphi">

struct mystruct
  byte   myarray(2)
  word   level
  string text[14]
endstruct

data table
  mystruct{ { 1, 2 ,3 }, 4, "hallo" } 'Text wird auf die in der Strukturdeklaration
  mystruct{ { 5, 6 ,7 }, 8, "ballo" } 'definierten Länge von "text" mit Leerzeichen aufgefüllt.
enddata
</syntaxhighlight>

=== Numerische Datentypen ===
Byte, Uint8, Integer, Int16, Word, Uint16, Long, Uint32, LongInt, Int32, Single, Float
=== Objekt-Datentypen ===
String, MemoryBlock, Graphics, sPtr, dPtr, ePtr

Zusätzlich ist es möglich eigene Objekte (Klassen) zu programmieren, die sich wie Objekt-Datentypen verhalten.
=== Methoden ===
Methoden können mit den Schlüsselwörtern <code>procedure</code> und <code>function</code> erzeugt werden. Funktionen liefern im Gegensatz zu Prozeduren einen Rückgabewert. Weiterhin werden unterstützt:

* [[Überladen]]
* [[Parameter-Zuweisung]]
* [[Parameter-Initialwert]]
* [[Inline-Ersetzung]]

<syntaxhighlight lang="delphi">
 function probe(zahl1 as integer, zahl2 as integer) as longint
   dim zahl3 as longint
   zahl3 = zahl1 * zahl2 + 10
   if zahl3 > 128000 then
     zahl3 /= 64
   end if
   return zahl3
 endfunc
</syntaxhighlight>

=== Klassen ===
In Luna lassen sich Klassen definieren, mit denen Funktionen im Sinne eines Moduls oder einer in sich geschlossenen Bibliothek nachgerüstet werden können. Sie sind ähnlich den [[Unit (Programmiersprache Pascal)|Units]] in Pascal implementiert.
<syntaxhighlight lang="delphi">
// Deklaration
Class test
  const Version = "1.0"
  dim a as byte
  Procedure Init()
    print "Initialisierung"
    print "a = "+str(a)
  EndProc
  Function GetData(x as byte, y as byte) as single
    mul y,4
    y=y+x
    return tabelle.SingleValue(y)
  EndFunc
  data tabelle
    .dw &h1234,&h5678,&h9aab
    .dw &h1234,&h5678,&h9aab
    .dw &h1234,&h5678,&h9aab
    .dw &h1234,&h5678,&h9aab
  enddata
EndClass
</syntaxhighlight>

Der Aufruf im Programmtext sähe folgendermaßen aus:
<syntaxhighlight lang="delphi">
 print test.Version       // Ausgabe
 test.Init()              // Procedure aufrufen
 var = test.GetData(0,2)  // Funktion aufrufen
 test.a=123               // Wert zuweisen
 print str(test.a)        // Wert lesen und ausgeben
</syntaxhighlight>

=== Inline-Assembler ===
In den Programmtext kann [[Assemblersprache|Assemblercode]] eingebettet werden, womit laufzeitkritische Bereiche optimiert werden können.

 asm
   ldi  _HA0,0x2a
   ldi  _HB0,0x09
   call _MathMul8u
 endasm

=== Beispielcode ===
Das klassische [[Hallo-Welt-Programm]] sieht wie folgt aus:

<syntaxhighlight lang="delphi">
 avr.device = atmega168
 avr.clock  = 8000000
 avr.stack = 32

 uart.baud = 19200
 uart.rxd.enable
 uart.txd.enable

 print "Hallo Welt!"

 do
 loop
</syntaxhighlight>

Beispiel für eine [[Rekursion]]:
<syntaxhighlight lang="delphi">
 function factorial(n as longint) as longint
   if n = 0 then
     return 1
   else
     return n * factorial(n - 1)
   end if
 endfunc
</syntaxhighlight>

[[Datei:Luna-AVR-Screenshot-2013r4.jpg|mini|Luna-AVR-IDE]]

== Weblinks ==
* [https://avr.myluna.de/ avr.myluna.de] – offizielle Website (englisch, deutsch)
* [https://avr.myluna.de/doku.php?id=de:unterstuetzte_controller Liste der unterstützten AVR-Mikrocontroller]
* [http://forum.myluna.de/ forum.myluna.de] – offizielles Nutzer- und Entwickler-Forum (englisch und deutsch)

== Einzelnachweise ==
<references />

[[Kategorie:Programmiersprache]]