This GitLab instance reached the end of its service life. It won't be possible to create new users or projects.

Please read the deprecation notice for more information concerning the deprecation timeline

Visit migration.git.tu-berlin.de (internal network only) to import your old projects to the new GitLab platform 📥

Commit 4082d9ff by Stefan Sydow

old stuff + lib update

parent b58cfe56
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
<orderEntry type="module" module-name="IntellijEve" />
<orderEntry type="library" name="KotlinJavaRuntime" level="project" />
</component>
</module>
\ No newline at end of file
......@@ -56,11 +56,11 @@ allprojects {
//updateSinceUntilBuild = false
//instrumentCode = true
version = "2018.3"
version = "2020.1"
pluginName = "IntellijEve"
setPlugins(
"org.toml.lang:0.2.0.19",
"org.rust.lang:0.2.0.2111-183"
"org.toml.lang:0.2.120",
"org.rust.lang:0.2.120"
)
}
......
extern crate futures;
extern crate tokio_core;
mod nodes;
mod structs;
use tokio_core::reactor::Core;
use futures::Async;
use futures::Future;
use futures::future::ok;
use futures::Poll;
use futures::Stream;
use futures::Async;
use nodes::sink;
use nodes::source;
use std::clone::Clone;
use std::sync::Arc;
use std::sync::Mutex;
use std::clone::Clone;
use std::sync::MutexGuard;
use structs::*;
use nodes::source;
use nodes::sink;
use tokio_core::reactor::Core;
mod nodes;
mod structs;
#[derive(Debug)]
pub enum EveError {
UnknownError
......@@ -27,7 +26,7 @@ pub enum EveError {
pub struct StreamCopy<T, S: Stream<Item=T, Error=EveError>> {
input: S,
buffers: Vec<Vec<T>>,
idx: usize
idx: usize,
}
struct StreamCopyMutex<T, S: Stream<Item=T, Error=EveError>> {
......@@ -36,7 +35,7 @@ struct StreamCopyMutex<T, S: Stream<Item=T, Error=EveError>> {
struct StreamCopyOutPort<T, S: Stream<Item=T, Error=EveError>> {
id: usize,
source: StreamCopyMutex<T, S>
source: StreamCopyMutex<T, S>,
}
impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopy<T, S> {
......@@ -58,10 +57,10 @@ impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopy<T, S> {
buffer.push(event.clone())
}
self.poll(id)
},
}
None => Ok(Async::Ready(None))
}
},
}
Async::NotReady => Ok(Async::NotReady)
}
}
......@@ -71,7 +70,7 @@ impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopy<T, S> {
}
}
fn buffered_poll(&mut self, id: usize) -> Option<T>{
fn buffered_poll(&mut self, id: usize) -> Option<T> {
let mut buffer = &mut self.buffers[id];
if buffer.len() > 0 {
Some(buffer.remove(0))
......@@ -107,7 +106,7 @@ impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopyMutex<T, S> {
let mut inner = self.lock();
let val = StreamCopyOutPort {
source: (*self).clone(),
id: inner.idx
id: inner.idx,
};
inner.buffers.push(vec!());
inner.idx += 1;
......
use futures::Stream;
use futures::Poll;
use futures::Async;
use ::structs::*;
use ::EveError;
use ::structs::*;
use futures::Async;
use futures::Poll;
use futures::Stream;
pub struct Source {
// struct members can be added here
......@@ -18,15 +17,16 @@ impl Source {
}
impl Stream for Source {
type Item = Coordinate; // use struct as defined in structs.rs
type Item = Coordinate;
// use struct as defined in structs.rs
type Error = EveError;
// this function will be called to request new event data from a source
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
Ok(Async::Ready(Some(Coordinate {
// initialization of struct members
x: 0,
y: 0
x: 0,
y: 0,
})))
}
}
#[derive(Debug, Clone)] // this is very useful for debugging
pub struct Coordinate {
pub x: i32,
pub y: i32
pub y: i32,
}
#Mon Nov 26 15:08:58 CET 2018
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-5.0-all.zip
#!/usr/bin/env sh
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS=""
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=$((i+1))
done
case $i in
(0) set -- ;;
(1) set -- "$args0" ;;
(2) set -- "$args0" "$args1" ;;
(3) set -- "$args0" "$args1" "$args2" ;;
(4) set -- "$args0" "$args1" "$args2" "$args3" ;;
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=$(save "$@")
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
cd "$(dirname "$0")"
fi
exec "$JAVACMD" "$@"
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windows variants
if not "%OS%" == "Windows_NT" goto win9xME_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
<idea-plugin>
<id>org.tub.eveamcp</id>
<name>IntellijEve</name>
<version>0.1.2</version>
<vendor email="stefan.sydow@tu-berlin.de" url="http://www.kbs.tu-berlin.de">KBS TU-Berlin</vendor>
<id>org.tub.eveamcp</id>
<name>IntellijEve</name>
<version>0.1.3</version>
<vendor email="stefan.sydow@tu-berlin.de" url="http://www.kbs.tu-berlin.de">KBS TU-Berlin</vendor>
<description><![CDATA[
<description><![CDATA[
A Graphical Editor for Safe Parallel Programs
]]></description>
<change-notes><![CDATA[
<change-notes><![CDATA[
0.1 - basic prototype with GraphML import/export
]]>
</change-notes>
</change-notes>
<!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
<idea-version since-build="183"/>
<!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/build_number_ranges.html for description -->
<idea-version since-build="201"/>
<!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/plugin_compatibility.html
on how to target different products -->
<depends>com.intellij.modules.lang</depends>
<depends>org.rust.lang</depends>
<depends>org.toml.lang</depends>
<!-- please see http://www.jetbrains.org/intellij/sdk/docs/basics/getting_started/plugin_compatibility.html
on how to target different products -->
<depends>com.intellij.modules.lang</depends>
<depends>org.rust.lang</depends>
<depends>org.toml.lang</depends>
<extensions defaultExtensionNs="com.intellij">
<!-- Add your extensions here -->
<fileEditorProvider order="first" implementation="intellij.GraphFileEditorProvider"/>
<fileTypeFactory implementation="intellij.GraphFileTypeFactory" />
</extensions>
<extensions defaultExtensionNs="com.intellij">
<!-- Add your extensions here -->
<fileEditorProvider order="first" implementation="intellij.GraphFileEditorProvider"/>
<fileTypeFactory implementation="intellij.GraphFileTypeFactory"/>
</extensions>
<actions>
<!-- Add your actions here -->
</actions>
<actions>
<!-- Add your actions here -->
</actions>
</idea-plugin>
use futures::{Poll, Stream, Async};
use futures::{Async, Poll, Stream};
use crate::structs::EveError;
......@@ -7,22 +6,22 @@ pub trait Context {
type Event;
type Result;
fn work(&mut self, event:Self::Event) -> Self::Result;
fn work(&mut self, event: Self::Event) -> Self::Result;
/*fn new() -> Self;*/
}
pub struct GlobalContext<Ctx, InStream> {
context:Ctx,
input:InStream
context: Ctx,
input: InStream,
}
impl<E, R, Ctx, InStream> GlobalContext<Ctx, InStream>
where Ctx:Context<Event=E, Result=R>, InStream:Stream
where Ctx: Context<Event=E, Result=R>, InStream: Stream
{
pub fn new(input:InStream, initial_ctx: Ctx) -> Self {
pub fn new(input: InStream, initial_ctx: Ctx) -> Self {
GlobalContext {
context: initial_ctx,
input
input,
}
}
}
......@@ -36,7 +35,7 @@ pub fn stream_context<E, R, InStream, Ctx> (input:InStream, initial_ctx: Ctx) ->
}
*/
impl<E, R, Ctx:Context<Event=E, Result=R>, InStream: Stream<Item=E, Error=EveError>> Stream for GlobalContext<Ctx, InStream> {
impl<E, R, Ctx: Context<Event=E, Result=R>, InStream: Stream<Item=E, Error=EveError>> Stream for GlobalContext<Ctx, InStream> {
type Item = R;
type Error = EveError;
......@@ -46,7 +45,7 @@ impl<E, R, Ctx:Context<Event=E, Result=R>, InStream: Stream<Item=E, Error=EveErr
Async::Ready(Some(event)) => {
let result = self.context.work(event);
Async::Ready(Some(result))
},
}
Async::Ready(None) => Async::Ready(None),
Async::NotReady => Async::NotReady
};
......
use tokio_core::reactor::Core;
mod task_graph;
mod nodes;
mod structs;
......
use futures::{Poll, Stream, Async};
use futures::{Async, Poll, Stream};
use std::clone::Clone;
use std::sync::Arc;
use std::sync::Mutex;
use std::clone::Clone;
use std::sync::MutexGuard;
use crate::structs::EveError;
......@@ -11,14 +9,14 @@ use crate::structs::EveError;
pub struct StreamCopy<T, S: Stream<Item=T, Error=EveError>> {
input: S,
buffers: Vec<Vec<T>>,
idx: usize
idx: usize,
}
pub struct StreamCopyMutex<T, S: Stream<Item=T, Error=EveError>>(Arc<Mutex<StreamCopy<T, S>>>);
pub struct StreamCopyOutPort<T, S: Stream<Item=T, Error=EveError>> {
id: usize,
source: StreamCopyMutex<T, S>
source: StreamCopyMutex<T, S>,
}
impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopy<T, S> {
......@@ -40,10 +38,10 @@ impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopy<T, S> {
buffer.push(event.clone())
}
self.poll(id)
},
}
None => Ok(Async::Ready(None))
}
},
}
Async::NotReady => Ok(Async::NotReady)
}
}
......@@ -53,7 +51,7 @@ impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopy<T, S> {
}
}
fn buffered_poll(&mut self, id: usize) -> Option<T>{
fn buffered_poll(&mut self, id: usize) -> Option<T> {
let buffer = &mut self.buffers[id];
if buffer.len() > 0 {
Some(buffer.remove(0))
......@@ -80,11 +78,12 @@ impl<T, S: Stream<Item=T, Error=EveError>> Clone for StreamCopyMutex<T, S> {
}
impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopyMutex<T, S> {
pub fn new(input:S) -> StreamCopyMutex<T, S> {
pub fn new(input: S) -> StreamCopyMutex<T, S> {
StreamCopyMutex(
Arc::new(Mutex::new(StreamCopy {
input, buffers: vec!(), idx: 0
input,
buffers: vec!(),
idx: 0,
})))
}
......@@ -96,7 +95,7 @@ impl<T: Clone, S: Stream<Item=T, Error=EveError>> StreamCopyMutex<T, S> {
let mut inner = self.lock();
let val = StreamCopyOutPort {
source: (*self).clone(),
id: inner.idx
id: inner.idx,
};
inner.buffers.push(vec!());
inner.idx += 1;
......
......@@ -52,7 +52,7 @@ class RustCodeGen {
val nextNodes = sources.toMutableSet()
val buildGraph = Function("build_graph", listOf(),"impl Future<Item=(), Error=EveError>")
val buildGraph = Function("build_graph", listOf(), Type.ImplTrait(AsyncTrait.Future(Type.unit))) //TODO Error Type
while (nextNodes.any()) {
val node = nextNodes.first()
node.codeGen.generate(buildGraph)
......
......@@ -7,6 +7,13 @@ import java.util.regex.Pattern
const val TAB = " "
val RustBasicTypes = arrayOf(
"bool",
"u8", "u16", "u32", "u64", "u128",
"i8", "i16", "i32", "i64", "i128",
"char", "str"
)
/*
* Function that checks whether the given string matches against the regular
* expression that is provided by the Rust developers as given here:
......@@ -168,14 +175,13 @@ class CodeBlock : ScopeImpl() , Statement {
fun asExpression() = Expression(toString())
}
class Parameter(val name:String, val type:String) {
override fun toString(): String {
return "$name:$type"
}
}
class Function(val name: String, val arguments: List<Parameter>, val resultType:String) : ScopeImpl(), Statement {
class Function(val name: String, val arguments: List<Parameter>, val resultType:Type) : ScopeImpl(), Statement {
class Parameter(val name:String, val type:Type) {
override fun toString(): String {
return "$name:$type"
}
}
init {
arguments.forEach { arg ->
require(knownIdentifiers.add(arg.name)){"argument \"${arg.name}\" allready defined"}
......@@ -188,7 +194,7 @@ class Function(val name: String, val arguments: List<Parameter>, val resultType:
}
override fun asStringBuilder() : StringBuilder {
check( (resultType != "()") == hasResult)
check( (resultType != Type.unit) == hasResult)
val builder = java.lang.StringBuilder()
builder.appendln("pub fn $signature")
builder.appendln("{")
......@@ -198,7 +204,7 @@ class Function(val name: String, val arguments: List<Parameter>, val resultType:
}
}
fun mainFunction() = Function("main", listOf<Parameter>(), "()")
fun mainFunction() = Function("main", listOf<Function.Parameter>(), Type.unit)
class Project(val root: Path) {
val sourceDir = root.resolve("src")
......
package codegen
class FnTrait(val arguments: List<Pair<String,Type>>, val result:Type) {
override fun toString(): String {
val argumentString = arguments.joinToString(", "){(name, type) -> type.toString()}
return "Fn($argumentString) -> $result"
}
}
sealed class AsyncTrait() {
abstract override fun toString(): String
class Future(val result: Type):AsyncTrait() {
override fun toString(): String = "Future<Item=$result>"
}
class Stream(val item: Type):AsyncTrait() {
override fun toString(): String = "Stream<Item=$item>"
}
class Sink(val item: Type):AsyncTrait() {
override fun toString(): String = "Sink<Item=$item>"
}
}
sealed class Type {
companion object {
val unit = Unit()
}
abstract override fun toString() : String
class Unit:Type() {
override fun toString(): String = "()"
}
class BasicType(val type:String):Type() {
init {
require(type in RustBasicTypes) {"$type in not a basic rust type"}
}
override fun toString(): String = type