R-GReQL-Grammatik: Unterschied zwischen den Versionen

Aus JACK Wiki
Zur Navigation springen Zur Suche springen
Keine Bearbeitungszusammenfassung
 
(32 dazwischenliegende Versionen von 2 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
In der Knotenstruktur kommen abstrakte Knoten vor. Das heißt, dass von ihnen keine direkten Instanzen im Graphen vorkommen, bzw. sie nicht instanziierbar sind, sie sind lediglich Oberklassen und dienen zur Vererbung und Knotenhierarchie.
Die Knotenstruktur ist hierarchisch und mittels Vererbung aufgebaut. Sie wurde hier durch die Hierarchie der Überschriften dargestellt. Beispielsweise ist AssignmentOperator die Oberklasse von Left- bzw. RightAssignmentOperator, welche wiederum von den spezifischen Operatoren die Oberklassen sind. Dadurch lassen sich allgemeinere Abfragen erstellen. Will man also beispielsweise wissen, ob ein Zuweisungsoperator (egal welcher) verwendet wird, muss man lediglich einen AssignmentOperator in der GReQL-Anfrage verwenden.
= Knoten =
= Knoten =
In dieser Grammatik sind abstrakte Knoten enthalten. Diese sind nicht instanziierbar und sowohl durch einen Kommentar, als auch durch kursiven Titel kenntlich gemacht.
In dieser Grammatik sind abstrakte Knoten enthalten. Diese sind nicht instanziierbar und <!--sowohl durch einen Kommentar, als auch-->durch kursiven Titel kenntlich gemacht.
== Context ==
# ''<!--[[Context (R-GReQL)|-->Context<!--]]-->''
## [[Prog (R-GReQL)|Prog]]
## [[ParameterList (R-GReQL)|ParameterList]]
## [[FunctionParameterList (R-GReQL)|FunctionParameterList]]
## [[IndexList (R-GReQL)|IndexList]]
## [[DoubleIndexList (R-GReQL)|DoubleIndexList]]
## [[Indexing (R-GReQL)|Indexing]]
## [[NamedElement (R-GReQL)|NamedElement]]
## [[Block (R-GReQL)|Block]]
# ''[[UnaryExpression (R-GReQL)|UnaryExpression]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
## [[Negative (R-GReQL)|Negative]]
## [[Positive (R-GReQL)|Positive]]
# ''[[Element (R-GReQL)|Element]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
## ''[[Literal (R-GReQL)|Literal]]'' <!--<pre>Ist ein abstrakter Knoten. Die folgenden Literale besitzen jeweils das Attribut "''value''", in dem der Wert abgespeichert wird.</pre>-->
### [[BooleanLiteral (R-GReQL)|BooleanLiteral]]
### [[ComplexLiteral (R-GReQL)|ComplexLiteral]]
### [[IntegerLiteral (R-GReQL)|IntegerLiteral]]
### [[NumericLiteral (R-GReQL)|NumericLiteral]]
### [[StringLiteral (R-GReQL)|StringLiteral]]
### [[NullLiteral (R-GReQL)|NullLiteral]]
### [[Infinite (R-GReQL)|Infinite]]
### [[NotANumber (R-GReQL)|NotANumber]]
### [[NotAvailable (R-GReQL)|NotAvailable]]
## ''[[ID (R-GReQL)|ID]]'' <!--<pre>Ist ein abstrakter Knoten. &#10;Jeder Funktionsaufruf oder Variable ist in R eine ID. In diesem Checker wurden diese separiert und in zwei verschiedene Knoten unterteilt. Eine ID besitzt ein Atrribut "''name''", welches der [[R-GReQL-Grammatik#FunctionCall|FunctionCall]]- und [[R-GReQL-Grammatik#Variable|Variable]]-Knoten erben.</pre>-->
### [[FunctionCall (R-GReQL)|FunctionCall]]
### [[Variable (R-GReQL)|Variable]]
### ''[[Function (R-GReQL)|Function]]
#### [[AnonFunctionDeclaration (R-GReQL)|AnonFunctionDeclaration]]
#### [[FunctionDeclaration (R-GReQL)|FunctionDeclaration]]
## ''[[Operator (R-GReQL)|Operator]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
### ''[[ArithmeticOperator (R-GReQL)|ArithmeticOperator]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
#### [[AddOperator (R-GReQL)|AddOperator]]
#### [[SubOperator (R-GReQL)|SubOperator]]
#### [[MulOperator (R-GReQL)|MulOperator]]
#### [[DivOperator (R-GReQL)|DivOperator]]
#### [[ExpOperator (R-GReQL)|ExpOperator]]
#### [[RemainderOperator (R-GReQL)|RemainderOperator]]
#### [[FloorOperator (R-GReQL)|FloorOperator]]
### ''[[RelationalOperator (R-GReQL)|RelationalOperator]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
#### [[GreaterOperator (R-GReQL)|GreaterOperator]]
#### [[LesserOperator (R-GReQL)|LesserOperator]]
#### [[GreaterEqOperator (R-GReQL)|GreaterEqOperator]]
#### [[LesserEqOperator (R-GReQL)|LesserEqOperator]]
#### [[EqualOperator (R-GReQL)|EqualOperator]]
#### [[UnequalOperator (R-GReQL)|UnequalOperator]]
#### [[InOperator (R-GReQL)|InOperator]]
### ''[[LogicalOperator (R-GReQL)|LogicalOperator]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
#### [[AndOperator (R-GReQL)|AndOperator]]
#### [[OrOperator (R-GReQL)|OrOperator]]
#### [[NotOperator (R-GReQL)|NotOperator]]
#### [[AndOperatorFirstElement (R-GReQL)|AndOperatorFirstElement]]
#### [[OrOperatorFirstElement (R-GReQL)|OrOperatorFirstElement]]
### ''[[AssignmentOperator (R-GReQL)|AssignmentOperator]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
#### ''[[LeftAssignmentOperator (R-GReQL)|LeftAssignmentOperator]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
##### [[LeftAssignmentOperator1 (R-GReQL)|LeftAssignmentOperator1]]
##### [[LeftAssignmentOperator2 (R-GReQL)|LeftAssignmentOperator2]]
##### [[LeftAssignmentOperator3 (R-GReQL)|LeftAssignmentOperator3]]
##### [[LeftAssignmentOperator4 (R-GReQL)|LeftAssignmentOperator4]]
#### ''[[RightAssignmentOperator (R-GReQL)|RightAssignmentOperator]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
##### [[RightAssignmentOperator1 (R-GReQL)|RightAssignmentOperator1]]
##### [[RightAssignmentOperator2 (R-GReQL)|RightAssignmentOperator2]]
### ''[[MiscOperator (R-GReQL)|MiscOperator]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
#### [[SequenceOperator (R-GReQL)|SequenceOperator]]
<!--#### <s>[[ContainsOperator (R-GReQL)|]]</s>-->
#### [[MatrixMulOperator (R-GReQL)|MatrixMulOperator]]
#### [[TildeOperator (R-GReQL)|TildeOperator]]
## ''[[Statement (R-GReQL)|Statement]]'' <!--<pre>Ist ein abstrakter Knoten.</pre>-->
### [[IfStatement (R-GReQL)|IfStatement]]
### [[SwitchStatement (R-GReQL)|SwitchStatement]]
### ''[[Loop (R-GReQL)|Loop]]''
#### [[WhileStatement (R-GReQL)|WhileStatement]]
#### [[RepeatStatement (R-GReQL)|RepeatStatement]]
#### [[ForStatement (R-GReQL)|ForStatement]]
### [[BreakStatement (R-GReQL)|BreakStatement]]
### [[NextStatement (R-GReQL)|NextStatement]]


=== Prog ===
<!--####<s>[[ReturnStatement (R-GReQL)|ReturnStatement]]</s>-->
 
[[Datei:1ParameterList_Prog.png|mini|250px|<code>x <- c(5,6)</code>]]
Prog stellt den Wurzelknoten jeder R-Datei dar. (blau)
 
=== ParameterList ===
Ist der Wurzelknoten für Parameter einer aufgerufenen Funktion. (rot)
 
=== AnonParameterList ===
[[Datei:2AnonParameterList.png|mini|250px|hochkant|<code>var <- (function (x) x + 3) (10)</code>]]
Ist die Parameter-Liste, die bei einer anonymen Funktion verwendet wird, z.B.
 
<code> var <- (function <u>(x)</u> x + 3)(10)</code>
 
=== IndexList ===
Ist der Oberknoten der Liste der verwendeteten Indizes durch Angabe einer eckigen Klammer, z.B.
 
<code> y <- array[1] </code>
 
=== DoubleIndexList ===
Ist der Oberknoten der Liste der verwendeteten Indizes durch Angabe von zwei eckigen Klammern, z.B.
 
<code> z <- otherarray[[2]] </code>
 
=== Indexing ===
 
Ist ein Zwischenknoten für die Indexierung ([[R-GReQL-Grammatik#IndexList|IndexList]], [[R-GReQL-Grammatik#DoubleIndexList|DoubleIndexList]])
 
== ''UnaryExpression'' ==
 
Ist ein abstrakter Knoten.
 
=== Negative ===
Ist der "-"-Operator vor einer Zahl, Variable oder Expression, z.B.
 
<code>var <- -(x + -3)</code>
 
=== Positive ===
Ist der "+"-Operator vor einer Zahl, Variable oder Expression, z.B.
 
<code>var <- +5</code>
 
== ''Element'' ==
Ist ein abstrakter Knoten.
=== ''Literal'' ===
Ist ein abstrakter Knoten. Die folgenden Literale besitzen jeweils das Attribut "''value''", in dem der Wert abgespeichert wird.
==== BooleanLiteral ====
Stellt den boolischen Wert ''TRUE'' bzw. ''FALSE'' dar.
==== ComplexLiteral ====
Stellt eine komplexe Zahl, z.B. ''3i'', dar.
==== IntegerLiteral ====
Stellt einen Integerwert, z.B. ''10L'', dar.
==== NumericLiteral ====
Stellt eine Gleitkommazahl, z.B. ''12.45'', dar.
==== StringLiteral ====
Stellt eine Zeichenkette, z.B. ''"Hello World!" oder ' ''Hello World!'' ', dar.
 
==== NullLiteral ====
 
=== ID ===
 
==== FunctionCall ====
 
==== Variable ====
 
=== Operator ===
 
==== ArithmeticOperator ====
 
===== AddOperator =====
 
===== SubOperator =====
 
===== MulOperator =====
 
===== DivOperator =====
 
===== ExpOperator =====
 
===== RemainderOperator =====
 
===== FloorOperator =====
 
==== RelationalOperator ====
 
===== GreaterOperator =====
 
===== LesserOperator =====
 
===== GreaterEqOperator =====
 
===== LesserEqOperator =====
 
===== EqualOperator =====
 
===== UnequalOperator =====
 
===== InOperator =====
 
==== LogicalOperator ====
 
===== AndOperator =====
 
===== OrOperator =====
 
===== NotOperator =====
 
===== AndOperatorFirstElement =====
 
===== OrOperatorFirstElement =====
 
==== AssignmentOperator ====
 
===== LeftAssignmentOperator =====
 
====== LeftAssignmentOperator1 ======
 
====== LeftAssignmentOperator2 ======
 
====== LeftAssignmentOperator3 ======
 
====== LeftAssignmentOperator4 ======
 
===== RightAssignmentOperator =====
 
====== RightAssignmentOperator1 ======
 
====== RightAssignmentOperator2 ======
 
==== MiscOperator ====
 
===== SequenceOperator =====
 
===== <s>ContainsOperator</s> =====
 
===== MatrixMulOperator =====
 
===== TildeOperator =====
 
=== Statement ===
 
==== Block ====
 
==== IfStatement ====
 
==== SwitchStatement ====
 
==== Loop ====
 
===== WhileStatement =====
 
===== RepeatStatement =====
 
===== ForStatement =====
 
==== BreakStatement ====
 
==== NextStatement ====
 
==== Unsortiert ====
 
===== AnonFunctionDeclaration =====
 
===== NamedElement =====
 
===== <s>FunctionDeclaration</s> =====
 
===== <s>ReturnStatement</s> =====


= Kanten =
= Kanten =
Im Folgenden werden alle Kanten beschrieben, sortiert nach den Knoten von denen sie ausgehen. Dort, wo keine eigene Kante vergeben wurde, wird eine "UniversalEdge" verwendet.
# AssignmentOperator
## [[LeftHandSide (R-GReQL)|LeftHandSide]]
## [[RightHandSide (R-GReQL)|RightHandSide]]
# Block
## [[BodyStatement (R-GReQL)|BodyStatement]]
# Context
## [[Index (R-GReQL)|Index]]
# ForStatement
## [[CountVariable (R-GReQL)|CountVariable]]
## [[Set (R-GReQL)|Set]]
## [[SetVariable (R-GReQL)|SetVariable]]
# ''Function''
## [[Body (R-GReQL)|Body]]
# ''ID''
## [[List (R-GReQL)|List]]
# IfStatement
## [[ElseBody  (R-GReQL)|ElseBody ]]
## [[ThenBody (R-GReQL)|ThenBody]]
# Node
## [[Expression (R-GReQL)|Expression]]
# ParameterList
## [[Parameter (R-GReQL)|Parameter]]
# Prog
## [[ProgStatement (R-GReQL)|ProgStatement]]
# Statement
## [[Condition  (R-GReQL)|Condition ]]
## [[StatementBody (R-GReQL)|StatementBody]]


== AssignmentOperator ==
==Tools==
 
[[Media:GReQL-Referencecard.pdf|GReQL-Referencecard]]
=== LeftHandSide ===
 
=== RightHandSide ===
 
== Block ==
 
=== BodyStatements ===
 
== ForStatement ==


=== CountVariable ===
= Letzte Änderungen =


=== Set ===
== 02.10.2018 ==


=== SetVariable ===
GReQL-Referencecard hinzugefügt


== FunctionCall ==
== 30.06.2017 ==
'''Umbenennungen'''


=== List ===
ProgStatements => ProgStatement


== IfStatement ==
BodyStatements => BodyStatement


=== Condition ===
AnonParameterList => FunctionParameterList


=== ElseBody ===
'''Neu'''


=== ThenBody ===
Abstrakte Klasse ''Function'' eingefügt, erbt von ID


== Node ==
Infinite, NotANumber, NotAvailable-Knoten, jeweils Unterklasse von Literal


=== Expression ===
FunctionDeclaration, Unterklasse von Function


== ParameterList ==
'''sonst. Änderungen'''


=== Parameter ===
AnonFunctionDeclaration von Unsortiert nach Function verschoben


== Prog ==
NamedElement von Unsortiert nach Context verschoben


=== ProgStatements ===
Block von Statement nach Context verschoben


== Statement ==
Bei Eingabe von 'NULL' wird ein NullLiteral gesetzt


=== StatementBody ===
[[Category:R-GReQL]]

Aktuelle Version vom 4. Dezember 2018, 16:16 Uhr

In der Knotenstruktur kommen abstrakte Knoten vor. Das heißt, dass von ihnen keine direkten Instanzen im Graphen vorkommen, bzw. sie nicht instanziierbar sind, sie sind lediglich Oberklassen und dienen zur Vererbung und Knotenhierarchie. Die Knotenstruktur ist hierarchisch und mittels Vererbung aufgebaut. Sie wurde hier durch die Hierarchie der Überschriften dargestellt. Beispielsweise ist AssignmentOperator die Oberklasse von Left- bzw. RightAssignmentOperator, welche wiederum von den spezifischen Operatoren die Oberklassen sind. Dadurch lassen sich allgemeinere Abfragen erstellen. Will man also beispielsweise wissen, ob ein Zuweisungsoperator (egal welcher) verwendet wird, muss man lediglich einen AssignmentOperator in der GReQL-Anfrage verwenden.

Knoten

In dieser Grammatik sind abstrakte Knoten enthalten. Diese sind nicht instanziierbar und durch kursiven Titel kenntlich gemacht.

  1. Context
    1. Prog
    2. ParameterList
    3. FunctionParameterList
    4. IndexList
    5. DoubleIndexList
    6. Indexing
    7. NamedElement
    8. Block
  2. UnaryExpression
    1. Negative
    2. Positive
  3. Element
    1. Literal
      1. BooleanLiteral
      2. ComplexLiteral
      3. IntegerLiteral
      4. NumericLiteral
      5. StringLiteral
      6. NullLiteral
      7. Infinite
      8. NotANumber
      9. NotAvailable
    2. ID
      1. FunctionCall
      2. Variable
      3. Function
        1. AnonFunctionDeclaration
        2. FunctionDeclaration
    3. Operator
      1. ArithmeticOperator
        1. AddOperator
        2. SubOperator
        3. MulOperator
        4. DivOperator
        5. ExpOperator
        6. RemainderOperator
        7. FloorOperator
      2. RelationalOperator
        1. GreaterOperator
        2. LesserOperator
        3. GreaterEqOperator
        4. LesserEqOperator
        5. EqualOperator
        6. UnequalOperator
        7. InOperator
      3. LogicalOperator
        1. AndOperator
        2. OrOperator
        3. NotOperator
        4. AndOperatorFirstElement
        5. OrOperatorFirstElement
      4. AssignmentOperator
        1. LeftAssignmentOperator
          1. LeftAssignmentOperator1
          2. LeftAssignmentOperator2
          3. LeftAssignmentOperator3
          4. LeftAssignmentOperator4
        2. RightAssignmentOperator
          1. RightAssignmentOperator1
          2. RightAssignmentOperator2
      5. MiscOperator
        1. SequenceOperator
        2. MatrixMulOperator
        3. TildeOperator
    4. Statement
      1. IfStatement
      2. SwitchStatement
      3. Loop
        1. WhileStatement
        2. RepeatStatement
        3. ForStatement
      4. BreakStatement
      5. NextStatement


Kanten

Im Folgenden werden alle Kanten beschrieben, sortiert nach den Knoten von denen sie ausgehen. Dort, wo keine eigene Kante vergeben wurde, wird eine "UniversalEdge" verwendet.

  1. AssignmentOperator
    1. LeftHandSide
    2. RightHandSide
  2. Block
    1. BodyStatement
  3. Context
    1. Index
  4. ForStatement
    1. CountVariable
    2. Set
    3. SetVariable
  5. Function
    1. Body
  6. ID
    1. List
  7. IfStatement
    1. ElseBody
    2. ThenBody
  8. Node
    1. Expression
  9. ParameterList
    1. Parameter
  10. Prog
    1. ProgStatement
  11. Statement
    1. Condition
    2. StatementBody

Tools

GReQL-Referencecard

Letzte Änderungen

02.10.2018

GReQL-Referencecard hinzugefügt

30.06.2017

Umbenennungen

ProgStatements => ProgStatement

BodyStatements => BodyStatement

AnonParameterList => FunctionParameterList

Neu

Abstrakte Klasse Function eingefügt, erbt von ID

Infinite, NotANumber, NotAvailable-Knoten, jeweils Unterklasse von Literal

FunctionDeclaration, Unterklasse von Function

sonst. Änderungen

AnonFunctionDeclaration von Unsortiert nach Function verschoben

NamedElement von Unsortiert nach Context verschoben

Block von Statement nach Context verschoben

Bei Eingabe von 'NULL' wird ein NullLiteral gesetzt

Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=R-GReQL-Grammatik&oldid=4468“