R-GReQL-Grammatik: Unterschied zwischen den Versionen

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

Version vom 19. Juni 2017, 10:14 Uhr

Knoten

In dieser Grammatik sind abstrakte Knoten enthalten. Diese sind nicht instanziierbar und sowohl durch einen Kommentar, als auch durch kursiven Titel kenntlich gemacht.

  1. Context
    1. Prog
      1. ParameterList
      2. AnonParameterList
      3. IndexList
      4. DoubleIndexList
      5. Indexing
  2. UnaryExpression
    1. Negative
    2. Positive
  3. Element
    1. Literal
      1. BooleanLiteral
      2. ComplexLiteral
      3. IntegerLiteral
      4. NumericLiteral
      5. StringLiteral
      6. NullLiteral
    2. ID
      1. FunctionCall
      2. Variable
    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. Block
      2. IfStatement
      3. SwitchStatement
      4. Loop
        1. WhileStatement
        2. RepeatStatement
        3. ForStatement
      5. BreakStatement
      6. NextStatement
      7. Unsortiert
        1. AnonFunctionDeclaration
        2. NamedElement
        3. FunctionDeclaration
        4. ReturnStatement

Kanten

  1. AssignmentOperator
    1. LeftHandSide
    2. RightHandSide
  2. Block
    1. BodyStatements
  3. ForStatement
    1. CountVariable
    2. Set
    3. SetVariable
  4. FunctionCall
    1. List
  5. IfStatement
    1. Condition
    2. ElseBody
    3. ThenBody
  6. Node
    1. Expression
  7. ParameterList
    1. Parameter
  8. Prog
    1. ProgStatements
  9. Statement
    1. StatementBody
Abgerufen von „https://wiki.uni-due.de/jack/index.php?title=R-GReQL-Grammatik&oldid=1142“