Просмотр исходного кода

Added and refactored the R frontend to match the current frontend interface

Robin Maisch 4 лет назад
Родитель
Сommit
4ac3433657

+ 39 - 0
jplag.frontend.R/pom.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>de.jplag</groupId>
+        <artifactId>aggregator</artifactId>
+        <version>${revision}</version>
+    </parent>
+    <artifactId>R</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.antlr</groupId>
+            <artifactId>antlr4-runtime</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>de.jplag</groupId>
+            <artifactId>frontend-utils</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.antlr</groupId>
+                <artifactId>antlr4-maven-plugin</artifactId>
+                <version>4.10.1</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>antlr4</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+        </plugins>
+    </build>
+</project>

+ 216 - 0
jplag.frontend.R/src/main/antlr4/de/jplag/R/grammar/R.g4

@@ -0,0 +1,216 @@
+/*
+ [The "BSD licence"]
+ Copyright (c) 2013 Terence Parr
+ All rights reserved.
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/**
+derived from http://svn.r-project.org/R/trunk/src/main/gram.y
+http://cran.r-project.org/doc/manuals/R-lang.html#Parser
+I'm no R genius but this seems to work.
+Requires RFilter.g4 to strip away NL that are really whitespace,
+not end-of-command. See TestR.java
+Usage:
+$ antlr4 R.g4 RFilter.g4
+$ javac *.java
+$ java TestR sample.R
+... prints parse tree ...
+*/
+
+/*
+Modified version of the original in https://github.com/antlr/grammars-v4/blob/master/r/R.g4 so that I can separate the most relevant tokens of R in 
+the JplagRListenter.java file.
+Author of the modification: Antonio Javier Rodriguez Perez
+*/
+
+grammar R;
+
+prog:   (   expr (';'|NL)
+        |   NL
+        )*
+        EOF
+    ;
+
+/*
+expr_or_assign
+    :   expr ('<-'|'='|'<<-') expr_or_assign
+    |   expr
+    ;
+*/
+
+expr:   expr index_statement  // '[[' follows R's yacc grammar
+    |   expr access_package expr
+    |   expr ('$'|'@') expr
+    |   <assoc=right> expr '^' expr
+    |   ('-'|'+') expr
+    |   expr ':' expr
+    |   expr USER_OP expr // anything wrappedin %: '%' .* '%'
+    |   expr ('*'|'/') expr
+    |   expr ('+'|'-') expr
+    |   expr ('>'|'>='|'<'|'<='|'=='|'!=') expr
+    |   '!' expr
+    |   expr ('&'|'&&') expr
+    |   expr ('|'|'||') expr
+    |   '~' expr
+    |   expr '~' expr
+    |   expr assign_value expr
+    |   function_definition                 // define function
+    |   expr function_call                  // call function
+    |   compound_statement
+    |   if_statement
+    |   for_statement
+    |   while_statement
+    |   repeat_statement
+    |   help
+    |   next_statement
+    |   break_statement
+    |   '(' expr ')'
+    |   ID
+    |   constant
+    ;
+
+index_statement : '[[' sublist ']' ']' | '[' sublist ']' ;
+
+access_package: '::'|':::' ;
+
+function_definition: 'function' '(' formlist? ')' expr ;
+
+function_call : '(' sublist ')' ;
+
+constant: constant_number | constant_string | constant_bool | 'NULL' | 'NA' | 'Inf' | 'NaN' ;
+
+constant_number: HEX | INT | FLOAT | COMPLEX ;
+
+constant_string: STRING ;
+
+constant_bool: 'TRUE' | 'FALSE' ;
+
+help: '?' expr ; // get help on expr, usually string or ID
+
+if_statement :  'if' '(' expr ')' expr | 'if' '(' expr ')' expr 'else' expr ;
+
+for_statement : 'for' '(' ID 'in' expr ')' expr ;
+
+while_statement : 'while' '(' expr ')' expr ;
+
+repeat_statement: 'repeat' expr ;
+
+next_statement: 'next' ;
+
+break_statement: 'break' ;
+
+compound_statement: '{' exprlist '}' ;
+
+exprlist
+    :   expr ((';'|NL) expr?)*
+    |
+    ;
+
+formlist : form (',' form)* ;
+
+form:   ID
+    |   assign_func_declaration
+    ;
+
+sublist : sub (',' sub)* ;
+
+sub :   expr
+    |   assign_value_list
+    |
+    ;
+
+assign_value: '<-'|'<<-'|'='|'->'|'->>'|':=';
+
+assign_func_declaration: ID '=' expr | '...' ;
+
+assign_value_list: ID '=' | ID '=' expr | constant_string '=' | constant_string '=' expr | 'NULL' '=' | 'NULL' '=' expr | '...' ;
+
+
+
+HEX :   '0' ('x'|'X') HEXDIGIT+ [Ll]? ;
+
+INT :   DIGIT+ [Ll]? ;
+
+fragment
+HEXDIGIT : ('0'..'9'|'a'..'f'|'A'..'F') ;
+
+FLOAT:  DIGIT+ '.' DIGIT* EXP? [Ll]?
+    |   DIGIT+ EXP? [Ll]?
+    |   '.' DIGIT+ EXP? [Ll]?
+    ;
+
+fragment
+DIGIT:  '0'..'9' ;
+
+fragment
+EXP :   ('E' | 'e') ('+' | '-')? INT ;
+
+COMPLEX
+    :   INT 'i'
+    |   FLOAT 'i'
+    ;
+
+STRING
+    :   '"' ( ESC | ~[\\"] )*? '"'
+    |   '\'' ( ESC | ~[\\'] )*? '\''
+    |   '`' ( ESC | ~[\\'] )*? '`'
+    ;
+fragment
+ESC :   '\\' [abtnfrv"'\\]
+    |   UNICODE_ESCAPE
+    |   HEX_ESCAPE
+    |   OCTAL_ESCAPE
+    ;
+
+fragment
+UNICODE_ESCAPE
+    :   '\\' 'u' HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT
+    |   '\\' 'u' '{' HEXDIGIT HEXDIGIT HEXDIGIT HEXDIGIT '}'
+    ;
+
+fragment
+OCTAL_ESCAPE
+    :   '\\' [0-3] [0-7] [0-7]
+    |   '\\' [0-7] [0-7]
+    |   '\\' [0-7]
+    ;
+
+fragment
+HEX_ESCAPE
+    :   '\\' HEXDIGIT HEXDIGIT?
+    ;
+
+ID  :   '.' (LETTER|'_'|'.') (LETTER|DIGIT|'_'|'.')*
+    |   LETTER (LETTER|DIGIT|'_'|'.')*
+    ;
+    
+fragment LETTER  : [a-zA-Z] ;
+
+USER_OP :   '%' .*? '%' ;
+
+COMMENT :   '#' .*? '\r'? '\n' -> type(NL) ;
+
+// Match both UNIX and Windows newlines
+NL      :   '\r'? '\n' ;
+
+WS      :   [ \t\u000C]+ -> skip ;

+ 83 - 0
jplag.frontend.R/src/main/antlr4/de/jplag/R/grammar/RFilter.g4

@@ -0,0 +1,83 @@
+/*
+ [The "BSD licence"]
+ Copyright (c) 2013 Terence Parr
+ All rights reserved.
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+    derived from this software without specific prior written permission.
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/** Must process R input with this before passing to R.g4; see TestR.java
+    We strip NL inside expressions.
+ */
+
+parser grammar RFilter;
+
+options { tokenVocab=R; }
+
+@members {
+protected int curlies = 0;
+}
+
+// TODO: MAKE THIS GET ONE COMMAND ONLY
+stream : (element|NL|';')* EOF ;
+
+eat :   (NL {((WritableToken)$NL).setChannel(Token.HIDDEN_CHANNEL);})+ ;
+
+element:   op eat?
+    |   atom
+    |   '{' eat? {curlies++;} (element|NL|';')* {curlies--;} '}'
+    |   '(' (element|eat)* ')'
+    |   '[' (element|eat)* ']'
+    |   '[[' (element|eat)* ']' ']'
+    |   'function' eat? '(' (element|eat)* ')' eat?
+    |   'for' eat? '(' (element|eat)* ')' eat?
+    |   'while' eat? '(' (element|eat)* ')' eat?
+    |   'if' eat? '(' (element|eat)* ')' eat?
+    |   'else'
+        {
+        // ``inside a compound expression, a newline before else is discarded,
+        // whereas at the outermost level, the newline terminates the if
+        // construction and a subsequent else causes a syntax error.''
+        /*
+        Works here
+            if (1==0) { print(1) } else { print(2) }
+        and correctly gets error here:
+            if (1==0) { print(1) }
+            else { print(2) }
+        this works too:
+            if (1==0) {
+              if (2==0) print(1)
+              else print(2)
+            }
+        */
+        WritableToken tok = (WritableToken)_input.LT(-2);
+        if (curlies>0&&tok.getType()==NL) tok.setChannel(Token.HIDDEN_CHANNEL);
+        }
+    ;
+
+atom:   'next' | 'break' | ID | STRING | HEX | INT | FLOAT | COMPLEX | 'NULL'
+    |   'NA' | 'Inf' | 'NaN' | 'TRUE' | 'FALSE'
+    ;
+
+op  :   '+'|'-'|'*'|'/'|'^'|'<'|'<='|'>='|'>'|'=='|'!='|'&'|'&&'|USER_OP|
+        'repeat'|'in'|'?'|'!'|'='|':'|'~'|'$'|'@'|'<-'|'->'|'='|'::'|':::'|
+        ','|'...'|'||'| '|'
+    ;

+ 368 - 0
jplag.frontend.R/src/main/java/de/jplag/R/JplagRListener.java

@@ -0,0 +1,368 @@
+package de.jplag.R;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import de.jplag.R.grammar.RFilter;
+import de.jplag.R.grammar.RFilterListener;
+import de.jplag.R.grammar.RListener;
+import de.jplag.R.grammar.RParser;
+
+/*
+ * This class is responsible for implementing the RListener methods generated by ANTLR4 in such a way that every time a
+ * token of the language is recognized, the corresponding "enter" and "exit" methods will be called. If it is an
+ * important token (i.e. it is important to consider it when identifying plagiarisms), then all there is to do is to
+ * call "parser.add" in its corresponding method using its constant. Esta clase se encarga de implementar los métodos
+ * clase RListener que se genera por ANTLR4 de forma que cada vez que se reconozca un Token del lenguaje se entrará en
+ * su "enter<NombredelToken>" y "exit<NombredelToken>" y en caso de ser un token importante (es decir, que sea relevante
+ * considerarlo a la hora de identificar plagio) tan solo tendremos que irnos a su método he implementarlo haciendo un
+ * parser.add o un parser.addEnd (en caso de que sea un exit) con el nombre del token que le hayamos asociado en
+ * RToken.java y RTokenConstants.java .
+ */
+
+public class JplagRListener implements RListener, RFilterListener, RTokenConstants {
+
+    private final RParserAdapter parserAdapter;
+
+    public JplagRListener(RParserAdapter parserAdapter) {
+        this.parserAdapter = parserAdapter;
+    }
+
+    private void transformToken(int targetType, Token token) {
+        parserAdapter.addToken(targetType, token.getLine(), token.getCharPositionInLine() + 1, token.getText().length());
+    }
+
+    @Override
+    public void enterProg(RParser.ProgContext ctx) {
+
+    }
+
+    @Override
+    public void exitProg(RParser.ProgContext ctx) {
+
+    }
+
+    @Override
+    public void enterExpr(RParser.ExprContext ctx) {
+
+    }
+
+    @Override
+    public void exitExpr(RParser.ExprContext ctx) {
+
+    }
+
+    @Override
+    public void enterIndex_statement(RParser.Index_statementContext ctx) {
+        transformToken(INDEX, ctx.getStart());
+    }
+
+    @Override
+    public void exitIndex_statement(RParser.Index_statementContext ctx) {
+
+    }
+
+    @Override
+    public void enterAccess_package(RParser.Access_packageContext ctx) {
+        transformToken(PACKAGE, ctx.getStart());
+    }
+
+    @Override
+    public void exitAccess_package(RParser.Access_packageContext ctx) {
+
+    }
+
+    @Override
+    public void enterFunction_definition(RParser.Function_definitionContext ctx) {
+        transformToken(BEGIN_FUNCTION, ctx.getStart());
+    }
+
+    @Override
+    public void exitFunction_definition(RParser.Function_definitionContext ctx) {
+        transformToken(END_FUNCTION, ctx.getStart());
+    }
+
+    @Override
+    public void enterFunction_call(RParser.Function_callContext ctx) {
+        transformToken(FUNCTION_CALL, ctx.getStart());
+    }
+
+    @Override
+    public void exitFunction_call(RParser.Function_callContext ctx) {
+
+    }
+
+    @Override
+    public void enterConstant(RParser.ConstantContext ctx) {
+
+    }
+
+    @Override
+    public void exitConstant(RParser.ConstantContext ctx) {
+
+    }
+
+    @Override
+    public void enterConstant_number(RParser.Constant_numberContext ctx) {
+        transformToken(NUMBER, ctx.getStart());
+    }
+
+    @Override
+    public void exitConstant_number(RParser.Constant_numberContext ctx) {
+
+    }
+
+    @Override
+    public void enterConstant_string(RParser.Constant_stringContext ctx) {
+        transformToken(STRING, ctx.getStart());
+    }
+
+    @Override
+    public void exitConstant_string(RParser.Constant_stringContext ctx) {
+
+    }
+
+    @Override
+    public void enterConstant_bool(RParser.Constant_boolContext ctx) {
+        transformToken(BOOL, ctx.getStart());
+    }
+
+    @Override
+    public void exitConstant_bool(RParser.Constant_boolContext ctx) {
+
+    }
+
+    @Override
+    public void enterHelp(RParser.HelpContext ctx) {
+        transformToken(HELP, ctx.getStart());
+    }
+
+    @Override
+    public void exitHelp(RParser.HelpContext ctx) {
+
+    }
+
+    @Override
+    public void enterIf_statement(RParser.If_statementContext ctx) {
+        transformToken(IF_BEGIN, ctx.getStart());
+    }
+
+    @Override
+    public void exitIf_statement(RParser.If_statementContext ctx) {
+        transformToken(IF_END, ctx.getStart());
+    }
+
+    @Override
+    public void enterFor_statement(RParser.For_statementContext ctx) {
+        transformToken(FOR_BEGIN, ctx.getStart());
+    }
+
+    @Override
+    public void exitFor_statement(RParser.For_statementContext ctx) {
+        transformToken(FOR_END, ctx.getStart());
+    }
+
+    @Override
+    public void enterWhile_statement(RParser.While_statementContext ctx) {
+        transformToken(WHILE_BEGIN, ctx.getStart());
+    }
+
+    @Override
+    public void exitWhile_statement(RParser.While_statementContext ctx) {
+        transformToken(WHILE_END, ctx.getStart());
+    }
+
+    @Override
+    public void enterRepeat_statement(RParser.Repeat_statementContext ctx) {
+        transformToken(REPEAT_BEGIN, ctx.getStart());
+    }
+
+    @Override
+    public void exitRepeat_statement(RParser.Repeat_statementContext ctx) {
+        transformToken(REPEAT_END, ctx.getStart());
+    }
+
+    @Override
+    public void enterNext_statement(RParser.Next_statementContext ctx) {
+        transformToken(NEXT, ctx.getStart());
+    }
+
+    @Override
+    public void exitNext_statement(RParser.Next_statementContext ctx) {
+
+    }
+
+    @Override
+    public void enterBreak_statement(RParser.Break_statementContext ctx) {
+        transformToken(BREAK, ctx.getStart());
+    }
+
+    @Override
+    public void exitBreak_statement(RParser.Break_statementContext ctx) {
+
+    }
+
+    @Override
+    public void enterCompound_statement(RParser.Compound_statementContext ctx) {
+        transformToken(COMPOUND_BEGIN, ctx.getStart());
+    }
+
+    @Override
+    public void exitCompound_statement(RParser.Compound_statementContext ctx) {
+        transformToken(COMPOUND_END, ctx.getStart());
+    }
+
+    @Override
+    public void enterExprlist(RParser.ExprlistContext ctx) {
+
+    }
+
+    @Override
+    public void exitExprlist(RParser.ExprlistContext ctx) {
+
+    }
+
+    @Override
+    public void enterFormlist(RParser.FormlistContext ctx) {
+
+    }
+
+    @Override
+    public void exitFormlist(RParser.FormlistContext ctx) {
+
+    }
+
+    @Override
+    public void enterForm(RParser.FormContext ctx) {
+
+    }
+
+    @Override
+    public void exitForm(RParser.FormContext ctx) {
+
+    }
+
+    @Override
+    public void enterSublist(RParser.SublistContext ctx) {
+
+    }
+
+    @Override
+    public void exitSublist(RParser.SublistContext ctx) {
+
+    }
+
+    @Override
+    public void enterSub(RParser.SubContext ctx) {
+
+    }
+
+    @Override
+    public void exitSub(RParser.SubContext ctx) {
+
+    }
+
+    @Override
+    public void enterAssign_value(RParser.Assign_valueContext ctx) {
+        transformToken(ASSIGN, ctx.getStart());
+    }
+
+    @Override
+    public void exitAssign_value(RParser.Assign_valueContext ctx) {
+
+    }
+
+    @Override
+    public void enterAssign_func_declaration(RParser.Assign_func_declarationContext ctx) {
+        transformToken(ASSIGN_FUNC, ctx.getStart());
+    }
+
+    @Override
+    public void exitAssign_func_declaration(RParser.Assign_func_declarationContext ctx) {
+
+    }
+
+    @Override
+    public void enterAssign_value_list(RParser.Assign_value_listContext ctx) {
+        transformToken(ASSIGN_LIST, ctx.getStart());
+    }
+
+    @Override
+    public void exitAssign_value_list(RParser.Assign_value_listContext ctx) {
+
+    }
+
+    @Override
+    public void enterStream(RFilter.StreamContext ctx) {
+
+    }
+
+    @Override
+    public void exitStream(RFilter.StreamContext ctx) {
+
+    }
+
+    @Override
+    public void enterEat(RFilter.EatContext ctx) {
+
+    }
+
+    @Override
+    public void exitEat(RFilter.EatContext ctx) {
+
+    }
+
+    @Override
+    public void enterElem(RFilter.ElemContext ctx) {
+
+    }
+
+    @Override
+    public void exitElem(RFilter.ElemContext ctx) {
+
+    }
+
+    @Override
+    public void enterAtom(RFilter.AtomContext ctx) {
+
+    }
+
+    @Override
+    public void exitAtom(RFilter.AtomContext ctx) {
+
+    }
+
+    @Override
+    public void enterOp(RFilter.OpContext ctx) {
+
+    }
+
+    @Override
+    public void exitOp(RFilter.OpContext ctx) {
+
+    }
+
+    @Override
+    public void enterEveryRule(ParserRuleContext ctx) {
+
+    }
+
+    @Override
+    public void exitEveryRule(ParserRuleContext ctx) {
+
+    }
+
+    @Override
+    public void visitTerminal(TerminalNode node) {
+        if (node.getText().equals("=")) {
+            transformToken(ASSIGN, node.getSymbol());
+        }
+    }
+
+    @Override
+    public void visitErrorNode(ErrorNode node) {
+
+    }
+}

+ 68 - 0
jplag.frontend.R/src/main/java/de/jplag/R/Language.java

@@ -0,0 +1,68 @@
+package de.jplag.R;
+
+import java.io.File;
+
+import de.jplag.ErrorConsumer;
+import de.jplag.TokenList;
+
+public class Language implements de.jplag.Language {
+
+    public static final String NAME = "R Parser";
+    public static final String SHORT_NAME = "R";
+    public static final int DEFAULT_MIN_TOKEN_MATCH = 8;
+    private RParserAdapter parserAdapter;
+
+    public Language(ErrorConsumer consumer) {
+        this.parserAdapter = new RParserAdapter(consumer);
+    }
+
+    @Override
+    public String[] suffixes() {
+        return new String[] {".R", ".r"};
+    }
+
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    public String getShortName() {
+        return SHORT_NAME;
+    }
+
+    @Override
+    public int minimumTokenMatch() {
+        return DEFAULT_MIN_TOKEN_MATCH;
+    }
+
+    @Override
+    public TokenList parse(File directory, String[] files) {
+        return parserAdapter.parse(directory, files);
+    }
+
+    @Override
+    public boolean hasErrors() {
+        return parserAdapter.hasErrors();
+    }
+
+    @Override
+    public boolean supportsColumns() {
+        return true;
+    }
+
+    @Override
+    public boolean isPreformatted() {
+        return true;
+    }
+
+    @Override
+    public boolean usesIndex() {
+        return false;
+    }
+
+    @Override
+    public int numberOfTokens() {
+        return RTokenConstants.NUM_DIFF_TOKENS;
+    }
+}

+ 80 - 0
jplag.frontend.R/src/main/java/de/jplag/R/RParserAdapter.java

@@ -0,0 +1,80 @@
+package de.jplag.R;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+
+import de.jplag.AbstractParser;
+import de.jplag.ErrorConsumer;
+import de.jplag.R.grammar.RFilter;
+import de.jplag.R.grammar.RLexer;
+import de.jplag.R.grammar.RParser;
+import de.jplag.TokenList;
+
+/**
+ * This class sets up the lexer and parser generated by ANTLR4, feeds the submissions through them and passes the
+ * selected tokens on to the main program.
+ */
+public class RParserAdapter extends AbstractParser implements RTokenConstants {
+
+    private String currentFile;
+    private TokenList tokens;
+
+    public RParserAdapter(ErrorConsumer errorConsumer) {
+        super(errorConsumer);
+    }
+
+    public TokenList parse(File directory, String[] fileNames) {
+        tokens = new TokenList();
+        errors = 0;
+        for (String fileName : fileNames) {
+            if (!parseFile(directory, fileName)) {
+                errors++;
+            }
+            tokens.addToken(new RToken(FILE_END, fileName, -1, -1, -1));
+        }
+        return tokens;
+    }
+
+    private boolean parseFile(File directory, String fileName) {
+        File file = new File(directory, fileName);
+        try (FileInputStream inputStream = new FileInputStream(file)) {
+            currentFile = fileName;
+
+            // create a lexer, a parser and a buffer between them.
+            RLexer lexer = new RLexer(CharStreams.fromStream(inputStream));
+            CommonTokenStream tokens = new CommonTokenStream(lexer);
+
+            RFilter filter = new RFilter(tokens);
+            filter.stream();
+            tokens.seek(0);
+
+            RParser parser = new RParser(tokens);
+
+            // Create a tree walker and the entry context defined by the parser grammar
+            ParserRuleContext entryContext = parser.prog();
+            ParseTreeWalker treeWalker = new ParseTreeWalker();
+
+            // Walk over the parse tree:
+            for (int i = 0; i < entryContext.getChildCount(); i++) {
+                ParseTree parseTree = entryContext.getChild(i);
+                treeWalker.walk(new JplagRListener(this), parseTree);
+            }
+        } catch (IOException exception) {
+            getErrorConsumer().addError("Parsing Error in '" + fileName + "':" + File.separator + exception);
+            return false;
+        }
+        return true;
+    }
+
+    /* package-private */ void addToken(int type, int line, int start, int end) {
+        tokens.addToken(new RToken(type, currentFile, line, start, end - start));
+
+    }
+}

+ 96 - 0
jplag.frontend.R/src/main/java/de/jplag/R/RToken.java

@@ -0,0 +1,96 @@
+package de.jplag.R;
+
+public class RToken extends de.jplag.Token implements RTokenConstants {
+    private static final long serialVersionUID = 1L;
+    private int line, column, length;
+
+    public RToken(int type, String file, int line, int column, int length) {
+        super(type, file, line, column, length);
+    }
+
+    public int getLine() {
+        return line;
+    }
+
+    public int getColumn() {
+        return column;
+    }
+
+    public int getLength() {
+        return length;
+    }
+
+    public void setLine(int line) {
+        this.line = line;
+    }
+
+    public void setColumn(int column) {
+        this.column = column;
+    }
+
+    public void setLength(int length) {
+        this.length = length;
+    }
+
+    @Override
+    public String type2string() {
+        switch (this.type) {
+            case FILE_END:
+                return "***********";
+            case SEPARATOR_TOKEN:
+                return "METHOD_SEPARATOR";
+            case BEGIN_FUNCTION:
+                return "FUNCTION{  ";
+            case END_FUNCTION:
+                return "}FUNCTION  ";
+            case FUNCTION_CALL:
+                return "FUNCTION() ";
+            case NUMBER:
+                return "NUMBER     ";
+            case STRING:
+                return "STRING     ";
+            case BOOL:
+                return "BOOL       ";
+            case ASSIGN:
+                return "ASSIGN     ";
+            case ASSIGN_FUNC:
+                return "ASSIGN_FUNC";
+            case ASSIGN_LIST:
+                return "ASSIGN_LIST";
+            case HELP:
+                return "HELP       ";
+            case INDEX:
+                return "INDEX      ";
+            case PACKAGE:
+                return "PACKAGE    ";
+            case IF_BEGIN:
+                return "IF{        ";
+            case IF_END:
+                return "}IF        ";
+            case FOR_BEGIN:
+                return "FOR{       ";
+            case FOR_END:
+                return "}FOR       ";
+            case WHILE_BEGIN:
+                return "WHILE{     ";
+            case WHILE_END:
+                return "}WHILE     ";
+            case REPEAT_BEGIN:
+                return "REPEAT{    ";
+            case REPEAT_END:
+                return "}REPEAT    ";
+            case NEXT:
+                return "NEXT       ";
+            case BREAK:
+                return "BREAK      ";
+            case COMPOUND_BEGIN:
+                return "COMPOUND{   ";
+            case COMPOUND_END:
+                return "}COMPOUND   ";
+            default:
+                System.err.println("*UNKNOWN: " + type);
+                return "*UNKNOWN" + type;
+        }
+    }
+
+}

+ 38 - 0
jplag.frontend.R/src/main/java/de/jplag/R/RTokenConstants.java

@@ -0,0 +1,38 @@
+package de.jplag.R;
+
+import de.jplag.TokenConstants;
+
+/**
+ * Tokens in R that are deemed important when comparing submissions for plagiarisms
+ */
+public interface RTokenConstants extends TokenConstants {
+    int FILE_END = 0;
+    int SEPARATOR_TOKEN = 1;
+
+    int BEGIN_FUNCTION = 2;
+    int END_FUNCTION = 3;
+    int FUNCTION_CALL = 4;
+    int NUMBER = 5;
+    int STRING = 6;
+    int BOOL = 7;
+    int ASSIGN = 8;
+    int ASSIGN_FUNC = 9;
+    int ASSIGN_LIST = 10;
+    int HELP = 11;
+    int INDEX = 12;
+    int PACKAGE = 13;
+    int IF_BEGIN = 14;
+    int IF_END = 15;
+    int FOR_BEGIN = 16;
+    int FOR_END = 17;
+    int WHILE_BEGIN = 18;
+    int WHILE_END = 19;
+    int REPEAT_BEGIN = 20;
+    int REPEAT_END = 21;
+    int NEXT = 22;
+    int BREAK = 23;
+    int COMPOUND_BEGIN = 24;
+    int COMPOUND_END = 25;
+
+    int NUM_DIFF_TOKENS = 26;
+}

+ 4 - 0
jplag/pom.xml

@@ -45,6 +45,10 @@
             <groupId>de.jplag</groupId>
             <artifactId>cpp</artifactId>
         </dependency>
+        <dependency>
+            <groupId>de.jplag</groupId>
+            <artifactId>R</artifactId>
+        </dependency>
         <dependency>
             <groupId>de.jplag</groupId>
             <artifactId>scheme</artifactId>

+ 1 - 0
jplag/src/main/java/de/jplag/options/LanguageOption.java

@@ -13,6 +13,7 @@ public enum LanguageOption {
     PYTHON_3("python3", "de.jplag.python3.Language"),
     C_CPP("cpp", "de.jplag.cpp.Language"),
     C_SHARP("csharp", "de.jplag.csharp.Language"),
+    R("R", "de.jplag.R.Language"),
     CHAR("char", "de.jplag.chars.Language"),
     TEXT("text", "de.jplag.text.Language"),
     SCHEME("scheme", "de.jplag.scheme.Language");

+ 11 - 0
pom.xml

@@ -49,6 +49,7 @@
         <module>jplag.frontend.csharp-6</module>
         <module>jplag.frontend.java</module>
         <module>jplag.frontend.python-3</module>
+        <module>jplag.frontend.R</module>
         <module>jplag.frontend.scheme</module>
         <module>jplag.frontend.text</module>
         <module>jplag</module>
@@ -156,6 +157,16 @@
                 <artifactId>csharp-6</artifactId>
                 <version>${project.version}</version>
             </dependency>
+            <dependency>
+                <groupId>${project.groupId}</groupId>
+                <artifactId>R</artifactId>
+                <version>${project.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>${project.groupId}</groupId>
+                <artifactId>scala</artifactId>
+                <version>${project.version}</version>
+            </dependency>
             <dependency>
                 <groupId>${project.groupId}</groupId>
                 <artifactId>cpp</artifactId>